configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS TOPLEVEL_CONFIGURE_ARGUMENTS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc ppllibs pplinc clooglibs clooginc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR GCC_SHLIB_SUBDIR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --disable-ppl-version-check    disable check for PPL version
 939   --disable-cloog-version-check  disable check for CLooG version
 940   --enable-stage1-languages[=all]   choose additional languages to build during
 941                           stage1.  Mostly useful for compiler development.
 942   --enable-objc-gc        enable use of Boehm's garbage collector with the
 943                           GNU Objective-C runtime
 944   --enable-bootstrap      enable bootstrapping [yes if native build]
 945   --enable-serial-[{host,target,build}-]configure
 946                           force sequential configuration of
 947                           sub-packages for the host, target or build
 948                           machine, or all sub-packages
 949   --enable-maintainer-mode enable make rules and dependencies not useful
 950                           (and sometimes confusing) to the casual installer
 951   --enable-stage1-checking[=all]   choose additional checking for stage1
 952                           of the compiler
 953   --enable-werror         enable -Werror in bootstrap stage2 and later
 954
 955 Optional Packages:
 956   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 957   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 958   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 959   --with-mpfr-dir=PATH    this option has been REMOVED
 960   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 961                           Equivalent to --with-mpfr-include=PATH/include
 962                           plus --with-mpfr-lib=PATH/lib
 963   --with-mpfr-include=PATH
 964                           specify directory for installed MPFR include files
 965   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 966   --with-gmp-dir=PATH     this option has been REMOVED
 967   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 968                           Equivalent to --with-gmp-include=PATH/include
 969                           plus --with-gmp-lib=PATH/lib
 970   --with-gmp-include=PATH specify directory for installed GMP include files
 971   --with-gmp-lib=PATH     specify directory for the installed GMP library
 972   --with-ppl=PATH         Specify prefix directory for the installed PPL package
 973                           Equivalent to --with-ppl-include=PATH/include
 974                           plus --with-ppl-lib=PATH/lib
 975   --with-ppl-include=PATH Specify directory for installed PPL include files
 976   --with-ppl-lib=PATH     Specify the directory for the installed PPL library
 977   --with-cloog=PATH       Specify prefix directory for the installed CLooG-PPL package
 978                           Equivalent to --with-cloog-include=PATH/include
 979                           plus --with-cloog-lib=PATH/lib
 980   --with-cloog-include=PATH Specify directory for installed CLooG include files
 981   --with-cloog-lib=PATH   Specify the directory for the installed CLooG library
 982   --with-cloog-polylib=PATH Specify prefix directory for the installed CLooG-PolyLib package
 983   --with-build-sysroot=SYSROOT
 984                           use sysroot as the system root during the build
 985   --with-debug-prefix-map='A=B C=D ...'
 986                              map A to B, C to D ... in debug information
 987   --with-build-time-tools=PATH
 988                           use given path to find target tools during the build
 989   --with-datarootdir      use datarootdir as the data root directory.
 990   --with-docdir           install documentation in this directory.
 991   --with-pdfdir           install pdf in this directory.
 992   --with-htmldir          install html in this directory.
 993
 994 Some influential environment variables:
 995   CC          C compiler command
 996   CFLAGS      C compiler flags
 997   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 998               nonstandard directory <lib dir>
 999   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
1000               headers in a nonstandard directory <include dir>
1001   CXX         C++ compiler command
1002   CXXFLAGS    C++ compiler flags
1003   AR          AR for the host
1004   AS          AS for the host
1005   DLLTOOL     DLLTOOL for the host
1006   LD          LD for the host
1007   LIPO        LIPO for the host
1008   NM          NM for the host
1009   RANLIB      RANLIB for the host
1010   STRIP       STRIP for the host
1011   WINDRES     WINDRES for the host
1012   WINDMC      WINDMC for the host
1013   OBJCOPY     OBJCOPY for the host
1014   OBJDUMP     OBJDUMP for the host
1015   CC_FOR_TARGET
1016               CC for the target
1017   CXX_FOR_TARGET
1018               CXX for the target
1019   GCC_FOR_TARGET
1020               GCC for the target
1021   GCJ_FOR_TARGET
1022               GCJ for the target
1023   GFORTRAN_FOR_TARGET
1024               GFORTRAN for the target
1025   AR_FOR_TARGET
1026               AR for the target
1027   AS_FOR_TARGET
1028               AS for the target
1029   DLLTOOL_FOR_TARGET
1030               DLLTOOL for the target
1031   LD_FOR_TARGET
1032               LD for the target
1033   LIPO_FOR_TARGET
1034               LIPO for the target
1035   NM_FOR_TARGET
1036               NM for the target
1037   OBJDUMP_FOR_TARGET
1038               OBJDUMP for the target
1039   RANLIB_FOR_TARGET
1040               RANLIB for the target
1041   STRIP_FOR_TARGET
1042               STRIP for the target
1043   WINDRES_FOR_TARGET
1044               WINDRES for the target
1045   WINDMC_FOR_TARGET
1046               WINDMC for the target
1047
1048 Use these variables to override the choices made by `configure' or to help
1049 it to find libraries and programs with nonstandard names/locations.
1050
1051 _ACEOF
1052 fi
1053
1054 if test "$ac_init_help" = "recursive"; then
1055   # If there are subdirs, report their specific --help.
1056   ac_popdir=`pwd`
1057   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1058     test -d $ac_dir || continue
1059     ac_builddir=.
1060
1061 if test "$ac_dir" != .; then
1062   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1063   # A "../" for each directory in $ac_dir_suffix.
1064   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1065 else
1066   ac_dir_suffix= ac_top_builddir=
1067 fi
1068
1069 case $srcdir in
1070   .)  # No --srcdir option.  We are building in place.
1071     ac_srcdir=.
1072     if test -z "$ac_top_builddir"; then
1073        ac_top_srcdir=.
1074     else
1075        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1076     fi ;;
1077   [\\/]* | ?:[\\/]* )  # Absolute path.
1078     ac_srcdir=$srcdir$ac_dir_suffix;
1079     ac_top_srcdir=$srcdir ;;
1080   *) # Relative path.
1081     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1082     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1083 esac
1084
1085 # Do not use `cd foo && pwd` to compute absolute paths, because
1086 # the directories may not exist.
1087 case `pwd` in
1088 .) ac_abs_builddir="$ac_dir";;
1089 *)
1090   case "$ac_dir" in
1091   .) ac_abs_builddir=`pwd`;;
1092   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1093   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1094   esac;;
1095 esac
1096 case $ac_abs_builddir in
1097 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1098 *)
1099   case ${ac_top_builddir}. in
1100   .) ac_abs_top_builddir=$ac_abs_builddir;;
1101   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1102   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1103   esac;;
1104 esac
1105 case $ac_abs_builddir in
1106 .) ac_abs_srcdir=$ac_srcdir;;
1107 *)
1108   case $ac_srcdir in
1109   .) ac_abs_srcdir=$ac_abs_builddir;;
1110   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1111   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1112   esac;;
1113 esac
1114 case $ac_abs_builddir in
1115 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1116 *)
1117   case $ac_top_srcdir in
1118   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1119   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1120   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1121   esac;;
1122 esac
1123
1124     cd $ac_dir
1125     # Check for guested configure; otherwise get Cygnus style configure.
1126     if test -f $ac_srcdir/configure.gnu; then
1127       echo
1128       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1129     elif test -f $ac_srcdir/configure; then
1130       echo
1131       $SHELL $ac_srcdir/configure  --help=recursive
1132     elif test -f $ac_srcdir/configure.ac ||
1133            test -f $ac_srcdir/configure.in; then
1134       echo
1135       $ac_configure --help
1136     else
1137       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1138     fi
1139     cd $ac_popdir
1140   done
1141 fi
1142
1143 test -n "$ac_init_help" && exit 0
1144 if $ac_init_version; then
1145   cat <<\_ACEOF
1146
1147 Copyright (C) 2003 Free Software Foundation, Inc.
1148 This configure script is free software; the Free Software Foundation
1149 gives unlimited permission to copy, distribute and modify it.
1150 _ACEOF
1151   exit 0
1152 fi
1153 exec 5>config.log
1154 cat >&5 <<_ACEOF
1155 This file contains any messages produced by compilers while
1156 running configure, to aid debugging if configure makes a mistake.
1157
1158 It was created by $as_me, which was
1159 generated by GNU Autoconf 2.59.  Invocation command line was
1160
1161   $ $0 $@
1162
1163 _ACEOF
1164 {
1165 cat <<_ASUNAME
1166 ## --------- ##
1167 ## Platform. ##
1168 ## --------- ##
1169
1170 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1171 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1172 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1173 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1174 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1175
1176 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1177 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1178
1179 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1180 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1181 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1182 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1183 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1184 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1185 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1186
1187 _ASUNAME
1188
1189 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1190 for as_dir in $PATH
1191 do
1192   IFS=$as_save_IFS
1193   test -z "$as_dir" && as_dir=.
1194   echo "PATH: $as_dir"
1195 done
1196
1197 } >&5
1198
1199 cat >&5 <<_ACEOF
1200
1201
1202 ## ----------- ##
1203 ## Core tests. ##
1204 ## ----------- ##
1205
1206 _ACEOF
1207
1208
1209 # Keep a trace of the command line.
1210 # Strip out --no-create and --no-recursion so they do not pile up.
1211 # Strip out --silent because we don't want to record it for future runs.
1212 # Also quote any args containing shell meta-characters.
1213 # Make two passes to allow for proper duplicate-argument suppression.
1214 ac_configure_args=
1215 ac_configure_args0=
1216 ac_configure_args1=
1217 ac_sep=
1218 ac_must_keep_next=false
1219 for ac_pass in 1 2
1220 do
1221   for ac_arg
1222   do
1223     case $ac_arg in
1224     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1225     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1226     | -silent | --silent | --silen | --sile | --sil)
1227       continue ;;
1228     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1229       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1230     esac
1231     case $ac_pass in
1232     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1233     2)
1234       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1235       if test $ac_must_keep_next = true; then
1236         ac_must_keep_next=false # Got value, back to normal.
1237       else
1238         case $ac_arg in
1239           *=* | --config-cache | -C | -disable-* | --disable-* \
1240           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1241           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1242           | -with-* | --with-* | -without-* | --without-* | --x)
1243             case "$ac_configure_args0 " in
1244               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1245             esac
1246             ;;
1247           -* ) ac_must_keep_next=true ;;
1248         esac
1249       fi
1250       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1251       # Get rid of the leading space.
1252       ac_sep=" "
1253       ;;
1254     esac
1255   done
1256 done
1257 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1258 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1259
1260 # When interrupted or exit'd, cleanup temporary files, and complete
1261 # config.log.  We remove comments because anyway the quotes in there
1262 # would cause problems or look ugly.
1263 # WARNING: Be sure not to use single quotes in there, as some shells,
1264 # such as our DU 5.0 friend, will then `close' the trap.
1265 trap 'exit_status=$?
1266   # Save into config.log some information that might help in debugging.
1267   {
1268     echo
1269
1270     cat <<\_ASBOX
1271 ## ---------------- ##
1272 ## Cache variables. ##
1273 ## ---------------- ##
1274 _ASBOX
1275     echo
1276     # The following way of writing the cache mishandles newlines in values,
1277 {
1278   (set) 2>&1 |
1279     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1280     *ac_space=\ *)
1281       sed -n \
1282         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1283           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1284       ;;
1285     *)
1286       sed -n \
1287         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1288       ;;
1289     esac;
1290 }
1291     echo
1292
1293     cat <<\_ASBOX
1294 ## ----------------- ##
1295 ## Output variables. ##
1296 ## ----------------- ##
1297 _ASBOX
1298     echo
1299     for ac_var in $ac_subst_vars
1300     do
1301       eval ac_val=$`echo $ac_var`
1302       echo "$ac_var='"'"'$ac_val'"'"'"
1303     done | sort
1304     echo
1305
1306     if test -n "$ac_subst_files"; then
1307       cat <<\_ASBOX
1308 ## ------------- ##
1309 ## Output files. ##
1310 ## ------------- ##
1311 _ASBOX
1312       echo
1313       for ac_var in $ac_subst_files
1314       do
1315         eval ac_val=$`echo $ac_var`
1316         echo "$ac_var='"'"'$ac_val'"'"'"
1317       done | sort
1318       echo
1319     fi
1320
1321     if test -s confdefs.h; then
1322       cat <<\_ASBOX
1323 ## ----------- ##
1324 ## confdefs.h. ##
1325 ## ----------- ##
1326 _ASBOX
1327       echo
1328       sed "/^$/d" confdefs.h | sort
1329       echo
1330     fi
1331     test "$ac_signal" != 0 &&
1332       echo "$as_me: caught signal $ac_signal"
1333     echo "$as_me: exit $exit_status"
1334   } >&5
1335   rm -f core *.core &&
1336   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1337     exit $exit_status
1338      ' 0
1339 for ac_signal in 1 2 13 15; do
1340   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1341 done
1342 ac_signal=0
1343
1344 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1345 rm -rf conftest* confdefs.h
1346 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1347 echo >confdefs.h
1348
1349 # Predefined preprocessor variables.
1350
1351 cat >>confdefs.h <<_ACEOF
1352 #define PACKAGE_NAME "$PACKAGE_NAME"
1353 _ACEOF
1354
1355
1356 cat >>confdefs.h <<_ACEOF
1357 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1358 _ACEOF
1359
1360
1361 cat >>confdefs.h <<_ACEOF
1362 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1363 _ACEOF
1364
1365
1366 cat >>confdefs.h <<_ACEOF
1367 #define PACKAGE_STRING "$PACKAGE_STRING"
1368 _ACEOF
1369
1370
1371 cat >>confdefs.h <<_ACEOF
1372 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1373 _ACEOF
1374
1375
1376 # Let the site file select an alternate cache file if it wants to.
1377 # Prefer explicitly selected file to automatically selected ones.
1378 if test -z "$CONFIG_SITE"; then
1379   if test "x$prefix" != xNONE; then
1380     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1381   else
1382     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1383   fi
1384 fi
1385 for ac_site_file in $CONFIG_SITE; do
1386   if test -r "$ac_site_file"; then
1387     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1388 echo "$as_me: loading site script $ac_site_file" >&6;}
1389     sed 's/^/| /' "$ac_site_file" >&5
1390     . "$ac_site_file"
1391   fi
1392 done
1393
1394 if test -r "$cache_file"; then
1395   # Some versions of bash will fail to source /dev/null (special
1396   # files actually), so we avoid doing that.
1397   if test -f "$cache_file"; then
1398     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1399 echo "$as_me: loading cache $cache_file" >&6;}
1400     case $cache_file in
1401       [\\/]* | ?:[\\/]* ) . $cache_file;;
1402       *)                      . ./$cache_file;;
1403     esac
1404   fi
1405 else
1406   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1407 echo "$as_me: creating cache $cache_file" >&6;}
1408   >$cache_file
1409 fi
1410
1411 # Check that the precious variables saved in the cache have kept the same
1412 # value.
1413 ac_cache_corrupted=false
1414 for ac_var in `(set) 2>&1 |
1415                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1416   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1417   eval ac_new_set=\$ac_env_${ac_var}_set
1418   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1419   eval ac_new_val="\$ac_env_${ac_var}_value"
1420   case $ac_old_set,$ac_new_set in
1421     set,)
1422       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1423 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1424       ac_cache_corrupted=: ;;
1425     ,set)
1426       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1427 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1428       ac_cache_corrupted=: ;;
1429     ,);;
1430     *)
1431       if test "x$ac_old_val" != "x$ac_new_val"; then
1432         # differences in whitespace do not lead to failure.
1433         ac_old_val_w=`echo x $ac_old_val`
1434         ac_new_val_w=`echo x $ac_new_val`
1435         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1436           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1437 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1438           ac_cache_corrupted=:
1439         else
1440           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1441 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1442           eval $ac_var=\$ac_old_val
1443         fi
1444         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1445 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1446         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1447 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1448       fi;;
1449   esac
1450   # Pass precious variables to config.status.
1451   if test "$ac_new_set" = set; then
1452     case $ac_new_val in
1453     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1454       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1455     *) ac_arg=$ac_var=$ac_new_val ;;
1456     esac
1457     case " $ac_configure_args " in
1458       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1459       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1460     esac
1461   fi
1462 done
1463 if $ac_cache_corrupted; then
1464   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1465 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1466   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1467 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1468   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1469 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1470    { (exit 1); exit 1; }; }
1471 fi
1472
1473 ac_ext=c
1474 ac_cpp='$CPP $CPPFLAGS'
1475 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1476 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1477 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502 progname=$0
1503 # if PWD already has a value, it is probably wrong.
1504 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1505
1506 # Export original configure arguments for use by sub-configures.
1507 # Quote arguments with shell meta charatcers.
1508 TOPLEVEL_CONFIGURE_ARGUMENTS=
1509 set -- "$progname" "$@"
1510 for ac_arg
1511 do
1512   case "$ac_arg" in
1513   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1514     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1515     # if the argument is of the form -foo=baz, quote the baz part only
1516     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1517   *) ;;
1518   esac
1519   # Add the quoted argument to the list.
1520   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1521 done
1522 if test "$silent" = yes; then
1523   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1524 fi
1525 # Remove the initial space we just introduced and, as these will be
1526 # expanded by make, quote '$'.
1527 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1528
1529
1530 # Find the build, host, and target systems.
1531 ac_aux_dir=
1532 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1533   if test -f $ac_dir/install-sh; then
1534     ac_aux_dir=$ac_dir
1535     ac_install_sh="$ac_aux_dir/install-sh -c"
1536     break
1537   elif test -f $ac_dir/install.sh; then
1538     ac_aux_dir=$ac_dir
1539     ac_install_sh="$ac_aux_dir/install.sh -c"
1540     break
1541   elif test -f $ac_dir/shtool; then
1542     ac_aux_dir=$ac_dir
1543     ac_install_sh="$ac_aux_dir/shtool install -c"
1544     break
1545   fi
1546 done
1547 if test -z "$ac_aux_dir"; then
1548   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1549 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1550    { (exit 1); exit 1; }; }
1551 fi
1552 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1553 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1554 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1555
1556 # Make sure we can run config.sub.
1557 $ac_config_sub sun4 >/dev/null 2>&1 ||
1558   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1559 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1560    { (exit 1); exit 1; }; }
1561
1562 echo "$as_me:$LINENO: checking build system type" >&5
1563 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1564 if test "${ac_cv_build+set}" = set; then
1565   echo $ECHO_N "(cached) $ECHO_C" >&6
1566 else
1567   ac_cv_build_alias=$build_alias
1568 test -z "$ac_cv_build_alias" &&
1569   ac_cv_build_alias=`$ac_config_guess`
1570 test -z "$ac_cv_build_alias" &&
1571   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1572 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1573    { (exit 1); exit 1; }; }
1574 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1575   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1576 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1577    { (exit 1); exit 1; }; }
1578
1579 fi
1580 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1581 echo "${ECHO_T}$ac_cv_build" >&6
1582 build=$ac_cv_build
1583 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1584 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1585 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1586
1587
1588  case ${build_alias} in
1589   "") build_noncanonical=${build} ;;
1590   *) build_noncanonical=${build_alias} ;;
1591 esac
1592
1593
1594
1595  case ${host_alias} in
1596   "") host_noncanonical=${build_noncanonical} ;;
1597   *) host_noncanonical=${host_alias} ;;
1598 esac
1599
1600
1601
1602  case ${target_alias} in
1603   "") target_noncanonical=${host_noncanonical} ;;
1604   *) target_noncanonical=${target_alias} ;;
1605 esac
1606
1607
1608
1609
1610 test "$host_noncanonical" = "$target_noncanonical" &&
1611   test "$program_prefix$program_suffix$program_transform_name" = \
1612     NONENONEs,x,x, &&
1613   program_transform_name=s,y,y,
1614
1615 echo "$as_me:$LINENO: checking host system type" >&5
1616 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1617 if test "${ac_cv_host+set}" = set; then
1618   echo $ECHO_N "(cached) $ECHO_C" >&6
1619 else
1620   ac_cv_host_alias=$host_alias
1621 test -z "$ac_cv_host_alias" &&
1622   ac_cv_host_alias=$ac_cv_build_alias
1623 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1624   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1625 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1626    { (exit 1); exit 1; }; }
1627
1628 fi
1629 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1630 echo "${ECHO_T}$ac_cv_host" >&6
1631 host=$ac_cv_host
1632 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1633 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1634 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1635
1636
1637 echo "$as_me:$LINENO: checking target system type" >&5
1638 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1639 if test "${ac_cv_target+set}" = set; then
1640   echo $ECHO_N "(cached) $ECHO_C" >&6
1641 else
1642   ac_cv_target_alias=$target_alias
1643 test "x$ac_cv_target_alias" = "x" &&
1644   ac_cv_target_alias=$ac_cv_host_alias
1645 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1646   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1647 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1648    { (exit 1); exit 1; }; }
1649
1650 fi
1651 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1652 echo "${ECHO_T}$ac_cv_target" >&6
1653 target=$ac_cv_target
1654 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1655 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1656 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1657
1658
1659 # The aliases save the names the user supplied, while $host etc.
1660 # will get canonicalized.
1661 test -n "$target_alias" &&
1662   test "$program_prefix$program_suffix$program_transform_name" = \
1663     NONENONEs,x,x, &&
1664   program_prefix=${target_alias}-
1665 test "$program_prefix" != NONE &&
1666   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1667 # Use a double $ so make ignores it.
1668 test "$program_suffix" != NONE &&
1669   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1670 # Double any \ or $.  echo might interpret backslashes.
1671 # By default was `s,x,x', remove it if useless.
1672 cat <<\_ACEOF >conftest.sed
1673 s/[\\$]/&&/g;s/;s,x,x,$//
1674 _ACEOF
1675 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1676 rm conftest.sed
1677
1678
1679
1680 # Get 'install' or 'install-sh' and its variants.
1681 # Find a good install program.  We prefer a C program (faster),
1682 # so one script is as good as another.  But avoid the broken or
1683 # incompatible versions:
1684 # SysV /etc/install, /usr/sbin/install
1685 # SunOS /usr/etc/install
1686 # IRIX /sbin/install
1687 # AIX /bin/install
1688 # AmigaOS /C/install, which installs bootblocks on floppy discs
1689 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1690 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1691 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1692 # OS/2's system install, which has a completely different semantic
1693 # ./install, which can be erroneously created by make from ./install.sh.
1694 # Reject install programs that cannot install multiple files.
1695 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1696 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1697 if test -z "$INSTALL"; then
1698 if test "${ac_cv_path_install+set}" = set; then
1699   echo $ECHO_N "(cached) $ECHO_C" >&6
1700 else
1701   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1702 for as_dir in $PATH
1703 do
1704   IFS=$as_save_IFS
1705   test -z "$as_dir" && as_dir=.
1706   # Account for people who put trailing slashes in PATH elements.
1707 case $as_dir/ in
1708   ./ | .// | /cC/* | \
1709   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1710   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1711   /usr/ucb/* ) ;;
1712   *)
1713     # OSF1 and SCO ODT 3.0 have their own names for install.
1714     # Don't use installbsd from OSF since it installs stuff as root
1715     # by default.
1716     for ac_prog in ginstall scoinst install; do
1717       for ac_exec_ext in '' $ac_executable_extensions; do
1718         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1719           if test $ac_prog = install &&
1720             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1721             # AIX install.  It has an incompatible calling convention.
1722             :
1723           elif test $ac_prog = install &&
1724             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1725             # program-specific install script used by HP pwplus--don't use.
1726             :
1727           else
1728             rm -rf conftest.one conftest.two conftest.dir
1729             echo one > conftest.one
1730             echo two > conftest.two
1731             mkdir conftest.dir
1732             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1733               test -s conftest.one && test -s conftest.two &&
1734               test -s conftest.dir/conftest.one &&
1735               test -s conftest.dir/conftest.two
1736             then
1737               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1738               break 3
1739             fi
1740           fi
1741         fi
1742       done
1743     done
1744     ;;
1745 esac
1746 done
1747
1748 rm -rf conftest.one conftest.two conftest.dir
1749
1750 fi
1751   if test "${ac_cv_path_install+set}" = set; then
1752     INSTALL=$ac_cv_path_install
1753   else
1754     # As a last resort, use the slow shell script.  Don't cache a
1755     # value for INSTALL within a source directory, because that will
1756     # break other packages using the cache if that directory is
1757     # removed, or if the value is a relative name.
1758     INSTALL=$ac_install_sh
1759   fi
1760 fi
1761 echo "$as_me:$LINENO: result: $INSTALL" >&5
1762 echo "${ECHO_T}$INSTALL" >&6
1763
1764 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1765 # It thinks the first close brace ends the variable substitution.
1766 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1767
1768 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1769
1770 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1771
1772 echo "$as_me:$LINENO: checking whether ln works" >&5
1773 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1774 if test "${acx_cv_prog_LN+set}" = set; then
1775   echo $ECHO_N "(cached) $ECHO_C" >&6
1776 else
1777   rm -f conftestdata_t
1778 echo >conftestdata_f
1779 if ln conftestdata_f conftestdata_t 2>/dev/null
1780 then
1781   acx_cv_prog_LN=ln
1782 else
1783   acx_cv_prog_LN=no
1784 fi
1785 rm -f conftestdata_f conftestdata_t
1786
1787 fi
1788 if test $acx_cv_prog_LN = no; then
1789   LN="cp"
1790   echo "$as_me:$LINENO: result: no, using $LN" >&5
1791 echo "${ECHO_T}no, using $LN" >&6
1792 else
1793   LN="$acx_cv_prog_LN"
1794   echo "$as_me:$LINENO: result: yes" >&5
1795 echo "${ECHO_T}yes" >&6
1796 fi
1797
1798 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1799 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1800 LN_S=$as_ln_s
1801 if test "$LN_S" = "ln -s"; then
1802   echo "$as_me:$LINENO: result: yes" >&5
1803 echo "${ECHO_T}yes" >&6
1804 else
1805   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1806 echo "${ECHO_T}no, using $LN_S" >&6
1807 fi
1808
1809
1810 ### we might need to use some other shell than /bin/sh for running subshells
1811 ### If we are on Windows, search for the shell.  This will permit people
1812 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1813 ### without also having to set CONFIG_SHELL.  This code will work when
1814 ### using bash, which sets OSTYPE.
1815 case "${OSTYPE}" in
1816 *win32*)
1817   if test x${CONFIG_SHELL} = x ; then
1818     if test ! -f /bin/sh ; then
1819       if test x${SHELL} != x && test -f ${SHELL} ; then
1820         CONFIG_SHELL=${SHELL}
1821         export CONFIG_SHELL
1822       else
1823         for prog in sh sh.exe bash bash.exe; do
1824           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1825           for dir in $PATH; do
1826             test -z "$dir" && dir=.
1827             if test -f $dir/$prog; then
1828               CONFIG_SHELL=$dir/$prog
1829               export CONFIG_SHELL
1830               break
1831             fi
1832           done
1833           IFS="$save_ifs"
1834           test -n "${CONFIG_SHELL}" && break
1835         done
1836       fi
1837     fi
1838   fi
1839   ;;
1840 esac
1841
1842 config_shell=${CONFIG_SHELL-/bin/sh}
1843
1844 moveifchange=${srcdir}/move-if-change
1845
1846 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1847
1848 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1849 # a relative path.
1850 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1851   INSTALL="${srcpwd}/install-sh -c"
1852 fi
1853
1854 # Set srcdir to "." if that's what it is.
1855 # This is important for multilib support.
1856 pwd=`${PWDCMD-pwd}`
1857 if test "${pwd}" = "${srcpwd}" ; then
1858   srcdir=.
1859 fi
1860
1861 topsrcdir=$srcpwd
1862
1863 extra_host_args=
1864
1865 ### To add a new directory to the tree, first choose whether it is a target
1866 ### or a host dependent tool.  Then put it into the appropriate list
1867 ### (library or tools, host or target), doing a dependency sort.
1868
1869 # Subdirs will be configured in the order listed in build_configdirs,
1870 # configdirs, or target_configdirs; see the serialization section below.
1871
1872 # Dependency sorting is only needed when *configuration* must be done in
1873 # a particular order.  In all cases a dependency should be specified in
1874 # the Makefile, whether or not it's implicitly specified here.
1875
1876 # Double entries in build_configdirs, configdirs, or target_configdirs may
1877 # cause circular dependencies and break everything horribly.
1878
1879 # these library is used by various programs built for the build
1880 # environment
1881 #
1882 build_libs="build-libiberty"
1883
1884 # these tools are built for the build environment
1885 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1886
1887 # these libraries are used by various programs built for the host environment
1888 #
1889 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr ppl cloog"
1890
1891 # these tools are built for the host environment
1892 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1893 # know that we are building the simulator.
1894 # binutils, gas and ld appear in that order because it makes sense to run
1895 # "make check" in that particular order.
1896 # If --enable-gold is used, "gold" will replace "ld".
1897 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"
1898
1899 # libgcj represents the runtime libraries only used by gcj.
1900 libgcj="target-libffi \
1901         target-zlib \
1902         target-qthreads \
1903         target-libjava"
1904
1905 # these libraries are built for the target environment, and are built after
1906 # the host libraries and the host tools (which may be a cross compiler)
1907 #
1908 target_libraries="target-libgcc \
1909                 target-libiberty \
1910                 target-libgloss \
1911                 target-newlib \
1912                 target-libgomp \
1913                 target-libstdc++-v3 \
1914                 target-libmudflap \
1915                 target-libssp \
1916                 target-libgfortran \
1917                 target-boehm-gc \
1918                 ${libgcj} \
1919                 target-libobjc \
1920                 target-libada"
1921
1922 # these tools are built using the target libraries, and are intended to
1923 # run only in the target environment
1924 #
1925 # note: any program that *uses* libraries that are in the "target_libraries"
1926 # list belongs in this list.  those programs are also very likely
1927 # candidates for the "native_only" list which follows
1928 #
1929 target_tools="target-examples target-groff target-gperf target-rda"
1930
1931 ################################################################################
1932
1933 ## All tools belong in one of the four categories, and are assigned above
1934 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1935 ## is important because configure will choke if they ever get through.
1936 ## ${configdirs} is directories we build using the host tools.
1937 ## ${target_configdirs} is directories we build using the target tools.
1938 configdirs=`echo ${host_libs} ${host_tools}`
1939 target_configdirs=`echo ${target_libraries} ${target_tools}`
1940 build_configdirs=`echo ${build_libs} ${build_tools}`
1941
1942
1943
1944 ################################################################################
1945
1946 srcname="gnu development package"
1947
1948 # This gets set non-empty for some net releases of packages.
1949 appdirs=""
1950
1951 # Define is_cross_compiler to save on calls to 'test'.
1952 is_cross_compiler=
1953 if test x"${host}" = x"${target}" ; then
1954   is_cross_compiler=no
1955 else
1956   is_cross_compiler=yes
1957 fi
1958
1959 # Find the build and target subdir names.
1960
1961 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1962 # have matching libraries, they should use host libraries: Makefile.tpl
1963 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1964 # However, they still use the build modules, because the corresponding
1965 # host modules (e.g. bison) are only built for the host when bootstrap
1966 # finishes. So:
1967 # - build_subdir is where we find build modules, and never changes.
1968 # - build_libsubdir is where we find build libraries, and can be overridden.
1969
1970 # Prefix 'build-' so this never conflicts with target_subdir.
1971 build_subdir="build-${build_noncanonical}"
1972
1973 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1974 if test "${with_build_libsubdir+set}" = set; then
1975   withval="$with_build_libsubdir"
1976   build_libsubdir="$withval"
1977 else
1978   build_libsubdir="$build_subdir"
1979 fi;
1980 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1981 if ( test $srcdir = . && test -d gcc ) \
1982    || test -d $srcdir/../host-${host_noncanonical}; then
1983   host_subdir="host-${host_noncanonical}"
1984 else
1985   host_subdir=.
1986 fi
1987 # No prefix.
1988 target_subdir=${target_noncanonical}
1989
1990
1991 # Skipdirs are removed silently.
1992 skipdirs=
1993 # Noconfigdirs are removed loudly.
1994 noconfigdirs=""
1995
1996 use_gnu_ld=
1997 # Make sure we don't let GNU ld be added if we didn't want it.
1998 if test x$with_gnu_ld = xno ; then
1999   use_gnu_ld=no
2000   noconfigdirs="$noconfigdirs ld gold"
2001 fi
2002
2003 use_gnu_as=
2004 # Make sure we don't let GNU as be added if we didn't want it.
2005 if test x$with_gnu_as = xno ; then
2006   use_gnu_as=no
2007   noconfigdirs="$noconfigdirs gas"
2008 fi
2009
2010 # some tools are so dependent upon X11 that if we're not building with X,
2011 # it's not even worth trying to configure, much less build, that tool.
2012
2013 case ${with_x} in
2014   yes | "") ;; # the default value for this tree is that X11 is available
2015   no)
2016     skipdirs="${skipdirs} tk itcl libgui"
2017     # We won't be able to build gdbtk without X.
2018     enable_gdbtk=no
2019     ;;
2020   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2021 esac
2022
2023 # Some tools are only suitable for building in a "native" situation.
2024 # Remove these if host!=target.
2025 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"
2026
2027 # Similarly, some are only suitable for cross toolchains.
2028 # Remove these if host=target.
2029 cross_only="target-libgloss target-newlib target-opcodes"
2030
2031 case $is_cross_compiler in
2032   no) skipdirs="${skipdirs} ${cross_only}" ;;
2033   yes) skipdirs="${skipdirs} ${native_only}" ;;
2034 esac
2035
2036 # If both --with-headers and --with-libs are specified, default to
2037 # --without-newlib.
2038 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2039    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2040   if test x"${with_newlib}" = x ; then
2041     with_newlib=no
2042   fi
2043 fi
2044
2045 # Recognize --with-newlib/--without-newlib.
2046 case ${with_newlib} in
2047   no) skipdirs="${skipdirs} target-newlib" ;;
2048   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2049 esac
2050
2051 # Handle --enable-gold.
2052
2053 # Check whether --enable-gold or --disable-gold was given.
2054 if test "${enable_gold+set}" = set; then
2055   enableval="$enable_gold"
2056   ENABLE_GOLD=$enableval
2057 else
2058   ENABLE_GOLD=no
2059 fi;
2060 if test "${ENABLE_GOLD}" = "yes"; then
2061   # Check for ELF target.
2062   is_elf=no
2063   case "${target}" in
2064     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2065     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2066     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2067       case "${target}" in
2068         *-*-linux*aout* | *-*-linux*oldld*)
2069           ;;
2070         *)
2071           is_elf=yes
2072           ;;
2073       esac
2074   esac
2075
2076   if test "$is_elf" = "yes"; then
2077     # Check for target supported by gold.
2078     case "${target}" in
2079       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-*)
2080         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2081         ;;
2082     esac
2083   fi
2084 fi
2085
2086 # Configure extra directories which are host specific
2087
2088 case "${host}" in
2089   *-cygwin*)
2090     configdirs="$configdirs libtermcap" ;;
2091 esac
2092
2093 # A target can indicate whether a language isn't supported for some reason.
2094 # Only spaces may be used in this macro; not newlines or tabs.
2095 unsupported_languages=
2096
2097 # Remove more programs from consideration, based on the host or
2098 # target this usually means that a port of the program doesn't
2099 # exist yet.
2100
2101 case "${host}" in
2102   hppa*64*-*-*)
2103     noconfigdirs="$noconfigdirs byacc"
2104     ;;
2105   i[3456789]86-*-vsta)
2106     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2107     ;;
2108   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2109     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2110     ;;
2111   x86_64-*-mingw*)
2112     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2113     ;;
2114   i[3456789]86-*-mingw32*)
2115     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2116     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2117     ;;
2118   i[3456789]86-*-beos*)
2119     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2120     ;;
2121   *-*-cygwin*)
2122     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2123     ;;
2124   *-*-netbsd*)
2125     noconfigdirs="$noconfigdirs rcs"
2126     ;;
2127   ppc*-*-pe)
2128     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2129     ;;
2130   powerpc-*-beos*)
2131     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2132     ;;
2133 esac
2134
2135
2136 # Check whether --enable-libada or --disable-libada was given.
2137 if test "${enable_libada+set}" = set; then
2138   enableval="$enable_libada"
2139   ENABLE_LIBADA=$enableval
2140 else
2141   ENABLE_LIBADA=yes
2142 fi;
2143 if test "${ENABLE_LIBADA}" != "yes" ; then
2144   noconfigdirs="$noconfigdirs gnattools"
2145 fi
2146
2147 # Check whether --enable-libssp or --disable-libssp was given.
2148 if test "${enable_libssp+set}" = set; then
2149   enableval="$enable_libssp"
2150   ENABLE_LIBSSP=$enableval
2151 else
2152   ENABLE_LIBSSP=yes
2153 fi;
2154
2155 # Save it here so that, even in case of --enable-libgcj, if the Java
2156 # front-end isn't enabled, we still get libgcj disabled.
2157 libgcj_saved=$libgcj
2158 case $enable_libgcj in
2159 yes)
2160   # If we reset it here, it won't get added to noconfigdirs in the
2161   # target-specific build rules, so it will be forcibly enabled
2162   # (unless the Java language itself isn't enabled).
2163   libgcj=
2164   ;;
2165 no)
2166   # Make sure we get it printed in the list of not supported target libs.
2167   noconfigdirs="$noconfigdirs ${libgcj}"
2168   ;;
2169 esac
2170
2171
2172 # Disable libmudflap on some systems.
2173 if test x$enable_libmudflap = x ; then
2174     case "${target}" in
2175     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2176         # Enable libmudflap by default in GNU and friends.
2177         ;;
2178     *-*-freebsd*)
2179         # Enable libmudflap by default in FreeBSD.
2180         ;;
2181     *)
2182         # Disable it by default everywhere else.
2183         noconfigdirs="$noconfigdirs target-libmudflap"
2184         ;;
2185     esac
2186 fi
2187
2188 # Disable libgomp on non POSIX hosted systems.
2189 if test x$enable_libgomp = x ; then
2190     # Enable libgomp by default on hosted POSIX systems.
2191     case "${target}" in
2192     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2193         ;;
2194     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2195         ;;
2196     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2197         ;;
2198     *-*-darwin* | *-*-aix*)
2199         ;;
2200     *)
2201         noconfigdirs="$noconfigdirs target-libgomp"
2202         ;;
2203     esac
2204 fi
2205
2206 # Default libgloss CPU subdirectory.
2207 libgloss_dir="$target_cpu"
2208
2209 case "${target}" in
2210   *-*-chorusos)
2211     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2212     ;;
2213   powerpc-*-darwin* | i[3456789]86-*-darwin* | x86_64-*-darwin9*)
2214     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2215     noconfigdirs="$noconfigdirs sim target-rda"
2216     ;;
2217   *-*-darwin*)
2218     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2219     noconfigdirs="$noconfigdirs sim target-rda"
2220     noconfigdirs="$noconfigdirs ${libgcj}"
2221     ;;
2222   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2223     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2224     ;;
2225   *-*-freebsd*)
2226     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2227     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2228         && test -f /usr/local/include/gmp.h; then
2229       with_gmp=/usr/local
2230     fi
2231
2232     # Skip some stuff that's unsupported on some FreeBSD configurations.
2233     case "${target}" in
2234       i*86-*-*) ;;
2235       alpha*-*-*) ;;
2236       *)
2237         noconfigdirs="$noconfigdirs ${libgcj}"
2238         ;;
2239     esac
2240     ;;
2241   *-*-kaos*)
2242     # Remove unsupported stuff on all kaOS configurations.
2243     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2244     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2245     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2246     noconfigdirs="$noconfigdirs target-libgloss"
2247     ;;
2248   *-*-netbsd*)
2249     # Skip some stuff on all NetBSD configurations.
2250     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2251
2252     # Skip some stuff that's unsupported on some NetBSD configurations.
2253     case "${target}" in
2254       i*86-*-netbsdelf*) ;;
2255       arm*-*-netbsdelf*) ;;
2256       *)
2257         noconfigdirs="$noconfigdirs ${libgcj}"
2258         ;;
2259     esac
2260     ;;
2261   *-*-netware*)
2262     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2263     ;;
2264   *-*-rtems*)
2265     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2266     ;;
2267     # The tpf target doesn't support gdb yet.
2268   *-*-tpf*)
2269     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2270     ;;
2271   *-*-uclinux*)
2272     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2273     ;;
2274   *-*-vxworks*)
2275     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2276     ;;
2277   alpha*-dec-osf*)
2278     # ld works, but does not support shared libraries.
2279     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2280     # gas doesn't generate exception information.
2281     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2282     ;;
2283   alpha*-*-*vms*)
2284     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2285     ;;
2286   alpha*-*-linux*)
2287     # newlib is not 64 bit ready
2288     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2289     ;;
2290   alpha*-*-*)
2291     # newlib is not 64 bit ready
2292     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2293     ;;
2294   am33_2.0-*-linux*)
2295     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2296     ;;
2297   sh-*-linux*)
2298     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2299     ;;
2300   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2301     noconfigdirs="$noconfigdirs ${libgcj}"
2302     noconfigdirs="$noconfigdirs target-examples"
2303     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2304     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2305     noconfigdirs="$noconfigdirs expect dejagnu"
2306     # the C++ libraries don't build on top of CE's C libraries
2307     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2308     noconfigdirs="$noconfigdirs target-newlib"
2309     case "${host}" in
2310       *-*-cygwin*) ;; # keep gdb and readline
2311       *) noconfigdirs="$noconfigdirs gdb readline"
2312          ;;
2313     esac
2314     libgloss_dir=wince
2315     ;;
2316   arc-*-*)
2317     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2318     ;;
2319   arm-semi-aof )
2320     ;;
2321   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2322     noconfigdirs="$noconfigdirs ${libgcj}"
2323     libgloss_dir=arm
2324     ;;
2325   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2326     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2327     libgloss_dir=arm
2328     ;;
2329   arm*-*-linux-gnueabi)
2330     noconfigdirs="$noconfigdirs target-qthreads"
2331     case ${with_newlib} in
2332       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2333     esac
2334     libgloss_dir=arm
2335     ;;
2336   arm*-*-symbianelf*)
2337     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2338     libgloss_dir=arm
2339     ;;
2340   arm-*-pe*)
2341     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2342     ;;
2343   thumb-*-coff)
2344     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2345     ;;
2346   thumb-*-elf)
2347     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2348     ;;
2349   thumb-*-pe)
2350     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2351     ;;
2352   arm-*-riscix*)
2353     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2354     ;;
2355   avr-*-*)
2356     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2357     ;;
2358   bfin-*-*)
2359     noconfigdirs="$noconfigdirs gdb"
2360     if test x${is_cross_compiler} != xno ; then
2361       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2362     fi
2363     ;;
2364   c4x-*-* | tic4x-*-*)
2365     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2366     ;;
2367   c54x*-*-* | tic54x-*-*)
2368     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2369     ;;
2370   cr16-*-*)
2371     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2372     ;;
2373   cris-*-* | crisv32-*-*)
2374     unsupported_languages="$unsupported_languages java"
2375     case "${target}" in
2376       *-*-aout)
2377         unsupported_languages="$unsupported_languages fortran"
2378         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2379       *-*-elf)
2380         noconfigdirs="$noconfigdirs target-boehm-gc";;
2381       *-*-linux*)
2382         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2383       *)
2384         unsupported_languages="$unsupported_languages fortran"
2385         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2386     esac
2387     libgloss_dir=cris
2388     ;;
2389   crx-*-*)
2390     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2391     ;;
2392   d10v-*-*)
2393     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2394     ;;
2395   d30v-*-*)
2396     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2397     ;;
2398   ep9312-*-elf | ep9312-*-coff)
2399     libgloss_dir=arm
2400     ;;
2401   fr30-*-elf*)
2402     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2403     ;;
2404   frv-*-*)
2405     noconfigdirs="$noconfigdirs ${libgcj}"
2406     ;;
2407   h8300*-*-*)
2408     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2409     ;;
2410   h8500-*-*)
2411     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2412     ;;
2413   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2414     ;;
2415   hppa*64*-*-linux* | parisc*64*-*-linux*)
2416     # In this case, it's because the hppa64-linux target is for
2417     # the kernel only at this point and has no libc, and thus no
2418     # headers, crt*.o, etc., all of which are needed by these.
2419     noconfigdirs="$noconfigdirs target-zlib"
2420     ;;
2421   parisc*-*-linux* | hppa*-*-linux*)
2422     ;;
2423   hppa*-*-*elf* | \
2424   hppa*-*-lites* | \
2425   hppa*-*-openbsd* | \
2426   hppa*64*-*-*)
2427     noconfigdirs="$noconfigdirs ${libgcj}"
2428     ;;
2429   hppa*-hp-hpux11*)
2430     noconfigdirs="$noconfigdirs ld shellutils"
2431     ;;
2432   hppa*-*-pro*)
2433     libgloss_dir=pa
2434     ;;
2435   hppa*-*-*)
2436     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2437     # build on HP-UX 10.20.
2438     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2439     ;;
2440   i960-*-*)
2441     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2442     ;;
2443   ia64*-*-elf*)
2444     # No gdb support yet.
2445     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2446     ;;
2447   ia64*-**-hpux*)
2448     # No gdb or ld support yet.
2449     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2450     ;;
2451   i370-*-opened*)
2452     ;;
2453   i[3456789]86-*-coff | i[3456789]86-*-elf)
2454     noconfigdirs="$noconfigdirs ${libgcj}"
2455     libgloss_dir=i386
2456     ;;
2457   i[3456789]86-*-linux*)
2458     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2459     # not build java stuff by default.
2460     case "${target}" in
2461       *-*-*libc1*)
2462         noconfigdirs="$noconfigdirs ${libgcj}";;
2463     esac
2464
2465     # This section makes it possible to build newlib natively on linux.
2466     # If we are using a cross compiler then don't configure newlib.
2467     if test x${is_cross_compiler} != xno ; then
2468       noconfigdirs="$noconfigdirs target-newlib"
2469     fi
2470     noconfigdirs="$noconfigdirs target-libgloss"
2471     # If we are not using a cross compiler, do configure newlib.
2472     # Note however, that newlib will only be configured in this situation
2473     # if the --with-newlib option has been given, because otherwise
2474     # 'target-newlib' will appear in skipdirs.
2475     ;;
2476   i[3456789]86-*-mingw32*)
2477     target_configdirs="$target_configdirs target-winsup"
2478     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2479     ;;
2480   x86_64-*-mingw*)
2481     target_configdirs="$target_configdirs target-winsup"
2482     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2483     ;;
2484   *-*-cygwin*)
2485     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2486     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2487     # always build newlib if winsup directory is present.
2488     if test -d "$srcdir/winsup/cygwin"; then
2489       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2490     elif test -d "$srcdir/newlib"; then
2491       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2492     fi
2493     ;;
2494   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2495   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2496     ;;
2497   i[3456789]86-*-pe)
2498     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2499     ;;
2500   i[3456789]86-*-sco3.2v5*)
2501     # The linker does not yet know about weak symbols in COFF,
2502     # and is not configured to handle mixed ELF and COFF.
2503     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2504     ;;
2505   i[3456789]86-*-sco*)
2506     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2507     ;;
2508   i[3456789]86-*-solaris2*)
2509     noconfigdirs="$noconfigdirs target-libgloss"
2510     ;;
2511   i[3456789]86-*-sysv4*)
2512     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2513     ;;
2514   i[3456789]86-*-beos*)
2515     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2516     ;;
2517   i[3456789]86-*-rdos*)
2518     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2519     ;;
2520   m32r-*-*)
2521     noconfigdirs="$noconfigdirs ${libgcj}"
2522     ;;
2523   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2524     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2525     libgloss_dir=m68hc11
2526     ;;
2527   m68k-*-elf*)
2528     noconfigdirs="$noconfigdirs ${libgcj}"
2529     ;;
2530   m68k-*-coff*)
2531     noconfigdirs="$noconfigdirs ${libgcj}"
2532     ;;
2533   m68*-*-* | fido-*-*)
2534     libgloss_dir=m68k
2535     ;;
2536   mcore-*-pe*)
2537   # The EPOC C++ environment does not support exceptions or rtti,
2538   # and so building libstdc++-v3 tends not to always work.
2539     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2540     ;;
2541   mmix-*-*)
2542     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2543     unsupported_languages="$unsupported_languages fortran java"
2544     ;;
2545   mn10200-*-*)
2546     noconfigdirs="$noconfigdirs ${libgcj}"
2547     ;;
2548   mn10300-*-*)
2549     noconfigdirs="$noconfigdirs ${libgcj}"
2550     ;;
2551   mt-*-*)
2552     noconfigdirs="$noconfigdirs sim"
2553     ;;
2554   powerpc-*-aix*)
2555     # copied from rs6000-*-* entry
2556     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2557     ;;
2558   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2559     target_configdirs="$target_configdirs target-winsup"
2560     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2561     # always build newlib.
2562     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2563     ;;
2564     # This is temporary until we can link against shared libraries
2565   powerpcle-*-solaris*)
2566     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2567     libgloss_dir=rs6000
2568     ;;
2569   powerpc-*-beos*)
2570     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2571     ;;
2572   powerpc-*-eabi)
2573     noconfigdirs="$noconfigdirs ${libgcj}"
2574     libgloss_dir=rs6000
2575     ;;
2576   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2577     libgloss_dir=rs6000
2578     ;;
2579   rs6000-*-lynxos*)
2580     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2581     ;;
2582   rs6000-*-aix*)
2583     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2584     ;;
2585   rs6000-*-*)
2586     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2587     ;;
2588   m68k-apollo-*)
2589     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2590     ;;
2591   mips*-sde-elf*)
2592     skipdirs="$skipdirs target-libiberty"
2593     noconfigdirs="$noconfigdirs ${libgcj}"
2594     if test x$with_newlib = xyes; then
2595       noconfigdirs="$noconfigdirs gprof"
2596     fi
2597     libgloss_dir=mips
2598     ;;
2599   mips*-*-irix5*)
2600     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2601     ;;
2602   mips*-*-irix6*)
2603     # Linking libjava exceeds command-line length limits on at least
2604     # IRIX 6.2, but not on IRIX 6.5.
2605     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2606     # <oldham@codesourcery.com>
2607     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2608     ;;
2609   mips*-*-bsd*)
2610     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2611     ;;
2612   mips*-*-linux*)
2613     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2614     ;;
2615   mips*-*-*)
2616     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2617     libgloss_dir=mips
2618     ;;
2619   romp-*-*)
2620     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2621     ;;
2622   sh-*-* | sh64-*-*)
2623     case "${host}" in
2624       i[3456789]86-*-vsta) ;; # don't add gprof back in
2625       i[3456789]86-*-go32*) ;; # don't add gprof back in
2626       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2627       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2628     esac
2629     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2630     ;;
2631   sparclet-*-aout* | sparc86x-*-*)
2632     libgloss_dir=sparc
2633     ;;
2634   sparc-*-elf*)
2635     noconfigdirs="$noconfigdirs ${libgcj}"
2636     ;;
2637   sparc64-*-elf*)
2638     noconfigdirs="$noconfigdirs ${libgcj}"
2639     libgloss_dir=sparc
2640     ;;
2641   sparclite-*-*)
2642     noconfigdirs="$noconfigdirs ${libgcj}"
2643     libgloss_dir=sparc
2644     ;;
2645   sparc-*-sunos4*)
2646     noconfigdirs="$noconfigdirs ${libgcj}"
2647     if test x${is_cross_compiler} != xno ; then
2648            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2649     else
2650            use_gnu_ld=no
2651     fi
2652     ;;
2653   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2654     noconfigdirs="$noconfigdirs ${libgcj}"
2655     ;;
2656   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2657     ;;
2658   v810-*-*)
2659     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2660     ;;
2661   v850-*-*)
2662     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2663     ;;
2664   v850e-*-*)
2665     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2666     ;;
2667   v850ea-*-*)
2668     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2669     ;;
2670   vax-*-vms)
2671     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2672     ;;
2673   vax-*-*)
2674     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2675     ;;
2676   xtensa*-*-*)
2677     noconfigdirs="$noconfigdirs ${libgcj}"
2678     ;;
2679   ip2k-*-*)
2680     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2681     ;;
2682   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2683     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2684     ;;
2685   *-*-lynxos*)
2686     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2687     ;;
2688   *-*-*)
2689     noconfigdirs="$noconfigdirs ${libgcj}"
2690     ;;
2691 esac
2692
2693 # If we aren't building newlib, then don't build libgloss, since libgloss
2694 # depends upon some newlib header files.
2695 case "${noconfigdirs}" in
2696   *target-libgloss*) ;;
2697   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2698 esac
2699
2700 # Work in distributions that contain no compiler tools, like Autoconf.
2701 tentative_cc=""
2702 host_makefile_frag=/dev/null
2703 if test -d ${srcdir}/config ; then
2704 case "${host}" in
2705   m68k-hp-hpux*)
2706     # Avoid "too much defining" errors from HPUX compiler.
2707     tentative_cc="cc -Wp,-H256000"
2708     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2709     # If it's HP/UX ar, this should be harmless.
2710     RANLIB="ar ts"
2711     ;;
2712   m68k-apollo-sysv*)
2713     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2714     ;;
2715   m68k-apollo-bsd*)
2716     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2717     # chokes on bfd, the compiler won't let you assign integers to enums, and
2718     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2719     # the apollo compiler" (the preferred version of GCC could be called cc,
2720     # or whatever), but I'm not sure leaving CC as cc is any better...
2721     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2722     # Used to have BISON=yacc.
2723     tentative_cc=gcc
2724     ;;
2725   m88k-dg-dgux*)
2726     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2727     ;;
2728   m88k-harris-cxux*)
2729     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2730     tentative_cc="cc -Xa"
2731     host_makefile_frag="config/mh-cxux"
2732     ;;
2733   m88k-motorola-sysv*)
2734     ;;
2735   mips*-dec-ultrix*)
2736     tentative_cc="cc -Wf,-XNg1000"
2737     host_makefile_frag="config/mh-decstation"
2738     ;;
2739   mips*-nec-sysv4*)
2740     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2741     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2742     host_makefile_frag="config/mh-necv4"
2743     ;;
2744   mips*-sgi-irix4*)
2745     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2746     # environment.  Also bump switch table size so that cp-parse will
2747     # compile.  Bump string length limit so linker builds.
2748     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2749     ;;
2750   mips*-*-sysv4*)
2751     host_makefile_frag="config/mh-sysv4"
2752     ;;
2753   mips*-*-sysv*)
2754     # This is for a MIPS running RISC/os 4.52C.
2755
2756     # This is needed for GDB, but needs to be in the top-level make because
2757     # if a library is compiled with the bsd headers and gets linked with the
2758     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2759     # a different size).
2760     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2761     # known except to select the sysv environment.  Could we use /proc instead?
2762     # These "sysv environments" and "bsd environments" often end up being a pain.
2763     #
2764     # This is not part of CFLAGS because perhaps not all C compilers have this
2765     # option.
2766     tentative_cc="cc -systype sysv"
2767     ;;
2768   i370-ibm-opened*)
2769     tentative_cc="c89"
2770     ;;
2771   i[3456789]86-*-sysv5*)
2772     host_makefile_frag="config/mh-sysv5"
2773     ;;
2774   i[3456789]86-*-dgux*)
2775     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2776     host_makefile_frag="config/mh-dgux386"
2777     ;;
2778   i[3456789]86-ncr-sysv4.3*)
2779     # The MetaWare compiler will generate a copyright message unless you
2780     # turn it off by adding the -Hnocopyr flag.
2781     tentative_cc="cc -Hnocopyr"
2782     ;;
2783   i[3456789]86-ncr-sysv4*)
2784     # for an NCR 3000 (i486/SVR4) system.
2785     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2786     # This compiler not only emits obnoxious copyright messages every time
2787     # you run it, but it chokes and dies on a whole bunch of GNU source
2788     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2789     tentative_cc="/usr/ccs/ATT/cc"
2790     host_makefile_frag="config/mh-ncr3000"
2791     ;;
2792   i[3456789]86-*-sco3.2v5*)
2793     ;;
2794   i[3456789]86-*-sco*)
2795     # The native C compiler botches some simple uses of const.  Unfortunately,
2796     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2797     tentative_cc="cc -Dconst="
2798     host_makefile_frag="config/mh-sco"
2799     ;;
2800   i[3456789]86-*-udk*)
2801     host_makefile_frag="config/mh-sysv5"
2802     ;;
2803   i[3456789]86-*-solaris2*)
2804     host_makefile_frag="config/mh-sysv4"
2805     ;;
2806   i[3456789]86-*-msdosdjgpp*)
2807     host_makefile_frag="config/mh-djgpp"
2808     ;;
2809   *-cygwin*)
2810
2811 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2812 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2813 echo a >cygwin-cat-check
2814 if test `cat cygwin-cat-check` == a ; then
2815   rm cygwin-cat-check
2816   echo "$as_me:$LINENO: result: yes" >&5
2817 echo "${ECHO_T}yes" >&6
2818 else
2819   rm cygwin-cat-check
2820   echo "$as_me:$LINENO: result: no" >&5
2821 echo "${ECHO_T}no" >&6
2822   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2823   Please either mount the build directory in binary mode or run the following
2824   commands before running any configure script:
2825 set -o igncr
2826 export SHELLOPTS
2827   " >&5
2828 echo "$as_me: error: The cat command does not ignore carriage return characters.
2829   Please either mount the build directory in binary mode or run the following
2830   commands before running any configure script:
2831 set -o igncr
2832 export SHELLOPTS
2833   " >&2;}
2834    { (exit 1); exit 1; }; }
2835 fi
2836
2837     host_makefile_frag="config/mh-cygwin"
2838     ;;
2839   *-mingw*)
2840     host_makefile_frag="config/mh-mingw"
2841     ;;
2842   *-interix*)
2843     host_makefile_frag="config/mh-interix"
2844     ;;
2845   vax-*-ultrix2*)
2846     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2847     tentative_cc=gcc
2848     ;;
2849   *-*-solaris2*)
2850     host_makefile_frag="config/mh-solaris"
2851     ;;
2852   m68k-sun-sunos*)
2853     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2854     # without overflowing the jump tables (-J says to use a 32 bit table)
2855     tentative_cc="cc -J"
2856     ;;
2857   hppa*-hp-hpux10*)
2858     tentative_cc="cc -Wp,-H256000"
2859     host_makefile_frag="config/mh-pa-hpux10"
2860     ;;
2861   hppa*-hp-hpux* | hppa*-*-hiux*)
2862     tentative_cc="cc -Wp,-H256000"
2863     host_makefile_frag="config/mh-pa"
2864     ;;
2865   hppa*-*)
2866     host_makefile_frag="config/mh-pa"
2867     ;;
2868   *-hp-hpux* | *-*-hiux*)
2869     tentative_cc="cc -Wp,-H256000"
2870     ;;
2871   rs6000-*-lynxos*)
2872     # /bin/cc is less than useful for our purposes.  Always use GCC
2873     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2874     host_makefile_frag="config/mh-lynxrs6k"
2875     ;;
2876   powerpc-*-darwin*)
2877     host_makefile_frag="config/mh-ppc-darwin"
2878     ;;
2879   powerpc-*-aix*)
2880     host_makefile_frag="config/mh-ppc-aix"
2881     ;;
2882   rs6000-*-aix*)
2883     host_makefile_frag="config/mh-ppc-aix"
2884     ;;
2885   *-*-lynxos*)
2886     # /bin/cc is less than useful for our purposes.  Always use GCC
2887     tentative_cc="/bin/gcc"
2888     ;;
2889   *-*-sysv4*)
2890     host_makefile_frag="config/mh-sysv4"
2891     ;;
2892   # This is placed last to prevent interfering with the cases above.
2893   i[3456789]86-*-*)
2894     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2895     host_makefile_frag="config/mh-x86omitfp"
2896     ;;
2897 esac
2898 fi
2899
2900 # If we aren't going to be using gcc, see if we can extract a definition
2901 # of CC from the fragment.
2902 # Actually, use the 'pre-extracted' version above.
2903 if test -z "${CC}" && test "${build}" = "${host}" ; then
2904   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2905   found=
2906   for dir in $PATH; do
2907     test -z "$dir" && dir=.
2908     if test -f $dir/gcc; then
2909       found=yes
2910       break
2911     fi
2912   done
2913   IFS="$save_ifs"
2914   if test -z "${found}" && test -n "${tentative_cc}" ; then
2915     CC=$tentative_cc
2916   fi
2917 fi
2918
2919 if test "${build}" != "${host}" ; then
2920   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2921   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2922   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2923   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2924   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2925   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2926   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2927   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2928   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2929   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2930   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2931   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2932 else
2933   AR_FOR_BUILD="\$(AR)"
2934   AS_FOR_BUILD="\$(AS)"
2935   CC_FOR_BUILD="\$(CC)"
2936   CXX_FOR_BUILD="\$(CXX)"
2937   GCJ_FOR_BUILD="\$(GCJ)"
2938   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2939   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2940   LD_FOR_BUILD="\$(LD)"
2941   NM_FOR_BUILD="\$(NM)"
2942   RANLIB_FOR_BUILD="\$(RANLIB)"
2943   WINDRES_FOR_BUILD="\$(WINDRES)"
2944   WINDMC_FOR_BUILD="\$(WINDMC)"
2945 fi
2946
2947 ac_ext=c
2948 ac_cpp='$CPP $CPPFLAGS'
2949 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2950 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2951 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2952 if test -n "$ac_tool_prefix"; then
2953   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2954 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2955 echo "$as_me:$LINENO: checking for $ac_word" >&5
2956 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2957 if test "${ac_cv_prog_CC+set}" = set; then
2958   echo $ECHO_N "(cached) $ECHO_C" >&6
2959 else
2960   if test -n "$CC"; then
2961   ac_cv_prog_CC="$CC" # Let the user override the test.
2962 else
2963 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2964 for as_dir in $PATH
2965 do
2966   IFS=$as_save_IFS
2967   test -z "$as_dir" && as_dir=.
2968   for ac_exec_ext in '' $ac_executable_extensions; do
2969   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2970     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2971     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2972     break 2
2973   fi
2974 done
2975 done
2976
2977 fi
2978 fi
2979 CC=$ac_cv_prog_CC
2980 if test -n "$CC"; then
2981   echo "$as_me:$LINENO: result: $CC" >&5
2982 echo "${ECHO_T}$CC" >&6
2983 else
2984   echo "$as_me:$LINENO: result: no" >&5
2985 echo "${ECHO_T}no" >&6
2986 fi
2987
2988 fi
2989 if test -z "$ac_cv_prog_CC"; then
2990   ac_ct_CC=$CC
2991   # Extract the first word of "gcc", so it can be a program name with args.
2992 set dummy gcc; ac_word=$2
2993 echo "$as_me:$LINENO: checking for $ac_word" >&5
2994 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2995 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2996   echo $ECHO_N "(cached) $ECHO_C" >&6
2997 else
2998   if test -n "$ac_ct_CC"; then
2999   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3000 else
3001 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3002 for as_dir in $PATH
3003 do
3004   IFS=$as_save_IFS
3005   test -z "$as_dir" && as_dir=.
3006   for ac_exec_ext in '' $ac_executable_extensions; do
3007   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3008     ac_cv_prog_ac_ct_CC="gcc"
3009     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3010     break 2
3011   fi
3012 done
3013 done
3014
3015 fi
3016 fi
3017 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3018 if test -n "$ac_ct_CC"; then
3019   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3020 echo "${ECHO_T}$ac_ct_CC" >&6
3021 else
3022   echo "$as_me:$LINENO: result: no" >&5
3023 echo "${ECHO_T}no" >&6
3024 fi
3025
3026   CC=$ac_ct_CC
3027 else
3028   CC="$ac_cv_prog_CC"
3029 fi
3030
3031 if test -z "$CC"; then
3032   if test -n "$ac_tool_prefix"; then
3033   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3034 set dummy ${ac_tool_prefix}cc; ac_word=$2
3035 echo "$as_me:$LINENO: checking for $ac_word" >&5
3036 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3037 if test "${ac_cv_prog_CC+set}" = set; then
3038   echo $ECHO_N "(cached) $ECHO_C" >&6
3039 else
3040   if test -n "$CC"; then
3041   ac_cv_prog_CC="$CC" # Let the user override the test.
3042 else
3043 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3044 for as_dir in $PATH
3045 do
3046   IFS=$as_save_IFS
3047   test -z "$as_dir" && as_dir=.
3048   for ac_exec_ext in '' $ac_executable_extensions; do
3049   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3050     ac_cv_prog_CC="${ac_tool_prefix}cc"
3051     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3052     break 2
3053   fi
3054 done
3055 done
3056
3057 fi
3058 fi
3059 CC=$ac_cv_prog_CC
3060 if test -n "$CC"; then
3061   echo "$as_me:$LINENO: result: $CC" >&5
3062 echo "${ECHO_T}$CC" >&6
3063 else
3064   echo "$as_me:$LINENO: result: no" >&5
3065 echo "${ECHO_T}no" >&6
3066 fi
3067
3068 fi
3069 if test -z "$ac_cv_prog_CC"; then
3070   ac_ct_CC=$CC
3071   # Extract the first word of "cc", so it can be a program name with args.
3072 set dummy cc; ac_word=$2
3073 echo "$as_me:$LINENO: checking for $ac_word" >&5
3074 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3075 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3076   echo $ECHO_N "(cached) $ECHO_C" >&6
3077 else
3078   if test -n "$ac_ct_CC"; then
3079   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3080 else
3081 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3082 for as_dir in $PATH
3083 do
3084   IFS=$as_save_IFS
3085   test -z "$as_dir" && as_dir=.
3086   for ac_exec_ext in '' $ac_executable_extensions; do
3087   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3088     ac_cv_prog_ac_ct_CC="cc"
3089     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3090     break 2
3091   fi
3092 done
3093 done
3094
3095 fi
3096 fi
3097 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3098 if test -n "$ac_ct_CC"; then
3099   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3100 echo "${ECHO_T}$ac_ct_CC" >&6
3101 else
3102   echo "$as_me:$LINENO: result: no" >&5
3103 echo "${ECHO_T}no" >&6
3104 fi
3105
3106   CC=$ac_ct_CC
3107 else
3108   CC="$ac_cv_prog_CC"
3109 fi
3110
3111 fi
3112 if test -z "$CC"; then
3113   # Extract the first word of "cc", so it can be a program name with args.
3114 set dummy cc; ac_word=$2
3115 echo "$as_me:$LINENO: checking for $ac_word" >&5
3116 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3117 if test "${ac_cv_prog_CC+set}" = set; then
3118   echo $ECHO_N "(cached) $ECHO_C" >&6
3119 else
3120   if test -n "$CC"; then
3121   ac_cv_prog_CC="$CC" # Let the user override the test.
3122 else
3123   ac_prog_rejected=no
3124 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3125 for as_dir in $PATH
3126 do
3127   IFS=$as_save_IFS
3128   test -z "$as_dir" && as_dir=.
3129   for ac_exec_ext in '' $ac_executable_extensions; do
3130   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3131     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3132        ac_prog_rejected=yes
3133        continue
3134      fi
3135     ac_cv_prog_CC="cc"
3136     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3137     break 2
3138   fi
3139 done
3140 done
3141
3142 if test $ac_prog_rejected = yes; then
3143   # We found a bogon in the path, so make sure we never use it.
3144   set dummy $ac_cv_prog_CC
3145   shift
3146   if test $# != 0; then
3147     # We chose a different compiler from the bogus one.
3148     # However, it has the same basename, so the bogon will be chosen
3149     # first if we set CC to just the basename; use the full file name.
3150     shift
3151     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3152   fi
3153 fi
3154 fi
3155 fi
3156 CC=$ac_cv_prog_CC
3157 if test -n "$CC"; then
3158   echo "$as_me:$LINENO: result: $CC" >&5
3159 echo "${ECHO_T}$CC" >&6
3160 else
3161   echo "$as_me:$LINENO: result: no" >&5
3162 echo "${ECHO_T}no" >&6
3163 fi
3164
3165 fi
3166 if test -z "$CC"; then
3167   if test -n "$ac_tool_prefix"; then
3168   for ac_prog in cl
3169   do
3170     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3171 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3172 echo "$as_me:$LINENO: checking for $ac_word" >&5
3173 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3174 if test "${ac_cv_prog_CC+set}" = set; then
3175   echo $ECHO_N "(cached) $ECHO_C" >&6
3176 else
3177   if test -n "$CC"; then
3178   ac_cv_prog_CC="$CC" # Let the user override the test.
3179 else
3180 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3181 for as_dir in $PATH
3182 do
3183   IFS=$as_save_IFS
3184   test -z "$as_dir" && as_dir=.
3185   for ac_exec_ext in '' $ac_executable_extensions; do
3186   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3187     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3188     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3189     break 2
3190   fi
3191 done
3192 done
3193
3194 fi
3195 fi
3196 CC=$ac_cv_prog_CC
3197 if test -n "$CC"; then
3198   echo "$as_me:$LINENO: result: $CC" >&5
3199 echo "${ECHO_T}$CC" >&6
3200 else
3201   echo "$as_me:$LINENO: result: no" >&5
3202 echo "${ECHO_T}no" >&6
3203 fi
3204
3205     test -n "$CC" && break
3206   done
3207 fi
3208 if test -z "$CC"; then
3209   ac_ct_CC=$CC
3210   for ac_prog in cl
3211 do
3212   # Extract the first word of "$ac_prog", so it can be a program name with args.
3213 set dummy $ac_prog; ac_word=$2
3214 echo "$as_me:$LINENO: checking for $ac_word" >&5
3215 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3216 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3217   echo $ECHO_N "(cached) $ECHO_C" >&6
3218 else
3219   if test -n "$ac_ct_CC"; then
3220   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3221 else
3222 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3223 for as_dir in $PATH
3224 do
3225   IFS=$as_save_IFS
3226   test -z "$as_dir" && as_dir=.
3227   for ac_exec_ext in '' $ac_executable_extensions; do
3228   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3229     ac_cv_prog_ac_ct_CC="$ac_prog"
3230     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3231     break 2
3232   fi
3233 done
3234 done
3235
3236 fi
3237 fi
3238 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3239 if test -n "$ac_ct_CC"; then
3240   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3241 echo "${ECHO_T}$ac_ct_CC" >&6
3242 else
3243   echo "$as_me:$LINENO: result: no" >&5
3244 echo "${ECHO_T}no" >&6
3245 fi
3246
3247   test -n "$ac_ct_CC" && break
3248 done
3249
3250   CC=$ac_ct_CC
3251 fi
3252
3253 fi
3254
3255
3256 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3257 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3258 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3259 See \`config.log' for more details." >&5
3260 echo "$as_me: error: no acceptable C compiler found in \$PATH
3261 See \`config.log' for more details." >&2;}
3262    { (exit 1); exit 1; }; }; }
3263
3264 # Provide some information about the compiler.
3265 echo "$as_me:$LINENO:" \
3266      "checking for C compiler version" >&5
3267 ac_compiler=`set X $ac_compile; echo $2`
3268 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3269   (eval $ac_compiler --version </dev/null >&5) 2>&5
3270   ac_status=$?
3271   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3272   (exit $ac_status); }
3273 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3274   (eval $ac_compiler -v </dev/null >&5) 2>&5
3275   ac_status=$?
3276   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3277   (exit $ac_status); }
3278 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3279   (eval $ac_compiler -V </dev/null >&5) 2>&5
3280   ac_status=$?
3281   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3282   (exit $ac_status); }
3283
3284 cat >conftest.$ac_ext <<_ACEOF
3285 /* confdefs.h.  */
3286 _ACEOF
3287 cat confdefs.h >>conftest.$ac_ext
3288 cat >>conftest.$ac_ext <<_ACEOF
3289 /* end confdefs.h.  */
3290
3291 int
3292 main ()
3293 {
3294
3295   ;
3296   return 0;
3297 }
3298 _ACEOF
3299 ac_clean_files_save=$ac_clean_files
3300 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3301 # Try to create an executable without -o first, disregard a.out.
3302 # It will help us diagnose broken compilers, and finding out an intuition
3303 # of exeext.
3304 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3305 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3306 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3307 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3308   (eval $ac_link_default) 2>&5
3309   ac_status=$?
3310   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3311   (exit $ac_status); }; then
3312   # Find the output, starting from the most likely.  This scheme is
3313 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3314 # resort.
3315
3316 # Be careful to initialize this variable, since it used to be cached.
3317 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3318 ac_cv_exeext=
3319 # b.out is created by i960 compilers.
3320 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3321 do
3322   test -f "$ac_file" || continue
3323   case $ac_file in
3324     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3325         ;;
3326     conftest.$ac_ext )
3327         # This is the source file.
3328         ;;
3329     [ab].out )
3330         # We found the default executable, but exeext='' is most
3331         # certainly right.
3332         break;;
3333     *.* )
3334         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3335         # FIXME: I believe we export ac_cv_exeext for Libtool,
3336         # but it would be cool to find out if it's true.  Does anybody
3337         # maintain Libtool? --akim.
3338         export ac_cv_exeext
3339         break;;
3340     * )
3341         break;;
3342   esac
3343 done
3344 else
3345   echo "$as_me: failed program was:" >&5
3346 sed 's/^/| /' conftest.$ac_ext >&5
3347
3348 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3349 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3350 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3351 See \`config.log' for more details." >&5
3352 echo "$as_me: error: C compiler cannot create executables
3353 See \`config.log' for more details." >&2;}
3354    { (exit 77); exit 77; }; }; }
3355 fi
3356
3357 ac_exeext=$ac_cv_exeext
3358 echo "$as_me:$LINENO: result: $ac_file" >&5
3359 echo "${ECHO_T}$ac_file" >&6
3360
3361 # Check the compiler produces executables we can run.  If not, either
3362 # the compiler is broken, or we cross compile.
3363 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3364 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3365 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3366 # If not cross compiling, check that we can run a simple program.
3367 if test "$cross_compiling" != yes; then
3368   if { ac_try='./$ac_file'
3369   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3370   (eval $ac_try) 2>&5
3371   ac_status=$?
3372   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3373   (exit $ac_status); }; }; then
3374     cross_compiling=no
3375   else
3376     if test "$cross_compiling" = maybe; then
3377         cross_compiling=yes
3378     else
3379         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3380 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3381 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3382 If you meant to cross compile, use \`--host'.
3383 See \`config.log' for more details." >&5
3384 echo "$as_me: error: cannot run C compiled programs.
3385 If you meant to cross compile, use \`--host'.
3386 See \`config.log' for more details." >&2;}
3387    { (exit 1); exit 1; }; }; }
3388     fi
3389   fi
3390 fi
3391 echo "$as_me:$LINENO: result: yes" >&5
3392 echo "${ECHO_T}yes" >&6
3393
3394 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3395 ac_clean_files=$ac_clean_files_save
3396 # Check the compiler produces executables we can run.  If not, either
3397 # the compiler is broken, or we cross compile.
3398 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3399 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3400 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3401 echo "${ECHO_T}$cross_compiling" >&6
3402
3403 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3404 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3405 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3406   (eval $ac_link) 2>&5
3407   ac_status=$?
3408   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3409   (exit $ac_status); }; then
3410   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3411 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3412 # work properly (i.e., refer to `conftest.exe'), while it won't with
3413 # `rm'.
3414 for ac_file in conftest.exe conftest conftest.*; do
3415   test -f "$ac_file" || continue
3416   case $ac_file in
3417     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3418     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3419           export ac_cv_exeext
3420           break;;
3421     * ) break;;
3422   esac
3423 done
3424 else
3425   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3426 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3427 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3428 See \`config.log' for more details." >&5
3429 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3430 See \`config.log' for more details." >&2;}
3431    { (exit 1); exit 1; }; }; }
3432 fi
3433
3434 rm -f conftest$ac_cv_exeext
3435 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3436 echo "${ECHO_T}$ac_cv_exeext" >&6
3437
3438 rm -f conftest.$ac_ext
3439 EXEEXT=$ac_cv_exeext
3440 ac_exeext=$EXEEXT
3441 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3442 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3443 if test "${ac_cv_objext+set}" = set; then
3444   echo $ECHO_N "(cached) $ECHO_C" >&6
3445 else
3446   cat >conftest.$ac_ext <<_ACEOF
3447 /* confdefs.h.  */
3448 _ACEOF
3449 cat confdefs.h >>conftest.$ac_ext
3450 cat >>conftest.$ac_ext <<_ACEOF
3451 /* end confdefs.h.  */
3452
3453 int
3454 main ()
3455 {
3456
3457   ;
3458   return 0;
3459 }
3460 _ACEOF
3461 rm -f conftest.o conftest.obj
3462 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3463   (eval $ac_compile) 2>&5
3464   ac_status=$?
3465   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3466   (exit $ac_status); }; then
3467   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3468   case $ac_file in
3469     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3470     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3471        break;;
3472   esac
3473 done
3474 else
3475   echo "$as_me: failed program was:" >&5
3476 sed 's/^/| /' conftest.$ac_ext >&5
3477
3478 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3479 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3480 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3481 See \`config.log' for more details." >&5
3482 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3483 See \`config.log' for more details." >&2;}
3484    { (exit 1); exit 1; }; }; }
3485 fi
3486
3487 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3488 fi
3489 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3490 echo "${ECHO_T}$ac_cv_objext" >&6
3491 OBJEXT=$ac_cv_objext
3492 ac_objext=$OBJEXT
3493 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3494 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3495 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3496   echo $ECHO_N "(cached) $ECHO_C" >&6
3497 else
3498   cat >conftest.$ac_ext <<_ACEOF
3499 /* confdefs.h.  */
3500 _ACEOF
3501 cat confdefs.h >>conftest.$ac_ext
3502 cat >>conftest.$ac_ext <<_ACEOF
3503 /* end confdefs.h.  */
3504
3505 int
3506 main ()
3507 {
3508 #ifndef __GNUC__
3509        choke me
3510 #endif
3511
3512   ;
3513   return 0;
3514 }
3515 _ACEOF
3516 rm -f conftest.$ac_objext
3517 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3518   (eval $ac_compile) 2>conftest.er1
3519   ac_status=$?
3520   grep -v '^ *+' conftest.er1 >conftest.err
3521   rm -f conftest.er1
3522   cat conftest.err >&5
3523   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3524   (exit $ac_status); } &&
3525          { ac_try='test -z "$ac_c_werror_flag"
3526                          || test ! -s conftest.err'
3527   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3528   (eval $ac_try) 2>&5
3529   ac_status=$?
3530   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3531   (exit $ac_status); }; } &&
3532          { ac_try='test -s conftest.$ac_objext'
3533   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3534   (eval $ac_try) 2>&5
3535   ac_status=$?
3536   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3537   (exit $ac_status); }; }; then
3538   ac_compiler_gnu=yes
3539 else
3540   echo "$as_me: failed program was:" >&5
3541 sed 's/^/| /' conftest.$ac_ext >&5
3542
3543 ac_compiler_gnu=no
3544 fi
3545 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3546 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3547
3548 fi
3549 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3550 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3551 GCC=`test $ac_compiler_gnu = yes && echo yes`
3552 ac_test_CFLAGS=${CFLAGS+set}
3553 ac_save_CFLAGS=$CFLAGS
3554 CFLAGS="-g"
3555 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3556 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3557 if test "${ac_cv_prog_cc_g+set}" = set; then
3558   echo $ECHO_N "(cached) $ECHO_C" >&6
3559 else
3560   cat >conftest.$ac_ext <<_ACEOF
3561 /* confdefs.h.  */
3562 _ACEOF
3563 cat confdefs.h >>conftest.$ac_ext
3564 cat >>conftest.$ac_ext <<_ACEOF
3565 /* end confdefs.h.  */
3566
3567 int
3568 main ()
3569 {
3570
3571   ;
3572   return 0;
3573 }
3574 _ACEOF
3575 rm -f conftest.$ac_objext
3576 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3577   (eval $ac_compile) 2>conftest.er1
3578   ac_status=$?
3579   grep -v '^ *+' conftest.er1 >conftest.err
3580   rm -f conftest.er1
3581   cat conftest.err >&5
3582   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3583   (exit $ac_status); } &&
3584          { ac_try='test -z "$ac_c_werror_flag"
3585                          || test ! -s conftest.err'
3586   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3587   (eval $ac_try) 2>&5
3588   ac_status=$?
3589   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3590   (exit $ac_status); }; } &&
3591          { ac_try='test -s conftest.$ac_objext'
3592   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3593   (eval $ac_try) 2>&5
3594   ac_status=$?
3595   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3596   (exit $ac_status); }; }; then
3597   ac_cv_prog_cc_g=yes
3598 else
3599   echo "$as_me: failed program was:" >&5
3600 sed 's/^/| /' conftest.$ac_ext >&5
3601
3602 ac_cv_prog_cc_g=no
3603 fi
3604 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3605 fi
3606 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3607 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3608 if test "$ac_test_CFLAGS" = set; then
3609   CFLAGS=$ac_save_CFLAGS
3610 elif test $ac_cv_prog_cc_g = yes; then
3611   if test "$GCC" = yes; then
3612     CFLAGS="-g -O2"
3613   else
3614     CFLAGS="-g"
3615   fi
3616 else
3617   if test "$GCC" = yes; then
3618     CFLAGS="-O2"
3619   else
3620     CFLAGS=
3621   fi
3622 fi
3623 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3624 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3625 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3626   echo $ECHO_N "(cached) $ECHO_C" >&6
3627 else
3628   ac_cv_prog_cc_stdc=no
3629 ac_save_CC=$CC
3630 cat >conftest.$ac_ext <<_ACEOF
3631 /* confdefs.h.  */
3632 _ACEOF
3633 cat confdefs.h >>conftest.$ac_ext
3634 cat >>conftest.$ac_ext <<_ACEOF
3635 /* end confdefs.h.  */
3636 #include <stdarg.h>
3637 #include <stdio.h>
3638 #include <sys/types.h>
3639 #include <sys/stat.h>
3640 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3641 struct buf { int x; };
3642 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3643 static char *e (p, i)
3644      char **p;
3645      int i;
3646 {
3647   return p[i];
3648 }
3649 static char *f (char * (*g) (char **, int), char **p, ...)
3650 {
3651   char *s;
3652   va_list v;
3653   va_start (v,p);
3654   s = g (p, va_arg (v,int));
3655   va_end (v);
3656   return s;
3657 }
3658
3659 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3660    function prototypes and stuff, but not '\xHH' hex character constants.
3661    These don't provoke an error unfortunately, instead are silently treated
3662    as 'x'.  The following induces an error, until -std1 is added to get
3663    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3664    array size at least.  It's necessary to write '\x00'==0 to get something
3665    that's true only with -std1.  */
3666 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3667
3668 int test (int i, double x);
3669 struct s1 {int (*f) (int a);};
3670 struct s2 {int (*f) (double a);};
3671 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3672 int argc;
3673 char **argv;
3674 int
3675 main ()
3676 {
3677 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3678   ;
3679   return 0;
3680 }
3681 _ACEOF
3682 # Don't try gcc -ansi; that turns off useful extensions and
3683 # breaks some systems' header files.
3684 # AIX                   -qlanglvl=ansi
3685 # Ultrix and OSF/1      -std1
3686 # HP-UX 10.20 and later -Ae
3687 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3688 # SVR4                  -Xc -D__EXTENSIONS__
3689 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3690 do
3691   CC="$ac_save_CC $ac_arg"
3692   rm -f conftest.$ac_objext
3693 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3694   (eval $ac_compile) 2>conftest.er1
3695   ac_status=$?
3696   grep -v '^ *+' conftest.er1 >conftest.err
3697   rm -f conftest.er1
3698   cat conftest.err >&5
3699   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3700   (exit $ac_status); } &&
3701          { ac_try='test -z "$ac_c_werror_flag"
3702                          || test ! -s conftest.err'
3703   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3704   (eval $ac_try) 2>&5
3705   ac_status=$?
3706   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3707   (exit $ac_status); }; } &&
3708          { ac_try='test -s conftest.$ac_objext'
3709   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3710   (eval $ac_try) 2>&5
3711   ac_status=$?
3712   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3713   (exit $ac_status); }; }; then
3714   ac_cv_prog_cc_stdc=$ac_arg
3715 break
3716 else
3717   echo "$as_me: failed program was:" >&5
3718 sed 's/^/| /' conftest.$ac_ext >&5
3719
3720 fi
3721 rm -f conftest.err conftest.$ac_objext
3722 done
3723 rm -f conftest.$ac_ext conftest.$ac_objext
3724 CC=$ac_save_CC
3725
3726 fi
3727
3728 case "x$ac_cv_prog_cc_stdc" in
3729   x|xno)
3730     echo "$as_me:$LINENO: result: none needed" >&5
3731 echo "${ECHO_T}none needed" >&6 ;;
3732   *)
3733     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3734 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3735     CC="$CC $ac_cv_prog_cc_stdc" ;;
3736 esac
3737
3738 # Some people use a C++ compiler to compile C.  Since we use `exit',
3739 # in C++ we need to declare it.  In case someone uses the same compiler
3740 # for both compiling C and C++ we need to have the C++ compiler decide
3741 # the declaration of exit, since it's the most demanding environment.
3742 cat >conftest.$ac_ext <<_ACEOF
3743 #ifndef __cplusplus
3744   choke me
3745 #endif
3746 _ACEOF
3747 rm -f conftest.$ac_objext
3748 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3749   (eval $ac_compile) 2>conftest.er1
3750   ac_status=$?
3751   grep -v '^ *+' conftest.er1 >conftest.err
3752   rm -f conftest.er1
3753   cat conftest.err >&5
3754   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3755   (exit $ac_status); } &&
3756          { ac_try='test -z "$ac_c_werror_flag"
3757                          || test ! -s conftest.err'
3758   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3759   (eval $ac_try) 2>&5
3760   ac_status=$?
3761   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3762   (exit $ac_status); }; } &&
3763          { ac_try='test -s conftest.$ac_objext'
3764   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3765   (eval $ac_try) 2>&5
3766   ac_status=$?
3767   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3768   (exit $ac_status); }; }; then
3769   for ac_declaration in \
3770    '' \
3771    'extern "C" void std::exit (int) throw (); using std::exit;' \
3772    'extern "C" void std::exit (int); using std::exit;' \
3773    'extern "C" void exit (int) throw ();' \
3774    'extern "C" void exit (int);' \
3775    'void exit (int);'
3776 do
3777   cat >conftest.$ac_ext <<_ACEOF
3778 /* confdefs.h.  */
3779 _ACEOF
3780 cat confdefs.h >>conftest.$ac_ext
3781 cat >>conftest.$ac_ext <<_ACEOF
3782 /* end confdefs.h.  */
3783 $ac_declaration
3784 #include <stdlib.h>
3785 int
3786 main ()
3787 {
3788 exit (42);
3789   ;
3790   return 0;
3791 }
3792 _ACEOF
3793 rm -f conftest.$ac_objext
3794 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3795   (eval $ac_compile) 2>conftest.er1
3796   ac_status=$?
3797   grep -v '^ *+' conftest.er1 >conftest.err
3798   rm -f conftest.er1
3799   cat conftest.err >&5
3800   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3801   (exit $ac_status); } &&
3802          { ac_try='test -z "$ac_c_werror_flag"
3803                          || test ! -s conftest.err'
3804   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3805   (eval $ac_try) 2>&5
3806   ac_status=$?
3807   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3808   (exit $ac_status); }; } &&
3809          { ac_try='test -s conftest.$ac_objext'
3810   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3811   (eval $ac_try) 2>&5
3812   ac_status=$?
3813   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3814   (exit $ac_status); }; }; then
3815   :
3816 else
3817   echo "$as_me: failed program was:" >&5
3818 sed 's/^/| /' conftest.$ac_ext >&5
3819
3820 continue
3821 fi
3822 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3823   cat >conftest.$ac_ext <<_ACEOF
3824 /* confdefs.h.  */
3825 _ACEOF
3826 cat confdefs.h >>conftest.$ac_ext
3827 cat >>conftest.$ac_ext <<_ACEOF
3828 /* end confdefs.h.  */
3829 $ac_declaration
3830 int
3831 main ()
3832 {
3833 exit (42);
3834   ;
3835   return 0;
3836 }
3837 _ACEOF
3838 rm -f conftest.$ac_objext
3839 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3840   (eval $ac_compile) 2>conftest.er1
3841   ac_status=$?
3842   grep -v '^ *+' conftest.er1 >conftest.err
3843   rm -f conftest.er1
3844   cat conftest.err >&5
3845   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3846   (exit $ac_status); } &&
3847          { ac_try='test -z "$ac_c_werror_flag"
3848                          || test ! -s conftest.err'
3849   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3850   (eval $ac_try) 2>&5
3851   ac_status=$?
3852   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3853   (exit $ac_status); }; } &&
3854          { ac_try='test -s conftest.$ac_objext'
3855   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3856   (eval $ac_try) 2>&5
3857   ac_status=$?
3858   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3859   (exit $ac_status); }; }; then
3860   break
3861 else
3862   echo "$as_me: failed program was:" >&5
3863 sed 's/^/| /' conftest.$ac_ext >&5
3864
3865 fi
3866 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3867 done
3868 rm -f conftest*
3869 if test -n "$ac_declaration"; then
3870   echo '#ifdef __cplusplus' >>confdefs.h
3871   echo $ac_declaration      >>confdefs.h
3872   echo '#endif'             >>confdefs.h
3873 fi
3874
3875 else
3876   echo "$as_me: failed program was:" >&5
3877 sed 's/^/| /' conftest.$ac_ext >&5
3878
3879 fi
3880 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3881 ac_ext=c
3882 ac_cpp='$CPP $CPPFLAGS'
3883 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3884 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3885 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3886
3887 ac_ext=cc
3888 ac_cpp='$CXXCPP $CPPFLAGS'
3889 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3890 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3891 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3892 if test -n "$ac_tool_prefix"; then
3893   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3894   do
3895     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3896 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3897 echo "$as_me:$LINENO: checking for $ac_word" >&5
3898 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3899 if test "${ac_cv_prog_CXX+set}" = set; then
3900   echo $ECHO_N "(cached) $ECHO_C" >&6
3901 else
3902   if test -n "$CXX"; then
3903   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3904 else
3905 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3906 for as_dir in $PATH
3907 do
3908   IFS=$as_save_IFS
3909   test -z "$as_dir" && as_dir=.
3910   for ac_exec_ext in '' $ac_executable_extensions; do
3911   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3912     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3913     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3914     break 2
3915   fi
3916 done
3917 done
3918
3919 fi
3920 fi
3921 CXX=$ac_cv_prog_CXX
3922 if test -n "$CXX"; then
3923   echo "$as_me:$LINENO: result: $CXX" >&5
3924 echo "${ECHO_T}$CXX" >&6
3925 else
3926   echo "$as_me:$LINENO: result: no" >&5
3927 echo "${ECHO_T}no" >&6
3928 fi
3929
3930     test -n "$CXX" && break
3931   done
3932 fi
3933 if test -z "$CXX"; then
3934   ac_ct_CXX=$CXX
3935   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3936 do
3937   # Extract the first word of "$ac_prog", so it can be a program name with args.
3938 set dummy $ac_prog; ac_word=$2
3939 echo "$as_me:$LINENO: checking for $ac_word" >&5
3940 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3941 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3942   echo $ECHO_N "(cached) $ECHO_C" >&6
3943 else
3944   if test -n "$ac_ct_CXX"; then
3945   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3946 else
3947 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3948 for as_dir in $PATH
3949 do
3950   IFS=$as_save_IFS
3951   test -z "$as_dir" && as_dir=.
3952   for ac_exec_ext in '' $ac_executable_extensions; do
3953   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3954     ac_cv_prog_ac_ct_CXX="$ac_prog"
3955     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3956     break 2
3957   fi
3958 done
3959 done
3960
3961 fi
3962 fi
3963 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3964 if test -n "$ac_ct_CXX"; then
3965   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3966 echo "${ECHO_T}$ac_ct_CXX" >&6
3967 else
3968   echo "$as_me:$LINENO: result: no" >&5
3969 echo "${ECHO_T}no" >&6
3970 fi
3971
3972   test -n "$ac_ct_CXX" && break
3973 done
3974 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3975
3976   CXX=$ac_ct_CXX
3977 fi
3978
3979
3980 # Provide some information about the compiler.
3981 echo "$as_me:$LINENO:" \
3982      "checking for C++ compiler version" >&5
3983 ac_compiler=`set X $ac_compile; echo $2`
3984 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3985   (eval $ac_compiler --version </dev/null >&5) 2>&5
3986   ac_status=$?
3987   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3988   (exit $ac_status); }
3989 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3990   (eval $ac_compiler -v </dev/null >&5) 2>&5
3991   ac_status=$?
3992   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3993   (exit $ac_status); }
3994 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3995   (eval $ac_compiler -V </dev/null >&5) 2>&5
3996   ac_status=$?
3997   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3998   (exit $ac_status); }
3999
4000 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4001 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4002 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4003   echo $ECHO_N "(cached) $ECHO_C" >&6
4004 else
4005   cat >conftest.$ac_ext <<_ACEOF
4006 /* confdefs.h.  */
4007 _ACEOF
4008 cat confdefs.h >>conftest.$ac_ext
4009 cat >>conftest.$ac_ext <<_ACEOF
4010 /* end confdefs.h.  */
4011
4012 int
4013 main ()
4014 {
4015 #ifndef __GNUC__
4016        choke me
4017 #endif
4018
4019   ;
4020   return 0;
4021 }
4022 _ACEOF
4023 rm -f conftest.$ac_objext
4024 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4025   (eval $ac_compile) 2>conftest.er1
4026   ac_status=$?
4027   grep -v '^ *+' conftest.er1 >conftest.err
4028   rm -f conftest.er1
4029   cat conftest.err >&5
4030   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4031   (exit $ac_status); } &&
4032          { ac_try='test -z "$ac_cxx_werror_flag"
4033                          || test ! -s conftest.err'
4034   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4035   (eval $ac_try) 2>&5
4036   ac_status=$?
4037   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4038   (exit $ac_status); }; } &&
4039          { ac_try='test -s conftest.$ac_objext'
4040   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4041   (eval $ac_try) 2>&5
4042   ac_status=$?
4043   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4044   (exit $ac_status); }; }; then
4045   ac_compiler_gnu=yes
4046 else
4047   echo "$as_me: failed program was:" >&5
4048 sed 's/^/| /' conftest.$ac_ext >&5
4049
4050 ac_compiler_gnu=no
4051 fi
4052 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4053 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4054
4055 fi
4056 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4057 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4058 GXX=`test $ac_compiler_gnu = yes && echo yes`
4059 ac_test_CXXFLAGS=${CXXFLAGS+set}
4060 ac_save_CXXFLAGS=$CXXFLAGS
4061 CXXFLAGS="-g"
4062 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4063 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4064 if test "${ac_cv_prog_cxx_g+set}" = set; then
4065   echo $ECHO_N "(cached) $ECHO_C" >&6
4066 else
4067   cat >conftest.$ac_ext <<_ACEOF
4068 /* confdefs.h.  */
4069 _ACEOF
4070 cat confdefs.h >>conftest.$ac_ext
4071 cat >>conftest.$ac_ext <<_ACEOF
4072 /* end confdefs.h.  */
4073
4074 int
4075 main ()
4076 {
4077
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   ac_cv_prog_cxx_g=yes
4105 else
4106   echo "$as_me: failed program was:" >&5
4107 sed 's/^/| /' conftest.$ac_ext >&5
4108
4109 ac_cv_prog_cxx_g=no
4110 fi
4111 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4112 fi
4113 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4114 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4115 if test "$ac_test_CXXFLAGS" = set; then
4116   CXXFLAGS=$ac_save_CXXFLAGS
4117 elif test $ac_cv_prog_cxx_g = yes; then
4118   if test "$GXX" = yes; then
4119     CXXFLAGS="-g -O2"
4120   else
4121     CXXFLAGS="-g"
4122   fi
4123 else
4124   if test "$GXX" = yes; then
4125     CXXFLAGS="-O2"
4126   else
4127     CXXFLAGS=
4128   fi
4129 fi
4130 for ac_declaration in \
4131    '' \
4132    'extern "C" void std::exit (int) throw (); using std::exit;' \
4133    'extern "C" void std::exit (int); using std::exit;' \
4134    'extern "C" void exit (int) throw ();' \
4135    'extern "C" void exit (int);' \
4136    'void exit (int);'
4137 do
4138   cat >conftest.$ac_ext <<_ACEOF
4139 /* confdefs.h.  */
4140 _ACEOF
4141 cat confdefs.h >>conftest.$ac_ext
4142 cat >>conftest.$ac_ext <<_ACEOF
4143 /* end confdefs.h.  */
4144 $ac_declaration
4145 #include <stdlib.h>
4146 int
4147 main ()
4148 {
4149 exit (42);
4150   ;
4151   return 0;
4152 }
4153 _ACEOF
4154 rm -f conftest.$ac_objext
4155 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4156   (eval $ac_compile) 2>conftest.er1
4157   ac_status=$?
4158   grep -v '^ *+' conftest.er1 >conftest.err
4159   rm -f conftest.er1
4160   cat conftest.err >&5
4161   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4162   (exit $ac_status); } &&
4163          { ac_try='test -z "$ac_cxx_werror_flag"
4164                          || test ! -s conftest.err'
4165   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4166   (eval $ac_try) 2>&5
4167   ac_status=$?
4168   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4169   (exit $ac_status); }; } &&
4170          { ac_try='test -s conftest.$ac_objext'
4171   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4172   (eval $ac_try) 2>&5
4173   ac_status=$?
4174   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4175   (exit $ac_status); }; }; then
4176   :
4177 else
4178   echo "$as_me: failed program was:" >&5
4179 sed 's/^/| /' conftest.$ac_ext >&5
4180
4181 continue
4182 fi
4183 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4184   cat >conftest.$ac_ext <<_ACEOF
4185 /* confdefs.h.  */
4186 _ACEOF
4187 cat confdefs.h >>conftest.$ac_ext
4188 cat >>conftest.$ac_ext <<_ACEOF
4189 /* end confdefs.h.  */
4190 $ac_declaration
4191 int
4192 main ()
4193 {
4194 exit (42);
4195   ;
4196   return 0;
4197 }
4198 _ACEOF
4199 rm -f conftest.$ac_objext
4200 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4201   (eval $ac_compile) 2>conftest.er1
4202   ac_status=$?
4203   grep -v '^ *+' conftest.er1 >conftest.err
4204   rm -f conftest.er1
4205   cat conftest.err >&5
4206   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4207   (exit $ac_status); } &&
4208          { ac_try='test -z "$ac_cxx_werror_flag"
4209                          || test ! -s conftest.err'
4210   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4211   (eval $ac_try) 2>&5
4212   ac_status=$?
4213   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4214   (exit $ac_status); }; } &&
4215          { ac_try='test -s conftest.$ac_objext'
4216   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4217   (eval $ac_try) 2>&5
4218   ac_status=$?
4219   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4220   (exit $ac_status); }; }; then
4221   break
4222 else
4223   echo "$as_me: failed program was:" >&5
4224 sed 's/^/| /' conftest.$ac_ext >&5
4225
4226 fi
4227 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4228 done
4229 rm -f conftest*
4230 if test -n "$ac_declaration"; then
4231   echo '#ifdef __cplusplus' >>confdefs.h
4232   echo $ac_declaration      >>confdefs.h
4233   echo '#endif'             >>confdefs.h
4234 fi
4235
4236 ac_ext=c
4237 ac_cpp='$CPP $CPPFLAGS'
4238 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4239 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4240 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4241
4242
4243 # We must set the default linker to the linker used by gcc for the correct
4244 # operation of libtool.  If LD is not defined and we are using gcc, try to
4245 # set the LD default to the ld used by gcc.
4246 if test -z "$LD"; then
4247   if test "$GCC" = yes; then
4248     case $build in
4249     *-*-mingw*)
4250       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4251     *)
4252       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4253     esac
4254     case $gcc_prog_ld in
4255     # Accept absolute paths.
4256     [\\/]* | [A-Za-z]:[\\/]*)
4257       LD="$gcc_prog_ld" ;;
4258     esac
4259   fi
4260 fi
4261
4262
4263
4264
4265 if test -n "$ac_tool_prefix"; then
4266   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4267 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4268 echo "$as_me:$LINENO: checking for $ac_word" >&5
4269 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4270 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4271   echo $ECHO_N "(cached) $ECHO_C" >&6
4272 else
4273   if test -n "$GNATBIND"; then
4274   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4275 else
4276 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4277 for as_dir in $PATH
4278 do
4279   IFS=$as_save_IFS
4280   test -z "$as_dir" && as_dir=.
4281   for ac_exec_ext in '' $ac_executable_extensions; do
4282   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4283     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4284     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4285     break 2
4286   fi
4287 done
4288 done
4289
4290 fi
4291 fi
4292 GNATBIND=$ac_cv_prog_GNATBIND
4293 if test -n "$GNATBIND"; then
4294   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4295 echo "${ECHO_T}$GNATBIND" >&6
4296 else
4297   echo "$as_me:$LINENO: result: no" >&5
4298 echo "${ECHO_T}no" >&6
4299 fi
4300
4301 fi
4302 if test -z "$ac_cv_prog_GNATBIND"; then
4303   ac_ct_GNATBIND=$GNATBIND
4304   # Extract the first word of "gnatbind", so it can be a program name with args.
4305 set dummy gnatbind; ac_word=$2
4306 echo "$as_me:$LINENO: checking for $ac_word" >&5
4307 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4308 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4309   echo $ECHO_N "(cached) $ECHO_C" >&6
4310 else
4311   if test -n "$ac_ct_GNATBIND"; then
4312   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4313 else
4314 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4315 for as_dir in $PATH
4316 do
4317   IFS=$as_save_IFS
4318   test -z "$as_dir" && as_dir=.
4319   for ac_exec_ext in '' $ac_executable_extensions; do
4320   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4321     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4322     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4323     break 2
4324   fi
4325 done
4326 done
4327
4328   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4329 fi
4330 fi
4331 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4332 if test -n "$ac_ct_GNATBIND"; then
4333   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4334 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4335 else
4336   echo "$as_me:$LINENO: result: no" >&5
4337 echo "${ECHO_T}no" >&6
4338 fi
4339
4340   GNATBIND=$ac_ct_GNATBIND
4341 else
4342   GNATBIND="$ac_cv_prog_GNATBIND"
4343 fi
4344
4345 if test -n "$ac_tool_prefix"; then
4346   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4347 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4348 echo "$as_me:$LINENO: checking for $ac_word" >&5
4349 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4350 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4351   echo $ECHO_N "(cached) $ECHO_C" >&6
4352 else
4353   if test -n "$GNATMAKE"; then
4354   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4355 else
4356 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4357 for as_dir in $PATH
4358 do
4359   IFS=$as_save_IFS
4360   test -z "$as_dir" && as_dir=.
4361   for ac_exec_ext in '' $ac_executable_extensions; do
4362   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4363     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4364     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4365     break 2
4366   fi
4367 done
4368 done
4369
4370 fi
4371 fi
4372 GNATMAKE=$ac_cv_prog_GNATMAKE
4373 if test -n "$GNATMAKE"; then
4374   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4375 echo "${ECHO_T}$GNATMAKE" >&6
4376 else
4377   echo "$as_me:$LINENO: result: no" >&5
4378 echo "${ECHO_T}no" >&6
4379 fi
4380
4381 fi
4382 if test -z "$ac_cv_prog_GNATMAKE"; then
4383   ac_ct_GNATMAKE=$GNATMAKE
4384   # Extract the first word of "gnatmake", so it can be a program name with args.
4385 set dummy gnatmake; ac_word=$2
4386 echo "$as_me:$LINENO: checking for $ac_word" >&5
4387 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4388 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4389   echo $ECHO_N "(cached) $ECHO_C" >&6
4390 else
4391   if test -n "$ac_ct_GNATMAKE"; then
4392   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4393 else
4394 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4395 for as_dir in $PATH
4396 do
4397   IFS=$as_save_IFS
4398   test -z "$as_dir" && as_dir=.
4399   for ac_exec_ext in '' $ac_executable_extensions; do
4400   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4401     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4402     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4403     break 2
4404   fi
4405 done
4406 done
4407
4408   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4409 fi
4410 fi
4411 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4412 if test -n "$ac_ct_GNATMAKE"; then
4413   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4414 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4415 else
4416   echo "$as_me:$LINENO: result: no" >&5
4417 echo "${ECHO_T}no" >&6
4418 fi
4419
4420   GNATMAKE=$ac_ct_GNATMAKE
4421 else
4422   GNATMAKE="$ac_cv_prog_GNATMAKE"
4423 fi
4424
4425 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4426 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4427 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4428   echo $ECHO_N "(cached) $ECHO_C" >&6
4429 else
4430   cat >conftest.adb <<EOF
4431 procedure conftest is begin null; end conftest;
4432 EOF
4433 acx_cv_cc_gcc_supports_ada=no
4434 # There is a bug in old released versions of GCC which causes the
4435 # driver to exit successfully when the appropriate language module
4436 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4437 # Therefore we must check for the error message as well as an
4438 # unsuccessful exit.
4439 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4440 # given a .adb file, but produce no object file.  So we must check
4441 # if an object file was really produced to guard against this.
4442 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4443 if test x"$errors" = x && test -f conftest.$ac_objext; then
4444   acx_cv_cc_gcc_supports_ada=yes
4445 fi
4446 rm -f conftest.*
4447 fi
4448 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4449 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4450
4451 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4452   have_gnat=yes
4453 else
4454   have_gnat=no
4455 fi
4456
4457 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4458 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4459 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4460   echo $ECHO_N "(cached) $ECHO_C" >&6
4461 else
4462    echo abfoo >t1
4463   echo cdfoo >t2
4464   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4465   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4466     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4467       :
4468     else
4469       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4470     fi
4471   fi
4472   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4473     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4474       :
4475     else
4476       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4477     fi
4478   fi
4479   rm t1 t2
4480
4481 fi
4482 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4483 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4484 do_compare="$gcc_cv_prog_cmp_skip"
4485
4486
4487
4488 # Check for GMP and MPFR
4489 gmplibs="-lmpfr -lgmp"
4490 gmpinc=
4491 have_gmp=no
4492
4493 # Specify a location for mpfr
4494 # check for this first so it ends up on the link line before gmp.
4495
4496 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4497 if test "${with_mpfr_dir+set}" = set; then
4498   withval="$with_mpfr_dir"
4499   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4500 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4501 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4502 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4503    { (exit 1); exit 1; }; }
4504 fi;
4505
4506
4507 # Check whether --with-mpfr or --without-mpfr was given.
4508 if test "${with_mpfr+set}" = set; then
4509   withval="$with_mpfr"
4510
4511 fi;
4512
4513 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4514 if test "${with_mpfr_include+set}" = set; then
4515   withval="$with_mpfr_include"
4516
4517 fi;
4518
4519 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4520 if test "${with_mpfr_lib+set}" = set; then
4521   withval="$with_mpfr_lib"
4522
4523 fi;
4524
4525 if test "x$with_mpfr" != x; then
4526   gmplibs="-L$with_mpfr/lib $gmplibs"
4527   gmpinc="-I$with_mpfr/include"
4528 fi
4529 if test "x$with_mpfr_include" != x; then
4530   gmpinc="-I$with_mpfr_include"
4531 fi
4532 if test "x$with_mpfr_lib" != x; then
4533   gmplibs="-L$with_mpfr_lib $gmplibs"
4534 fi
4535 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4536   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4537   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4538   # Do not test the mpfr version.  Assume that it is sufficient, since
4539   # it is in the source tree, and the library has not been built yet
4540   # but it would be included on the link line in the version check below
4541   # hence making the test fail.
4542   have_gmp=yes
4543 fi
4544
4545 # Specify a location for gmp
4546
4547 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4548 if test "${with_gmp_dir+set}" = set; then
4549   withval="$with_gmp_dir"
4550   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4551 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4552 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4553 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4554    { (exit 1); exit 1; }; }
4555 fi;
4556
4557
4558 # Check whether --with-gmp or --without-gmp was given.
4559 if test "${with_gmp+set}" = set; then
4560   withval="$with_gmp"
4561
4562 fi;
4563
4564 # Check whether --with-gmp_include or --without-gmp_include was given.
4565 if test "${with_gmp_include+set}" = set; then
4566   withval="$with_gmp_include"
4567
4568 fi;
4569
4570 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4571 if test "${with_gmp_lib+set}" = set; then
4572   withval="$with_gmp_lib"
4573
4574 fi;
4575
4576
4577 if test "x$with_gmp" != x; then
4578   gmplibs="-L$with_gmp/lib $gmplibs"
4579   gmpinc="-I$with_gmp/include $gmpinc"
4580 fi
4581 if test "x$with_gmp_include" != x; then
4582   gmpinc="-I$with_gmp_include $gmpinc"
4583 fi
4584 if test "x$with_gmp_lib" != x; then
4585   gmplibs="-L$with_gmp_lib $gmplibs"
4586 fi
4587 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4588   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4589   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4590   # Do not test the gmp version.  Assume that it is sufficient, since
4591   # it is in the source tree, and the library has not been built yet
4592   # but it would be included on the link line in the version check below
4593   # hence making the test fail.
4594   have_gmp=yes
4595 fi
4596
4597 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4598   have_gmp=yes
4599   saved_CFLAGS="$CFLAGS"
4600   CFLAGS="$CFLAGS $gmpinc"
4601   # Check GMP actually works
4602   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4603 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4604
4605 cat >conftest.$ac_ext <<_ACEOF
4606 /* confdefs.h.  */
4607 _ACEOF
4608 cat confdefs.h >>conftest.$ac_ext
4609 cat >>conftest.$ac_ext <<_ACEOF
4610 /* end confdefs.h.  */
4611 #include "gmp.h"
4612 int
4613 main ()
4614 {
4615
4616   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4617   choke me
4618   #endif
4619
4620   ;
4621   return 0;
4622 }
4623 _ACEOF
4624 rm -f conftest.$ac_objext
4625 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4626   (eval $ac_compile) 2>conftest.er1
4627   ac_status=$?
4628   grep -v '^ *+' conftest.er1 >conftest.err
4629   rm -f conftest.er1
4630   cat conftest.err >&5
4631   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4632   (exit $ac_status); } &&
4633          { ac_try='test -z "$ac_c_werror_flag"
4634                          || test ! -s conftest.err'
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); }; } &&
4640          { ac_try='test -s conftest.$ac_objext'
4641   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4642   (eval $ac_try) 2>&5
4643   ac_status=$?
4644   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4645   (exit $ac_status); }; }; then
4646   echo "$as_me:$LINENO: result: yes" >&5
4647 echo "${ECHO_T}yes" >&6
4648 else
4649   echo "$as_me: failed program was:" >&5
4650 sed 's/^/| /' conftest.$ac_ext >&5
4651
4652 echo "$as_me:$LINENO: result: no" >&5
4653 echo "${ECHO_T}no" >&6; have_gmp=no
4654 fi
4655 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4656
4657   if test x"$have_gmp" = xyes; then
4658     saved_LIBS="$LIBS"
4659     LIBS="$LIBS $gmplibs"
4660         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4661 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4662     cat >conftest.$ac_ext <<_ACEOF
4663 /* confdefs.h.  */
4664 _ACEOF
4665 cat confdefs.h >>conftest.$ac_ext
4666 cat >>conftest.$ac_ext <<_ACEOF
4667 /* end confdefs.h.  */
4668 #include <gmp.h>
4669     #include <mpfr.h>
4670 int
4671 main ()
4672 {
4673
4674     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4675     choke me
4676     #endif
4677     mpfr_t n;
4678     mpfr_t x;
4679     int t;
4680     mpfr_init (n);
4681     mpfr_init (x);
4682     mpfr_atan2 (n, n, x, GMP_RNDN);
4683     mpfr_erfc (n, x, GMP_RNDN);
4684     mpfr_subnormalize (x, t, GMP_RNDN);
4685
4686   ;
4687   return 0;
4688 }
4689 _ACEOF
4690 rm -f conftest.$ac_objext conftest$ac_exeext
4691 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4692   (eval $ac_link) 2>conftest.er1
4693   ac_status=$?
4694   grep -v '^ *+' conftest.er1 >conftest.err
4695   rm -f conftest.er1
4696   cat conftest.err >&5
4697   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4698   (exit $ac_status); } &&
4699          { ac_try='test -z "$ac_c_werror_flag"
4700                          || test ! -s conftest.err'
4701   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4702   (eval $ac_try) 2>&5
4703   ac_status=$?
4704   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4705   (exit $ac_status); }; } &&
4706          { ac_try='test -s conftest$ac_exeext'
4707   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4708   (eval $ac_try) 2>&5
4709   ac_status=$?
4710   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4711   (exit $ac_status); }; }; then
4712   cat >conftest.$ac_ext <<_ACEOF
4713 /* confdefs.h.  */
4714 _ACEOF
4715 cat confdefs.h >>conftest.$ac_ext
4716 cat >>conftest.$ac_ext <<_ACEOF
4717 /* end confdefs.h.  */
4718 #include <gmp.h>
4719     #include <mpfr.h>
4720 int
4721 main ()
4722 {
4723
4724     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4725     choke me
4726     #endif
4727     mpfr_t n; mpfr_init(n);
4728
4729   ;
4730   return 0;
4731 }
4732 _ACEOF
4733 rm -f conftest.$ac_objext conftest$ac_exeext
4734 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4735   (eval $ac_link) 2>conftest.er1
4736   ac_status=$?
4737   grep -v '^ *+' conftest.er1 >conftest.err
4738   rm -f conftest.er1
4739   cat conftest.err >&5
4740   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4741   (exit $ac_status); } &&
4742          { ac_try='test -z "$ac_c_werror_flag"
4743                          || test ! -s conftest.err'
4744   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4745   (eval $ac_try) 2>&5
4746   ac_status=$?
4747   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4748   (exit $ac_status); }; } &&
4749          { ac_try='test -s conftest$ac_exeext'
4750   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4751   (eval $ac_try) 2>&5
4752   ac_status=$?
4753   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4754   (exit $ac_status); }; }; then
4755   echo "$as_me:$LINENO: result: yes" >&5
4756 echo "${ECHO_T}yes" >&6
4757 else
4758   echo "$as_me: failed program was:" >&5
4759 sed 's/^/| /' conftest.$ac_ext >&5
4760
4761 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4762 echo "${ECHO_T}buggy but acceptable" >&6
4763 fi
4764 rm -f conftest.err conftest.$ac_objext \
4765       conftest$ac_exeext conftest.$ac_ext
4766 else
4767   echo "$as_me: failed program was:" >&5
4768 sed 's/^/| /' conftest.$ac_ext >&5
4769
4770 echo "$as_me:$LINENO: result: no" >&5
4771 echo "${ECHO_T}no" >&6; have_gmp=no
4772 fi
4773 rm -f conftest.err conftest.$ac_objext \
4774       conftest$ac_exeext conftest.$ac_ext
4775       LIBS="$saved_LIBS"
4776   fi
4777   CFLAGS="$saved_CFLAGS"
4778
4779   if test x$have_gmp != xyes; then
4780     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.2+.
4781 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4782 Copies of these libraries' source code can be found at their respective
4783 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4784 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4785 If you obtained GMP and/or MPFR from a vendor distribution package, make
4786 sure that you have installed both the libraries and the header files.
4787 They may be located in separate packages." >&5
4788 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.2+.
4789 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4790 Copies of these libraries' source code can be found at their respective
4791 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4792 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4793 If you obtained GMP and/or MPFR from a vendor distribution package, make
4794 sure that you have installed both the libraries and the header files.
4795 They may be located in separate packages." >&2;}
4796    { (exit 1); exit 1; }; }
4797   fi
4798 fi
4799
4800 # Flags needed for both GMP and/or MPFR
4801
4802
4803
4804
4805 # Check for PPL
4806 ppl_major_version=0
4807 ppl_minor_version=10
4808 ppllibs=
4809 pplinc=
4810
4811
4812 # Check whether --with-ppl or --without-ppl was given.
4813 if test "${with_ppl+set}" = set; then
4814   withval="$with_ppl"
4815
4816 fi;
4817
4818 # Check whether --with-ppl_include or --without-ppl_include was given.
4819 if test "${with_ppl_include+set}" = set; then
4820   withval="$with_ppl_include"
4821
4822 fi;
4823
4824 # Check whether --with-ppl_lib or --without-ppl_lib was given.
4825 if test "${with_ppl_lib+set}" = set; then
4826   withval="$with_ppl_lib"
4827
4828 fi;
4829
4830 if test "x$with_ppl" != x; then
4831   ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx"
4832   pplinc="-I$with_ppl/include $pplinc"
4833   LIBS="$ppllibs $LIBS"
4834 fi
4835 if test "x$with_ppl_include" != x; then
4836   pplinc="-I$with_ppl_include $pplinc"
4837 fi
4838 if test "x$with_ppl_lib" != x; then
4839   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx"
4840   LIBS="$ppllibs $LIBS"
4841 fi
4842 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
4843   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '
4844   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
4845   LIBS="$ppllibs $LIBS"
4846 fi
4847
4848 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
4849 if test "${enable_ppl_version_check+set}" = set; then
4850   enableval="$enable_ppl_version_check"
4851   ENABLE_PPL_CHECK=$enableval
4852 else
4853   ENABLE_PPL_CHECK=yes
4854 fi;
4855
4856 if test "${ENABLE_PPL_CHECK}" = "yes"; then
4857   saved_CFLAGS="$CFLAGS"
4858   CFLAGS="$CFLAGS $pplinc $gmpinc"
4859   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
4860 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
4861   cat >conftest.$ac_ext <<_ACEOF
4862 /* confdefs.h.  */
4863 _ACEOF
4864 cat confdefs.h >>conftest.$ac_ext
4865 cat >>conftest.$ac_ext <<_ACEOF
4866 /* end confdefs.h.  */
4867 #include "ppl_c.h"
4868 int
4869 main ()
4870 {
4871
4872   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
4873   choke me
4874   #endif
4875
4876   ;
4877   return 0;
4878 }
4879 _ACEOF
4880 rm -f conftest.$ac_objext
4881 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4882   (eval $ac_compile) 2>conftest.er1
4883   ac_status=$?
4884   grep -v '^ *+' conftest.er1 >conftest.err
4885   rm -f conftest.er1
4886   cat conftest.err >&5
4887   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4888   (exit $ac_status); } &&
4889          { ac_try='test -z "$ac_c_werror_flag"
4890                          || test ! -s conftest.err'
4891   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4892   (eval $ac_try) 2>&5
4893   ac_status=$?
4894   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4895   (exit $ac_status); }; } &&
4896          { ac_try='test -s conftest.$ac_objext'
4897   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4898   (eval $ac_try) 2>&5
4899   ac_status=$?
4900   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4901   (exit $ac_status); }; }; then
4902   echo "$as_me:$LINENO: result: yes" >&5
4903 echo "${ECHO_T}yes" >&6
4904 else
4905   echo "$as_me: failed program was:" >&5
4906 sed 's/^/| /' conftest.$ac_ext >&5
4907
4908 echo "$as_me:$LINENO: result: no" >&5
4909 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
4910 fi
4911 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4912   CFLAGS="$saved_CFLAGS"
4913 fi
4914
4915 # Flags needed for PPL
4916
4917
4918
4919
4920 # Check for CLOOG
4921 clooglibs=" -lcloog "
4922 clooginc=" -DCLOOG_PPL_BACKEND "
4923
4924
4925 # Check whether --with-cloog or --without-cloog was given.
4926 if test "${with_cloog+set}" = set; then
4927   withval="$with_cloog"
4928
4929 fi;
4930
4931 # Check whether --with-cloog_include or --without-cloog_include was given.
4932 if test "${with_cloog_include+set}" = set; then
4933   withval="$with_cloog_include"
4934
4935 fi;
4936
4937 # Check whether --with-cloog_lib or --without-cloog_lib was given.
4938 if test "${with_cloog_lib+set}" = set; then
4939   withval="$with_cloog_lib"
4940
4941 fi;
4942
4943 # Check whether --with-cloog-polylib or --without-cloog-polylib was given.
4944 if test "${with_cloog_polylib+set}" = set; then
4945   withval="$with_cloog_polylib"
4946
4947 fi;
4948
4949 if test "x$with_cloog" != x; then
4950   clooglibs="-L$with_cloog/lib -lcloog"
4951   clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
4952   LIBS="$clooglibs $LIBS"
4953 fi
4954 if test "x$with_cloog_polylib" != x; then
4955   clooglibs="-L$with_cloog/lib -lcloog"
4956   clooginc="-I$with_cloog/include "
4957   LIBS="$clooglibs $LIBS"
4958 fi
4959 if test "x$with_cloog_include" != x; then
4960   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
4961 fi
4962 if test "x$with_cloog_lib" != x; then
4963   clooglibs="-L$with_cloog_lib -lcloog"
4964   LIBS="$clooglibs $LIBS"
4965 fi
4966 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
4967   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
4968   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
4969   LIBS="$clooglibs $LIBS"
4970 fi
4971
4972 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
4973 if test "${enable_cloog_version_check+set}" = set; then
4974   enableval="$enable_cloog_version_check"
4975   ENABLE_CLOOG_CHECK=$enableval
4976 else
4977   ENABLE_CLOOG_CHECK=yes
4978 fi;
4979
4980 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
4981   saved_CFLAGS="$CFLAGS"
4982   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
4983   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
4984 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
4985   cat >conftest.$ac_ext <<_ACEOF
4986 /* confdefs.h.  */
4987 _ACEOF
4988 cat confdefs.h >>conftest.$ac_ext
4989 cat >>conftest.$ac_ext <<_ACEOF
4990 /* end confdefs.h.  */
4991 #include "cloog/cloog.h"
4992 int
4993 main ()
4994 {
4995
4996   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
4997   choke me
4998   #endif
4999
5000   ;
5001   return 0;
5002 }
5003 _ACEOF
5004 rm -f conftest.$ac_objext
5005 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5006   (eval $ac_compile) 2>conftest.er1
5007   ac_status=$?
5008   grep -v '^ *+' conftest.er1 >conftest.err
5009   rm -f conftest.er1
5010   cat conftest.err >&5
5011   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5012   (exit $ac_status); } &&
5013          { ac_try='test -z "$ac_c_werror_flag"
5014                          || test ! -s conftest.err'
5015   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5016   (eval $ac_try) 2>&5
5017   ac_status=$?
5018   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5019   (exit $ac_status); }; } &&
5020          { ac_try='test -s conftest.$ac_objext'
5021   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5022   (eval $ac_try) 2>&5
5023   ac_status=$?
5024   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5025   (exit $ac_status); }; }; then
5026   echo "$as_me:$LINENO: result: yes" >&5
5027 echo "${ECHO_T}yes" >&6
5028 else
5029   echo "$as_me: failed program was:" >&5
5030 sed 's/^/| /' conftest.$ac_ext >&5
5031
5032 echo "$as_me:$LINENO: result: no" >&5
5033 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5034 fi
5035 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5036   CFLAGS="$saved_CFLAGS"
5037 fi
5038
5039 # Flags needed for CLOOG
5040
5041
5042
5043
5044 # By default, C is the only stage 1 language.
5045 stage1_languages=,c,
5046
5047 # Figure out what language subdirectories are present.
5048 # Look if the user specified --enable-languages="..."; if not, use
5049 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5050 # go away some day.
5051 # NB:  embedded tabs in this IF block -- do not untabify
5052 if test -d ${srcdir}/gcc; then
5053   if test x"${enable_languages+set}" != xset; then
5054     if test x"${LANGUAGES+set}" = xset; then
5055       enable_languages="${LANGUAGES}"
5056         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5057     else
5058       enable_languages=all
5059     fi
5060   else
5061     if test x"${enable_languages}" = x ||
5062        test x"${enable_languages}" = xyes;
5063        then
5064       echo configure.in: --enable-languages needs at least one language argument 1>&2
5065       exit 1
5066     fi
5067   fi
5068   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5069
5070   # 'f95' is the old name for the 'fortran' language. We issue a warning
5071   # and make the substitution.
5072   case ,${enable_languages}, in
5073     *,f95,*)
5074       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5075       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5076       ;;
5077   esac
5078
5079   # First scan to see if an enabled language requires some other language.
5080   # We assume that a given config-lang.in will list all the language
5081   # front ends it requires, even if some are required indirectly.
5082   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5083     case ${lang_frag} in
5084       ..) ;;
5085       # The odd quoting in the next line works around
5086       # an apparent bug in bash 1.12 on linux.
5087       ${srcdir}/gcc/[*]/config-lang.in) ;;
5088       *)
5089         # From the config-lang.in, get $language, $lang_requires
5090         language=
5091         lang_requires=
5092         . ${lang_frag}
5093         for other in ${lang_requires} ; do
5094           case ,${enable_languages}, in
5095             *,$other,*) ;;
5096             *,all,*) ;;
5097             *,$language,*)
5098               echo " \`$other' language required by \`$language'; enabling" 1>&2
5099               enable_languages="${enable_languages},${other}"
5100               ;;
5101           esac
5102         done
5103         ;;
5104     esac
5105   done
5106
5107   new_enable_languages=,c,
5108   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5109   potential_languages=,c,
5110
5111   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5112     case ${lang_frag} in
5113       ..) ;;
5114       # The odd quoting in the next line works around
5115       # an apparent bug in bash 1.12 on linux.
5116       ${srcdir}/gcc/[*]/config-lang.in) ;;
5117       *)
5118         # From the config-lang.in, get $language, $target_libs,
5119         # $lang_dirs, $boot_language, and $build_by_default
5120         language=
5121         target_libs=
5122         lang_dirs=
5123         subdir_requires=
5124         boot_language=no
5125         build_by_default=yes
5126         . ${lang_frag}
5127         if test x${language} = x; then
5128           echo "${lang_frag} doesn't set \$language." 1>&2
5129           exit 1
5130         fi
5131
5132         case ,${enable_languages}, in
5133           *,${language},*)
5134             # Language was explicitly selected; include it.
5135             add_this_lang=yes
5136             ;;
5137           *,all,*)
5138             # 'all' was selected, select it if it is a default language
5139             add_this_lang=${build_by_default}
5140             ;;
5141           *)
5142             add_this_lang=no
5143             ;;
5144         esac
5145
5146         # Disable languages that need other directories if these aren't available.
5147         for i in $subdir_requires; do
5148           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5149           case ,${enable_languages}, in
5150             *,${language},*)
5151               # Specifically requested language; tell them.
5152               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5153 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5154    { (exit 1); exit 1; }; }
5155               ;;
5156             *)
5157               # Silently disable.
5158               add_this_lang=unsupported
5159               ;;
5160           esac
5161         done
5162
5163         # Disable Ada if no preexisting GNAT is available.
5164         case ,${enable_languages},:${language}:${have_gnat} in
5165           *,${language},*:ada:no)
5166             # Specifically requested language; tell them.
5167             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5168 echo "$as_me: error: GNAT is required to build $language" >&2;}
5169    { (exit 1); exit 1; }; }
5170             ;;
5171           *:ada:no)
5172             # Silently disable.
5173             add_this_lang=unsupported
5174             ;;
5175         esac
5176
5177         # Disable a language that is unsupported by the target.
5178         case " $unsupported_languages " in
5179           *" $language "*)
5180             add_this_lang=unsupported
5181             ;;
5182         esac
5183
5184         case $add_this_lang in
5185           unsupported)
5186             # Remove language-dependent dirs.
5187             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5188             ;;
5189           no)
5190             # Remove language-dependent dirs; still show language as supported.
5191             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5192             potential_languages="${potential_languages}${language},"
5193             ;;
5194           yes)
5195             new_enable_languages="${new_enable_languages}${language},"
5196             potential_languages="${potential_languages}${language},"
5197             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5198             case ${boot_language} in
5199               yes)
5200                 # Add to (comma-separated) list of stage 1 languages.
5201                 stage1_languages="${stage1_languages}${language},"
5202                 ;;
5203             esac
5204             ;;
5205         esac
5206         ;;
5207     esac
5208   done
5209
5210   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5211 if test "${enable_stage1_languages+set}" = set; then
5212   enableval="$enable_stage1_languages"
5213   case ,${enable_stage1_languages}, in
5214     ,no,|,,)
5215       # Set it to something that will have no effect in the loop below
5216       enable_stage1_languages=c ;;
5217     ,yes,)
5218       enable_stage1_languages=`echo $new_enable_languages | \
5219         sed -e "s/^,//" -e "s/,$//" ` ;;
5220     *,all,*)
5221       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5222         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5223   esac
5224
5225   # Add "good" languages from enable_stage1_languages to stage1_languages,
5226   # while "bad" languages go in missing_languages.  Leave no duplicates.
5227   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5228     case $potential_languages in
5229       *,$i,*)
5230         case $stage1_languages in
5231           *,$i,*) ;;
5232           *) stage1_languages="$stage1_languages$i," ;;
5233         esac ;;
5234       *)
5235         case $missing_languages in
5236           *,$i,*) ;;
5237           *) missing_languages="$missing_languages$i," ;;
5238         esac ;;
5239      esac
5240   done
5241 fi;
5242
5243   # Remove leading/trailing commas that were added for simplicity
5244   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5245   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5246   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5247   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5248
5249   if test "x$missing_languages" != x; then
5250     { { echo "$as_me:$LINENO: error:
5251 The following requested languages could not be built: ${missing_languages}
5252 Supported languages are: ${potential_languages}" >&5
5253 echo "$as_me: error:
5254 The following requested languages could not be built: ${missing_languages}
5255 Supported languages are: ${potential_languages}" >&2;}
5256    { (exit 1); exit 1; }; }
5257   fi
5258   if test "x$new_enable_languages" != "x$enable_languages"; then
5259     echo The following languages will be built: ${new_enable_languages}
5260     enable_languages="$new_enable_languages"
5261   fi
5262
5263
5264   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5265 fi
5266
5267 # Handle --disable-<component> generically.
5268 for dir in $configdirs $build_configdirs $target_configdirs ; do
5269   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5270   varname=`echo $dirname | sed -e s/+/_/g`
5271   if eval test x\${enable_${varname}} "=" xno ; then
5272     noconfigdirs="$noconfigdirs $dir"
5273   fi
5274 done
5275
5276 # Check for Boehm's garbage collector
5277 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5278 if test "${enable_objc_gc+set}" = set; then
5279   enableval="$enable_objc_gc"
5280   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5281   *,objc,*:*:yes:*target-boehm-gc*)
5282     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5283 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5284    { (exit 1); exit 1; }; }
5285     ;;
5286 esac
5287 fi;
5288
5289 # Make sure we only build Boehm's garbage collector if required.
5290 case ,${enable_languages},:${enable_objc_gc} in
5291   *,objc,*:yes)
5292     # Keep target-boehm-gc if requested for Objective-C.
5293     ;;
5294   *)
5295     # Otherwise remove target-boehm-gc depending on target-libjava.
5296     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5297       noconfigdirs="$noconfigdirs target-boehm-gc"
5298     fi
5299     ;;
5300 esac
5301
5302 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5303 # $build_configdirs and $target_configdirs.
5304 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5305
5306 notsupp=""
5307 for dir in . $skipdirs $noconfigdirs ; do
5308   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5309   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5310     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5311     if test -r $srcdir/$dirname/configure ; then
5312       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5313         true
5314       else
5315         notsupp="$notsupp $dir"
5316       fi
5317     fi
5318   fi
5319   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5320     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5321     if test -r $srcdir/$dirname/configure ; then
5322       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5323         true
5324       else
5325         notsupp="$notsupp $dir"
5326       fi
5327     fi
5328   fi
5329   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5330     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5331     if test -r $srcdir/$dirname/configure ; then
5332       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5333         true
5334       else
5335         notsupp="$notsupp $dir"
5336       fi
5337     fi
5338   fi
5339 done
5340
5341 # Sometimes the tools are distributed with libiberty but with no other
5342 # libraries.  In that case, we don't want to build target-libiberty.
5343 # Don't let libgcc imply libiberty either.
5344 if test -n "${target_configdirs}" ; then
5345   libgcc=
5346   others=
5347   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5348     if test "$i" = "libgcc"; then
5349       libgcc=target-libgcc
5350     elif test "$i" != "libiberty" ; then
5351       if test -r $srcdir/$i/configure ; then
5352         others=yes;
5353         break;
5354       fi
5355     fi
5356   done
5357   if test -z "${others}" ; then
5358     target_configdirs=$libgcc
5359   fi
5360 fi
5361
5362 # Quietly strip out all directories which aren't configurable in this tree.
5363 # This relies on all configurable subdirectories being autoconfiscated, which
5364 # is now the case.
5365 build_configdirs_all="$build_configdirs"
5366 build_configdirs=
5367 for i in ${build_configdirs_all} ; do
5368   j=`echo $i | sed -e s/build-//g`
5369   if test -f ${srcdir}/$j/configure ; then
5370     build_configdirs="${build_configdirs} $i"
5371   fi
5372 done
5373
5374 configdirs_all="$configdirs"
5375 configdirs=
5376 for i in ${configdirs_all} ; do
5377   if test -f ${srcdir}/$i/configure ; then
5378     configdirs="${configdirs} $i"
5379   fi
5380 done
5381
5382 target_configdirs_all="$target_configdirs"
5383 target_configdirs=
5384 for i in ${target_configdirs_all} ; do
5385   j=`echo $i | sed -e s/target-//g`
5386   if test -f ${srcdir}/$j/configure ; then
5387     target_configdirs="${target_configdirs} $i"
5388   fi
5389 done
5390
5391 # Produce a warning message for the subdirs we can't configure.
5392 # This isn't especially interesting in the Cygnus tree, but in the individual
5393 # FSF releases, it's important to let people know when their machine isn't
5394 # supported by the one or two programs in a package.
5395
5396 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5397   # If $appdirs is non-empty, at least one of those directories must still
5398   # be configured, or we error out.  (E.g., if the gas release supports a
5399   # specified target in some subdirs but not the gas subdir, we shouldn't
5400   # pretend that all is well.)
5401   if test -n "$appdirs" ; then
5402     for dir in $appdirs ; do
5403       if test -r $dir/Makefile.in ; then
5404         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5405           appdirs=""
5406           break
5407         fi
5408         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5409           appdirs=""
5410           break
5411         fi
5412       fi
5413     done
5414     if test -n "$appdirs" ; then
5415       echo "*** This configuration is not supported by this package." 1>&2
5416       exit 1
5417     fi
5418   fi
5419   # Okay, some application will build, or we don't care to check.  Still
5420   # notify of subdirs not getting built.
5421   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5422   echo "    ${notsupp}" 1>&2
5423   echo "    (Any other directories should still work fine.)" 1>&2
5424 fi
5425
5426 case "$host" in
5427   *msdosdjgpp*)
5428     enable_gdbtk=no ;;
5429 esac
5430
5431 # To find our prefix, in gcc_cv_tool_prefix.
5432
5433 # The user is always right.
5434 if test "${PATH_SEPARATOR+set}" != set; then
5435   echo "#! /bin/sh" >conf$$.sh
5436   echo  "exit 0"   >>conf$$.sh
5437   chmod +x conf$$.sh
5438   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5439     PATH_SEPARATOR=';'
5440   else
5441     PATH_SEPARATOR=:
5442   fi
5443   rm -f conf$$.sh
5444 fi
5445
5446
5447
5448 if test "x$exec_prefix" = xNONE; then
5449         if test "x$prefix" = xNONE; then
5450                 gcc_cv_tool_prefix=$ac_default_prefix
5451         else
5452                 gcc_cv_tool_prefix=$prefix
5453         fi
5454 else
5455         gcc_cv_tool_prefix=$exec_prefix
5456 fi
5457
5458 # If there is no compiler in the tree, use the PATH only.  In any
5459 # case, if there is no compiler in the tree nobody should use
5460 # AS_FOR_TARGET and LD_FOR_TARGET.
5461 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5462     gcc_version=`cat $srcdir/gcc/BASE-VER`
5463     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5464     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5465     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5466     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5467     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5468     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5469 else
5470     gcc_cv_tool_dirs=
5471 fi
5472
5473 if test x$build = x$target && test -n "$md_exec_prefix"; then
5474         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5475 fi
5476
5477
5478
5479 copy_dirs=
5480
5481
5482 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5483 if test "${with_build_sysroot+set}" = set; then
5484   withval="$with_build_sysroot"
5485   if test x"$withval" != x ; then
5486      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5487    fi
5488 else
5489   SYSROOT_CFLAGS_FOR_TARGET=
5490 fi;
5491
5492
5493
5494 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5495 if test "${with_debug_prefix_map+set}" = set; then
5496   withval="$with_debug_prefix_map"
5497   if test x"$withval" != x; then
5498      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5499      for debug_map in $withval; do
5500        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5501      done
5502    fi
5503 else
5504   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5505 fi;
5506
5507
5508 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5509 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5510 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5511 # We want to ensure that TARGET libraries (which we know are built with
5512 # gcc) are built with "-O2 -g", so include those options when setting
5513 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5514 if test "x$CFLAGS_FOR_TARGET" = x; then
5515   CFLAGS_FOR_TARGET=$CFLAGS
5516   case " $CFLAGS " in
5517     *" -O2 "*) ;;
5518     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5519   esac
5520   case " $CFLAGS " in
5521     *" -g "* | *" -g3 "*) ;;
5522     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5523   esac
5524 fi
5525
5526
5527 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5528   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5529   case " $CXXFLAGS " in
5530     *" -O2 "*) ;;
5531     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5532   esac
5533   case " $CXXFLAGS " in
5534     *" -g "* | *" -g3 "*) ;;
5535     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5536   esac
5537 fi
5538
5539
5540 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5541 # the named directory are copied to $(tooldir)/sys-include.
5542 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5543   if test x${is_cross_compiler} = xno ; then
5544     echo 1>&2 '***' --with-headers is only supported when cross compiling
5545     exit 1
5546   fi
5547   if test x"${with_headers}" != xyes ; then
5548     x=${gcc_cv_tool_prefix}
5549     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5550   fi
5551 fi
5552
5553 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5554 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5555 # are permitted.
5556 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5557   if test x${is_cross_compiler} = xno ; then
5558     echo 1>&2 '***' --with-libs is only supported when cross compiling
5559     exit 1
5560   fi
5561   if test x"${with_libs}" != xyes ; then
5562     # Copy the libraries in reverse order, so that files in the first named
5563     # library override files in subsequent libraries.
5564     x=${gcc_cv_tool_prefix}
5565     for l in ${with_libs}; do
5566       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5567     done
5568   fi
5569 fi
5570
5571 # Set with_gnu_as and with_gnu_ld as appropriate.
5572 #
5573 # This is done by determining whether or not the appropriate directory
5574 # is available, and by checking whether or not specific configurations
5575 # have requested that this magic not happen.
5576 #
5577 # The command line options always override the explicit settings in
5578 # configure.in, and the settings in configure.in override this magic.
5579 #
5580 # If the default for a toolchain is to use GNU as and ld, and you don't
5581 # want to do that, then you should use the --without-gnu-as and
5582 # --without-gnu-ld options for the configure script.
5583
5584 if test x${use_gnu_as} = x &&
5585    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5586   with_gnu_as=yes
5587   extra_host_args="$extra_host_args --with-gnu-as"
5588 fi
5589
5590 if test x${use_gnu_ld} = x &&
5591    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5592   with_gnu_ld=yes
5593   extra_host_args="$extra_host_args --with-gnu-ld"
5594 fi
5595
5596 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5597 # can detect this case.
5598
5599 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5600   with_newlib=yes
5601   extra_host_args="$extra_host_args --with-newlib"
5602 fi
5603
5604 # Handle ${copy_dirs}
5605 set fnord ${copy_dirs}
5606 shift
5607 while test $# != 0 ; do
5608   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5609     :
5610   else
5611     echo Copying $1 to $2
5612
5613     # Use the install script to create the directory and all required
5614     # parent directories.
5615     if test -d $2 ; then
5616       :
5617     else
5618       echo >config.temp
5619       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5620     fi
5621
5622     # Copy the directory, assuming we have tar.
5623     # FIXME: Should we use B in the second tar?  Not all systems support it.
5624     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5625
5626     # It is the responsibility of the user to correctly adjust all
5627     # symlinks.  If somebody can figure out how to handle them correctly
5628     # here, feel free to add the code.
5629
5630     echo $1 > $2/COPIED
5631   fi
5632   shift; shift
5633 done
5634
5635 # Determine a target-dependent exec_prefix that the installed
5636 # gcc will search in.  Keep this list sorted by triplet, with
5637 # the *-*-osname triplets last.
5638 md_exec_prefix=
5639 case "${target}" in
5640   alpha*-*-*vms*)
5641     md_exec_prefix=/gnu/lib/gcc-lib
5642     ;;
5643   i[34567]86-pc-msdosdjgpp*)
5644     md_exec_prefix=/dev/env/DJDIR/bin
5645     ;;
5646   i[34567]86-*-sco3.2v5*)
5647     if test $with_gnu_as = yes; then
5648       md_exec_prefix=/usr/gnu/bin
5649     else
5650       md_exec_prefix=/usr/ccs/bin/elf
5651     fi
5652     ;;
5653
5654   mn10300-*-* | \
5655   powerpc-*-chorusos* | \
5656   powerpc*-*-eabi* | \
5657   powerpc*-*-sysv* | \
5658   powerpc*-*-kaos* | \
5659   s390x-ibm-tpf*)
5660     md_exec_prefix=/usr/ccs/bin
5661     ;;
5662   sparc64-*-elf*)
5663     ;;
5664   v850*-*-*)
5665     md_exec_prefix=/usr/ccs/bin
5666     ;;
5667   xtensa*-*-elf*)
5668     ;;
5669
5670   *-*-beos* | \
5671   *-*-elf* | \
5672   *-*-hpux* | \
5673   *-*-netware* | \
5674   *-*-nto-qnx* | \
5675   *-*-rtems* | \
5676   *-*-solaris2* | \
5677   *-*-sysv[45]* | \
5678   *-*-vxworks* | \
5679   *-wrs-windiss)
5680     md_exec_prefix=/usr/ccs/bin
5681     ;;
5682 esac
5683
5684 extra_arflags_for_target=
5685 extra_nmflags_for_target=
5686 extra_ranlibflags_for_target=
5687 target_makefile_frag=/dev/null
5688 case "${target}" in
5689   mep*-*-*)
5690     target_makefile_frag="config/mt-mep"
5691     ;;
5692   spu-*-*)
5693     target_makefile_frag="config/mt-spu"
5694     ;;
5695   mips*-sde-elf*)
5696     target_makefile_frag="config/mt-sde"
5697     ;;
5698   mipsisa*-*-elfoabi*)
5699     target_makefile_frag="config/mt-mips-elfoabi"
5700     ;;
5701   mips*-*-*linux* | mips*-*-gnu*)
5702     target_makefile_frag="config/mt-mips-gnu"
5703     ;;
5704   *-*-netware*)
5705     target_makefile_frag="config/mt-netware"
5706     ;;
5707   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5708     target_makefile_frag="config/mt-gnu"
5709     ;;
5710   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5711     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5712     # commands to handle both 32-bit and 64-bit objects.  These flags are
5713     # harmless if we're using GNU nm or ar.
5714     extra_arflags_for_target=" -X32_64"
5715     extra_nmflags_for_target=" -B -X32_64"
5716     ;;
5717   *-*-darwin*)
5718     # ranlib from Darwin requires the -c flag to look at common symbols.
5719     extra_ranlibflags_for_target=" -c"
5720     ;;
5721   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5722     target_makefile_frag="config/mt-wince"
5723     ;;
5724 esac
5725
5726 alphaieee_frag=/dev/null
5727 case $target in
5728   alpha*-*-*)
5729     # This just makes sure to use the -mieee option to build target libs.
5730     # This should probably be set individually by each library.
5731     alphaieee_frag="config/mt-alphaieee"
5732     ;;
5733 esac
5734
5735 # If --enable-target-optspace always use -Os instead of -O2 to build
5736 # the target libraries, similarly if it is not specified, use -Os
5737 # on selected platforms.
5738 ospace_frag=/dev/null
5739 case "${enable_target_optspace}:${target}" in
5740   yes:*)
5741     ospace_frag="config/mt-ospace"
5742     ;;
5743   :d30v-*)
5744     ospace_frag="config/mt-d30v"
5745     ;;
5746   :m32r-* | :d10v-* | :fr30-*)
5747     ospace_frag="config/mt-ospace"
5748     ;;
5749   no:* | :*)
5750     ;;
5751   *)
5752     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5753     ;;
5754 esac
5755
5756 # Default to using --with-stabs for certain targets.
5757 if test x${with_stabs} = x ; then
5758   case "${target}" in
5759   mips*-*-irix[56]*)
5760     ;;
5761   mips*-*-* | alpha*-*-osf*)
5762     with_stabs=yes;
5763     extra_host_args="${extra_host_args} --with-stabs"
5764     ;;
5765   esac
5766 fi
5767
5768 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5769 # them automatically.
5770 case "${host}" in
5771   hppa*64*-*-hpux11*)
5772     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5773     ;;
5774 esac
5775
5776 # Some systems (e.g., one of the i386-aix systems the gas testers are
5777 # using) don't handle "\$" correctly, so don't use it here.
5778 tooldir='${exec_prefix}'/${target_noncanonical}
5779 build_tooldir=${tooldir}
5780
5781 # Create a .gdbinit file which runs the one in srcdir
5782 # and tells GDB to look there for source files.
5783
5784 if test -r ${srcdir}/.gdbinit ; then
5785   case ${srcdir} in
5786     .) ;;
5787     *) cat > ./.gdbinit <<EOF
5788 # ${NO_EDIT}
5789 dir ${srcdir}
5790 dir .
5791 source ${srcdir}/.gdbinit
5792 EOF
5793     ;;
5794   esac
5795 fi
5796
5797 # Make sure that the compiler is able to generate an executable.  If it
5798 # can't, we are probably in trouble.  We don't care whether we can run the
5799 # executable--we might be using a cross compiler--we only care whether it
5800 # can be created.  At this point the main configure script has set CC.
5801 we_are_ok=no
5802 echo "int main () { return 0; }" > conftest.c
5803 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5804 if test $? = 0 ; then
5805   if test -s conftest || test -s conftest.exe ; then
5806     we_are_ok=yes
5807   fi
5808 fi
5809 case $we_are_ok in
5810   no)
5811     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5812     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5813     rm -f conftest*
5814     exit 1
5815     ;;
5816 esac
5817 rm -f conftest*
5818
5819 # The Solaris /usr/ucb/cc compiler does not appear to work.
5820 case "${host}" in
5821   sparc-sun-solaris2*)
5822       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5823       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5824           could_use=
5825           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5826           if test -d /opt/cygnus/bin ; then
5827               if test "$could_use" = "" ; then
5828                   could_use="/opt/cygnus/bin"
5829               else
5830                   could_use="$could_use or /opt/cygnus/bin"
5831               fi
5832           fi
5833         if test "$could_use" = "" ; then
5834             echo "Warning: compilation may fail because you're using"
5835             echo "/usr/ucb/cc.  You should change your PATH or CC "
5836             echo "variable and rerun configure."
5837         else
5838             echo "Warning: compilation may fail because you're using"
5839             echo "/usr/ucb/cc, when you should use the C compiler from"
5840             echo "$could_use.  You should change your"
5841             echo "PATH or CC variable and rerun configure."
5842         fi
5843       fi
5844   ;;
5845 esac
5846
5847 # Decide which environment variable is used to find dynamic libraries.
5848 case "${host}" in
5849   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5850   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5851   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5852   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5853 esac
5854
5855 # On systems where the dynamic library environment variable is PATH,
5856 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
5857 # built executables to PATH.
5858 if test "$RPATH_ENVVAR" = PATH; then
5859   GCC_SHLIB_SUBDIR=/shlib
5860 else
5861   GCC_SHLIB_SUBDIR=
5862 fi
5863
5864 # Record target_configdirs and the configure arguments for target and
5865 # build configuration in Makefile.
5866 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5867 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5868
5869 # Determine whether gdb needs tk/tcl or not.
5870 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5871 # and in that case we want gdb to be built without tk.  Ugh!
5872 # In fact I believe gdb is the *only* package directly dependent on tk,
5873 # so we should be able to put the 'maybe's in unconditionally and
5874 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5875 # 100% sure that that's safe though.
5876
5877 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5878 case "$enable_gdbtk" in
5879   no)
5880     GDB_TK="" ;;
5881   yes)
5882     GDB_TK="${gdb_tk}" ;;
5883   *)
5884     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5885     # distro.  Eventually someone will fix this and move Insight, nee
5886     # gdbtk to a separate directory.
5887     if test -d ${srcdir}/gdb/gdbtk ; then
5888       GDB_TK="${gdb_tk}"
5889     else
5890       GDB_TK=""
5891     fi
5892     ;;
5893 esac
5894 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5895 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5896
5897 # Strip out unwanted targets.
5898
5899 # While at that, we remove Makefiles if we were started for recursive
5900 # configuration, so that the top-level Makefile reconfigures them,
5901 # like we used to do when configure itself was recursive.
5902
5903 # Loop over modules.  $extrasub must be used with care, limiting as
5904 # much as possible the usage of range addresses.  That's because autoconf
5905 # splits the sed script to overcome limits in the number of commands,
5906 # and relying on carefully-timed sed passes may turn out to be very hard
5907 # to maintain later.  In this particular case, you just have to be careful
5908 # not to nest @if/@endif pairs, because configure will not warn you at all.
5909
5910 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5911 if test "${enable_bootstrap+set}" = set; then
5912   enableval="$enable_bootstrap"
5913
5914 else
5915   enable_bootstrap=default
5916 fi;
5917
5918 # Issue errors and warnings for invalid/strange bootstrap combinations.
5919 case "$configdirs" in
5920   *gcc*) have_compiler=yes ;;
5921   *) have_compiler=no ;;
5922 esac
5923
5924 case "$have_compiler:$host:$target:$enable_bootstrap" in
5925   *:*:*:no) ;;
5926
5927   # Default behavior.  Enable bootstrap if we have a compiler
5928   # and we are in a native configuration.
5929   yes:$build:$build:default)
5930     enable_bootstrap=yes ;;
5931
5932   *:*:*:default)
5933     enable_bootstrap=no ;;
5934
5935   # We have a compiler and we are in a native configuration, bootstrap is ok
5936   yes:$build:$build:yes)
5937     ;;
5938
5939   # Other configurations, but we have a compiler.  Assume the user knows
5940   # what he's doing.
5941   yes:*:*:yes)
5942     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5943 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5944     ;;
5945
5946   # No compiler: if they passed --enable-bootstrap explicitly, fail
5947   no:*:*:yes)
5948     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5949 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5950    { (exit 1); exit 1; }; } ;;
5951
5952   # Fail if wrong command line
5953   *)
5954     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5955 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5956    { (exit 1); exit 1; }; }
5957     ;;
5958 esac
5959
5960 # Adjust the toplevel makefile according to whether bootstrap was selected.
5961 case "$enable_bootstrap" in
5962   yes)
5963     bootstrap_suffix=bootstrap ;;
5964   no)
5965     bootstrap_suffix=no-bootstrap ;;
5966 esac
5967
5968 for module in ${build_configdirs} ; do
5969   if test -z "${no_recursion}" \
5970      && test -f ${build_subdir}/${module}/Makefile; then
5971     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5972     rm -f ${build_subdir}/${module}/Makefile
5973   fi
5974   extrasub="$extrasub
5975 /^@if build-$module\$/d
5976 /^@endif build-$module\$/d
5977 /^@if build-$module-$bootstrap_suffix\$/d
5978 /^@endif build-$module-$bootstrap_suffix\$/d"
5979 done
5980 for module in ${configdirs} ; do
5981   if test -z "${no_recursion}"; then
5982     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5983       if test -f ${file}; then
5984         echo 1>&2 "*** removing ${file} to force reconfigure"
5985         rm -f ${file}
5986       fi
5987     done
5988   fi
5989   extrasub="$extrasub
5990 /^@if $module\$/d
5991 /^@endif $module\$/d
5992 /^@if $module-$bootstrap_suffix\$/d
5993 /^@endif $module-$bootstrap_suffix\$/d"
5994 done
5995 for module in ${target_configdirs} ; do
5996   if test -z "${no_recursion}" \
5997      && test -f ${target_subdir}/${module}/Makefile; then
5998     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5999     rm -f ${target_subdir}/${module}/Makefile
6000   fi
6001   extrasub="$extrasub
6002 /^@if target-$module\$/d
6003 /^@endif target-$module\$/d
6004 /^@if target-$module-$bootstrap_suffix\$/d
6005 /^@endif target-$module-$bootstrap_suffix\$/d"
6006 done
6007
6008 extrasub="$extrasub
6009 /^@if /,/^@endif /d"
6010
6011 # Create the serialization dependencies.  This uses a temporary file.
6012
6013 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6014 if test "${enable_serial_configure+set}" = set; then
6015   enableval="$enable_serial_configure"
6016
6017 fi;
6018
6019 case ${enable_serial_configure} in
6020   yes)
6021     enable_serial_build_configure=yes
6022     enable_serial_host_configure=yes
6023     enable_serial_target_configure=yes
6024     ;;
6025 esac
6026
6027 # These force 'configure's to be done one at a time, to avoid problems
6028 # with contention over a shared config.cache.
6029 rm -f serdep.tmp
6030 echo '# serdep.tmp' > serdep.tmp
6031 olditem=
6032 test "x${enable_serial_build_configure}" = xyes &&
6033 for item in ${build_configdirs} ; do
6034   case ${olditem} in
6035     "") ;;
6036     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6037   esac
6038   olditem=${item}
6039 done
6040 olditem=
6041 test "x${enable_serial_host_configure}" = xyes &&
6042 for item in ${configdirs} ; do
6043   case ${olditem} in
6044     "") ;;
6045     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6046   esac
6047   olditem=${item}
6048 done
6049 olditem=
6050 test "x${enable_serial_target_configure}" = xyes &&
6051 for item in ${target_configdirs} ; do
6052   case ${olditem} in
6053     "") ;;
6054     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6055   esac
6056   olditem=${item}
6057 done
6058 serialization_dependencies=serdep.tmp
6059
6060
6061 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6062 # target, nonopt, and variable assignments.  These are the ones we
6063 # might not want to pass down to subconfigures.  Also strip
6064 # program-prefix, program-suffix, and program-transform-name, so that
6065 # we can pass down a consistent program-transform-name.
6066 baseargs=
6067 keep_next=no
6068 skip_next=no
6069 eval "set -- $ac_configure_args"
6070 for ac_arg
6071 do
6072   if test X"$skip_next" = X"yes"; then
6073     skip_next=no
6074     continue
6075   fi
6076   if test X"$keep_next" = X"yes"; then
6077     case $ac_arg in
6078       *\'*)
6079         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6080     esac
6081     baseargs="$baseargs '$ac_arg'"
6082     keep_next=no
6083     continue
6084   fi
6085
6086   # Handle separated arguments.  Based on the logic generated by
6087   # autoconf 2.59.
6088   case $ac_arg in
6089     *=* | --config-cache | -C | -disable-* | --disable-* \
6090       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6091       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6092       | -with-* | --with-* | -without-* | --without-* | --x)
6093       separate_arg=no
6094       ;;
6095     -*)
6096       separate_arg=yes
6097       ;;
6098     *)
6099       separate_arg=no
6100       ;;
6101   esac
6102
6103   case "$ac_arg" in
6104     --no*)
6105       continue
6106       ;;
6107     --c* | \
6108     --sr* | \
6109     --ho* | \
6110     --bu* | \
6111     --t* | \
6112     --program-* | \
6113     -cache_file* | \
6114     -srcdir* | \
6115     -host* | \
6116     -build* | \
6117     -target* | \
6118     -program-prefix* | \
6119     -program-suffix* | \
6120     -program-transform-name* )
6121       skip_next=$separate_arg
6122       continue
6123       ;;
6124     -*)
6125       # An option.  Add it.
6126       case $ac_arg in
6127         *\'*)
6128           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6129       esac
6130       baseargs="$baseargs '$ac_arg'"
6131       keep_next=$separate_arg
6132       ;;
6133     *)
6134       # Either a variable assignment, or a nonopt (triplet).  Don't
6135       # pass it down; let the Makefile handle this.
6136       continue
6137       ;;
6138   esac
6139 done
6140 # Remove the initial space we just introduced and, as these will be
6141 # expanded by make, quote '$'.
6142 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6143
6144 # Add in --program-transform-name, after --program-prefix and
6145 # --program-suffix have been applied to it.  Autoconf has already
6146 # doubled dollar signs and backslashes in program_transform_name; we want
6147 # the backslashes un-doubled, and then the entire thing wrapped in single
6148 # quotes, because this will be expanded first by make and then by the shell.
6149 # Also, because we want to override the logic in subdir configure scripts to
6150 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6151 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6152 ${program_transform_name}
6153 EOF_SED
6154 gcc_transform_name=`cat conftestsed.out`
6155 rm -f conftestsed.out
6156 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6157 if test "$silent" = yes; then
6158   baseargs="$baseargs --silent"
6159 fi
6160
6161 # For the build-side libraries, we just need to pretend we're native,
6162 # and not use the same cache file.  Multilibs are neither needed nor
6163 # desired.
6164 build_configargs="--cache-file=../config.cache ${baseargs}"
6165
6166 # For host modules, accept cache file option, or specification as blank.
6167 case "${cache_file}" in
6168 "") # empty
6169   cache_file_option="" ;;
6170 /* | [A-Za-z]:[\\/]* ) # absolute path
6171   cache_file_option="--cache-file=${cache_file}" ;;
6172 *) # relative path
6173   cache_file_option="--cache-file=../${cache_file}" ;;
6174 esac
6175
6176 # Host dirs don't like to share a cache file either, horribly enough.
6177 # This seems to be due to autoconf 2.5x stupidity.
6178 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6179
6180 target_configargs=${baseargs}
6181
6182 # Passing a --with-cross-host argument lets the target libraries know
6183 # whether they are being built with a cross-compiler or being built
6184 # native.  However, it would be better to use other mechanisms to make the
6185 # sorts of decisions they want to make on this basis.  Please consider
6186 # this option to be deprecated.  FIXME.
6187 if test x${is_cross_compiler} = xyes ; then
6188   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6189 fi
6190
6191 # Default to --enable-multilib.
6192 if test x${enable_multilib} = x ; then
6193   target_configargs="--enable-multilib ${target_configargs}"
6194 fi
6195
6196 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6197 # changed from the earlier setting of with_newlib.
6198 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6199   target_configargs="--with-newlib ${target_configargs}"
6200 fi
6201
6202 # Different target subdirs use different values of certain variables
6203 # (notably CXX).  Worse, multilibs use *lots* of different values.
6204 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6205 # it doesn't automatically accept command-line overrides of them.
6206 # This means it's not safe for target subdirs to share a cache file,
6207 # which is disgusting, but there you have it.  Hopefully this can be
6208 # fixed in future.  It's still worthwhile to use a cache file for each
6209 # directory.  I think.
6210
6211 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6212 # We need to pass --target, as newer autoconf's requires consistency
6213 # for target_alias and gcc doesn't manage it consistently.
6214 target_configargs="--cache-file=./config.cache ${target_configargs}"
6215
6216 FLAGS_FOR_TARGET=
6217 case " $target_configdirs " in
6218  *" newlib "*)
6219   case " $target_configargs " in
6220   *" --with-newlib "*)
6221    case "$target" in
6222    *-cygwin*)
6223      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' ;;
6224    esac
6225
6226    # If we're not building GCC, don't discard standard headers.
6227    if test -d ${srcdir}/gcc; then
6228      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6229
6230      if test "${build}" != "${host}"; then
6231        # On Canadian crosses, CC_FOR_TARGET will have already been set
6232        # by `configure', so we won't have an opportunity to add -Bgcc/
6233        # to it.  This is right: we don't want to search that directory
6234        # for binaries, but we want the header files in there, so add
6235        # them explicitly.
6236        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6237
6238        # Someone might think of using the pre-installed headers on
6239        # Canadian crosses, in case the installed compiler is not fully
6240        # compatible with the compiler being built.  In this case, it
6241        # would be better to flag an error than risking having
6242        # incompatible object files being constructed.  We can't
6243        # guarantee that an error will be flagged, but let's hope the
6244        # compiler will do it, when presented with incompatible header
6245        # files.
6246      fi
6247    fi
6248
6249    case "${target}-${is_cross_compiler}" in
6250    i[3456789]86-*-linux*-no)
6251       # Here host == target, so we don't need to build gcc,
6252       # so we don't want to discard standard headers.
6253       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6254       ;;
6255    *)
6256       # If we're building newlib, use its generic headers last, but search
6257       # for any libc-related directories first (so make it the last -B
6258       # switch).
6259       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6260
6261       # If we're building libgloss, find the startup file, simulator library
6262       # and linker script.
6263       case " $target_configdirs " in
6264         *" libgloss "*)
6265         # Look for startup file, simulator library and maybe linker script.
6266         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6267         # Look for libnosys.a in case the target needs it.
6268         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6269         # Most targets have the linker script in the source directory.
6270         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6271         ;;
6272       esac
6273       ;;
6274    esac
6275    ;;
6276   esac
6277   ;;
6278 esac
6279 case "$target" in
6280 *-mingw*)
6281   # Can't be handled as Cygwin above since Mingw does not use newlib.
6282   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' ;;
6283 esac
6284
6285 # Allow the user to override the flags for
6286 # our build compiler if desired.
6287 if test x"${build}" = x"${host}" ; then
6288   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6289   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6290   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6291 fi
6292
6293 # On Canadian crosses, we'll be searching the right directories for
6294 # the previously-installed cross compiler, so don't bother to add
6295 # flags for directories within the install tree of the compiler
6296 # being built; programs in there won't even run.
6297 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6298   # Search for pre-installed headers if nothing else fits.
6299   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6300 fi
6301
6302 if test "x${use_gnu_ld}" = x &&
6303    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6304   # Arrange for us to find uninstalled linker scripts.
6305   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6306 fi
6307
6308 # Search for other target-specific linker scripts and such.
6309 case "${target}" in
6310   mep*)
6311     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6312     ;;
6313 esac
6314
6315 # Makefile fragments.
6316 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6317 do
6318   eval fragval=\$$frag
6319   if test $fragval != /dev/null; then
6320     eval $frag=${srcdir}/$fragval
6321   fi
6322 done
6323
6324
6325
6326
6327
6328 # Miscellanea: directories, flags, etc.
6329
6330
6331
6332
6333
6334
6335
6336
6337 # Build module lists & subconfigure args.
6338
6339
6340
6341 # Host module lists & subconfigure args.
6342
6343
6344
6345 # Target module lists & subconfigure args.
6346
6347
6348
6349 # Build tools.
6350
6351
6352
6353
6354
6355
6356
6357
6358
6359
6360
6361
6362
6363
6364
6365
6366
6367 # Generate default definitions for YACC, M4, LEX and other programs that run
6368 # on the build machine.  These are used if the Makefile can't locate these
6369 # programs in objdir.
6370 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6371
6372 for ac_prog in 'bison -y' byacc yacc
6373 do
6374   # Extract the first word of "$ac_prog", so it can be a program name with args.
6375 set dummy $ac_prog; ac_word=$2
6376 echo "$as_me:$LINENO: checking for $ac_word" >&5
6377 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6378 if test "${ac_cv_prog_YACC+set}" = set; then
6379   echo $ECHO_N "(cached) $ECHO_C" >&6
6380 else
6381   if test -n "$YACC"; then
6382   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6383 else
6384 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6385 for as_dir in $PATH
6386 do
6387   IFS=$as_save_IFS
6388   test -z "$as_dir" && as_dir=.
6389   for ac_exec_ext in '' $ac_executable_extensions; do
6390   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6391     ac_cv_prog_YACC="$ac_prog"
6392     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6393     break 2
6394   fi
6395 done
6396 done
6397
6398 fi
6399 fi
6400 YACC=$ac_cv_prog_YACC
6401 if test -n "$YACC"; then
6402   echo "$as_me:$LINENO: result: $YACC" >&5
6403 echo "${ECHO_T}$YACC" >&6
6404 else
6405   echo "$as_me:$LINENO: result: no" >&5
6406 echo "${ECHO_T}no" >&6
6407 fi
6408
6409   test -n "$YACC" && break
6410 done
6411 test -n "$YACC" || YACC="$MISSING bison -y"
6412
6413 case " $build_configdirs " in
6414   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6415   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6416 esac
6417
6418 for ac_prog in bison
6419 do
6420   # Extract the first word of "$ac_prog", so it can be a program name with args.
6421 set dummy $ac_prog; ac_word=$2
6422 echo "$as_me:$LINENO: checking for $ac_word" >&5
6423 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6424 if test "${ac_cv_prog_BISON+set}" = set; then
6425   echo $ECHO_N "(cached) $ECHO_C" >&6
6426 else
6427   if test -n "$BISON"; then
6428   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6429 else
6430 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6431 for as_dir in $PATH
6432 do
6433   IFS=$as_save_IFS
6434   test -z "$as_dir" && as_dir=.
6435   for ac_exec_ext in '' $ac_executable_extensions; do
6436   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6437     ac_cv_prog_BISON="$ac_prog"
6438     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6439     break 2
6440   fi
6441 done
6442 done
6443
6444 fi
6445 fi
6446 BISON=$ac_cv_prog_BISON
6447 if test -n "$BISON"; then
6448   echo "$as_me:$LINENO: result: $BISON" >&5
6449 echo "${ECHO_T}$BISON" >&6
6450 else
6451   echo "$as_me:$LINENO: result: no" >&5
6452 echo "${ECHO_T}no" >&6
6453 fi
6454
6455   test -n "$BISON" && break
6456 done
6457 test -n "$BISON" || BISON="$MISSING bison"
6458
6459 case " $build_configdirs " in
6460   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6461 esac
6462
6463 for ac_prog in gm4 gnum4 m4
6464 do
6465   # Extract the first word of "$ac_prog", so it can be a program name with args.
6466 set dummy $ac_prog; ac_word=$2
6467 echo "$as_me:$LINENO: checking for $ac_word" >&5
6468 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6469 if test "${ac_cv_prog_M4+set}" = set; then
6470   echo $ECHO_N "(cached) $ECHO_C" >&6
6471 else
6472   if test -n "$M4"; then
6473   ac_cv_prog_M4="$M4" # Let the user override the test.
6474 else
6475 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6476 for as_dir in $PATH
6477 do
6478   IFS=$as_save_IFS
6479   test -z "$as_dir" && as_dir=.
6480   for ac_exec_ext in '' $ac_executable_extensions; do
6481   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6482     ac_cv_prog_M4="$ac_prog"
6483     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6484     break 2
6485   fi
6486 done
6487 done
6488
6489 fi
6490 fi
6491 M4=$ac_cv_prog_M4
6492 if test -n "$M4"; then
6493   echo "$as_me:$LINENO: result: $M4" >&5
6494 echo "${ECHO_T}$M4" >&6
6495 else
6496   echo "$as_me:$LINENO: result: no" >&5
6497 echo "${ECHO_T}no" >&6
6498 fi
6499
6500   test -n "$M4" && break
6501 done
6502 test -n "$M4" || M4="$MISSING m4"
6503
6504 case " $build_configdirs " in
6505   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6506 esac
6507
6508 for ac_prog in flex lex
6509 do
6510   # Extract the first word of "$ac_prog", so it can be a program name with args.
6511 set dummy $ac_prog; ac_word=$2
6512 echo "$as_me:$LINENO: checking for $ac_word" >&5
6513 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6514 if test "${ac_cv_prog_LEX+set}" = set; then
6515   echo $ECHO_N "(cached) $ECHO_C" >&6
6516 else
6517   if test -n "$LEX"; then
6518   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6519 else
6520 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6521 for as_dir in $PATH
6522 do
6523   IFS=$as_save_IFS
6524   test -z "$as_dir" && as_dir=.
6525   for ac_exec_ext in '' $ac_executable_extensions; do
6526   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6527     ac_cv_prog_LEX="$ac_prog"
6528     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6529     break 2
6530   fi
6531 done
6532 done
6533
6534 fi
6535 fi
6536 LEX=$ac_cv_prog_LEX
6537 if test -n "$LEX"; then
6538   echo "$as_me:$LINENO: result: $LEX" >&5
6539 echo "${ECHO_T}$LEX" >&6
6540 else
6541   echo "$as_me:$LINENO: result: no" >&5
6542 echo "${ECHO_T}no" >&6
6543 fi
6544
6545   test -n "$LEX" && break
6546 done
6547 test -n "$LEX" || LEX="$MISSING flex"
6548
6549 case " $build_configdirs " in
6550   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6551   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6552 esac
6553
6554 for ac_prog in flex
6555 do
6556   # Extract the first word of "$ac_prog", so it can be a program name with args.
6557 set dummy $ac_prog; ac_word=$2
6558 echo "$as_me:$LINENO: checking for $ac_word" >&5
6559 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6560 if test "${ac_cv_prog_FLEX+set}" = set; then
6561   echo $ECHO_N "(cached) $ECHO_C" >&6
6562 else
6563   if test -n "$FLEX"; then
6564   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6565 else
6566 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6567 for as_dir in $PATH
6568 do
6569   IFS=$as_save_IFS
6570   test -z "$as_dir" && as_dir=.
6571   for ac_exec_ext in '' $ac_executable_extensions; do
6572   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6573     ac_cv_prog_FLEX="$ac_prog"
6574     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6575     break 2
6576   fi
6577 done
6578 done
6579
6580 fi
6581 fi
6582 FLEX=$ac_cv_prog_FLEX
6583 if test -n "$FLEX"; then
6584   echo "$as_me:$LINENO: result: $FLEX" >&5
6585 echo "${ECHO_T}$FLEX" >&6
6586 else
6587   echo "$as_me:$LINENO: result: no" >&5
6588 echo "${ECHO_T}no" >&6
6589 fi
6590
6591   test -n "$FLEX" && break
6592 done
6593 test -n "$FLEX" || FLEX="$MISSING flex"
6594
6595 case " $build_configdirs " in
6596   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6597 esac
6598
6599 for ac_prog in makeinfo
6600 do
6601   # Extract the first word of "$ac_prog", so it can be a program name with args.
6602 set dummy $ac_prog; ac_word=$2
6603 echo "$as_me:$LINENO: checking for $ac_word" >&5
6604 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6605 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6606   echo $ECHO_N "(cached) $ECHO_C" >&6
6607 else
6608   if test -n "$MAKEINFO"; then
6609   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6610 else
6611 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6612 for as_dir in $PATH
6613 do
6614   IFS=$as_save_IFS
6615   test -z "$as_dir" && as_dir=.
6616   for ac_exec_ext in '' $ac_executable_extensions; do
6617   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6618     ac_cv_prog_MAKEINFO="$ac_prog"
6619     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6620     break 2
6621   fi
6622 done
6623 done
6624
6625 fi
6626 fi
6627 MAKEINFO=$ac_cv_prog_MAKEINFO
6628 if test -n "$MAKEINFO"; then
6629   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6630 echo "${ECHO_T}$MAKEINFO" >&6
6631 else
6632   echo "$as_me:$LINENO: result: no" >&5
6633 echo "${ECHO_T}no" >&6
6634 fi
6635
6636   test -n "$MAKEINFO" && break
6637 done
6638 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6639
6640 case " $build_configdirs " in
6641   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6642   *)
6643
6644     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6645     # higher, else we use the "missing" dummy.
6646     if ${MAKEINFO} --version \
6647        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6648       :
6649     else
6650       MAKEINFO="$MISSING makeinfo"
6651     fi
6652     ;;
6653
6654 esac
6655
6656 # FIXME: expect and dejagnu may become build tools?
6657
6658 for ac_prog in expect
6659 do
6660   # Extract the first word of "$ac_prog", so it can be a program name with args.
6661 set dummy $ac_prog; ac_word=$2
6662 echo "$as_me:$LINENO: checking for $ac_word" >&5
6663 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6664 if test "${ac_cv_prog_EXPECT+set}" = set; then
6665   echo $ECHO_N "(cached) $ECHO_C" >&6
6666 else
6667   if test -n "$EXPECT"; then
6668   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6669 else
6670 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6671 for as_dir in $PATH
6672 do
6673   IFS=$as_save_IFS
6674   test -z "$as_dir" && as_dir=.
6675   for ac_exec_ext in '' $ac_executable_extensions; do
6676   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6677     ac_cv_prog_EXPECT="$ac_prog"
6678     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6679     break 2
6680   fi
6681 done
6682 done
6683
6684 fi
6685 fi
6686 EXPECT=$ac_cv_prog_EXPECT
6687 if test -n "$EXPECT"; then
6688   echo "$as_me:$LINENO: result: $EXPECT" >&5
6689 echo "${ECHO_T}$EXPECT" >&6
6690 else
6691   echo "$as_me:$LINENO: result: no" >&5
6692 echo "${ECHO_T}no" >&6
6693 fi
6694
6695   test -n "$EXPECT" && break
6696 done
6697 test -n "$EXPECT" || EXPECT="expect"
6698
6699 case " $configdirs " in
6700   *" expect "*)
6701     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6702     ;;
6703 esac
6704
6705 for ac_prog in runtest
6706 do
6707   # Extract the first word of "$ac_prog", so it can be a program name with args.
6708 set dummy $ac_prog; ac_word=$2
6709 echo "$as_me:$LINENO: checking for $ac_word" >&5
6710 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6711 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6712   echo $ECHO_N "(cached) $ECHO_C" >&6
6713 else
6714   if test -n "$RUNTEST"; then
6715   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6716 else
6717 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6718 for as_dir in $PATH
6719 do
6720   IFS=$as_save_IFS
6721   test -z "$as_dir" && as_dir=.
6722   for ac_exec_ext in '' $ac_executable_extensions; do
6723   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6724     ac_cv_prog_RUNTEST="$ac_prog"
6725     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6726     break 2
6727   fi
6728 done
6729 done
6730
6731 fi
6732 fi
6733 RUNTEST=$ac_cv_prog_RUNTEST
6734 if test -n "$RUNTEST"; then
6735   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6736 echo "${ECHO_T}$RUNTEST" >&6
6737 else
6738   echo "$as_me:$LINENO: result: no" >&5
6739 echo "${ECHO_T}no" >&6
6740 fi
6741
6742   test -n "$RUNTEST" && break
6743 done
6744 test -n "$RUNTEST" || RUNTEST="runtest"
6745
6746 case " $configdirs " in
6747   *" dejagnu "*)
6748     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6749     ;;
6750 esac
6751
6752
6753 # Host tools.
6754 ncn_tool_prefix=
6755 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6756 ncn_target_tool_prefix=
6757 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6758
6759
6760
6761 if test -n "$AR"; then
6762   ac_cv_prog_AR=$AR
6763 elif test -n "$ac_cv_prog_AR"; then
6764   AR=$ac_cv_prog_AR
6765 fi
6766
6767 if test -n "$ac_cv_prog_AR"; then
6768   for ncn_progname in ar; do
6769     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6770 set dummy ${ncn_progname}; ac_word=$2
6771 echo "$as_me:$LINENO: checking for $ac_word" >&5
6772 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6773 if test "${ac_cv_prog_AR+set}" = set; then
6774   echo $ECHO_N "(cached) $ECHO_C" >&6
6775 else
6776   if test -n "$AR"; then
6777   ac_cv_prog_AR="$AR" # Let the user override the test.
6778 else
6779 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6780 for as_dir in $PATH
6781 do
6782   IFS=$as_save_IFS
6783   test -z "$as_dir" && as_dir=.
6784   for ac_exec_ext in '' $ac_executable_extensions; do
6785   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6786     ac_cv_prog_AR="${ncn_progname}"
6787     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6788     break 2
6789   fi
6790 done
6791 done
6792
6793 fi
6794 fi
6795 AR=$ac_cv_prog_AR
6796 if test -n "$AR"; then
6797   echo "$as_me:$LINENO: result: $AR" >&5
6798 echo "${ECHO_T}$AR" >&6
6799 else
6800   echo "$as_me:$LINENO: result: no" >&5
6801 echo "${ECHO_T}no" >&6
6802 fi
6803
6804   done
6805 fi
6806
6807 for ncn_progname in ar; do
6808   if test -n "$ncn_tool_prefix"; then
6809     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6810 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6811 echo "$as_me:$LINENO: checking for $ac_word" >&5
6812 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6813 if test "${ac_cv_prog_AR+set}" = set; then
6814   echo $ECHO_N "(cached) $ECHO_C" >&6
6815 else
6816   if test -n "$AR"; then
6817   ac_cv_prog_AR="$AR" # Let the user override the test.
6818 else
6819 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6820 for as_dir in $PATH
6821 do
6822   IFS=$as_save_IFS
6823   test -z "$as_dir" && as_dir=.
6824   for ac_exec_ext in '' $ac_executable_extensions; do
6825   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6826     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6827     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6828     break 2
6829   fi
6830 done
6831 done
6832
6833 fi
6834 fi
6835 AR=$ac_cv_prog_AR
6836 if test -n "$AR"; then
6837   echo "$as_me:$LINENO: result: $AR" >&5
6838 echo "${ECHO_T}$AR" >&6
6839 else
6840   echo "$as_me:$LINENO: result: no" >&5
6841 echo "${ECHO_T}no" >&6
6842 fi
6843
6844   fi
6845   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6846     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6847 set dummy ${ncn_progname}; ac_word=$2
6848 echo "$as_me:$LINENO: checking for $ac_word" >&5
6849 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6850 if test "${ac_cv_prog_AR+set}" = set; then
6851   echo $ECHO_N "(cached) $ECHO_C" >&6
6852 else
6853   if test -n "$AR"; then
6854   ac_cv_prog_AR="$AR" # Let the user override the test.
6855 else
6856 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6857 for as_dir in $PATH
6858 do
6859   IFS=$as_save_IFS
6860   test -z "$as_dir" && as_dir=.
6861   for ac_exec_ext in '' $ac_executable_extensions; do
6862   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6863     ac_cv_prog_AR="${ncn_progname}"
6864     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6865     break 2
6866   fi
6867 done
6868 done
6869
6870 fi
6871 fi
6872 AR=$ac_cv_prog_AR
6873 if test -n "$AR"; then
6874   echo "$as_me:$LINENO: result: $AR" >&5
6875 echo "${ECHO_T}$AR" >&6
6876 else
6877   echo "$as_me:$LINENO: result: no" >&5
6878 echo "${ECHO_T}no" >&6
6879 fi
6880
6881   fi
6882   test -n "$ac_cv_prog_AR" && break
6883 done
6884
6885 if test -z "$ac_cv_prog_AR" ; then
6886   set dummy ar
6887   if test $build = $host ; then
6888     AR="$2"
6889   else
6890     AR="${ncn_tool_prefix}$2"
6891   fi
6892 fi
6893
6894
6895
6896 if test -n "$AS"; then
6897   ac_cv_prog_AS=$AS
6898 elif test -n "$ac_cv_prog_AS"; then
6899   AS=$ac_cv_prog_AS
6900 fi
6901
6902 if test -n "$ac_cv_prog_AS"; then
6903   for ncn_progname in as; do
6904     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6905 set dummy ${ncn_progname}; ac_word=$2
6906 echo "$as_me:$LINENO: checking for $ac_word" >&5
6907 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6908 if test "${ac_cv_prog_AS+set}" = set; then
6909   echo $ECHO_N "(cached) $ECHO_C" >&6
6910 else
6911   if test -n "$AS"; then
6912   ac_cv_prog_AS="$AS" # Let the user override the test.
6913 else
6914 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6915 for as_dir in $PATH
6916 do
6917   IFS=$as_save_IFS
6918   test -z "$as_dir" && as_dir=.
6919   for ac_exec_ext in '' $ac_executable_extensions; do
6920   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6921     ac_cv_prog_AS="${ncn_progname}"
6922     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6923     break 2
6924   fi
6925 done
6926 done
6927
6928 fi
6929 fi
6930 AS=$ac_cv_prog_AS
6931 if test -n "$AS"; then
6932   echo "$as_me:$LINENO: result: $AS" >&5
6933 echo "${ECHO_T}$AS" >&6
6934 else
6935   echo "$as_me:$LINENO: result: no" >&5
6936 echo "${ECHO_T}no" >&6
6937 fi
6938
6939   done
6940 fi
6941
6942 for ncn_progname in as; do
6943   if test -n "$ncn_tool_prefix"; then
6944     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6945 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6946 echo "$as_me:$LINENO: checking for $ac_word" >&5
6947 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6948 if test "${ac_cv_prog_AS+set}" = set; then
6949   echo $ECHO_N "(cached) $ECHO_C" >&6
6950 else
6951   if test -n "$AS"; then
6952   ac_cv_prog_AS="$AS" # Let the user override the test.
6953 else
6954 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6955 for as_dir in $PATH
6956 do
6957   IFS=$as_save_IFS
6958   test -z "$as_dir" && as_dir=.
6959   for ac_exec_ext in '' $ac_executable_extensions; do
6960   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6961     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6962     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6963     break 2
6964   fi
6965 done
6966 done
6967
6968 fi
6969 fi
6970 AS=$ac_cv_prog_AS
6971 if test -n "$AS"; then
6972   echo "$as_me:$LINENO: result: $AS" >&5
6973 echo "${ECHO_T}$AS" >&6
6974 else
6975   echo "$as_me:$LINENO: result: no" >&5
6976 echo "${ECHO_T}no" >&6
6977 fi
6978
6979   fi
6980   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6981     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6982 set dummy ${ncn_progname}; ac_word=$2
6983 echo "$as_me:$LINENO: checking for $ac_word" >&5
6984 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6985 if test "${ac_cv_prog_AS+set}" = set; then
6986   echo $ECHO_N "(cached) $ECHO_C" >&6
6987 else
6988   if test -n "$AS"; then
6989   ac_cv_prog_AS="$AS" # Let the user override the test.
6990 else
6991 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6992 for as_dir in $PATH
6993 do
6994   IFS=$as_save_IFS
6995   test -z "$as_dir" && as_dir=.
6996   for ac_exec_ext in '' $ac_executable_extensions; do
6997   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6998     ac_cv_prog_AS="${ncn_progname}"
6999     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7000     break 2
7001   fi
7002 done
7003 done
7004
7005 fi
7006 fi
7007 AS=$ac_cv_prog_AS
7008 if test -n "$AS"; then
7009   echo "$as_me:$LINENO: result: $AS" >&5
7010 echo "${ECHO_T}$AS" >&6
7011 else
7012   echo "$as_me:$LINENO: result: no" >&5
7013 echo "${ECHO_T}no" >&6
7014 fi
7015
7016   fi
7017   test -n "$ac_cv_prog_AS" && break
7018 done
7019
7020 if test -z "$ac_cv_prog_AS" ; then
7021   set dummy as
7022   if test $build = $host ; then
7023     AS="$2"
7024   else
7025     AS="${ncn_tool_prefix}$2"
7026   fi
7027 fi
7028
7029
7030
7031 if test -n "$DLLTOOL"; then
7032   ac_cv_prog_DLLTOOL=$DLLTOOL
7033 elif test -n "$ac_cv_prog_DLLTOOL"; then
7034   DLLTOOL=$ac_cv_prog_DLLTOOL
7035 fi
7036
7037 if test -n "$ac_cv_prog_DLLTOOL"; then
7038   for ncn_progname in dlltool; do
7039     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7040 set dummy ${ncn_progname}; ac_word=$2
7041 echo "$as_me:$LINENO: checking for $ac_word" >&5
7042 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7043 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7044   echo $ECHO_N "(cached) $ECHO_C" >&6
7045 else
7046   if test -n "$DLLTOOL"; then
7047   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7048 else
7049 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7050 for as_dir in $PATH
7051 do
7052   IFS=$as_save_IFS
7053   test -z "$as_dir" && as_dir=.
7054   for ac_exec_ext in '' $ac_executable_extensions; do
7055   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7056     ac_cv_prog_DLLTOOL="${ncn_progname}"
7057     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7058     break 2
7059   fi
7060 done
7061 done
7062
7063 fi
7064 fi
7065 DLLTOOL=$ac_cv_prog_DLLTOOL
7066 if test -n "$DLLTOOL"; then
7067   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7068 echo "${ECHO_T}$DLLTOOL" >&6
7069 else
7070   echo "$as_me:$LINENO: result: no" >&5
7071 echo "${ECHO_T}no" >&6
7072 fi
7073
7074   done
7075 fi
7076
7077 for ncn_progname in dlltool; do
7078   if test -n "$ncn_tool_prefix"; then
7079     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7080 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7081 echo "$as_me:$LINENO: checking for $ac_word" >&5
7082 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7083 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7084   echo $ECHO_N "(cached) $ECHO_C" >&6
7085 else
7086   if test -n "$DLLTOOL"; then
7087   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7088 else
7089 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7090 for as_dir in $PATH
7091 do
7092   IFS=$as_save_IFS
7093   test -z "$as_dir" && as_dir=.
7094   for ac_exec_ext in '' $ac_executable_extensions; do
7095   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7096     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7097     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7098     break 2
7099   fi
7100 done
7101 done
7102
7103 fi
7104 fi
7105 DLLTOOL=$ac_cv_prog_DLLTOOL
7106 if test -n "$DLLTOOL"; then
7107   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7108 echo "${ECHO_T}$DLLTOOL" >&6
7109 else
7110   echo "$as_me:$LINENO: result: no" >&5
7111 echo "${ECHO_T}no" >&6
7112 fi
7113
7114   fi
7115   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7116     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7117 set dummy ${ncn_progname}; ac_word=$2
7118 echo "$as_me:$LINENO: checking for $ac_word" >&5
7119 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7120 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7121   echo $ECHO_N "(cached) $ECHO_C" >&6
7122 else
7123   if test -n "$DLLTOOL"; then
7124   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7125 else
7126 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7127 for as_dir in $PATH
7128 do
7129   IFS=$as_save_IFS
7130   test -z "$as_dir" && as_dir=.
7131   for ac_exec_ext in '' $ac_executable_extensions; do
7132   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7133     ac_cv_prog_DLLTOOL="${ncn_progname}"
7134     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7135     break 2
7136   fi
7137 done
7138 done
7139
7140 fi
7141 fi
7142 DLLTOOL=$ac_cv_prog_DLLTOOL
7143 if test -n "$DLLTOOL"; then
7144   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7145 echo "${ECHO_T}$DLLTOOL" >&6
7146 else
7147   echo "$as_me:$LINENO: result: no" >&5
7148 echo "${ECHO_T}no" >&6
7149 fi
7150
7151   fi
7152   test -n "$ac_cv_prog_DLLTOOL" && break
7153 done
7154
7155 if test -z "$ac_cv_prog_DLLTOOL" ; then
7156   set dummy dlltool
7157   if test $build = $host ; then
7158     DLLTOOL="$2"
7159   else
7160     DLLTOOL="${ncn_tool_prefix}$2"
7161   fi
7162 fi
7163
7164
7165
7166 if test -n "$LD"; then
7167   ac_cv_prog_LD=$LD
7168 elif test -n "$ac_cv_prog_LD"; then
7169   LD=$ac_cv_prog_LD
7170 fi
7171
7172 if test -n "$ac_cv_prog_LD"; then
7173   for ncn_progname in ld; do
7174     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7175 set dummy ${ncn_progname}; ac_word=$2
7176 echo "$as_me:$LINENO: checking for $ac_word" >&5
7177 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7178 if test "${ac_cv_prog_LD+set}" = set; then
7179   echo $ECHO_N "(cached) $ECHO_C" >&6
7180 else
7181   if test -n "$LD"; then
7182   ac_cv_prog_LD="$LD" # Let the user override the test.
7183 else
7184 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7185 for as_dir in $PATH
7186 do
7187   IFS=$as_save_IFS
7188   test -z "$as_dir" && as_dir=.
7189   for ac_exec_ext in '' $ac_executable_extensions; do
7190   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7191     ac_cv_prog_LD="${ncn_progname}"
7192     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7193     break 2
7194   fi
7195 done
7196 done
7197
7198 fi
7199 fi
7200 LD=$ac_cv_prog_LD
7201 if test -n "$LD"; then
7202   echo "$as_me:$LINENO: result: $LD" >&5
7203 echo "${ECHO_T}$LD" >&6
7204 else
7205   echo "$as_me:$LINENO: result: no" >&5
7206 echo "${ECHO_T}no" >&6
7207 fi
7208
7209   done
7210 fi
7211
7212 for ncn_progname in ld; do
7213   if test -n "$ncn_tool_prefix"; then
7214     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7215 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7216 echo "$as_me:$LINENO: checking for $ac_word" >&5
7217 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7218 if test "${ac_cv_prog_LD+set}" = set; then
7219   echo $ECHO_N "(cached) $ECHO_C" >&6
7220 else
7221   if test -n "$LD"; then
7222   ac_cv_prog_LD="$LD" # Let the user override the test.
7223 else
7224 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7225 for as_dir in $PATH
7226 do
7227   IFS=$as_save_IFS
7228   test -z "$as_dir" && as_dir=.
7229   for ac_exec_ext in '' $ac_executable_extensions; do
7230   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7231     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7232     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7233     break 2
7234   fi
7235 done
7236 done
7237
7238 fi
7239 fi
7240 LD=$ac_cv_prog_LD
7241 if test -n "$LD"; then
7242   echo "$as_me:$LINENO: result: $LD" >&5
7243 echo "${ECHO_T}$LD" >&6
7244 else
7245   echo "$as_me:$LINENO: result: no" >&5
7246 echo "${ECHO_T}no" >&6
7247 fi
7248
7249   fi
7250   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7251     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7252 set dummy ${ncn_progname}; ac_word=$2
7253 echo "$as_me:$LINENO: checking for $ac_word" >&5
7254 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7255 if test "${ac_cv_prog_LD+set}" = set; then
7256   echo $ECHO_N "(cached) $ECHO_C" >&6
7257 else
7258   if test -n "$LD"; then
7259   ac_cv_prog_LD="$LD" # Let the user override the test.
7260 else
7261 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7262 for as_dir in $PATH
7263 do
7264   IFS=$as_save_IFS
7265   test -z "$as_dir" && as_dir=.
7266   for ac_exec_ext in '' $ac_executable_extensions; do
7267   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7268     ac_cv_prog_LD="${ncn_progname}"
7269     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7270     break 2
7271   fi
7272 done
7273 done
7274
7275 fi
7276 fi
7277 LD=$ac_cv_prog_LD
7278 if test -n "$LD"; then
7279   echo "$as_me:$LINENO: result: $LD" >&5
7280 echo "${ECHO_T}$LD" >&6
7281 else
7282   echo "$as_me:$LINENO: result: no" >&5
7283 echo "${ECHO_T}no" >&6
7284 fi
7285
7286   fi
7287   test -n "$ac_cv_prog_LD" && break
7288 done
7289
7290 if test -z "$ac_cv_prog_LD" ; then
7291   set dummy ld
7292   if test $build = $host ; then
7293     LD="$2"
7294   else
7295     LD="${ncn_tool_prefix}$2"
7296   fi
7297 fi
7298
7299
7300
7301 if test -n "$LIPO"; then
7302   ac_cv_prog_LIPO=$LIPO
7303 elif test -n "$ac_cv_prog_LIPO"; then
7304   LIPO=$ac_cv_prog_LIPO
7305 fi
7306
7307 if test -n "$ac_cv_prog_LIPO"; then
7308   for ncn_progname in lipo; do
7309     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7310 set dummy ${ncn_progname}; ac_word=$2
7311 echo "$as_me:$LINENO: checking for $ac_word" >&5
7312 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7313 if test "${ac_cv_prog_LIPO+set}" = set; then
7314   echo $ECHO_N "(cached) $ECHO_C" >&6
7315 else
7316   if test -n "$LIPO"; then
7317   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7318 else
7319 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7320 for as_dir in $PATH
7321 do
7322   IFS=$as_save_IFS
7323   test -z "$as_dir" && as_dir=.
7324   for ac_exec_ext in '' $ac_executable_extensions; do
7325   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7326     ac_cv_prog_LIPO="${ncn_progname}"
7327     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7328     break 2
7329   fi
7330 done
7331 done
7332
7333 fi
7334 fi
7335 LIPO=$ac_cv_prog_LIPO
7336 if test -n "$LIPO"; then
7337   echo "$as_me:$LINENO: result: $LIPO" >&5
7338 echo "${ECHO_T}$LIPO" >&6
7339 else
7340   echo "$as_me:$LINENO: result: no" >&5
7341 echo "${ECHO_T}no" >&6
7342 fi
7343
7344   done
7345 fi
7346
7347 for ncn_progname in lipo; do
7348   if test -n "$ncn_tool_prefix"; then
7349     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7350 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7351 echo "$as_me:$LINENO: checking for $ac_word" >&5
7352 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7353 if test "${ac_cv_prog_LIPO+set}" = set; then
7354   echo $ECHO_N "(cached) $ECHO_C" >&6
7355 else
7356   if test -n "$LIPO"; then
7357   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7358 else
7359 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7360 for as_dir in $PATH
7361 do
7362   IFS=$as_save_IFS
7363   test -z "$as_dir" && as_dir=.
7364   for ac_exec_ext in '' $ac_executable_extensions; do
7365   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7366     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7367     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7368     break 2
7369   fi
7370 done
7371 done
7372
7373 fi
7374 fi
7375 LIPO=$ac_cv_prog_LIPO
7376 if test -n "$LIPO"; then
7377   echo "$as_me:$LINENO: result: $LIPO" >&5
7378 echo "${ECHO_T}$LIPO" >&6
7379 else
7380   echo "$as_me:$LINENO: result: no" >&5
7381 echo "${ECHO_T}no" >&6
7382 fi
7383
7384   fi
7385   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7386     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7387 set dummy ${ncn_progname}; ac_word=$2
7388 echo "$as_me:$LINENO: checking for $ac_word" >&5
7389 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7390 if test "${ac_cv_prog_LIPO+set}" = set; then
7391   echo $ECHO_N "(cached) $ECHO_C" >&6
7392 else
7393   if test -n "$LIPO"; then
7394   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7395 else
7396 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7397 for as_dir in $PATH
7398 do
7399   IFS=$as_save_IFS
7400   test -z "$as_dir" && as_dir=.
7401   for ac_exec_ext in '' $ac_executable_extensions; do
7402   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7403     ac_cv_prog_LIPO="${ncn_progname}"
7404     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7405     break 2
7406   fi
7407 done
7408 done
7409
7410 fi
7411 fi
7412 LIPO=$ac_cv_prog_LIPO
7413 if test -n "$LIPO"; then
7414   echo "$as_me:$LINENO: result: $LIPO" >&5
7415 echo "${ECHO_T}$LIPO" >&6
7416 else
7417   echo "$as_me:$LINENO: result: no" >&5
7418 echo "${ECHO_T}no" >&6
7419 fi
7420
7421   fi
7422   test -n "$ac_cv_prog_LIPO" && break
7423 done
7424
7425 if test -z "$ac_cv_prog_LIPO" ; then
7426   set dummy lipo
7427   if test $build = $host ; then
7428     LIPO="$2"
7429   else
7430     LIPO="${ncn_tool_prefix}$2"
7431   fi
7432 fi
7433
7434
7435
7436 if test -n "$NM"; then
7437   ac_cv_prog_NM=$NM
7438 elif test -n "$ac_cv_prog_NM"; then
7439   NM=$ac_cv_prog_NM
7440 fi
7441
7442 if test -n "$ac_cv_prog_NM"; then
7443   for ncn_progname in nm; do
7444     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7445 set dummy ${ncn_progname}; ac_word=$2
7446 echo "$as_me:$LINENO: checking for $ac_word" >&5
7447 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7448 if test "${ac_cv_prog_NM+set}" = set; then
7449   echo $ECHO_N "(cached) $ECHO_C" >&6
7450 else
7451   if test -n "$NM"; then
7452   ac_cv_prog_NM="$NM" # Let the user override the test.
7453 else
7454 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7455 for as_dir in $PATH
7456 do
7457   IFS=$as_save_IFS
7458   test -z "$as_dir" && as_dir=.
7459   for ac_exec_ext in '' $ac_executable_extensions; do
7460   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7461     ac_cv_prog_NM="${ncn_progname}"
7462     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7463     break 2
7464   fi
7465 done
7466 done
7467
7468 fi
7469 fi
7470 NM=$ac_cv_prog_NM
7471 if test -n "$NM"; then
7472   echo "$as_me:$LINENO: result: $NM" >&5
7473 echo "${ECHO_T}$NM" >&6
7474 else
7475   echo "$as_me:$LINENO: result: no" >&5
7476 echo "${ECHO_T}no" >&6
7477 fi
7478
7479   done
7480 fi
7481
7482 for ncn_progname in nm; do
7483   if test -n "$ncn_tool_prefix"; then
7484     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7485 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7486 echo "$as_me:$LINENO: checking for $ac_word" >&5
7487 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7488 if test "${ac_cv_prog_NM+set}" = set; then
7489   echo $ECHO_N "(cached) $ECHO_C" >&6
7490 else
7491   if test -n "$NM"; then
7492   ac_cv_prog_NM="$NM" # Let the user override the test.
7493 else
7494 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7495 for as_dir in $PATH
7496 do
7497   IFS=$as_save_IFS
7498   test -z "$as_dir" && as_dir=.
7499   for ac_exec_ext in '' $ac_executable_extensions; do
7500   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7501     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7502     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7503     break 2
7504   fi
7505 done
7506 done
7507
7508 fi
7509 fi
7510 NM=$ac_cv_prog_NM
7511 if test -n "$NM"; then
7512   echo "$as_me:$LINENO: result: $NM" >&5
7513 echo "${ECHO_T}$NM" >&6
7514 else
7515   echo "$as_me:$LINENO: result: no" >&5
7516 echo "${ECHO_T}no" >&6
7517 fi
7518
7519   fi
7520   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7521     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7522 set dummy ${ncn_progname}; ac_word=$2
7523 echo "$as_me:$LINENO: checking for $ac_word" >&5
7524 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7525 if test "${ac_cv_prog_NM+set}" = set; then
7526   echo $ECHO_N "(cached) $ECHO_C" >&6
7527 else
7528   if test -n "$NM"; then
7529   ac_cv_prog_NM="$NM" # Let the user override the test.
7530 else
7531 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7532 for as_dir in $PATH
7533 do
7534   IFS=$as_save_IFS
7535   test -z "$as_dir" && as_dir=.
7536   for ac_exec_ext in '' $ac_executable_extensions; do
7537   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7538     ac_cv_prog_NM="${ncn_progname}"
7539     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7540     break 2
7541   fi
7542 done
7543 done
7544
7545 fi
7546 fi
7547 NM=$ac_cv_prog_NM
7548 if test -n "$NM"; then
7549   echo "$as_me:$LINENO: result: $NM" >&5
7550 echo "${ECHO_T}$NM" >&6
7551 else
7552   echo "$as_me:$LINENO: result: no" >&5
7553 echo "${ECHO_T}no" >&6
7554 fi
7555
7556   fi
7557   test -n "$ac_cv_prog_NM" && break
7558 done
7559
7560 if test -z "$ac_cv_prog_NM" ; then
7561   set dummy nm
7562   if test $build = $host ; then
7563     NM="$2"
7564   else
7565     NM="${ncn_tool_prefix}$2"
7566   fi
7567 fi
7568
7569
7570
7571 if test -n "$RANLIB"; then
7572   ac_cv_prog_RANLIB=$RANLIB
7573 elif test -n "$ac_cv_prog_RANLIB"; then
7574   RANLIB=$ac_cv_prog_RANLIB
7575 fi
7576
7577 if test -n "$ac_cv_prog_RANLIB"; then
7578   for ncn_progname in ranlib; do
7579     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7580 set dummy ${ncn_progname}; ac_word=$2
7581 echo "$as_me:$LINENO: checking for $ac_word" >&5
7582 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7583 if test "${ac_cv_prog_RANLIB+set}" = set; then
7584   echo $ECHO_N "(cached) $ECHO_C" >&6
7585 else
7586   if test -n "$RANLIB"; then
7587   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7588 else
7589 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7590 for as_dir in $PATH
7591 do
7592   IFS=$as_save_IFS
7593   test -z "$as_dir" && as_dir=.
7594   for ac_exec_ext in '' $ac_executable_extensions; do
7595   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7596     ac_cv_prog_RANLIB="${ncn_progname}"
7597     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7598     break 2
7599   fi
7600 done
7601 done
7602
7603 fi
7604 fi
7605 RANLIB=$ac_cv_prog_RANLIB
7606 if test -n "$RANLIB"; then
7607   echo "$as_me:$LINENO: result: $RANLIB" >&5
7608 echo "${ECHO_T}$RANLIB" >&6
7609 else
7610   echo "$as_me:$LINENO: result: no" >&5
7611 echo "${ECHO_T}no" >&6
7612 fi
7613
7614   done
7615 fi
7616
7617 for ncn_progname in ranlib; do
7618   if test -n "$ncn_tool_prefix"; then
7619     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7620 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7621 echo "$as_me:$LINENO: checking for $ac_word" >&5
7622 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7623 if test "${ac_cv_prog_RANLIB+set}" = set; then
7624   echo $ECHO_N "(cached) $ECHO_C" >&6
7625 else
7626   if test -n "$RANLIB"; then
7627   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7628 else
7629 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7630 for as_dir in $PATH
7631 do
7632   IFS=$as_save_IFS
7633   test -z "$as_dir" && as_dir=.
7634   for ac_exec_ext in '' $ac_executable_extensions; do
7635   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7636     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7637     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7638     break 2
7639   fi
7640 done
7641 done
7642
7643 fi
7644 fi
7645 RANLIB=$ac_cv_prog_RANLIB
7646 if test -n "$RANLIB"; then
7647   echo "$as_me:$LINENO: result: $RANLIB" >&5
7648 echo "${ECHO_T}$RANLIB" >&6
7649 else
7650   echo "$as_me:$LINENO: result: no" >&5
7651 echo "${ECHO_T}no" >&6
7652 fi
7653
7654   fi
7655   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7656     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7657 set dummy ${ncn_progname}; ac_word=$2
7658 echo "$as_me:$LINENO: checking for $ac_word" >&5
7659 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7660 if test "${ac_cv_prog_RANLIB+set}" = set; then
7661   echo $ECHO_N "(cached) $ECHO_C" >&6
7662 else
7663   if test -n "$RANLIB"; then
7664   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7665 else
7666 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7667 for as_dir in $PATH
7668 do
7669   IFS=$as_save_IFS
7670   test -z "$as_dir" && as_dir=.
7671   for ac_exec_ext in '' $ac_executable_extensions; do
7672   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7673     ac_cv_prog_RANLIB="${ncn_progname}"
7674     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7675     break 2
7676   fi
7677 done
7678 done
7679
7680 fi
7681 fi
7682 RANLIB=$ac_cv_prog_RANLIB
7683 if test -n "$RANLIB"; then
7684   echo "$as_me:$LINENO: result: $RANLIB" >&5
7685 echo "${ECHO_T}$RANLIB" >&6
7686 else
7687   echo "$as_me:$LINENO: result: no" >&5
7688 echo "${ECHO_T}no" >&6
7689 fi
7690
7691   fi
7692   test -n "$ac_cv_prog_RANLIB" && break
7693 done
7694
7695 if test -z "$ac_cv_prog_RANLIB" ; then
7696   RANLIB=":"
7697 fi
7698
7699
7700
7701 if test -n "$STRIP"; then
7702   ac_cv_prog_STRIP=$STRIP
7703 elif test -n "$ac_cv_prog_STRIP"; then
7704   STRIP=$ac_cv_prog_STRIP
7705 fi
7706
7707 if test -n "$ac_cv_prog_STRIP"; then
7708   for ncn_progname in strip; do
7709     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7710 set dummy ${ncn_progname}; ac_word=$2
7711 echo "$as_me:$LINENO: checking for $ac_word" >&5
7712 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7713 if test "${ac_cv_prog_STRIP+set}" = set; then
7714   echo $ECHO_N "(cached) $ECHO_C" >&6
7715 else
7716   if test -n "$STRIP"; then
7717   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7718 else
7719 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7720 for as_dir in $PATH
7721 do
7722   IFS=$as_save_IFS
7723   test -z "$as_dir" && as_dir=.
7724   for ac_exec_ext in '' $ac_executable_extensions; do
7725   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7726     ac_cv_prog_STRIP="${ncn_progname}"
7727     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7728     break 2
7729   fi
7730 done
7731 done
7732
7733 fi
7734 fi
7735 STRIP=$ac_cv_prog_STRIP
7736 if test -n "$STRIP"; then
7737   echo "$as_me:$LINENO: result: $STRIP" >&5
7738 echo "${ECHO_T}$STRIP" >&6
7739 else
7740   echo "$as_me:$LINENO: result: no" >&5
7741 echo "${ECHO_T}no" >&6
7742 fi
7743
7744   done
7745 fi
7746
7747 for ncn_progname in strip; do
7748   if test -n "$ncn_tool_prefix"; then
7749     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7750 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7751 echo "$as_me:$LINENO: checking for $ac_word" >&5
7752 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7753 if test "${ac_cv_prog_STRIP+set}" = set; then
7754   echo $ECHO_N "(cached) $ECHO_C" >&6
7755 else
7756   if test -n "$STRIP"; then
7757   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7758 else
7759 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7760 for as_dir in $PATH
7761 do
7762   IFS=$as_save_IFS
7763   test -z "$as_dir" && as_dir=.
7764   for ac_exec_ext in '' $ac_executable_extensions; do
7765   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7766     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7767     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7768     break 2
7769   fi
7770 done
7771 done
7772
7773 fi
7774 fi
7775 STRIP=$ac_cv_prog_STRIP
7776 if test -n "$STRIP"; then
7777   echo "$as_me:$LINENO: result: $STRIP" >&5
7778 echo "${ECHO_T}$STRIP" >&6
7779 else
7780   echo "$as_me:$LINENO: result: no" >&5
7781 echo "${ECHO_T}no" >&6
7782 fi
7783
7784   fi
7785   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7786     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7787 set dummy ${ncn_progname}; ac_word=$2
7788 echo "$as_me:$LINENO: checking for $ac_word" >&5
7789 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7790 if test "${ac_cv_prog_STRIP+set}" = set; then
7791   echo $ECHO_N "(cached) $ECHO_C" >&6
7792 else
7793   if test -n "$STRIP"; then
7794   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7795 else
7796 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7797 for as_dir in $PATH
7798 do
7799   IFS=$as_save_IFS
7800   test -z "$as_dir" && as_dir=.
7801   for ac_exec_ext in '' $ac_executable_extensions; do
7802   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7803     ac_cv_prog_STRIP="${ncn_progname}"
7804     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7805     break 2
7806   fi
7807 done
7808 done
7809
7810 fi
7811 fi
7812 STRIP=$ac_cv_prog_STRIP
7813 if test -n "$STRIP"; then
7814   echo "$as_me:$LINENO: result: $STRIP" >&5
7815 echo "${ECHO_T}$STRIP" >&6
7816 else
7817   echo "$as_me:$LINENO: result: no" >&5
7818 echo "${ECHO_T}no" >&6
7819 fi
7820
7821   fi
7822   test -n "$ac_cv_prog_STRIP" && break
7823 done
7824
7825 if test -z "$ac_cv_prog_STRIP" ; then
7826   STRIP=":"
7827 fi
7828
7829
7830
7831 if test -n "$WINDRES"; then
7832   ac_cv_prog_WINDRES=$WINDRES
7833 elif test -n "$ac_cv_prog_WINDRES"; then
7834   WINDRES=$ac_cv_prog_WINDRES
7835 fi
7836
7837 if test -n "$ac_cv_prog_WINDRES"; then
7838   for ncn_progname in windres; do
7839     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7840 set dummy ${ncn_progname}; ac_word=$2
7841 echo "$as_me:$LINENO: checking for $ac_word" >&5
7842 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7843 if test "${ac_cv_prog_WINDRES+set}" = set; then
7844   echo $ECHO_N "(cached) $ECHO_C" >&6
7845 else
7846   if test -n "$WINDRES"; then
7847   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7848 else
7849 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7850 for as_dir in $PATH
7851 do
7852   IFS=$as_save_IFS
7853   test -z "$as_dir" && as_dir=.
7854   for ac_exec_ext in '' $ac_executable_extensions; do
7855   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7856     ac_cv_prog_WINDRES="${ncn_progname}"
7857     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7858     break 2
7859   fi
7860 done
7861 done
7862
7863 fi
7864 fi
7865 WINDRES=$ac_cv_prog_WINDRES
7866 if test -n "$WINDRES"; then
7867   echo "$as_me:$LINENO: result: $WINDRES" >&5
7868 echo "${ECHO_T}$WINDRES" >&6
7869 else
7870   echo "$as_me:$LINENO: result: no" >&5
7871 echo "${ECHO_T}no" >&6
7872 fi
7873
7874   done
7875 fi
7876
7877 for ncn_progname in windres; do
7878   if test -n "$ncn_tool_prefix"; then
7879     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7880 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7881 echo "$as_me:$LINENO: checking for $ac_word" >&5
7882 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7883 if test "${ac_cv_prog_WINDRES+set}" = set; then
7884   echo $ECHO_N "(cached) $ECHO_C" >&6
7885 else
7886   if test -n "$WINDRES"; then
7887   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7888 else
7889 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7890 for as_dir in $PATH
7891 do
7892   IFS=$as_save_IFS
7893   test -z "$as_dir" && as_dir=.
7894   for ac_exec_ext in '' $ac_executable_extensions; do
7895   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7896     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7897     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7898     break 2
7899   fi
7900 done
7901 done
7902
7903 fi
7904 fi
7905 WINDRES=$ac_cv_prog_WINDRES
7906 if test -n "$WINDRES"; then
7907   echo "$as_me:$LINENO: result: $WINDRES" >&5
7908 echo "${ECHO_T}$WINDRES" >&6
7909 else
7910   echo "$as_me:$LINENO: result: no" >&5
7911 echo "${ECHO_T}no" >&6
7912 fi
7913
7914   fi
7915   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7916     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7917 set dummy ${ncn_progname}; ac_word=$2
7918 echo "$as_me:$LINENO: checking for $ac_word" >&5
7919 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7920 if test "${ac_cv_prog_WINDRES+set}" = set; then
7921   echo $ECHO_N "(cached) $ECHO_C" >&6
7922 else
7923   if test -n "$WINDRES"; then
7924   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7925 else
7926 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7927 for as_dir in $PATH
7928 do
7929   IFS=$as_save_IFS
7930   test -z "$as_dir" && as_dir=.
7931   for ac_exec_ext in '' $ac_executable_extensions; do
7932   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7933     ac_cv_prog_WINDRES="${ncn_progname}"
7934     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7935     break 2
7936   fi
7937 done
7938 done
7939
7940 fi
7941 fi
7942 WINDRES=$ac_cv_prog_WINDRES
7943 if test -n "$WINDRES"; then
7944   echo "$as_me:$LINENO: result: $WINDRES" >&5
7945 echo "${ECHO_T}$WINDRES" >&6
7946 else
7947   echo "$as_me:$LINENO: result: no" >&5
7948 echo "${ECHO_T}no" >&6
7949 fi
7950
7951   fi
7952   test -n "$ac_cv_prog_WINDRES" && break
7953 done
7954
7955 if test -z "$ac_cv_prog_WINDRES" ; then
7956   set dummy windres
7957   if test $build = $host ; then
7958     WINDRES="$2"
7959   else
7960     WINDRES="${ncn_tool_prefix}$2"
7961   fi
7962 fi
7963
7964
7965
7966 if test -n "$WINDMC"; then
7967   ac_cv_prog_WINDMC=$WINDMC
7968 elif test -n "$ac_cv_prog_WINDMC"; then
7969   WINDMC=$ac_cv_prog_WINDMC
7970 fi
7971
7972 if test -n "$ac_cv_prog_WINDMC"; then
7973   for ncn_progname in windmc; do
7974     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7975 set dummy ${ncn_progname}; ac_word=$2
7976 echo "$as_me:$LINENO: checking for $ac_word" >&5
7977 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7978 if test "${ac_cv_prog_WINDMC+set}" = set; then
7979   echo $ECHO_N "(cached) $ECHO_C" >&6
7980 else
7981   if test -n "$WINDMC"; then
7982   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7983 else
7984 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7985 for as_dir in $PATH
7986 do
7987   IFS=$as_save_IFS
7988   test -z "$as_dir" && as_dir=.
7989   for ac_exec_ext in '' $ac_executable_extensions; do
7990   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7991     ac_cv_prog_WINDMC="${ncn_progname}"
7992     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7993     break 2
7994   fi
7995 done
7996 done
7997
7998 fi
7999 fi
8000 WINDMC=$ac_cv_prog_WINDMC
8001 if test -n "$WINDMC"; then
8002   echo "$as_me:$LINENO: result: $WINDMC" >&5
8003 echo "${ECHO_T}$WINDMC" >&6
8004 else
8005   echo "$as_me:$LINENO: result: no" >&5
8006 echo "${ECHO_T}no" >&6
8007 fi
8008
8009   done
8010 fi
8011
8012 for ncn_progname in windmc; do
8013   if test -n "$ncn_tool_prefix"; then
8014     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8015 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8016 echo "$as_me:$LINENO: checking for $ac_word" >&5
8017 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8018 if test "${ac_cv_prog_WINDMC+set}" = set; then
8019   echo $ECHO_N "(cached) $ECHO_C" >&6
8020 else
8021   if test -n "$WINDMC"; then
8022   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8023 else
8024 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8025 for as_dir in $PATH
8026 do
8027   IFS=$as_save_IFS
8028   test -z "$as_dir" && as_dir=.
8029   for ac_exec_ext in '' $ac_executable_extensions; do
8030   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8031     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8032     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8033     break 2
8034   fi
8035 done
8036 done
8037
8038 fi
8039 fi
8040 WINDMC=$ac_cv_prog_WINDMC
8041 if test -n "$WINDMC"; then
8042   echo "$as_me:$LINENO: result: $WINDMC" >&5
8043 echo "${ECHO_T}$WINDMC" >&6
8044 else
8045   echo "$as_me:$LINENO: result: no" >&5
8046 echo "${ECHO_T}no" >&6
8047 fi
8048
8049   fi
8050   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8051     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8052 set dummy ${ncn_progname}; ac_word=$2
8053 echo "$as_me:$LINENO: checking for $ac_word" >&5
8054 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8055 if test "${ac_cv_prog_WINDMC+set}" = set; then
8056   echo $ECHO_N "(cached) $ECHO_C" >&6
8057 else
8058   if test -n "$WINDMC"; then
8059   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8060 else
8061 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8062 for as_dir in $PATH
8063 do
8064   IFS=$as_save_IFS
8065   test -z "$as_dir" && as_dir=.
8066   for ac_exec_ext in '' $ac_executable_extensions; do
8067   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8068     ac_cv_prog_WINDMC="${ncn_progname}"
8069     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8070     break 2
8071   fi
8072 done
8073 done
8074
8075 fi
8076 fi
8077 WINDMC=$ac_cv_prog_WINDMC
8078 if test -n "$WINDMC"; then
8079   echo "$as_me:$LINENO: result: $WINDMC" >&5
8080 echo "${ECHO_T}$WINDMC" >&6
8081 else
8082   echo "$as_me:$LINENO: result: no" >&5
8083 echo "${ECHO_T}no" >&6
8084 fi
8085
8086   fi
8087   test -n "$ac_cv_prog_WINDMC" && break
8088 done
8089
8090 if test -z "$ac_cv_prog_WINDMC" ; then
8091   set dummy windmc
8092   if test $build = $host ; then
8093     WINDMC="$2"
8094   else
8095     WINDMC="${ncn_tool_prefix}$2"
8096   fi
8097 fi
8098
8099
8100
8101 if test -n "$OBJCOPY"; then
8102   ac_cv_prog_OBJCOPY=$OBJCOPY
8103 elif test -n "$ac_cv_prog_OBJCOPY"; then
8104   OBJCOPY=$ac_cv_prog_OBJCOPY
8105 fi
8106
8107 if test -n "$ac_cv_prog_OBJCOPY"; then
8108   for ncn_progname in objcopy; do
8109     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8110 set dummy ${ncn_progname}; ac_word=$2
8111 echo "$as_me:$LINENO: checking for $ac_word" >&5
8112 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8113 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8114   echo $ECHO_N "(cached) $ECHO_C" >&6
8115 else
8116   if test -n "$OBJCOPY"; then
8117   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8118 else
8119 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8120 for as_dir in $PATH
8121 do
8122   IFS=$as_save_IFS
8123   test -z "$as_dir" && as_dir=.
8124   for ac_exec_ext in '' $ac_executable_extensions; do
8125   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8126     ac_cv_prog_OBJCOPY="${ncn_progname}"
8127     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8128     break 2
8129   fi
8130 done
8131 done
8132
8133 fi
8134 fi
8135 OBJCOPY=$ac_cv_prog_OBJCOPY
8136 if test -n "$OBJCOPY"; then
8137   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8138 echo "${ECHO_T}$OBJCOPY" >&6
8139 else
8140   echo "$as_me:$LINENO: result: no" >&5
8141 echo "${ECHO_T}no" >&6
8142 fi
8143
8144   done
8145 fi
8146
8147 for ncn_progname in objcopy; do
8148   if test -n "$ncn_tool_prefix"; then
8149     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8150 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8151 echo "$as_me:$LINENO: checking for $ac_word" >&5
8152 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8153 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8154   echo $ECHO_N "(cached) $ECHO_C" >&6
8155 else
8156   if test -n "$OBJCOPY"; then
8157   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8158 else
8159 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8160 for as_dir in $PATH
8161 do
8162   IFS=$as_save_IFS
8163   test -z "$as_dir" && as_dir=.
8164   for ac_exec_ext in '' $ac_executable_extensions; do
8165   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8166     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8167     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8168     break 2
8169   fi
8170 done
8171 done
8172
8173 fi
8174 fi
8175 OBJCOPY=$ac_cv_prog_OBJCOPY
8176 if test -n "$OBJCOPY"; then
8177   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8178 echo "${ECHO_T}$OBJCOPY" >&6
8179 else
8180   echo "$as_me:$LINENO: result: no" >&5
8181 echo "${ECHO_T}no" >&6
8182 fi
8183
8184   fi
8185   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8186     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8187 set dummy ${ncn_progname}; ac_word=$2
8188 echo "$as_me:$LINENO: checking for $ac_word" >&5
8189 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8190 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8191   echo $ECHO_N "(cached) $ECHO_C" >&6
8192 else
8193   if test -n "$OBJCOPY"; then
8194   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8195 else
8196 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8197 for as_dir in $PATH
8198 do
8199   IFS=$as_save_IFS
8200   test -z "$as_dir" && as_dir=.
8201   for ac_exec_ext in '' $ac_executable_extensions; do
8202   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8203     ac_cv_prog_OBJCOPY="${ncn_progname}"
8204     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8205     break 2
8206   fi
8207 done
8208 done
8209
8210 fi
8211 fi
8212 OBJCOPY=$ac_cv_prog_OBJCOPY
8213 if test -n "$OBJCOPY"; then
8214   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8215 echo "${ECHO_T}$OBJCOPY" >&6
8216 else
8217   echo "$as_me:$LINENO: result: no" >&5
8218 echo "${ECHO_T}no" >&6
8219 fi
8220
8221   fi
8222   test -n "$ac_cv_prog_OBJCOPY" && break
8223 done
8224
8225 if test -z "$ac_cv_prog_OBJCOPY" ; then
8226   set dummy objcopy
8227   if test $build = $host ; then
8228     OBJCOPY="$2"
8229   else
8230     OBJCOPY="${ncn_tool_prefix}$2"
8231   fi
8232 fi
8233
8234
8235
8236 if test -n "$OBJDUMP"; then
8237   ac_cv_prog_OBJDUMP=$OBJDUMP
8238 elif test -n "$ac_cv_prog_OBJDUMP"; then
8239   OBJDUMP=$ac_cv_prog_OBJDUMP
8240 fi
8241
8242 if test -n "$ac_cv_prog_OBJDUMP"; then
8243   for ncn_progname in objdump; do
8244     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8245 set dummy ${ncn_progname}; ac_word=$2
8246 echo "$as_me:$LINENO: checking for $ac_word" >&5
8247 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8248 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8249   echo $ECHO_N "(cached) $ECHO_C" >&6
8250 else
8251   if test -n "$OBJDUMP"; then
8252   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8253 else
8254 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8255 for as_dir in $PATH
8256 do
8257   IFS=$as_save_IFS
8258   test -z "$as_dir" && as_dir=.
8259   for ac_exec_ext in '' $ac_executable_extensions; do
8260   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8261     ac_cv_prog_OBJDUMP="${ncn_progname}"
8262     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8263     break 2
8264   fi
8265 done
8266 done
8267
8268 fi
8269 fi
8270 OBJDUMP=$ac_cv_prog_OBJDUMP
8271 if test -n "$OBJDUMP"; then
8272   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8273 echo "${ECHO_T}$OBJDUMP" >&6
8274 else
8275   echo "$as_me:$LINENO: result: no" >&5
8276 echo "${ECHO_T}no" >&6
8277 fi
8278
8279   done
8280 fi
8281
8282 for ncn_progname in objdump; do
8283   if test -n "$ncn_tool_prefix"; then
8284     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8285 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8286 echo "$as_me:$LINENO: checking for $ac_word" >&5
8287 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8288 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8289   echo $ECHO_N "(cached) $ECHO_C" >&6
8290 else
8291   if test -n "$OBJDUMP"; then
8292   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8293 else
8294 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8295 for as_dir in $PATH
8296 do
8297   IFS=$as_save_IFS
8298   test -z "$as_dir" && as_dir=.
8299   for ac_exec_ext in '' $ac_executable_extensions; do
8300   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8301     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8302     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8303     break 2
8304   fi
8305 done
8306 done
8307
8308 fi
8309 fi
8310 OBJDUMP=$ac_cv_prog_OBJDUMP
8311 if test -n "$OBJDUMP"; then
8312   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8313 echo "${ECHO_T}$OBJDUMP" >&6
8314 else
8315   echo "$as_me:$LINENO: result: no" >&5
8316 echo "${ECHO_T}no" >&6
8317 fi
8318
8319   fi
8320   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8321     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8322 set dummy ${ncn_progname}; ac_word=$2
8323 echo "$as_me:$LINENO: checking for $ac_word" >&5
8324 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8325 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8326   echo $ECHO_N "(cached) $ECHO_C" >&6
8327 else
8328   if test -n "$OBJDUMP"; then
8329   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8330 else
8331 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8332 for as_dir in $PATH
8333 do
8334   IFS=$as_save_IFS
8335   test -z "$as_dir" && as_dir=.
8336   for ac_exec_ext in '' $ac_executable_extensions; do
8337   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8338     ac_cv_prog_OBJDUMP="${ncn_progname}"
8339     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8340     break 2
8341   fi
8342 done
8343 done
8344
8345 fi
8346 fi
8347 OBJDUMP=$ac_cv_prog_OBJDUMP
8348 if test -n "$OBJDUMP"; then
8349   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8350 echo "${ECHO_T}$OBJDUMP" >&6
8351 else
8352   echo "$as_me:$LINENO: result: no" >&5
8353 echo "${ECHO_T}no" >&6
8354 fi
8355
8356   fi
8357   test -n "$ac_cv_prog_OBJDUMP" && break
8358 done
8359
8360 if test -z "$ac_cv_prog_OBJDUMP" ; then
8361   set dummy objdump
8362   if test $build = $host ; then
8363     OBJDUMP="$2"
8364   else
8365     OBJDUMP="${ncn_tool_prefix}$2"
8366   fi
8367 fi
8368
8369
8370
8371
8372
8373
8374 # Target tools.
8375
8376 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8377 if test "${with_build_time_tools+set}" = set; then
8378   withval="$with_build_time_tools"
8379   case x"$withval" in
8380      x/*) ;;
8381      *)
8382        with_build_time_tools=
8383        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8384 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8385        ;;
8386    esac
8387 else
8388   with_build_time_tools=
8389 fi;
8390
8391
8392
8393 if test -n "$CC_FOR_TARGET"; then
8394   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8395 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8396   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8397 fi
8398
8399 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8400   for ncn_progname in cc gcc; do
8401     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8402 set dummy ${ncn_progname}; ac_word=$2
8403 echo "$as_me:$LINENO: checking for $ac_word" >&5
8404 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8405 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8406   echo $ECHO_N "(cached) $ECHO_C" >&6
8407 else
8408   if test -n "$CC_FOR_TARGET"; then
8409   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8410 else
8411 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8412 for as_dir in $PATH
8413 do
8414   IFS=$as_save_IFS
8415   test -z "$as_dir" && as_dir=.
8416   for ac_exec_ext in '' $ac_executable_extensions; do
8417   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8418     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8419     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8420     break 2
8421   fi
8422 done
8423 done
8424
8425 fi
8426 fi
8427 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8428 if test -n "$CC_FOR_TARGET"; then
8429   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8430 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8431 else
8432   echo "$as_me:$LINENO: result: no" >&5
8433 echo "${ECHO_T}no" >&6
8434 fi
8435
8436   done
8437 fi
8438
8439 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8440   for ncn_progname in cc gcc; do
8441     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8442 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8443     if test -x $with_build_time_tools/${ncn_progname}; then
8444       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8445       echo "$as_me:$LINENO: result: yes" >&5
8446 echo "${ECHO_T}yes" >&6
8447       break
8448     else
8449       echo "$as_me:$LINENO: result: no" >&5
8450 echo "${ECHO_T}no" >&6
8451     fi
8452   done
8453 fi
8454
8455 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8456   for ncn_progname in cc gcc; do
8457     if test -n "$ncn_target_tool_prefix"; then
8458       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8459 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8460 echo "$as_me:$LINENO: checking for $ac_word" >&5
8461 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8462 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8463   echo $ECHO_N "(cached) $ECHO_C" >&6
8464 else
8465   if test -n "$CC_FOR_TARGET"; then
8466   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8467 else
8468 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8469 for as_dir in $PATH
8470 do
8471   IFS=$as_save_IFS
8472   test -z "$as_dir" && as_dir=.
8473   for ac_exec_ext in '' $ac_executable_extensions; do
8474   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8475     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8476     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8477     break 2
8478   fi
8479 done
8480 done
8481
8482 fi
8483 fi
8484 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8485 if test -n "$CC_FOR_TARGET"; then
8486   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8487 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8488 else
8489   echo "$as_me:$LINENO: result: no" >&5
8490 echo "${ECHO_T}no" >&6
8491 fi
8492
8493     fi
8494     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8495       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8496 set dummy ${ncn_progname}; ac_word=$2
8497 echo "$as_me:$LINENO: checking for $ac_word" >&5
8498 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8499 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8500   echo $ECHO_N "(cached) $ECHO_C" >&6
8501 else
8502   if test -n "$CC_FOR_TARGET"; then
8503   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8504 else
8505 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8506 for as_dir in $PATH
8507 do
8508   IFS=$as_save_IFS
8509   test -z "$as_dir" && as_dir=.
8510   for ac_exec_ext in '' $ac_executable_extensions; do
8511   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8512     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8513     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8514     break 2
8515   fi
8516 done
8517 done
8518
8519 fi
8520 fi
8521 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8522 if test -n "$CC_FOR_TARGET"; then
8523   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8524 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8525 else
8526   echo "$as_me:$LINENO: result: no" >&5
8527 echo "${ECHO_T}no" >&6
8528 fi
8529
8530     fi
8531     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8532   done
8533 fi
8534
8535 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8536   set dummy cc gcc
8537   if test $build = $target ; then
8538     CC_FOR_TARGET="$2"
8539   else
8540     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8541   fi
8542 else
8543   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8544 fi
8545
8546
8547
8548 if test -n "$CXX_FOR_TARGET"; then
8549   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8550 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8551   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8552 fi
8553
8554 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8555   for ncn_progname in c++ g++ cxx gxx; do
8556     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8557 set dummy ${ncn_progname}; ac_word=$2
8558 echo "$as_me:$LINENO: checking for $ac_word" >&5
8559 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8560 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8561   echo $ECHO_N "(cached) $ECHO_C" >&6
8562 else
8563   if test -n "$CXX_FOR_TARGET"; then
8564   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8565 else
8566 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8567 for as_dir in $PATH
8568 do
8569   IFS=$as_save_IFS
8570   test -z "$as_dir" && as_dir=.
8571   for ac_exec_ext in '' $ac_executable_extensions; do
8572   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8573     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8574     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8575     break 2
8576   fi
8577 done
8578 done
8579
8580 fi
8581 fi
8582 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8583 if test -n "$CXX_FOR_TARGET"; then
8584   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8585 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8586 else
8587   echo "$as_me:$LINENO: result: no" >&5
8588 echo "${ECHO_T}no" >&6
8589 fi
8590
8591   done
8592 fi
8593
8594 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8595   for ncn_progname in c++ g++ cxx gxx; do
8596     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8597 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8598     if test -x $with_build_time_tools/${ncn_progname}; then
8599       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8600       echo "$as_me:$LINENO: result: yes" >&5
8601 echo "${ECHO_T}yes" >&6
8602       break
8603     else
8604       echo "$as_me:$LINENO: result: no" >&5
8605 echo "${ECHO_T}no" >&6
8606     fi
8607   done
8608 fi
8609
8610 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8611   for ncn_progname in c++ g++ cxx gxx; do
8612     if test -n "$ncn_target_tool_prefix"; then
8613       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8614 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8615 echo "$as_me:$LINENO: checking for $ac_word" >&5
8616 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8617 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8618   echo $ECHO_N "(cached) $ECHO_C" >&6
8619 else
8620   if test -n "$CXX_FOR_TARGET"; then
8621   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8622 else
8623 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8624 for as_dir in $PATH
8625 do
8626   IFS=$as_save_IFS
8627   test -z "$as_dir" && as_dir=.
8628   for ac_exec_ext in '' $ac_executable_extensions; do
8629   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8630     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8631     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8632     break 2
8633   fi
8634 done
8635 done
8636
8637 fi
8638 fi
8639 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8640 if test -n "$CXX_FOR_TARGET"; then
8641   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8642 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8643 else
8644   echo "$as_me:$LINENO: result: no" >&5
8645 echo "${ECHO_T}no" >&6
8646 fi
8647
8648     fi
8649     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8650       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8651 set dummy ${ncn_progname}; ac_word=$2
8652 echo "$as_me:$LINENO: checking for $ac_word" >&5
8653 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8654 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8655   echo $ECHO_N "(cached) $ECHO_C" >&6
8656 else
8657   if test -n "$CXX_FOR_TARGET"; then
8658   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8659 else
8660 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8661 for as_dir in $PATH
8662 do
8663   IFS=$as_save_IFS
8664   test -z "$as_dir" && as_dir=.
8665   for ac_exec_ext in '' $ac_executable_extensions; do
8666   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8667     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8668     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8669     break 2
8670   fi
8671 done
8672 done
8673
8674 fi
8675 fi
8676 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8677 if test -n "$CXX_FOR_TARGET"; then
8678   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8679 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8680 else
8681   echo "$as_me:$LINENO: result: no" >&5
8682 echo "${ECHO_T}no" >&6
8683 fi
8684
8685     fi
8686     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8687   done
8688 fi
8689
8690 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8691   set dummy c++ g++ cxx gxx
8692   if test $build = $target ; then
8693     CXX_FOR_TARGET="$2"
8694   else
8695     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8696   fi
8697 else
8698   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8699 fi
8700
8701
8702
8703 if test -n "$GCC_FOR_TARGET"; then
8704   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8705 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8706   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8707 fi
8708
8709 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8710   for ncn_progname in gcc; do
8711     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8712 set dummy ${ncn_progname}; ac_word=$2
8713 echo "$as_me:$LINENO: checking for $ac_word" >&5
8714 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8715 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8716   echo $ECHO_N "(cached) $ECHO_C" >&6
8717 else
8718   if test -n "$GCC_FOR_TARGET"; then
8719   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8720 else
8721 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8722 for as_dir in $PATH
8723 do
8724   IFS=$as_save_IFS
8725   test -z "$as_dir" && as_dir=.
8726   for ac_exec_ext in '' $ac_executable_extensions; do
8727   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8728     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8729     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8730     break 2
8731   fi
8732 done
8733 done
8734
8735 fi
8736 fi
8737 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8738 if test -n "$GCC_FOR_TARGET"; then
8739   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8740 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8741 else
8742   echo "$as_me:$LINENO: result: no" >&5
8743 echo "${ECHO_T}no" >&6
8744 fi
8745
8746   done
8747 fi
8748
8749 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8750   for ncn_progname in gcc; do
8751     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8752 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8753     if test -x $with_build_time_tools/${ncn_progname}; then
8754       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8755       echo "$as_me:$LINENO: result: yes" >&5
8756 echo "${ECHO_T}yes" >&6
8757       break
8758     else
8759       echo "$as_me:$LINENO: result: no" >&5
8760 echo "${ECHO_T}no" >&6
8761     fi
8762   done
8763 fi
8764
8765 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8766   for ncn_progname in gcc; do
8767     if test -n "$ncn_target_tool_prefix"; then
8768       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8769 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8770 echo "$as_me:$LINENO: checking for $ac_word" >&5
8771 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8772 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8773   echo $ECHO_N "(cached) $ECHO_C" >&6
8774 else
8775   if test -n "$GCC_FOR_TARGET"; then
8776   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8777 else
8778 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8779 for as_dir in $PATH
8780 do
8781   IFS=$as_save_IFS
8782   test -z "$as_dir" && as_dir=.
8783   for ac_exec_ext in '' $ac_executable_extensions; do
8784   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8785     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8786     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8787     break 2
8788   fi
8789 done
8790 done
8791
8792 fi
8793 fi
8794 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8795 if test -n "$GCC_FOR_TARGET"; then
8796   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8797 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8798 else
8799   echo "$as_me:$LINENO: result: no" >&5
8800 echo "${ECHO_T}no" >&6
8801 fi
8802
8803     fi
8804     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8805       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8806 set dummy ${ncn_progname}; ac_word=$2
8807 echo "$as_me:$LINENO: checking for $ac_word" >&5
8808 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8809 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8810   echo $ECHO_N "(cached) $ECHO_C" >&6
8811 else
8812   if test -n "$GCC_FOR_TARGET"; then
8813   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8814 else
8815 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8816 for as_dir in $PATH
8817 do
8818   IFS=$as_save_IFS
8819   test -z "$as_dir" && as_dir=.
8820   for ac_exec_ext in '' $ac_executable_extensions; do
8821   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8822     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8823     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8824     break 2
8825   fi
8826 done
8827 done
8828
8829 fi
8830 fi
8831 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8832 if test -n "$GCC_FOR_TARGET"; then
8833   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8834 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8835 else
8836   echo "$as_me:$LINENO: result: no" >&5
8837 echo "${ECHO_T}no" >&6
8838 fi
8839
8840     fi
8841     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8842   done
8843 fi
8844
8845 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8846   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8847 else
8848   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8849 fi
8850
8851
8852
8853 if test -n "$GCJ_FOR_TARGET"; then
8854   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8855 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8856   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8857 fi
8858
8859 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8860   for ncn_progname in gcj; do
8861     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8862 set dummy ${ncn_progname}; ac_word=$2
8863 echo "$as_me:$LINENO: checking for $ac_word" >&5
8864 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8865 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8866   echo $ECHO_N "(cached) $ECHO_C" >&6
8867 else
8868   if test -n "$GCJ_FOR_TARGET"; then
8869   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8870 else
8871 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8872 for as_dir in $PATH
8873 do
8874   IFS=$as_save_IFS
8875   test -z "$as_dir" && as_dir=.
8876   for ac_exec_ext in '' $ac_executable_extensions; do
8877   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8878     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8879     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8880     break 2
8881   fi
8882 done
8883 done
8884
8885 fi
8886 fi
8887 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8888 if test -n "$GCJ_FOR_TARGET"; then
8889   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8890 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8891 else
8892   echo "$as_me:$LINENO: result: no" >&5
8893 echo "${ECHO_T}no" >&6
8894 fi
8895
8896   done
8897 fi
8898
8899 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8900   for ncn_progname in gcj; do
8901     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8902 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8903     if test -x $with_build_time_tools/${ncn_progname}; then
8904       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8905       echo "$as_me:$LINENO: result: yes" >&5
8906 echo "${ECHO_T}yes" >&6
8907       break
8908     else
8909       echo "$as_me:$LINENO: result: no" >&5
8910 echo "${ECHO_T}no" >&6
8911     fi
8912   done
8913 fi
8914
8915 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8916   for ncn_progname in gcj; do
8917     if test -n "$ncn_target_tool_prefix"; then
8918       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8919 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8920 echo "$as_me:$LINENO: checking for $ac_word" >&5
8921 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8922 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8923   echo $ECHO_N "(cached) $ECHO_C" >&6
8924 else
8925   if test -n "$GCJ_FOR_TARGET"; then
8926   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8927 else
8928 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8929 for as_dir in $PATH
8930 do
8931   IFS=$as_save_IFS
8932   test -z "$as_dir" && as_dir=.
8933   for ac_exec_ext in '' $ac_executable_extensions; do
8934   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8935     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8936     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8937     break 2
8938   fi
8939 done
8940 done
8941
8942 fi
8943 fi
8944 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8945 if test -n "$GCJ_FOR_TARGET"; then
8946   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8947 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8948 else
8949   echo "$as_me:$LINENO: result: no" >&5
8950 echo "${ECHO_T}no" >&6
8951 fi
8952
8953     fi
8954     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8955       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8956 set dummy ${ncn_progname}; ac_word=$2
8957 echo "$as_me:$LINENO: checking for $ac_word" >&5
8958 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8959 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8960   echo $ECHO_N "(cached) $ECHO_C" >&6
8961 else
8962   if test -n "$GCJ_FOR_TARGET"; then
8963   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8964 else
8965 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8966 for as_dir in $PATH
8967 do
8968   IFS=$as_save_IFS
8969   test -z "$as_dir" && as_dir=.
8970   for ac_exec_ext in '' $ac_executable_extensions; do
8971   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8972     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8973     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8974     break 2
8975   fi
8976 done
8977 done
8978
8979 fi
8980 fi
8981 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8982 if test -n "$GCJ_FOR_TARGET"; then
8983   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8984 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8985 else
8986   echo "$as_me:$LINENO: result: no" >&5
8987 echo "${ECHO_T}no" >&6
8988 fi
8989
8990     fi
8991     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8992   done
8993 fi
8994
8995 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8996   set dummy gcj
8997   if test $build = $target ; then
8998     GCJ_FOR_TARGET="$2"
8999   else
9000     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9001   fi
9002 else
9003   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9004 fi
9005
9006
9007
9008 if test -n "$GFORTRAN_FOR_TARGET"; then
9009   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9010 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9011   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9012 fi
9013
9014 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9015   for ncn_progname in gfortran; do
9016     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9017 set dummy ${ncn_progname}; ac_word=$2
9018 echo "$as_me:$LINENO: checking for $ac_word" >&5
9019 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9020 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9021   echo $ECHO_N "(cached) $ECHO_C" >&6
9022 else
9023   if test -n "$GFORTRAN_FOR_TARGET"; then
9024   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9025 else
9026 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9027 for as_dir in $PATH
9028 do
9029   IFS=$as_save_IFS
9030   test -z "$as_dir" && as_dir=.
9031   for ac_exec_ext in '' $ac_executable_extensions; do
9032   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9033     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9034     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9035     break 2
9036   fi
9037 done
9038 done
9039
9040 fi
9041 fi
9042 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9043 if test -n "$GFORTRAN_FOR_TARGET"; then
9044   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9045 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9046 else
9047   echo "$as_me:$LINENO: result: no" >&5
9048 echo "${ECHO_T}no" >&6
9049 fi
9050
9051   done
9052 fi
9053
9054 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9055   for ncn_progname in gfortran; do
9056     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9057 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9058     if test -x $with_build_time_tools/${ncn_progname}; then
9059       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9060       echo "$as_me:$LINENO: result: yes" >&5
9061 echo "${ECHO_T}yes" >&6
9062       break
9063     else
9064       echo "$as_me:$LINENO: result: no" >&5
9065 echo "${ECHO_T}no" >&6
9066     fi
9067   done
9068 fi
9069
9070 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9071   for ncn_progname in gfortran; do
9072     if test -n "$ncn_target_tool_prefix"; then
9073       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9074 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9075 echo "$as_me:$LINENO: checking for $ac_word" >&5
9076 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9077 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9078   echo $ECHO_N "(cached) $ECHO_C" >&6
9079 else
9080   if test -n "$GFORTRAN_FOR_TARGET"; then
9081   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9082 else
9083 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9084 for as_dir in $PATH
9085 do
9086   IFS=$as_save_IFS
9087   test -z "$as_dir" && as_dir=.
9088   for ac_exec_ext in '' $ac_executable_extensions; do
9089   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9090     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9091     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9092     break 2
9093   fi
9094 done
9095 done
9096
9097 fi
9098 fi
9099 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9100 if test -n "$GFORTRAN_FOR_TARGET"; then
9101   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9102 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9103 else
9104   echo "$as_me:$LINENO: result: no" >&5
9105 echo "${ECHO_T}no" >&6
9106 fi
9107
9108     fi
9109     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9110       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9111 set dummy ${ncn_progname}; ac_word=$2
9112 echo "$as_me:$LINENO: checking for $ac_word" >&5
9113 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9114 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9115   echo $ECHO_N "(cached) $ECHO_C" >&6
9116 else
9117   if test -n "$GFORTRAN_FOR_TARGET"; then
9118   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9119 else
9120 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9121 for as_dir in $PATH
9122 do
9123   IFS=$as_save_IFS
9124   test -z "$as_dir" && as_dir=.
9125   for ac_exec_ext in '' $ac_executable_extensions; do
9126   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9127     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9128     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9129     break 2
9130   fi
9131 done
9132 done
9133
9134 fi
9135 fi
9136 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9137 if test -n "$GFORTRAN_FOR_TARGET"; then
9138   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9139 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9140 else
9141   echo "$as_me:$LINENO: result: no" >&5
9142 echo "${ECHO_T}no" >&6
9143 fi
9144
9145     fi
9146     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9147   done
9148 fi
9149
9150 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9151   set dummy gfortran
9152   if test $build = $target ; then
9153     GFORTRAN_FOR_TARGET="$2"
9154   else
9155     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9156   fi
9157 else
9158   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9159 fi
9160
9161
9162
9163 cat > conftest.c << \EOF
9164 #ifdef __GNUC__
9165   gcc_yay;
9166 #endif
9167 EOF
9168 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9169   have_gcc_for_target=yes
9170 else
9171   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9172   have_gcc_for_target=no
9173 fi
9174 rm conftest.c
9175
9176
9177
9178
9179 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9180   if test -n "$with_build_time_tools"; then
9181     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9182 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9183     if test -x $with_build_time_tools/ar; then
9184       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9185       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9186       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9187 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9188     else
9189       echo "$as_me:$LINENO: result: no" >&5
9190 echo "${ECHO_T}no" >&6
9191     fi
9192   elif test $build != $host && test $have_gcc_for_target = yes; then
9193     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9194     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9195     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9196   fi
9197 fi
9198 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9199   # Extract the first word of "ar", so it can be a program name with args.
9200 set dummy ar; ac_word=$2
9201 echo "$as_me:$LINENO: checking for $ac_word" >&5
9202 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9203 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9204   echo $ECHO_N "(cached) $ECHO_C" >&6
9205 else
9206   case $AR_FOR_TARGET in
9207   [\\/]* | ?:[\\/]*)
9208   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9209   ;;
9210   *)
9211   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9212 for as_dir in $gcc_cv_tool_dirs
9213 do
9214   IFS=$as_save_IFS
9215   test -z "$as_dir" && as_dir=.
9216   for ac_exec_ext in '' $ac_executable_extensions; do
9217   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9218     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9219     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9220     break 2
9221   fi
9222 done
9223 done
9224
9225   ;;
9226 esac
9227 fi
9228 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9229
9230 if test -n "$AR_FOR_TARGET"; then
9231   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9232 echo "${ECHO_T}$AR_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_path_AR_FOR_TARGET" ; then
9240
9241
9242 if test -n "$AR_FOR_TARGET"; then
9243   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9244 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9245   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9246 fi
9247
9248 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9249   for ncn_progname in ar; do
9250     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9251 set dummy ${ncn_progname}; ac_word=$2
9252 echo "$as_me:$LINENO: checking for $ac_word" >&5
9253 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9254 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9255   echo $ECHO_N "(cached) $ECHO_C" >&6
9256 else
9257   if test -n "$AR_FOR_TARGET"; then
9258   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9259 else
9260 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9261 for as_dir in $PATH
9262 do
9263   IFS=$as_save_IFS
9264   test -z "$as_dir" && as_dir=.
9265   for ac_exec_ext in '' $ac_executable_extensions; do
9266   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9267     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9268     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9269     break 2
9270   fi
9271 done
9272 done
9273
9274 fi
9275 fi
9276 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9277 if test -n "$AR_FOR_TARGET"; then
9278   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9279 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9280 else
9281   echo "$as_me:$LINENO: result: no" >&5
9282 echo "${ECHO_T}no" >&6
9283 fi
9284
9285   done
9286 fi
9287
9288 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9289   for ncn_progname in ar; do
9290     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9291 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9292     if test -x $with_build_time_tools/${ncn_progname}; then
9293       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9294       echo "$as_me:$LINENO: result: yes" >&5
9295 echo "${ECHO_T}yes" >&6
9296       break
9297     else
9298       echo "$as_me:$LINENO: result: no" >&5
9299 echo "${ECHO_T}no" >&6
9300     fi
9301   done
9302 fi
9303
9304 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9305   for ncn_progname in ar; do
9306     if test -n "$ncn_target_tool_prefix"; then
9307       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9308 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9309 echo "$as_me:$LINENO: checking for $ac_word" >&5
9310 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9311 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9312   echo $ECHO_N "(cached) $ECHO_C" >&6
9313 else
9314   if test -n "$AR_FOR_TARGET"; then
9315   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9316 else
9317 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9318 for as_dir in $PATH
9319 do
9320   IFS=$as_save_IFS
9321   test -z "$as_dir" && as_dir=.
9322   for ac_exec_ext in '' $ac_executable_extensions; do
9323   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9324     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9325     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9326     break 2
9327   fi
9328 done
9329 done
9330
9331 fi
9332 fi
9333 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9334 if test -n "$AR_FOR_TARGET"; then
9335   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9336 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9337 else
9338   echo "$as_me:$LINENO: result: no" >&5
9339 echo "${ECHO_T}no" >&6
9340 fi
9341
9342     fi
9343     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9344       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9345 set dummy ${ncn_progname}; ac_word=$2
9346 echo "$as_me:$LINENO: checking for $ac_word" >&5
9347 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9348 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9349   echo $ECHO_N "(cached) $ECHO_C" >&6
9350 else
9351   if test -n "$AR_FOR_TARGET"; then
9352   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9353 else
9354 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9355 for as_dir in $PATH
9356 do
9357   IFS=$as_save_IFS
9358   test -z "$as_dir" && as_dir=.
9359   for ac_exec_ext in '' $ac_executable_extensions; do
9360   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9361     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9362     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9363     break 2
9364   fi
9365 done
9366 done
9367
9368 fi
9369 fi
9370 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9371 if test -n "$AR_FOR_TARGET"; then
9372   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9373 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9374 else
9375   echo "$as_me:$LINENO: result: no" >&5
9376 echo "${ECHO_T}no" >&6
9377 fi
9378
9379     fi
9380     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9381   done
9382 fi
9383
9384 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9385   set dummy ar
9386   if test $build = $target ; then
9387     AR_FOR_TARGET="$2"
9388   else
9389     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9390   fi
9391 else
9392   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9393 fi
9394
9395 else
9396   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9397 fi
9398
9399
9400
9401
9402 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9403   if test -n "$with_build_time_tools"; then
9404     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9405 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9406     if test -x $with_build_time_tools/as; then
9407       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9408       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9409       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9410 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9411     else
9412       echo "$as_me:$LINENO: result: no" >&5
9413 echo "${ECHO_T}no" >&6
9414     fi
9415   elif test $build != $host && test $have_gcc_for_target = yes; then
9416     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9417     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9418     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9419   fi
9420 fi
9421 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9422   # Extract the first word of "as", so it can be a program name with args.
9423 set dummy as; ac_word=$2
9424 echo "$as_me:$LINENO: checking for $ac_word" >&5
9425 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9426 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9427   echo $ECHO_N "(cached) $ECHO_C" >&6
9428 else
9429   case $AS_FOR_TARGET in
9430   [\\/]* | ?:[\\/]*)
9431   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9432   ;;
9433   *)
9434   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9435 for as_dir in $gcc_cv_tool_dirs
9436 do
9437   IFS=$as_save_IFS
9438   test -z "$as_dir" && as_dir=.
9439   for ac_exec_ext in '' $ac_executable_extensions; do
9440   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9441     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9442     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9443     break 2
9444   fi
9445 done
9446 done
9447
9448   ;;
9449 esac
9450 fi
9451 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9452
9453 if test -n "$AS_FOR_TARGET"; then
9454   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9455 echo "${ECHO_T}$AS_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_path_AS_FOR_TARGET" ; then
9463
9464
9465 if test -n "$AS_FOR_TARGET"; then
9466   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9467 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9468   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9469 fi
9470
9471 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9472   for ncn_progname in as; do
9473     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9474 set dummy ${ncn_progname}; ac_word=$2
9475 echo "$as_me:$LINENO: checking for $ac_word" >&5
9476 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9477 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9478   echo $ECHO_N "(cached) $ECHO_C" >&6
9479 else
9480   if test -n "$AS_FOR_TARGET"; then
9481   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9482 else
9483 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9484 for as_dir in $PATH
9485 do
9486   IFS=$as_save_IFS
9487   test -z "$as_dir" && as_dir=.
9488   for ac_exec_ext in '' $ac_executable_extensions; do
9489   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9490     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9491     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9492     break 2
9493   fi
9494 done
9495 done
9496
9497 fi
9498 fi
9499 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9500 if test -n "$AS_FOR_TARGET"; then
9501   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9502 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9503 else
9504   echo "$as_me:$LINENO: result: no" >&5
9505 echo "${ECHO_T}no" >&6
9506 fi
9507
9508   done
9509 fi
9510
9511 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9512   for ncn_progname in as; do
9513     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9514 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9515     if test -x $with_build_time_tools/${ncn_progname}; then
9516       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9517       echo "$as_me:$LINENO: result: yes" >&5
9518 echo "${ECHO_T}yes" >&6
9519       break
9520     else
9521       echo "$as_me:$LINENO: result: no" >&5
9522 echo "${ECHO_T}no" >&6
9523     fi
9524   done
9525 fi
9526
9527 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9528   for ncn_progname in as; do
9529     if test -n "$ncn_target_tool_prefix"; then
9530       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9531 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9532 echo "$as_me:$LINENO: checking for $ac_word" >&5
9533 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9534 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9535   echo $ECHO_N "(cached) $ECHO_C" >&6
9536 else
9537   if test -n "$AS_FOR_TARGET"; then
9538   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9539 else
9540 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9541 for as_dir in $PATH
9542 do
9543   IFS=$as_save_IFS
9544   test -z "$as_dir" && as_dir=.
9545   for ac_exec_ext in '' $ac_executable_extensions; do
9546   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9547     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9548     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9549     break 2
9550   fi
9551 done
9552 done
9553
9554 fi
9555 fi
9556 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9557 if test -n "$AS_FOR_TARGET"; then
9558   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9559 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9560 else
9561   echo "$as_me:$LINENO: result: no" >&5
9562 echo "${ECHO_T}no" >&6
9563 fi
9564
9565     fi
9566     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9567       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9568 set dummy ${ncn_progname}; ac_word=$2
9569 echo "$as_me:$LINENO: checking for $ac_word" >&5
9570 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9571 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9572   echo $ECHO_N "(cached) $ECHO_C" >&6
9573 else
9574   if test -n "$AS_FOR_TARGET"; then
9575   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9576 else
9577 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9578 for as_dir in $PATH
9579 do
9580   IFS=$as_save_IFS
9581   test -z "$as_dir" && as_dir=.
9582   for ac_exec_ext in '' $ac_executable_extensions; do
9583   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9584     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9585     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9586     break 2
9587   fi
9588 done
9589 done
9590
9591 fi
9592 fi
9593 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9594 if test -n "$AS_FOR_TARGET"; then
9595   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9596 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9597 else
9598   echo "$as_me:$LINENO: result: no" >&5
9599 echo "${ECHO_T}no" >&6
9600 fi
9601
9602     fi
9603     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9604   done
9605 fi
9606
9607 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9608   set dummy as
9609   if test $build = $target ; then
9610     AS_FOR_TARGET="$2"
9611   else
9612     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9613   fi
9614 else
9615   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9616 fi
9617
9618 else
9619   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9620 fi
9621
9622
9623
9624
9625 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9626   if test -n "$with_build_time_tools"; then
9627     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9628 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9629     if test -x $with_build_time_tools/dlltool; then
9630       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9631       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9632       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9633 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9634     else
9635       echo "$as_me:$LINENO: result: no" >&5
9636 echo "${ECHO_T}no" >&6
9637     fi
9638   elif test $build != $host && test $have_gcc_for_target = yes; then
9639     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9640     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9641     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9642   fi
9643 fi
9644 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9645   # Extract the first word of "dlltool", so it can be a program name with args.
9646 set dummy dlltool; ac_word=$2
9647 echo "$as_me:$LINENO: checking for $ac_word" >&5
9648 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9649 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9650   echo $ECHO_N "(cached) $ECHO_C" >&6
9651 else
9652   case $DLLTOOL_FOR_TARGET in
9653   [\\/]* | ?:[\\/]*)
9654   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9655   ;;
9656   *)
9657   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9658 for as_dir in $gcc_cv_tool_dirs
9659 do
9660   IFS=$as_save_IFS
9661   test -z "$as_dir" && as_dir=.
9662   for ac_exec_ext in '' $ac_executable_extensions; do
9663   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9664     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9665     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9666     break 2
9667   fi
9668 done
9669 done
9670
9671   ;;
9672 esac
9673 fi
9674 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9675
9676 if test -n "$DLLTOOL_FOR_TARGET"; then
9677   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9678 echo "${ECHO_T}$DLLTOOL_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_path_DLLTOOL_FOR_TARGET" ; then
9686
9687
9688 if test -n "$DLLTOOL_FOR_TARGET"; then
9689   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9690 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9691   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9692 fi
9693
9694 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9695   for ncn_progname in dlltool; do
9696     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9697 set dummy ${ncn_progname}; ac_word=$2
9698 echo "$as_me:$LINENO: checking for $ac_word" >&5
9699 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9700 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9701   echo $ECHO_N "(cached) $ECHO_C" >&6
9702 else
9703   if test -n "$DLLTOOL_FOR_TARGET"; then
9704   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9705 else
9706 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9707 for as_dir in $PATH
9708 do
9709   IFS=$as_save_IFS
9710   test -z "$as_dir" && as_dir=.
9711   for ac_exec_ext in '' $ac_executable_extensions; do
9712   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9713     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9714     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9715     break 2
9716   fi
9717 done
9718 done
9719
9720 fi
9721 fi
9722 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9723 if test -n "$DLLTOOL_FOR_TARGET"; then
9724   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9725 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9726 else
9727   echo "$as_me:$LINENO: result: no" >&5
9728 echo "${ECHO_T}no" >&6
9729 fi
9730
9731   done
9732 fi
9733
9734 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9735   for ncn_progname in dlltool; do
9736     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9737 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9738     if test -x $with_build_time_tools/${ncn_progname}; then
9739       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9740       echo "$as_me:$LINENO: result: yes" >&5
9741 echo "${ECHO_T}yes" >&6
9742       break
9743     else
9744       echo "$as_me:$LINENO: result: no" >&5
9745 echo "${ECHO_T}no" >&6
9746     fi
9747   done
9748 fi
9749
9750 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9751   for ncn_progname in dlltool; do
9752     if test -n "$ncn_target_tool_prefix"; then
9753       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9754 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9755 echo "$as_me:$LINENO: checking for $ac_word" >&5
9756 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9757 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9758   echo $ECHO_N "(cached) $ECHO_C" >&6
9759 else
9760   if test -n "$DLLTOOL_FOR_TARGET"; then
9761   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9762 else
9763 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9764 for as_dir in $PATH
9765 do
9766   IFS=$as_save_IFS
9767   test -z "$as_dir" && as_dir=.
9768   for ac_exec_ext in '' $ac_executable_extensions; do
9769   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9770     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9771     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9772     break 2
9773   fi
9774 done
9775 done
9776
9777 fi
9778 fi
9779 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9780 if test -n "$DLLTOOL_FOR_TARGET"; then
9781   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9782 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9783 else
9784   echo "$as_me:$LINENO: result: no" >&5
9785 echo "${ECHO_T}no" >&6
9786 fi
9787
9788     fi
9789     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9790       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9791 set dummy ${ncn_progname}; ac_word=$2
9792 echo "$as_me:$LINENO: checking for $ac_word" >&5
9793 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9794 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9795   echo $ECHO_N "(cached) $ECHO_C" >&6
9796 else
9797   if test -n "$DLLTOOL_FOR_TARGET"; then
9798   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9799 else
9800 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9801 for as_dir in $PATH
9802 do
9803   IFS=$as_save_IFS
9804   test -z "$as_dir" && as_dir=.
9805   for ac_exec_ext in '' $ac_executable_extensions; do
9806   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9807     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9808     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9809     break 2
9810   fi
9811 done
9812 done
9813
9814 fi
9815 fi
9816 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9817 if test -n "$DLLTOOL_FOR_TARGET"; then
9818   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9819 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9820 else
9821   echo "$as_me:$LINENO: result: no" >&5
9822 echo "${ECHO_T}no" >&6
9823 fi
9824
9825     fi
9826     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9827   done
9828 fi
9829
9830 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9831   set dummy dlltool
9832   if test $build = $target ; then
9833     DLLTOOL_FOR_TARGET="$2"
9834   else
9835     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9836   fi
9837 else
9838   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9839 fi
9840
9841 else
9842   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9843 fi
9844
9845
9846
9847
9848 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9849   if test -n "$with_build_time_tools"; then
9850     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9851 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9852     if test -x $with_build_time_tools/ld; then
9853       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9854       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9855       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9856 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9857     else
9858       echo "$as_me:$LINENO: result: no" >&5
9859 echo "${ECHO_T}no" >&6
9860     fi
9861   elif test $build != $host && test $have_gcc_for_target = yes; then
9862     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9863     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9864     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9865   fi
9866 fi
9867 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9868   # Extract the first word of "ld", so it can be a program name with args.
9869 set dummy ld; ac_word=$2
9870 echo "$as_me:$LINENO: checking for $ac_word" >&5
9871 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9872 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9873   echo $ECHO_N "(cached) $ECHO_C" >&6
9874 else
9875   case $LD_FOR_TARGET in
9876   [\\/]* | ?:[\\/]*)
9877   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9878   ;;
9879   *)
9880   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9881 for as_dir in $gcc_cv_tool_dirs
9882 do
9883   IFS=$as_save_IFS
9884   test -z "$as_dir" && as_dir=.
9885   for ac_exec_ext in '' $ac_executable_extensions; do
9886   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9887     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9888     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9889     break 2
9890   fi
9891 done
9892 done
9893
9894   ;;
9895 esac
9896 fi
9897 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9898
9899 if test -n "$LD_FOR_TARGET"; then
9900   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9901 echo "${ECHO_T}$LD_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_path_LD_FOR_TARGET" ; then
9909
9910
9911 if test -n "$LD_FOR_TARGET"; then
9912   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9913 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9914   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9915 fi
9916
9917 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9918   for ncn_progname in ld; do
9919     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9920 set dummy ${ncn_progname}; ac_word=$2
9921 echo "$as_me:$LINENO: checking for $ac_word" >&5
9922 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9923 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9924   echo $ECHO_N "(cached) $ECHO_C" >&6
9925 else
9926   if test -n "$LD_FOR_TARGET"; then
9927   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9928 else
9929 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9930 for as_dir in $PATH
9931 do
9932   IFS=$as_save_IFS
9933   test -z "$as_dir" && as_dir=.
9934   for ac_exec_ext in '' $ac_executable_extensions; do
9935   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9936     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9937     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9938     break 2
9939   fi
9940 done
9941 done
9942
9943 fi
9944 fi
9945 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9946 if test -n "$LD_FOR_TARGET"; then
9947   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9948 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9949 else
9950   echo "$as_me:$LINENO: result: no" >&5
9951 echo "${ECHO_T}no" >&6
9952 fi
9953
9954   done
9955 fi
9956
9957 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9958   for ncn_progname in ld; do
9959     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9960 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9961     if test -x $with_build_time_tools/${ncn_progname}; then
9962       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9963       echo "$as_me:$LINENO: result: yes" >&5
9964 echo "${ECHO_T}yes" >&6
9965       break
9966     else
9967       echo "$as_me:$LINENO: result: no" >&5
9968 echo "${ECHO_T}no" >&6
9969     fi
9970   done
9971 fi
9972
9973 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9974   for ncn_progname in ld; do
9975     if test -n "$ncn_target_tool_prefix"; then
9976       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9977 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9978 echo "$as_me:$LINENO: checking for $ac_word" >&5
9979 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9980 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9981   echo $ECHO_N "(cached) $ECHO_C" >&6
9982 else
9983   if test -n "$LD_FOR_TARGET"; then
9984   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9985 else
9986 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9987 for as_dir in $PATH
9988 do
9989   IFS=$as_save_IFS
9990   test -z "$as_dir" && as_dir=.
9991   for ac_exec_ext in '' $ac_executable_extensions; do
9992   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9993     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9994     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9995     break 2
9996   fi
9997 done
9998 done
9999
10000 fi
10001 fi
10002 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10003 if test -n "$LD_FOR_TARGET"; then
10004   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10005 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10006 else
10007   echo "$as_me:$LINENO: result: no" >&5
10008 echo "${ECHO_T}no" >&6
10009 fi
10010
10011     fi
10012     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10013       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10014 set dummy ${ncn_progname}; ac_word=$2
10015 echo "$as_me:$LINENO: checking for $ac_word" >&5
10016 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10017 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10018   echo $ECHO_N "(cached) $ECHO_C" >&6
10019 else
10020   if test -n "$LD_FOR_TARGET"; then
10021   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10022 else
10023 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10024 for as_dir in $PATH
10025 do
10026   IFS=$as_save_IFS
10027   test -z "$as_dir" && as_dir=.
10028   for ac_exec_ext in '' $ac_executable_extensions; do
10029   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10030     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10031     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10032     break 2
10033   fi
10034 done
10035 done
10036
10037 fi
10038 fi
10039 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10040 if test -n "$LD_FOR_TARGET"; then
10041   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10042 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10043 else
10044   echo "$as_me:$LINENO: result: no" >&5
10045 echo "${ECHO_T}no" >&6
10046 fi
10047
10048     fi
10049     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10050   done
10051 fi
10052
10053 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10054   set dummy ld
10055   if test $build = $target ; then
10056     LD_FOR_TARGET="$2"
10057   else
10058     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10059   fi
10060 else
10061   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10062 fi
10063
10064 else
10065   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10066 fi
10067
10068
10069
10070
10071 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10072   if test -n "$with_build_time_tools"; then
10073     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10074 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10075     if test -x $with_build_time_tools/lipo; then
10076       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10077       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10078       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10079 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10080     else
10081       echo "$as_me:$LINENO: result: no" >&5
10082 echo "${ECHO_T}no" >&6
10083     fi
10084   elif test $build != $host && test $have_gcc_for_target = yes; then
10085     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10086     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10087     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10088   fi
10089 fi
10090 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10091   # Extract the first word of "lipo", so it can be a program name with args.
10092 set dummy lipo; ac_word=$2
10093 echo "$as_me:$LINENO: checking for $ac_word" >&5
10094 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10095 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10096   echo $ECHO_N "(cached) $ECHO_C" >&6
10097 else
10098   case $LIPO_FOR_TARGET in
10099   [\\/]* | ?:[\\/]*)
10100   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10101   ;;
10102   *)
10103   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10104 for as_dir in $gcc_cv_tool_dirs
10105 do
10106   IFS=$as_save_IFS
10107   test -z "$as_dir" && as_dir=.
10108   for ac_exec_ext in '' $ac_executable_extensions; do
10109   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10110     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10111     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10112     break 2
10113   fi
10114 done
10115 done
10116
10117   ;;
10118 esac
10119 fi
10120 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10121
10122 if test -n "$LIPO_FOR_TARGET"; then
10123   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10124 echo "${ECHO_T}$LIPO_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_path_LIPO_FOR_TARGET" ; then
10132
10133
10134 if test -n "$LIPO_FOR_TARGET"; then
10135   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10136 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10137   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10138 fi
10139
10140 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10141   for ncn_progname in lipo; do
10142     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10143 set dummy ${ncn_progname}; ac_word=$2
10144 echo "$as_me:$LINENO: checking for $ac_word" >&5
10145 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10146 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10147   echo $ECHO_N "(cached) $ECHO_C" >&6
10148 else
10149   if test -n "$LIPO_FOR_TARGET"; then
10150   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10151 else
10152 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10153 for as_dir in $PATH
10154 do
10155   IFS=$as_save_IFS
10156   test -z "$as_dir" && as_dir=.
10157   for ac_exec_ext in '' $ac_executable_extensions; do
10158   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10159     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10160     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10161     break 2
10162   fi
10163 done
10164 done
10165
10166 fi
10167 fi
10168 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10169 if test -n "$LIPO_FOR_TARGET"; then
10170   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10171 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10172 else
10173   echo "$as_me:$LINENO: result: no" >&5
10174 echo "${ECHO_T}no" >&6
10175 fi
10176
10177   done
10178 fi
10179
10180 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10181   for ncn_progname in lipo; do
10182     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10183 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10184     if test -x $with_build_time_tools/${ncn_progname}; then
10185       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10186       echo "$as_me:$LINENO: result: yes" >&5
10187 echo "${ECHO_T}yes" >&6
10188       break
10189     else
10190       echo "$as_me:$LINENO: result: no" >&5
10191 echo "${ECHO_T}no" >&6
10192     fi
10193   done
10194 fi
10195
10196 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10197   for ncn_progname in lipo; do
10198     if test -n "$ncn_target_tool_prefix"; then
10199       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10200 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10201 echo "$as_me:$LINENO: checking for $ac_word" >&5
10202 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10203 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10204   echo $ECHO_N "(cached) $ECHO_C" >&6
10205 else
10206   if test -n "$LIPO_FOR_TARGET"; then
10207   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10208 else
10209 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10210 for as_dir in $PATH
10211 do
10212   IFS=$as_save_IFS
10213   test -z "$as_dir" && as_dir=.
10214   for ac_exec_ext in '' $ac_executable_extensions; do
10215   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10216     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10217     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10218     break 2
10219   fi
10220 done
10221 done
10222
10223 fi
10224 fi
10225 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10226 if test -n "$LIPO_FOR_TARGET"; then
10227   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10228 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10229 else
10230   echo "$as_me:$LINENO: result: no" >&5
10231 echo "${ECHO_T}no" >&6
10232 fi
10233
10234     fi
10235     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10236       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10237 set dummy ${ncn_progname}; ac_word=$2
10238 echo "$as_me:$LINENO: checking for $ac_word" >&5
10239 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10240 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10241   echo $ECHO_N "(cached) $ECHO_C" >&6
10242 else
10243   if test -n "$LIPO_FOR_TARGET"; then
10244   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10245 else
10246 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10247 for as_dir in $PATH
10248 do
10249   IFS=$as_save_IFS
10250   test -z "$as_dir" && as_dir=.
10251   for ac_exec_ext in '' $ac_executable_extensions; do
10252   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10253     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10254     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10255     break 2
10256   fi
10257 done
10258 done
10259
10260 fi
10261 fi
10262 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10263 if test -n "$LIPO_FOR_TARGET"; then
10264   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10265 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10266 else
10267   echo "$as_me:$LINENO: result: no" >&5
10268 echo "${ECHO_T}no" >&6
10269 fi
10270
10271     fi
10272     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10273   done
10274 fi
10275
10276 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10277   set dummy lipo
10278   if test $build = $target ; then
10279     LIPO_FOR_TARGET="$2"
10280   else
10281     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10282   fi
10283 else
10284   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10285 fi
10286
10287 else
10288   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10289 fi
10290
10291
10292
10293
10294 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10295   if test -n "$with_build_time_tools"; then
10296     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10297 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10298     if test -x $with_build_time_tools/nm; then
10299       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10300       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10301       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10302 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10303     else
10304       echo "$as_me:$LINENO: result: no" >&5
10305 echo "${ECHO_T}no" >&6
10306     fi
10307   elif test $build != $host && test $have_gcc_for_target = yes; then
10308     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10309     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10310     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10311   fi
10312 fi
10313 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10314   # Extract the first word of "nm", so it can be a program name with args.
10315 set dummy nm; ac_word=$2
10316 echo "$as_me:$LINENO: checking for $ac_word" >&5
10317 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10318 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10319   echo $ECHO_N "(cached) $ECHO_C" >&6
10320 else
10321   case $NM_FOR_TARGET in
10322   [\\/]* | ?:[\\/]*)
10323   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10324   ;;
10325   *)
10326   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10327 for as_dir in $gcc_cv_tool_dirs
10328 do
10329   IFS=$as_save_IFS
10330   test -z "$as_dir" && as_dir=.
10331   for ac_exec_ext in '' $ac_executable_extensions; do
10332   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10333     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10334     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10335     break 2
10336   fi
10337 done
10338 done
10339
10340   ;;
10341 esac
10342 fi
10343 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10344
10345 if test -n "$NM_FOR_TARGET"; then
10346   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10347 echo "${ECHO_T}$NM_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_path_NM_FOR_TARGET" ; then
10355
10356
10357 if test -n "$NM_FOR_TARGET"; then
10358   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10359 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10360   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10361 fi
10362
10363 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10364   for ncn_progname in nm; do
10365     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10366 set dummy ${ncn_progname}; ac_word=$2
10367 echo "$as_me:$LINENO: checking for $ac_word" >&5
10368 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10369 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10370   echo $ECHO_N "(cached) $ECHO_C" >&6
10371 else
10372   if test -n "$NM_FOR_TARGET"; then
10373   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10374 else
10375 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10376 for as_dir in $PATH
10377 do
10378   IFS=$as_save_IFS
10379   test -z "$as_dir" && as_dir=.
10380   for ac_exec_ext in '' $ac_executable_extensions; do
10381   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10382     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10383     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10384     break 2
10385   fi
10386 done
10387 done
10388
10389 fi
10390 fi
10391 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10392 if test -n "$NM_FOR_TARGET"; then
10393   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10394 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10395 else
10396   echo "$as_me:$LINENO: result: no" >&5
10397 echo "${ECHO_T}no" >&6
10398 fi
10399
10400   done
10401 fi
10402
10403 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10404   for ncn_progname in nm; do
10405     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10406 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10407     if test -x $with_build_time_tools/${ncn_progname}; then
10408       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10409       echo "$as_me:$LINENO: result: yes" >&5
10410 echo "${ECHO_T}yes" >&6
10411       break
10412     else
10413       echo "$as_me:$LINENO: result: no" >&5
10414 echo "${ECHO_T}no" >&6
10415     fi
10416   done
10417 fi
10418
10419 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10420   for ncn_progname in nm; do
10421     if test -n "$ncn_target_tool_prefix"; then
10422       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10423 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10424 echo "$as_me:$LINENO: checking for $ac_word" >&5
10425 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10426 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10427   echo $ECHO_N "(cached) $ECHO_C" >&6
10428 else
10429   if test -n "$NM_FOR_TARGET"; then
10430   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10431 else
10432 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10433 for as_dir in $PATH
10434 do
10435   IFS=$as_save_IFS
10436   test -z "$as_dir" && as_dir=.
10437   for ac_exec_ext in '' $ac_executable_extensions; do
10438   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10439     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10440     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10441     break 2
10442   fi
10443 done
10444 done
10445
10446 fi
10447 fi
10448 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10449 if test -n "$NM_FOR_TARGET"; then
10450   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10451 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10452 else
10453   echo "$as_me:$LINENO: result: no" >&5
10454 echo "${ECHO_T}no" >&6
10455 fi
10456
10457     fi
10458     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10459       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10460 set dummy ${ncn_progname}; ac_word=$2
10461 echo "$as_me:$LINENO: checking for $ac_word" >&5
10462 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10463 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10464   echo $ECHO_N "(cached) $ECHO_C" >&6
10465 else
10466   if test -n "$NM_FOR_TARGET"; then
10467   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10468 else
10469 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10470 for as_dir in $PATH
10471 do
10472   IFS=$as_save_IFS
10473   test -z "$as_dir" && as_dir=.
10474   for ac_exec_ext in '' $ac_executable_extensions; do
10475   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10476     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10477     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10478     break 2
10479   fi
10480 done
10481 done
10482
10483 fi
10484 fi
10485 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10486 if test -n "$NM_FOR_TARGET"; then
10487   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10488 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10489 else
10490   echo "$as_me:$LINENO: result: no" >&5
10491 echo "${ECHO_T}no" >&6
10492 fi
10493
10494     fi
10495     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10496   done
10497 fi
10498
10499 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10500   set dummy nm
10501   if test $build = $target ; then
10502     NM_FOR_TARGET="$2"
10503   else
10504     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10505   fi
10506 else
10507   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10508 fi
10509
10510 else
10511   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10512 fi
10513
10514
10515
10516
10517 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10518   if test -n "$with_build_time_tools"; then
10519     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10520 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10521     if test -x $with_build_time_tools/objdump; then
10522       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10523       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10524       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10525 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10526     else
10527       echo "$as_me:$LINENO: result: no" >&5
10528 echo "${ECHO_T}no" >&6
10529     fi
10530   elif test $build != $host && test $have_gcc_for_target = yes; then
10531     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10532     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10533     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10534   fi
10535 fi
10536 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10537   # Extract the first word of "objdump", so it can be a program name with args.
10538 set dummy objdump; ac_word=$2
10539 echo "$as_me:$LINENO: checking for $ac_word" >&5
10540 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10541 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10542   echo $ECHO_N "(cached) $ECHO_C" >&6
10543 else
10544   case $OBJDUMP_FOR_TARGET in
10545   [\\/]* | ?:[\\/]*)
10546   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10547   ;;
10548   *)
10549   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10550 for as_dir in $gcc_cv_tool_dirs
10551 do
10552   IFS=$as_save_IFS
10553   test -z "$as_dir" && as_dir=.
10554   for ac_exec_ext in '' $ac_executable_extensions; do
10555   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10556     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10557     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10558     break 2
10559   fi
10560 done
10561 done
10562
10563   ;;
10564 esac
10565 fi
10566 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10567
10568 if test -n "$OBJDUMP_FOR_TARGET"; then
10569   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10570 echo "${ECHO_T}$OBJDUMP_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_path_OBJDUMP_FOR_TARGET" ; then
10578
10579
10580 if test -n "$OBJDUMP_FOR_TARGET"; then
10581   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10582 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10583   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10584 fi
10585
10586 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10587   for ncn_progname in objdump; do
10588     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10589 set dummy ${ncn_progname}; ac_word=$2
10590 echo "$as_me:$LINENO: checking for $ac_word" >&5
10591 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10592 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10593   echo $ECHO_N "(cached) $ECHO_C" >&6
10594 else
10595   if test -n "$OBJDUMP_FOR_TARGET"; then
10596   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10597 else
10598 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10599 for as_dir in $PATH
10600 do
10601   IFS=$as_save_IFS
10602   test -z "$as_dir" && as_dir=.
10603   for ac_exec_ext in '' $ac_executable_extensions; do
10604   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10605     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10606     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10607     break 2
10608   fi
10609 done
10610 done
10611
10612 fi
10613 fi
10614 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10615 if test -n "$OBJDUMP_FOR_TARGET"; then
10616   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10617 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10618 else
10619   echo "$as_me:$LINENO: result: no" >&5
10620 echo "${ECHO_T}no" >&6
10621 fi
10622
10623   done
10624 fi
10625
10626 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10627   for ncn_progname in objdump; do
10628     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10629 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10630     if test -x $with_build_time_tools/${ncn_progname}; then
10631       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10632       echo "$as_me:$LINENO: result: yes" >&5
10633 echo "${ECHO_T}yes" >&6
10634       break
10635     else
10636       echo "$as_me:$LINENO: result: no" >&5
10637 echo "${ECHO_T}no" >&6
10638     fi
10639   done
10640 fi
10641
10642 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10643   for ncn_progname in objdump; do
10644     if test -n "$ncn_target_tool_prefix"; then
10645       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10646 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10647 echo "$as_me:$LINENO: checking for $ac_word" >&5
10648 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10649 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10650   echo $ECHO_N "(cached) $ECHO_C" >&6
10651 else
10652   if test -n "$OBJDUMP_FOR_TARGET"; then
10653   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10654 else
10655 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10656 for as_dir in $PATH
10657 do
10658   IFS=$as_save_IFS
10659   test -z "$as_dir" && as_dir=.
10660   for ac_exec_ext in '' $ac_executable_extensions; do
10661   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10662     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10663     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10664     break 2
10665   fi
10666 done
10667 done
10668
10669 fi
10670 fi
10671 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10672 if test -n "$OBJDUMP_FOR_TARGET"; then
10673   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10674 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10675 else
10676   echo "$as_me:$LINENO: result: no" >&5
10677 echo "${ECHO_T}no" >&6
10678 fi
10679
10680     fi
10681     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10682       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10683 set dummy ${ncn_progname}; ac_word=$2
10684 echo "$as_me:$LINENO: checking for $ac_word" >&5
10685 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10686 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10687   echo $ECHO_N "(cached) $ECHO_C" >&6
10688 else
10689   if test -n "$OBJDUMP_FOR_TARGET"; then
10690   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10691 else
10692 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10693 for as_dir in $PATH
10694 do
10695   IFS=$as_save_IFS
10696   test -z "$as_dir" && as_dir=.
10697   for ac_exec_ext in '' $ac_executable_extensions; do
10698   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10699     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10700     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10701     break 2
10702   fi
10703 done
10704 done
10705
10706 fi
10707 fi
10708 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10709 if test -n "$OBJDUMP_FOR_TARGET"; then
10710   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10711 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10712 else
10713   echo "$as_me:$LINENO: result: no" >&5
10714 echo "${ECHO_T}no" >&6
10715 fi
10716
10717     fi
10718     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10719   done
10720 fi
10721
10722 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10723   set dummy objdump
10724   if test $build = $target ; then
10725     OBJDUMP_FOR_TARGET="$2"
10726   else
10727     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10728   fi
10729 else
10730   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10731 fi
10732
10733 else
10734   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10735 fi
10736
10737
10738
10739
10740 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10741   if test -n "$with_build_time_tools"; then
10742     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10743 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10744     if test -x $with_build_time_tools/ranlib; then
10745       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10746       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10747       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10748 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10749     else
10750       echo "$as_me:$LINENO: result: no" >&5
10751 echo "${ECHO_T}no" >&6
10752     fi
10753   elif test $build != $host && test $have_gcc_for_target = yes; then
10754     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10755     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10756     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10757   fi
10758 fi
10759 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10760   # Extract the first word of "ranlib", so it can be a program name with args.
10761 set dummy ranlib; ac_word=$2
10762 echo "$as_me:$LINENO: checking for $ac_word" >&5
10763 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10764 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10765   echo $ECHO_N "(cached) $ECHO_C" >&6
10766 else
10767   case $RANLIB_FOR_TARGET in
10768   [\\/]* | ?:[\\/]*)
10769   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10770   ;;
10771   *)
10772   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10773 for as_dir in $gcc_cv_tool_dirs
10774 do
10775   IFS=$as_save_IFS
10776   test -z "$as_dir" && as_dir=.
10777   for ac_exec_ext in '' $ac_executable_extensions; do
10778   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10779     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10780     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10781     break 2
10782   fi
10783 done
10784 done
10785
10786   ;;
10787 esac
10788 fi
10789 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10790
10791 if test -n "$RANLIB_FOR_TARGET"; then
10792   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10793 echo "${ECHO_T}$RANLIB_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_path_RANLIB_FOR_TARGET" ; then
10801
10802
10803 if test -n "$RANLIB_FOR_TARGET"; then
10804   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10805 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10806   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10807 fi
10808
10809 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10810   for ncn_progname in ranlib; do
10811     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10812 set dummy ${ncn_progname}; ac_word=$2
10813 echo "$as_me:$LINENO: checking for $ac_word" >&5
10814 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10815 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10816   echo $ECHO_N "(cached) $ECHO_C" >&6
10817 else
10818   if test -n "$RANLIB_FOR_TARGET"; then
10819   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10820 else
10821 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10822 for as_dir in $PATH
10823 do
10824   IFS=$as_save_IFS
10825   test -z "$as_dir" && as_dir=.
10826   for ac_exec_ext in '' $ac_executable_extensions; do
10827   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10828     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10829     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10830     break 2
10831   fi
10832 done
10833 done
10834
10835 fi
10836 fi
10837 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10838 if test -n "$RANLIB_FOR_TARGET"; then
10839   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10840 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10841 else
10842   echo "$as_me:$LINENO: result: no" >&5
10843 echo "${ECHO_T}no" >&6
10844 fi
10845
10846   done
10847 fi
10848
10849 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10850   for ncn_progname in ranlib; do
10851     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10852 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10853     if test -x $with_build_time_tools/${ncn_progname}; then
10854       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10855       echo "$as_me:$LINENO: result: yes" >&5
10856 echo "${ECHO_T}yes" >&6
10857       break
10858     else
10859       echo "$as_me:$LINENO: result: no" >&5
10860 echo "${ECHO_T}no" >&6
10861     fi
10862   done
10863 fi
10864
10865 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10866   for ncn_progname in ranlib; do
10867     if test -n "$ncn_target_tool_prefix"; then
10868       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10869 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10870 echo "$as_me:$LINENO: checking for $ac_word" >&5
10871 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10872 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10873   echo $ECHO_N "(cached) $ECHO_C" >&6
10874 else
10875   if test -n "$RANLIB_FOR_TARGET"; then
10876   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10877 else
10878 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10879 for as_dir in $PATH
10880 do
10881   IFS=$as_save_IFS
10882   test -z "$as_dir" && as_dir=.
10883   for ac_exec_ext in '' $ac_executable_extensions; do
10884   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10885     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10886     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10887     break 2
10888   fi
10889 done
10890 done
10891
10892 fi
10893 fi
10894 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10895 if test -n "$RANLIB_FOR_TARGET"; then
10896   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10897 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10898 else
10899   echo "$as_me:$LINENO: result: no" >&5
10900 echo "${ECHO_T}no" >&6
10901 fi
10902
10903     fi
10904     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10905       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10906 set dummy ${ncn_progname}; ac_word=$2
10907 echo "$as_me:$LINENO: checking for $ac_word" >&5
10908 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10909 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10910   echo $ECHO_N "(cached) $ECHO_C" >&6
10911 else
10912   if test -n "$RANLIB_FOR_TARGET"; then
10913   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10914 else
10915 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10916 for as_dir in $PATH
10917 do
10918   IFS=$as_save_IFS
10919   test -z "$as_dir" && as_dir=.
10920   for ac_exec_ext in '' $ac_executable_extensions; do
10921   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10922     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10923     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10924     break 2
10925   fi
10926 done
10927 done
10928
10929 fi
10930 fi
10931 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10932 if test -n "$RANLIB_FOR_TARGET"; then
10933   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10934 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10935 else
10936   echo "$as_me:$LINENO: result: no" >&5
10937 echo "${ECHO_T}no" >&6
10938 fi
10939
10940     fi
10941     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10942   done
10943 fi
10944
10945 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10946   set dummy ranlib
10947   if test $build = $target ; then
10948     RANLIB_FOR_TARGET="$2"
10949   else
10950     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10951   fi
10952 else
10953   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10954 fi
10955
10956 else
10957   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10958 fi
10959
10960
10961
10962
10963 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10964   if test -n "$with_build_time_tools"; then
10965     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10966 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10967     if test -x $with_build_time_tools/strip; then
10968       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10969       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10970       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10971 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10972     else
10973       echo "$as_me:$LINENO: result: no" >&5
10974 echo "${ECHO_T}no" >&6
10975     fi
10976   elif test $build != $host && test $have_gcc_for_target = yes; then
10977     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10978     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10979     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10980   fi
10981 fi
10982 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10983   # Extract the first word of "strip", so it can be a program name with args.
10984 set dummy strip; ac_word=$2
10985 echo "$as_me:$LINENO: checking for $ac_word" >&5
10986 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10987 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10988   echo $ECHO_N "(cached) $ECHO_C" >&6
10989 else
10990   case $STRIP_FOR_TARGET in
10991   [\\/]* | ?:[\\/]*)
10992   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10993   ;;
10994   *)
10995   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10996 for as_dir in $gcc_cv_tool_dirs
10997 do
10998   IFS=$as_save_IFS
10999   test -z "$as_dir" && as_dir=.
11000   for ac_exec_ext in '' $ac_executable_extensions; do
11001   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11002     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11003     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11004     break 2
11005   fi
11006 done
11007 done
11008
11009   ;;
11010 esac
11011 fi
11012 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11013
11014 if test -n "$STRIP_FOR_TARGET"; then
11015   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11016 echo "${ECHO_T}$STRIP_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_path_STRIP_FOR_TARGET" ; then
11024
11025
11026 if test -n "$STRIP_FOR_TARGET"; then
11027   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11028 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11029   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11030 fi
11031
11032 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11033   for ncn_progname in strip; do
11034     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11035 set dummy ${ncn_progname}; ac_word=$2
11036 echo "$as_me:$LINENO: checking for $ac_word" >&5
11037 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11038 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11039   echo $ECHO_N "(cached) $ECHO_C" >&6
11040 else
11041   if test -n "$STRIP_FOR_TARGET"; then
11042   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11043 else
11044 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11045 for as_dir in $PATH
11046 do
11047   IFS=$as_save_IFS
11048   test -z "$as_dir" && as_dir=.
11049   for ac_exec_ext in '' $ac_executable_extensions; do
11050   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11051     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11052     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11053     break 2
11054   fi
11055 done
11056 done
11057
11058 fi
11059 fi
11060 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11061 if test -n "$STRIP_FOR_TARGET"; then
11062   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11063 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11064 else
11065   echo "$as_me:$LINENO: result: no" >&5
11066 echo "${ECHO_T}no" >&6
11067 fi
11068
11069   done
11070 fi
11071
11072 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11073   for ncn_progname in strip; do
11074     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11075 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11076     if test -x $with_build_time_tools/${ncn_progname}; then
11077       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11078       echo "$as_me:$LINENO: result: yes" >&5
11079 echo "${ECHO_T}yes" >&6
11080       break
11081     else
11082       echo "$as_me:$LINENO: result: no" >&5
11083 echo "${ECHO_T}no" >&6
11084     fi
11085   done
11086 fi
11087
11088 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11089   for ncn_progname in strip; do
11090     if test -n "$ncn_target_tool_prefix"; then
11091       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11092 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11093 echo "$as_me:$LINENO: checking for $ac_word" >&5
11094 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11095 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11096   echo $ECHO_N "(cached) $ECHO_C" >&6
11097 else
11098   if test -n "$STRIP_FOR_TARGET"; then
11099   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11100 else
11101 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11102 for as_dir in $PATH
11103 do
11104   IFS=$as_save_IFS
11105   test -z "$as_dir" && as_dir=.
11106   for ac_exec_ext in '' $ac_executable_extensions; do
11107   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11108     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11109     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11110     break 2
11111   fi
11112 done
11113 done
11114
11115 fi
11116 fi
11117 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11118 if test -n "$STRIP_FOR_TARGET"; then
11119   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11120 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11121 else
11122   echo "$as_me:$LINENO: result: no" >&5
11123 echo "${ECHO_T}no" >&6
11124 fi
11125
11126     fi
11127     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11128       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11129 set dummy ${ncn_progname}; ac_word=$2
11130 echo "$as_me:$LINENO: checking for $ac_word" >&5
11131 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11132 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11133   echo $ECHO_N "(cached) $ECHO_C" >&6
11134 else
11135   if test -n "$STRIP_FOR_TARGET"; then
11136   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11137 else
11138 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11139 for as_dir in $PATH
11140 do
11141   IFS=$as_save_IFS
11142   test -z "$as_dir" && as_dir=.
11143   for ac_exec_ext in '' $ac_executable_extensions; do
11144   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11145     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11146     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11147     break 2
11148   fi
11149 done
11150 done
11151
11152 fi
11153 fi
11154 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11155 if test -n "$STRIP_FOR_TARGET"; then
11156   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11157 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11158 else
11159   echo "$as_me:$LINENO: result: no" >&5
11160 echo "${ECHO_T}no" >&6
11161 fi
11162
11163     fi
11164     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11165   done
11166 fi
11167
11168 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11169   set dummy strip
11170   if test $build = $target ; then
11171     STRIP_FOR_TARGET="$2"
11172   else
11173     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11174   fi
11175 else
11176   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11177 fi
11178
11179 else
11180   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11181 fi
11182
11183
11184
11185
11186 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11187   if test -n "$with_build_time_tools"; then
11188     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11189 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11190     if test -x $with_build_time_tools/windres; then
11191       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11192       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11193       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11194 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11195     else
11196       echo "$as_me:$LINENO: result: no" >&5
11197 echo "${ECHO_T}no" >&6
11198     fi
11199   elif test $build != $host && test $have_gcc_for_target = yes; then
11200     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11201     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11202     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11203   fi
11204 fi
11205 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11206   # Extract the first word of "windres", so it can be a program name with args.
11207 set dummy windres; ac_word=$2
11208 echo "$as_me:$LINENO: checking for $ac_word" >&5
11209 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11210 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11211   echo $ECHO_N "(cached) $ECHO_C" >&6
11212 else
11213   case $WINDRES_FOR_TARGET in
11214   [\\/]* | ?:[\\/]*)
11215   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11216   ;;
11217   *)
11218   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11219 for as_dir in $gcc_cv_tool_dirs
11220 do
11221   IFS=$as_save_IFS
11222   test -z "$as_dir" && as_dir=.
11223   for ac_exec_ext in '' $ac_executable_extensions; do
11224   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11225     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11226     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11227     break 2
11228   fi
11229 done
11230 done
11231
11232   ;;
11233 esac
11234 fi
11235 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11236
11237 if test -n "$WINDRES_FOR_TARGET"; then
11238   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11239 echo "${ECHO_T}$WINDRES_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_path_WINDRES_FOR_TARGET" ; then
11247
11248
11249 if test -n "$WINDRES_FOR_TARGET"; then
11250   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11251 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11252   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11253 fi
11254
11255 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11256   for ncn_progname in windres; do
11257     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11258 set dummy ${ncn_progname}; ac_word=$2
11259 echo "$as_me:$LINENO: checking for $ac_word" >&5
11260 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11261 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11262   echo $ECHO_N "(cached) $ECHO_C" >&6
11263 else
11264   if test -n "$WINDRES_FOR_TARGET"; then
11265   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11266 else
11267 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11268 for as_dir in $PATH
11269 do
11270   IFS=$as_save_IFS
11271   test -z "$as_dir" && as_dir=.
11272   for ac_exec_ext in '' $ac_executable_extensions; do
11273   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11274     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11275     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11276     break 2
11277   fi
11278 done
11279 done
11280
11281 fi
11282 fi
11283 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11284 if test -n "$WINDRES_FOR_TARGET"; then
11285   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11286 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11287 else
11288   echo "$as_me:$LINENO: result: no" >&5
11289 echo "${ECHO_T}no" >&6
11290 fi
11291
11292   done
11293 fi
11294
11295 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11296   for ncn_progname in windres; do
11297     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11298 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11299     if test -x $with_build_time_tools/${ncn_progname}; then
11300       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11301       echo "$as_me:$LINENO: result: yes" >&5
11302 echo "${ECHO_T}yes" >&6
11303       break
11304     else
11305       echo "$as_me:$LINENO: result: no" >&5
11306 echo "${ECHO_T}no" >&6
11307     fi
11308   done
11309 fi
11310
11311 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11312   for ncn_progname in windres; do
11313     if test -n "$ncn_target_tool_prefix"; then
11314       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11315 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11316 echo "$as_me:$LINENO: checking for $ac_word" >&5
11317 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11318 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11319   echo $ECHO_N "(cached) $ECHO_C" >&6
11320 else
11321   if test -n "$WINDRES_FOR_TARGET"; then
11322   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11323 else
11324 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11325 for as_dir in $PATH
11326 do
11327   IFS=$as_save_IFS
11328   test -z "$as_dir" && as_dir=.
11329   for ac_exec_ext in '' $ac_executable_extensions; do
11330   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11331     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11332     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11333     break 2
11334   fi
11335 done
11336 done
11337
11338 fi
11339 fi
11340 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11341 if test -n "$WINDRES_FOR_TARGET"; then
11342   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11343 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11344 else
11345   echo "$as_me:$LINENO: result: no" >&5
11346 echo "${ECHO_T}no" >&6
11347 fi
11348
11349     fi
11350     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11351       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11352 set dummy ${ncn_progname}; ac_word=$2
11353 echo "$as_me:$LINENO: checking for $ac_word" >&5
11354 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11355 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11356   echo $ECHO_N "(cached) $ECHO_C" >&6
11357 else
11358   if test -n "$WINDRES_FOR_TARGET"; then
11359   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11360 else
11361 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11362 for as_dir in $PATH
11363 do
11364   IFS=$as_save_IFS
11365   test -z "$as_dir" && as_dir=.
11366   for ac_exec_ext in '' $ac_executable_extensions; do
11367   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11368     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11369     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11370     break 2
11371   fi
11372 done
11373 done
11374
11375 fi
11376 fi
11377 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11378 if test -n "$WINDRES_FOR_TARGET"; then
11379   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11380 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11381 else
11382   echo "$as_me:$LINENO: result: no" >&5
11383 echo "${ECHO_T}no" >&6
11384 fi
11385
11386     fi
11387     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11388   done
11389 fi
11390
11391 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11392   set dummy windres
11393   if test $build = $target ; then
11394     WINDRES_FOR_TARGET="$2"
11395   else
11396     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11397   fi
11398 else
11399   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11400 fi
11401
11402 else
11403   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11404 fi
11405
11406
11407
11408
11409 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11410   if test -n "$with_build_time_tools"; then
11411     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11412 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11413     if test -x $with_build_time_tools/windmc; then
11414       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11415       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11416       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11417 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11418     else
11419       echo "$as_me:$LINENO: result: no" >&5
11420 echo "${ECHO_T}no" >&6
11421     fi
11422   elif test $build != $host && test $have_gcc_for_target = yes; then
11423     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11424     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11425     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11426   fi
11427 fi
11428 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11429   # Extract the first word of "windmc", so it can be a program name with args.
11430 set dummy windmc; ac_word=$2
11431 echo "$as_me:$LINENO: checking for $ac_word" >&5
11432 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11433 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11434   echo $ECHO_N "(cached) $ECHO_C" >&6
11435 else
11436   case $WINDMC_FOR_TARGET in
11437   [\\/]* | ?:[\\/]*)
11438   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11439   ;;
11440   *)
11441   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11442 for as_dir in $gcc_cv_tool_dirs
11443 do
11444   IFS=$as_save_IFS
11445   test -z "$as_dir" && as_dir=.
11446   for ac_exec_ext in '' $ac_executable_extensions; do
11447   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11448     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11449     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11450     break 2
11451   fi
11452 done
11453 done
11454
11455   ;;
11456 esac
11457 fi
11458 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11459
11460 if test -n "$WINDMC_FOR_TARGET"; then
11461   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11462 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11463 else
11464   echo "$as_me:$LINENO: result: no" >&5
11465 echo "${ECHO_T}no" >&6
11466 fi
11467
11468 fi
11469 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11470
11471
11472 if test -n "$WINDMC_FOR_TARGET"; then
11473   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11474 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11475   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11476 fi
11477
11478 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11479   for ncn_progname in windmc; do
11480     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11481 set dummy ${ncn_progname}; ac_word=$2
11482 echo "$as_me:$LINENO: checking for $ac_word" >&5
11483 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11484 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11485   echo $ECHO_N "(cached) $ECHO_C" >&6
11486 else
11487   if test -n "$WINDMC_FOR_TARGET"; then
11488   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11489 else
11490 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11491 for as_dir in $PATH
11492 do
11493   IFS=$as_save_IFS
11494   test -z "$as_dir" && as_dir=.
11495   for ac_exec_ext in '' $ac_executable_extensions; do
11496   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11497     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11498     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11499     break 2
11500   fi
11501 done
11502 done
11503
11504 fi
11505 fi
11506 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11507 if test -n "$WINDMC_FOR_TARGET"; then
11508   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11509 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11510 else
11511   echo "$as_me:$LINENO: result: no" >&5
11512 echo "${ECHO_T}no" >&6
11513 fi
11514
11515   done
11516 fi
11517
11518 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11519   for ncn_progname in windmc; do
11520     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11521 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11522     if test -x $with_build_time_tools/${ncn_progname}; then
11523       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11524       echo "$as_me:$LINENO: result: yes" >&5
11525 echo "${ECHO_T}yes" >&6
11526       break
11527     else
11528       echo "$as_me:$LINENO: result: no" >&5
11529 echo "${ECHO_T}no" >&6
11530     fi
11531   done
11532 fi
11533
11534 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11535   for ncn_progname in windmc; do
11536     if test -n "$ncn_target_tool_prefix"; then
11537       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11538 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11539 echo "$as_me:$LINENO: checking for $ac_word" >&5
11540 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11541 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11542   echo $ECHO_N "(cached) $ECHO_C" >&6
11543 else
11544   if test -n "$WINDMC_FOR_TARGET"; then
11545   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11546 else
11547 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11548 for as_dir in $PATH
11549 do
11550   IFS=$as_save_IFS
11551   test -z "$as_dir" && as_dir=.
11552   for ac_exec_ext in '' $ac_executable_extensions; do
11553   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11554     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11555     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11556     break 2
11557   fi
11558 done
11559 done
11560
11561 fi
11562 fi
11563 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11564 if test -n "$WINDMC_FOR_TARGET"; then
11565   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11566 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11567 else
11568   echo "$as_me:$LINENO: result: no" >&5
11569 echo "${ECHO_T}no" >&6
11570 fi
11571
11572     fi
11573     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11574       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11575 set dummy ${ncn_progname}; ac_word=$2
11576 echo "$as_me:$LINENO: checking for $ac_word" >&5
11577 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11578 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11579   echo $ECHO_N "(cached) $ECHO_C" >&6
11580 else
11581   if test -n "$WINDMC_FOR_TARGET"; then
11582   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11583 else
11584 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11585 for as_dir in $PATH
11586 do
11587   IFS=$as_save_IFS
11588   test -z "$as_dir" && as_dir=.
11589   for ac_exec_ext in '' $ac_executable_extensions; do
11590   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11591     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11592     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11593     break 2
11594   fi
11595 done
11596 done
11597
11598 fi
11599 fi
11600 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11601 if test -n "$WINDMC_FOR_TARGET"; then
11602   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11603 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11604 else
11605   echo "$as_me:$LINENO: result: no" >&5
11606 echo "${ECHO_T}no" >&6
11607 fi
11608
11609     fi
11610     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11611   done
11612 fi
11613
11614 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11615   set dummy windmc
11616   if test $build = $target ; then
11617     WINDMC_FOR_TARGET="$2"
11618   else
11619     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11620   fi
11621 else
11622   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11623 fi
11624
11625 else
11626   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11627 fi
11628
11629
11630 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11631
11632 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11633 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11634 if test "x${build}" != "x${host}" ; then
11635   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11636     # We already found the complete path
11637     ac_dir=`dirname $AR_FOR_TARGET`
11638     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11639 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11640   else
11641     # Canadian cross, just use what we found
11642     echo "$as_me:$LINENO: result: pre-installed" >&5
11643 echo "${ECHO_T}pre-installed" >&6
11644   fi
11645 else
11646   ok=yes
11647   case " ${configdirs} " in
11648     *" binutils "*) ;;
11649     *) ok=no ;;
11650   esac
11651
11652   if test $ok = yes; then
11653     # An in-tree tool is available and we can use it
11654     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11655     echo "$as_me:$LINENO: result: just compiled" >&5
11656 echo "${ECHO_T}just compiled" >&6
11657   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11658     # We already found the complete path
11659     ac_dir=`dirname $AR_FOR_TARGET`
11660     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11661 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11662   elif test "x$target" = "x$host"; then
11663     # We can use an host tool
11664     AR_FOR_TARGET='$(AR)'
11665     echo "$as_me:$LINENO: result: host tool" >&5
11666 echo "${ECHO_T}host tool" >&6
11667   else
11668     # We need a cross tool
11669     echo "$as_me:$LINENO: result: pre-installed" >&5
11670 echo "${ECHO_T}pre-installed" >&6
11671   fi
11672 fi
11673
11674 echo "$as_me:$LINENO: checking where to find the target as" >&5
11675 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11676 if test "x${build}" != "x${host}" ; then
11677   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11678     # We already found the complete path
11679     ac_dir=`dirname $AS_FOR_TARGET`
11680     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11681 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11682   else
11683     # Canadian cross, just use what we found
11684     echo "$as_me:$LINENO: result: pre-installed" >&5
11685 echo "${ECHO_T}pre-installed" >&6
11686   fi
11687 else
11688   ok=yes
11689   case " ${configdirs} " in
11690     *" gas "*) ;;
11691     *) ok=no ;;
11692   esac
11693
11694   if test $ok = yes; then
11695     # An in-tree tool is available and we can use it
11696     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11697     echo "$as_me:$LINENO: result: just compiled" >&5
11698 echo "${ECHO_T}just compiled" >&6
11699   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11700     # We already found the complete path
11701     ac_dir=`dirname $AS_FOR_TARGET`
11702     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11703 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11704   elif test "x$target" = "x$host"; then
11705     # We can use an host tool
11706     AS_FOR_TARGET='$(AS)'
11707     echo "$as_me:$LINENO: result: host tool" >&5
11708 echo "${ECHO_T}host tool" >&6
11709   else
11710     # We need a cross tool
11711     echo "$as_me:$LINENO: result: pre-installed" >&5
11712 echo "${ECHO_T}pre-installed" >&6
11713   fi
11714 fi
11715
11716 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11717 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11718 if test "x${build}" != "x${host}" ; then
11719   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11720     # We already found the complete path
11721     ac_dir=`dirname $CC_FOR_TARGET`
11722     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11723 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11724   else
11725     # Canadian cross, just use what we found
11726     echo "$as_me:$LINENO: result: pre-installed" >&5
11727 echo "${ECHO_T}pre-installed" >&6
11728   fi
11729 else
11730   ok=yes
11731   case " ${configdirs} " in
11732     *" gcc "*) ;;
11733     *) ok=no ;;
11734   esac
11735
11736   if test $ok = yes; then
11737     # An in-tree tool is available and we can use it
11738     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11739     echo "$as_me:$LINENO: result: just compiled" >&5
11740 echo "${ECHO_T}just compiled" >&6
11741   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11742     # We already found the complete path
11743     ac_dir=`dirname $CC_FOR_TARGET`
11744     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11745 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11746   elif test "x$target" = "x$host"; then
11747     # We can use an host tool
11748     CC_FOR_TARGET='$(CC)'
11749     echo "$as_me:$LINENO: result: host tool" >&5
11750 echo "${ECHO_T}host tool" >&6
11751   else
11752     # We need a cross tool
11753     echo "$as_me:$LINENO: result: pre-installed" >&5
11754 echo "${ECHO_T}pre-installed" >&6
11755   fi
11756 fi
11757
11758 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11759 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11760 if test "x${build}" != "x${host}" ; then
11761   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11762     # We already found the complete path
11763     ac_dir=`dirname $CXX_FOR_TARGET`
11764     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11765 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11766   else
11767     # Canadian cross, just use what we found
11768     echo "$as_me:$LINENO: result: pre-installed" >&5
11769 echo "${ECHO_T}pre-installed" >&6
11770   fi
11771 else
11772   ok=yes
11773   case " ${configdirs} " in
11774     *" gcc "*) ;;
11775     *) ok=no ;;
11776   esac
11777   case ,${enable_languages}, in
11778     *,c++,*) ;;
11779     *) ok=no ;;
11780   esac
11781   if test $ok = yes; then
11782     # An in-tree tool is available and we can use it
11783     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'
11784     echo "$as_me:$LINENO: result: just compiled" >&5
11785 echo "${ECHO_T}just compiled" >&6
11786   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11787     # We already found the complete path
11788     ac_dir=`dirname $CXX_FOR_TARGET`
11789     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11790 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11791   elif test "x$target" = "x$host"; then
11792     # We can use an host tool
11793     CXX_FOR_TARGET='$(CXX)'
11794     echo "$as_me:$LINENO: result: host tool" >&5
11795 echo "${ECHO_T}host tool" >&6
11796   else
11797     # We need a cross tool
11798     echo "$as_me:$LINENO: result: pre-installed" >&5
11799 echo "${ECHO_T}pre-installed" >&6
11800   fi
11801 fi
11802
11803 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11804 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11805 if test "x${build}" != "x${host}" ; then
11806   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11807     # We already found the complete path
11808     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11809     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11810 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11811   else
11812     # Canadian cross, just use what we found
11813     echo "$as_me:$LINENO: result: pre-installed" >&5
11814 echo "${ECHO_T}pre-installed" >&6
11815   fi
11816 else
11817   ok=yes
11818   case " ${configdirs} " in
11819     *" gcc "*) ;;
11820     *) ok=no ;;
11821   esac
11822   case ,${enable_languages}, in
11823     *,c++,*) ;;
11824     *) ok=no ;;
11825   esac
11826   if test $ok = yes; then
11827     # An in-tree tool is available and we can use it
11828     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'
11829     echo "$as_me:$LINENO: result: just compiled" >&5
11830 echo "${ECHO_T}just compiled" >&6
11831   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11832     # We already found the complete path
11833     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11834     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11835 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11836   elif test "x$target" = "x$host"; then
11837     # We can use an host tool
11838     RAW_CXX_FOR_TARGET='$(CXX)'
11839     echo "$as_me:$LINENO: result: host tool" >&5
11840 echo "${ECHO_T}host tool" >&6
11841   else
11842     # We need a cross tool
11843     echo "$as_me:$LINENO: result: pre-installed" >&5
11844 echo "${ECHO_T}pre-installed" >&6
11845   fi
11846 fi
11847
11848 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11849 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11850 if test "x${build}" != "x${host}" ; then
11851   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11852     # We already found the complete path
11853     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11854     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11855 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11856   else
11857     # Canadian cross, just use what we found
11858     echo "$as_me:$LINENO: result: pre-installed" >&5
11859 echo "${ECHO_T}pre-installed" >&6
11860   fi
11861 else
11862   ok=yes
11863   case " ${configdirs} " in
11864     *" binutils "*) ;;
11865     *) ok=no ;;
11866   esac
11867
11868   if test $ok = yes; then
11869     # An in-tree tool is available and we can use it
11870     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11871     echo "$as_me:$LINENO: result: just compiled" >&5
11872 echo "${ECHO_T}just compiled" >&6
11873   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11874     # We already found the complete path
11875     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11876     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11877 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11878   elif test "x$target" = "x$host"; then
11879     # We can use an host tool
11880     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11881     echo "$as_me:$LINENO: result: host tool" >&5
11882 echo "${ECHO_T}host tool" >&6
11883   else
11884     # We need a cross tool
11885     echo "$as_me:$LINENO: result: pre-installed" >&5
11886 echo "${ECHO_T}pre-installed" >&6
11887   fi
11888 fi
11889
11890 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11891 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11892 if test "x${build}" != "x${host}" ; then
11893   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11894     # We already found the complete path
11895     ac_dir=`dirname $GCC_FOR_TARGET`
11896     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11897 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11898   else
11899     # Canadian cross, just use what we found
11900     echo "$as_me:$LINENO: result: pre-installed" >&5
11901 echo "${ECHO_T}pre-installed" >&6
11902   fi
11903 else
11904   ok=yes
11905   case " ${configdirs} " in
11906     *" gcc "*) ;;
11907     *) ok=no ;;
11908   esac
11909
11910   if test $ok = yes; then
11911     # An in-tree tool is available and we can use it
11912     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11913     echo "$as_me:$LINENO: result: just compiled" >&5
11914 echo "${ECHO_T}just compiled" >&6
11915   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11916     # We already found the complete path
11917     ac_dir=`dirname $GCC_FOR_TARGET`
11918     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11919 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11920   elif test "x$target" = "x$host"; then
11921     # We can use an host tool
11922     GCC_FOR_TARGET='$()'
11923     echo "$as_me:$LINENO: result: host tool" >&5
11924 echo "${ECHO_T}host tool" >&6
11925   else
11926     # We need a cross tool
11927     echo "$as_me:$LINENO: result: pre-installed" >&5
11928 echo "${ECHO_T}pre-installed" >&6
11929   fi
11930 fi
11931
11932 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11933 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11934 if test "x${build}" != "x${host}" ; then
11935   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11936     # We already found the complete path
11937     ac_dir=`dirname $GCJ_FOR_TARGET`
11938     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11939 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11940   else
11941     # Canadian cross, just use what we found
11942     echo "$as_me:$LINENO: result: pre-installed" >&5
11943 echo "${ECHO_T}pre-installed" >&6
11944   fi
11945 else
11946   ok=yes
11947   case " ${configdirs} " in
11948     *" gcc "*) ;;
11949     *) ok=no ;;
11950   esac
11951   case ,${enable_languages}, in
11952     *,java,*) ;;
11953     *) ok=no ;;
11954   esac
11955   if test $ok = yes; then
11956     # An in-tree tool is available and we can use it
11957     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11958     echo "$as_me:$LINENO: result: just compiled" >&5
11959 echo "${ECHO_T}just compiled" >&6
11960   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11961     # We already found the complete path
11962     ac_dir=`dirname $GCJ_FOR_TARGET`
11963     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11964 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11965   elif test "x$target" = "x$host"; then
11966     # We can use an host tool
11967     GCJ_FOR_TARGET='$(GCJ)'
11968     echo "$as_me:$LINENO: result: host tool" >&5
11969 echo "${ECHO_T}host tool" >&6
11970   else
11971     # We need a cross tool
11972     echo "$as_me:$LINENO: result: pre-installed" >&5
11973 echo "${ECHO_T}pre-installed" >&6
11974   fi
11975 fi
11976
11977 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11978 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11979 if test "x${build}" != "x${host}" ; then
11980   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11981     # We already found the complete path
11982     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11983     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11984 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11985   else
11986     # Canadian cross, just use what we found
11987     echo "$as_me:$LINENO: result: pre-installed" >&5
11988 echo "${ECHO_T}pre-installed" >&6
11989   fi
11990 else
11991   ok=yes
11992   case " ${configdirs} " in
11993     *" gcc "*) ;;
11994     *) ok=no ;;
11995   esac
11996   case ,${enable_languages}, in
11997     *,fortran,*) ;;
11998     *) ok=no ;;
11999   esac
12000   if test $ok = yes; then
12001     # An in-tree tool is available and we can use it
12002     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12003     echo "$as_me:$LINENO: result: just compiled" >&5
12004 echo "${ECHO_T}just compiled" >&6
12005   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12006     # We already found the complete path
12007     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12008     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12009 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12010   elif test "x$target" = "x$host"; then
12011     # We can use an host tool
12012     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12013     echo "$as_me:$LINENO: result: host tool" >&5
12014 echo "${ECHO_T}host tool" >&6
12015   else
12016     # We need a cross tool
12017     echo "$as_me:$LINENO: result: pre-installed" >&5
12018 echo "${ECHO_T}pre-installed" >&6
12019   fi
12020 fi
12021
12022 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12023 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12024 if test "x${build}" != "x${host}" ; then
12025   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12026     # We already found the complete path
12027     ac_dir=`dirname $LD_FOR_TARGET`
12028     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12029 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12030   else
12031     # Canadian cross, just use what we found
12032     echo "$as_me:$LINENO: result: pre-installed" >&5
12033 echo "${ECHO_T}pre-installed" >&6
12034   fi
12035 else
12036   ok=yes
12037   case " ${configdirs} " in
12038     *" ld "*) ;;
12039     *) ok=no ;;
12040   esac
12041
12042   if test $ok = yes; then
12043     # An in-tree tool is available and we can use it
12044     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12045     echo "$as_me:$LINENO: result: just compiled" >&5
12046 echo "${ECHO_T}just compiled" >&6
12047   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12048     # We already found the complete path
12049     ac_dir=`dirname $LD_FOR_TARGET`
12050     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12051 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12052   elif test "x$target" = "x$host"; then
12053     # We can use an host tool
12054     LD_FOR_TARGET='$(LD)'
12055     echo "$as_me:$LINENO: result: host tool" >&5
12056 echo "${ECHO_T}host tool" >&6
12057   else
12058     # We need a cross tool
12059     echo "$as_me:$LINENO: result: pre-installed" >&5
12060 echo "${ECHO_T}pre-installed" >&6
12061   fi
12062 fi
12063
12064 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12065 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12066 if test "x${build}" != "x${host}" ; then
12067   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12068     # We already found the complete path
12069     ac_dir=`dirname $LIPO_FOR_TARGET`
12070     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12071 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12072   else
12073     # Canadian cross, just use what we found
12074     echo "$as_me:$LINENO: result: pre-installed" >&5
12075 echo "${ECHO_T}pre-installed" >&6
12076   fi
12077 else
12078   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12079     # We already found the complete path
12080     ac_dir=`dirname $LIPO_FOR_TARGET`
12081     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12082 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12083   elif test "x$target" = "x$host"; then
12084     # We can use an host tool
12085     LIPO_FOR_TARGET='$(LIPO)'
12086     echo "$as_me:$LINENO: result: host tool" >&5
12087 echo "${ECHO_T}host tool" >&6
12088   else
12089     # We need a cross tool
12090     echo "$as_me:$LINENO: result: pre-installed" >&5
12091 echo "${ECHO_T}pre-installed" >&6
12092   fi
12093 fi
12094
12095 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12096 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12097 if test "x${build}" != "x${host}" ; then
12098   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12099     # We already found the complete path
12100     ac_dir=`dirname $NM_FOR_TARGET`
12101     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12102 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12103   else
12104     # Canadian cross, just use what we found
12105     echo "$as_me:$LINENO: result: pre-installed" >&5
12106 echo "${ECHO_T}pre-installed" >&6
12107   fi
12108 else
12109   ok=yes
12110   case " ${configdirs} " in
12111     *" binutils "*) ;;
12112     *) ok=no ;;
12113   esac
12114
12115   if test $ok = yes; then
12116     # An in-tree tool is available and we can use it
12117     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12118     echo "$as_me:$LINENO: result: just compiled" >&5
12119 echo "${ECHO_T}just compiled" >&6
12120   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12121     # We already found the complete path
12122     ac_dir=`dirname $NM_FOR_TARGET`
12123     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12124 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12125   elif test "x$target" = "x$host"; then
12126     # We can use an host tool
12127     NM_FOR_TARGET='$(NM)'
12128     echo "$as_me:$LINENO: result: host tool" >&5
12129 echo "${ECHO_T}host tool" >&6
12130   else
12131     # We need a cross tool
12132     echo "$as_me:$LINENO: result: pre-installed" >&5
12133 echo "${ECHO_T}pre-installed" >&6
12134   fi
12135 fi
12136
12137 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12138 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12139 if test "x${build}" != "x${host}" ; then
12140   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12141     # We already found the complete path
12142     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12143     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12144 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12145   else
12146     # Canadian cross, just use what we found
12147     echo "$as_me:$LINENO: result: pre-installed" >&5
12148 echo "${ECHO_T}pre-installed" >&6
12149   fi
12150 else
12151   ok=yes
12152   case " ${configdirs} " in
12153     *" binutils "*) ;;
12154     *) ok=no ;;
12155   esac
12156
12157   if test $ok = yes; then
12158     # An in-tree tool is available and we can use it
12159     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12160     echo "$as_me:$LINENO: result: just compiled" >&5
12161 echo "${ECHO_T}just compiled" >&6
12162   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12163     # We already found the complete path
12164     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12165     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12166 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12167   elif test "x$target" = "x$host"; then
12168     # We can use an host tool
12169     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12170     echo "$as_me:$LINENO: result: host tool" >&5
12171 echo "${ECHO_T}host tool" >&6
12172   else
12173     # We need a cross tool
12174     echo "$as_me:$LINENO: result: pre-installed" >&5
12175 echo "${ECHO_T}pre-installed" >&6
12176   fi
12177 fi
12178
12179 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12180 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12181 if test "x${build}" != "x${host}" ; then
12182   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12183     # We already found the complete path
12184     ac_dir=`dirname $RANLIB_FOR_TARGET`
12185     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12186 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12187   else
12188     # Canadian cross, just use what we found
12189     echo "$as_me:$LINENO: result: pre-installed" >&5
12190 echo "${ECHO_T}pre-installed" >&6
12191   fi
12192 else
12193   ok=yes
12194   case " ${configdirs} " in
12195     *" binutils "*) ;;
12196     *) ok=no ;;
12197   esac
12198
12199   if test $ok = yes; then
12200     # An in-tree tool is available and we can use it
12201     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12202     echo "$as_me:$LINENO: result: just compiled" >&5
12203 echo "${ECHO_T}just compiled" >&6
12204   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12205     # We already found the complete path
12206     ac_dir=`dirname $RANLIB_FOR_TARGET`
12207     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12208 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12209   elif test "x$target" = "x$host"; then
12210     # We can use an host tool
12211     RANLIB_FOR_TARGET='$(RANLIB)'
12212     echo "$as_me:$LINENO: result: host tool" >&5
12213 echo "${ECHO_T}host tool" >&6
12214   else
12215     # We need a cross tool
12216     echo "$as_me:$LINENO: result: pre-installed" >&5
12217 echo "${ECHO_T}pre-installed" >&6
12218   fi
12219 fi
12220
12221 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12222 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12223 if test "x${build}" != "x${host}" ; then
12224   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12225     # We already found the complete path
12226     ac_dir=`dirname $STRIP_FOR_TARGET`
12227     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12228 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12229   else
12230     # Canadian cross, just use what we found
12231     echo "$as_me:$LINENO: result: pre-installed" >&5
12232 echo "${ECHO_T}pre-installed" >&6
12233   fi
12234 else
12235   ok=yes
12236   case " ${configdirs} " in
12237     *" binutils "*) ;;
12238     *) ok=no ;;
12239   esac
12240
12241   if test $ok = yes; then
12242     # An in-tree tool is available and we can use it
12243     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12244     echo "$as_me:$LINENO: result: just compiled" >&5
12245 echo "${ECHO_T}just compiled" >&6
12246   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12247     # We already found the complete path
12248     ac_dir=`dirname $STRIP_FOR_TARGET`
12249     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12250 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12251   elif test "x$target" = "x$host"; then
12252     # We can use an host tool
12253     STRIP_FOR_TARGET='$(STRIP)'
12254     echo "$as_me:$LINENO: result: host tool" >&5
12255 echo "${ECHO_T}host tool" >&6
12256   else
12257     # We need a cross tool
12258     echo "$as_me:$LINENO: result: pre-installed" >&5
12259 echo "${ECHO_T}pre-installed" >&6
12260   fi
12261 fi
12262
12263 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12264 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12265 if test "x${build}" != "x${host}" ; then
12266   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12267     # We already found the complete path
12268     ac_dir=`dirname $WINDRES_FOR_TARGET`
12269     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12270 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12271   else
12272     # Canadian cross, just use what we found
12273     echo "$as_me:$LINENO: result: pre-installed" >&5
12274 echo "${ECHO_T}pre-installed" >&6
12275   fi
12276 else
12277   ok=yes
12278   case " ${configdirs} " in
12279     *" binutils "*) ;;
12280     *) ok=no ;;
12281   esac
12282
12283   if test $ok = yes; then
12284     # An in-tree tool is available and we can use it
12285     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12286     echo "$as_me:$LINENO: result: just compiled" >&5
12287 echo "${ECHO_T}just compiled" >&6
12288   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12289     # We already found the complete path
12290     ac_dir=`dirname $WINDRES_FOR_TARGET`
12291     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12292 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12293   elif test "x$target" = "x$host"; then
12294     # We can use an host tool
12295     WINDRES_FOR_TARGET='$(WINDRES)'
12296     echo "$as_me:$LINENO: result: host tool" >&5
12297 echo "${ECHO_T}host tool" >&6
12298   else
12299     # We need a cross tool
12300     echo "$as_me:$LINENO: result: pre-installed" >&5
12301 echo "${ECHO_T}pre-installed" >&6
12302   fi
12303 fi
12304
12305 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12306 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12307 if test "x${build}" != "x${host}" ; then
12308   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12309     # We already found the complete path
12310     ac_dir=`dirname $WINDMC_FOR_TARGET`
12311     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12312 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12313   else
12314     # Canadian cross, just use what we found
12315     echo "$as_me:$LINENO: result: pre-installed" >&5
12316 echo "${ECHO_T}pre-installed" >&6
12317   fi
12318 else
12319   ok=yes
12320   case " ${configdirs} " in
12321     *" binutils "*) ;;
12322     *) ok=no ;;
12323   esac
12324
12325   if test $ok = yes; then
12326     # An in-tree tool is available and we can use it
12327     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12328     echo "$as_me:$LINENO: result: just compiled" >&5
12329 echo "${ECHO_T}just compiled" >&6
12330   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12331     # We already found the complete path
12332     ac_dir=`dirname $WINDMC_FOR_TARGET`
12333     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12334 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12335   elif test "x$target" = "x$host"; then
12336     # We can use an host tool
12337     WINDMC_FOR_TARGET='$(WINDMC)'
12338     echo "$as_me:$LINENO: result: host tool" >&5
12339 echo "${ECHO_T}host tool" >&6
12340   else
12341     # We need a cross tool
12342     echo "$as_me:$LINENO: result: pre-installed" >&5
12343 echo "${ECHO_T}pre-installed" >&6
12344   fi
12345 fi
12346
12347
12348
12349
12350
12351 # Certain tools may need extra flags.
12352 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12353 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12354 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12355
12356 # When building target libraries, except in a Canadian cross, we use
12357 # the same toolchain as the compiler we just built.
12358 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12359 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12360 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12361 if test $host = $build; then
12362   case " $configdirs " in
12363     *" gcc "*)
12364       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12365       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12366       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12367       ;;
12368   esac
12369 fi
12370
12371
12372
12373
12374
12375 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12376 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12377 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12378 if test "${enable_maintainer_mode+set}" = set; then
12379   enableval="$enable_maintainer_mode"
12380   USE_MAINTAINER_MODE=$enableval
12381 else
12382   USE_MAINTAINER_MODE=no
12383 fi;
12384 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12385 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12386
12387
12388 if test "$USE_MAINTAINER_MODE" = yes; then
12389   MAINTAINER_MODE_TRUE=
12390   MAINTAINER_MODE_FALSE='#'
12391 else
12392   MAINTAINER_MODE_TRUE='#'
12393   MAINTAINER_MODE_FALSE=
12394 fi
12395 MAINT=$MAINTAINER_MODE_TRUE
12396
12397 # ---------------------
12398 # GCC bootstrap support
12399 # ---------------------
12400
12401 # Stage specific cflags for build.
12402 stage1_cflags="-g"
12403 case $build in
12404   vax-*-*)
12405     case ${GCC} in
12406       yes) stage1_cflags="-g -Wa,-J" ;;
12407       *) stage1_cflags="-g -J" ;;
12408     esac ;;
12409 esac
12410
12411 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12412 if test "$GCC" = yes; then
12413   saved_CFLAGS="$CFLAGS"
12414
12415   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12416   CFLAGS="$CFLAGS -fkeep-inline-functions"
12417   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12418 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12419   cat >conftest.$ac_ext <<_ACEOF
12420 /* confdefs.h.  */
12421 _ACEOF
12422 cat confdefs.h >>conftest.$ac_ext
12423 cat >>conftest.$ac_ext <<_ACEOF
12424 /* end confdefs.h.  */
12425
12426 #if (__GNUC__ < 3) \
12427     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12428                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12429 #error http://gcc.gnu.org/PR29382
12430 #endif
12431
12432 int
12433 main ()
12434 {
12435
12436   ;
12437   return 0;
12438 }
12439 _ACEOF
12440 rm -f conftest.$ac_objext
12441 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12442   (eval $ac_compile) 2>conftest.er1
12443   ac_status=$?
12444   grep -v '^ *+' conftest.er1 >conftest.err
12445   rm -f conftest.er1
12446   cat conftest.err >&5
12447   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12448   (exit $ac_status); } &&
12449          { ac_try='test -z "$ac_c_werror_flag"
12450                          || test ! -s conftest.err'
12451   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12452   (eval $ac_try) 2>&5
12453   ac_status=$?
12454   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12455   (exit $ac_status); }; } &&
12456          { ac_try='test -s conftest.$ac_objext'
12457   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12458   (eval $ac_try) 2>&5
12459   ac_status=$?
12460   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12461   (exit $ac_status); }; }; then
12462   echo "$as_me:$LINENO: result: yes" >&5
12463 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12464 else
12465   echo "$as_me: failed program was:" >&5
12466 sed 's/^/| /' conftest.$ac_ext >&5
12467
12468 echo "$as_me:$LINENO: result: no" >&5
12469 echo "${ECHO_T}no" >&6
12470 fi
12471 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12472
12473   CFLAGS="$saved_CFLAGS"
12474 fi
12475
12476
12477
12478 # Enable --enable-checking in stage1 of the compiler.
12479 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12480 if test "${enable_stage1_checking+set}" = set; then
12481   enableval="$enable_stage1_checking"
12482   stage1_checking=--enable-checking=${enable_stage1_checking}
12483 else
12484   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12485   stage1_checking=--enable-checking=yes,types
12486 else
12487   stage1_checking=--enable-checking=$enable_checking,types
12488 fi
12489 fi;
12490
12491
12492 # Enable -Werror in bootstrap stage2 and later.
12493 # Check whether --enable-werror or --disable-werror was given.
12494 if test "${enable_werror+set}" = set; then
12495   enableval="$enable_werror"
12496
12497 else
12498   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12499   enable_werror=yes
12500 else
12501   enable_werror=no
12502 fi
12503 fi;
12504 case ${enable_werror} in
12505   yes) stage2_werror_flag="--enable-werror-always" ;;
12506   *) stage2_werror_flag="" ;;
12507 esac
12508
12509
12510 # Flags needed to enable html installing and building
12511
12512 # Check whether --with-datarootdir or --without-datarootdir was given.
12513 if test "${with_datarootdir+set}" = set; then
12514   withval="$with_datarootdir"
12515   datarootdir="\${prefix}/${withval}"
12516 else
12517   datarootdir="\${prefix}/share"
12518 fi;
12519
12520
12521 # Check whether --with-docdir or --without-docdir was given.
12522 if test "${with_docdir+set}" = set; then
12523   withval="$with_docdir"
12524   docdir="\${prefix}/${withval}"
12525 else
12526   docdir="\${datarootdir}/doc"
12527 fi;
12528
12529
12530 # Check whether --with-pdfdir or --without-pdfdir was given.
12531 if test "${with_pdfdir+set}" = set; then
12532   withval="$with_pdfdir"
12533   pdfdir="\${prefix}/${withval}"
12534 else
12535   pdfdir="\${docdir}"
12536 fi;
12537
12538
12539 # Check whether --with-htmldir or --without-htmldir was given.
12540 if test "${with_htmldir+set}" = set; then
12541   withval="$with_htmldir"
12542   htmldir="\${prefix}/${withval}"
12543 else
12544   htmldir="\${docdir}"
12545 fi;
12546
12547
12548
12549
12550
12551
12552           ac_config_files="$ac_config_files Makefile"
12553 cat >confcache <<\_ACEOF
12554 # This file is a shell script that caches the results of configure
12555 # tests run on this system so they can be shared between configure
12556 # scripts and configure runs, see configure's option --config-cache.
12557 # It is not useful on other systems.  If it contains results you don't
12558 # want to keep, you may remove or edit it.
12559 #
12560 # config.status only pays attention to the cache file if you give it
12561 # the --recheck option to rerun configure.
12562 #
12563 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12564 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12565 # following values.
12566
12567 _ACEOF
12568
12569 # The following way of writing the cache mishandles newlines in values,
12570 # but we know of no workaround that is simple, portable, and efficient.
12571 # So, don't put newlines in cache variables' values.
12572 # Ultrix sh set writes to stderr and can't be redirected directly,
12573 # and sets the high bit in the cache file unless we assign to the vars.
12574 {
12575   (set) 2>&1 |
12576     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12577     *ac_space=\ *)
12578       # `set' does not quote correctly, so add quotes (double-quote
12579       # substitution turns \\\\ into \\, and sed turns \\ into \).
12580       sed -n \
12581         "s/'/'\\\\''/g;
12582           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12583       ;;
12584     *)
12585       # `set' quotes correctly as required by POSIX, so do not add quotes.
12586       sed -n \
12587         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12588       ;;
12589     esac;
12590 } |
12591   sed '
12592      t clear
12593      : clear
12594      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12595      t end
12596      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12597      : end' >>confcache
12598 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12599   if test -w $cache_file; then
12600     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12601     cat confcache >$cache_file
12602   else
12603     echo "not updating unwritable cache $cache_file"
12604   fi
12605 fi
12606 rm -f confcache
12607
12608 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12609 # Let make expand exec_prefix.
12610 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12611
12612 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12613 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12614 # trailing colons and then remove the whole line if VPATH becomes empty
12615 # (actually we leave an empty line to preserve line numbers).
12616 if test "x$srcdir" = x.; then
12617   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12618 s/:*\$(srcdir):*/:/;
12619 s/:*\${srcdir}:*/:/;
12620 s/:*@srcdir@:*/:/;
12621 s/^\([^=]*=[     ]*\):*/\1/;
12622 s/:*$//;
12623 s/^[^=]*=[       ]*$//;
12624 }'
12625 fi
12626
12627 # Transform confdefs.h into DEFS.
12628 # Protect against shell expansion while executing Makefile rules.
12629 # Protect against Makefile macro expansion.
12630 #
12631 # If the first sed substitution is executed (which looks for macros that
12632 # take arguments), then we branch to the quote section.  Otherwise,
12633 # look for a macro that doesn't take arguments.
12634 cat >confdef2opt.sed <<\_ACEOF
12635 t clear
12636 : clear
12637 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12638 t quote
12639 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12640 t quote
12641 d
12642 : quote
12643 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12644 s,\[,\\&,g
12645 s,\],\\&,g
12646 s,\$,$$,g
12647 p
12648 _ACEOF
12649 # We use echo to avoid assuming a particular line-breaking character.
12650 # The extra dot is to prevent the shell from consuming trailing
12651 # line-breaks from the sub-command output.  A line-break within
12652 # single-quotes doesn't work because, if this script is created in a
12653 # platform that uses two characters for line-breaks (e.g., DOS), tr
12654 # would break.
12655 ac_LF_and_DOT=`echo; echo .`
12656 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12657 rm -f confdef2opt.sed
12658
12659
12660 ac_libobjs=
12661 ac_ltlibobjs=
12662 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12663   # 1. Remove the extension, and $U if already installed.
12664   ac_i=`echo "$ac_i" |
12665          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12666   # 2. Add them.
12667   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12668   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12669 done
12670 LIBOBJS=$ac_libobjs
12671
12672 LTLIBOBJS=$ac_ltlibobjs
12673
12674
12675
12676 : ${CONFIG_STATUS=./config.status}
12677 ac_clean_files_save=$ac_clean_files
12678 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12679 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12680 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12681 cat >$CONFIG_STATUS <<_ACEOF
12682 #! $SHELL
12683 # Generated by $as_me.
12684 # Run this file to recreate the current configuration.
12685 # Compiler output produced by configure, useful for debugging
12686 # configure, is in config.log if it exists.
12687
12688 debug=false
12689 ac_cs_recheck=false
12690 ac_cs_silent=false
12691 SHELL=\${CONFIG_SHELL-$SHELL}
12692 _ACEOF
12693
12694 cat >>$CONFIG_STATUS <<\_ACEOF
12695 ## --------------------- ##
12696 ## M4sh Initialization.  ##
12697 ## --------------------- ##
12698
12699 # Be Bourne compatible
12700 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12701   emulate sh
12702   NULLCMD=:
12703   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12704   # is contrary to our usage.  Disable this feature.
12705   alias -g '${1+"$@"}'='"$@"'
12706 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12707   set -o posix
12708 fi
12709 DUALCASE=1; export DUALCASE # for MKS sh
12710
12711 # Support unset when possible.
12712 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12713   as_unset=unset
12714 else
12715   as_unset=false
12716 fi
12717
12718
12719 # Work around bugs in pre-3.0 UWIN ksh.
12720 $as_unset ENV MAIL MAILPATH
12721 PS1='$ '
12722 PS2='> '
12723 PS4='+ '
12724
12725 # NLS nuisances.
12726 for as_var in \
12727   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12728   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12729   LC_TELEPHONE LC_TIME
12730 do
12731   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12732     eval $as_var=C; export $as_var
12733   else
12734     $as_unset $as_var
12735   fi
12736 done
12737
12738 # Required to use basename.
12739 if expr a : '\(a\)' >/dev/null 2>&1; then
12740   as_expr=expr
12741 else
12742   as_expr=false
12743 fi
12744
12745 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12746   as_basename=basename
12747 else
12748   as_basename=false
12749 fi
12750
12751
12752 # Name of the executable.
12753 as_me=`$as_basename "$0" ||
12754 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12755          X"$0" : 'X\(//\)$' \| \
12756          X"$0" : 'X\(/\)$' \| \
12757          .     : '\(.\)' 2>/dev/null ||
12758 echo X/"$0" |
12759     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12760           /^X\/\(\/\/\)$/{ s//\1/; q; }
12761           /^X\/\(\/\).*/{ s//\1/; q; }
12762           s/.*/./; q'`
12763
12764
12765 # PATH needs CR, and LINENO needs CR and PATH.
12766 # Avoid depending upon Character Ranges.
12767 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12768 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12769 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12770 as_cr_digits='0123456789'
12771 as_cr_alnum=$as_cr_Letters$as_cr_digits
12772
12773 # The user is always right.
12774 if test "${PATH_SEPARATOR+set}" != set; then
12775   echo "#! /bin/sh" >conf$$.sh
12776   echo  "exit 0"   >>conf$$.sh
12777   chmod +x conf$$.sh
12778   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12779     PATH_SEPARATOR=';'
12780   else
12781     PATH_SEPARATOR=:
12782   fi
12783   rm -f conf$$.sh
12784 fi
12785
12786
12787   as_lineno_1=$LINENO
12788   as_lineno_2=$LINENO
12789   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12790   test "x$as_lineno_1" != "x$as_lineno_2" &&
12791   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12792   # Find who we are.  Look in the path if we contain no path at all
12793   # relative or not.
12794   case $0 in
12795     *[\\/]* ) as_myself=$0 ;;
12796     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12797 for as_dir in $PATH
12798 do
12799   IFS=$as_save_IFS
12800   test -z "$as_dir" && as_dir=.
12801   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12802 done
12803
12804        ;;
12805   esac
12806   # We did not find ourselves, most probably we were run as `sh COMMAND'
12807   # in which case we are not to be found in the path.
12808   if test "x$as_myself" = x; then
12809     as_myself=$0
12810   fi
12811   if test ! -f "$as_myself"; then
12812     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12813 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12814    { (exit 1); exit 1; }; }
12815   fi
12816   case $CONFIG_SHELL in
12817   '')
12818     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12819 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12820 do
12821   IFS=$as_save_IFS
12822   test -z "$as_dir" && as_dir=.
12823   for as_base in sh bash ksh sh5; do
12824          case $as_dir in
12825          /*)
12826            if ("$as_dir/$as_base" -c '
12827   as_lineno_1=$LINENO
12828   as_lineno_2=$LINENO
12829   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12830   test "x$as_lineno_1" != "x$as_lineno_2" &&
12831   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12832              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12833              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12834              CONFIG_SHELL=$as_dir/$as_base
12835              export CONFIG_SHELL
12836              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12837            fi;;
12838          esac
12839        done
12840 done
12841 ;;
12842   esac
12843
12844   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12845   # uniformly replaced by the line number.  The first 'sed' inserts a
12846   # line-number line before each line; the second 'sed' does the real
12847   # work.  The second script uses 'N' to pair each line-number line
12848   # with the numbered line, and appends trailing '-' during
12849   # substitution so that $LINENO is not a special case at line end.
12850   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12851   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12852   sed '=' <$as_myself |
12853     sed '
12854       N
12855       s,$,-,
12856       : loop
12857       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12858       t loop
12859       s,-$,,
12860       s,^['$as_cr_digits']*\n,,
12861     ' >$as_me.lineno &&
12862   chmod +x $as_me.lineno ||
12863     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12864 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12865    { (exit 1); exit 1; }; }
12866
12867   # Don't try to exec as it changes $[0], causing all sort of problems
12868   # (the dirname of $[0] is not the place where we might find the
12869   # original and so on.  Autoconf is especially sensible to this).
12870   . ./$as_me.lineno
12871   # Exit status is that of the last command.
12872   exit
12873 }
12874
12875
12876 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12877   *c*,-n*) ECHO_N= ECHO_C='
12878 ' ECHO_T='      ' ;;
12879   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12880   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12881 esac
12882
12883 if expr a : '\(a\)' >/dev/null 2>&1; then
12884   as_expr=expr
12885 else
12886   as_expr=false
12887 fi
12888
12889 rm -f conf$$ conf$$.exe conf$$.file
12890 echo >conf$$.file
12891 if ln -s conf$$.file conf$$ 2>/dev/null; then
12892   # We could just check for DJGPP; but this test a) works b) is more generic
12893   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12894   if test -f conf$$.exe; then
12895     # Don't use ln at all; we don't have any links
12896     as_ln_s='cp -p'
12897   else
12898     as_ln_s='ln -s'
12899   fi
12900 elif ln conf$$.file conf$$ 2>/dev/null; then
12901   as_ln_s=ln
12902 else
12903   as_ln_s='cp -p'
12904 fi
12905 rm -f conf$$ conf$$.exe conf$$.file
12906
12907 if mkdir -p . 2>/dev/null; then
12908   as_mkdir_p=:
12909 else
12910   test -d ./-p && rmdir ./-p
12911   as_mkdir_p=false
12912 fi
12913
12914 as_executable_p="test -f"
12915
12916 # Sed expression to map a string onto a valid CPP name.
12917 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12918
12919 # Sed expression to map a string onto a valid variable name.
12920 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12921
12922
12923 # IFS
12924 # We need space, tab and new line, in precisely that order.
12925 as_nl='
12926 '
12927 IFS="   $as_nl"
12928
12929 # CDPATH.
12930 $as_unset CDPATH
12931
12932 exec 6>&1
12933
12934 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12935 # report actual input values of CONFIG_FILES etc. instead of their
12936 # values after options handling.  Logging --version etc. is OK.
12937 exec 5>>config.log
12938 {
12939   echo
12940   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12941 ## Running $as_me. ##
12942 _ASBOX
12943 } >&5
12944 cat >&5 <<_CSEOF
12945
12946 This file was extended by $as_me, which was
12947 generated by GNU Autoconf 2.59.  Invocation command line was
12948
12949   CONFIG_FILES    = $CONFIG_FILES
12950   CONFIG_HEADERS  = $CONFIG_HEADERS
12951   CONFIG_LINKS    = $CONFIG_LINKS
12952   CONFIG_COMMANDS = $CONFIG_COMMANDS
12953   $ $0 $@
12954
12955 _CSEOF
12956 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12957 echo >&5
12958 _ACEOF
12959
12960 # Files that config.status was made for.
12961 if test -n "$ac_config_files"; then
12962   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12963 fi
12964
12965 if test -n "$ac_config_headers"; then
12966   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12967 fi
12968
12969 if test -n "$ac_config_links"; then
12970   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12971 fi
12972
12973 if test -n "$ac_config_commands"; then
12974   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12975 fi
12976
12977 cat >>$CONFIG_STATUS <<\_ACEOF
12978
12979 ac_cs_usage="\
12980 \`$as_me' instantiates files from templates according to the
12981 current configuration.
12982
12983 Usage: $0 [OPTIONS] [FILE]...
12984
12985   -h, --help       print this help, then exit
12986   -V, --version    print version number, then exit
12987   -q, --quiet      do not print progress messages
12988   -d, --debug      don't remove temporary files
12989       --recheck    update $as_me by reconfiguring in the same conditions
12990   --file=FILE[:TEMPLATE]
12991                    instantiate the configuration file FILE
12992
12993 Configuration files:
12994 $config_files
12995
12996 Report bugs to <bug-autoconf@gnu.org>."
12997 _ACEOF
12998
12999 cat >>$CONFIG_STATUS <<_ACEOF
13000 ac_cs_version="\\
13001 config.status
13002 configured by $0, generated by GNU Autoconf 2.59,
13003   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13004
13005 Copyright (C) 2003 Free Software Foundation, Inc.
13006 This config.status script is free software; the Free Software Foundation
13007 gives unlimited permission to copy, distribute and modify it."
13008 srcdir=$srcdir
13009 INSTALL="$INSTALL"
13010 _ACEOF
13011
13012 cat >>$CONFIG_STATUS <<\_ACEOF
13013 # If no file are specified by the user, then we need to provide default
13014 # value.  By we need to know if files were specified by the user.
13015 ac_need_defaults=:
13016 while test $# != 0
13017 do
13018   case $1 in
13019   --*=*)
13020     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13021     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13022     ac_shift=:
13023     ;;
13024   -*)
13025     ac_option=$1
13026     ac_optarg=$2
13027     ac_shift=shift
13028     ;;
13029   *) # This is not an option, so the user has probably given explicit
13030      # arguments.
13031      ac_option=$1
13032      ac_need_defaults=false;;
13033   esac
13034
13035   case $ac_option in
13036   # Handling of the options.
13037 _ACEOF
13038 cat >>$CONFIG_STATUS <<\_ACEOF
13039   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13040     ac_cs_recheck=: ;;
13041   --version | --vers* | -V )
13042     echo "$ac_cs_version"; exit 0 ;;
13043   --he | --h)
13044     # Conflict between --help and --header
13045     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13046 Try \`$0 --help' for more information." >&5
13047 echo "$as_me: error: ambiguous option: $1
13048 Try \`$0 --help' for more information." >&2;}
13049    { (exit 1); exit 1; }; };;
13050   --help | --hel | -h )
13051     echo "$ac_cs_usage"; exit 0 ;;
13052   --debug | --d* | -d )
13053     debug=: ;;
13054   --file | --fil | --fi | --f )
13055     $ac_shift
13056     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13057     ac_need_defaults=false;;
13058   --header | --heade | --head | --hea )
13059     $ac_shift
13060     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13061     ac_need_defaults=false;;
13062   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13063   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13064     ac_cs_silent=: ;;
13065
13066   # This is an error.
13067   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13068 Try \`$0 --help' for more information." >&5
13069 echo "$as_me: error: unrecognized option: $1
13070 Try \`$0 --help' for more information." >&2;}
13071    { (exit 1); exit 1; }; } ;;
13072
13073   *) ac_config_targets="$ac_config_targets $1" ;;
13074
13075   esac
13076   shift
13077 done
13078
13079 ac_configure_extra_args=
13080
13081 if $ac_cs_silent; then
13082   exec 6>/dev/null
13083   ac_configure_extra_args="$ac_configure_extra_args --silent"
13084 fi
13085
13086 _ACEOF
13087 cat >>$CONFIG_STATUS <<_ACEOF
13088 if \$ac_cs_recheck; then
13089   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13090   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13091 fi
13092
13093 _ACEOF
13094
13095
13096
13097
13098
13099 cat >>$CONFIG_STATUS <<\_ACEOF
13100 for ac_config_target in $ac_config_targets
13101 do
13102   case "$ac_config_target" in
13103   # Handling of arguments.
13104   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13105   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13106 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13107    { (exit 1); exit 1; }; };;
13108   esac
13109 done
13110
13111 # If the user did not use the arguments to specify the items to instantiate,
13112 # then the envvar interface is used.  Set only those that are not.
13113 # We use the long form for the default assignment because of an extremely
13114 # bizarre bug on SunOS 4.1.3.
13115 if $ac_need_defaults; then
13116   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13117 fi
13118
13119 # Have a temporary directory for convenience.  Make it in the build tree
13120 # simply because there is no reason to put it here, and in addition,
13121 # creating and moving files from /tmp can sometimes cause problems.
13122 # Create a temporary directory, and hook for its removal unless debugging.
13123 $debug ||
13124 {
13125   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13126   trap '{ (exit 1); exit 1; }' 1 2 13 15
13127 }
13128
13129 # Create a (secure) tmp directory for tmp files.
13130
13131 {
13132   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13133   test -n "$tmp" && test -d "$tmp"
13134 }  ||
13135 {
13136   tmp=./confstat$$-$RANDOM
13137   (umask 077 && mkdir $tmp)
13138 } ||
13139 {
13140    echo "$me: cannot create a temporary directory in ." >&2
13141    { (exit 1); exit 1; }
13142 }
13143
13144 _ACEOF
13145
13146 cat >>$CONFIG_STATUS <<_ACEOF
13147
13148 #
13149 # CONFIG_FILES section.
13150 #
13151
13152 # No need to generate the scripts if there are no CONFIG_FILES.
13153 # This happens for instance when ./config.status config.h
13154 if test -n "\$CONFIG_FILES"; then
13155   # Protect against being on the right side of a sed subst in config.status.
13156   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13157    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13158 s,@SHELL@,$SHELL,;t t
13159 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13160 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13161 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13162 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13163 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13164 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13165 s,@exec_prefix@,$exec_prefix,;t t
13166 s,@prefix@,$prefix,;t t
13167 s,@program_transform_name@,$program_transform_name,;t t
13168 s,@bindir@,$bindir,;t t
13169 s,@sbindir@,$sbindir,;t t
13170 s,@libexecdir@,$libexecdir,;t t
13171 s,@datadir@,$datadir,;t t
13172 s,@sysconfdir@,$sysconfdir,;t t
13173 s,@sharedstatedir@,$sharedstatedir,;t t
13174 s,@localstatedir@,$localstatedir,;t t
13175 s,@libdir@,$libdir,;t t
13176 s,@includedir@,$includedir,;t t
13177 s,@oldincludedir@,$oldincludedir,;t t
13178 s,@infodir@,$infodir,;t t
13179 s,@mandir@,$mandir,;t t
13180 s,@build_alias@,$build_alias,;t t
13181 s,@host_alias@,$host_alias,;t t
13182 s,@target_alias@,$target_alias,;t t
13183 s,@DEFS@,$DEFS,;t t
13184 s,@ECHO_C@,$ECHO_C,;t t
13185 s,@ECHO_N@,$ECHO_N,;t t
13186 s,@ECHO_T@,$ECHO_T,;t t
13187 s,@LIBS@,$LIBS,;t t
13188 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13189 s,@build@,$build,;t t
13190 s,@build_cpu@,$build_cpu,;t t
13191 s,@build_vendor@,$build_vendor,;t t
13192 s,@build_os@,$build_os,;t t
13193 s,@build_noncanonical@,$build_noncanonical,;t t
13194 s,@host_noncanonical@,$host_noncanonical,;t t
13195 s,@target_noncanonical@,$target_noncanonical,;t t
13196 s,@host@,$host,;t t
13197 s,@host_cpu@,$host_cpu,;t t
13198 s,@host_vendor@,$host_vendor,;t t
13199 s,@host_os@,$host_os,;t t
13200 s,@target@,$target,;t t
13201 s,@target_cpu@,$target_cpu,;t t
13202 s,@target_vendor@,$target_vendor,;t t
13203 s,@target_os@,$target_os,;t t
13204 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13205 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13206 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13207 s,@LN@,$LN,;t t
13208 s,@LN_S@,$LN_S,;t t
13209 s,@build_libsubdir@,$build_libsubdir,;t t
13210 s,@build_subdir@,$build_subdir,;t t
13211 s,@host_subdir@,$host_subdir,;t t
13212 s,@target_subdir@,$target_subdir,;t t
13213 s,@CC@,$CC,;t t
13214 s,@CFLAGS@,$CFLAGS,;t t
13215 s,@LDFLAGS@,$LDFLAGS,;t t
13216 s,@CPPFLAGS@,$CPPFLAGS,;t t
13217 s,@ac_ct_CC@,$ac_ct_CC,;t t
13218 s,@EXEEXT@,$EXEEXT,;t t
13219 s,@OBJEXT@,$OBJEXT,;t t
13220 s,@CXX@,$CXX,;t t
13221 s,@CXXFLAGS@,$CXXFLAGS,;t t
13222 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13223 s,@GNATBIND@,$GNATBIND,;t t
13224 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13225 s,@GNATMAKE@,$GNATMAKE,;t t
13226 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13227 s,@do_compare@,$do_compare,;t t
13228 s,@gmplibs@,$gmplibs,;t t
13229 s,@gmpinc@,$gmpinc,;t t
13230 s,@ppllibs@,$ppllibs,;t t
13231 s,@pplinc@,$pplinc,;t t
13232 s,@clooglibs@,$clooglibs,;t t
13233 s,@clooginc@,$clooginc,;t t
13234 s,@stage1_languages@,$stage1_languages,;t t
13235 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13236 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13237 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13238 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13239 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13240 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13241 s,@tooldir@,$tooldir,;t t
13242 s,@build_tooldir@,$build_tooldir,;t t
13243 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13244 s,@GDB_TK@,$GDB_TK,;t t
13245 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13246 s,@build_configargs@,$build_configargs,;t t
13247 s,@build_configdirs@,$build_configdirs,;t t
13248 s,@host_configargs@,$host_configargs,;t t
13249 s,@configdirs@,$configdirs,;t t
13250 s,@target_configargs@,$target_configargs,;t t
13251 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13252 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13253 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13254 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13255 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13256 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13257 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13258 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13259 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13260 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13261 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13262 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13263 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13264 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13265 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13266 s,@config_shell@,$config_shell,;t t
13267 s,@YACC@,$YACC,;t t
13268 s,@BISON@,$BISON,;t t
13269 s,@M4@,$M4,;t t
13270 s,@LEX@,$LEX,;t t
13271 s,@FLEX@,$FLEX,;t t
13272 s,@MAKEINFO@,$MAKEINFO,;t t
13273 s,@EXPECT@,$EXPECT,;t t
13274 s,@RUNTEST@,$RUNTEST,;t t
13275 s,@AR@,$AR,;t t
13276 s,@AS@,$AS,;t t
13277 s,@DLLTOOL@,$DLLTOOL,;t t
13278 s,@LD@,$LD,;t t
13279 s,@LIPO@,$LIPO,;t t
13280 s,@NM@,$NM,;t t
13281 s,@RANLIB@,$RANLIB,;t t
13282 s,@STRIP@,$STRIP,;t t
13283 s,@WINDRES@,$WINDRES,;t t
13284 s,@WINDMC@,$WINDMC,;t t
13285 s,@OBJCOPY@,$OBJCOPY,;t t
13286 s,@OBJDUMP@,$OBJDUMP,;t t
13287 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13288 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13289 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13290 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13291 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13292 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13293 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13294 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13295 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13296 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13297 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13298 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13299 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13300 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13301 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13302 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13303 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13304 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13305 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13306 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13307 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13308 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13309 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13310 s,@MAINT@,$MAINT,;t t
13311 s,@stage1_cflags@,$stage1_cflags,;t t
13312 s,@stage1_checking@,$stage1_checking,;t t
13313 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13314 s,@datarootdir@,$datarootdir,;t t
13315 s,@docdir@,$docdir,;t t
13316 s,@pdfdir@,$pdfdir,;t t
13317 s,@htmldir@,$htmldir,;t t
13318 s,@LIBOBJS@,$LIBOBJS,;t t
13319 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13320 /@serialization_dependencies@/r $serialization_dependencies
13321 s,@serialization_dependencies@,,;t t
13322 /@host_makefile_frag@/r $host_makefile_frag
13323 s,@host_makefile_frag@,,;t t
13324 /@target_makefile_frag@/r $target_makefile_frag
13325 s,@target_makefile_frag@,,;t t
13326 /@alphaieee_frag@/r $alphaieee_frag
13327 s,@alphaieee_frag@,,;t t
13328 /@ospace_frag@/r $ospace_frag
13329 s,@ospace_frag@,,;t t
13330 CEOF
13331
13332 _ACEOF
13333
13334   cat >>$CONFIG_STATUS <<\_ACEOF
13335   # Split the substitutions into bite-sized pieces for seds with
13336   # small command number limits, like on Digital OSF/1 and HP-UX.
13337   ac_max_sed_lines=48
13338   ac_sed_frag=1 # Number of current file.
13339   ac_beg=1 # First line for current file.
13340   ac_end=$ac_max_sed_lines # Line after last line for current file.
13341   ac_more_lines=:
13342   ac_sed_cmds=
13343   while $ac_more_lines; do
13344     if test $ac_beg -gt 1; then
13345       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13346     else
13347       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13348     fi
13349     if test ! -s $tmp/subs.frag; then
13350       ac_more_lines=false
13351     else
13352       # The purpose of the label and of the branching condition is to
13353       # speed up the sed processing (if there are no `@' at all, there
13354       # is no need to browse any of the substitutions).
13355       # These are the two extra sed commands mentioned above.
13356       (echo ':t
13357   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13358       if test -z "$ac_sed_cmds"; then
13359         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13360       else
13361         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13362       fi
13363       ac_sed_frag=`expr $ac_sed_frag + 1`
13364       ac_beg=$ac_end
13365       ac_end=`expr $ac_end + $ac_max_sed_lines`
13366     fi
13367   done
13368   if test -z "$ac_sed_cmds"; then
13369     ac_sed_cmds=cat
13370   fi
13371 fi # test -n "$CONFIG_FILES"
13372
13373 _ACEOF
13374 cat >>$CONFIG_STATUS <<\_ACEOF
13375 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13376   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13377   case $ac_file in
13378   - | *:- | *:-:* ) # input from stdin
13379         cat >$tmp/stdin
13380         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13381         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13382   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13383         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13384   * )   ac_file_in=$ac_file.in ;;
13385   esac
13386
13387   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13388   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13389 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13390          X"$ac_file" : 'X\(//\)[^/]' \| \
13391          X"$ac_file" : 'X\(//\)$' \| \
13392          X"$ac_file" : 'X\(/\)' \| \
13393          .     : '\(.\)' 2>/dev/null ||
13394 echo X"$ac_file" |
13395     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13396           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13397           /^X\(\/\/\)$/{ s//\1/; q; }
13398           /^X\(\/\).*/{ s//\1/; q; }
13399           s/.*/./; q'`
13400   { if $as_mkdir_p; then
13401     mkdir -p "$ac_dir"
13402   else
13403     as_dir="$ac_dir"
13404     as_dirs=
13405     while test ! -d "$as_dir"; do
13406       as_dirs="$as_dir $as_dirs"
13407       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13408 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13409          X"$as_dir" : 'X\(//\)[^/]' \| \
13410          X"$as_dir" : 'X\(//\)$' \| \
13411          X"$as_dir" : 'X\(/\)' \| \
13412          .     : '\(.\)' 2>/dev/null ||
13413 echo X"$as_dir" |
13414     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13415           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13416           /^X\(\/\/\)$/{ s//\1/; q; }
13417           /^X\(\/\).*/{ s//\1/; q; }
13418           s/.*/./; q'`
13419     done
13420     test ! -n "$as_dirs" || mkdir $as_dirs
13421   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13422 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13423    { (exit 1); exit 1; }; }; }
13424
13425   ac_builddir=.
13426
13427 if test "$ac_dir" != .; then
13428   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13429   # A "../" for each directory in $ac_dir_suffix.
13430   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13431 else
13432   ac_dir_suffix= ac_top_builddir=
13433 fi
13434
13435 case $srcdir in
13436   .)  # No --srcdir option.  We are building in place.
13437     ac_srcdir=.
13438     if test -z "$ac_top_builddir"; then
13439        ac_top_srcdir=.
13440     else
13441        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13442     fi ;;
13443   [\\/]* | ?:[\\/]* )  # Absolute path.
13444     ac_srcdir=$srcdir$ac_dir_suffix;
13445     ac_top_srcdir=$srcdir ;;
13446   *) # Relative path.
13447     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13448     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13449 esac
13450
13451 # Do not use `cd foo && pwd` to compute absolute paths, because
13452 # the directories may not exist.
13453 case `pwd` in
13454 .) ac_abs_builddir="$ac_dir";;
13455 *)
13456   case "$ac_dir" in
13457   .) ac_abs_builddir=`pwd`;;
13458   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13459   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13460   esac;;
13461 esac
13462 case $ac_abs_builddir in
13463 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13464 *)
13465   case ${ac_top_builddir}. in
13466   .) ac_abs_top_builddir=$ac_abs_builddir;;
13467   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13468   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13469   esac;;
13470 esac
13471 case $ac_abs_builddir in
13472 .) ac_abs_srcdir=$ac_srcdir;;
13473 *)
13474   case $ac_srcdir in
13475   .) ac_abs_srcdir=$ac_abs_builddir;;
13476   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13477   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13478   esac;;
13479 esac
13480 case $ac_abs_builddir in
13481 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13482 *)
13483   case $ac_top_srcdir in
13484   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13485   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13486   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13487   esac;;
13488 esac
13489
13490
13491   case $INSTALL in
13492   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13493   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13494   esac
13495
13496   if test x"$ac_file" != x-; then
13497     { echo "$as_me:$LINENO: creating $ac_file" >&5
13498 echo "$as_me: creating $ac_file" >&6;}
13499     rm -f "$ac_file"
13500   fi
13501   # Let's still pretend it is `configure' which instantiates (i.e., don't
13502   # use $as_me), people would be surprised to read:
13503   #    /* config.h.  Generated by config.status.  */
13504   if test x"$ac_file" = x-; then
13505     configure_input=
13506   else
13507     configure_input="$ac_file.  "
13508   fi
13509   configure_input=$configure_input"Generated from `echo $ac_file_in |
13510                                      sed 's,.*/,,'` by configure."
13511
13512   # First look for the input files in the build tree, otherwise in the
13513   # src tree.
13514   ac_file_inputs=`IFS=:
13515     for f in $ac_file_in; do
13516       case $f in
13517       -) echo $tmp/stdin ;;
13518       [\\/$]*)
13519          # Absolute (can't be DOS-style, as IFS=:)
13520          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13521 echo "$as_me: error: cannot find input file: $f" >&2;}
13522    { (exit 1); exit 1; }; }
13523          echo "$f";;
13524       *) # Relative
13525          if test -f "$f"; then
13526            # Build tree
13527            echo "$f"
13528          elif test -f "$srcdir/$f"; then
13529            # Source tree
13530            echo "$srcdir/$f"
13531          else
13532            # /dev/null tree
13533            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13534 echo "$as_me: error: cannot find input file: $f" >&2;}
13535    { (exit 1); exit 1; }; }
13536          fi;;
13537       esac
13538     done` || { (exit 1); exit 1; }
13539 _ACEOF
13540 cat >>$CONFIG_STATUS <<_ACEOF
13541   sed "$ac_vpsub
13542 $extrasub
13543 _ACEOF
13544 cat >>$CONFIG_STATUS <<\_ACEOF
13545 :t
13546 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13547 s,@configure_input@,$configure_input,;t t
13548 s,@srcdir@,$ac_srcdir,;t t
13549 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13550 s,@top_srcdir@,$ac_top_srcdir,;t t
13551 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13552 s,@builddir@,$ac_builddir,;t t
13553 s,@abs_builddir@,$ac_abs_builddir,;t t
13554 s,@top_builddir@,$ac_top_builddir,;t t
13555 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13556 s,@INSTALL@,$ac_INSTALL,;t t
13557 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13558   rm -f $tmp/stdin
13559   if test x"$ac_file" != x-; then
13560     mv $tmp/out $ac_file
13561   else
13562     cat $tmp/out
13563     rm -f $tmp/out
13564   fi
13565
13566 done
13567 _ACEOF
13568
13569 cat >>$CONFIG_STATUS <<\_ACEOF
13570
13571 { (exit 0); exit 0; }
13572 _ACEOF
13573 chmod +x $CONFIG_STATUS
13574 ac_clean_files=$ac_clean_files_save
13575
13576
13577 # configure is writing to config.log, and then calls config.status.
13578 # config.status does its own redirection, appending to config.log.
13579 # Unfortunately, on DOS this fails, as config.log is still kept open
13580 # by configure, so config.status won't be able to write to it; its
13581 # output is simply discarded.  So we exec the FD to /dev/null,
13582 # effectively closing config.log, so it can be properly (re)opened and
13583 # appended to by config.status.  When coming back to configure, we
13584 # need to make the FD available again.
13585 if test "$no_create" != yes; then
13586   ac_cs_success=:
13587   ac_config_status_args=
13588   test "$silent" = yes &&
13589     ac_config_status_args="$ac_config_status_args --quiet"
13590   exec 5>/dev/null
13591   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13592   exec 5>>config.log
13593   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13594   # would make configure fail if this is the last instruction.
13595   $ac_cs_success || { (exit 1); exit 1; }
13596 fi
13597