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* | x86_64-*-darwin[912]*)
2214     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2215     noconfigdirs="$noconfigdirs sim target-rda"
2216     ;;
2217   i[3456789]86-*-darwin*)
2218     noconfigdirs="$noconfigdirs ld gas gprof"
2219     noconfigdirs="$noconfigdirs sim target-rda"
2220     ;;
2221   *-*-darwin*)
2222     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2223     noconfigdirs="$noconfigdirs sim target-rda"
2224     noconfigdirs="$noconfigdirs ${libgcj}"
2225     ;;
2226   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2227     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2228     ;;
2229   *-*-freebsd*)
2230     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2231     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2232         && test -f /usr/local/include/gmp.h; then
2233       with_gmp=/usr/local
2234     fi
2235
2236     # Skip some stuff that's unsupported on some FreeBSD configurations.
2237     case "${target}" in
2238       i*86-*-*) ;;
2239       alpha*-*-*) ;;
2240       *)
2241         noconfigdirs="$noconfigdirs ${libgcj}"
2242         ;;
2243     esac
2244     ;;
2245   *-*-kaos*)
2246     # Remove unsupported stuff on all kaOS configurations.
2247     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2248     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2249     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2250     noconfigdirs="$noconfigdirs target-libgloss"
2251     ;;
2252   *-*-netbsd*)
2253     # Skip some stuff on all NetBSD configurations.
2254     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2255
2256     # Skip some stuff that's unsupported on some NetBSD configurations.
2257     case "${target}" in
2258       i*86-*-netbsdelf*) ;;
2259       arm*-*-netbsdelf*) ;;
2260       *)
2261         noconfigdirs="$noconfigdirs ${libgcj}"
2262         ;;
2263     esac
2264     ;;
2265   *-*-netware*)
2266     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2267     ;;
2268   *-*-rtems*)
2269     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2270     ;;
2271     # The tpf target doesn't support gdb yet.
2272   *-*-tpf*)
2273     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2274     ;;
2275   *-*-uclinux*)
2276     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2277     ;;
2278   *-*-vxworks*)
2279     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2280     ;;
2281   alpha*-dec-osf*)
2282     # ld works, but does not support shared libraries.
2283     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2284     # gas doesn't generate exception information.
2285     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2286     ;;
2287   alpha*-*-*vms*)
2288     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2289     ;;
2290   alpha*-*-linux*)
2291     # newlib is not 64 bit ready
2292     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2293     ;;
2294   alpha*-*-*)
2295     # newlib is not 64 bit ready
2296     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2297     ;;
2298   am33_2.0-*-linux*)
2299     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2300     ;;
2301   sh-*-linux*)
2302     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2303     ;;
2304   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2305     noconfigdirs="$noconfigdirs ${libgcj}"
2306     noconfigdirs="$noconfigdirs target-examples"
2307     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2308     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2309     noconfigdirs="$noconfigdirs expect dejagnu"
2310     # the C++ libraries don't build on top of CE's C libraries
2311     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2312     noconfigdirs="$noconfigdirs target-newlib"
2313     case "${host}" in
2314       *-*-cygwin*) ;; # keep gdb and readline
2315       *) noconfigdirs="$noconfigdirs gdb readline"
2316          ;;
2317     esac
2318     libgloss_dir=wince
2319     ;;
2320   arc-*-*)
2321     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2322     ;;
2323   arm-semi-aof )
2324     ;;
2325   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2326     noconfigdirs="$noconfigdirs ${libgcj}"
2327     libgloss_dir=arm
2328     ;;
2329   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2330     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2331     libgloss_dir=arm
2332     ;;
2333   arm*-*-linux-gnueabi)
2334     noconfigdirs="$noconfigdirs target-qthreads"
2335     case ${with_newlib} in
2336       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2337     esac
2338     libgloss_dir=arm
2339     ;;
2340   arm*-*-symbianelf*)
2341     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2342     libgloss_dir=arm
2343     ;;
2344   arm-*-pe*)
2345     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2346     ;;
2347   thumb-*-coff)
2348     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2349     ;;
2350   thumb-*-elf)
2351     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2352     ;;
2353   thumb-*-pe)
2354     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2355     ;;
2356   arm-*-riscix*)
2357     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2358     ;;
2359   avr-*-*)
2360     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2361     ;;
2362   bfin-*-*)
2363     noconfigdirs="$noconfigdirs gdb"
2364     if test x${is_cross_compiler} != xno ; then
2365       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2366     fi
2367     ;;
2368   c4x-*-* | tic4x-*-*)
2369     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2370     ;;
2371   c54x*-*-* | tic54x-*-*)
2372     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2373     ;;
2374   cr16-*-*)
2375     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2376     ;;
2377   cris-*-* | crisv32-*-*)
2378     unsupported_languages="$unsupported_languages java"
2379     case "${target}" in
2380       *-*-aout)
2381         unsupported_languages="$unsupported_languages fortran"
2382         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2383       *-*-elf)
2384         noconfigdirs="$noconfigdirs target-boehm-gc";;
2385       *-*-linux*)
2386         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2387       *)
2388         unsupported_languages="$unsupported_languages fortran"
2389         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2390     esac
2391     libgloss_dir=cris
2392     ;;
2393   crx-*-*)
2394     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2395     ;;
2396   d10v-*-*)
2397     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2398     ;;
2399   d30v-*-*)
2400     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2401     ;;
2402   ep9312-*-elf | ep9312-*-coff)
2403     libgloss_dir=arm
2404     ;;
2405   fr30-*-elf*)
2406     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2407     ;;
2408   frv-*-*)
2409     noconfigdirs="$noconfigdirs ${libgcj}"
2410     ;;
2411   h8300*-*-*)
2412     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2413     ;;
2414   h8500-*-*)
2415     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2416     ;;
2417   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2418     ;;
2419   hppa*64*-*-linux* | parisc*64*-*-linux*)
2420     # In this case, it's because the hppa64-linux target is for
2421     # the kernel only at this point and has no libc, and thus no
2422     # headers, crt*.o, etc., all of which are needed by these.
2423     noconfigdirs="$noconfigdirs target-zlib"
2424     ;;
2425   parisc*-*-linux* | hppa*-*-linux*)
2426     ;;
2427   hppa*-*-*elf* | \
2428   hppa*-*-lites* | \
2429   hppa*-*-openbsd* | \
2430   hppa*64*-*-*)
2431     noconfigdirs="$noconfigdirs ${libgcj}"
2432     ;;
2433   hppa*-hp-hpux11*)
2434     noconfigdirs="$noconfigdirs ld shellutils"
2435     ;;
2436   hppa*-*-pro*)
2437     libgloss_dir=pa
2438     ;;
2439   hppa*-*-*)
2440     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2441     # build on HP-UX 10.20.
2442     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2443     ;;
2444   i960-*-*)
2445     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2446     ;;
2447   ia64*-*-elf*)
2448     # No gdb support yet.
2449     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2450     ;;
2451   ia64*-**-hpux*)
2452     # No gdb or ld support yet.
2453     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2454     ;;
2455   i370-*-opened*)
2456     ;;
2457   i[3456789]86-*-coff | i[3456789]86-*-elf)
2458     noconfigdirs="$noconfigdirs ${libgcj}"
2459     libgloss_dir=i386
2460     ;;
2461   i[3456789]86-*-linux*)
2462     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2463     # not build java stuff by default.
2464     case "${target}" in
2465       *-*-*libc1*)
2466         noconfigdirs="$noconfigdirs ${libgcj}";;
2467     esac
2468
2469     # This section makes it possible to build newlib natively on linux.
2470     # If we are using a cross compiler then don't configure newlib.
2471     if test x${is_cross_compiler} != xno ; then
2472       noconfigdirs="$noconfigdirs target-newlib"
2473     fi
2474     noconfigdirs="$noconfigdirs target-libgloss"
2475     # If we are not using a cross compiler, do configure newlib.
2476     # Note however, that newlib will only be configured in this situation
2477     # if the --with-newlib option has been given, because otherwise
2478     # 'target-newlib' will appear in skipdirs.
2479     ;;
2480   i[3456789]86-*-mingw32*)
2481     target_configdirs="$target_configdirs target-winsup"
2482     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2483     ;;
2484   x86_64-*-mingw*)
2485     target_configdirs="$target_configdirs target-winsup"
2486     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2487     ;;
2488   *-*-cygwin*)
2489     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2490     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2491     # always build newlib if winsup directory is present.
2492     if test -d "$srcdir/winsup/cygwin"; then
2493       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2494     elif test -d "$srcdir/newlib"; then
2495       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2496     fi
2497     ;;
2498   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2499   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2500     ;;
2501   i[3456789]86-*-pe)
2502     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2503     ;;
2504   i[3456789]86-*-sco3.2v5*)
2505     # The linker does not yet know about weak symbols in COFF,
2506     # and is not configured to handle mixed ELF and COFF.
2507     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2508     ;;
2509   i[3456789]86-*-sco*)
2510     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2511     ;;
2512   i[3456789]86-*-solaris2*)
2513     noconfigdirs="$noconfigdirs target-libgloss"
2514     ;;
2515   i[3456789]86-*-sysv4*)
2516     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2517     ;;
2518   i[3456789]86-*-beos*)
2519     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2520     ;;
2521   i[3456789]86-*-rdos*)
2522     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2523     ;;
2524   m32r-*-*)
2525     noconfigdirs="$noconfigdirs ${libgcj}"
2526     ;;
2527   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2528     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2529     libgloss_dir=m68hc11
2530     ;;
2531   m68k-*-elf*)
2532     noconfigdirs="$noconfigdirs ${libgcj}"
2533     ;;
2534   m68k-*-coff*)
2535     noconfigdirs="$noconfigdirs ${libgcj}"
2536     ;;
2537   m68*-*-* | fido-*-*)
2538     libgloss_dir=m68k
2539     ;;
2540   mcore-*-pe*)
2541   # The EPOC C++ environment does not support exceptions or rtti,
2542   # and so building libstdc++-v3 tends not to always work.
2543     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2544     ;;
2545   mmix-*-*)
2546     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2547     unsupported_languages="$unsupported_languages fortran java"
2548     ;;
2549   mn10200-*-*)
2550     noconfigdirs="$noconfigdirs ${libgcj}"
2551     ;;
2552   mn10300-*-*)
2553     noconfigdirs="$noconfigdirs ${libgcj}"
2554     ;;
2555   mt-*-*)
2556     noconfigdirs="$noconfigdirs sim"
2557     ;;
2558   powerpc-*-aix*)
2559     # copied from rs6000-*-* entry
2560     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2561     ;;
2562   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2563     target_configdirs="$target_configdirs target-winsup"
2564     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2565     # always build newlib.
2566     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2567     ;;
2568     # This is temporary until we can link against shared libraries
2569   powerpcle-*-solaris*)
2570     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2571     libgloss_dir=rs6000
2572     ;;
2573   powerpc-*-beos*)
2574     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2575     ;;
2576   powerpc-*-eabi)
2577     noconfigdirs="$noconfigdirs ${libgcj}"
2578     libgloss_dir=rs6000
2579     ;;
2580   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2581     libgloss_dir=rs6000
2582     ;;
2583   rs6000-*-lynxos*)
2584     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2585     ;;
2586   rs6000-*-aix*)
2587     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2588     ;;
2589   rs6000-*-*)
2590     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2591     ;;
2592   m68k-apollo-*)
2593     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2594     ;;
2595   mips*-sde-elf*)
2596     skipdirs="$skipdirs target-libiberty"
2597     noconfigdirs="$noconfigdirs ${libgcj}"
2598     if test x$with_newlib = xyes; then
2599       noconfigdirs="$noconfigdirs gprof"
2600     fi
2601     libgloss_dir=mips
2602     ;;
2603   mips*-*-irix5*)
2604     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2605     ;;
2606   mips*-*-irix6*)
2607     # Linking libjava exceeds command-line length limits on at least
2608     # IRIX 6.2, but not on IRIX 6.5.
2609     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2610     # <oldham@codesourcery.com>
2611     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2612     ;;
2613   mips*-*-bsd*)
2614     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2615     ;;
2616   mips*-*-linux*)
2617     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2618     ;;
2619   mips*-*-*)
2620     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2621     libgloss_dir=mips
2622     ;;
2623   romp-*-*)
2624     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2625     ;;
2626   sh-*-* | sh64-*-*)
2627     case "${host}" in
2628       i[3456789]86-*-vsta) ;; # don't add gprof back in
2629       i[3456789]86-*-go32*) ;; # don't add gprof back in
2630       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2631       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2632     esac
2633     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2634     ;;
2635   sparclet-*-aout* | sparc86x-*-*)
2636     libgloss_dir=sparc
2637     ;;
2638   sparc-*-elf*)
2639     noconfigdirs="$noconfigdirs ${libgcj}"
2640     ;;
2641   sparc64-*-elf*)
2642     noconfigdirs="$noconfigdirs ${libgcj}"
2643     libgloss_dir=sparc
2644     ;;
2645   sparclite-*-*)
2646     noconfigdirs="$noconfigdirs ${libgcj}"
2647     libgloss_dir=sparc
2648     ;;
2649   sparc-*-sunos4*)
2650     noconfigdirs="$noconfigdirs ${libgcj}"
2651     if test x${is_cross_compiler} != xno ; then
2652            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2653     else
2654            use_gnu_ld=no
2655     fi
2656     ;;
2657   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2658     noconfigdirs="$noconfigdirs ${libgcj}"
2659     ;;
2660   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2661     ;;
2662   v810-*-*)
2663     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2664     ;;
2665   v850-*-*)
2666     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2667     ;;
2668   v850e-*-*)
2669     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2670     ;;
2671   v850ea-*-*)
2672     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2673     ;;
2674   vax-*-vms)
2675     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2676     ;;
2677   vax-*-*)
2678     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2679     ;;
2680   xtensa*-*-*)
2681     noconfigdirs="$noconfigdirs ${libgcj}"
2682     ;;
2683   ip2k-*-*)
2684     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2685     ;;
2686   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2687     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2688     ;;
2689   *-*-lynxos*)
2690     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2691     ;;
2692   *-*-*)
2693     noconfigdirs="$noconfigdirs ${libgcj}"
2694     ;;
2695 esac
2696
2697 # If we aren't building newlib, then don't build libgloss, since libgloss
2698 # depends upon some newlib header files.
2699 case "${noconfigdirs}" in
2700   *target-libgloss*) ;;
2701   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2702 esac
2703
2704 # Work in distributions that contain no compiler tools, like Autoconf.
2705 tentative_cc=""
2706 host_makefile_frag=/dev/null
2707 if test -d ${srcdir}/config ; then
2708 case "${host}" in
2709   m68k-hp-hpux*)
2710     # Avoid "too much defining" errors from HPUX compiler.
2711     tentative_cc="cc -Wp,-H256000"
2712     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2713     # If it's HP/UX ar, this should be harmless.
2714     RANLIB="ar ts"
2715     ;;
2716   m68k-apollo-sysv*)
2717     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2718     ;;
2719   m68k-apollo-bsd*)
2720     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2721     # chokes on bfd, the compiler won't let you assign integers to enums, and
2722     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2723     # the apollo compiler" (the preferred version of GCC could be called cc,
2724     # or whatever), but I'm not sure leaving CC as cc is any better...
2725     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2726     # Used to have BISON=yacc.
2727     tentative_cc=gcc
2728     ;;
2729   m88k-dg-dgux*)
2730     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2731     ;;
2732   m88k-harris-cxux*)
2733     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2734     tentative_cc="cc -Xa"
2735     host_makefile_frag="config/mh-cxux"
2736     ;;
2737   m88k-motorola-sysv*)
2738     ;;
2739   mips*-dec-ultrix*)
2740     tentative_cc="cc -Wf,-XNg1000"
2741     host_makefile_frag="config/mh-decstation"
2742     ;;
2743   mips*-nec-sysv4*)
2744     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2745     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2746     host_makefile_frag="config/mh-necv4"
2747     ;;
2748   mips*-sgi-irix4*)
2749     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2750     # environment.  Also bump switch table size so that cp-parse will
2751     # compile.  Bump string length limit so linker builds.
2752     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2753     ;;
2754   mips*-*-sysv4*)
2755     host_makefile_frag="config/mh-sysv4"
2756     ;;
2757   mips*-*-sysv*)
2758     # This is for a MIPS running RISC/os 4.52C.
2759
2760     # This is needed for GDB, but needs to be in the top-level make because
2761     # if a library is compiled with the bsd headers and gets linked with the
2762     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2763     # a different size).
2764     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2765     # known except to select the sysv environment.  Could we use /proc instead?
2766     # These "sysv environments" and "bsd environments" often end up being a pain.
2767     #
2768     # This is not part of CFLAGS because perhaps not all C compilers have this
2769     # option.
2770     tentative_cc="cc -systype sysv"
2771     ;;
2772   i370-ibm-opened*)
2773     tentative_cc="c89"
2774     ;;
2775   i[3456789]86-*-sysv5*)
2776     host_makefile_frag="config/mh-sysv5"
2777     ;;
2778   i[3456789]86-*-dgux*)
2779     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2780     host_makefile_frag="config/mh-dgux386"
2781     ;;
2782   i[3456789]86-ncr-sysv4.3*)
2783     # The MetaWare compiler will generate a copyright message unless you
2784     # turn it off by adding the -Hnocopyr flag.
2785     tentative_cc="cc -Hnocopyr"
2786     ;;
2787   i[3456789]86-ncr-sysv4*)
2788     # for an NCR 3000 (i486/SVR4) system.
2789     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2790     # This compiler not only emits obnoxious copyright messages every time
2791     # you run it, but it chokes and dies on a whole bunch of GNU source
2792     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2793     tentative_cc="/usr/ccs/ATT/cc"
2794     host_makefile_frag="config/mh-ncr3000"
2795     ;;
2796   i[3456789]86-*-sco3.2v5*)
2797     ;;
2798   i[3456789]86-*-sco*)
2799     # The native C compiler botches some simple uses of const.  Unfortunately,
2800     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2801     tentative_cc="cc -Dconst="
2802     host_makefile_frag="config/mh-sco"
2803     ;;
2804   i[3456789]86-*-udk*)
2805     host_makefile_frag="config/mh-sysv5"
2806     ;;
2807   i[3456789]86-*-solaris2*)
2808     host_makefile_frag="config/mh-sysv4"
2809     ;;
2810   i[3456789]86-*-msdosdjgpp*)
2811     host_makefile_frag="config/mh-djgpp"
2812     ;;
2813   *-cygwin*)
2814
2815 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2816 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2817 echo a >cygwin-cat-check
2818 if test `cat cygwin-cat-check` == a ; then
2819   rm cygwin-cat-check
2820   echo "$as_me:$LINENO: result: yes" >&5
2821 echo "${ECHO_T}yes" >&6
2822 else
2823   rm cygwin-cat-check
2824   echo "$as_me:$LINENO: result: no" >&5
2825 echo "${ECHO_T}no" >&6
2826   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2827   Please either mount the build directory in binary mode or run the following
2828   commands before running any configure script:
2829 set -o igncr
2830 export SHELLOPTS
2831   " >&5
2832 echo "$as_me: error: The cat command does not ignore carriage return characters.
2833   Please either mount the build directory in binary mode or run the following
2834   commands before running any configure script:
2835 set -o igncr
2836 export SHELLOPTS
2837   " >&2;}
2838    { (exit 1); exit 1; }; }
2839 fi
2840
2841     host_makefile_frag="config/mh-cygwin"
2842     ;;
2843   *-mingw*)
2844     host_makefile_frag="config/mh-mingw"
2845     ;;
2846   *-interix*)
2847     host_makefile_frag="config/mh-interix"
2848     ;;
2849   vax-*-ultrix2*)
2850     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2851     tentative_cc=gcc
2852     ;;
2853   *-*-solaris2*)
2854     host_makefile_frag="config/mh-solaris"
2855     ;;
2856   m68k-sun-sunos*)
2857     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2858     # without overflowing the jump tables (-J says to use a 32 bit table)
2859     tentative_cc="cc -J"
2860     ;;
2861   hppa*-hp-hpux10*)
2862     tentative_cc="cc -Wp,-H256000"
2863     host_makefile_frag="config/mh-pa-hpux10"
2864     ;;
2865   hppa*-hp-hpux* | hppa*-*-hiux*)
2866     tentative_cc="cc -Wp,-H256000"
2867     host_makefile_frag="config/mh-pa"
2868     ;;
2869   hppa*-*)
2870     host_makefile_frag="config/mh-pa"
2871     ;;
2872   *-hp-hpux* | *-*-hiux*)
2873     tentative_cc="cc -Wp,-H256000"
2874     ;;
2875   rs6000-*-lynxos*)
2876     # /bin/cc is less than useful for our purposes.  Always use GCC
2877     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2878     host_makefile_frag="config/mh-lynxrs6k"
2879     ;;
2880   powerpc-*-darwin*)
2881     host_makefile_frag="config/mh-ppc-darwin"
2882     ;;
2883   powerpc-*-aix*)
2884     host_makefile_frag="config/mh-ppc-aix"
2885     ;;
2886   rs6000-*-aix*)
2887     host_makefile_frag="config/mh-ppc-aix"
2888     ;;
2889   *-*-lynxos*)
2890     # /bin/cc is less than useful for our purposes.  Always use GCC
2891     tentative_cc="/bin/gcc"
2892     ;;
2893   *-*-sysv4*)
2894     host_makefile_frag="config/mh-sysv4"
2895     ;;
2896   # This is placed last to prevent interfering with the cases above.
2897   i[3456789]86-*-*)
2898     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2899     host_makefile_frag="config/mh-x86omitfp"
2900     ;;
2901 esac
2902 fi
2903
2904 # If we aren't going to be using gcc, see if we can extract a definition
2905 # of CC from the fragment.
2906 # Actually, use the 'pre-extracted' version above.
2907 if test -z "${CC}" && test "${build}" = "${host}" ; then
2908   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2909   found=
2910   for dir in $PATH; do
2911     test -z "$dir" && dir=.
2912     if test -f $dir/gcc; then
2913       found=yes
2914       break
2915     fi
2916   done
2917   IFS="$save_ifs"
2918   if test -z "${found}" && test -n "${tentative_cc}" ; then
2919     CC=$tentative_cc
2920   fi
2921 fi
2922
2923 if test "${build}" != "${host}" ; then
2924   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2925   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2926   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2927   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2928   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2929   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2930   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2931   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2932   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2933   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2934   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2935   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2936 else
2937   AR_FOR_BUILD="\$(AR)"
2938   AS_FOR_BUILD="\$(AS)"
2939   CC_FOR_BUILD="\$(CC)"
2940   CXX_FOR_BUILD="\$(CXX)"
2941   GCJ_FOR_BUILD="\$(GCJ)"
2942   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2943   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2944   LD_FOR_BUILD="\$(LD)"
2945   NM_FOR_BUILD="\$(NM)"
2946   RANLIB_FOR_BUILD="\$(RANLIB)"
2947   WINDRES_FOR_BUILD="\$(WINDRES)"
2948   WINDMC_FOR_BUILD="\$(WINDMC)"
2949 fi
2950
2951 ac_ext=c
2952 ac_cpp='$CPP $CPPFLAGS'
2953 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2954 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2955 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2956 if test -n "$ac_tool_prefix"; then
2957   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2958 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2959 echo "$as_me:$LINENO: checking for $ac_word" >&5
2960 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2961 if test "${ac_cv_prog_CC+set}" = set; then
2962   echo $ECHO_N "(cached) $ECHO_C" >&6
2963 else
2964   if test -n "$CC"; then
2965   ac_cv_prog_CC="$CC" # Let the user override the test.
2966 else
2967 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2968 for as_dir in $PATH
2969 do
2970   IFS=$as_save_IFS
2971   test -z "$as_dir" && as_dir=.
2972   for ac_exec_ext in '' $ac_executable_extensions; do
2973   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2974     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2975     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2976     break 2
2977   fi
2978 done
2979 done
2980
2981 fi
2982 fi
2983 CC=$ac_cv_prog_CC
2984 if test -n "$CC"; then
2985   echo "$as_me:$LINENO: result: $CC" >&5
2986 echo "${ECHO_T}$CC" >&6
2987 else
2988   echo "$as_me:$LINENO: result: no" >&5
2989 echo "${ECHO_T}no" >&6
2990 fi
2991
2992 fi
2993 if test -z "$ac_cv_prog_CC"; then
2994   ac_ct_CC=$CC
2995   # Extract the first word of "gcc", so it can be a program name with args.
2996 set dummy gcc; ac_word=$2
2997 echo "$as_me:$LINENO: checking for $ac_word" >&5
2998 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2999 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3000   echo $ECHO_N "(cached) $ECHO_C" >&6
3001 else
3002   if test -n "$ac_ct_CC"; then
3003   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3004 else
3005 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3006 for as_dir in $PATH
3007 do
3008   IFS=$as_save_IFS
3009   test -z "$as_dir" && as_dir=.
3010   for ac_exec_ext in '' $ac_executable_extensions; do
3011   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3012     ac_cv_prog_ac_ct_CC="gcc"
3013     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3014     break 2
3015   fi
3016 done
3017 done
3018
3019 fi
3020 fi
3021 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3022 if test -n "$ac_ct_CC"; then
3023   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3024 echo "${ECHO_T}$ac_ct_CC" >&6
3025 else
3026   echo "$as_me:$LINENO: result: no" >&5
3027 echo "${ECHO_T}no" >&6
3028 fi
3029
3030   CC=$ac_ct_CC
3031 else
3032   CC="$ac_cv_prog_CC"
3033 fi
3034
3035 if test -z "$CC"; then
3036   if test -n "$ac_tool_prefix"; then
3037   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3038 set dummy ${ac_tool_prefix}cc; ac_word=$2
3039 echo "$as_me:$LINENO: checking for $ac_word" >&5
3040 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3041 if test "${ac_cv_prog_CC+set}" = set; then
3042   echo $ECHO_N "(cached) $ECHO_C" >&6
3043 else
3044   if test -n "$CC"; then
3045   ac_cv_prog_CC="$CC" # Let the user override the test.
3046 else
3047 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3048 for as_dir in $PATH
3049 do
3050   IFS=$as_save_IFS
3051   test -z "$as_dir" && as_dir=.
3052   for ac_exec_ext in '' $ac_executable_extensions; do
3053   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3054     ac_cv_prog_CC="${ac_tool_prefix}cc"
3055     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3056     break 2
3057   fi
3058 done
3059 done
3060
3061 fi
3062 fi
3063 CC=$ac_cv_prog_CC
3064 if test -n "$CC"; then
3065   echo "$as_me:$LINENO: result: $CC" >&5
3066 echo "${ECHO_T}$CC" >&6
3067 else
3068   echo "$as_me:$LINENO: result: no" >&5
3069 echo "${ECHO_T}no" >&6
3070 fi
3071
3072 fi
3073 if test -z "$ac_cv_prog_CC"; then
3074   ac_ct_CC=$CC
3075   # Extract the first word of "cc", so it can be a program name with args.
3076 set dummy cc; ac_word=$2
3077 echo "$as_me:$LINENO: checking for $ac_word" >&5
3078 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3079 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3080   echo $ECHO_N "(cached) $ECHO_C" >&6
3081 else
3082   if test -n "$ac_ct_CC"; then
3083   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3084 else
3085 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3086 for as_dir in $PATH
3087 do
3088   IFS=$as_save_IFS
3089   test -z "$as_dir" && as_dir=.
3090   for ac_exec_ext in '' $ac_executable_extensions; do
3091   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3092     ac_cv_prog_ac_ct_CC="cc"
3093     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3094     break 2
3095   fi
3096 done
3097 done
3098
3099 fi
3100 fi
3101 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3102 if test -n "$ac_ct_CC"; then
3103   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3104 echo "${ECHO_T}$ac_ct_CC" >&6
3105 else
3106   echo "$as_me:$LINENO: result: no" >&5
3107 echo "${ECHO_T}no" >&6
3108 fi
3109
3110   CC=$ac_ct_CC
3111 else
3112   CC="$ac_cv_prog_CC"
3113 fi
3114
3115 fi
3116 if test -z "$CC"; then
3117   # Extract the first word of "cc", so it can be a program name with args.
3118 set dummy cc; ac_word=$2
3119 echo "$as_me:$LINENO: checking for $ac_word" >&5
3120 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3121 if test "${ac_cv_prog_CC+set}" = set; then
3122   echo $ECHO_N "(cached) $ECHO_C" >&6
3123 else
3124   if test -n "$CC"; then
3125   ac_cv_prog_CC="$CC" # Let the user override the test.
3126 else
3127   ac_prog_rejected=no
3128 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3129 for as_dir in $PATH
3130 do
3131   IFS=$as_save_IFS
3132   test -z "$as_dir" && as_dir=.
3133   for ac_exec_ext in '' $ac_executable_extensions; do
3134   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3135     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3136        ac_prog_rejected=yes
3137        continue
3138      fi
3139     ac_cv_prog_CC="cc"
3140     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3141     break 2
3142   fi
3143 done
3144 done
3145
3146 if test $ac_prog_rejected = yes; then
3147   # We found a bogon in the path, so make sure we never use it.
3148   set dummy $ac_cv_prog_CC
3149   shift
3150   if test $# != 0; then
3151     # We chose a different compiler from the bogus one.
3152     # However, it has the same basename, so the bogon will be chosen
3153     # first if we set CC to just the basename; use the full file name.
3154     shift
3155     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3156   fi
3157 fi
3158 fi
3159 fi
3160 CC=$ac_cv_prog_CC
3161 if test -n "$CC"; then
3162   echo "$as_me:$LINENO: result: $CC" >&5
3163 echo "${ECHO_T}$CC" >&6
3164 else
3165   echo "$as_me:$LINENO: result: no" >&5
3166 echo "${ECHO_T}no" >&6
3167 fi
3168
3169 fi
3170 if test -z "$CC"; then
3171   if test -n "$ac_tool_prefix"; then
3172   for ac_prog in cl
3173   do
3174     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3175 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3176 echo "$as_me:$LINENO: checking for $ac_word" >&5
3177 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3178 if test "${ac_cv_prog_CC+set}" = set; then
3179   echo $ECHO_N "(cached) $ECHO_C" >&6
3180 else
3181   if test -n "$CC"; then
3182   ac_cv_prog_CC="$CC" # Let the user override the test.
3183 else
3184 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3185 for as_dir in $PATH
3186 do
3187   IFS=$as_save_IFS
3188   test -z "$as_dir" && as_dir=.
3189   for ac_exec_ext in '' $ac_executable_extensions; do
3190   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3191     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3192     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3193     break 2
3194   fi
3195 done
3196 done
3197
3198 fi
3199 fi
3200 CC=$ac_cv_prog_CC
3201 if test -n "$CC"; then
3202   echo "$as_me:$LINENO: result: $CC" >&5
3203 echo "${ECHO_T}$CC" >&6
3204 else
3205   echo "$as_me:$LINENO: result: no" >&5
3206 echo "${ECHO_T}no" >&6
3207 fi
3208
3209     test -n "$CC" && break
3210   done
3211 fi
3212 if test -z "$CC"; then
3213   ac_ct_CC=$CC
3214   for ac_prog in cl
3215 do
3216   # Extract the first word of "$ac_prog", so it can be a program name with args.
3217 set dummy $ac_prog; ac_word=$2
3218 echo "$as_me:$LINENO: checking for $ac_word" >&5
3219 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3220 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3221   echo $ECHO_N "(cached) $ECHO_C" >&6
3222 else
3223   if test -n "$ac_ct_CC"; then
3224   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3225 else
3226 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3227 for as_dir in $PATH
3228 do
3229   IFS=$as_save_IFS
3230   test -z "$as_dir" && as_dir=.
3231   for ac_exec_ext in '' $ac_executable_extensions; do
3232   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3233     ac_cv_prog_ac_ct_CC="$ac_prog"
3234     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3235     break 2
3236   fi
3237 done
3238 done
3239
3240 fi
3241 fi
3242 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3243 if test -n "$ac_ct_CC"; then
3244   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3245 echo "${ECHO_T}$ac_ct_CC" >&6
3246 else
3247   echo "$as_me:$LINENO: result: no" >&5
3248 echo "${ECHO_T}no" >&6
3249 fi
3250
3251   test -n "$ac_ct_CC" && break
3252 done
3253
3254   CC=$ac_ct_CC
3255 fi
3256
3257 fi
3258
3259
3260 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3261 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3262 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3263 See \`config.log' for more details." >&5
3264 echo "$as_me: error: no acceptable C compiler found in \$PATH
3265 See \`config.log' for more details." >&2;}
3266    { (exit 1); exit 1; }; }; }
3267
3268 # Provide some information about the compiler.
3269 echo "$as_me:$LINENO:" \
3270      "checking for C compiler version" >&5
3271 ac_compiler=`set X $ac_compile; echo $2`
3272 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3273   (eval $ac_compiler --version </dev/null >&5) 2>&5
3274   ac_status=$?
3275   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3276   (exit $ac_status); }
3277 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3278   (eval $ac_compiler -v </dev/null >&5) 2>&5
3279   ac_status=$?
3280   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3281   (exit $ac_status); }
3282 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3283   (eval $ac_compiler -V </dev/null >&5) 2>&5
3284   ac_status=$?
3285   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3286   (exit $ac_status); }
3287
3288 cat >conftest.$ac_ext <<_ACEOF
3289 /* confdefs.h.  */
3290 _ACEOF
3291 cat confdefs.h >>conftest.$ac_ext
3292 cat >>conftest.$ac_ext <<_ACEOF
3293 /* end confdefs.h.  */
3294
3295 int
3296 main ()
3297 {
3298
3299   ;
3300   return 0;
3301 }
3302 _ACEOF
3303 ac_clean_files_save=$ac_clean_files
3304 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3305 # Try to create an executable without -o first, disregard a.out.
3306 # It will help us diagnose broken compilers, and finding out an intuition
3307 # of exeext.
3308 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3309 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3310 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3311 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3312   (eval $ac_link_default) 2>&5
3313   ac_status=$?
3314   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3315   (exit $ac_status); }; then
3316   # Find the output, starting from the most likely.  This scheme is
3317 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3318 # resort.
3319
3320 # Be careful to initialize this variable, since it used to be cached.
3321 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3322 ac_cv_exeext=
3323 # b.out is created by i960 compilers.
3324 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3325 do
3326   test -f "$ac_file" || continue
3327   case $ac_file in
3328     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3329         ;;
3330     conftest.$ac_ext )
3331         # This is the source file.
3332         ;;
3333     [ab].out )
3334         # We found the default executable, but exeext='' is most
3335         # certainly right.
3336         break;;
3337     *.* )
3338         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3339         # FIXME: I believe we export ac_cv_exeext for Libtool,
3340         # but it would be cool to find out if it's true.  Does anybody
3341         # maintain Libtool? --akim.
3342         export ac_cv_exeext
3343         break;;
3344     * )
3345         break;;
3346   esac
3347 done
3348 else
3349   echo "$as_me: failed program was:" >&5
3350 sed 's/^/| /' conftest.$ac_ext >&5
3351
3352 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3353 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3354 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3355 See \`config.log' for more details." >&5
3356 echo "$as_me: error: C compiler cannot create executables
3357 See \`config.log' for more details." >&2;}
3358    { (exit 77); exit 77; }; }; }
3359 fi
3360
3361 ac_exeext=$ac_cv_exeext
3362 echo "$as_me:$LINENO: result: $ac_file" >&5
3363 echo "${ECHO_T}$ac_file" >&6
3364
3365 # Check the compiler produces executables we can run.  If not, either
3366 # the compiler is broken, or we cross compile.
3367 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3368 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3369 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3370 # If not cross compiling, check that we can run a simple program.
3371 if test "$cross_compiling" != yes; then
3372   if { ac_try='./$ac_file'
3373   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3374   (eval $ac_try) 2>&5
3375   ac_status=$?
3376   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3377   (exit $ac_status); }; }; then
3378     cross_compiling=no
3379   else
3380     if test "$cross_compiling" = maybe; then
3381         cross_compiling=yes
3382     else
3383         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3384 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3385 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3386 If you meant to cross compile, use \`--host'.
3387 See \`config.log' for more details." >&5
3388 echo "$as_me: error: cannot run C compiled programs.
3389 If you meant to cross compile, use \`--host'.
3390 See \`config.log' for more details." >&2;}
3391    { (exit 1); exit 1; }; }; }
3392     fi
3393   fi
3394 fi
3395 echo "$as_me:$LINENO: result: yes" >&5
3396 echo "${ECHO_T}yes" >&6
3397
3398 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3399 ac_clean_files=$ac_clean_files_save
3400 # Check the compiler produces executables we can run.  If not, either
3401 # the compiler is broken, or we cross compile.
3402 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3403 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3404 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3405 echo "${ECHO_T}$cross_compiling" >&6
3406
3407 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3408 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3409 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3410   (eval $ac_link) 2>&5
3411   ac_status=$?
3412   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3413   (exit $ac_status); }; then
3414   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3415 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3416 # work properly (i.e., refer to `conftest.exe'), while it won't with
3417 # `rm'.
3418 for ac_file in conftest.exe conftest conftest.*; do
3419   test -f "$ac_file" || continue
3420   case $ac_file in
3421     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3422     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3423           export ac_cv_exeext
3424           break;;
3425     * ) break;;
3426   esac
3427 done
3428 else
3429   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3430 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3431 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3432 See \`config.log' for more details." >&5
3433 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3434 See \`config.log' for more details." >&2;}
3435    { (exit 1); exit 1; }; }; }
3436 fi
3437
3438 rm -f conftest$ac_cv_exeext
3439 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3440 echo "${ECHO_T}$ac_cv_exeext" >&6
3441
3442 rm -f conftest.$ac_ext
3443 EXEEXT=$ac_cv_exeext
3444 ac_exeext=$EXEEXT
3445 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3446 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3447 if test "${ac_cv_objext+set}" = set; then
3448   echo $ECHO_N "(cached) $ECHO_C" >&6
3449 else
3450   cat >conftest.$ac_ext <<_ACEOF
3451 /* confdefs.h.  */
3452 _ACEOF
3453 cat confdefs.h >>conftest.$ac_ext
3454 cat >>conftest.$ac_ext <<_ACEOF
3455 /* end confdefs.h.  */
3456
3457 int
3458 main ()
3459 {
3460
3461   ;
3462   return 0;
3463 }
3464 _ACEOF
3465 rm -f conftest.o conftest.obj
3466 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3467   (eval $ac_compile) 2>&5
3468   ac_status=$?
3469   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3470   (exit $ac_status); }; then
3471   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3472   case $ac_file in
3473     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3474     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3475        break;;
3476   esac
3477 done
3478 else
3479   echo "$as_me: failed program was:" >&5
3480 sed 's/^/| /' conftest.$ac_ext >&5
3481
3482 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3483 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3484 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3485 See \`config.log' for more details." >&5
3486 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3487 See \`config.log' for more details." >&2;}
3488    { (exit 1); exit 1; }; }; }
3489 fi
3490
3491 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3492 fi
3493 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3494 echo "${ECHO_T}$ac_cv_objext" >&6
3495 OBJEXT=$ac_cv_objext
3496 ac_objext=$OBJEXT
3497 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3498 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3499 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3500   echo $ECHO_N "(cached) $ECHO_C" >&6
3501 else
3502   cat >conftest.$ac_ext <<_ACEOF
3503 /* confdefs.h.  */
3504 _ACEOF
3505 cat confdefs.h >>conftest.$ac_ext
3506 cat >>conftest.$ac_ext <<_ACEOF
3507 /* end confdefs.h.  */
3508
3509 int
3510 main ()
3511 {
3512 #ifndef __GNUC__
3513        choke me
3514 #endif
3515
3516   ;
3517   return 0;
3518 }
3519 _ACEOF
3520 rm -f conftest.$ac_objext
3521 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3522   (eval $ac_compile) 2>conftest.er1
3523   ac_status=$?
3524   grep -v '^ *+' conftest.er1 >conftest.err
3525   rm -f conftest.er1
3526   cat conftest.err >&5
3527   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3528   (exit $ac_status); } &&
3529          { ac_try='test -z "$ac_c_werror_flag"
3530                          || test ! -s conftest.err'
3531   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3532   (eval $ac_try) 2>&5
3533   ac_status=$?
3534   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3535   (exit $ac_status); }; } &&
3536          { ac_try='test -s conftest.$ac_objext'
3537   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3538   (eval $ac_try) 2>&5
3539   ac_status=$?
3540   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3541   (exit $ac_status); }; }; then
3542   ac_compiler_gnu=yes
3543 else
3544   echo "$as_me: failed program was:" >&5
3545 sed 's/^/| /' conftest.$ac_ext >&5
3546
3547 ac_compiler_gnu=no
3548 fi
3549 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3550 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3551
3552 fi
3553 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3554 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3555 GCC=`test $ac_compiler_gnu = yes && echo yes`
3556 ac_test_CFLAGS=${CFLAGS+set}
3557 ac_save_CFLAGS=$CFLAGS
3558 CFLAGS="-g"
3559 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3560 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3561 if test "${ac_cv_prog_cc_g+set}" = set; then
3562   echo $ECHO_N "(cached) $ECHO_C" >&6
3563 else
3564   cat >conftest.$ac_ext <<_ACEOF
3565 /* confdefs.h.  */
3566 _ACEOF
3567 cat confdefs.h >>conftest.$ac_ext
3568 cat >>conftest.$ac_ext <<_ACEOF
3569 /* end confdefs.h.  */
3570
3571 int
3572 main ()
3573 {
3574
3575   ;
3576   return 0;
3577 }
3578 _ACEOF
3579 rm -f conftest.$ac_objext
3580 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3581   (eval $ac_compile) 2>conftest.er1
3582   ac_status=$?
3583   grep -v '^ *+' conftest.er1 >conftest.err
3584   rm -f conftest.er1
3585   cat conftest.err >&5
3586   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3587   (exit $ac_status); } &&
3588          { ac_try='test -z "$ac_c_werror_flag"
3589                          || test ! -s conftest.err'
3590   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3591   (eval $ac_try) 2>&5
3592   ac_status=$?
3593   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3594   (exit $ac_status); }; } &&
3595          { ac_try='test -s conftest.$ac_objext'
3596   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3597   (eval $ac_try) 2>&5
3598   ac_status=$?
3599   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3600   (exit $ac_status); }; }; then
3601   ac_cv_prog_cc_g=yes
3602 else
3603   echo "$as_me: failed program was:" >&5
3604 sed 's/^/| /' conftest.$ac_ext >&5
3605
3606 ac_cv_prog_cc_g=no
3607 fi
3608 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3609 fi
3610 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3611 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3612 if test "$ac_test_CFLAGS" = set; then
3613   CFLAGS=$ac_save_CFLAGS
3614 elif test $ac_cv_prog_cc_g = yes; then
3615   if test "$GCC" = yes; then
3616     CFLAGS="-g -O2"
3617   else
3618     CFLAGS="-g"
3619   fi
3620 else
3621   if test "$GCC" = yes; then
3622     CFLAGS="-O2"
3623   else
3624     CFLAGS=
3625   fi
3626 fi
3627 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3628 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3629 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3630   echo $ECHO_N "(cached) $ECHO_C" >&6
3631 else
3632   ac_cv_prog_cc_stdc=no
3633 ac_save_CC=$CC
3634 cat >conftest.$ac_ext <<_ACEOF
3635 /* confdefs.h.  */
3636 _ACEOF
3637 cat confdefs.h >>conftest.$ac_ext
3638 cat >>conftest.$ac_ext <<_ACEOF
3639 /* end confdefs.h.  */
3640 #include <stdarg.h>
3641 #include <stdio.h>
3642 #include <sys/types.h>
3643 #include <sys/stat.h>
3644 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3645 struct buf { int x; };
3646 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3647 static char *e (p, i)
3648      char **p;
3649      int i;
3650 {
3651   return p[i];
3652 }
3653 static char *f (char * (*g) (char **, int), char **p, ...)
3654 {
3655   char *s;
3656   va_list v;
3657   va_start (v,p);
3658   s = g (p, va_arg (v,int));
3659   va_end (v);
3660   return s;
3661 }
3662
3663 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3664    function prototypes and stuff, but not '\xHH' hex character constants.
3665    These don't provoke an error unfortunately, instead are silently treated
3666    as 'x'.  The following induces an error, until -std1 is added to get
3667    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3668    array size at least.  It's necessary to write '\x00'==0 to get something
3669    that's true only with -std1.  */
3670 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3671
3672 int test (int i, double x);
3673 struct s1 {int (*f) (int a);};
3674 struct s2 {int (*f) (double a);};
3675 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3676 int argc;
3677 char **argv;
3678 int
3679 main ()
3680 {
3681 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3682   ;
3683   return 0;
3684 }
3685 _ACEOF
3686 # Don't try gcc -ansi; that turns off useful extensions and
3687 # breaks some systems' header files.
3688 # AIX                   -qlanglvl=ansi
3689 # Ultrix and OSF/1      -std1
3690 # HP-UX 10.20 and later -Ae
3691 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3692 # SVR4                  -Xc -D__EXTENSIONS__
3693 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3694 do
3695   CC="$ac_save_CC $ac_arg"
3696   rm -f conftest.$ac_objext
3697 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3698   (eval $ac_compile) 2>conftest.er1
3699   ac_status=$?
3700   grep -v '^ *+' conftest.er1 >conftest.err
3701   rm -f conftest.er1
3702   cat conftest.err >&5
3703   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3704   (exit $ac_status); } &&
3705          { ac_try='test -z "$ac_c_werror_flag"
3706                          || test ! -s conftest.err'
3707   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3708   (eval $ac_try) 2>&5
3709   ac_status=$?
3710   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3711   (exit $ac_status); }; } &&
3712          { ac_try='test -s conftest.$ac_objext'
3713   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3714   (eval $ac_try) 2>&5
3715   ac_status=$?
3716   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3717   (exit $ac_status); }; }; then
3718   ac_cv_prog_cc_stdc=$ac_arg
3719 break
3720 else
3721   echo "$as_me: failed program was:" >&5
3722 sed 's/^/| /' conftest.$ac_ext >&5
3723
3724 fi
3725 rm -f conftest.err conftest.$ac_objext
3726 done
3727 rm -f conftest.$ac_ext conftest.$ac_objext
3728 CC=$ac_save_CC
3729
3730 fi
3731
3732 case "x$ac_cv_prog_cc_stdc" in
3733   x|xno)
3734     echo "$as_me:$LINENO: result: none needed" >&5
3735 echo "${ECHO_T}none needed" >&6 ;;
3736   *)
3737     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3738 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3739     CC="$CC $ac_cv_prog_cc_stdc" ;;
3740 esac
3741
3742 # Some people use a C++ compiler to compile C.  Since we use `exit',
3743 # in C++ we need to declare it.  In case someone uses the same compiler
3744 # for both compiling C and C++ we need to have the C++ compiler decide
3745 # the declaration of exit, since it's the most demanding environment.
3746 cat >conftest.$ac_ext <<_ACEOF
3747 #ifndef __cplusplus
3748   choke me
3749 #endif
3750 _ACEOF
3751 rm -f conftest.$ac_objext
3752 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3753   (eval $ac_compile) 2>conftest.er1
3754   ac_status=$?
3755   grep -v '^ *+' conftest.er1 >conftest.err
3756   rm -f conftest.er1
3757   cat conftest.err >&5
3758   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3759   (exit $ac_status); } &&
3760          { ac_try='test -z "$ac_c_werror_flag"
3761                          || test ! -s conftest.err'
3762   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3763   (eval $ac_try) 2>&5
3764   ac_status=$?
3765   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3766   (exit $ac_status); }; } &&
3767          { ac_try='test -s conftest.$ac_objext'
3768   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3769   (eval $ac_try) 2>&5
3770   ac_status=$?
3771   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3772   (exit $ac_status); }; }; then
3773   for ac_declaration in \
3774    '' \
3775    'extern "C" void std::exit (int) throw (); using std::exit;' \
3776    'extern "C" void std::exit (int); using std::exit;' \
3777    'extern "C" void exit (int) throw ();' \
3778    'extern "C" void exit (int);' \
3779    'void exit (int);'
3780 do
3781   cat >conftest.$ac_ext <<_ACEOF
3782 /* confdefs.h.  */
3783 _ACEOF
3784 cat confdefs.h >>conftest.$ac_ext
3785 cat >>conftest.$ac_ext <<_ACEOF
3786 /* end confdefs.h.  */
3787 $ac_declaration
3788 #include <stdlib.h>
3789 int
3790 main ()
3791 {
3792 exit (42);
3793   ;
3794   return 0;
3795 }
3796 _ACEOF
3797 rm -f conftest.$ac_objext
3798 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3799   (eval $ac_compile) 2>conftest.er1
3800   ac_status=$?
3801   grep -v '^ *+' conftest.er1 >conftest.err
3802   rm -f conftest.er1
3803   cat conftest.err >&5
3804   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3805   (exit $ac_status); } &&
3806          { ac_try='test -z "$ac_c_werror_flag"
3807                          || test ! -s conftest.err'
3808   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3809   (eval $ac_try) 2>&5
3810   ac_status=$?
3811   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3812   (exit $ac_status); }; } &&
3813          { ac_try='test -s conftest.$ac_objext'
3814   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3815   (eval $ac_try) 2>&5
3816   ac_status=$?
3817   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3818   (exit $ac_status); }; }; then
3819   :
3820 else
3821   echo "$as_me: failed program was:" >&5
3822 sed 's/^/| /' conftest.$ac_ext >&5
3823
3824 continue
3825 fi
3826 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3827   cat >conftest.$ac_ext <<_ACEOF
3828 /* confdefs.h.  */
3829 _ACEOF
3830 cat confdefs.h >>conftest.$ac_ext
3831 cat >>conftest.$ac_ext <<_ACEOF
3832 /* end confdefs.h.  */
3833 $ac_declaration
3834 int
3835 main ()
3836 {
3837 exit (42);
3838   ;
3839   return 0;
3840 }
3841 _ACEOF
3842 rm -f conftest.$ac_objext
3843 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3844   (eval $ac_compile) 2>conftest.er1
3845   ac_status=$?
3846   grep -v '^ *+' conftest.er1 >conftest.err
3847   rm -f conftest.er1
3848   cat conftest.err >&5
3849   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3850   (exit $ac_status); } &&
3851          { ac_try='test -z "$ac_c_werror_flag"
3852                          || test ! -s conftest.err'
3853   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3854   (eval $ac_try) 2>&5
3855   ac_status=$?
3856   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3857   (exit $ac_status); }; } &&
3858          { ac_try='test -s conftest.$ac_objext'
3859   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3860   (eval $ac_try) 2>&5
3861   ac_status=$?
3862   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3863   (exit $ac_status); }; }; then
3864   break
3865 else
3866   echo "$as_me: failed program was:" >&5
3867 sed 's/^/| /' conftest.$ac_ext >&5
3868
3869 fi
3870 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3871 done
3872 rm -f conftest*
3873 if test -n "$ac_declaration"; then
3874   echo '#ifdef __cplusplus' >>confdefs.h
3875   echo $ac_declaration      >>confdefs.h
3876   echo '#endif'             >>confdefs.h
3877 fi
3878
3879 else
3880   echo "$as_me: failed program was:" >&5
3881 sed 's/^/| /' conftest.$ac_ext >&5
3882
3883 fi
3884 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3885 ac_ext=c
3886 ac_cpp='$CPP $CPPFLAGS'
3887 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3888 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3889 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3890
3891 ac_ext=cc
3892 ac_cpp='$CXXCPP $CPPFLAGS'
3893 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3894 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3895 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3896 if test -n "$ac_tool_prefix"; then
3897   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3898   do
3899     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3900 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3901 echo "$as_me:$LINENO: checking for $ac_word" >&5
3902 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3903 if test "${ac_cv_prog_CXX+set}" = set; then
3904   echo $ECHO_N "(cached) $ECHO_C" >&6
3905 else
3906   if test -n "$CXX"; then
3907   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3908 else
3909 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3910 for as_dir in $PATH
3911 do
3912   IFS=$as_save_IFS
3913   test -z "$as_dir" && as_dir=.
3914   for ac_exec_ext in '' $ac_executable_extensions; do
3915   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3916     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3917     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3918     break 2
3919   fi
3920 done
3921 done
3922
3923 fi
3924 fi
3925 CXX=$ac_cv_prog_CXX
3926 if test -n "$CXX"; then
3927   echo "$as_me:$LINENO: result: $CXX" >&5
3928 echo "${ECHO_T}$CXX" >&6
3929 else
3930   echo "$as_me:$LINENO: result: no" >&5
3931 echo "${ECHO_T}no" >&6
3932 fi
3933
3934     test -n "$CXX" && break
3935   done
3936 fi
3937 if test -z "$CXX"; then
3938   ac_ct_CXX=$CXX
3939   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3940 do
3941   # Extract the first word of "$ac_prog", so it can be a program name with args.
3942 set dummy $ac_prog; ac_word=$2
3943 echo "$as_me:$LINENO: checking for $ac_word" >&5
3944 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3945 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3946   echo $ECHO_N "(cached) $ECHO_C" >&6
3947 else
3948   if test -n "$ac_ct_CXX"; then
3949   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3950 else
3951 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3952 for as_dir in $PATH
3953 do
3954   IFS=$as_save_IFS
3955   test -z "$as_dir" && as_dir=.
3956   for ac_exec_ext in '' $ac_executable_extensions; do
3957   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3958     ac_cv_prog_ac_ct_CXX="$ac_prog"
3959     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3960     break 2
3961   fi
3962 done
3963 done
3964
3965 fi
3966 fi
3967 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3968 if test -n "$ac_ct_CXX"; then
3969   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3970 echo "${ECHO_T}$ac_ct_CXX" >&6
3971 else
3972   echo "$as_me:$LINENO: result: no" >&5
3973 echo "${ECHO_T}no" >&6
3974 fi
3975
3976   test -n "$ac_ct_CXX" && break
3977 done
3978 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3979
3980   CXX=$ac_ct_CXX
3981 fi
3982
3983
3984 # Provide some information about the compiler.
3985 echo "$as_me:$LINENO:" \
3986      "checking for C++ compiler version" >&5
3987 ac_compiler=`set X $ac_compile; echo $2`
3988 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3989   (eval $ac_compiler --version </dev/null >&5) 2>&5
3990   ac_status=$?
3991   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3992   (exit $ac_status); }
3993 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3994   (eval $ac_compiler -v </dev/null >&5) 2>&5
3995   ac_status=$?
3996   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3997   (exit $ac_status); }
3998 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3999   (eval $ac_compiler -V </dev/null >&5) 2>&5
4000   ac_status=$?
4001   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4002   (exit $ac_status); }
4003
4004 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4005 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4006 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4007   echo $ECHO_N "(cached) $ECHO_C" >&6
4008 else
4009   cat >conftest.$ac_ext <<_ACEOF
4010 /* confdefs.h.  */
4011 _ACEOF
4012 cat confdefs.h >>conftest.$ac_ext
4013 cat >>conftest.$ac_ext <<_ACEOF
4014 /* end confdefs.h.  */
4015
4016 int
4017 main ()
4018 {
4019 #ifndef __GNUC__
4020        choke me
4021 #endif
4022
4023   ;
4024   return 0;
4025 }
4026 _ACEOF
4027 rm -f conftest.$ac_objext
4028 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4029   (eval $ac_compile) 2>conftest.er1
4030   ac_status=$?
4031   grep -v '^ *+' conftest.er1 >conftest.err
4032   rm -f conftest.er1
4033   cat conftest.err >&5
4034   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4035   (exit $ac_status); } &&
4036          { ac_try='test -z "$ac_cxx_werror_flag"
4037                          || test ! -s conftest.err'
4038   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4039   (eval $ac_try) 2>&5
4040   ac_status=$?
4041   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4042   (exit $ac_status); }; } &&
4043          { ac_try='test -s conftest.$ac_objext'
4044   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4045   (eval $ac_try) 2>&5
4046   ac_status=$?
4047   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4048   (exit $ac_status); }; }; then
4049   ac_compiler_gnu=yes
4050 else
4051   echo "$as_me: failed program was:" >&5
4052 sed 's/^/| /' conftest.$ac_ext >&5
4053
4054 ac_compiler_gnu=no
4055 fi
4056 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4057 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4058
4059 fi
4060 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4061 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4062 GXX=`test $ac_compiler_gnu = yes && echo yes`
4063 ac_test_CXXFLAGS=${CXXFLAGS+set}
4064 ac_save_CXXFLAGS=$CXXFLAGS
4065 CXXFLAGS="-g"
4066 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4067 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4068 if test "${ac_cv_prog_cxx_g+set}" = set; then
4069   echo $ECHO_N "(cached) $ECHO_C" >&6
4070 else
4071   cat >conftest.$ac_ext <<_ACEOF
4072 /* confdefs.h.  */
4073 _ACEOF
4074 cat confdefs.h >>conftest.$ac_ext
4075 cat >>conftest.$ac_ext <<_ACEOF
4076 /* end confdefs.h.  */
4077
4078 int
4079 main ()
4080 {
4081
4082   ;
4083   return 0;
4084 }
4085 _ACEOF
4086 rm -f conftest.$ac_objext
4087 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4088   (eval $ac_compile) 2>conftest.er1
4089   ac_status=$?
4090   grep -v '^ *+' conftest.er1 >conftest.err
4091   rm -f conftest.er1
4092   cat conftest.err >&5
4093   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4094   (exit $ac_status); } &&
4095          { ac_try='test -z "$ac_cxx_werror_flag"
4096                          || test ! -s conftest.err'
4097   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4098   (eval $ac_try) 2>&5
4099   ac_status=$?
4100   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4101   (exit $ac_status); }; } &&
4102          { ac_try='test -s conftest.$ac_objext'
4103   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4104   (eval $ac_try) 2>&5
4105   ac_status=$?
4106   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4107   (exit $ac_status); }; }; then
4108   ac_cv_prog_cxx_g=yes
4109 else
4110   echo "$as_me: failed program was:" >&5
4111 sed 's/^/| /' conftest.$ac_ext >&5
4112
4113 ac_cv_prog_cxx_g=no
4114 fi
4115 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4116 fi
4117 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4118 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4119 if test "$ac_test_CXXFLAGS" = set; then
4120   CXXFLAGS=$ac_save_CXXFLAGS
4121 elif test $ac_cv_prog_cxx_g = yes; then
4122   if test "$GXX" = yes; then
4123     CXXFLAGS="-g -O2"
4124   else
4125     CXXFLAGS="-g"
4126   fi
4127 else
4128   if test "$GXX" = yes; then
4129     CXXFLAGS="-O2"
4130   else
4131     CXXFLAGS=
4132   fi
4133 fi
4134 for ac_declaration in \
4135    '' \
4136    'extern "C" void std::exit (int) throw (); using std::exit;' \
4137    'extern "C" void std::exit (int); using std::exit;' \
4138    'extern "C" void exit (int) throw ();' \
4139    'extern "C" void exit (int);' \
4140    'void exit (int);'
4141 do
4142   cat >conftest.$ac_ext <<_ACEOF
4143 /* confdefs.h.  */
4144 _ACEOF
4145 cat confdefs.h >>conftest.$ac_ext
4146 cat >>conftest.$ac_ext <<_ACEOF
4147 /* end confdefs.h.  */
4148 $ac_declaration
4149 #include <stdlib.h>
4150 int
4151 main ()
4152 {
4153 exit (42);
4154   ;
4155   return 0;
4156 }
4157 _ACEOF
4158 rm -f conftest.$ac_objext
4159 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4160   (eval $ac_compile) 2>conftest.er1
4161   ac_status=$?
4162   grep -v '^ *+' conftest.er1 >conftest.err
4163   rm -f conftest.er1
4164   cat conftest.err >&5
4165   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4166   (exit $ac_status); } &&
4167          { ac_try='test -z "$ac_cxx_werror_flag"
4168                          || test ! -s conftest.err'
4169   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4170   (eval $ac_try) 2>&5
4171   ac_status=$?
4172   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4173   (exit $ac_status); }; } &&
4174          { ac_try='test -s conftest.$ac_objext'
4175   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4176   (eval $ac_try) 2>&5
4177   ac_status=$?
4178   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4179   (exit $ac_status); }; }; then
4180   :
4181 else
4182   echo "$as_me: failed program was:" >&5
4183 sed 's/^/| /' conftest.$ac_ext >&5
4184
4185 continue
4186 fi
4187 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4188   cat >conftest.$ac_ext <<_ACEOF
4189 /* confdefs.h.  */
4190 _ACEOF
4191 cat confdefs.h >>conftest.$ac_ext
4192 cat >>conftest.$ac_ext <<_ACEOF
4193 /* end confdefs.h.  */
4194 $ac_declaration
4195 int
4196 main ()
4197 {
4198 exit (42);
4199   ;
4200   return 0;
4201 }
4202 _ACEOF
4203 rm -f conftest.$ac_objext
4204 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4205   (eval $ac_compile) 2>conftest.er1
4206   ac_status=$?
4207   grep -v '^ *+' conftest.er1 >conftest.err
4208   rm -f conftest.er1
4209   cat conftest.err >&5
4210   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4211   (exit $ac_status); } &&
4212          { ac_try='test -z "$ac_cxx_werror_flag"
4213                          || test ! -s conftest.err'
4214   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4215   (eval $ac_try) 2>&5
4216   ac_status=$?
4217   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4218   (exit $ac_status); }; } &&
4219          { ac_try='test -s conftest.$ac_objext'
4220   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4221   (eval $ac_try) 2>&5
4222   ac_status=$?
4223   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4224   (exit $ac_status); }; }; then
4225   break
4226 else
4227   echo "$as_me: failed program was:" >&5
4228 sed 's/^/| /' conftest.$ac_ext >&5
4229
4230 fi
4231 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4232 done
4233 rm -f conftest*
4234 if test -n "$ac_declaration"; then
4235   echo '#ifdef __cplusplus' >>confdefs.h
4236   echo $ac_declaration      >>confdefs.h
4237   echo '#endif'             >>confdefs.h
4238 fi
4239
4240 ac_ext=c
4241 ac_cpp='$CPP $CPPFLAGS'
4242 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4243 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4244 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4245
4246
4247 # We must set the default linker to the linker used by gcc for the correct
4248 # operation of libtool.  If LD is not defined and we are using gcc, try to
4249 # set the LD default to the ld used by gcc.
4250 if test -z "$LD"; then
4251   if test "$GCC" = yes; then
4252     case $build in
4253     *-*-mingw*)
4254       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4255     *)
4256       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4257     esac
4258     case $gcc_prog_ld in
4259     # Accept absolute paths.
4260     [\\/]* | [A-Za-z]:[\\/]*)
4261       LD="$gcc_prog_ld" ;;
4262     esac
4263   fi
4264 fi
4265
4266
4267
4268
4269 if test -n "$ac_tool_prefix"; then
4270   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4271 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4272 echo "$as_me:$LINENO: checking for $ac_word" >&5
4273 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4274 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4275   echo $ECHO_N "(cached) $ECHO_C" >&6
4276 else
4277   if test -n "$GNATBIND"; then
4278   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4279 else
4280 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4281 for as_dir in $PATH
4282 do
4283   IFS=$as_save_IFS
4284   test -z "$as_dir" && as_dir=.
4285   for ac_exec_ext in '' $ac_executable_extensions; do
4286   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4287     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4288     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4289     break 2
4290   fi
4291 done
4292 done
4293
4294 fi
4295 fi
4296 GNATBIND=$ac_cv_prog_GNATBIND
4297 if test -n "$GNATBIND"; then
4298   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4299 echo "${ECHO_T}$GNATBIND" >&6
4300 else
4301   echo "$as_me:$LINENO: result: no" >&5
4302 echo "${ECHO_T}no" >&6
4303 fi
4304
4305 fi
4306 if test -z "$ac_cv_prog_GNATBIND"; then
4307   ac_ct_GNATBIND=$GNATBIND
4308   # Extract the first word of "gnatbind", so it can be a program name with args.
4309 set dummy gnatbind; ac_word=$2
4310 echo "$as_me:$LINENO: checking for $ac_word" >&5
4311 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4312 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4313   echo $ECHO_N "(cached) $ECHO_C" >&6
4314 else
4315   if test -n "$ac_ct_GNATBIND"; then
4316   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4317 else
4318 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4319 for as_dir in $PATH
4320 do
4321   IFS=$as_save_IFS
4322   test -z "$as_dir" && as_dir=.
4323   for ac_exec_ext in '' $ac_executable_extensions; do
4324   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4325     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4326     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4327     break 2
4328   fi
4329 done
4330 done
4331
4332   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4333 fi
4334 fi
4335 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4336 if test -n "$ac_ct_GNATBIND"; then
4337   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4338 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4339 else
4340   echo "$as_me:$LINENO: result: no" >&5
4341 echo "${ECHO_T}no" >&6
4342 fi
4343
4344   GNATBIND=$ac_ct_GNATBIND
4345 else
4346   GNATBIND="$ac_cv_prog_GNATBIND"
4347 fi
4348
4349 if test -n "$ac_tool_prefix"; then
4350   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4351 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4352 echo "$as_me:$LINENO: checking for $ac_word" >&5
4353 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4354 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4355   echo $ECHO_N "(cached) $ECHO_C" >&6
4356 else
4357   if test -n "$GNATMAKE"; then
4358   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4359 else
4360 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4361 for as_dir in $PATH
4362 do
4363   IFS=$as_save_IFS
4364   test -z "$as_dir" && as_dir=.
4365   for ac_exec_ext in '' $ac_executable_extensions; do
4366   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4367     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4368     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4369     break 2
4370   fi
4371 done
4372 done
4373
4374 fi
4375 fi
4376 GNATMAKE=$ac_cv_prog_GNATMAKE
4377 if test -n "$GNATMAKE"; then
4378   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4379 echo "${ECHO_T}$GNATMAKE" >&6
4380 else
4381   echo "$as_me:$LINENO: result: no" >&5
4382 echo "${ECHO_T}no" >&6
4383 fi
4384
4385 fi
4386 if test -z "$ac_cv_prog_GNATMAKE"; then
4387   ac_ct_GNATMAKE=$GNATMAKE
4388   # Extract the first word of "gnatmake", so it can be a program name with args.
4389 set dummy gnatmake; ac_word=$2
4390 echo "$as_me:$LINENO: checking for $ac_word" >&5
4391 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4392 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4393   echo $ECHO_N "(cached) $ECHO_C" >&6
4394 else
4395   if test -n "$ac_ct_GNATMAKE"; then
4396   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4397 else
4398 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4399 for as_dir in $PATH
4400 do
4401   IFS=$as_save_IFS
4402   test -z "$as_dir" && as_dir=.
4403   for ac_exec_ext in '' $ac_executable_extensions; do
4404   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4405     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4406     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4407     break 2
4408   fi
4409 done
4410 done
4411
4412   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4413 fi
4414 fi
4415 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4416 if test -n "$ac_ct_GNATMAKE"; then
4417   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4418 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4419 else
4420   echo "$as_me:$LINENO: result: no" >&5
4421 echo "${ECHO_T}no" >&6
4422 fi
4423
4424   GNATMAKE=$ac_ct_GNATMAKE
4425 else
4426   GNATMAKE="$ac_cv_prog_GNATMAKE"
4427 fi
4428
4429 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4430 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4431 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4432   echo $ECHO_N "(cached) $ECHO_C" >&6
4433 else
4434   cat >conftest.adb <<EOF
4435 procedure conftest is begin null; end conftest;
4436 EOF
4437 acx_cv_cc_gcc_supports_ada=no
4438 # There is a bug in old released versions of GCC which causes the
4439 # driver to exit successfully when the appropriate language module
4440 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4441 # Therefore we must check for the error message as well as an
4442 # unsuccessful exit.
4443 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4444 # given a .adb file, but produce no object file.  So we must check
4445 # if an object file was really produced to guard against this.
4446 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4447 if test x"$errors" = x && test -f conftest.$ac_objext; then
4448   acx_cv_cc_gcc_supports_ada=yes
4449 fi
4450 rm -f conftest.*
4451 fi
4452 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4453 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4454
4455 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4456   have_gnat=yes
4457 else
4458   have_gnat=no
4459 fi
4460
4461 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4462 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4463 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4464   echo $ECHO_N "(cached) $ECHO_C" >&6
4465 else
4466    echo abfoo >t1
4467   echo cdfoo >t2
4468   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4469   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4470     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4471       :
4472     else
4473       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4474     fi
4475   fi
4476   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4477     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4478       :
4479     else
4480       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4481     fi
4482   fi
4483   rm t1 t2
4484
4485 fi
4486 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4487 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4488 do_compare="$gcc_cv_prog_cmp_skip"
4489
4490
4491
4492 # Check for GMP and MPFR
4493 gmplibs="-lmpfr -lgmp"
4494 gmpinc=
4495 have_gmp=no
4496
4497 # Specify a location for mpfr
4498 # check for this first so it ends up on the link line before gmp.
4499
4500 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4501 if test "${with_mpfr_dir+set}" = set; then
4502   withval="$with_mpfr_dir"
4503   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4504 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4505 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4506 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4507    { (exit 1); exit 1; }; }
4508 fi;
4509
4510
4511 # Check whether --with-mpfr or --without-mpfr was given.
4512 if test "${with_mpfr+set}" = set; then
4513   withval="$with_mpfr"
4514
4515 fi;
4516
4517 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4518 if test "${with_mpfr_include+set}" = set; then
4519   withval="$with_mpfr_include"
4520
4521 fi;
4522
4523 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4524 if test "${with_mpfr_lib+set}" = set; then
4525   withval="$with_mpfr_lib"
4526
4527 fi;
4528
4529 if test "x$with_mpfr" != x; then
4530   gmplibs="-L$with_mpfr/lib $gmplibs"
4531   gmpinc="-I$with_mpfr/include"
4532 fi
4533 if test "x$with_mpfr_include" != x; then
4534   gmpinc="-I$with_mpfr_include"
4535 fi
4536 if test "x$with_mpfr_lib" != x; then
4537   gmplibs="-L$with_mpfr_lib $gmplibs"
4538 fi
4539 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4540   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4541   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4542   # Do not test the mpfr version.  Assume that it is sufficient, since
4543   # it is in the source tree, and the library has not been built yet
4544   # but it would be included on the link line in the version check below
4545   # hence making the test fail.
4546   have_gmp=yes
4547 fi
4548
4549 # Specify a location for gmp
4550
4551 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4552 if test "${with_gmp_dir+set}" = set; then
4553   withval="$with_gmp_dir"
4554   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4555 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4556 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4557 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4558    { (exit 1); exit 1; }; }
4559 fi;
4560
4561
4562 # Check whether --with-gmp or --without-gmp was given.
4563 if test "${with_gmp+set}" = set; then
4564   withval="$with_gmp"
4565
4566 fi;
4567
4568 # Check whether --with-gmp_include or --without-gmp_include was given.
4569 if test "${with_gmp_include+set}" = set; then
4570   withval="$with_gmp_include"
4571
4572 fi;
4573
4574 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4575 if test "${with_gmp_lib+set}" = set; then
4576   withval="$with_gmp_lib"
4577
4578 fi;
4579
4580
4581 if test "x$with_gmp" != x; then
4582   gmplibs="-L$with_gmp/lib $gmplibs"
4583   gmpinc="-I$with_gmp/include $gmpinc"
4584 fi
4585 if test "x$with_gmp_include" != x; then
4586   gmpinc="-I$with_gmp_include $gmpinc"
4587 fi
4588 if test "x$with_gmp_lib" != x; then
4589   gmplibs="-L$with_gmp_lib $gmplibs"
4590 fi
4591 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4592   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4593   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4594   # Do not test the gmp version.  Assume that it is sufficient, since
4595   # it is in the source tree, and the library has not been built yet
4596   # but it would be included on the link line in the version check below
4597   # hence making the test fail.
4598   have_gmp=yes
4599 fi
4600
4601 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4602   have_gmp=yes
4603   saved_CFLAGS="$CFLAGS"
4604   CFLAGS="$CFLAGS $gmpinc"
4605   # Check GMP actually works
4606   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4607 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4608
4609 cat >conftest.$ac_ext <<_ACEOF
4610 /* confdefs.h.  */
4611 _ACEOF
4612 cat confdefs.h >>conftest.$ac_ext
4613 cat >>conftest.$ac_ext <<_ACEOF
4614 /* end confdefs.h.  */
4615 #include "gmp.h"
4616 int
4617 main ()
4618 {
4619
4620   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4621   choke me
4622   #endif
4623
4624   ;
4625   return 0;
4626 }
4627 _ACEOF
4628 rm -f conftest.$ac_objext
4629 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4630   (eval $ac_compile) 2>conftest.er1
4631   ac_status=$?
4632   grep -v '^ *+' conftest.er1 >conftest.err
4633   rm -f conftest.er1
4634   cat conftest.err >&5
4635   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4636   (exit $ac_status); } &&
4637          { ac_try='test -z "$ac_c_werror_flag"
4638                          || test ! -s conftest.err'
4639   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4640   (eval $ac_try) 2>&5
4641   ac_status=$?
4642   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4643   (exit $ac_status); }; } &&
4644          { ac_try='test -s conftest.$ac_objext'
4645   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4646   (eval $ac_try) 2>&5
4647   ac_status=$?
4648   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4649   (exit $ac_status); }; }; then
4650   echo "$as_me:$LINENO: result: yes" >&5
4651 echo "${ECHO_T}yes" >&6
4652 else
4653   echo "$as_me: failed program was:" >&5
4654 sed 's/^/| /' conftest.$ac_ext >&5
4655
4656 echo "$as_me:$LINENO: result: no" >&5
4657 echo "${ECHO_T}no" >&6; have_gmp=no
4658 fi
4659 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4660
4661   if test x"$have_gmp" = xyes; then
4662     saved_LIBS="$LIBS"
4663     LIBS="$LIBS $gmplibs"
4664         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4665 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4666     cat >conftest.$ac_ext <<_ACEOF
4667 /* confdefs.h.  */
4668 _ACEOF
4669 cat confdefs.h >>conftest.$ac_ext
4670 cat >>conftest.$ac_ext <<_ACEOF
4671 /* end confdefs.h.  */
4672 #include <gmp.h>
4673     #include <mpfr.h>
4674 int
4675 main ()
4676 {
4677
4678     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4679     choke me
4680     #endif
4681     mpfr_t n;
4682     mpfr_t x;
4683     int t;
4684     mpfr_init (n);
4685     mpfr_init (x);
4686     mpfr_atan2 (n, n, x, GMP_RNDN);
4687     mpfr_erfc (n, x, GMP_RNDN);
4688     mpfr_subnormalize (x, t, GMP_RNDN);
4689
4690   ;
4691   return 0;
4692 }
4693 _ACEOF
4694 rm -f conftest.$ac_objext conftest$ac_exeext
4695 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4696   (eval $ac_link) 2>conftest.er1
4697   ac_status=$?
4698   grep -v '^ *+' conftest.er1 >conftest.err
4699   rm -f conftest.er1
4700   cat conftest.err >&5
4701   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4702   (exit $ac_status); } &&
4703          { ac_try='test -z "$ac_c_werror_flag"
4704                          || test ! -s conftest.err'
4705   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4706   (eval $ac_try) 2>&5
4707   ac_status=$?
4708   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4709   (exit $ac_status); }; } &&
4710          { ac_try='test -s conftest$ac_exeext'
4711   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4712   (eval $ac_try) 2>&5
4713   ac_status=$?
4714   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4715   (exit $ac_status); }; }; then
4716   cat >conftest.$ac_ext <<_ACEOF
4717 /* confdefs.h.  */
4718 _ACEOF
4719 cat confdefs.h >>conftest.$ac_ext
4720 cat >>conftest.$ac_ext <<_ACEOF
4721 /* end confdefs.h.  */
4722 #include <gmp.h>
4723     #include <mpfr.h>
4724 int
4725 main ()
4726 {
4727
4728     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4729     choke me
4730     #endif
4731     mpfr_t n; mpfr_init(n);
4732
4733   ;
4734   return 0;
4735 }
4736 _ACEOF
4737 rm -f conftest.$ac_objext conftest$ac_exeext
4738 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4739   (eval $ac_link) 2>conftest.er1
4740   ac_status=$?
4741   grep -v '^ *+' conftest.er1 >conftest.err
4742   rm -f conftest.er1
4743   cat conftest.err >&5
4744   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4745   (exit $ac_status); } &&
4746          { ac_try='test -z "$ac_c_werror_flag"
4747                          || test ! -s conftest.err'
4748   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4749   (eval $ac_try) 2>&5
4750   ac_status=$?
4751   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4752   (exit $ac_status); }; } &&
4753          { ac_try='test -s conftest$ac_exeext'
4754   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4755   (eval $ac_try) 2>&5
4756   ac_status=$?
4757   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4758   (exit $ac_status); }; }; then
4759   echo "$as_me:$LINENO: result: yes" >&5
4760 echo "${ECHO_T}yes" >&6
4761 else
4762   echo "$as_me: failed program was:" >&5
4763 sed 's/^/| /' conftest.$ac_ext >&5
4764
4765 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4766 echo "${ECHO_T}buggy but acceptable" >&6
4767 fi
4768 rm -f conftest.err conftest.$ac_objext \
4769       conftest$ac_exeext conftest.$ac_ext
4770 else
4771   echo "$as_me: failed program was:" >&5
4772 sed 's/^/| /' conftest.$ac_ext >&5
4773
4774 echo "$as_me:$LINENO: result: no" >&5
4775 echo "${ECHO_T}no" >&6; have_gmp=no
4776 fi
4777 rm -f conftest.err conftest.$ac_objext \
4778       conftest$ac_exeext conftest.$ac_ext
4779       LIBS="$saved_LIBS"
4780   fi
4781   CFLAGS="$saved_CFLAGS"
4782
4783   if test x$have_gmp != xyes; then
4784     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.2+.
4785 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4786 Copies of these libraries' source code can be found at their respective
4787 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4788 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4789 If you obtained GMP and/or MPFR from a vendor distribution package, make
4790 sure that you have installed both the libraries and the header files.
4791 They may be located in separate packages." >&5
4792 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.2+.
4793 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4794 Copies of these libraries' source code can be found at their respective
4795 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4796 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4797 If you obtained GMP and/or MPFR from a vendor distribution package, make
4798 sure that you have installed both the libraries and the header files.
4799 They may be located in separate packages." >&2;}
4800    { (exit 1); exit 1; }; }
4801   fi
4802 fi
4803
4804 # Flags needed for both GMP and/or MPFR
4805
4806
4807
4808
4809 # Check for PPL
4810 ppl_major_version=0
4811 ppl_minor_version=10
4812 ppllibs=" -lppl_c -lppl -lgmpxx "
4813 pplinc=
4814
4815
4816 # Check whether --with-ppl or --without-ppl was given.
4817 if test "${with_ppl+set}" = set; then
4818   withval="$with_ppl"
4819
4820 fi;
4821
4822 # Check whether --with-ppl_include or --without-ppl_include was given.
4823 if test "${with_ppl_include+set}" = set; then
4824   withval="$with_ppl_include"
4825
4826 fi;
4827
4828 # Check whether --with-ppl_lib or --without-ppl_lib was given.
4829 if test "${with_ppl_lib+set}" = set; then
4830   withval="$with_ppl_lib"
4831
4832 fi;
4833
4834 if test "x$with_ppl" != x; then
4835   ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx"
4836   pplinc="-I$with_ppl/include $pplinc"
4837   LIBS="$ppllibs $LIBS"
4838 fi
4839 if test "x$with_ppl_include" != x; then
4840   pplinc="-I$with_ppl_include $pplinc"
4841 fi
4842 if test "x$with_ppl_lib" != x; then
4843   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx"
4844   LIBS="$ppllibs $LIBS"
4845 fi
4846 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
4847   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '
4848   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
4849   LIBS="$ppllibs $LIBS"
4850 fi
4851
4852 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
4853 if test "${enable_ppl_version_check+set}" = set; then
4854   enableval="$enable_ppl_version_check"
4855   ENABLE_PPL_CHECK=$enableval
4856 else
4857   ENABLE_PPL_CHECK=yes
4858 fi;
4859
4860 if test "${ENABLE_PPL_CHECK}" = "yes"; then
4861   saved_CFLAGS="$CFLAGS"
4862   CFLAGS="$CFLAGS $pplinc $gmpinc"
4863   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
4864 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
4865   cat >conftest.$ac_ext <<_ACEOF
4866 /* confdefs.h.  */
4867 _ACEOF
4868 cat confdefs.h >>conftest.$ac_ext
4869 cat >>conftest.$ac_ext <<_ACEOF
4870 /* end confdefs.h.  */
4871 #include "ppl_c.h"
4872 int
4873 main ()
4874 {
4875
4876   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
4877   choke me
4878   #endif
4879
4880   ;
4881   return 0;
4882 }
4883 _ACEOF
4884 rm -f conftest.$ac_objext
4885 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4886   (eval $ac_compile) 2>conftest.er1
4887   ac_status=$?
4888   grep -v '^ *+' conftest.er1 >conftest.err
4889   rm -f conftest.er1
4890   cat conftest.err >&5
4891   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4892   (exit $ac_status); } &&
4893          { ac_try='test -z "$ac_c_werror_flag"
4894                          || test ! -s conftest.err'
4895   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4896   (eval $ac_try) 2>&5
4897   ac_status=$?
4898   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4899   (exit $ac_status); }; } &&
4900          { ac_try='test -s conftest.$ac_objext'
4901   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4902   (eval $ac_try) 2>&5
4903   ac_status=$?
4904   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4905   (exit $ac_status); }; }; then
4906   echo "$as_me:$LINENO: result: yes" >&5
4907 echo "${ECHO_T}yes" >&6
4908 else
4909   echo "$as_me: failed program was:" >&5
4910 sed 's/^/| /' conftest.$ac_ext >&5
4911
4912 echo "$as_me:$LINENO: result: no" >&5
4913 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
4914 fi
4915 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4916   CFLAGS="$saved_CFLAGS"
4917 fi
4918
4919 # Flags needed for PPL
4920
4921
4922
4923
4924 # Check for CLOOG
4925 clooglibs=" -lcloog "
4926 clooginc=" -DCLOOG_PPL_BACKEND "
4927
4928
4929 # Check whether --with-cloog or --without-cloog was given.
4930 if test "${with_cloog+set}" = set; then
4931   withval="$with_cloog"
4932
4933 fi;
4934
4935 # Check whether --with-cloog_include or --without-cloog_include was given.
4936 if test "${with_cloog_include+set}" = set; then
4937   withval="$with_cloog_include"
4938
4939 fi;
4940
4941 # Check whether --with-cloog_lib or --without-cloog_lib was given.
4942 if test "${with_cloog_lib+set}" = set; then
4943   withval="$with_cloog_lib"
4944
4945 fi;
4946
4947 # Check whether --with-cloog-polylib or --without-cloog-polylib was given.
4948 if test "${with_cloog_polylib+set}" = set; then
4949   withval="$with_cloog_polylib"
4950
4951 fi;
4952
4953 if test "x$with_cloog" != x; then
4954   clooglibs="-L$with_cloog/lib -lcloog"
4955   clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
4956   LIBS="$clooglibs $LIBS"
4957 fi
4958 if test "x$with_cloog_polylib" != x; then
4959   clooglibs="-L$with_cloog/lib -lcloog"
4960   clooginc="-I$with_cloog/include "
4961   LIBS="$clooglibs $LIBS"
4962 fi
4963 if test "x$with_cloog_include" != x; then
4964   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
4965 fi
4966 if test "x$with_cloog_lib" != x; then
4967   clooglibs="-L$with_cloog_lib -lcloog"
4968   LIBS="$clooglibs $LIBS"
4969 fi
4970 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
4971   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
4972   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
4973   LIBS="$clooglibs $LIBS"
4974 fi
4975
4976 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
4977 if test "${enable_cloog_version_check+set}" = set; then
4978   enableval="$enable_cloog_version_check"
4979   ENABLE_CLOOG_CHECK=$enableval
4980 else
4981   ENABLE_CLOOG_CHECK=yes
4982 fi;
4983
4984 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
4985   saved_CFLAGS="$CFLAGS"
4986   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
4987   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
4988 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
4989   cat >conftest.$ac_ext <<_ACEOF
4990 /* confdefs.h.  */
4991 _ACEOF
4992 cat confdefs.h >>conftest.$ac_ext
4993 cat >>conftest.$ac_ext <<_ACEOF
4994 /* end confdefs.h.  */
4995 #include "cloog/cloog.h"
4996 int
4997 main ()
4998 {
4999
5000   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5001   choke me
5002   #endif
5003
5004   ;
5005   return 0;
5006 }
5007 _ACEOF
5008 rm -f conftest.$ac_objext
5009 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5010   (eval $ac_compile) 2>conftest.er1
5011   ac_status=$?
5012   grep -v '^ *+' conftest.er1 >conftest.err
5013   rm -f conftest.er1
5014   cat conftest.err >&5
5015   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5016   (exit $ac_status); } &&
5017          { ac_try='test -z "$ac_c_werror_flag"
5018                          || test ! -s conftest.err'
5019   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5020   (eval $ac_try) 2>&5
5021   ac_status=$?
5022   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5023   (exit $ac_status); }; } &&
5024          { ac_try='test -s conftest.$ac_objext'
5025   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5026   (eval $ac_try) 2>&5
5027   ac_status=$?
5028   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5029   (exit $ac_status); }; }; then
5030   echo "$as_me:$LINENO: result: yes" >&5
5031 echo "${ECHO_T}yes" >&6
5032 else
5033   echo "$as_me: failed program was:" >&5
5034 sed 's/^/| /' conftest.$ac_ext >&5
5035
5036 echo "$as_me:$LINENO: result: no" >&5
5037 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5038 fi
5039 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5040   CFLAGS="$saved_CFLAGS"
5041 fi
5042
5043 # Flags needed for CLOOG
5044
5045
5046
5047
5048 # By default, C is the only stage 1 language.
5049 stage1_languages=,c,
5050
5051 # Figure out what language subdirectories are present.
5052 # Look if the user specified --enable-languages="..."; if not, use
5053 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5054 # go away some day.
5055 # NB:  embedded tabs in this IF block -- do not untabify
5056 if test -d ${srcdir}/gcc; then
5057   if test x"${enable_languages+set}" != xset; then
5058     if test x"${LANGUAGES+set}" = xset; then
5059       enable_languages="${LANGUAGES}"
5060         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5061     else
5062       enable_languages=all
5063     fi
5064   else
5065     if test x"${enable_languages}" = x ||
5066        test x"${enable_languages}" = xyes;
5067        then
5068       echo configure.in: --enable-languages needs at least one language argument 1>&2
5069       exit 1
5070     fi
5071   fi
5072   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5073
5074   # 'f95' is the old name for the 'fortran' language. We issue a warning
5075   # and make the substitution.
5076   case ,${enable_languages}, in
5077     *,f95,*)
5078       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5079       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5080       ;;
5081   esac
5082
5083   # First scan to see if an enabled language requires some other language.
5084   # We assume that a given config-lang.in will list all the language
5085   # front ends it requires, even if some are required indirectly.
5086   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5087     case ${lang_frag} in
5088       ..) ;;
5089       # The odd quoting in the next line works around
5090       # an apparent bug in bash 1.12 on linux.
5091       ${srcdir}/gcc/[*]/config-lang.in) ;;
5092       *)
5093         # From the config-lang.in, get $language, $lang_requires
5094         language=
5095         lang_requires=
5096         . ${lang_frag}
5097         for other in ${lang_requires} ; do
5098           case ,${enable_languages}, in
5099             *,$other,*) ;;
5100             *,all,*) ;;
5101             *,$language,*)
5102               echo " \`$other' language required by \`$language'; enabling" 1>&2
5103               enable_languages="${enable_languages},${other}"
5104               ;;
5105           esac
5106         done
5107         ;;
5108     esac
5109   done
5110
5111   new_enable_languages=,c,
5112   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5113   potential_languages=,c,
5114
5115   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5116     case ${lang_frag} in
5117       ..) ;;
5118       # The odd quoting in the next line works around
5119       # an apparent bug in bash 1.12 on linux.
5120       ${srcdir}/gcc/[*]/config-lang.in) ;;
5121       *)
5122         # From the config-lang.in, get $language, $target_libs,
5123         # $lang_dirs, $boot_language, and $build_by_default
5124         language=
5125         target_libs=
5126         lang_dirs=
5127         subdir_requires=
5128         boot_language=no
5129         build_by_default=yes
5130         . ${lang_frag}
5131         if test x${language} = x; then
5132           echo "${lang_frag} doesn't set \$language." 1>&2
5133           exit 1
5134         fi
5135
5136         case ,${enable_languages}, in
5137           *,${language},*)
5138             # Language was explicitly selected; include it.
5139             add_this_lang=yes
5140             ;;
5141           *,all,*)
5142             # 'all' was selected, select it if it is a default language
5143             add_this_lang=${build_by_default}
5144             ;;
5145           *)
5146             add_this_lang=no
5147             ;;
5148         esac
5149
5150         # Disable languages that need other directories if these aren't available.
5151         for i in $subdir_requires; do
5152           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5153           case ,${enable_languages}, in
5154             *,${language},*)
5155               # Specifically requested language; tell them.
5156               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5157 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5158    { (exit 1); exit 1; }; }
5159               ;;
5160             *)
5161               # Silently disable.
5162               add_this_lang=unsupported
5163               ;;
5164           esac
5165         done
5166
5167         # Disable Ada if no preexisting GNAT is available.
5168         case ,${enable_languages},:${language}:${have_gnat} in
5169           *,${language},*:ada:no)
5170             # Specifically requested language; tell them.
5171             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5172 echo "$as_me: error: GNAT is required to build $language" >&2;}
5173    { (exit 1); exit 1; }; }
5174             ;;
5175           *:ada:no)
5176             # Silently disable.
5177             add_this_lang=unsupported
5178             ;;
5179         esac
5180
5181         # Disable a language that is unsupported by the target.
5182         case " $unsupported_languages " in
5183           *" $language "*)
5184             add_this_lang=unsupported
5185             ;;
5186         esac
5187
5188         case $add_this_lang in
5189           unsupported)
5190             # Remove language-dependent dirs.
5191             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5192             ;;
5193           no)
5194             # Remove language-dependent dirs; still show language as supported.
5195             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5196             potential_languages="${potential_languages}${language},"
5197             ;;
5198           yes)
5199             new_enable_languages="${new_enable_languages}${language},"
5200             potential_languages="${potential_languages}${language},"
5201             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5202             case ${boot_language} in
5203               yes)
5204                 # Add to (comma-separated) list of stage 1 languages.
5205                 stage1_languages="${stage1_languages}${language},"
5206                 ;;
5207             esac
5208             ;;
5209         esac
5210         ;;
5211     esac
5212   done
5213
5214   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5215 if test "${enable_stage1_languages+set}" = set; then
5216   enableval="$enable_stage1_languages"
5217   case ,${enable_stage1_languages}, in
5218     ,no,|,,)
5219       # Set it to something that will have no effect in the loop below
5220       enable_stage1_languages=c ;;
5221     ,yes,)
5222       enable_stage1_languages=`echo $new_enable_languages | \
5223         sed -e "s/^,//" -e "s/,$//" ` ;;
5224     *,all,*)
5225       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5226         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5227   esac
5228
5229   # Add "good" languages from enable_stage1_languages to stage1_languages,
5230   # while "bad" languages go in missing_languages.  Leave no duplicates.
5231   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5232     case $potential_languages in
5233       *,$i,*)
5234         case $stage1_languages in
5235           *,$i,*) ;;
5236           *) stage1_languages="$stage1_languages$i," ;;
5237         esac ;;
5238       *)
5239         case $missing_languages in
5240           *,$i,*) ;;
5241           *) missing_languages="$missing_languages$i," ;;
5242         esac ;;
5243      esac
5244   done
5245 fi;
5246
5247   # Remove leading/trailing commas that were added for simplicity
5248   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5249   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5250   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5251   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5252
5253   if test "x$missing_languages" != x; then
5254     { { echo "$as_me:$LINENO: error:
5255 The following requested languages could not be built: ${missing_languages}
5256 Supported languages are: ${potential_languages}" >&5
5257 echo "$as_me: error:
5258 The following requested languages could not be built: ${missing_languages}
5259 Supported languages are: ${potential_languages}" >&2;}
5260    { (exit 1); exit 1; }; }
5261   fi
5262   if test "x$new_enable_languages" != "x$enable_languages"; then
5263     echo The following languages will be built: ${new_enable_languages}
5264     enable_languages="$new_enable_languages"
5265   fi
5266
5267
5268   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5269 fi
5270
5271 # Handle --disable-<component> generically.
5272 for dir in $configdirs $build_configdirs $target_configdirs ; do
5273   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5274   varname=`echo $dirname | sed -e s/+/_/g`
5275   if eval test x\${enable_${varname}} "=" xno ; then
5276     noconfigdirs="$noconfigdirs $dir"
5277   fi
5278 done
5279
5280 # Check for Boehm's garbage collector
5281 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5282 if test "${enable_objc_gc+set}" = set; then
5283   enableval="$enable_objc_gc"
5284   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5285   *,objc,*:*:yes:*target-boehm-gc*)
5286     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5287 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5288    { (exit 1); exit 1; }; }
5289     ;;
5290 esac
5291 fi;
5292
5293 # Make sure we only build Boehm's garbage collector if required.
5294 case ,${enable_languages},:${enable_objc_gc} in
5295   *,objc,*:yes)
5296     # Keep target-boehm-gc if requested for Objective-C.
5297     ;;
5298   *)
5299     # Otherwise remove target-boehm-gc depending on target-libjava.
5300     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5301       noconfigdirs="$noconfigdirs target-boehm-gc"
5302     fi
5303     ;;
5304 esac
5305
5306 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5307 # $build_configdirs and $target_configdirs.
5308 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5309
5310 notsupp=""
5311 for dir in . $skipdirs $noconfigdirs ; do
5312   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5313   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5314     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5315     if test -r $srcdir/$dirname/configure ; then
5316       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5317         true
5318       else
5319         notsupp="$notsupp $dir"
5320       fi
5321     fi
5322   fi
5323   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5324     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5325     if test -r $srcdir/$dirname/configure ; then
5326       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5327         true
5328       else
5329         notsupp="$notsupp $dir"
5330       fi
5331     fi
5332   fi
5333   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5334     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5335     if test -r $srcdir/$dirname/configure ; then
5336       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5337         true
5338       else
5339         notsupp="$notsupp $dir"
5340       fi
5341     fi
5342   fi
5343 done
5344
5345 # Sometimes the tools are distributed with libiberty but with no other
5346 # libraries.  In that case, we don't want to build target-libiberty.
5347 # Don't let libgcc imply libiberty either.
5348 if test -n "${target_configdirs}" ; then
5349   libgcc=
5350   others=
5351   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5352     if test "$i" = "libgcc"; then
5353       libgcc=target-libgcc
5354     elif test "$i" != "libiberty" ; then
5355       if test -r $srcdir/$i/configure ; then
5356         others=yes;
5357         break;
5358       fi
5359     fi
5360   done
5361   if test -z "${others}" ; then
5362     target_configdirs=$libgcc
5363   fi
5364 fi
5365
5366 # Quietly strip out all directories which aren't configurable in this tree.
5367 # This relies on all configurable subdirectories being autoconfiscated, which
5368 # is now the case.
5369 build_configdirs_all="$build_configdirs"
5370 build_configdirs=
5371 for i in ${build_configdirs_all} ; do
5372   j=`echo $i | sed -e s/build-//g`
5373   if test -f ${srcdir}/$j/configure ; then
5374     build_configdirs="${build_configdirs} $i"
5375   fi
5376 done
5377
5378 configdirs_all="$configdirs"
5379 configdirs=
5380 for i in ${configdirs_all} ; do
5381   if test -f ${srcdir}/$i/configure ; then
5382     configdirs="${configdirs} $i"
5383   fi
5384 done
5385
5386 target_configdirs_all="$target_configdirs"
5387 target_configdirs=
5388 for i in ${target_configdirs_all} ; do
5389   j=`echo $i | sed -e s/target-//g`
5390   if test -f ${srcdir}/$j/configure ; then
5391     target_configdirs="${target_configdirs} $i"
5392   fi
5393 done
5394
5395 # Produce a warning message for the subdirs we can't configure.
5396 # This isn't especially interesting in the Cygnus tree, but in the individual
5397 # FSF releases, it's important to let people know when their machine isn't
5398 # supported by the one or two programs in a package.
5399
5400 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5401   # If $appdirs is non-empty, at least one of those directories must still
5402   # be configured, or we error out.  (E.g., if the gas release supports a
5403   # specified target in some subdirs but not the gas subdir, we shouldn't
5404   # pretend that all is well.)
5405   if test -n "$appdirs" ; then
5406     for dir in $appdirs ; do
5407       if test -r $dir/Makefile.in ; then
5408         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5409           appdirs=""
5410           break
5411         fi
5412         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5413           appdirs=""
5414           break
5415         fi
5416       fi
5417     done
5418     if test -n "$appdirs" ; then
5419       echo "*** This configuration is not supported by this package." 1>&2
5420       exit 1
5421     fi
5422   fi
5423   # Okay, some application will build, or we don't care to check.  Still
5424   # notify of subdirs not getting built.
5425   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5426   echo "    ${notsupp}" 1>&2
5427   echo "    (Any other directories should still work fine.)" 1>&2
5428 fi
5429
5430 case "$host" in
5431   *msdosdjgpp*)
5432     enable_gdbtk=no ;;
5433 esac
5434
5435 # To find our prefix, in gcc_cv_tool_prefix.
5436
5437 # The user is always right.
5438 if test "${PATH_SEPARATOR+set}" != set; then
5439   echo "#! /bin/sh" >conf$$.sh
5440   echo  "exit 0"   >>conf$$.sh
5441   chmod +x conf$$.sh
5442   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5443     PATH_SEPARATOR=';'
5444   else
5445     PATH_SEPARATOR=:
5446   fi
5447   rm -f conf$$.sh
5448 fi
5449
5450
5451
5452 if test "x$exec_prefix" = xNONE; then
5453         if test "x$prefix" = xNONE; then
5454                 gcc_cv_tool_prefix=$ac_default_prefix
5455         else
5456                 gcc_cv_tool_prefix=$prefix
5457         fi
5458 else
5459         gcc_cv_tool_prefix=$exec_prefix
5460 fi
5461
5462 # If there is no compiler in the tree, use the PATH only.  In any
5463 # case, if there is no compiler in the tree nobody should use
5464 # AS_FOR_TARGET and LD_FOR_TARGET.
5465 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5466     gcc_version=`cat $srcdir/gcc/BASE-VER`
5467     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5468     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5469     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5470     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5471     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5472     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5473 else
5474     gcc_cv_tool_dirs=
5475 fi
5476
5477 if test x$build = x$target && test -n "$md_exec_prefix"; then
5478         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5479 fi
5480
5481
5482
5483 copy_dirs=
5484
5485
5486 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5487 if test "${with_build_sysroot+set}" = set; then
5488   withval="$with_build_sysroot"
5489   if test x"$withval" != x ; then
5490      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5491    fi
5492 else
5493   SYSROOT_CFLAGS_FOR_TARGET=
5494 fi;
5495
5496
5497
5498 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5499 if test "${with_debug_prefix_map+set}" = set; then
5500   withval="$with_debug_prefix_map"
5501   if test x"$withval" != x; then
5502      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5503      for debug_map in $withval; do
5504        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5505      done
5506    fi
5507 else
5508   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5509 fi;
5510
5511
5512 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5513 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5514 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5515 # We want to ensure that TARGET libraries (which we know are built with
5516 # gcc) are built with "-O2 -g", so include those options when setting
5517 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5518 if test "x$CFLAGS_FOR_TARGET" = x; then
5519   CFLAGS_FOR_TARGET=$CFLAGS
5520   case " $CFLAGS " in
5521     *" -O2 "*) ;;
5522     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5523   esac
5524   case " $CFLAGS " in
5525     *" -g "* | *" -g3 "*) ;;
5526     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5527   esac
5528 fi
5529
5530
5531 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5532   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5533   case " $CXXFLAGS " in
5534     *" -O2 "*) ;;
5535     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5536   esac
5537   case " $CXXFLAGS " in
5538     *" -g "* | *" -g3 "*) ;;
5539     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5540   esac
5541 fi
5542
5543
5544 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5545 # the named directory are copied to $(tooldir)/sys-include.
5546 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5547   if test x${is_cross_compiler} = xno ; then
5548     echo 1>&2 '***' --with-headers is only supported when cross compiling
5549     exit 1
5550   fi
5551   if test x"${with_headers}" != xyes ; then
5552     x=${gcc_cv_tool_prefix}
5553     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5554   fi
5555 fi
5556
5557 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5558 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5559 # are permitted.
5560 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5561   if test x${is_cross_compiler} = xno ; then
5562     echo 1>&2 '***' --with-libs is only supported when cross compiling
5563     exit 1
5564   fi
5565   if test x"${with_libs}" != xyes ; then
5566     # Copy the libraries in reverse order, so that files in the first named
5567     # library override files in subsequent libraries.
5568     x=${gcc_cv_tool_prefix}
5569     for l in ${with_libs}; do
5570       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5571     done
5572   fi
5573 fi
5574
5575 # Set with_gnu_as and with_gnu_ld as appropriate.
5576 #
5577 # This is done by determining whether or not the appropriate directory
5578 # is available, and by checking whether or not specific configurations
5579 # have requested that this magic not happen.
5580 #
5581 # The command line options always override the explicit settings in
5582 # configure.in, and the settings in configure.in override this magic.
5583 #
5584 # If the default for a toolchain is to use GNU as and ld, and you don't
5585 # want to do that, then you should use the --without-gnu-as and
5586 # --without-gnu-ld options for the configure script.
5587
5588 if test x${use_gnu_as} = x &&
5589    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5590   with_gnu_as=yes
5591   extra_host_args="$extra_host_args --with-gnu-as"
5592 fi
5593
5594 if test x${use_gnu_ld} = x &&
5595    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5596   with_gnu_ld=yes
5597   extra_host_args="$extra_host_args --with-gnu-ld"
5598 fi
5599
5600 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5601 # can detect this case.
5602
5603 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5604   with_newlib=yes
5605   extra_host_args="$extra_host_args --with-newlib"
5606 fi
5607
5608 # Handle ${copy_dirs}
5609 set fnord ${copy_dirs}
5610 shift
5611 while test $# != 0 ; do
5612   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5613     :
5614   else
5615     echo Copying $1 to $2
5616
5617     # Use the install script to create the directory and all required
5618     # parent directories.
5619     if test -d $2 ; then
5620       :
5621     else
5622       echo >config.temp
5623       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5624     fi
5625
5626     # Copy the directory, assuming we have tar.
5627     # FIXME: Should we use B in the second tar?  Not all systems support it.
5628     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5629
5630     # It is the responsibility of the user to correctly adjust all
5631     # symlinks.  If somebody can figure out how to handle them correctly
5632     # here, feel free to add the code.
5633
5634     echo $1 > $2/COPIED
5635   fi
5636   shift; shift
5637 done
5638
5639 # Determine a target-dependent exec_prefix that the installed
5640 # gcc will search in.  Keep this list sorted by triplet, with
5641 # the *-*-osname triplets last.
5642 md_exec_prefix=
5643 case "${target}" in
5644   alpha*-*-*vms*)
5645     md_exec_prefix=/gnu/lib/gcc-lib
5646     ;;
5647   i[34567]86-pc-msdosdjgpp*)
5648     md_exec_prefix=/dev/env/DJDIR/bin
5649     ;;
5650   i[34567]86-*-sco3.2v5*)
5651     if test $with_gnu_as = yes; then
5652       md_exec_prefix=/usr/gnu/bin
5653     else
5654       md_exec_prefix=/usr/ccs/bin/elf
5655     fi
5656     ;;
5657
5658   mn10300-*-* | \
5659   powerpc-*-chorusos* | \
5660   powerpc*-*-eabi* | \
5661   powerpc*-*-sysv* | \
5662   powerpc*-*-kaos* | \
5663   s390x-ibm-tpf*)
5664     md_exec_prefix=/usr/ccs/bin
5665     ;;
5666   sparc64-*-elf*)
5667     ;;
5668   v850*-*-*)
5669     md_exec_prefix=/usr/ccs/bin
5670     ;;
5671   xtensa*-*-elf*)
5672     ;;
5673
5674   *-*-beos* | \
5675   *-*-elf* | \
5676   *-*-hpux* | \
5677   *-*-netware* | \
5678   *-*-nto-qnx* | \
5679   *-*-rtems* | \
5680   *-*-solaris2* | \
5681   *-*-sysv[45]* | \
5682   *-*-vxworks* | \
5683   *-wrs-windiss)
5684     md_exec_prefix=/usr/ccs/bin
5685     ;;
5686 esac
5687
5688 extra_arflags_for_target=
5689 extra_nmflags_for_target=
5690 extra_ranlibflags_for_target=
5691 target_makefile_frag=/dev/null
5692 case "${target}" in
5693   mep*-*-*)
5694     target_makefile_frag="config/mt-mep"
5695     ;;
5696   spu-*-*)
5697     target_makefile_frag="config/mt-spu"
5698     ;;
5699   mips*-sde-elf*)
5700     target_makefile_frag="config/mt-sde"
5701     ;;
5702   mipsisa*-*-elfoabi*)
5703     target_makefile_frag="config/mt-mips-elfoabi"
5704     ;;
5705   mips*-*-*linux* | mips*-*-gnu*)
5706     target_makefile_frag="config/mt-mips-gnu"
5707     ;;
5708   *-*-netware*)
5709     target_makefile_frag="config/mt-netware"
5710     ;;
5711   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5712     target_makefile_frag="config/mt-gnu"
5713     ;;
5714   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5715     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5716     # commands to handle both 32-bit and 64-bit objects.  These flags are
5717     # harmless if we're using GNU nm or ar.
5718     extra_arflags_for_target=" -X32_64"
5719     extra_nmflags_for_target=" -B -X32_64"
5720     ;;
5721   *-*-darwin*)
5722     # ranlib from Darwin requires the -c flag to look at common symbols.
5723     extra_ranlibflags_for_target=" -c"
5724     ;;
5725   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5726     target_makefile_frag="config/mt-wince"
5727     ;;
5728 esac
5729
5730 alphaieee_frag=/dev/null
5731 case $target in
5732   alpha*-*-*)
5733     # This just makes sure to use the -mieee option to build target libs.
5734     # This should probably be set individually by each library.
5735     alphaieee_frag="config/mt-alphaieee"
5736     ;;
5737 esac
5738
5739 # If --enable-target-optspace always use -Os instead of -O2 to build
5740 # the target libraries, similarly if it is not specified, use -Os
5741 # on selected platforms.
5742 ospace_frag=/dev/null
5743 case "${enable_target_optspace}:${target}" in
5744   yes:*)
5745     ospace_frag="config/mt-ospace"
5746     ;;
5747   :d30v-*)
5748     ospace_frag="config/mt-d30v"
5749     ;;
5750   :m32r-* | :d10v-* | :fr30-*)
5751     ospace_frag="config/mt-ospace"
5752     ;;
5753   no:* | :*)
5754     ;;
5755   *)
5756     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5757     ;;
5758 esac
5759
5760 # Default to using --with-stabs for certain targets.
5761 if test x${with_stabs} = x ; then
5762   case "${target}" in
5763   mips*-*-irix[56]*)
5764     ;;
5765   mips*-*-* | alpha*-*-osf*)
5766     with_stabs=yes;
5767     extra_host_args="${extra_host_args} --with-stabs"
5768     ;;
5769   esac
5770 fi
5771
5772 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5773 # them automatically.
5774 case "${host}" in
5775   hppa*64*-*-hpux11*)
5776     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5777     ;;
5778 esac
5779
5780 # Some systems (e.g., one of the i386-aix systems the gas testers are
5781 # using) don't handle "\$" correctly, so don't use it here.
5782 tooldir='${exec_prefix}'/${target_noncanonical}
5783 build_tooldir=${tooldir}
5784
5785 # Create a .gdbinit file which runs the one in srcdir
5786 # and tells GDB to look there for source files.
5787
5788 if test -r ${srcdir}/.gdbinit ; then
5789   case ${srcdir} in
5790     .) ;;
5791     *) cat > ./.gdbinit <<EOF
5792 # ${NO_EDIT}
5793 dir ${srcdir}
5794 dir .
5795 source ${srcdir}/.gdbinit
5796 EOF
5797     ;;
5798   esac
5799 fi
5800
5801 # Make sure that the compiler is able to generate an executable.  If it
5802 # can't, we are probably in trouble.  We don't care whether we can run the
5803 # executable--we might be using a cross compiler--we only care whether it
5804 # can be created.  At this point the main configure script has set CC.
5805 we_are_ok=no
5806 echo "int main () { return 0; }" > conftest.c
5807 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5808 if test $? = 0 ; then
5809   if test -s conftest || test -s conftest.exe ; then
5810     we_are_ok=yes
5811   fi
5812 fi
5813 case $we_are_ok in
5814   no)
5815     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5816     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5817     rm -f conftest*
5818     exit 1
5819     ;;
5820 esac
5821 rm -f conftest*
5822
5823 # The Solaris /usr/ucb/cc compiler does not appear to work.
5824 case "${host}" in
5825   sparc-sun-solaris2*)
5826       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5827       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5828           could_use=
5829           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5830           if test -d /opt/cygnus/bin ; then
5831               if test "$could_use" = "" ; then
5832                   could_use="/opt/cygnus/bin"
5833               else
5834                   could_use="$could_use or /opt/cygnus/bin"
5835               fi
5836           fi
5837         if test "$could_use" = "" ; then
5838             echo "Warning: compilation may fail because you're using"
5839             echo "/usr/ucb/cc.  You should change your PATH or CC "
5840             echo "variable and rerun configure."
5841         else
5842             echo "Warning: compilation may fail because you're using"
5843             echo "/usr/ucb/cc, when you should use the C compiler from"
5844             echo "$could_use.  You should change your"
5845             echo "PATH or CC variable and rerun configure."
5846         fi
5847       fi
5848   ;;
5849 esac
5850
5851 # Decide which environment variable is used to find dynamic libraries.
5852 case "${host}" in
5853   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5854   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5855   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5856   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5857 esac
5858
5859 # On systems where the dynamic library environment variable is PATH,
5860 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
5861 # built executables to PATH.
5862 if test "$RPATH_ENVVAR" = PATH; then
5863   GCC_SHLIB_SUBDIR=/shlib
5864 else
5865   GCC_SHLIB_SUBDIR=
5866 fi
5867
5868 # Record target_configdirs and the configure arguments for target and
5869 # build configuration in Makefile.
5870 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5871 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5872
5873 # Determine whether gdb needs tk/tcl or not.
5874 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5875 # and in that case we want gdb to be built without tk.  Ugh!
5876 # In fact I believe gdb is the *only* package directly dependent on tk,
5877 # so we should be able to put the 'maybe's in unconditionally and
5878 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5879 # 100% sure that that's safe though.
5880
5881 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5882 case "$enable_gdbtk" in
5883   no)
5884     GDB_TK="" ;;
5885   yes)
5886     GDB_TK="${gdb_tk}" ;;
5887   *)
5888     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5889     # distro.  Eventually someone will fix this and move Insight, nee
5890     # gdbtk to a separate directory.
5891     if test -d ${srcdir}/gdb/gdbtk ; then
5892       GDB_TK="${gdb_tk}"
5893     else
5894       GDB_TK=""
5895     fi
5896     ;;
5897 esac
5898 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5899 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5900
5901 # Strip out unwanted targets.
5902
5903 # While at that, we remove Makefiles if we were started for recursive
5904 # configuration, so that the top-level Makefile reconfigures them,
5905 # like we used to do when configure itself was recursive.
5906
5907 # Loop over modules.  $extrasub must be used with care, limiting as
5908 # much as possible the usage of range addresses.  That's because autoconf
5909 # splits the sed script to overcome limits in the number of commands,
5910 # and relying on carefully-timed sed passes may turn out to be very hard
5911 # to maintain later.  In this particular case, you just have to be careful
5912 # not to nest @if/@endif pairs, because configure will not warn you at all.
5913
5914 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5915 if test "${enable_bootstrap+set}" = set; then
5916   enableval="$enable_bootstrap"
5917
5918 else
5919   enable_bootstrap=default
5920 fi;
5921
5922 # Issue errors and warnings for invalid/strange bootstrap combinations.
5923 case "$configdirs" in
5924   *gcc*) have_compiler=yes ;;
5925   *) have_compiler=no ;;
5926 esac
5927
5928 case "$have_compiler:$host:$target:$enable_bootstrap" in
5929   *:*:*:no) ;;
5930
5931   # Default behavior.  Enable bootstrap if we have a compiler
5932   # and we are in a native configuration.
5933   yes:$build:$build:default)
5934     enable_bootstrap=yes ;;
5935
5936   *:*:*:default)
5937     enable_bootstrap=no ;;
5938
5939   # We have a compiler and we are in a native configuration, bootstrap is ok
5940   yes:$build:$build:yes)
5941     ;;
5942
5943   # Other configurations, but we have a compiler.  Assume the user knows
5944   # what he's doing.
5945   yes:*:*:yes)
5946     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5947 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5948     ;;
5949
5950   # No compiler: if they passed --enable-bootstrap explicitly, fail
5951   no:*:*:yes)
5952     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5953 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5954    { (exit 1); exit 1; }; } ;;
5955
5956   # Fail if wrong command line
5957   *)
5958     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5959 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5960    { (exit 1); exit 1; }; }
5961     ;;
5962 esac
5963
5964 # Adjust the toplevel makefile according to whether bootstrap was selected.
5965 case "$enable_bootstrap" in
5966   yes)
5967     bootstrap_suffix=bootstrap ;;
5968   no)
5969     bootstrap_suffix=no-bootstrap ;;
5970 esac
5971
5972 for module in ${build_configdirs} ; do
5973   if test -z "${no_recursion}" \
5974      && test -f ${build_subdir}/${module}/Makefile; then
5975     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5976     rm -f ${build_subdir}/${module}/Makefile
5977   fi
5978   extrasub="$extrasub
5979 /^@if build-$module\$/d
5980 /^@endif build-$module\$/d
5981 /^@if build-$module-$bootstrap_suffix\$/d
5982 /^@endif build-$module-$bootstrap_suffix\$/d"
5983 done
5984 for module in ${configdirs} ; do
5985   if test -z "${no_recursion}"; then
5986     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5987       if test -f ${file}; then
5988         echo 1>&2 "*** removing ${file} to force reconfigure"
5989         rm -f ${file}
5990       fi
5991     done
5992   fi
5993   extrasub="$extrasub
5994 /^@if $module\$/d
5995 /^@endif $module\$/d
5996 /^@if $module-$bootstrap_suffix\$/d
5997 /^@endif $module-$bootstrap_suffix\$/d"
5998 done
5999 for module in ${target_configdirs} ; do
6000   if test -z "${no_recursion}" \
6001      && test -f ${target_subdir}/${module}/Makefile; then
6002     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6003     rm -f ${target_subdir}/${module}/Makefile
6004   fi
6005   extrasub="$extrasub
6006 /^@if target-$module\$/d
6007 /^@endif target-$module\$/d
6008 /^@if target-$module-$bootstrap_suffix\$/d
6009 /^@endif target-$module-$bootstrap_suffix\$/d"
6010 done
6011
6012 extrasub="$extrasub
6013 /^@if /,/^@endif /d"
6014
6015 # Create the serialization dependencies.  This uses a temporary file.
6016
6017 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6018 if test "${enable_serial_configure+set}" = set; then
6019   enableval="$enable_serial_configure"
6020
6021 fi;
6022
6023 case ${enable_serial_configure} in
6024   yes)
6025     enable_serial_build_configure=yes
6026     enable_serial_host_configure=yes
6027     enable_serial_target_configure=yes
6028     ;;
6029 esac
6030
6031 # These force 'configure's to be done one at a time, to avoid problems
6032 # with contention over a shared config.cache.
6033 rm -f serdep.tmp
6034 echo '# serdep.tmp' > serdep.tmp
6035 olditem=
6036 test "x${enable_serial_build_configure}" = xyes &&
6037 for item in ${build_configdirs} ; do
6038   case ${olditem} in
6039     "") ;;
6040     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6041   esac
6042   olditem=${item}
6043 done
6044 olditem=
6045 test "x${enable_serial_host_configure}" = xyes &&
6046 for item in ${configdirs} ; do
6047   case ${olditem} in
6048     "") ;;
6049     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6050   esac
6051   olditem=${item}
6052 done
6053 olditem=
6054 test "x${enable_serial_target_configure}" = xyes &&
6055 for item in ${target_configdirs} ; do
6056   case ${olditem} in
6057     "") ;;
6058     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6059   esac
6060   olditem=${item}
6061 done
6062 serialization_dependencies=serdep.tmp
6063
6064
6065 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6066 # target, nonopt, and variable assignments.  These are the ones we
6067 # might not want to pass down to subconfigures.  Also strip
6068 # program-prefix, program-suffix, and program-transform-name, so that
6069 # we can pass down a consistent program-transform-name.
6070 baseargs=
6071 keep_next=no
6072 skip_next=no
6073 eval "set -- $ac_configure_args"
6074 for ac_arg
6075 do
6076   if test X"$skip_next" = X"yes"; then
6077     skip_next=no
6078     continue
6079   fi
6080   if test X"$keep_next" = X"yes"; then
6081     case $ac_arg in
6082       *\'*)
6083         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6084     esac
6085     baseargs="$baseargs '$ac_arg'"
6086     keep_next=no
6087     continue
6088   fi
6089
6090   # Handle separated arguments.  Based on the logic generated by
6091   # autoconf 2.59.
6092   case $ac_arg in
6093     *=* | --config-cache | -C | -disable-* | --disable-* \
6094       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6095       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6096       | -with-* | --with-* | -without-* | --without-* | --x)
6097       separate_arg=no
6098       ;;
6099     -*)
6100       separate_arg=yes
6101       ;;
6102     *)
6103       separate_arg=no
6104       ;;
6105   esac
6106
6107   case "$ac_arg" in
6108     --no*)
6109       continue
6110       ;;
6111     --c* | \
6112     --sr* | \
6113     --ho* | \
6114     --bu* | \
6115     --t* | \
6116     --program-* | \
6117     -cache_file* | \
6118     -srcdir* | \
6119     -host* | \
6120     -build* | \
6121     -target* | \
6122     -program-prefix* | \
6123     -program-suffix* | \
6124     -program-transform-name* )
6125       skip_next=$separate_arg
6126       continue
6127       ;;
6128     -*)
6129       # An option.  Add it.
6130       case $ac_arg in
6131         *\'*)
6132           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6133       esac
6134       baseargs="$baseargs '$ac_arg'"
6135       keep_next=$separate_arg
6136       ;;
6137     *)
6138       # Either a variable assignment, or a nonopt (triplet).  Don't
6139       # pass it down; let the Makefile handle this.
6140       continue
6141       ;;
6142   esac
6143 done
6144 # Remove the initial space we just introduced and, as these will be
6145 # expanded by make, quote '$'.
6146 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6147
6148 # Add in --program-transform-name, after --program-prefix and
6149 # --program-suffix have been applied to it.  Autoconf has already
6150 # doubled dollar signs and backslashes in program_transform_name; we want
6151 # the backslashes un-doubled, and then the entire thing wrapped in single
6152 # quotes, because this will be expanded first by make and then by the shell.
6153 # Also, because we want to override the logic in subdir configure scripts to
6154 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6155 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6156 ${program_transform_name}
6157 EOF_SED
6158 gcc_transform_name=`cat conftestsed.out`
6159 rm -f conftestsed.out
6160 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6161 if test "$silent" = yes; then
6162   baseargs="$baseargs --silent"
6163 fi
6164
6165 # For the build-side libraries, we just need to pretend we're native,
6166 # and not use the same cache file.  Multilibs are neither needed nor
6167 # desired.
6168 build_configargs="--cache-file=../config.cache ${baseargs}"
6169
6170 # For host modules, accept cache file option, or specification as blank.
6171 case "${cache_file}" in
6172 "") # empty
6173   cache_file_option="" ;;
6174 /* | [A-Za-z]:[\\/]* ) # absolute path
6175   cache_file_option="--cache-file=${cache_file}" ;;
6176 *) # relative path
6177   cache_file_option="--cache-file=../${cache_file}" ;;
6178 esac
6179
6180 # Host dirs don't like to share a cache file either, horribly enough.
6181 # This seems to be due to autoconf 2.5x stupidity.
6182 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6183
6184 target_configargs=${baseargs}
6185
6186 # Passing a --with-cross-host argument lets the target libraries know
6187 # whether they are being built with a cross-compiler or being built
6188 # native.  However, it would be better to use other mechanisms to make the
6189 # sorts of decisions they want to make on this basis.  Please consider
6190 # this option to be deprecated.  FIXME.
6191 if test x${is_cross_compiler} = xyes ; then
6192   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6193 fi
6194
6195 # Default to --enable-multilib.
6196 if test x${enable_multilib} = x ; then
6197   target_configargs="--enable-multilib ${target_configargs}"
6198 fi
6199
6200 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6201 # changed from the earlier setting of with_newlib.
6202 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6203   target_configargs="--with-newlib ${target_configargs}"
6204 fi
6205
6206 # Different target subdirs use different values of certain variables
6207 # (notably CXX).  Worse, multilibs use *lots* of different values.
6208 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6209 # it doesn't automatically accept command-line overrides of them.
6210 # This means it's not safe for target subdirs to share a cache file,
6211 # which is disgusting, but there you have it.  Hopefully this can be
6212 # fixed in future.  It's still worthwhile to use a cache file for each
6213 # directory.  I think.
6214
6215 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6216 # We need to pass --target, as newer autoconf's requires consistency
6217 # for target_alias and gcc doesn't manage it consistently.
6218 target_configargs="--cache-file=./config.cache ${target_configargs}"
6219
6220 FLAGS_FOR_TARGET=
6221 case " $target_configdirs " in
6222  *" newlib "*)
6223   case " $target_configargs " in
6224   *" --with-newlib "*)
6225    case "$target" in
6226    *-cygwin*)
6227      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' ;;
6228    esac
6229
6230    # If we're not building GCC, don't discard standard headers.
6231    if test -d ${srcdir}/gcc; then
6232      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6233
6234      if test "${build}" != "${host}"; then
6235        # On Canadian crosses, CC_FOR_TARGET will have already been set
6236        # by `configure', so we won't have an opportunity to add -Bgcc/
6237        # to it.  This is right: we don't want to search that directory
6238        # for binaries, but we want the header files in there, so add
6239        # them explicitly.
6240        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6241
6242        # Someone might think of using the pre-installed headers on
6243        # Canadian crosses, in case the installed compiler is not fully
6244        # compatible with the compiler being built.  In this case, it
6245        # would be better to flag an error than risking having
6246        # incompatible object files being constructed.  We can't
6247        # guarantee that an error will be flagged, but let's hope the
6248        # compiler will do it, when presented with incompatible header
6249        # files.
6250      fi
6251    fi
6252
6253    case "${target}-${is_cross_compiler}" in
6254    i[3456789]86-*-linux*-no)
6255       # Here host == target, so we don't need to build gcc,
6256       # so we don't want to discard standard headers.
6257       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6258       ;;
6259    *)
6260       # If we're building newlib, use its generic headers last, but search
6261       # for any libc-related directories first (so make it the last -B
6262       # switch).
6263       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6264
6265       # If we're building libgloss, find the startup file, simulator library
6266       # and linker script.
6267       case " $target_configdirs " in
6268         *" libgloss "*)
6269         # Look for startup file, simulator library and maybe linker script.
6270         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6271         # Look for libnosys.a in case the target needs it.
6272         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6273         # Most targets have the linker script in the source directory.
6274         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6275         ;;
6276       esac
6277       ;;
6278    esac
6279    ;;
6280   esac
6281   ;;
6282 esac
6283 case "$target" in
6284 *-mingw*)
6285   # Can't be handled as Cygwin above since Mingw does not use newlib.
6286   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' ;;
6287 esac
6288
6289 # Allow the user to override the flags for
6290 # our build compiler if desired.
6291 if test x"${build}" = x"${host}" ; then
6292   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6293   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6294   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6295 fi
6296
6297 # On Canadian crosses, we'll be searching the right directories for
6298 # the previously-installed cross compiler, so don't bother to add
6299 # flags for directories within the install tree of the compiler
6300 # being built; programs in there won't even run.
6301 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6302   # Search for pre-installed headers if nothing else fits.
6303   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6304 fi
6305
6306 if test "x${use_gnu_ld}" = x &&
6307    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6308   # Arrange for us to find uninstalled linker scripts.
6309   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6310 fi
6311
6312 # Search for other target-specific linker scripts and such.
6313 case "${target}" in
6314   mep*)
6315     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6316     ;;
6317 esac
6318
6319 # Makefile fragments.
6320 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6321 do
6322   eval fragval=\$$frag
6323   if test $fragval != /dev/null; then
6324     eval $frag=${srcdir}/$fragval
6325   fi
6326 done
6327
6328
6329
6330
6331
6332 # Miscellanea: directories, flags, etc.
6333
6334
6335
6336
6337
6338
6339
6340
6341 # Build module lists & subconfigure args.
6342
6343
6344
6345 # Host module lists & subconfigure args.
6346
6347
6348
6349 # Target module lists & subconfigure args.
6350
6351
6352
6353 # Build tools.
6354
6355
6356
6357
6358
6359
6360
6361
6362
6363
6364
6365
6366
6367
6368
6369
6370
6371 # Generate default definitions for YACC, M4, LEX and other programs that run
6372 # on the build machine.  These are used if the Makefile can't locate these
6373 # programs in objdir.
6374 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6375
6376 for ac_prog in 'bison -y' byacc yacc
6377 do
6378   # Extract the first word of "$ac_prog", so it can be a program name with args.
6379 set dummy $ac_prog; ac_word=$2
6380 echo "$as_me:$LINENO: checking for $ac_word" >&5
6381 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6382 if test "${ac_cv_prog_YACC+set}" = set; then
6383   echo $ECHO_N "(cached) $ECHO_C" >&6
6384 else
6385   if test -n "$YACC"; then
6386   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6387 else
6388 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6389 for as_dir in $PATH
6390 do
6391   IFS=$as_save_IFS
6392   test -z "$as_dir" && as_dir=.
6393   for ac_exec_ext in '' $ac_executable_extensions; do
6394   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6395     ac_cv_prog_YACC="$ac_prog"
6396     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6397     break 2
6398   fi
6399 done
6400 done
6401
6402 fi
6403 fi
6404 YACC=$ac_cv_prog_YACC
6405 if test -n "$YACC"; then
6406   echo "$as_me:$LINENO: result: $YACC" >&5
6407 echo "${ECHO_T}$YACC" >&6
6408 else
6409   echo "$as_me:$LINENO: result: no" >&5
6410 echo "${ECHO_T}no" >&6
6411 fi
6412
6413   test -n "$YACC" && break
6414 done
6415 test -n "$YACC" || YACC="$MISSING bison -y"
6416
6417 case " $build_configdirs " in
6418   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6419   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6420 esac
6421
6422 for ac_prog in bison
6423 do
6424   # Extract the first word of "$ac_prog", so it can be a program name with args.
6425 set dummy $ac_prog; ac_word=$2
6426 echo "$as_me:$LINENO: checking for $ac_word" >&5
6427 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6428 if test "${ac_cv_prog_BISON+set}" = set; then
6429   echo $ECHO_N "(cached) $ECHO_C" >&6
6430 else
6431   if test -n "$BISON"; then
6432   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6433 else
6434 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6435 for as_dir in $PATH
6436 do
6437   IFS=$as_save_IFS
6438   test -z "$as_dir" && as_dir=.
6439   for ac_exec_ext in '' $ac_executable_extensions; do
6440   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6441     ac_cv_prog_BISON="$ac_prog"
6442     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6443     break 2
6444   fi
6445 done
6446 done
6447
6448 fi
6449 fi
6450 BISON=$ac_cv_prog_BISON
6451 if test -n "$BISON"; then
6452   echo "$as_me:$LINENO: result: $BISON" >&5
6453 echo "${ECHO_T}$BISON" >&6
6454 else
6455   echo "$as_me:$LINENO: result: no" >&5
6456 echo "${ECHO_T}no" >&6
6457 fi
6458
6459   test -n "$BISON" && break
6460 done
6461 test -n "$BISON" || BISON="$MISSING bison"
6462
6463 case " $build_configdirs " in
6464   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6465 esac
6466
6467 for ac_prog in gm4 gnum4 m4
6468 do
6469   # Extract the first word of "$ac_prog", so it can be a program name with args.
6470 set dummy $ac_prog; ac_word=$2
6471 echo "$as_me:$LINENO: checking for $ac_word" >&5
6472 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6473 if test "${ac_cv_prog_M4+set}" = set; then
6474   echo $ECHO_N "(cached) $ECHO_C" >&6
6475 else
6476   if test -n "$M4"; then
6477   ac_cv_prog_M4="$M4" # Let the user override the test.
6478 else
6479 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6480 for as_dir in $PATH
6481 do
6482   IFS=$as_save_IFS
6483   test -z "$as_dir" && as_dir=.
6484   for ac_exec_ext in '' $ac_executable_extensions; do
6485   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6486     ac_cv_prog_M4="$ac_prog"
6487     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6488     break 2
6489   fi
6490 done
6491 done
6492
6493 fi
6494 fi
6495 M4=$ac_cv_prog_M4
6496 if test -n "$M4"; then
6497   echo "$as_me:$LINENO: result: $M4" >&5
6498 echo "${ECHO_T}$M4" >&6
6499 else
6500   echo "$as_me:$LINENO: result: no" >&5
6501 echo "${ECHO_T}no" >&6
6502 fi
6503
6504   test -n "$M4" && break
6505 done
6506 test -n "$M4" || M4="$MISSING m4"
6507
6508 case " $build_configdirs " in
6509   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6510 esac
6511
6512 for ac_prog in flex lex
6513 do
6514   # Extract the first word of "$ac_prog", so it can be a program name with args.
6515 set dummy $ac_prog; ac_word=$2
6516 echo "$as_me:$LINENO: checking for $ac_word" >&5
6517 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6518 if test "${ac_cv_prog_LEX+set}" = set; then
6519   echo $ECHO_N "(cached) $ECHO_C" >&6
6520 else
6521   if test -n "$LEX"; then
6522   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6523 else
6524 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6525 for as_dir in $PATH
6526 do
6527   IFS=$as_save_IFS
6528   test -z "$as_dir" && as_dir=.
6529   for ac_exec_ext in '' $ac_executable_extensions; do
6530   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6531     ac_cv_prog_LEX="$ac_prog"
6532     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6533     break 2
6534   fi
6535 done
6536 done
6537
6538 fi
6539 fi
6540 LEX=$ac_cv_prog_LEX
6541 if test -n "$LEX"; then
6542   echo "$as_me:$LINENO: result: $LEX" >&5
6543 echo "${ECHO_T}$LEX" >&6
6544 else
6545   echo "$as_me:$LINENO: result: no" >&5
6546 echo "${ECHO_T}no" >&6
6547 fi
6548
6549   test -n "$LEX" && break
6550 done
6551 test -n "$LEX" || LEX="$MISSING flex"
6552
6553 case " $build_configdirs " in
6554   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6555   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6556 esac
6557
6558 for ac_prog in flex
6559 do
6560   # Extract the first word of "$ac_prog", so it can be a program name with args.
6561 set dummy $ac_prog; ac_word=$2
6562 echo "$as_me:$LINENO: checking for $ac_word" >&5
6563 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6564 if test "${ac_cv_prog_FLEX+set}" = set; then
6565   echo $ECHO_N "(cached) $ECHO_C" >&6
6566 else
6567   if test -n "$FLEX"; then
6568   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6569 else
6570 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6571 for as_dir in $PATH
6572 do
6573   IFS=$as_save_IFS
6574   test -z "$as_dir" && as_dir=.
6575   for ac_exec_ext in '' $ac_executable_extensions; do
6576   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6577     ac_cv_prog_FLEX="$ac_prog"
6578     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6579     break 2
6580   fi
6581 done
6582 done
6583
6584 fi
6585 fi
6586 FLEX=$ac_cv_prog_FLEX
6587 if test -n "$FLEX"; then
6588   echo "$as_me:$LINENO: result: $FLEX" >&5
6589 echo "${ECHO_T}$FLEX" >&6
6590 else
6591   echo "$as_me:$LINENO: result: no" >&5
6592 echo "${ECHO_T}no" >&6
6593 fi
6594
6595   test -n "$FLEX" && break
6596 done
6597 test -n "$FLEX" || FLEX="$MISSING flex"
6598
6599 case " $build_configdirs " in
6600   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6601 esac
6602
6603 for ac_prog in makeinfo
6604 do
6605   # Extract the first word of "$ac_prog", so it can be a program name with args.
6606 set dummy $ac_prog; ac_word=$2
6607 echo "$as_me:$LINENO: checking for $ac_word" >&5
6608 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6609 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6610   echo $ECHO_N "(cached) $ECHO_C" >&6
6611 else
6612   if test -n "$MAKEINFO"; then
6613   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6614 else
6615 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6616 for as_dir in $PATH
6617 do
6618   IFS=$as_save_IFS
6619   test -z "$as_dir" && as_dir=.
6620   for ac_exec_ext in '' $ac_executable_extensions; do
6621   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6622     ac_cv_prog_MAKEINFO="$ac_prog"
6623     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6624     break 2
6625   fi
6626 done
6627 done
6628
6629 fi
6630 fi
6631 MAKEINFO=$ac_cv_prog_MAKEINFO
6632 if test -n "$MAKEINFO"; then
6633   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6634 echo "${ECHO_T}$MAKEINFO" >&6
6635 else
6636   echo "$as_me:$LINENO: result: no" >&5
6637 echo "${ECHO_T}no" >&6
6638 fi
6639
6640   test -n "$MAKEINFO" && break
6641 done
6642 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6643
6644 case " $build_configdirs " in
6645   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6646   *)
6647
6648     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6649     # higher, else we use the "missing" dummy.
6650     if ${MAKEINFO} --version \
6651        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6652       :
6653     else
6654       MAKEINFO="$MISSING makeinfo"
6655     fi
6656     ;;
6657
6658 esac
6659
6660 # FIXME: expect and dejagnu may become build tools?
6661
6662 for ac_prog in expect
6663 do
6664   # Extract the first word of "$ac_prog", so it can be a program name with args.
6665 set dummy $ac_prog; ac_word=$2
6666 echo "$as_me:$LINENO: checking for $ac_word" >&5
6667 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6668 if test "${ac_cv_prog_EXPECT+set}" = set; then
6669   echo $ECHO_N "(cached) $ECHO_C" >&6
6670 else
6671   if test -n "$EXPECT"; then
6672   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6673 else
6674 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6675 for as_dir in $PATH
6676 do
6677   IFS=$as_save_IFS
6678   test -z "$as_dir" && as_dir=.
6679   for ac_exec_ext in '' $ac_executable_extensions; do
6680   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6681     ac_cv_prog_EXPECT="$ac_prog"
6682     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6683     break 2
6684   fi
6685 done
6686 done
6687
6688 fi
6689 fi
6690 EXPECT=$ac_cv_prog_EXPECT
6691 if test -n "$EXPECT"; then
6692   echo "$as_me:$LINENO: result: $EXPECT" >&5
6693 echo "${ECHO_T}$EXPECT" >&6
6694 else
6695   echo "$as_me:$LINENO: result: no" >&5
6696 echo "${ECHO_T}no" >&6
6697 fi
6698
6699   test -n "$EXPECT" && break
6700 done
6701 test -n "$EXPECT" || EXPECT="expect"
6702
6703 case " $configdirs " in
6704   *" expect "*)
6705     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6706     ;;
6707 esac
6708
6709 for ac_prog in runtest
6710 do
6711   # Extract the first word of "$ac_prog", so it can be a program name with args.
6712 set dummy $ac_prog; ac_word=$2
6713 echo "$as_me:$LINENO: checking for $ac_word" >&5
6714 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6715 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6716   echo $ECHO_N "(cached) $ECHO_C" >&6
6717 else
6718   if test -n "$RUNTEST"; then
6719   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6720 else
6721 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6722 for as_dir in $PATH
6723 do
6724   IFS=$as_save_IFS
6725   test -z "$as_dir" && as_dir=.
6726   for ac_exec_ext in '' $ac_executable_extensions; do
6727   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6728     ac_cv_prog_RUNTEST="$ac_prog"
6729     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6730     break 2
6731   fi
6732 done
6733 done
6734
6735 fi
6736 fi
6737 RUNTEST=$ac_cv_prog_RUNTEST
6738 if test -n "$RUNTEST"; then
6739   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6740 echo "${ECHO_T}$RUNTEST" >&6
6741 else
6742   echo "$as_me:$LINENO: result: no" >&5
6743 echo "${ECHO_T}no" >&6
6744 fi
6745
6746   test -n "$RUNTEST" && break
6747 done
6748 test -n "$RUNTEST" || RUNTEST="runtest"
6749
6750 case " $configdirs " in
6751   *" dejagnu "*)
6752     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6753     ;;
6754 esac
6755
6756
6757 # Host tools.
6758 ncn_tool_prefix=
6759 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6760 ncn_target_tool_prefix=
6761 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6762
6763
6764
6765 if test -n "$AR"; then
6766   ac_cv_prog_AR=$AR
6767 elif test -n "$ac_cv_prog_AR"; then
6768   AR=$ac_cv_prog_AR
6769 fi
6770
6771 if test -n "$ac_cv_prog_AR"; then
6772   for ncn_progname in ar; do
6773     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6774 set dummy ${ncn_progname}; ac_word=$2
6775 echo "$as_me:$LINENO: checking for $ac_word" >&5
6776 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6777 if test "${ac_cv_prog_AR+set}" = set; then
6778   echo $ECHO_N "(cached) $ECHO_C" >&6
6779 else
6780   if test -n "$AR"; then
6781   ac_cv_prog_AR="$AR" # Let the user override the test.
6782 else
6783 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6784 for as_dir in $PATH
6785 do
6786   IFS=$as_save_IFS
6787   test -z "$as_dir" && as_dir=.
6788   for ac_exec_ext in '' $ac_executable_extensions; do
6789   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6790     ac_cv_prog_AR="${ncn_progname}"
6791     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6792     break 2
6793   fi
6794 done
6795 done
6796
6797 fi
6798 fi
6799 AR=$ac_cv_prog_AR
6800 if test -n "$AR"; then
6801   echo "$as_me:$LINENO: result: $AR" >&5
6802 echo "${ECHO_T}$AR" >&6
6803 else
6804   echo "$as_me:$LINENO: result: no" >&5
6805 echo "${ECHO_T}no" >&6
6806 fi
6807
6808   done
6809 fi
6810
6811 for ncn_progname in ar; do
6812   if test -n "$ncn_tool_prefix"; then
6813     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6814 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6815 echo "$as_me:$LINENO: checking for $ac_word" >&5
6816 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6817 if test "${ac_cv_prog_AR+set}" = set; then
6818   echo $ECHO_N "(cached) $ECHO_C" >&6
6819 else
6820   if test -n "$AR"; then
6821   ac_cv_prog_AR="$AR" # Let the user override the test.
6822 else
6823 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6824 for as_dir in $PATH
6825 do
6826   IFS=$as_save_IFS
6827   test -z "$as_dir" && as_dir=.
6828   for ac_exec_ext in '' $ac_executable_extensions; do
6829   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6830     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6831     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6832     break 2
6833   fi
6834 done
6835 done
6836
6837 fi
6838 fi
6839 AR=$ac_cv_prog_AR
6840 if test -n "$AR"; then
6841   echo "$as_me:$LINENO: result: $AR" >&5
6842 echo "${ECHO_T}$AR" >&6
6843 else
6844   echo "$as_me:$LINENO: result: no" >&5
6845 echo "${ECHO_T}no" >&6
6846 fi
6847
6848   fi
6849   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6850     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6851 set dummy ${ncn_progname}; ac_word=$2
6852 echo "$as_me:$LINENO: checking for $ac_word" >&5
6853 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6854 if test "${ac_cv_prog_AR+set}" = set; then
6855   echo $ECHO_N "(cached) $ECHO_C" >&6
6856 else
6857   if test -n "$AR"; then
6858   ac_cv_prog_AR="$AR" # Let the user override the test.
6859 else
6860 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6861 for as_dir in $PATH
6862 do
6863   IFS=$as_save_IFS
6864   test -z "$as_dir" && as_dir=.
6865   for ac_exec_ext in '' $ac_executable_extensions; do
6866   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6867     ac_cv_prog_AR="${ncn_progname}"
6868     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6869     break 2
6870   fi
6871 done
6872 done
6873
6874 fi
6875 fi
6876 AR=$ac_cv_prog_AR
6877 if test -n "$AR"; then
6878   echo "$as_me:$LINENO: result: $AR" >&5
6879 echo "${ECHO_T}$AR" >&6
6880 else
6881   echo "$as_me:$LINENO: result: no" >&5
6882 echo "${ECHO_T}no" >&6
6883 fi
6884
6885   fi
6886   test -n "$ac_cv_prog_AR" && break
6887 done
6888
6889 if test -z "$ac_cv_prog_AR" ; then
6890   set dummy ar
6891   if test $build = $host ; then
6892     AR="$2"
6893   else
6894     AR="${ncn_tool_prefix}$2"
6895   fi
6896 fi
6897
6898
6899
6900 if test -n "$AS"; then
6901   ac_cv_prog_AS=$AS
6902 elif test -n "$ac_cv_prog_AS"; then
6903   AS=$ac_cv_prog_AS
6904 fi
6905
6906 if test -n "$ac_cv_prog_AS"; then
6907   for ncn_progname in as; do
6908     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6909 set dummy ${ncn_progname}; ac_word=$2
6910 echo "$as_me:$LINENO: checking for $ac_word" >&5
6911 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6912 if test "${ac_cv_prog_AS+set}" = set; then
6913   echo $ECHO_N "(cached) $ECHO_C" >&6
6914 else
6915   if test -n "$AS"; then
6916   ac_cv_prog_AS="$AS" # Let the user override the test.
6917 else
6918 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6919 for as_dir in $PATH
6920 do
6921   IFS=$as_save_IFS
6922   test -z "$as_dir" && as_dir=.
6923   for ac_exec_ext in '' $ac_executable_extensions; do
6924   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6925     ac_cv_prog_AS="${ncn_progname}"
6926     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6927     break 2
6928   fi
6929 done
6930 done
6931
6932 fi
6933 fi
6934 AS=$ac_cv_prog_AS
6935 if test -n "$AS"; then
6936   echo "$as_me:$LINENO: result: $AS" >&5
6937 echo "${ECHO_T}$AS" >&6
6938 else
6939   echo "$as_me:$LINENO: result: no" >&5
6940 echo "${ECHO_T}no" >&6
6941 fi
6942
6943   done
6944 fi
6945
6946 for ncn_progname in as; do
6947   if test -n "$ncn_tool_prefix"; then
6948     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6949 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6950 echo "$as_me:$LINENO: checking for $ac_word" >&5
6951 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6952 if test "${ac_cv_prog_AS+set}" = set; then
6953   echo $ECHO_N "(cached) $ECHO_C" >&6
6954 else
6955   if test -n "$AS"; then
6956   ac_cv_prog_AS="$AS" # Let the user override the test.
6957 else
6958 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6959 for as_dir in $PATH
6960 do
6961   IFS=$as_save_IFS
6962   test -z "$as_dir" && as_dir=.
6963   for ac_exec_ext in '' $ac_executable_extensions; do
6964   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6965     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6966     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6967     break 2
6968   fi
6969 done
6970 done
6971
6972 fi
6973 fi
6974 AS=$ac_cv_prog_AS
6975 if test -n "$AS"; then
6976   echo "$as_me:$LINENO: result: $AS" >&5
6977 echo "${ECHO_T}$AS" >&6
6978 else
6979   echo "$as_me:$LINENO: result: no" >&5
6980 echo "${ECHO_T}no" >&6
6981 fi
6982
6983   fi
6984   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6985     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6986 set dummy ${ncn_progname}; ac_word=$2
6987 echo "$as_me:$LINENO: checking for $ac_word" >&5
6988 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6989 if test "${ac_cv_prog_AS+set}" = set; then
6990   echo $ECHO_N "(cached) $ECHO_C" >&6
6991 else
6992   if test -n "$AS"; then
6993   ac_cv_prog_AS="$AS" # Let the user override the test.
6994 else
6995 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6996 for as_dir in $PATH
6997 do
6998   IFS=$as_save_IFS
6999   test -z "$as_dir" && as_dir=.
7000   for ac_exec_ext in '' $ac_executable_extensions; do
7001   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7002     ac_cv_prog_AS="${ncn_progname}"
7003     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7004     break 2
7005   fi
7006 done
7007 done
7008
7009 fi
7010 fi
7011 AS=$ac_cv_prog_AS
7012 if test -n "$AS"; then
7013   echo "$as_me:$LINENO: result: $AS" >&5
7014 echo "${ECHO_T}$AS" >&6
7015 else
7016   echo "$as_me:$LINENO: result: no" >&5
7017 echo "${ECHO_T}no" >&6
7018 fi
7019
7020   fi
7021   test -n "$ac_cv_prog_AS" && break
7022 done
7023
7024 if test -z "$ac_cv_prog_AS" ; then
7025   set dummy as
7026   if test $build = $host ; then
7027     AS="$2"
7028   else
7029     AS="${ncn_tool_prefix}$2"
7030   fi
7031 fi
7032
7033
7034
7035 if test -n "$DLLTOOL"; then
7036   ac_cv_prog_DLLTOOL=$DLLTOOL
7037 elif test -n "$ac_cv_prog_DLLTOOL"; then
7038   DLLTOOL=$ac_cv_prog_DLLTOOL
7039 fi
7040
7041 if test -n "$ac_cv_prog_DLLTOOL"; then
7042   for ncn_progname in dlltool; do
7043     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7044 set dummy ${ncn_progname}; ac_word=$2
7045 echo "$as_me:$LINENO: checking for $ac_word" >&5
7046 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7047 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7048   echo $ECHO_N "(cached) $ECHO_C" >&6
7049 else
7050   if test -n "$DLLTOOL"; then
7051   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7052 else
7053 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7054 for as_dir in $PATH
7055 do
7056   IFS=$as_save_IFS
7057   test -z "$as_dir" && as_dir=.
7058   for ac_exec_ext in '' $ac_executable_extensions; do
7059   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7060     ac_cv_prog_DLLTOOL="${ncn_progname}"
7061     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7062     break 2
7063   fi
7064 done
7065 done
7066
7067 fi
7068 fi
7069 DLLTOOL=$ac_cv_prog_DLLTOOL
7070 if test -n "$DLLTOOL"; then
7071   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7072 echo "${ECHO_T}$DLLTOOL" >&6
7073 else
7074   echo "$as_me:$LINENO: result: no" >&5
7075 echo "${ECHO_T}no" >&6
7076 fi
7077
7078   done
7079 fi
7080
7081 for ncn_progname in dlltool; do
7082   if test -n "$ncn_tool_prefix"; then
7083     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7084 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7085 echo "$as_me:$LINENO: checking for $ac_word" >&5
7086 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7087 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7088   echo $ECHO_N "(cached) $ECHO_C" >&6
7089 else
7090   if test -n "$DLLTOOL"; then
7091   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7092 else
7093 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7094 for as_dir in $PATH
7095 do
7096   IFS=$as_save_IFS
7097   test -z "$as_dir" && as_dir=.
7098   for ac_exec_ext in '' $ac_executable_extensions; do
7099   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7100     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7101     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7102     break 2
7103   fi
7104 done
7105 done
7106
7107 fi
7108 fi
7109 DLLTOOL=$ac_cv_prog_DLLTOOL
7110 if test -n "$DLLTOOL"; then
7111   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7112 echo "${ECHO_T}$DLLTOOL" >&6
7113 else
7114   echo "$as_me:$LINENO: result: no" >&5
7115 echo "${ECHO_T}no" >&6
7116 fi
7117
7118   fi
7119   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7120     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7121 set dummy ${ncn_progname}; ac_word=$2
7122 echo "$as_me:$LINENO: checking for $ac_word" >&5
7123 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7124 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7125   echo $ECHO_N "(cached) $ECHO_C" >&6
7126 else
7127   if test -n "$DLLTOOL"; then
7128   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7129 else
7130 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7131 for as_dir in $PATH
7132 do
7133   IFS=$as_save_IFS
7134   test -z "$as_dir" && as_dir=.
7135   for ac_exec_ext in '' $ac_executable_extensions; do
7136   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7137     ac_cv_prog_DLLTOOL="${ncn_progname}"
7138     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7139     break 2
7140   fi
7141 done
7142 done
7143
7144 fi
7145 fi
7146 DLLTOOL=$ac_cv_prog_DLLTOOL
7147 if test -n "$DLLTOOL"; then
7148   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7149 echo "${ECHO_T}$DLLTOOL" >&6
7150 else
7151   echo "$as_me:$LINENO: result: no" >&5
7152 echo "${ECHO_T}no" >&6
7153 fi
7154
7155   fi
7156   test -n "$ac_cv_prog_DLLTOOL" && break
7157 done
7158
7159 if test -z "$ac_cv_prog_DLLTOOL" ; then
7160   set dummy dlltool
7161   if test $build = $host ; then
7162     DLLTOOL="$2"
7163   else
7164     DLLTOOL="${ncn_tool_prefix}$2"
7165   fi
7166 fi
7167
7168
7169
7170 if test -n "$LD"; then
7171   ac_cv_prog_LD=$LD
7172 elif test -n "$ac_cv_prog_LD"; then
7173   LD=$ac_cv_prog_LD
7174 fi
7175
7176 if test -n "$ac_cv_prog_LD"; then
7177   for ncn_progname in ld; do
7178     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7179 set dummy ${ncn_progname}; ac_word=$2
7180 echo "$as_me:$LINENO: checking for $ac_word" >&5
7181 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7182 if test "${ac_cv_prog_LD+set}" = set; then
7183   echo $ECHO_N "(cached) $ECHO_C" >&6
7184 else
7185   if test -n "$LD"; then
7186   ac_cv_prog_LD="$LD" # Let the user override the test.
7187 else
7188 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7189 for as_dir in $PATH
7190 do
7191   IFS=$as_save_IFS
7192   test -z "$as_dir" && as_dir=.
7193   for ac_exec_ext in '' $ac_executable_extensions; do
7194   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7195     ac_cv_prog_LD="${ncn_progname}"
7196     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7197     break 2
7198   fi
7199 done
7200 done
7201
7202 fi
7203 fi
7204 LD=$ac_cv_prog_LD
7205 if test -n "$LD"; then
7206   echo "$as_me:$LINENO: result: $LD" >&5
7207 echo "${ECHO_T}$LD" >&6
7208 else
7209   echo "$as_me:$LINENO: result: no" >&5
7210 echo "${ECHO_T}no" >&6
7211 fi
7212
7213   done
7214 fi
7215
7216 for ncn_progname in ld; do
7217   if test -n "$ncn_tool_prefix"; then
7218     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7219 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7220 echo "$as_me:$LINENO: checking for $ac_word" >&5
7221 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7222 if test "${ac_cv_prog_LD+set}" = set; then
7223   echo $ECHO_N "(cached) $ECHO_C" >&6
7224 else
7225   if test -n "$LD"; then
7226   ac_cv_prog_LD="$LD" # Let the user override the test.
7227 else
7228 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7229 for as_dir in $PATH
7230 do
7231   IFS=$as_save_IFS
7232   test -z "$as_dir" && as_dir=.
7233   for ac_exec_ext in '' $ac_executable_extensions; do
7234   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7235     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7236     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7237     break 2
7238   fi
7239 done
7240 done
7241
7242 fi
7243 fi
7244 LD=$ac_cv_prog_LD
7245 if test -n "$LD"; then
7246   echo "$as_me:$LINENO: result: $LD" >&5
7247 echo "${ECHO_T}$LD" >&6
7248 else
7249   echo "$as_me:$LINENO: result: no" >&5
7250 echo "${ECHO_T}no" >&6
7251 fi
7252
7253   fi
7254   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7255     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7256 set dummy ${ncn_progname}; ac_word=$2
7257 echo "$as_me:$LINENO: checking for $ac_word" >&5
7258 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7259 if test "${ac_cv_prog_LD+set}" = set; then
7260   echo $ECHO_N "(cached) $ECHO_C" >&6
7261 else
7262   if test -n "$LD"; then
7263   ac_cv_prog_LD="$LD" # Let the user override the test.
7264 else
7265 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7266 for as_dir in $PATH
7267 do
7268   IFS=$as_save_IFS
7269   test -z "$as_dir" && as_dir=.
7270   for ac_exec_ext in '' $ac_executable_extensions; do
7271   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7272     ac_cv_prog_LD="${ncn_progname}"
7273     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7274     break 2
7275   fi
7276 done
7277 done
7278
7279 fi
7280 fi
7281 LD=$ac_cv_prog_LD
7282 if test -n "$LD"; then
7283   echo "$as_me:$LINENO: result: $LD" >&5
7284 echo "${ECHO_T}$LD" >&6
7285 else
7286   echo "$as_me:$LINENO: result: no" >&5
7287 echo "${ECHO_T}no" >&6
7288 fi
7289
7290   fi
7291   test -n "$ac_cv_prog_LD" && break
7292 done
7293
7294 if test -z "$ac_cv_prog_LD" ; then
7295   set dummy ld
7296   if test $build = $host ; then
7297     LD="$2"
7298   else
7299     LD="${ncn_tool_prefix}$2"
7300   fi
7301 fi
7302
7303
7304
7305 if test -n "$LIPO"; then
7306   ac_cv_prog_LIPO=$LIPO
7307 elif test -n "$ac_cv_prog_LIPO"; then
7308   LIPO=$ac_cv_prog_LIPO
7309 fi
7310
7311 if test -n "$ac_cv_prog_LIPO"; then
7312   for ncn_progname in lipo; do
7313     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7314 set dummy ${ncn_progname}; ac_word=$2
7315 echo "$as_me:$LINENO: checking for $ac_word" >&5
7316 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7317 if test "${ac_cv_prog_LIPO+set}" = set; then
7318   echo $ECHO_N "(cached) $ECHO_C" >&6
7319 else
7320   if test -n "$LIPO"; then
7321   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7322 else
7323 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7324 for as_dir in $PATH
7325 do
7326   IFS=$as_save_IFS
7327   test -z "$as_dir" && as_dir=.
7328   for ac_exec_ext in '' $ac_executable_extensions; do
7329   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7330     ac_cv_prog_LIPO="${ncn_progname}"
7331     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7332     break 2
7333   fi
7334 done
7335 done
7336
7337 fi
7338 fi
7339 LIPO=$ac_cv_prog_LIPO
7340 if test -n "$LIPO"; then
7341   echo "$as_me:$LINENO: result: $LIPO" >&5
7342 echo "${ECHO_T}$LIPO" >&6
7343 else
7344   echo "$as_me:$LINENO: result: no" >&5
7345 echo "${ECHO_T}no" >&6
7346 fi
7347
7348   done
7349 fi
7350
7351 for ncn_progname in lipo; do
7352   if test -n "$ncn_tool_prefix"; then
7353     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7354 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7355 echo "$as_me:$LINENO: checking for $ac_word" >&5
7356 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7357 if test "${ac_cv_prog_LIPO+set}" = set; then
7358   echo $ECHO_N "(cached) $ECHO_C" >&6
7359 else
7360   if test -n "$LIPO"; then
7361   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7362 else
7363 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7364 for as_dir in $PATH
7365 do
7366   IFS=$as_save_IFS
7367   test -z "$as_dir" && as_dir=.
7368   for ac_exec_ext in '' $ac_executable_extensions; do
7369   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7370     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7371     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7372     break 2
7373   fi
7374 done
7375 done
7376
7377 fi
7378 fi
7379 LIPO=$ac_cv_prog_LIPO
7380 if test -n "$LIPO"; then
7381   echo "$as_me:$LINENO: result: $LIPO" >&5
7382 echo "${ECHO_T}$LIPO" >&6
7383 else
7384   echo "$as_me:$LINENO: result: no" >&5
7385 echo "${ECHO_T}no" >&6
7386 fi
7387
7388   fi
7389   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7390     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7391 set dummy ${ncn_progname}; ac_word=$2
7392 echo "$as_me:$LINENO: checking for $ac_word" >&5
7393 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7394 if test "${ac_cv_prog_LIPO+set}" = set; then
7395   echo $ECHO_N "(cached) $ECHO_C" >&6
7396 else
7397   if test -n "$LIPO"; then
7398   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7399 else
7400 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7401 for as_dir in $PATH
7402 do
7403   IFS=$as_save_IFS
7404   test -z "$as_dir" && as_dir=.
7405   for ac_exec_ext in '' $ac_executable_extensions; do
7406   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7407     ac_cv_prog_LIPO="${ncn_progname}"
7408     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7409     break 2
7410   fi
7411 done
7412 done
7413
7414 fi
7415 fi
7416 LIPO=$ac_cv_prog_LIPO
7417 if test -n "$LIPO"; then
7418   echo "$as_me:$LINENO: result: $LIPO" >&5
7419 echo "${ECHO_T}$LIPO" >&6
7420 else
7421   echo "$as_me:$LINENO: result: no" >&5
7422 echo "${ECHO_T}no" >&6
7423 fi
7424
7425   fi
7426   test -n "$ac_cv_prog_LIPO" && break
7427 done
7428
7429 if test -z "$ac_cv_prog_LIPO" ; then
7430   set dummy lipo
7431   if test $build = $host ; then
7432     LIPO="$2"
7433   else
7434     LIPO="${ncn_tool_prefix}$2"
7435   fi
7436 fi
7437
7438
7439
7440 if test -n "$NM"; then
7441   ac_cv_prog_NM=$NM
7442 elif test -n "$ac_cv_prog_NM"; then
7443   NM=$ac_cv_prog_NM
7444 fi
7445
7446 if test -n "$ac_cv_prog_NM"; then
7447   for ncn_progname in nm; do
7448     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7449 set dummy ${ncn_progname}; ac_word=$2
7450 echo "$as_me:$LINENO: checking for $ac_word" >&5
7451 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7452 if test "${ac_cv_prog_NM+set}" = set; then
7453   echo $ECHO_N "(cached) $ECHO_C" >&6
7454 else
7455   if test -n "$NM"; then
7456   ac_cv_prog_NM="$NM" # Let the user override the test.
7457 else
7458 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7459 for as_dir in $PATH
7460 do
7461   IFS=$as_save_IFS
7462   test -z "$as_dir" && as_dir=.
7463   for ac_exec_ext in '' $ac_executable_extensions; do
7464   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7465     ac_cv_prog_NM="${ncn_progname}"
7466     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7467     break 2
7468   fi
7469 done
7470 done
7471
7472 fi
7473 fi
7474 NM=$ac_cv_prog_NM
7475 if test -n "$NM"; then
7476   echo "$as_me:$LINENO: result: $NM" >&5
7477 echo "${ECHO_T}$NM" >&6
7478 else
7479   echo "$as_me:$LINENO: result: no" >&5
7480 echo "${ECHO_T}no" >&6
7481 fi
7482
7483   done
7484 fi
7485
7486 for ncn_progname in nm; do
7487   if test -n "$ncn_tool_prefix"; then
7488     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7489 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7490 echo "$as_me:$LINENO: checking for $ac_word" >&5
7491 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7492 if test "${ac_cv_prog_NM+set}" = set; then
7493   echo $ECHO_N "(cached) $ECHO_C" >&6
7494 else
7495   if test -n "$NM"; then
7496   ac_cv_prog_NM="$NM" # Let the user override the test.
7497 else
7498 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7499 for as_dir in $PATH
7500 do
7501   IFS=$as_save_IFS
7502   test -z "$as_dir" && as_dir=.
7503   for ac_exec_ext in '' $ac_executable_extensions; do
7504   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7505     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7506     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7507     break 2
7508   fi
7509 done
7510 done
7511
7512 fi
7513 fi
7514 NM=$ac_cv_prog_NM
7515 if test -n "$NM"; then
7516   echo "$as_me:$LINENO: result: $NM" >&5
7517 echo "${ECHO_T}$NM" >&6
7518 else
7519   echo "$as_me:$LINENO: result: no" >&5
7520 echo "${ECHO_T}no" >&6
7521 fi
7522
7523   fi
7524   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7525     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7526 set dummy ${ncn_progname}; ac_word=$2
7527 echo "$as_me:$LINENO: checking for $ac_word" >&5
7528 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7529 if test "${ac_cv_prog_NM+set}" = set; then
7530   echo $ECHO_N "(cached) $ECHO_C" >&6
7531 else
7532   if test -n "$NM"; then
7533   ac_cv_prog_NM="$NM" # Let the user override the test.
7534 else
7535 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7536 for as_dir in $PATH
7537 do
7538   IFS=$as_save_IFS
7539   test -z "$as_dir" && as_dir=.
7540   for ac_exec_ext in '' $ac_executable_extensions; do
7541   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7542     ac_cv_prog_NM="${ncn_progname}"
7543     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7544     break 2
7545   fi
7546 done
7547 done
7548
7549 fi
7550 fi
7551 NM=$ac_cv_prog_NM
7552 if test -n "$NM"; then
7553   echo "$as_me:$LINENO: result: $NM" >&5
7554 echo "${ECHO_T}$NM" >&6
7555 else
7556   echo "$as_me:$LINENO: result: no" >&5
7557 echo "${ECHO_T}no" >&6
7558 fi
7559
7560   fi
7561   test -n "$ac_cv_prog_NM" && break
7562 done
7563
7564 if test -z "$ac_cv_prog_NM" ; then
7565   set dummy nm
7566   if test $build = $host ; then
7567     NM="$2"
7568   else
7569     NM="${ncn_tool_prefix}$2"
7570   fi
7571 fi
7572
7573
7574
7575 if test -n "$RANLIB"; then
7576   ac_cv_prog_RANLIB=$RANLIB
7577 elif test -n "$ac_cv_prog_RANLIB"; then
7578   RANLIB=$ac_cv_prog_RANLIB
7579 fi
7580
7581 if test -n "$ac_cv_prog_RANLIB"; then
7582   for ncn_progname in ranlib; do
7583     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7584 set dummy ${ncn_progname}; ac_word=$2
7585 echo "$as_me:$LINENO: checking for $ac_word" >&5
7586 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7587 if test "${ac_cv_prog_RANLIB+set}" = set; then
7588   echo $ECHO_N "(cached) $ECHO_C" >&6
7589 else
7590   if test -n "$RANLIB"; then
7591   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7592 else
7593 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7594 for as_dir in $PATH
7595 do
7596   IFS=$as_save_IFS
7597   test -z "$as_dir" && as_dir=.
7598   for ac_exec_ext in '' $ac_executable_extensions; do
7599   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7600     ac_cv_prog_RANLIB="${ncn_progname}"
7601     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7602     break 2
7603   fi
7604 done
7605 done
7606
7607 fi
7608 fi
7609 RANLIB=$ac_cv_prog_RANLIB
7610 if test -n "$RANLIB"; then
7611   echo "$as_me:$LINENO: result: $RANLIB" >&5
7612 echo "${ECHO_T}$RANLIB" >&6
7613 else
7614   echo "$as_me:$LINENO: result: no" >&5
7615 echo "${ECHO_T}no" >&6
7616 fi
7617
7618   done
7619 fi
7620
7621 for ncn_progname in ranlib; do
7622   if test -n "$ncn_tool_prefix"; then
7623     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7624 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7625 echo "$as_me:$LINENO: checking for $ac_word" >&5
7626 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7627 if test "${ac_cv_prog_RANLIB+set}" = set; then
7628   echo $ECHO_N "(cached) $ECHO_C" >&6
7629 else
7630   if test -n "$RANLIB"; then
7631   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7632 else
7633 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7634 for as_dir in $PATH
7635 do
7636   IFS=$as_save_IFS
7637   test -z "$as_dir" && as_dir=.
7638   for ac_exec_ext in '' $ac_executable_extensions; do
7639   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7640     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7641     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7642     break 2
7643   fi
7644 done
7645 done
7646
7647 fi
7648 fi
7649 RANLIB=$ac_cv_prog_RANLIB
7650 if test -n "$RANLIB"; then
7651   echo "$as_me:$LINENO: result: $RANLIB" >&5
7652 echo "${ECHO_T}$RANLIB" >&6
7653 else
7654   echo "$as_me:$LINENO: result: no" >&5
7655 echo "${ECHO_T}no" >&6
7656 fi
7657
7658   fi
7659   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7660     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7661 set dummy ${ncn_progname}; ac_word=$2
7662 echo "$as_me:$LINENO: checking for $ac_word" >&5
7663 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7664 if test "${ac_cv_prog_RANLIB+set}" = set; then
7665   echo $ECHO_N "(cached) $ECHO_C" >&6
7666 else
7667   if test -n "$RANLIB"; then
7668   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7669 else
7670 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7671 for as_dir in $PATH
7672 do
7673   IFS=$as_save_IFS
7674   test -z "$as_dir" && as_dir=.
7675   for ac_exec_ext in '' $ac_executable_extensions; do
7676   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7677     ac_cv_prog_RANLIB="${ncn_progname}"
7678     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7679     break 2
7680   fi
7681 done
7682 done
7683
7684 fi
7685 fi
7686 RANLIB=$ac_cv_prog_RANLIB
7687 if test -n "$RANLIB"; then
7688   echo "$as_me:$LINENO: result: $RANLIB" >&5
7689 echo "${ECHO_T}$RANLIB" >&6
7690 else
7691   echo "$as_me:$LINENO: result: no" >&5
7692 echo "${ECHO_T}no" >&6
7693 fi
7694
7695   fi
7696   test -n "$ac_cv_prog_RANLIB" && break
7697 done
7698
7699 if test -z "$ac_cv_prog_RANLIB" ; then
7700   RANLIB=":"
7701 fi
7702
7703
7704
7705 if test -n "$STRIP"; then
7706   ac_cv_prog_STRIP=$STRIP
7707 elif test -n "$ac_cv_prog_STRIP"; then
7708   STRIP=$ac_cv_prog_STRIP
7709 fi
7710
7711 if test -n "$ac_cv_prog_STRIP"; then
7712   for ncn_progname in strip; do
7713     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7714 set dummy ${ncn_progname}; ac_word=$2
7715 echo "$as_me:$LINENO: checking for $ac_word" >&5
7716 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7717 if test "${ac_cv_prog_STRIP+set}" = set; then
7718   echo $ECHO_N "(cached) $ECHO_C" >&6
7719 else
7720   if test -n "$STRIP"; then
7721   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7722 else
7723 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7724 for as_dir in $PATH
7725 do
7726   IFS=$as_save_IFS
7727   test -z "$as_dir" && as_dir=.
7728   for ac_exec_ext in '' $ac_executable_extensions; do
7729   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7730     ac_cv_prog_STRIP="${ncn_progname}"
7731     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7732     break 2
7733   fi
7734 done
7735 done
7736
7737 fi
7738 fi
7739 STRIP=$ac_cv_prog_STRIP
7740 if test -n "$STRIP"; then
7741   echo "$as_me:$LINENO: result: $STRIP" >&5
7742 echo "${ECHO_T}$STRIP" >&6
7743 else
7744   echo "$as_me:$LINENO: result: no" >&5
7745 echo "${ECHO_T}no" >&6
7746 fi
7747
7748   done
7749 fi
7750
7751 for ncn_progname in strip; do
7752   if test -n "$ncn_tool_prefix"; then
7753     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7754 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7755 echo "$as_me:$LINENO: checking for $ac_word" >&5
7756 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7757 if test "${ac_cv_prog_STRIP+set}" = set; then
7758   echo $ECHO_N "(cached) $ECHO_C" >&6
7759 else
7760   if test -n "$STRIP"; then
7761   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7762 else
7763 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7764 for as_dir in $PATH
7765 do
7766   IFS=$as_save_IFS
7767   test -z "$as_dir" && as_dir=.
7768   for ac_exec_ext in '' $ac_executable_extensions; do
7769   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7770     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7771     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7772     break 2
7773   fi
7774 done
7775 done
7776
7777 fi
7778 fi
7779 STRIP=$ac_cv_prog_STRIP
7780 if test -n "$STRIP"; then
7781   echo "$as_me:$LINENO: result: $STRIP" >&5
7782 echo "${ECHO_T}$STRIP" >&6
7783 else
7784   echo "$as_me:$LINENO: result: no" >&5
7785 echo "${ECHO_T}no" >&6
7786 fi
7787
7788   fi
7789   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7790     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7791 set dummy ${ncn_progname}; ac_word=$2
7792 echo "$as_me:$LINENO: checking for $ac_word" >&5
7793 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7794 if test "${ac_cv_prog_STRIP+set}" = set; then
7795   echo $ECHO_N "(cached) $ECHO_C" >&6
7796 else
7797   if test -n "$STRIP"; then
7798   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7799 else
7800 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7801 for as_dir in $PATH
7802 do
7803   IFS=$as_save_IFS
7804   test -z "$as_dir" && as_dir=.
7805   for ac_exec_ext in '' $ac_executable_extensions; do
7806   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7807     ac_cv_prog_STRIP="${ncn_progname}"
7808     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7809     break 2
7810   fi
7811 done
7812 done
7813
7814 fi
7815 fi
7816 STRIP=$ac_cv_prog_STRIP
7817 if test -n "$STRIP"; then
7818   echo "$as_me:$LINENO: result: $STRIP" >&5
7819 echo "${ECHO_T}$STRIP" >&6
7820 else
7821   echo "$as_me:$LINENO: result: no" >&5
7822 echo "${ECHO_T}no" >&6
7823 fi
7824
7825   fi
7826   test -n "$ac_cv_prog_STRIP" && break
7827 done
7828
7829 if test -z "$ac_cv_prog_STRIP" ; then
7830   STRIP=":"
7831 fi
7832
7833
7834
7835 if test -n "$WINDRES"; then
7836   ac_cv_prog_WINDRES=$WINDRES
7837 elif test -n "$ac_cv_prog_WINDRES"; then
7838   WINDRES=$ac_cv_prog_WINDRES
7839 fi
7840
7841 if test -n "$ac_cv_prog_WINDRES"; then
7842   for ncn_progname in windres; do
7843     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7844 set dummy ${ncn_progname}; ac_word=$2
7845 echo "$as_me:$LINENO: checking for $ac_word" >&5
7846 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7847 if test "${ac_cv_prog_WINDRES+set}" = set; then
7848   echo $ECHO_N "(cached) $ECHO_C" >&6
7849 else
7850   if test -n "$WINDRES"; then
7851   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7852 else
7853 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7854 for as_dir in $PATH
7855 do
7856   IFS=$as_save_IFS
7857   test -z "$as_dir" && as_dir=.
7858   for ac_exec_ext in '' $ac_executable_extensions; do
7859   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7860     ac_cv_prog_WINDRES="${ncn_progname}"
7861     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7862     break 2
7863   fi
7864 done
7865 done
7866
7867 fi
7868 fi
7869 WINDRES=$ac_cv_prog_WINDRES
7870 if test -n "$WINDRES"; then
7871   echo "$as_me:$LINENO: result: $WINDRES" >&5
7872 echo "${ECHO_T}$WINDRES" >&6
7873 else
7874   echo "$as_me:$LINENO: result: no" >&5
7875 echo "${ECHO_T}no" >&6
7876 fi
7877
7878   done
7879 fi
7880
7881 for ncn_progname in windres; do
7882   if test -n "$ncn_tool_prefix"; then
7883     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7884 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7885 echo "$as_me:$LINENO: checking for $ac_word" >&5
7886 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7887 if test "${ac_cv_prog_WINDRES+set}" = set; then
7888   echo $ECHO_N "(cached) $ECHO_C" >&6
7889 else
7890   if test -n "$WINDRES"; then
7891   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7892 else
7893 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7894 for as_dir in $PATH
7895 do
7896   IFS=$as_save_IFS
7897   test -z "$as_dir" && as_dir=.
7898   for ac_exec_ext in '' $ac_executable_extensions; do
7899   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7900     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7901     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7902     break 2
7903   fi
7904 done
7905 done
7906
7907 fi
7908 fi
7909 WINDRES=$ac_cv_prog_WINDRES
7910 if test -n "$WINDRES"; then
7911   echo "$as_me:$LINENO: result: $WINDRES" >&5
7912 echo "${ECHO_T}$WINDRES" >&6
7913 else
7914   echo "$as_me:$LINENO: result: no" >&5
7915 echo "${ECHO_T}no" >&6
7916 fi
7917
7918   fi
7919   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7920     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7921 set dummy ${ncn_progname}; ac_word=$2
7922 echo "$as_me:$LINENO: checking for $ac_word" >&5
7923 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7924 if test "${ac_cv_prog_WINDRES+set}" = set; then
7925   echo $ECHO_N "(cached) $ECHO_C" >&6
7926 else
7927   if test -n "$WINDRES"; then
7928   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7929 else
7930 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7931 for as_dir in $PATH
7932 do
7933   IFS=$as_save_IFS
7934   test -z "$as_dir" && as_dir=.
7935   for ac_exec_ext in '' $ac_executable_extensions; do
7936   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7937     ac_cv_prog_WINDRES="${ncn_progname}"
7938     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7939     break 2
7940   fi
7941 done
7942 done
7943
7944 fi
7945 fi
7946 WINDRES=$ac_cv_prog_WINDRES
7947 if test -n "$WINDRES"; then
7948   echo "$as_me:$LINENO: result: $WINDRES" >&5
7949 echo "${ECHO_T}$WINDRES" >&6
7950 else
7951   echo "$as_me:$LINENO: result: no" >&5
7952 echo "${ECHO_T}no" >&6
7953 fi
7954
7955   fi
7956   test -n "$ac_cv_prog_WINDRES" && break
7957 done
7958
7959 if test -z "$ac_cv_prog_WINDRES" ; then
7960   set dummy windres
7961   if test $build = $host ; then
7962     WINDRES="$2"
7963   else
7964     WINDRES="${ncn_tool_prefix}$2"
7965   fi
7966 fi
7967
7968
7969
7970 if test -n "$WINDMC"; then
7971   ac_cv_prog_WINDMC=$WINDMC
7972 elif test -n "$ac_cv_prog_WINDMC"; then
7973   WINDMC=$ac_cv_prog_WINDMC
7974 fi
7975
7976 if test -n "$ac_cv_prog_WINDMC"; then
7977   for ncn_progname in windmc; do
7978     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7979 set dummy ${ncn_progname}; ac_word=$2
7980 echo "$as_me:$LINENO: checking for $ac_word" >&5
7981 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7982 if test "${ac_cv_prog_WINDMC+set}" = set; then
7983   echo $ECHO_N "(cached) $ECHO_C" >&6
7984 else
7985   if test -n "$WINDMC"; then
7986   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7987 else
7988 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7989 for as_dir in $PATH
7990 do
7991   IFS=$as_save_IFS
7992   test -z "$as_dir" && as_dir=.
7993   for ac_exec_ext in '' $ac_executable_extensions; do
7994   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7995     ac_cv_prog_WINDMC="${ncn_progname}"
7996     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7997     break 2
7998   fi
7999 done
8000 done
8001
8002 fi
8003 fi
8004 WINDMC=$ac_cv_prog_WINDMC
8005 if test -n "$WINDMC"; then
8006   echo "$as_me:$LINENO: result: $WINDMC" >&5
8007 echo "${ECHO_T}$WINDMC" >&6
8008 else
8009   echo "$as_me:$LINENO: result: no" >&5
8010 echo "${ECHO_T}no" >&6
8011 fi
8012
8013   done
8014 fi
8015
8016 for ncn_progname in windmc; do
8017   if test -n "$ncn_tool_prefix"; then
8018     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8019 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8020 echo "$as_me:$LINENO: checking for $ac_word" >&5
8021 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8022 if test "${ac_cv_prog_WINDMC+set}" = set; then
8023   echo $ECHO_N "(cached) $ECHO_C" >&6
8024 else
8025   if test -n "$WINDMC"; then
8026   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8027 else
8028 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8029 for as_dir in $PATH
8030 do
8031   IFS=$as_save_IFS
8032   test -z "$as_dir" && as_dir=.
8033   for ac_exec_ext in '' $ac_executable_extensions; do
8034   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8035     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8036     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8037     break 2
8038   fi
8039 done
8040 done
8041
8042 fi
8043 fi
8044 WINDMC=$ac_cv_prog_WINDMC
8045 if test -n "$WINDMC"; then
8046   echo "$as_me:$LINENO: result: $WINDMC" >&5
8047 echo "${ECHO_T}$WINDMC" >&6
8048 else
8049   echo "$as_me:$LINENO: result: no" >&5
8050 echo "${ECHO_T}no" >&6
8051 fi
8052
8053   fi
8054   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8055     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8056 set dummy ${ncn_progname}; ac_word=$2
8057 echo "$as_me:$LINENO: checking for $ac_word" >&5
8058 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8059 if test "${ac_cv_prog_WINDMC+set}" = set; then
8060   echo $ECHO_N "(cached) $ECHO_C" >&6
8061 else
8062   if test -n "$WINDMC"; then
8063   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8064 else
8065 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8066 for as_dir in $PATH
8067 do
8068   IFS=$as_save_IFS
8069   test -z "$as_dir" && as_dir=.
8070   for ac_exec_ext in '' $ac_executable_extensions; do
8071   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8072     ac_cv_prog_WINDMC="${ncn_progname}"
8073     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8074     break 2
8075   fi
8076 done
8077 done
8078
8079 fi
8080 fi
8081 WINDMC=$ac_cv_prog_WINDMC
8082 if test -n "$WINDMC"; then
8083   echo "$as_me:$LINENO: result: $WINDMC" >&5
8084 echo "${ECHO_T}$WINDMC" >&6
8085 else
8086   echo "$as_me:$LINENO: result: no" >&5
8087 echo "${ECHO_T}no" >&6
8088 fi
8089
8090   fi
8091   test -n "$ac_cv_prog_WINDMC" && break
8092 done
8093
8094 if test -z "$ac_cv_prog_WINDMC" ; then
8095   set dummy windmc
8096   if test $build = $host ; then
8097     WINDMC="$2"
8098   else
8099     WINDMC="${ncn_tool_prefix}$2"
8100   fi
8101 fi
8102
8103
8104
8105 if test -n "$OBJCOPY"; then
8106   ac_cv_prog_OBJCOPY=$OBJCOPY
8107 elif test -n "$ac_cv_prog_OBJCOPY"; then
8108   OBJCOPY=$ac_cv_prog_OBJCOPY
8109 fi
8110
8111 if test -n "$ac_cv_prog_OBJCOPY"; then
8112   for ncn_progname in objcopy; do
8113     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8114 set dummy ${ncn_progname}; ac_word=$2
8115 echo "$as_me:$LINENO: checking for $ac_word" >&5
8116 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8117 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8118   echo $ECHO_N "(cached) $ECHO_C" >&6
8119 else
8120   if test -n "$OBJCOPY"; then
8121   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8122 else
8123 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8124 for as_dir in $PATH
8125 do
8126   IFS=$as_save_IFS
8127   test -z "$as_dir" && as_dir=.
8128   for ac_exec_ext in '' $ac_executable_extensions; do
8129   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8130     ac_cv_prog_OBJCOPY="${ncn_progname}"
8131     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8132     break 2
8133   fi
8134 done
8135 done
8136
8137 fi
8138 fi
8139 OBJCOPY=$ac_cv_prog_OBJCOPY
8140 if test -n "$OBJCOPY"; then
8141   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8142 echo "${ECHO_T}$OBJCOPY" >&6
8143 else
8144   echo "$as_me:$LINENO: result: no" >&5
8145 echo "${ECHO_T}no" >&6
8146 fi
8147
8148   done
8149 fi
8150
8151 for ncn_progname in objcopy; do
8152   if test -n "$ncn_tool_prefix"; then
8153     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8154 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8155 echo "$as_me:$LINENO: checking for $ac_word" >&5
8156 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8157 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8158   echo $ECHO_N "(cached) $ECHO_C" >&6
8159 else
8160   if test -n "$OBJCOPY"; then
8161   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8162 else
8163 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8164 for as_dir in $PATH
8165 do
8166   IFS=$as_save_IFS
8167   test -z "$as_dir" && as_dir=.
8168   for ac_exec_ext in '' $ac_executable_extensions; do
8169   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8170     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8171     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8172     break 2
8173   fi
8174 done
8175 done
8176
8177 fi
8178 fi
8179 OBJCOPY=$ac_cv_prog_OBJCOPY
8180 if test -n "$OBJCOPY"; then
8181   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8182 echo "${ECHO_T}$OBJCOPY" >&6
8183 else
8184   echo "$as_me:$LINENO: result: no" >&5
8185 echo "${ECHO_T}no" >&6
8186 fi
8187
8188   fi
8189   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8190     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8191 set dummy ${ncn_progname}; ac_word=$2
8192 echo "$as_me:$LINENO: checking for $ac_word" >&5
8193 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8194 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8195   echo $ECHO_N "(cached) $ECHO_C" >&6
8196 else
8197   if test -n "$OBJCOPY"; then
8198   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8199 else
8200 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8201 for as_dir in $PATH
8202 do
8203   IFS=$as_save_IFS
8204   test -z "$as_dir" && as_dir=.
8205   for ac_exec_ext in '' $ac_executable_extensions; do
8206   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8207     ac_cv_prog_OBJCOPY="${ncn_progname}"
8208     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8209     break 2
8210   fi
8211 done
8212 done
8213
8214 fi
8215 fi
8216 OBJCOPY=$ac_cv_prog_OBJCOPY
8217 if test -n "$OBJCOPY"; then
8218   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8219 echo "${ECHO_T}$OBJCOPY" >&6
8220 else
8221   echo "$as_me:$LINENO: result: no" >&5
8222 echo "${ECHO_T}no" >&6
8223 fi
8224
8225   fi
8226   test -n "$ac_cv_prog_OBJCOPY" && break
8227 done
8228
8229 if test -z "$ac_cv_prog_OBJCOPY" ; then
8230   set dummy objcopy
8231   if test $build = $host ; then
8232     OBJCOPY="$2"
8233   else
8234     OBJCOPY="${ncn_tool_prefix}$2"
8235   fi
8236 fi
8237
8238
8239
8240 if test -n "$OBJDUMP"; then
8241   ac_cv_prog_OBJDUMP=$OBJDUMP
8242 elif test -n "$ac_cv_prog_OBJDUMP"; then
8243   OBJDUMP=$ac_cv_prog_OBJDUMP
8244 fi
8245
8246 if test -n "$ac_cv_prog_OBJDUMP"; then
8247   for ncn_progname in objdump; do
8248     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8249 set dummy ${ncn_progname}; ac_word=$2
8250 echo "$as_me:$LINENO: checking for $ac_word" >&5
8251 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8252 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8253   echo $ECHO_N "(cached) $ECHO_C" >&6
8254 else
8255   if test -n "$OBJDUMP"; then
8256   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8257 else
8258 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8259 for as_dir in $PATH
8260 do
8261   IFS=$as_save_IFS
8262   test -z "$as_dir" && as_dir=.
8263   for ac_exec_ext in '' $ac_executable_extensions; do
8264   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8265     ac_cv_prog_OBJDUMP="${ncn_progname}"
8266     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8267     break 2
8268   fi
8269 done
8270 done
8271
8272 fi
8273 fi
8274 OBJDUMP=$ac_cv_prog_OBJDUMP
8275 if test -n "$OBJDUMP"; then
8276   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8277 echo "${ECHO_T}$OBJDUMP" >&6
8278 else
8279   echo "$as_me:$LINENO: result: no" >&5
8280 echo "${ECHO_T}no" >&6
8281 fi
8282
8283   done
8284 fi
8285
8286 for ncn_progname in objdump; do
8287   if test -n "$ncn_tool_prefix"; then
8288     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8289 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8290 echo "$as_me:$LINENO: checking for $ac_word" >&5
8291 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8292 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8293   echo $ECHO_N "(cached) $ECHO_C" >&6
8294 else
8295   if test -n "$OBJDUMP"; then
8296   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8297 else
8298 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8299 for as_dir in $PATH
8300 do
8301   IFS=$as_save_IFS
8302   test -z "$as_dir" && as_dir=.
8303   for ac_exec_ext in '' $ac_executable_extensions; do
8304   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8305     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8306     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8307     break 2
8308   fi
8309 done
8310 done
8311
8312 fi
8313 fi
8314 OBJDUMP=$ac_cv_prog_OBJDUMP
8315 if test -n "$OBJDUMP"; then
8316   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8317 echo "${ECHO_T}$OBJDUMP" >&6
8318 else
8319   echo "$as_me:$LINENO: result: no" >&5
8320 echo "${ECHO_T}no" >&6
8321 fi
8322
8323   fi
8324   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8325     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8326 set dummy ${ncn_progname}; ac_word=$2
8327 echo "$as_me:$LINENO: checking for $ac_word" >&5
8328 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8329 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8330   echo $ECHO_N "(cached) $ECHO_C" >&6
8331 else
8332   if test -n "$OBJDUMP"; then
8333   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8334 else
8335 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8336 for as_dir in $PATH
8337 do
8338   IFS=$as_save_IFS
8339   test -z "$as_dir" && as_dir=.
8340   for ac_exec_ext in '' $ac_executable_extensions; do
8341   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8342     ac_cv_prog_OBJDUMP="${ncn_progname}"
8343     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8344     break 2
8345   fi
8346 done
8347 done
8348
8349 fi
8350 fi
8351 OBJDUMP=$ac_cv_prog_OBJDUMP
8352 if test -n "$OBJDUMP"; then
8353   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8354 echo "${ECHO_T}$OBJDUMP" >&6
8355 else
8356   echo "$as_me:$LINENO: result: no" >&5
8357 echo "${ECHO_T}no" >&6
8358 fi
8359
8360   fi
8361   test -n "$ac_cv_prog_OBJDUMP" && break
8362 done
8363
8364 if test -z "$ac_cv_prog_OBJDUMP" ; then
8365   set dummy objdump
8366   if test $build = $host ; then
8367     OBJDUMP="$2"
8368   else
8369     OBJDUMP="${ncn_tool_prefix}$2"
8370   fi
8371 fi
8372
8373
8374
8375
8376
8377
8378 # Target tools.
8379
8380 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8381 if test "${with_build_time_tools+set}" = set; then
8382   withval="$with_build_time_tools"
8383   case x"$withval" in
8384      x/*) ;;
8385      *)
8386        with_build_time_tools=
8387        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8388 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8389        ;;
8390    esac
8391 else
8392   with_build_time_tools=
8393 fi;
8394
8395
8396
8397 if test -n "$CC_FOR_TARGET"; then
8398   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8399 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8400   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8401 fi
8402
8403 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8404   for ncn_progname in cc gcc; do
8405     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8406 set dummy ${ncn_progname}; ac_word=$2
8407 echo "$as_me:$LINENO: checking for $ac_word" >&5
8408 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8409 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8410   echo $ECHO_N "(cached) $ECHO_C" >&6
8411 else
8412   if test -n "$CC_FOR_TARGET"; then
8413   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8414 else
8415 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8416 for as_dir in $PATH
8417 do
8418   IFS=$as_save_IFS
8419   test -z "$as_dir" && as_dir=.
8420   for ac_exec_ext in '' $ac_executable_extensions; do
8421   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8422     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8423     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8424     break 2
8425   fi
8426 done
8427 done
8428
8429 fi
8430 fi
8431 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8432 if test -n "$CC_FOR_TARGET"; then
8433   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8434 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8435 else
8436   echo "$as_me:$LINENO: result: no" >&5
8437 echo "${ECHO_T}no" >&6
8438 fi
8439
8440   done
8441 fi
8442
8443 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8444   for ncn_progname in cc gcc; do
8445     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8446 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8447     if test -x $with_build_time_tools/${ncn_progname}; then
8448       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8449       echo "$as_me:$LINENO: result: yes" >&5
8450 echo "${ECHO_T}yes" >&6
8451       break
8452     else
8453       echo "$as_me:$LINENO: result: no" >&5
8454 echo "${ECHO_T}no" >&6
8455     fi
8456   done
8457 fi
8458
8459 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8460   for ncn_progname in cc gcc; do
8461     if test -n "$ncn_target_tool_prefix"; then
8462       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8463 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8464 echo "$as_me:$LINENO: checking for $ac_word" >&5
8465 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8466 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8467   echo $ECHO_N "(cached) $ECHO_C" >&6
8468 else
8469   if test -n "$CC_FOR_TARGET"; then
8470   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8471 else
8472 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8473 for as_dir in $PATH
8474 do
8475   IFS=$as_save_IFS
8476   test -z "$as_dir" && as_dir=.
8477   for ac_exec_ext in '' $ac_executable_extensions; do
8478   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8479     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8480     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8481     break 2
8482   fi
8483 done
8484 done
8485
8486 fi
8487 fi
8488 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8489 if test -n "$CC_FOR_TARGET"; then
8490   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8491 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8492 else
8493   echo "$as_me:$LINENO: result: no" >&5
8494 echo "${ECHO_T}no" >&6
8495 fi
8496
8497     fi
8498     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8499       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8500 set dummy ${ncn_progname}; ac_word=$2
8501 echo "$as_me:$LINENO: checking for $ac_word" >&5
8502 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8503 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8504   echo $ECHO_N "(cached) $ECHO_C" >&6
8505 else
8506   if test -n "$CC_FOR_TARGET"; then
8507   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8508 else
8509 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8510 for as_dir in $PATH
8511 do
8512   IFS=$as_save_IFS
8513   test -z "$as_dir" && as_dir=.
8514   for ac_exec_ext in '' $ac_executable_extensions; do
8515   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8516     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8517     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8518     break 2
8519   fi
8520 done
8521 done
8522
8523 fi
8524 fi
8525 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8526 if test -n "$CC_FOR_TARGET"; then
8527   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8528 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8529 else
8530   echo "$as_me:$LINENO: result: no" >&5
8531 echo "${ECHO_T}no" >&6
8532 fi
8533
8534     fi
8535     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8536   done
8537 fi
8538
8539 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8540   set dummy cc gcc
8541   if test $build = $target ; then
8542     CC_FOR_TARGET="$2"
8543   else
8544     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8545   fi
8546 else
8547   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8548 fi
8549
8550
8551
8552 if test -n "$CXX_FOR_TARGET"; then
8553   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8554 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8555   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8556 fi
8557
8558 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8559   for ncn_progname in c++ g++ cxx gxx; do
8560     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8561 set dummy ${ncn_progname}; ac_word=$2
8562 echo "$as_me:$LINENO: checking for $ac_word" >&5
8563 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8564 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8565   echo $ECHO_N "(cached) $ECHO_C" >&6
8566 else
8567   if test -n "$CXX_FOR_TARGET"; then
8568   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8569 else
8570 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8571 for as_dir in $PATH
8572 do
8573   IFS=$as_save_IFS
8574   test -z "$as_dir" && as_dir=.
8575   for ac_exec_ext in '' $ac_executable_extensions; do
8576   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8577     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8578     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8579     break 2
8580   fi
8581 done
8582 done
8583
8584 fi
8585 fi
8586 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8587 if test -n "$CXX_FOR_TARGET"; then
8588   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8589 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8590 else
8591   echo "$as_me:$LINENO: result: no" >&5
8592 echo "${ECHO_T}no" >&6
8593 fi
8594
8595   done
8596 fi
8597
8598 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8599   for ncn_progname in c++ g++ cxx gxx; do
8600     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8601 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8602     if test -x $with_build_time_tools/${ncn_progname}; then
8603       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8604       echo "$as_me:$LINENO: result: yes" >&5
8605 echo "${ECHO_T}yes" >&6
8606       break
8607     else
8608       echo "$as_me:$LINENO: result: no" >&5
8609 echo "${ECHO_T}no" >&6
8610     fi
8611   done
8612 fi
8613
8614 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8615   for ncn_progname in c++ g++ cxx gxx; do
8616     if test -n "$ncn_target_tool_prefix"; then
8617       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8618 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8619 echo "$as_me:$LINENO: checking for $ac_word" >&5
8620 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8621 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8622   echo $ECHO_N "(cached) $ECHO_C" >&6
8623 else
8624   if test -n "$CXX_FOR_TARGET"; then
8625   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8626 else
8627 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8628 for as_dir in $PATH
8629 do
8630   IFS=$as_save_IFS
8631   test -z "$as_dir" && as_dir=.
8632   for ac_exec_ext in '' $ac_executable_extensions; do
8633   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8634     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8635     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8636     break 2
8637   fi
8638 done
8639 done
8640
8641 fi
8642 fi
8643 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8644 if test -n "$CXX_FOR_TARGET"; then
8645   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8646 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8647 else
8648   echo "$as_me:$LINENO: result: no" >&5
8649 echo "${ECHO_T}no" >&6
8650 fi
8651
8652     fi
8653     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8654       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8655 set dummy ${ncn_progname}; ac_word=$2
8656 echo "$as_me:$LINENO: checking for $ac_word" >&5
8657 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8658 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8659   echo $ECHO_N "(cached) $ECHO_C" >&6
8660 else
8661   if test -n "$CXX_FOR_TARGET"; then
8662   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8663 else
8664 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8665 for as_dir in $PATH
8666 do
8667   IFS=$as_save_IFS
8668   test -z "$as_dir" && as_dir=.
8669   for ac_exec_ext in '' $ac_executable_extensions; do
8670   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8671     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8672     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8673     break 2
8674   fi
8675 done
8676 done
8677
8678 fi
8679 fi
8680 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8681 if test -n "$CXX_FOR_TARGET"; then
8682   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8683 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8684 else
8685   echo "$as_me:$LINENO: result: no" >&5
8686 echo "${ECHO_T}no" >&6
8687 fi
8688
8689     fi
8690     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8691   done
8692 fi
8693
8694 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8695   set dummy c++ g++ cxx gxx
8696   if test $build = $target ; then
8697     CXX_FOR_TARGET="$2"
8698   else
8699     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8700   fi
8701 else
8702   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8703 fi
8704
8705
8706
8707 if test -n "$GCC_FOR_TARGET"; then
8708   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8709 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8710   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8711 fi
8712
8713 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8714   for ncn_progname in gcc; do
8715     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8716 set dummy ${ncn_progname}; ac_word=$2
8717 echo "$as_me:$LINENO: checking for $ac_word" >&5
8718 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8719 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8720   echo $ECHO_N "(cached) $ECHO_C" >&6
8721 else
8722   if test -n "$GCC_FOR_TARGET"; then
8723   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8724 else
8725 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8726 for as_dir in $PATH
8727 do
8728   IFS=$as_save_IFS
8729   test -z "$as_dir" && as_dir=.
8730   for ac_exec_ext in '' $ac_executable_extensions; do
8731   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8732     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8733     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8734     break 2
8735   fi
8736 done
8737 done
8738
8739 fi
8740 fi
8741 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8742 if test -n "$GCC_FOR_TARGET"; then
8743   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8744 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8745 else
8746   echo "$as_me:$LINENO: result: no" >&5
8747 echo "${ECHO_T}no" >&6
8748 fi
8749
8750   done
8751 fi
8752
8753 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8754   for ncn_progname in gcc; do
8755     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8756 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8757     if test -x $with_build_time_tools/${ncn_progname}; then
8758       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8759       echo "$as_me:$LINENO: result: yes" >&5
8760 echo "${ECHO_T}yes" >&6
8761       break
8762     else
8763       echo "$as_me:$LINENO: result: no" >&5
8764 echo "${ECHO_T}no" >&6
8765     fi
8766   done
8767 fi
8768
8769 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8770   for ncn_progname in gcc; do
8771     if test -n "$ncn_target_tool_prefix"; then
8772       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8773 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8774 echo "$as_me:$LINENO: checking for $ac_word" >&5
8775 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8776 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8777   echo $ECHO_N "(cached) $ECHO_C" >&6
8778 else
8779   if test -n "$GCC_FOR_TARGET"; then
8780   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8781 else
8782 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8783 for as_dir in $PATH
8784 do
8785   IFS=$as_save_IFS
8786   test -z "$as_dir" && as_dir=.
8787   for ac_exec_ext in '' $ac_executable_extensions; do
8788   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8789     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8790     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8791     break 2
8792   fi
8793 done
8794 done
8795
8796 fi
8797 fi
8798 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8799 if test -n "$GCC_FOR_TARGET"; then
8800   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8801 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8802 else
8803   echo "$as_me:$LINENO: result: no" >&5
8804 echo "${ECHO_T}no" >&6
8805 fi
8806
8807     fi
8808     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8809       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8810 set dummy ${ncn_progname}; ac_word=$2
8811 echo "$as_me:$LINENO: checking for $ac_word" >&5
8812 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8813 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8814   echo $ECHO_N "(cached) $ECHO_C" >&6
8815 else
8816   if test -n "$GCC_FOR_TARGET"; then
8817   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8818 else
8819 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8820 for as_dir in $PATH
8821 do
8822   IFS=$as_save_IFS
8823   test -z "$as_dir" && as_dir=.
8824   for ac_exec_ext in '' $ac_executable_extensions; do
8825   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8826     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8827     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8828     break 2
8829   fi
8830 done
8831 done
8832
8833 fi
8834 fi
8835 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8836 if test -n "$GCC_FOR_TARGET"; then
8837   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8838 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8839 else
8840   echo "$as_me:$LINENO: result: no" >&5
8841 echo "${ECHO_T}no" >&6
8842 fi
8843
8844     fi
8845     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8846   done
8847 fi
8848
8849 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8850   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8851 else
8852   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8853 fi
8854
8855
8856
8857 if test -n "$GCJ_FOR_TARGET"; then
8858   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8859 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8860   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8861 fi
8862
8863 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8864   for ncn_progname in gcj; do
8865     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8866 set dummy ${ncn_progname}; ac_word=$2
8867 echo "$as_me:$LINENO: checking for $ac_word" >&5
8868 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8869 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8870   echo $ECHO_N "(cached) $ECHO_C" >&6
8871 else
8872   if test -n "$GCJ_FOR_TARGET"; then
8873   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8874 else
8875 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8876 for as_dir in $PATH
8877 do
8878   IFS=$as_save_IFS
8879   test -z "$as_dir" && as_dir=.
8880   for ac_exec_ext in '' $ac_executable_extensions; do
8881   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8882     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8883     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8884     break 2
8885   fi
8886 done
8887 done
8888
8889 fi
8890 fi
8891 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8892 if test -n "$GCJ_FOR_TARGET"; then
8893   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8894 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8895 else
8896   echo "$as_me:$LINENO: result: no" >&5
8897 echo "${ECHO_T}no" >&6
8898 fi
8899
8900   done
8901 fi
8902
8903 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8904   for ncn_progname in gcj; do
8905     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8906 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8907     if test -x $with_build_time_tools/${ncn_progname}; then
8908       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8909       echo "$as_me:$LINENO: result: yes" >&5
8910 echo "${ECHO_T}yes" >&6
8911       break
8912     else
8913       echo "$as_me:$LINENO: result: no" >&5
8914 echo "${ECHO_T}no" >&6
8915     fi
8916   done
8917 fi
8918
8919 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8920   for ncn_progname in gcj; do
8921     if test -n "$ncn_target_tool_prefix"; then
8922       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8923 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8924 echo "$as_me:$LINENO: checking for $ac_word" >&5
8925 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8926 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8927   echo $ECHO_N "(cached) $ECHO_C" >&6
8928 else
8929   if test -n "$GCJ_FOR_TARGET"; then
8930   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8931 else
8932 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8933 for as_dir in $PATH
8934 do
8935   IFS=$as_save_IFS
8936   test -z "$as_dir" && as_dir=.
8937   for ac_exec_ext in '' $ac_executable_extensions; do
8938   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8939     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8940     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8941     break 2
8942   fi
8943 done
8944 done
8945
8946 fi
8947 fi
8948 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8949 if test -n "$GCJ_FOR_TARGET"; then
8950   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8951 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8952 else
8953   echo "$as_me:$LINENO: result: no" >&5
8954 echo "${ECHO_T}no" >&6
8955 fi
8956
8957     fi
8958     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8959       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8960 set dummy ${ncn_progname}; ac_word=$2
8961 echo "$as_me:$LINENO: checking for $ac_word" >&5
8962 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8963 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8964   echo $ECHO_N "(cached) $ECHO_C" >&6
8965 else
8966   if test -n "$GCJ_FOR_TARGET"; then
8967   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8968 else
8969 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8970 for as_dir in $PATH
8971 do
8972   IFS=$as_save_IFS
8973   test -z "$as_dir" && as_dir=.
8974   for ac_exec_ext in '' $ac_executable_extensions; do
8975   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8976     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8977     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8978     break 2
8979   fi
8980 done
8981 done
8982
8983 fi
8984 fi
8985 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8986 if test -n "$GCJ_FOR_TARGET"; then
8987   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8988 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8989 else
8990   echo "$as_me:$LINENO: result: no" >&5
8991 echo "${ECHO_T}no" >&6
8992 fi
8993
8994     fi
8995     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8996   done
8997 fi
8998
8999 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9000   set dummy gcj
9001   if test $build = $target ; then
9002     GCJ_FOR_TARGET="$2"
9003   else
9004     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9005   fi
9006 else
9007   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9008 fi
9009
9010
9011
9012 if test -n "$GFORTRAN_FOR_TARGET"; then
9013   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9014 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9015   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9016 fi
9017
9018 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9019   for ncn_progname in gfortran; do
9020     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9021 set dummy ${ncn_progname}; ac_word=$2
9022 echo "$as_me:$LINENO: checking for $ac_word" >&5
9023 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9024 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9025   echo $ECHO_N "(cached) $ECHO_C" >&6
9026 else
9027   if test -n "$GFORTRAN_FOR_TARGET"; then
9028   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9029 else
9030 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9031 for as_dir in $PATH
9032 do
9033   IFS=$as_save_IFS
9034   test -z "$as_dir" && as_dir=.
9035   for ac_exec_ext in '' $ac_executable_extensions; do
9036   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9037     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9038     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9039     break 2
9040   fi
9041 done
9042 done
9043
9044 fi
9045 fi
9046 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9047 if test -n "$GFORTRAN_FOR_TARGET"; then
9048   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9049 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9050 else
9051   echo "$as_me:$LINENO: result: no" >&5
9052 echo "${ECHO_T}no" >&6
9053 fi
9054
9055   done
9056 fi
9057
9058 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9059   for ncn_progname in gfortran; do
9060     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9061 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9062     if test -x $with_build_time_tools/${ncn_progname}; then
9063       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9064       echo "$as_me:$LINENO: result: yes" >&5
9065 echo "${ECHO_T}yes" >&6
9066       break
9067     else
9068       echo "$as_me:$LINENO: result: no" >&5
9069 echo "${ECHO_T}no" >&6
9070     fi
9071   done
9072 fi
9073
9074 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9075   for ncn_progname in gfortran; do
9076     if test -n "$ncn_target_tool_prefix"; then
9077       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9078 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9079 echo "$as_me:$LINENO: checking for $ac_word" >&5
9080 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9081 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9082   echo $ECHO_N "(cached) $ECHO_C" >&6
9083 else
9084   if test -n "$GFORTRAN_FOR_TARGET"; then
9085   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9086 else
9087 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9088 for as_dir in $PATH
9089 do
9090   IFS=$as_save_IFS
9091   test -z "$as_dir" && as_dir=.
9092   for ac_exec_ext in '' $ac_executable_extensions; do
9093   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9094     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9095     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9096     break 2
9097   fi
9098 done
9099 done
9100
9101 fi
9102 fi
9103 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9104 if test -n "$GFORTRAN_FOR_TARGET"; then
9105   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9106 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9107 else
9108   echo "$as_me:$LINENO: result: no" >&5
9109 echo "${ECHO_T}no" >&6
9110 fi
9111
9112     fi
9113     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9114       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9115 set dummy ${ncn_progname}; ac_word=$2
9116 echo "$as_me:$LINENO: checking for $ac_word" >&5
9117 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9118 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9119   echo $ECHO_N "(cached) $ECHO_C" >&6
9120 else
9121   if test -n "$GFORTRAN_FOR_TARGET"; then
9122   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9123 else
9124 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9125 for as_dir in $PATH
9126 do
9127   IFS=$as_save_IFS
9128   test -z "$as_dir" && as_dir=.
9129   for ac_exec_ext in '' $ac_executable_extensions; do
9130   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9131     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9132     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9133     break 2
9134   fi
9135 done
9136 done
9137
9138 fi
9139 fi
9140 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9141 if test -n "$GFORTRAN_FOR_TARGET"; then
9142   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9143 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9144 else
9145   echo "$as_me:$LINENO: result: no" >&5
9146 echo "${ECHO_T}no" >&6
9147 fi
9148
9149     fi
9150     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9151   done
9152 fi
9153
9154 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9155   set dummy gfortran
9156   if test $build = $target ; then
9157     GFORTRAN_FOR_TARGET="$2"
9158   else
9159     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9160   fi
9161 else
9162   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9163 fi
9164
9165
9166
9167 cat > conftest.c << \EOF
9168 #ifdef __GNUC__
9169   gcc_yay;
9170 #endif
9171 EOF
9172 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9173   have_gcc_for_target=yes
9174 else
9175   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9176   have_gcc_for_target=no
9177 fi
9178 rm conftest.c
9179
9180
9181
9182
9183 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9184   if test -n "$with_build_time_tools"; then
9185     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9186 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9187     if test -x $with_build_time_tools/ar; then
9188       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9189       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9190       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9191 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9192     else
9193       echo "$as_me:$LINENO: result: no" >&5
9194 echo "${ECHO_T}no" >&6
9195     fi
9196   elif test $build != $host && test $have_gcc_for_target = yes; then
9197     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9198     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9199     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9200   fi
9201 fi
9202 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9203   # Extract the first word of "ar", so it can be a program name with args.
9204 set dummy ar; ac_word=$2
9205 echo "$as_me:$LINENO: checking for $ac_word" >&5
9206 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9207 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9208   echo $ECHO_N "(cached) $ECHO_C" >&6
9209 else
9210   case $AR_FOR_TARGET in
9211   [\\/]* | ?:[\\/]*)
9212   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9213   ;;
9214   *)
9215   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9216 for as_dir in $gcc_cv_tool_dirs
9217 do
9218   IFS=$as_save_IFS
9219   test -z "$as_dir" && as_dir=.
9220   for ac_exec_ext in '' $ac_executable_extensions; do
9221   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9222     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9223     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9224     break 2
9225   fi
9226 done
9227 done
9228
9229   ;;
9230 esac
9231 fi
9232 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9233
9234 if test -n "$AR_FOR_TARGET"; then
9235   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9236 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9237 else
9238   echo "$as_me:$LINENO: result: no" >&5
9239 echo "${ECHO_T}no" >&6
9240 fi
9241
9242 fi
9243 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9244
9245
9246 if test -n "$AR_FOR_TARGET"; then
9247   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9248 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9249   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9250 fi
9251
9252 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9253   for ncn_progname in ar; do
9254     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9255 set dummy ${ncn_progname}; ac_word=$2
9256 echo "$as_me:$LINENO: checking for $ac_word" >&5
9257 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9258 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9259   echo $ECHO_N "(cached) $ECHO_C" >&6
9260 else
9261   if test -n "$AR_FOR_TARGET"; then
9262   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9263 else
9264 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9265 for as_dir in $PATH
9266 do
9267   IFS=$as_save_IFS
9268   test -z "$as_dir" && as_dir=.
9269   for ac_exec_ext in '' $ac_executable_extensions; do
9270   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9271     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9272     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9273     break 2
9274   fi
9275 done
9276 done
9277
9278 fi
9279 fi
9280 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9281 if test -n "$AR_FOR_TARGET"; then
9282   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9283 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9284 else
9285   echo "$as_me:$LINENO: result: no" >&5
9286 echo "${ECHO_T}no" >&6
9287 fi
9288
9289   done
9290 fi
9291
9292 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9293   for ncn_progname in ar; do
9294     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9295 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9296     if test -x $with_build_time_tools/${ncn_progname}; then
9297       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9298       echo "$as_me:$LINENO: result: yes" >&5
9299 echo "${ECHO_T}yes" >&6
9300       break
9301     else
9302       echo "$as_me:$LINENO: result: no" >&5
9303 echo "${ECHO_T}no" >&6
9304     fi
9305   done
9306 fi
9307
9308 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9309   for ncn_progname in ar; do
9310     if test -n "$ncn_target_tool_prefix"; then
9311       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9312 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9313 echo "$as_me:$LINENO: checking for $ac_word" >&5
9314 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9315 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9316   echo $ECHO_N "(cached) $ECHO_C" >&6
9317 else
9318   if test -n "$AR_FOR_TARGET"; then
9319   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9320 else
9321 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9322 for as_dir in $PATH
9323 do
9324   IFS=$as_save_IFS
9325   test -z "$as_dir" && as_dir=.
9326   for ac_exec_ext in '' $ac_executable_extensions; do
9327   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9328     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9329     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9330     break 2
9331   fi
9332 done
9333 done
9334
9335 fi
9336 fi
9337 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9338 if test -n "$AR_FOR_TARGET"; then
9339   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9340 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9341 else
9342   echo "$as_me:$LINENO: result: no" >&5
9343 echo "${ECHO_T}no" >&6
9344 fi
9345
9346     fi
9347     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9348       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9349 set dummy ${ncn_progname}; ac_word=$2
9350 echo "$as_me:$LINENO: checking for $ac_word" >&5
9351 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9352 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9353   echo $ECHO_N "(cached) $ECHO_C" >&6
9354 else
9355   if test -n "$AR_FOR_TARGET"; then
9356   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9357 else
9358 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9359 for as_dir in $PATH
9360 do
9361   IFS=$as_save_IFS
9362   test -z "$as_dir" && as_dir=.
9363   for ac_exec_ext in '' $ac_executable_extensions; do
9364   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9365     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9366     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9367     break 2
9368   fi
9369 done
9370 done
9371
9372 fi
9373 fi
9374 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9375 if test -n "$AR_FOR_TARGET"; then
9376   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9377 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9378 else
9379   echo "$as_me:$LINENO: result: no" >&5
9380 echo "${ECHO_T}no" >&6
9381 fi
9382
9383     fi
9384     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9385   done
9386 fi
9387
9388 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9389   set dummy ar
9390   if test $build = $target ; then
9391     AR_FOR_TARGET="$2"
9392   else
9393     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9394   fi
9395 else
9396   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9397 fi
9398
9399 else
9400   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9401 fi
9402
9403
9404
9405
9406 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9407   if test -n "$with_build_time_tools"; then
9408     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9409 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9410     if test -x $with_build_time_tools/as; then
9411       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9412       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9413       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9414 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9415     else
9416       echo "$as_me:$LINENO: result: no" >&5
9417 echo "${ECHO_T}no" >&6
9418     fi
9419   elif test $build != $host && test $have_gcc_for_target = yes; then
9420     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9421     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9422     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9423   fi
9424 fi
9425 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9426   # Extract the first word of "as", so it can be a program name with args.
9427 set dummy as; ac_word=$2
9428 echo "$as_me:$LINENO: checking for $ac_word" >&5
9429 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9430 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9431   echo $ECHO_N "(cached) $ECHO_C" >&6
9432 else
9433   case $AS_FOR_TARGET in
9434   [\\/]* | ?:[\\/]*)
9435   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9436   ;;
9437   *)
9438   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9439 for as_dir in $gcc_cv_tool_dirs
9440 do
9441   IFS=$as_save_IFS
9442   test -z "$as_dir" && as_dir=.
9443   for ac_exec_ext in '' $ac_executable_extensions; do
9444   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9445     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9446     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9447     break 2
9448   fi
9449 done
9450 done
9451
9452   ;;
9453 esac
9454 fi
9455 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9456
9457 if test -n "$AS_FOR_TARGET"; then
9458   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9459 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9460 else
9461   echo "$as_me:$LINENO: result: no" >&5
9462 echo "${ECHO_T}no" >&6
9463 fi
9464
9465 fi
9466 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9467
9468
9469 if test -n "$AS_FOR_TARGET"; then
9470   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9471 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9472   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9473 fi
9474
9475 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9476   for ncn_progname in as; do
9477     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9478 set dummy ${ncn_progname}; ac_word=$2
9479 echo "$as_me:$LINENO: checking for $ac_word" >&5
9480 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9481 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9482   echo $ECHO_N "(cached) $ECHO_C" >&6
9483 else
9484   if test -n "$AS_FOR_TARGET"; then
9485   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9486 else
9487 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9488 for as_dir in $PATH
9489 do
9490   IFS=$as_save_IFS
9491   test -z "$as_dir" && as_dir=.
9492   for ac_exec_ext in '' $ac_executable_extensions; do
9493   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9494     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9495     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9496     break 2
9497   fi
9498 done
9499 done
9500
9501 fi
9502 fi
9503 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9504 if test -n "$AS_FOR_TARGET"; then
9505   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9506 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9507 else
9508   echo "$as_me:$LINENO: result: no" >&5
9509 echo "${ECHO_T}no" >&6
9510 fi
9511
9512   done
9513 fi
9514
9515 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9516   for ncn_progname in as; do
9517     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9518 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9519     if test -x $with_build_time_tools/${ncn_progname}; then
9520       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9521       echo "$as_me:$LINENO: result: yes" >&5
9522 echo "${ECHO_T}yes" >&6
9523       break
9524     else
9525       echo "$as_me:$LINENO: result: no" >&5
9526 echo "${ECHO_T}no" >&6
9527     fi
9528   done
9529 fi
9530
9531 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9532   for ncn_progname in as; do
9533     if test -n "$ncn_target_tool_prefix"; then
9534       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9535 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9536 echo "$as_me:$LINENO: checking for $ac_word" >&5
9537 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9538 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9539   echo $ECHO_N "(cached) $ECHO_C" >&6
9540 else
9541   if test -n "$AS_FOR_TARGET"; then
9542   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9543 else
9544 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9545 for as_dir in $PATH
9546 do
9547   IFS=$as_save_IFS
9548   test -z "$as_dir" && as_dir=.
9549   for ac_exec_ext in '' $ac_executable_extensions; do
9550   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9551     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9552     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9553     break 2
9554   fi
9555 done
9556 done
9557
9558 fi
9559 fi
9560 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9561 if test -n "$AS_FOR_TARGET"; then
9562   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9563 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9564 else
9565   echo "$as_me:$LINENO: result: no" >&5
9566 echo "${ECHO_T}no" >&6
9567 fi
9568
9569     fi
9570     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9571       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9572 set dummy ${ncn_progname}; ac_word=$2
9573 echo "$as_me:$LINENO: checking for $ac_word" >&5
9574 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9575 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9576   echo $ECHO_N "(cached) $ECHO_C" >&6
9577 else
9578   if test -n "$AS_FOR_TARGET"; then
9579   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9580 else
9581 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9582 for as_dir in $PATH
9583 do
9584   IFS=$as_save_IFS
9585   test -z "$as_dir" && as_dir=.
9586   for ac_exec_ext in '' $ac_executable_extensions; do
9587   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9588     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9589     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9590     break 2
9591   fi
9592 done
9593 done
9594
9595 fi
9596 fi
9597 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9598 if test -n "$AS_FOR_TARGET"; then
9599   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9600 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9601 else
9602   echo "$as_me:$LINENO: result: no" >&5
9603 echo "${ECHO_T}no" >&6
9604 fi
9605
9606     fi
9607     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9608   done
9609 fi
9610
9611 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9612   set dummy as
9613   if test $build = $target ; then
9614     AS_FOR_TARGET="$2"
9615   else
9616     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9617   fi
9618 else
9619   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9620 fi
9621
9622 else
9623   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9624 fi
9625
9626
9627
9628
9629 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9630   if test -n "$with_build_time_tools"; then
9631     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9632 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9633     if test -x $with_build_time_tools/dlltool; then
9634       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9635       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9636       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9637 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9638     else
9639       echo "$as_me:$LINENO: result: no" >&5
9640 echo "${ECHO_T}no" >&6
9641     fi
9642   elif test $build != $host && test $have_gcc_for_target = yes; then
9643     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9644     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9645     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9646   fi
9647 fi
9648 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9649   # Extract the first word of "dlltool", so it can be a program name with args.
9650 set dummy dlltool; ac_word=$2
9651 echo "$as_me:$LINENO: checking for $ac_word" >&5
9652 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9653 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9654   echo $ECHO_N "(cached) $ECHO_C" >&6
9655 else
9656   case $DLLTOOL_FOR_TARGET in
9657   [\\/]* | ?:[\\/]*)
9658   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9659   ;;
9660   *)
9661   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9662 for as_dir in $gcc_cv_tool_dirs
9663 do
9664   IFS=$as_save_IFS
9665   test -z "$as_dir" && as_dir=.
9666   for ac_exec_ext in '' $ac_executable_extensions; do
9667   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9668     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9669     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9670     break 2
9671   fi
9672 done
9673 done
9674
9675   ;;
9676 esac
9677 fi
9678 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9679
9680 if test -n "$DLLTOOL_FOR_TARGET"; then
9681   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9682 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9683 else
9684   echo "$as_me:$LINENO: result: no" >&5
9685 echo "${ECHO_T}no" >&6
9686 fi
9687
9688 fi
9689 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9690
9691
9692 if test -n "$DLLTOOL_FOR_TARGET"; then
9693   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9694 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9695   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9696 fi
9697
9698 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9699   for ncn_progname in dlltool; do
9700     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9701 set dummy ${ncn_progname}; ac_word=$2
9702 echo "$as_me:$LINENO: checking for $ac_word" >&5
9703 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9704 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9705   echo $ECHO_N "(cached) $ECHO_C" >&6
9706 else
9707   if test -n "$DLLTOOL_FOR_TARGET"; then
9708   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9709 else
9710 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9711 for as_dir in $PATH
9712 do
9713   IFS=$as_save_IFS
9714   test -z "$as_dir" && as_dir=.
9715   for ac_exec_ext in '' $ac_executable_extensions; do
9716   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9717     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9718     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9719     break 2
9720   fi
9721 done
9722 done
9723
9724 fi
9725 fi
9726 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9727 if test -n "$DLLTOOL_FOR_TARGET"; then
9728   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9729 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9730 else
9731   echo "$as_me:$LINENO: result: no" >&5
9732 echo "${ECHO_T}no" >&6
9733 fi
9734
9735   done
9736 fi
9737
9738 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9739   for ncn_progname in dlltool; do
9740     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9741 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9742     if test -x $with_build_time_tools/${ncn_progname}; then
9743       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9744       echo "$as_me:$LINENO: result: yes" >&5
9745 echo "${ECHO_T}yes" >&6
9746       break
9747     else
9748       echo "$as_me:$LINENO: result: no" >&5
9749 echo "${ECHO_T}no" >&6
9750     fi
9751   done
9752 fi
9753
9754 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9755   for ncn_progname in dlltool; do
9756     if test -n "$ncn_target_tool_prefix"; then
9757       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9758 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9759 echo "$as_me:$LINENO: checking for $ac_word" >&5
9760 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9761 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9762   echo $ECHO_N "(cached) $ECHO_C" >&6
9763 else
9764   if test -n "$DLLTOOL_FOR_TARGET"; then
9765   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9766 else
9767 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9768 for as_dir in $PATH
9769 do
9770   IFS=$as_save_IFS
9771   test -z "$as_dir" && as_dir=.
9772   for ac_exec_ext in '' $ac_executable_extensions; do
9773   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9774     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9775     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9776     break 2
9777   fi
9778 done
9779 done
9780
9781 fi
9782 fi
9783 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9784 if test -n "$DLLTOOL_FOR_TARGET"; then
9785   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9786 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9787 else
9788   echo "$as_me:$LINENO: result: no" >&5
9789 echo "${ECHO_T}no" >&6
9790 fi
9791
9792     fi
9793     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9794       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9795 set dummy ${ncn_progname}; ac_word=$2
9796 echo "$as_me:$LINENO: checking for $ac_word" >&5
9797 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9798 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9799   echo $ECHO_N "(cached) $ECHO_C" >&6
9800 else
9801   if test -n "$DLLTOOL_FOR_TARGET"; then
9802   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9803 else
9804 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9805 for as_dir in $PATH
9806 do
9807   IFS=$as_save_IFS
9808   test -z "$as_dir" && as_dir=.
9809   for ac_exec_ext in '' $ac_executable_extensions; do
9810   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9811     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9812     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9813     break 2
9814   fi
9815 done
9816 done
9817
9818 fi
9819 fi
9820 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9821 if test -n "$DLLTOOL_FOR_TARGET"; then
9822   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9823 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9824 else
9825   echo "$as_me:$LINENO: result: no" >&5
9826 echo "${ECHO_T}no" >&6
9827 fi
9828
9829     fi
9830     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9831   done
9832 fi
9833
9834 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9835   set dummy dlltool
9836   if test $build = $target ; then
9837     DLLTOOL_FOR_TARGET="$2"
9838   else
9839     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9840   fi
9841 else
9842   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9843 fi
9844
9845 else
9846   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9847 fi
9848
9849
9850
9851
9852 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9853   if test -n "$with_build_time_tools"; then
9854     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9855 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9856     if test -x $with_build_time_tools/ld; then
9857       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9858       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9859       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9860 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9861     else
9862       echo "$as_me:$LINENO: result: no" >&5
9863 echo "${ECHO_T}no" >&6
9864     fi
9865   elif test $build != $host && test $have_gcc_for_target = yes; then
9866     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9867     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9868     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9869   fi
9870 fi
9871 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9872   # Extract the first word of "ld", so it can be a program name with args.
9873 set dummy ld; ac_word=$2
9874 echo "$as_me:$LINENO: checking for $ac_word" >&5
9875 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9876 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9877   echo $ECHO_N "(cached) $ECHO_C" >&6
9878 else
9879   case $LD_FOR_TARGET in
9880   [\\/]* | ?:[\\/]*)
9881   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9882   ;;
9883   *)
9884   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9885 for as_dir in $gcc_cv_tool_dirs
9886 do
9887   IFS=$as_save_IFS
9888   test -z "$as_dir" && as_dir=.
9889   for ac_exec_ext in '' $ac_executable_extensions; do
9890   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9891     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9892     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9893     break 2
9894   fi
9895 done
9896 done
9897
9898   ;;
9899 esac
9900 fi
9901 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9902
9903 if test -n "$LD_FOR_TARGET"; then
9904   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9905 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9906 else
9907   echo "$as_me:$LINENO: result: no" >&5
9908 echo "${ECHO_T}no" >&6
9909 fi
9910
9911 fi
9912 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9913
9914
9915 if test -n "$LD_FOR_TARGET"; then
9916   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9917 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9918   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9919 fi
9920
9921 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9922   for ncn_progname in ld; do
9923     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9924 set dummy ${ncn_progname}; ac_word=$2
9925 echo "$as_me:$LINENO: checking for $ac_word" >&5
9926 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9927 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9928   echo $ECHO_N "(cached) $ECHO_C" >&6
9929 else
9930   if test -n "$LD_FOR_TARGET"; then
9931   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9932 else
9933 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9934 for as_dir in $PATH
9935 do
9936   IFS=$as_save_IFS
9937   test -z "$as_dir" && as_dir=.
9938   for ac_exec_ext in '' $ac_executable_extensions; do
9939   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9940     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9941     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9942     break 2
9943   fi
9944 done
9945 done
9946
9947 fi
9948 fi
9949 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9950 if test -n "$LD_FOR_TARGET"; then
9951   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9952 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9953 else
9954   echo "$as_me:$LINENO: result: no" >&5
9955 echo "${ECHO_T}no" >&6
9956 fi
9957
9958   done
9959 fi
9960
9961 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9962   for ncn_progname in ld; do
9963     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9964 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9965     if test -x $with_build_time_tools/${ncn_progname}; then
9966       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9967       echo "$as_me:$LINENO: result: yes" >&5
9968 echo "${ECHO_T}yes" >&6
9969       break
9970     else
9971       echo "$as_me:$LINENO: result: no" >&5
9972 echo "${ECHO_T}no" >&6
9973     fi
9974   done
9975 fi
9976
9977 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9978   for ncn_progname in ld; do
9979     if test -n "$ncn_target_tool_prefix"; then
9980       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9981 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9982 echo "$as_me:$LINENO: checking for $ac_word" >&5
9983 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9984 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9985   echo $ECHO_N "(cached) $ECHO_C" >&6
9986 else
9987   if test -n "$LD_FOR_TARGET"; then
9988   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9989 else
9990 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9991 for as_dir in $PATH
9992 do
9993   IFS=$as_save_IFS
9994   test -z "$as_dir" && as_dir=.
9995   for ac_exec_ext in '' $ac_executable_extensions; do
9996   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9997     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9998     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9999     break 2
10000   fi
10001 done
10002 done
10003
10004 fi
10005 fi
10006 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10007 if test -n "$LD_FOR_TARGET"; then
10008   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10009 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10010 else
10011   echo "$as_me:$LINENO: result: no" >&5
10012 echo "${ECHO_T}no" >&6
10013 fi
10014
10015     fi
10016     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10017       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10018 set dummy ${ncn_progname}; ac_word=$2
10019 echo "$as_me:$LINENO: checking for $ac_word" >&5
10020 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10021 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10022   echo $ECHO_N "(cached) $ECHO_C" >&6
10023 else
10024   if test -n "$LD_FOR_TARGET"; then
10025   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10026 else
10027 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10028 for as_dir in $PATH
10029 do
10030   IFS=$as_save_IFS
10031   test -z "$as_dir" && as_dir=.
10032   for ac_exec_ext in '' $ac_executable_extensions; do
10033   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10034     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10035     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10036     break 2
10037   fi
10038 done
10039 done
10040
10041 fi
10042 fi
10043 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10044 if test -n "$LD_FOR_TARGET"; then
10045   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10046 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10047 else
10048   echo "$as_me:$LINENO: result: no" >&5
10049 echo "${ECHO_T}no" >&6
10050 fi
10051
10052     fi
10053     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10054   done
10055 fi
10056
10057 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10058   set dummy ld
10059   if test $build = $target ; then
10060     LD_FOR_TARGET="$2"
10061   else
10062     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10063   fi
10064 else
10065   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10066 fi
10067
10068 else
10069   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10070 fi
10071
10072
10073
10074
10075 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10076   if test -n "$with_build_time_tools"; then
10077     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10078 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10079     if test -x $with_build_time_tools/lipo; then
10080       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10081       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10082       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10083 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10084     else
10085       echo "$as_me:$LINENO: result: no" >&5
10086 echo "${ECHO_T}no" >&6
10087     fi
10088   elif test $build != $host && test $have_gcc_for_target = yes; then
10089     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10090     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10091     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10092   fi
10093 fi
10094 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10095   # Extract the first word of "lipo", so it can be a program name with args.
10096 set dummy lipo; ac_word=$2
10097 echo "$as_me:$LINENO: checking for $ac_word" >&5
10098 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10099 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10100   echo $ECHO_N "(cached) $ECHO_C" >&6
10101 else
10102   case $LIPO_FOR_TARGET in
10103   [\\/]* | ?:[\\/]*)
10104   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10105   ;;
10106   *)
10107   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10108 for as_dir in $gcc_cv_tool_dirs
10109 do
10110   IFS=$as_save_IFS
10111   test -z "$as_dir" && as_dir=.
10112   for ac_exec_ext in '' $ac_executable_extensions; do
10113   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10114     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10115     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10116     break 2
10117   fi
10118 done
10119 done
10120
10121   ;;
10122 esac
10123 fi
10124 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10125
10126 if test -n "$LIPO_FOR_TARGET"; then
10127   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10128 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10129 else
10130   echo "$as_me:$LINENO: result: no" >&5
10131 echo "${ECHO_T}no" >&6
10132 fi
10133
10134 fi
10135 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10136
10137
10138 if test -n "$LIPO_FOR_TARGET"; then
10139   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10140 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10141   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10142 fi
10143
10144 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10145   for ncn_progname in lipo; do
10146     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10147 set dummy ${ncn_progname}; ac_word=$2
10148 echo "$as_me:$LINENO: checking for $ac_word" >&5
10149 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10150 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10151   echo $ECHO_N "(cached) $ECHO_C" >&6
10152 else
10153   if test -n "$LIPO_FOR_TARGET"; then
10154   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10155 else
10156 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10157 for as_dir in $PATH
10158 do
10159   IFS=$as_save_IFS
10160   test -z "$as_dir" && as_dir=.
10161   for ac_exec_ext in '' $ac_executable_extensions; do
10162   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10163     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10164     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10165     break 2
10166   fi
10167 done
10168 done
10169
10170 fi
10171 fi
10172 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10173 if test -n "$LIPO_FOR_TARGET"; then
10174   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10175 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10176 else
10177   echo "$as_me:$LINENO: result: no" >&5
10178 echo "${ECHO_T}no" >&6
10179 fi
10180
10181   done
10182 fi
10183
10184 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10185   for ncn_progname in lipo; do
10186     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10187 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10188     if test -x $with_build_time_tools/${ncn_progname}; then
10189       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10190       echo "$as_me:$LINENO: result: yes" >&5
10191 echo "${ECHO_T}yes" >&6
10192       break
10193     else
10194       echo "$as_me:$LINENO: result: no" >&5
10195 echo "${ECHO_T}no" >&6
10196     fi
10197   done
10198 fi
10199
10200 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10201   for ncn_progname in lipo; do
10202     if test -n "$ncn_target_tool_prefix"; then
10203       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10204 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10205 echo "$as_me:$LINENO: checking for $ac_word" >&5
10206 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10207 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10208   echo $ECHO_N "(cached) $ECHO_C" >&6
10209 else
10210   if test -n "$LIPO_FOR_TARGET"; then
10211   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10212 else
10213 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10214 for as_dir in $PATH
10215 do
10216   IFS=$as_save_IFS
10217   test -z "$as_dir" && as_dir=.
10218   for ac_exec_ext in '' $ac_executable_extensions; do
10219   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10220     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10221     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10222     break 2
10223   fi
10224 done
10225 done
10226
10227 fi
10228 fi
10229 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10230 if test -n "$LIPO_FOR_TARGET"; then
10231   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10232 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10233 else
10234   echo "$as_me:$LINENO: result: no" >&5
10235 echo "${ECHO_T}no" >&6
10236 fi
10237
10238     fi
10239     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10240       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10241 set dummy ${ncn_progname}; ac_word=$2
10242 echo "$as_me:$LINENO: checking for $ac_word" >&5
10243 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10244 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10245   echo $ECHO_N "(cached) $ECHO_C" >&6
10246 else
10247   if test -n "$LIPO_FOR_TARGET"; then
10248   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10249 else
10250 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10251 for as_dir in $PATH
10252 do
10253   IFS=$as_save_IFS
10254   test -z "$as_dir" && as_dir=.
10255   for ac_exec_ext in '' $ac_executable_extensions; do
10256   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10257     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10258     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10259     break 2
10260   fi
10261 done
10262 done
10263
10264 fi
10265 fi
10266 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10267 if test -n "$LIPO_FOR_TARGET"; then
10268   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10269 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10270 else
10271   echo "$as_me:$LINENO: result: no" >&5
10272 echo "${ECHO_T}no" >&6
10273 fi
10274
10275     fi
10276     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10277   done
10278 fi
10279
10280 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10281   set dummy lipo
10282   if test $build = $target ; then
10283     LIPO_FOR_TARGET="$2"
10284   else
10285     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10286   fi
10287 else
10288   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10289 fi
10290
10291 else
10292   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10293 fi
10294
10295
10296
10297
10298 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10299   if test -n "$with_build_time_tools"; then
10300     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10301 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10302     if test -x $with_build_time_tools/nm; then
10303       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10304       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10305       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10306 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10307     else
10308       echo "$as_me:$LINENO: result: no" >&5
10309 echo "${ECHO_T}no" >&6
10310     fi
10311   elif test $build != $host && test $have_gcc_for_target = yes; then
10312     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10313     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10314     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10315   fi
10316 fi
10317 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10318   # Extract the first word of "nm", so it can be a program name with args.
10319 set dummy nm; ac_word=$2
10320 echo "$as_me:$LINENO: checking for $ac_word" >&5
10321 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10322 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10323   echo $ECHO_N "(cached) $ECHO_C" >&6
10324 else
10325   case $NM_FOR_TARGET in
10326   [\\/]* | ?:[\\/]*)
10327   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10328   ;;
10329   *)
10330   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10331 for as_dir in $gcc_cv_tool_dirs
10332 do
10333   IFS=$as_save_IFS
10334   test -z "$as_dir" && as_dir=.
10335   for ac_exec_ext in '' $ac_executable_extensions; do
10336   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10337     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10338     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10339     break 2
10340   fi
10341 done
10342 done
10343
10344   ;;
10345 esac
10346 fi
10347 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10348
10349 if test -n "$NM_FOR_TARGET"; then
10350   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10351 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10352 else
10353   echo "$as_me:$LINENO: result: no" >&5
10354 echo "${ECHO_T}no" >&6
10355 fi
10356
10357 fi
10358 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10359
10360
10361 if test -n "$NM_FOR_TARGET"; then
10362   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10363 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10364   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10365 fi
10366
10367 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10368   for ncn_progname in nm; do
10369     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10370 set dummy ${ncn_progname}; ac_word=$2
10371 echo "$as_me:$LINENO: checking for $ac_word" >&5
10372 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10373 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10374   echo $ECHO_N "(cached) $ECHO_C" >&6
10375 else
10376   if test -n "$NM_FOR_TARGET"; then
10377   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10378 else
10379 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10380 for as_dir in $PATH
10381 do
10382   IFS=$as_save_IFS
10383   test -z "$as_dir" && as_dir=.
10384   for ac_exec_ext in '' $ac_executable_extensions; do
10385   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10386     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10387     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10388     break 2
10389   fi
10390 done
10391 done
10392
10393 fi
10394 fi
10395 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10396 if test -n "$NM_FOR_TARGET"; then
10397   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10398 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10399 else
10400   echo "$as_me:$LINENO: result: no" >&5
10401 echo "${ECHO_T}no" >&6
10402 fi
10403
10404   done
10405 fi
10406
10407 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10408   for ncn_progname in nm; do
10409     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10410 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10411     if test -x $with_build_time_tools/${ncn_progname}; then
10412       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10413       echo "$as_me:$LINENO: result: yes" >&5
10414 echo "${ECHO_T}yes" >&6
10415       break
10416     else
10417       echo "$as_me:$LINENO: result: no" >&5
10418 echo "${ECHO_T}no" >&6
10419     fi
10420   done
10421 fi
10422
10423 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10424   for ncn_progname in nm; do
10425     if test -n "$ncn_target_tool_prefix"; then
10426       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10427 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10428 echo "$as_me:$LINENO: checking for $ac_word" >&5
10429 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10430 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10431   echo $ECHO_N "(cached) $ECHO_C" >&6
10432 else
10433   if test -n "$NM_FOR_TARGET"; then
10434   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10435 else
10436 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10437 for as_dir in $PATH
10438 do
10439   IFS=$as_save_IFS
10440   test -z "$as_dir" && as_dir=.
10441   for ac_exec_ext in '' $ac_executable_extensions; do
10442   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10443     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10444     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10445     break 2
10446   fi
10447 done
10448 done
10449
10450 fi
10451 fi
10452 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10453 if test -n "$NM_FOR_TARGET"; then
10454   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10455 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10456 else
10457   echo "$as_me:$LINENO: result: no" >&5
10458 echo "${ECHO_T}no" >&6
10459 fi
10460
10461     fi
10462     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10463       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10464 set dummy ${ncn_progname}; ac_word=$2
10465 echo "$as_me:$LINENO: checking for $ac_word" >&5
10466 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10467 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10468   echo $ECHO_N "(cached) $ECHO_C" >&6
10469 else
10470   if test -n "$NM_FOR_TARGET"; then
10471   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10472 else
10473 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10474 for as_dir in $PATH
10475 do
10476   IFS=$as_save_IFS
10477   test -z "$as_dir" && as_dir=.
10478   for ac_exec_ext in '' $ac_executable_extensions; do
10479   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10480     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10481     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10482     break 2
10483   fi
10484 done
10485 done
10486
10487 fi
10488 fi
10489 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10490 if test -n "$NM_FOR_TARGET"; then
10491   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10492 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10493 else
10494   echo "$as_me:$LINENO: result: no" >&5
10495 echo "${ECHO_T}no" >&6
10496 fi
10497
10498     fi
10499     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10500   done
10501 fi
10502
10503 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10504   set dummy nm
10505   if test $build = $target ; then
10506     NM_FOR_TARGET="$2"
10507   else
10508     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10509   fi
10510 else
10511   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10512 fi
10513
10514 else
10515   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10516 fi
10517
10518
10519
10520
10521 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10522   if test -n "$with_build_time_tools"; then
10523     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10524 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10525     if test -x $with_build_time_tools/objdump; then
10526       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10527       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10528       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10529 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10530     else
10531       echo "$as_me:$LINENO: result: no" >&5
10532 echo "${ECHO_T}no" >&6
10533     fi
10534   elif test $build != $host && test $have_gcc_for_target = yes; then
10535     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10536     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10537     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10538   fi
10539 fi
10540 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10541   # Extract the first word of "objdump", so it can be a program name with args.
10542 set dummy objdump; ac_word=$2
10543 echo "$as_me:$LINENO: checking for $ac_word" >&5
10544 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10545 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10546   echo $ECHO_N "(cached) $ECHO_C" >&6
10547 else
10548   case $OBJDUMP_FOR_TARGET in
10549   [\\/]* | ?:[\\/]*)
10550   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10551   ;;
10552   *)
10553   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10554 for as_dir in $gcc_cv_tool_dirs
10555 do
10556   IFS=$as_save_IFS
10557   test -z "$as_dir" && as_dir=.
10558   for ac_exec_ext in '' $ac_executable_extensions; do
10559   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10560     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10561     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10562     break 2
10563   fi
10564 done
10565 done
10566
10567   ;;
10568 esac
10569 fi
10570 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10571
10572 if test -n "$OBJDUMP_FOR_TARGET"; then
10573   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10574 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10575 else
10576   echo "$as_me:$LINENO: result: no" >&5
10577 echo "${ECHO_T}no" >&6
10578 fi
10579
10580 fi
10581 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10582
10583
10584 if test -n "$OBJDUMP_FOR_TARGET"; then
10585   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10586 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10587   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10588 fi
10589
10590 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10591   for ncn_progname in objdump; do
10592     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10593 set dummy ${ncn_progname}; ac_word=$2
10594 echo "$as_me:$LINENO: checking for $ac_word" >&5
10595 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10596 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10597   echo $ECHO_N "(cached) $ECHO_C" >&6
10598 else
10599   if test -n "$OBJDUMP_FOR_TARGET"; then
10600   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10601 else
10602 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10603 for as_dir in $PATH
10604 do
10605   IFS=$as_save_IFS
10606   test -z "$as_dir" && as_dir=.
10607   for ac_exec_ext in '' $ac_executable_extensions; do
10608   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10609     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10610     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10611     break 2
10612   fi
10613 done
10614 done
10615
10616 fi
10617 fi
10618 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10619 if test -n "$OBJDUMP_FOR_TARGET"; then
10620   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10621 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10622 else
10623   echo "$as_me:$LINENO: result: no" >&5
10624 echo "${ECHO_T}no" >&6
10625 fi
10626
10627   done
10628 fi
10629
10630 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10631   for ncn_progname in objdump; do
10632     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10633 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10634     if test -x $with_build_time_tools/${ncn_progname}; then
10635       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10636       echo "$as_me:$LINENO: result: yes" >&5
10637 echo "${ECHO_T}yes" >&6
10638       break
10639     else
10640       echo "$as_me:$LINENO: result: no" >&5
10641 echo "${ECHO_T}no" >&6
10642     fi
10643   done
10644 fi
10645
10646 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10647   for ncn_progname in objdump; do
10648     if test -n "$ncn_target_tool_prefix"; then
10649       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10650 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10651 echo "$as_me:$LINENO: checking for $ac_word" >&5
10652 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10653 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10654   echo $ECHO_N "(cached) $ECHO_C" >&6
10655 else
10656   if test -n "$OBJDUMP_FOR_TARGET"; then
10657   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10658 else
10659 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10660 for as_dir in $PATH
10661 do
10662   IFS=$as_save_IFS
10663   test -z "$as_dir" && as_dir=.
10664   for ac_exec_ext in '' $ac_executable_extensions; do
10665   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10666     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10667     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10668     break 2
10669   fi
10670 done
10671 done
10672
10673 fi
10674 fi
10675 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10676 if test -n "$OBJDUMP_FOR_TARGET"; then
10677   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10678 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10679 else
10680   echo "$as_me:$LINENO: result: no" >&5
10681 echo "${ECHO_T}no" >&6
10682 fi
10683
10684     fi
10685     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10686       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10687 set dummy ${ncn_progname}; ac_word=$2
10688 echo "$as_me:$LINENO: checking for $ac_word" >&5
10689 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10690 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10691   echo $ECHO_N "(cached) $ECHO_C" >&6
10692 else
10693   if test -n "$OBJDUMP_FOR_TARGET"; then
10694   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10695 else
10696 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10697 for as_dir in $PATH
10698 do
10699   IFS=$as_save_IFS
10700   test -z "$as_dir" && as_dir=.
10701   for ac_exec_ext in '' $ac_executable_extensions; do
10702   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10703     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10704     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10705     break 2
10706   fi
10707 done
10708 done
10709
10710 fi
10711 fi
10712 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10713 if test -n "$OBJDUMP_FOR_TARGET"; then
10714   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10715 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10716 else
10717   echo "$as_me:$LINENO: result: no" >&5
10718 echo "${ECHO_T}no" >&6
10719 fi
10720
10721     fi
10722     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10723   done
10724 fi
10725
10726 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10727   set dummy objdump
10728   if test $build = $target ; then
10729     OBJDUMP_FOR_TARGET="$2"
10730   else
10731     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10732   fi
10733 else
10734   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10735 fi
10736
10737 else
10738   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10739 fi
10740
10741
10742
10743
10744 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10745   if test -n "$with_build_time_tools"; then
10746     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10747 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10748     if test -x $with_build_time_tools/ranlib; then
10749       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10750       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10751       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10752 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10753     else
10754       echo "$as_me:$LINENO: result: no" >&5
10755 echo "${ECHO_T}no" >&6
10756     fi
10757   elif test $build != $host && test $have_gcc_for_target = yes; then
10758     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10759     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10760     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10761   fi
10762 fi
10763 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10764   # Extract the first word of "ranlib", so it can be a program name with args.
10765 set dummy ranlib; ac_word=$2
10766 echo "$as_me:$LINENO: checking for $ac_word" >&5
10767 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10768 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10769   echo $ECHO_N "(cached) $ECHO_C" >&6
10770 else
10771   case $RANLIB_FOR_TARGET in
10772   [\\/]* | ?:[\\/]*)
10773   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10774   ;;
10775   *)
10776   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10777 for as_dir in $gcc_cv_tool_dirs
10778 do
10779   IFS=$as_save_IFS
10780   test -z "$as_dir" && as_dir=.
10781   for ac_exec_ext in '' $ac_executable_extensions; do
10782   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10783     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10784     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10785     break 2
10786   fi
10787 done
10788 done
10789
10790   ;;
10791 esac
10792 fi
10793 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10794
10795 if test -n "$RANLIB_FOR_TARGET"; then
10796   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10797 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10798 else
10799   echo "$as_me:$LINENO: result: no" >&5
10800 echo "${ECHO_T}no" >&6
10801 fi
10802
10803 fi
10804 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10805
10806
10807 if test -n "$RANLIB_FOR_TARGET"; then
10808   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10809 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10810   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10811 fi
10812
10813 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10814   for ncn_progname in ranlib; do
10815     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10816 set dummy ${ncn_progname}; ac_word=$2
10817 echo "$as_me:$LINENO: checking for $ac_word" >&5
10818 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10819 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10820   echo $ECHO_N "(cached) $ECHO_C" >&6
10821 else
10822   if test -n "$RANLIB_FOR_TARGET"; then
10823   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10824 else
10825 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10826 for as_dir in $PATH
10827 do
10828   IFS=$as_save_IFS
10829   test -z "$as_dir" && as_dir=.
10830   for ac_exec_ext in '' $ac_executable_extensions; do
10831   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10832     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10833     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10834     break 2
10835   fi
10836 done
10837 done
10838
10839 fi
10840 fi
10841 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10842 if test -n "$RANLIB_FOR_TARGET"; then
10843   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10844 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10845 else
10846   echo "$as_me:$LINENO: result: no" >&5
10847 echo "${ECHO_T}no" >&6
10848 fi
10849
10850   done
10851 fi
10852
10853 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10854   for ncn_progname in ranlib; do
10855     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10856 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10857     if test -x $with_build_time_tools/${ncn_progname}; then
10858       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10859       echo "$as_me:$LINENO: result: yes" >&5
10860 echo "${ECHO_T}yes" >&6
10861       break
10862     else
10863       echo "$as_me:$LINENO: result: no" >&5
10864 echo "${ECHO_T}no" >&6
10865     fi
10866   done
10867 fi
10868
10869 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10870   for ncn_progname in ranlib; do
10871     if test -n "$ncn_target_tool_prefix"; then
10872       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10873 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10874 echo "$as_me:$LINENO: checking for $ac_word" >&5
10875 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10876 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10877   echo $ECHO_N "(cached) $ECHO_C" >&6
10878 else
10879   if test -n "$RANLIB_FOR_TARGET"; then
10880   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10881 else
10882 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10883 for as_dir in $PATH
10884 do
10885   IFS=$as_save_IFS
10886   test -z "$as_dir" && as_dir=.
10887   for ac_exec_ext in '' $ac_executable_extensions; do
10888   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10889     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10890     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10891     break 2
10892   fi
10893 done
10894 done
10895
10896 fi
10897 fi
10898 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10899 if test -n "$RANLIB_FOR_TARGET"; then
10900   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10901 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10902 else
10903   echo "$as_me:$LINENO: result: no" >&5
10904 echo "${ECHO_T}no" >&6
10905 fi
10906
10907     fi
10908     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10909       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10910 set dummy ${ncn_progname}; ac_word=$2
10911 echo "$as_me:$LINENO: checking for $ac_word" >&5
10912 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10913 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10914   echo $ECHO_N "(cached) $ECHO_C" >&6
10915 else
10916   if test -n "$RANLIB_FOR_TARGET"; then
10917   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10918 else
10919 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10920 for as_dir in $PATH
10921 do
10922   IFS=$as_save_IFS
10923   test -z "$as_dir" && as_dir=.
10924   for ac_exec_ext in '' $ac_executable_extensions; do
10925   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10926     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10927     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10928     break 2
10929   fi
10930 done
10931 done
10932
10933 fi
10934 fi
10935 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10936 if test -n "$RANLIB_FOR_TARGET"; then
10937   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10938 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10939 else
10940   echo "$as_me:$LINENO: result: no" >&5
10941 echo "${ECHO_T}no" >&6
10942 fi
10943
10944     fi
10945     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10946   done
10947 fi
10948
10949 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10950   set dummy ranlib
10951   if test $build = $target ; then
10952     RANLIB_FOR_TARGET="$2"
10953   else
10954     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10955   fi
10956 else
10957   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10958 fi
10959
10960 else
10961   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10962 fi
10963
10964
10965
10966
10967 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10968   if test -n "$with_build_time_tools"; then
10969     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10970 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10971     if test -x $with_build_time_tools/strip; then
10972       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10973       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10974       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10975 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10976     else
10977       echo "$as_me:$LINENO: result: no" >&5
10978 echo "${ECHO_T}no" >&6
10979     fi
10980   elif test $build != $host && test $have_gcc_for_target = yes; then
10981     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10982     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10983     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10984   fi
10985 fi
10986 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10987   # Extract the first word of "strip", so it can be a program name with args.
10988 set dummy strip; ac_word=$2
10989 echo "$as_me:$LINENO: checking for $ac_word" >&5
10990 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10991 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10992   echo $ECHO_N "(cached) $ECHO_C" >&6
10993 else
10994   case $STRIP_FOR_TARGET in
10995   [\\/]* | ?:[\\/]*)
10996   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10997   ;;
10998   *)
10999   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11000 for as_dir in $gcc_cv_tool_dirs
11001 do
11002   IFS=$as_save_IFS
11003   test -z "$as_dir" && as_dir=.
11004   for ac_exec_ext in '' $ac_executable_extensions; do
11005   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11006     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11007     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11008     break 2
11009   fi
11010 done
11011 done
11012
11013   ;;
11014 esac
11015 fi
11016 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11017
11018 if test -n "$STRIP_FOR_TARGET"; then
11019   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11020 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11021 else
11022   echo "$as_me:$LINENO: result: no" >&5
11023 echo "${ECHO_T}no" >&6
11024 fi
11025
11026 fi
11027 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11028
11029
11030 if test -n "$STRIP_FOR_TARGET"; then
11031   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11032 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11033   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11034 fi
11035
11036 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11037   for ncn_progname in strip; do
11038     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11039 set dummy ${ncn_progname}; ac_word=$2
11040 echo "$as_me:$LINENO: checking for $ac_word" >&5
11041 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11042 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11043   echo $ECHO_N "(cached) $ECHO_C" >&6
11044 else
11045   if test -n "$STRIP_FOR_TARGET"; then
11046   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11047 else
11048 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11049 for as_dir in $PATH
11050 do
11051   IFS=$as_save_IFS
11052   test -z "$as_dir" && as_dir=.
11053   for ac_exec_ext in '' $ac_executable_extensions; do
11054   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11055     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11056     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11057     break 2
11058   fi
11059 done
11060 done
11061
11062 fi
11063 fi
11064 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11065 if test -n "$STRIP_FOR_TARGET"; then
11066   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11067 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11068 else
11069   echo "$as_me:$LINENO: result: no" >&5
11070 echo "${ECHO_T}no" >&6
11071 fi
11072
11073   done
11074 fi
11075
11076 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11077   for ncn_progname in strip; do
11078     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11079 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11080     if test -x $with_build_time_tools/${ncn_progname}; then
11081       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11082       echo "$as_me:$LINENO: result: yes" >&5
11083 echo "${ECHO_T}yes" >&6
11084       break
11085     else
11086       echo "$as_me:$LINENO: result: no" >&5
11087 echo "${ECHO_T}no" >&6
11088     fi
11089   done
11090 fi
11091
11092 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11093   for ncn_progname in strip; do
11094     if test -n "$ncn_target_tool_prefix"; then
11095       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11096 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11097 echo "$as_me:$LINENO: checking for $ac_word" >&5
11098 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11099 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11100   echo $ECHO_N "(cached) $ECHO_C" >&6
11101 else
11102   if test -n "$STRIP_FOR_TARGET"; then
11103   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11104 else
11105 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11106 for as_dir in $PATH
11107 do
11108   IFS=$as_save_IFS
11109   test -z "$as_dir" && as_dir=.
11110   for ac_exec_ext in '' $ac_executable_extensions; do
11111   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11112     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11113     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11114     break 2
11115   fi
11116 done
11117 done
11118
11119 fi
11120 fi
11121 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11122 if test -n "$STRIP_FOR_TARGET"; then
11123   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11124 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11125 else
11126   echo "$as_me:$LINENO: result: no" >&5
11127 echo "${ECHO_T}no" >&6
11128 fi
11129
11130     fi
11131     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11132       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11133 set dummy ${ncn_progname}; ac_word=$2
11134 echo "$as_me:$LINENO: checking for $ac_word" >&5
11135 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11136 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11137   echo $ECHO_N "(cached) $ECHO_C" >&6
11138 else
11139   if test -n "$STRIP_FOR_TARGET"; then
11140   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11141 else
11142 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11143 for as_dir in $PATH
11144 do
11145   IFS=$as_save_IFS
11146   test -z "$as_dir" && as_dir=.
11147   for ac_exec_ext in '' $ac_executable_extensions; do
11148   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11149     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11150     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11151     break 2
11152   fi
11153 done
11154 done
11155
11156 fi
11157 fi
11158 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11159 if test -n "$STRIP_FOR_TARGET"; then
11160   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11161 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11162 else
11163   echo "$as_me:$LINENO: result: no" >&5
11164 echo "${ECHO_T}no" >&6
11165 fi
11166
11167     fi
11168     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11169   done
11170 fi
11171
11172 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11173   set dummy strip
11174   if test $build = $target ; then
11175     STRIP_FOR_TARGET="$2"
11176   else
11177     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11178   fi
11179 else
11180   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11181 fi
11182
11183 else
11184   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11185 fi
11186
11187
11188
11189
11190 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11191   if test -n "$with_build_time_tools"; then
11192     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11193 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11194     if test -x $with_build_time_tools/windres; then
11195       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11196       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11197       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11198 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11199     else
11200       echo "$as_me:$LINENO: result: no" >&5
11201 echo "${ECHO_T}no" >&6
11202     fi
11203   elif test $build != $host && test $have_gcc_for_target = yes; then
11204     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11205     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11206     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11207   fi
11208 fi
11209 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11210   # Extract the first word of "windres", so it can be a program name with args.
11211 set dummy windres; ac_word=$2
11212 echo "$as_me:$LINENO: checking for $ac_word" >&5
11213 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11214 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11215   echo $ECHO_N "(cached) $ECHO_C" >&6
11216 else
11217   case $WINDRES_FOR_TARGET in
11218   [\\/]* | ?:[\\/]*)
11219   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11220   ;;
11221   *)
11222   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11223 for as_dir in $gcc_cv_tool_dirs
11224 do
11225   IFS=$as_save_IFS
11226   test -z "$as_dir" && as_dir=.
11227   for ac_exec_ext in '' $ac_executable_extensions; do
11228   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11229     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11230     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11231     break 2
11232   fi
11233 done
11234 done
11235
11236   ;;
11237 esac
11238 fi
11239 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11240
11241 if test -n "$WINDRES_FOR_TARGET"; then
11242   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11243 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11244 else
11245   echo "$as_me:$LINENO: result: no" >&5
11246 echo "${ECHO_T}no" >&6
11247 fi
11248
11249 fi
11250 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11251
11252
11253 if test -n "$WINDRES_FOR_TARGET"; then
11254   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11255 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11256   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11257 fi
11258
11259 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11260   for ncn_progname in windres; do
11261     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11262 set dummy ${ncn_progname}; ac_word=$2
11263 echo "$as_me:$LINENO: checking for $ac_word" >&5
11264 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11265 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11266   echo $ECHO_N "(cached) $ECHO_C" >&6
11267 else
11268   if test -n "$WINDRES_FOR_TARGET"; then
11269   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11270 else
11271 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11272 for as_dir in $PATH
11273 do
11274   IFS=$as_save_IFS
11275   test -z "$as_dir" && as_dir=.
11276   for ac_exec_ext in '' $ac_executable_extensions; do
11277   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11278     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11279     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11280     break 2
11281   fi
11282 done
11283 done
11284
11285 fi
11286 fi
11287 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11288 if test -n "$WINDRES_FOR_TARGET"; then
11289   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11290 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11291 else
11292   echo "$as_me:$LINENO: result: no" >&5
11293 echo "${ECHO_T}no" >&6
11294 fi
11295
11296   done
11297 fi
11298
11299 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11300   for ncn_progname in windres; do
11301     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11302 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11303     if test -x $with_build_time_tools/${ncn_progname}; then
11304       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11305       echo "$as_me:$LINENO: result: yes" >&5
11306 echo "${ECHO_T}yes" >&6
11307       break
11308     else
11309       echo "$as_me:$LINENO: result: no" >&5
11310 echo "${ECHO_T}no" >&6
11311     fi
11312   done
11313 fi
11314
11315 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11316   for ncn_progname in windres; do
11317     if test -n "$ncn_target_tool_prefix"; then
11318       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11319 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11320 echo "$as_me:$LINENO: checking for $ac_word" >&5
11321 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11322 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11323   echo $ECHO_N "(cached) $ECHO_C" >&6
11324 else
11325   if test -n "$WINDRES_FOR_TARGET"; then
11326   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11327 else
11328 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11329 for as_dir in $PATH
11330 do
11331   IFS=$as_save_IFS
11332   test -z "$as_dir" && as_dir=.
11333   for ac_exec_ext in '' $ac_executable_extensions; do
11334   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11335     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11336     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11337     break 2
11338   fi
11339 done
11340 done
11341
11342 fi
11343 fi
11344 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11345 if test -n "$WINDRES_FOR_TARGET"; then
11346   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11347 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11348 else
11349   echo "$as_me:$LINENO: result: no" >&5
11350 echo "${ECHO_T}no" >&6
11351 fi
11352
11353     fi
11354     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11355       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11356 set dummy ${ncn_progname}; ac_word=$2
11357 echo "$as_me:$LINENO: checking for $ac_word" >&5
11358 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11359 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11360   echo $ECHO_N "(cached) $ECHO_C" >&6
11361 else
11362   if test -n "$WINDRES_FOR_TARGET"; then
11363   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11364 else
11365 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11366 for as_dir in $PATH
11367 do
11368   IFS=$as_save_IFS
11369   test -z "$as_dir" && as_dir=.
11370   for ac_exec_ext in '' $ac_executable_extensions; do
11371   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11372     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11373     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11374     break 2
11375   fi
11376 done
11377 done
11378
11379 fi
11380 fi
11381 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11382 if test -n "$WINDRES_FOR_TARGET"; then
11383   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11384 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11385 else
11386   echo "$as_me:$LINENO: result: no" >&5
11387 echo "${ECHO_T}no" >&6
11388 fi
11389
11390     fi
11391     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11392   done
11393 fi
11394
11395 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11396   set dummy windres
11397   if test $build = $target ; then
11398     WINDRES_FOR_TARGET="$2"
11399   else
11400     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11401   fi
11402 else
11403   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11404 fi
11405
11406 else
11407   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11408 fi
11409
11410
11411
11412
11413 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11414   if test -n "$with_build_time_tools"; then
11415     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11416 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11417     if test -x $with_build_time_tools/windmc; then
11418       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11419       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11420       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11421 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11422     else
11423       echo "$as_me:$LINENO: result: no" >&5
11424 echo "${ECHO_T}no" >&6
11425     fi
11426   elif test $build != $host && test $have_gcc_for_target = yes; then
11427     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11428     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11429     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11430   fi
11431 fi
11432 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11433   # Extract the first word of "windmc", so it can be a program name with args.
11434 set dummy windmc; ac_word=$2
11435 echo "$as_me:$LINENO: checking for $ac_word" >&5
11436 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11437 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11438   echo $ECHO_N "(cached) $ECHO_C" >&6
11439 else
11440   case $WINDMC_FOR_TARGET in
11441   [\\/]* | ?:[\\/]*)
11442   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11443   ;;
11444   *)
11445   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11446 for as_dir in $gcc_cv_tool_dirs
11447 do
11448   IFS=$as_save_IFS
11449   test -z "$as_dir" && as_dir=.
11450   for ac_exec_ext in '' $ac_executable_extensions; do
11451   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11452     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11453     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11454     break 2
11455   fi
11456 done
11457 done
11458
11459   ;;
11460 esac
11461 fi
11462 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11463
11464 if test -n "$WINDMC_FOR_TARGET"; then
11465   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11466 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11467 else
11468   echo "$as_me:$LINENO: result: no" >&5
11469 echo "${ECHO_T}no" >&6
11470 fi
11471
11472 fi
11473 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11474
11475
11476 if test -n "$WINDMC_FOR_TARGET"; then
11477   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11478 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11479   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11480 fi
11481
11482 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11483   for ncn_progname in windmc; do
11484     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11485 set dummy ${ncn_progname}; ac_word=$2
11486 echo "$as_me:$LINENO: checking for $ac_word" >&5
11487 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11488 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11489   echo $ECHO_N "(cached) $ECHO_C" >&6
11490 else
11491   if test -n "$WINDMC_FOR_TARGET"; then
11492   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11493 else
11494 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11495 for as_dir in $PATH
11496 do
11497   IFS=$as_save_IFS
11498   test -z "$as_dir" && as_dir=.
11499   for ac_exec_ext in '' $ac_executable_extensions; do
11500   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11501     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11502     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11503     break 2
11504   fi
11505 done
11506 done
11507
11508 fi
11509 fi
11510 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11511 if test -n "$WINDMC_FOR_TARGET"; then
11512   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11513 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11514 else
11515   echo "$as_me:$LINENO: result: no" >&5
11516 echo "${ECHO_T}no" >&6
11517 fi
11518
11519   done
11520 fi
11521
11522 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11523   for ncn_progname in windmc; do
11524     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11525 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11526     if test -x $with_build_time_tools/${ncn_progname}; then
11527       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11528       echo "$as_me:$LINENO: result: yes" >&5
11529 echo "${ECHO_T}yes" >&6
11530       break
11531     else
11532       echo "$as_me:$LINENO: result: no" >&5
11533 echo "${ECHO_T}no" >&6
11534     fi
11535   done
11536 fi
11537
11538 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11539   for ncn_progname in windmc; do
11540     if test -n "$ncn_target_tool_prefix"; then
11541       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11542 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11543 echo "$as_me:$LINENO: checking for $ac_word" >&5
11544 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11545 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11546   echo $ECHO_N "(cached) $ECHO_C" >&6
11547 else
11548   if test -n "$WINDMC_FOR_TARGET"; then
11549   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11550 else
11551 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11552 for as_dir in $PATH
11553 do
11554   IFS=$as_save_IFS
11555   test -z "$as_dir" && as_dir=.
11556   for ac_exec_ext in '' $ac_executable_extensions; do
11557   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11558     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11559     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11560     break 2
11561   fi
11562 done
11563 done
11564
11565 fi
11566 fi
11567 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11568 if test -n "$WINDMC_FOR_TARGET"; then
11569   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11570 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11571 else
11572   echo "$as_me:$LINENO: result: no" >&5
11573 echo "${ECHO_T}no" >&6
11574 fi
11575
11576     fi
11577     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11578       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11579 set dummy ${ncn_progname}; ac_word=$2
11580 echo "$as_me:$LINENO: checking for $ac_word" >&5
11581 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11582 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11583   echo $ECHO_N "(cached) $ECHO_C" >&6
11584 else
11585   if test -n "$WINDMC_FOR_TARGET"; then
11586   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11587 else
11588 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11589 for as_dir in $PATH
11590 do
11591   IFS=$as_save_IFS
11592   test -z "$as_dir" && as_dir=.
11593   for ac_exec_ext in '' $ac_executable_extensions; do
11594   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11595     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11596     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11597     break 2
11598   fi
11599 done
11600 done
11601
11602 fi
11603 fi
11604 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11605 if test -n "$WINDMC_FOR_TARGET"; then
11606   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11607 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11608 else
11609   echo "$as_me:$LINENO: result: no" >&5
11610 echo "${ECHO_T}no" >&6
11611 fi
11612
11613     fi
11614     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11615   done
11616 fi
11617
11618 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11619   set dummy windmc
11620   if test $build = $target ; then
11621     WINDMC_FOR_TARGET="$2"
11622   else
11623     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11624   fi
11625 else
11626   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11627 fi
11628
11629 else
11630   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11631 fi
11632
11633
11634 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11635
11636 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11637 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11638 if test "x${build}" != "x${host}" ; then
11639   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11640     # We already found the complete path
11641     ac_dir=`dirname $AR_FOR_TARGET`
11642     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11643 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11644   else
11645     # Canadian cross, just use what we found
11646     echo "$as_me:$LINENO: result: pre-installed" >&5
11647 echo "${ECHO_T}pre-installed" >&6
11648   fi
11649 else
11650   ok=yes
11651   case " ${configdirs} " in
11652     *" binutils "*) ;;
11653     *) ok=no ;;
11654   esac
11655
11656   if test $ok = yes; then
11657     # An in-tree tool is available and we can use it
11658     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11659     echo "$as_me:$LINENO: result: just compiled" >&5
11660 echo "${ECHO_T}just compiled" >&6
11661   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11662     # We already found the complete path
11663     ac_dir=`dirname $AR_FOR_TARGET`
11664     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11665 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11666   elif test "x$target" = "x$host"; then
11667     # We can use an host tool
11668     AR_FOR_TARGET='$(AR)'
11669     echo "$as_me:$LINENO: result: host tool" >&5
11670 echo "${ECHO_T}host tool" >&6
11671   else
11672     # We need a cross tool
11673     echo "$as_me:$LINENO: result: pre-installed" >&5
11674 echo "${ECHO_T}pre-installed" >&6
11675   fi
11676 fi
11677
11678 echo "$as_me:$LINENO: checking where to find the target as" >&5
11679 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11680 if test "x${build}" != "x${host}" ; then
11681   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11682     # We already found the complete path
11683     ac_dir=`dirname $AS_FOR_TARGET`
11684     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11685 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11686   else
11687     # Canadian cross, just use what we found
11688     echo "$as_me:$LINENO: result: pre-installed" >&5
11689 echo "${ECHO_T}pre-installed" >&6
11690   fi
11691 else
11692   ok=yes
11693   case " ${configdirs} " in
11694     *" gas "*) ;;
11695     *) ok=no ;;
11696   esac
11697
11698   if test $ok = yes; then
11699     # An in-tree tool is available and we can use it
11700     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11701     echo "$as_me:$LINENO: result: just compiled" >&5
11702 echo "${ECHO_T}just compiled" >&6
11703   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11704     # We already found the complete path
11705     ac_dir=`dirname $AS_FOR_TARGET`
11706     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11707 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11708   elif test "x$target" = "x$host"; then
11709     # We can use an host tool
11710     AS_FOR_TARGET='$(AS)'
11711     echo "$as_me:$LINENO: result: host tool" >&5
11712 echo "${ECHO_T}host tool" >&6
11713   else
11714     # We need a cross tool
11715     echo "$as_me:$LINENO: result: pre-installed" >&5
11716 echo "${ECHO_T}pre-installed" >&6
11717   fi
11718 fi
11719
11720 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11721 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11722 if test "x${build}" != "x${host}" ; then
11723   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11724     # We already found the complete path
11725     ac_dir=`dirname $CC_FOR_TARGET`
11726     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11727 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11728   else
11729     # Canadian cross, just use what we found
11730     echo "$as_me:$LINENO: result: pre-installed" >&5
11731 echo "${ECHO_T}pre-installed" >&6
11732   fi
11733 else
11734   ok=yes
11735   case " ${configdirs} " in
11736     *" gcc "*) ;;
11737     *) ok=no ;;
11738   esac
11739
11740   if test $ok = yes; then
11741     # An in-tree tool is available and we can use it
11742     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11743     echo "$as_me:$LINENO: result: just compiled" >&5
11744 echo "${ECHO_T}just compiled" >&6
11745   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11746     # We already found the complete path
11747     ac_dir=`dirname $CC_FOR_TARGET`
11748     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11749 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11750   elif test "x$target" = "x$host"; then
11751     # We can use an host tool
11752     CC_FOR_TARGET='$(CC)'
11753     echo "$as_me:$LINENO: result: host tool" >&5
11754 echo "${ECHO_T}host tool" >&6
11755   else
11756     # We need a cross tool
11757     echo "$as_me:$LINENO: result: pre-installed" >&5
11758 echo "${ECHO_T}pre-installed" >&6
11759   fi
11760 fi
11761
11762 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11763 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11764 if test "x${build}" != "x${host}" ; then
11765   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11766     # We already found the complete path
11767     ac_dir=`dirname $CXX_FOR_TARGET`
11768     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11769 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11770   else
11771     # Canadian cross, just use what we found
11772     echo "$as_me:$LINENO: result: pre-installed" >&5
11773 echo "${ECHO_T}pre-installed" >&6
11774   fi
11775 else
11776   ok=yes
11777   case " ${configdirs} " in
11778     *" gcc "*) ;;
11779     *) ok=no ;;
11780   esac
11781   case ,${enable_languages}, in
11782     *,c++,*) ;;
11783     *) ok=no ;;
11784   esac
11785   if test $ok = yes; then
11786     # An in-tree tool is available and we can use it
11787     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'
11788     echo "$as_me:$LINENO: result: just compiled" >&5
11789 echo "${ECHO_T}just compiled" >&6
11790   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11791     # We already found the complete path
11792     ac_dir=`dirname $CXX_FOR_TARGET`
11793     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11794 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11795   elif test "x$target" = "x$host"; then
11796     # We can use an host tool
11797     CXX_FOR_TARGET='$(CXX)'
11798     echo "$as_me:$LINENO: result: host tool" >&5
11799 echo "${ECHO_T}host tool" >&6
11800   else
11801     # We need a cross tool
11802     echo "$as_me:$LINENO: result: pre-installed" >&5
11803 echo "${ECHO_T}pre-installed" >&6
11804   fi
11805 fi
11806
11807 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11808 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11809 if test "x${build}" != "x${host}" ; then
11810   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11811     # We already found the complete path
11812     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11813     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11814 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11815   else
11816     # Canadian cross, just use what we found
11817     echo "$as_me:$LINENO: result: pre-installed" >&5
11818 echo "${ECHO_T}pre-installed" >&6
11819   fi
11820 else
11821   ok=yes
11822   case " ${configdirs} " in
11823     *" gcc "*) ;;
11824     *) ok=no ;;
11825   esac
11826   case ,${enable_languages}, in
11827     *,c++,*) ;;
11828     *) ok=no ;;
11829   esac
11830   if test $ok = yes; then
11831     # An in-tree tool is available and we can use it
11832     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'
11833     echo "$as_me:$LINENO: result: just compiled" >&5
11834 echo "${ECHO_T}just compiled" >&6
11835   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11836     # We already found the complete path
11837     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11838     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11839 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11840   elif test "x$target" = "x$host"; then
11841     # We can use an host tool
11842     RAW_CXX_FOR_TARGET='$(CXX)'
11843     echo "$as_me:$LINENO: result: host tool" >&5
11844 echo "${ECHO_T}host tool" >&6
11845   else
11846     # We need a cross tool
11847     echo "$as_me:$LINENO: result: pre-installed" >&5
11848 echo "${ECHO_T}pre-installed" >&6
11849   fi
11850 fi
11851
11852 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11853 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11854 if test "x${build}" != "x${host}" ; then
11855   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11856     # We already found the complete path
11857     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11858     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11859 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11860   else
11861     # Canadian cross, just use what we found
11862     echo "$as_me:$LINENO: result: pre-installed" >&5
11863 echo "${ECHO_T}pre-installed" >&6
11864   fi
11865 else
11866   ok=yes
11867   case " ${configdirs} " in
11868     *" binutils "*) ;;
11869     *) ok=no ;;
11870   esac
11871
11872   if test $ok = yes; then
11873     # An in-tree tool is available and we can use it
11874     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11875     echo "$as_me:$LINENO: result: just compiled" >&5
11876 echo "${ECHO_T}just compiled" >&6
11877   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11878     # We already found the complete path
11879     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11880     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11881 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11882   elif test "x$target" = "x$host"; then
11883     # We can use an host tool
11884     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11885     echo "$as_me:$LINENO: result: host tool" >&5
11886 echo "${ECHO_T}host tool" >&6
11887   else
11888     # We need a cross tool
11889     echo "$as_me:$LINENO: result: pre-installed" >&5
11890 echo "${ECHO_T}pre-installed" >&6
11891   fi
11892 fi
11893
11894 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11895 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11896 if test "x${build}" != "x${host}" ; then
11897   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11898     # We already found the complete path
11899     ac_dir=`dirname $GCC_FOR_TARGET`
11900     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11901 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11902   else
11903     # Canadian cross, just use what we found
11904     echo "$as_me:$LINENO: result: pre-installed" >&5
11905 echo "${ECHO_T}pre-installed" >&6
11906   fi
11907 else
11908   ok=yes
11909   case " ${configdirs} " in
11910     *" gcc "*) ;;
11911     *) ok=no ;;
11912   esac
11913
11914   if test $ok = yes; then
11915     # An in-tree tool is available and we can use it
11916     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11917     echo "$as_me:$LINENO: result: just compiled" >&5
11918 echo "${ECHO_T}just compiled" >&6
11919   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11920     # We already found the complete path
11921     ac_dir=`dirname $GCC_FOR_TARGET`
11922     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11923 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11924   elif test "x$target" = "x$host"; then
11925     # We can use an host tool
11926     GCC_FOR_TARGET='$()'
11927     echo "$as_me:$LINENO: result: host tool" >&5
11928 echo "${ECHO_T}host tool" >&6
11929   else
11930     # We need a cross tool
11931     echo "$as_me:$LINENO: result: pre-installed" >&5
11932 echo "${ECHO_T}pre-installed" >&6
11933   fi
11934 fi
11935
11936 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11937 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11938 if test "x${build}" != "x${host}" ; then
11939   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11940     # We already found the complete path
11941     ac_dir=`dirname $GCJ_FOR_TARGET`
11942     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11943 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11944   else
11945     # Canadian cross, just use what we found
11946     echo "$as_me:$LINENO: result: pre-installed" >&5
11947 echo "${ECHO_T}pre-installed" >&6
11948   fi
11949 else
11950   ok=yes
11951   case " ${configdirs} " in
11952     *" gcc "*) ;;
11953     *) ok=no ;;
11954   esac
11955   case ,${enable_languages}, in
11956     *,java,*) ;;
11957     *) ok=no ;;
11958   esac
11959   if test $ok = yes; then
11960     # An in-tree tool is available and we can use it
11961     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11962     echo "$as_me:$LINENO: result: just compiled" >&5
11963 echo "${ECHO_T}just compiled" >&6
11964   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11965     # We already found the complete path
11966     ac_dir=`dirname $GCJ_FOR_TARGET`
11967     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11968 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11969   elif test "x$target" = "x$host"; then
11970     # We can use an host tool
11971     GCJ_FOR_TARGET='$(GCJ)'
11972     echo "$as_me:$LINENO: result: host tool" >&5
11973 echo "${ECHO_T}host tool" >&6
11974   else
11975     # We need a cross tool
11976     echo "$as_me:$LINENO: result: pre-installed" >&5
11977 echo "${ECHO_T}pre-installed" >&6
11978   fi
11979 fi
11980
11981 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11982 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11983 if test "x${build}" != "x${host}" ; then
11984   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11985     # We already found the complete path
11986     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11987     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11988 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11989   else
11990     # Canadian cross, just use what we found
11991     echo "$as_me:$LINENO: result: pre-installed" >&5
11992 echo "${ECHO_T}pre-installed" >&6
11993   fi
11994 else
11995   ok=yes
11996   case " ${configdirs} " in
11997     *" gcc "*) ;;
11998     *) ok=no ;;
11999   esac
12000   case ,${enable_languages}, in
12001     *,fortran,*) ;;
12002     *) ok=no ;;
12003   esac
12004   if test $ok = yes; then
12005     # An in-tree tool is available and we can use it
12006     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12007     echo "$as_me:$LINENO: result: just compiled" >&5
12008 echo "${ECHO_T}just compiled" >&6
12009   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12010     # We already found the complete path
12011     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12012     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12013 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12014   elif test "x$target" = "x$host"; then
12015     # We can use an host tool
12016     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12017     echo "$as_me:$LINENO: result: host tool" >&5
12018 echo "${ECHO_T}host tool" >&6
12019   else
12020     # We need a cross tool
12021     echo "$as_me:$LINENO: result: pre-installed" >&5
12022 echo "${ECHO_T}pre-installed" >&6
12023   fi
12024 fi
12025
12026 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12027 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12028 if test "x${build}" != "x${host}" ; then
12029   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12030     # We already found the complete path
12031     ac_dir=`dirname $LD_FOR_TARGET`
12032     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12033 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12034   else
12035     # Canadian cross, just use what we found
12036     echo "$as_me:$LINENO: result: pre-installed" >&5
12037 echo "${ECHO_T}pre-installed" >&6
12038   fi
12039 else
12040   ok=yes
12041   case " ${configdirs} " in
12042     *" ld "*) ;;
12043     *) ok=no ;;
12044   esac
12045
12046   if test $ok = yes; then
12047     # An in-tree tool is available and we can use it
12048     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12049     echo "$as_me:$LINENO: result: just compiled" >&5
12050 echo "${ECHO_T}just compiled" >&6
12051   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12052     # We already found the complete path
12053     ac_dir=`dirname $LD_FOR_TARGET`
12054     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12055 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12056   elif test "x$target" = "x$host"; then
12057     # We can use an host tool
12058     LD_FOR_TARGET='$(LD)'
12059     echo "$as_me:$LINENO: result: host tool" >&5
12060 echo "${ECHO_T}host tool" >&6
12061   else
12062     # We need a cross tool
12063     echo "$as_me:$LINENO: result: pre-installed" >&5
12064 echo "${ECHO_T}pre-installed" >&6
12065   fi
12066 fi
12067
12068 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12069 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12070 if test "x${build}" != "x${host}" ; then
12071   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12072     # We already found the complete path
12073     ac_dir=`dirname $LIPO_FOR_TARGET`
12074     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12075 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12076   else
12077     # Canadian cross, just use what we found
12078     echo "$as_me:$LINENO: result: pre-installed" >&5
12079 echo "${ECHO_T}pre-installed" >&6
12080   fi
12081 else
12082   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12083     # We already found the complete path
12084     ac_dir=`dirname $LIPO_FOR_TARGET`
12085     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12086 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12087   elif test "x$target" = "x$host"; then
12088     # We can use an host tool
12089     LIPO_FOR_TARGET='$(LIPO)'
12090     echo "$as_me:$LINENO: result: host tool" >&5
12091 echo "${ECHO_T}host tool" >&6
12092   else
12093     # We need a cross tool
12094     echo "$as_me:$LINENO: result: pre-installed" >&5
12095 echo "${ECHO_T}pre-installed" >&6
12096   fi
12097 fi
12098
12099 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12100 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12101 if test "x${build}" != "x${host}" ; then
12102   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12103     # We already found the complete path
12104     ac_dir=`dirname $NM_FOR_TARGET`
12105     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12106 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12107   else
12108     # Canadian cross, just use what we found
12109     echo "$as_me:$LINENO: result: pre-installed" >&5
12110 echo "${ECHO_T}pre-installed" >&6
12111   fi
12112 else
12113   ok=yes
12114   case " ${configdirs} " in
12115     *" binutils "*) ;;
12116     *) ok=no ;;
12117   esac
12118
12119   if test $ok = yes; then
12120     # An in-tree tool is available and we can use it
12121     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12122     echo "$as_me:$LINENO: result: just compiled" >&5
12123 echo "${ECHO_T}just compiled" >&6
12124   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12125     # We already found the complete path
12126     ac_dir=`dirname $NM_FOR_TARGET`
12127     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12128 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12129   elif test "x$target" = "x$host"; then
12130     # We can use an host tool
12131     NM_FOR_TARGET='$(NM)'
12132     echo "$as_me:$LINENO: result: host tool" >&5
12133 echo "${ECHO_T}host tool" >&6
12134   else
12135     # We need a cross tool
12136     echo "$as_me:$LINENO: result: pre-installed" >&5
12137 echo "${ECHO_T}pre-installed" >&6
12138   fi
12139 fi
12140
12141 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12142 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12143 if test "x${build}" != "x${host}" ; then
12144   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12145     # We already found the complete path
12146     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12147     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12148 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12149   else
12150     # Canadian cross, just use what we found
12151     echo "$as_me:$LINENO: result: pre-installed" >&5
12152 echo "${ECHO_T}pre-installed" >&6
12153   fi
12154 else
12155   ok=yes
12156   case " ${configdirs} " in
12157     *" binutils "*) ;;
12158     *) ok=no ;;
12159   esac
12160
12161   if test $ok = yes; then
12162     # An in-tree tool is available and we can use it
12163     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12164     echo "$as_me:$LINENO: result: just compiled" >&5
12165 echo "${ECHO_T}just compiled" >&6
12166   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12167     # We already found the complete path
12168     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12169     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12170 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12171   elif test "x$target" = "x$host"; then
12172     # We can use an host tool
12173     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12174     echo "$as_me:$LINENO: result: host tool" >&5
12175 echo "${ECHO_T}host tool" >&6
12176   else
12177     # We need a cross tool
12178     echo "$as_me:$LINENO: result: pre-installed" >&5
12179 echo "${ECHO_T}pre-installed" >&6
12180   fi
12181 fi
12182
12183 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12184 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12185 if test "x${build}" != "x${host}" ; then
12186   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12187     # We already found the complete path
12188     ac_dir=`dirname $RANLIB_FOR_TARGET`
12189     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12190 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12191   else
12192     # Canadian cross, just use what we found
12193     echo "$as_me:$LINENO: result: pre-installed" >&5
12194 echo "${ECHO_T}pre-installed" >&6
12195   fi
12196 else
12197   ok=yes
12198   case " ${configdirs} " in
12199     *" binutils "*) ;;
12200     *) ok=no ;;
12201   esac
12202
12203   if test $ok = yes; then
12204     # An in-tree tool is available and we can use it
12205     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12206     echo "$as_me:$LINENO: result: just compiled" >&5
12207 echo "${ECHO_T}just compiled" >&6
12208   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12209     # We already found the complete path
12210     ac_dir=`dirname $RANLIB_FOR_TARGET`
12211     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12212 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12213   elif test "x$target" = "x$host"; then
12214     # We can use an host tool
12215     RANLIB_FOR_TARGET='$(RANLIB)'
12216     echo "$as_me:$LINENO: result: host tool" >&5
12217 echo "${ECHO_T}host tool" >&6
12218   else
12219     # We need a cross tool
12220     echo "$as_me:$LINENO: result: pre-installed" >&5
12221 echo "${ECHO_T}pre-installed" >&6
12222   fi
12223 fi
12224
12225 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12226 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12227 if test "x${build}" != "x${host}" ; then
12228   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12229     # We already found the complete path
12230     ac_dir=`dirname $STRIP_FOR_TARGET`
12231     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12232 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12233   else
12234     # Canadian cross, just use what we found
12235     echo "$as_me:$LINENO: result: pre-installed" >&5
12236 echo "${ECHO_T}pre-installed" >&6
12237   fi
12238 else
12239   ok=yes
12240   case " ${configdirs} " in
12241     *" binutils "*) ;;
12242     *) ok=no ;;
12243   esac
12244
12245   if test $ok = yes; then
12246     # An in-tree tool is available and we can use it
12247     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12248     echo "$as_me:$LINENO: result: just compiled" >&5
12249 echo "${ECHO_T}just compiled" >&6
12250   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12251     # We already found the complete path
12252     ac_dir=`dirname $STRIP_FOR_TARGET`
12253     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12254 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12255   elif test "x$target" = "x$host"; then
12256     # We can use an host tool
12257     STRIP_FOR_TARGET='$(STRIP)'
12258     echo "$as_me:$LINENO: result: host tool" >&5
12259 echo "${ECHO_T}host tool" >&6
12260   else
12261     # We need a cross tool
12262     echo "$as_me:$LINENO: result: pre-installed" >&5
12263 echo "${ECHO_T}pre-installed" >&6
12264   fi
12265 fi
12266
12267 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12268 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12269 if test "x${build}" != "x${host}" ; then
12270   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12271     # We already found the complete path
12272     ac_dir=`dirname $WINDRES_FOR_TARGET`
12273     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12274 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12275   else
12276     # Canadian cross, just use what we found
12277     echo "$as_me:$LINENO: result: pre-installed" >&5
12278 echo "${ECHO_T}pre-installed" >&6
12279   fi
12280 else
12281   ok=yes
12282   case " ${configdirs} " in
12283     *" binutils "*) ;;
12284     *) ok=no ;;
12285   esac
12286
12287   if test $ok = yes; then
12288     # An in-tree tool is available and we can use it
12289     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12290     echo "$as_me:$LINENO: result: just compiled" >&5
12291 echo "${ECHO_T}just compiled" >&6
12292   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12293     # We already found the complete path
12294     ac_dir=`dirname $WINDRES_FOR_TARGET`
12295     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12296 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12297   elif test "x$target" = "x$host"; then
12298     # We can use an host tool
12299     WINDRES_FOR_TARGET='$(WINDRES)'
12300     echo "$as_me:$LINENO: result: host tool" >&5
12301 echo "${ECHO_T}host tool" >&6
12302   else
12303     # We need a cross tool
12304     echo "$as_me:$LINENO: result: pre-installed" >&5
12305 echo "${ECHO_T}pre-installed" >&6
12306   fi
12307 fi
12308
12309 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12310 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12311 if test "x${build}" != "x${host}" ; then
12312   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12313     # We already found the complete path
12314     ac_dir=`dirname $WINDMC_FOR_TARGET`
12315     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12316 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12317   else
12318     # Canadian cross, just use what we found
12319     echo "$as_me:$LINENO: result: pre-installed" >&5
12320 echo "${ECHO_T}pre-installed" >&6
12321   fi
12322 else
12323   ok=yes
12324   case " ${configdirs} " in
12325     *" binutils "*) ;;
12326     *) ok=no ;;
12327   esac
12328
12329   if test $ok = yes; then
12330     # An in-tree tool is available and we can use it
12331     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12332     echo "$as_me:$LINENO: result: just compiled" >&5
12333 echo "${ECHO_T}just compiled" >&6
12334   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12335     # We already found the complete path
12336     ac_dir=`dirname $WINDMC_FOR_TARGET`
12337     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12338 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12339   elif test "x$target" = "x$host"; then
12340     # We can use an host tool
12341     WINDMC_FOR_TARGET='$(WINDMC)'
12342     echo "$as_me:$LINENO: result: host tool" >&5
12343 echo "${ECHO_T}host tool" >&6
12344   else
12345     # We need a cross tool
12346     echo "$as_me:$LINENO: result: pre-installed" >&5
12347 echo "${ECHO_T}pre-installed" >&6
12348   fi
12349 fi
12350
12351
12352
12353
12354
12355 # Certain tools may need extra flags.
12356 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12357 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12358 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12359
12360 # When building target libraries, except in a Canadian cross, we use
12361 # the same toolchain as the compiler we just built.
12362 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12363 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12364 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12365 if test $host = $build; then
12366   case " $configdirs " in
12367     *" gcc "*)
12368       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12369       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12370       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12371       ;;
12372   esac
12373 fi
12374
12375
12376
12377
12378
12379 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12380 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12381 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12382 if test "${enable_maintainer_mode+set}" = set; then
12383   enableval="$enable_maintainer_mode"
12384   USE_MAINTAINER_MODE=$enableval
12385 else
12386   USE_MAINTAINER_MODE=no
12387 fi;
12388 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12389 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12390
12391
12392 if test "$USE_MAINTAINER_MODE" = yes; then
12393   MAINTAINER_MODE_TRUE=
12394   MAINTAINER_MODE_FALSE='#'
12395 else
12396   MAINTAINER_MODE_TRUE='#'
12397   MAINTAINER_MODE_FALSE=
12398 fi
12399 MAINT=$MAINTAINER_MODE_TRUE
12400
12401 # ---------------------
12402 # GCC bootstrap support
12403 # ---------------------
12404
12405 # Stage specific cflags for build.
12406 stage1_cflags="-g"
12407 case $build in
12408   vax-*-*)
12409     case ${GCC} in
12410       yes) stage1_cflags="-g -Wa,-J" ;;
12411       *) stage1_cflags="-g -J" ;;
12412     esac ;;
12413 esac
12414
12415 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12416 if test "$GCC" = yes; then
12417   saved_CFLAGS="$CFLAGS"
12418
12419   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12420   CFLAGS="$CFLAGS -fkeep-inline-functions"
12421   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12422 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12423   cat >conftest.$ac_ext <<_ACEOF
12424 /* confdefs.h.  */
12425 _ACEOF
12426 cat confdefs.h >>conftest.$ac_ext
12427 cat >>conftest.$ac_ext <<_ACEOF
12428 /* end confdefs.h.  */
12429
12430 #if (__GNUC__ < 3) \
12431     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12432                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12433 #error http://gcc.gnu.org/PR29382
12434 #endif
12435
12436 int
12437 main ()
12438 {
12439
12440   ;
12441   return 0;
12442 }
12443 _ACEOF
12444 rm -f conftest.$ac_objext
12445 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12446   (eval $ac_compile) 2>conftest.er1
12447   ac_status=$?
12448   grep -v '^ *+' conftest.er1 >conftest.err
12449   rm -f conftest.er1
12450   cat conftest.err >&5
12451   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12452   (exit $ac_status); } &&
12453          { ac_try='test -z "$ac_c_werror_flag"
12454                          || test ! -s conftest.err'
12455   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12456   (eval $ac_try) 2>&5
12457   ac_status=$?
12458   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12459   (exit $ac_status); }; } &&
12460          { ac_try='test -s conftest.$ac_objext'
12461   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12462   (eval $ac_try) 2>&5
12463   ac_status=$?
12464   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12465   (exit $ac_status); }; }; then
12466   echo "$as_me:$LINENO: result: yes" >&5
12467 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12468 else
12469   echo "$as_me: failed program was:" >&5
12470 sed 's/^/| /' conftest.$ac_ext >&5
12471
12472 echo "$as_me:$LINENO: result: no" >&5
12473 echo "${ECHO_T}no" >&6
12474 fi
12475 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12476
12477   CFLAGS="$saved_CFLAGS"
12478 fi
12479
12480
12481
12482 # Enable --enable-checking in stage1 of the compiler.
12483 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12484 if test "${enable_stage1_checking+set}" = set; then
12485   enableval="$enable_stage1_checking"
12486   stage1_checking=--enable-checking=${enable_stage1_checking}
12487 else
12488   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12489   stage1_checking=--enable-checking=yes,types
12490 else
12491   stage1_checking=--enable-checking=$enable_checking,types
12492 fi
12493 fi;
12494
12495
12496 # Enable -Werror in bootstrap stage2 and later.
12497 # Check whether --enable-werror or --disable-werror was given.
12498 if test "${enable_werror+set}" = set; then
12499   enableval="$enable_werror"
12500
12501 else
12502   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12503   enable_werror=yes
12504 else
12505   enable_werror=no
12506 fi
12507 fi;
12508 case ${enable_werror} in
12509   yes) stage2_werror_flag="--enable-werror-always" ;;
12510   *) stage2_werror_flag="" ;;
12511 esac
12512
12513
12514 # Flags needed to enable html installing and building
12515
12516 # Check whether --with-datarootdir or --without-datarootdir was given.
12517 if test "${with_datarootdir+set}" = set; then
12518   withval="$with_datarootdir"
12519   datarootdir="\${prefix}/${withval}"
12520 else
12521   datarootdir="\${prefix}/share"
12522 fi;
12523
12524
12525 # Check whether --with-docdir or --without-docdir was given.
12526 if test "${with_docdir+set}" = set; then
12527   withval="$with_docdir"
12528   docdir="\${prefix}/${withval}"
12529 else
12530   docdir="\${datarootdir}/doc"
12531 fi;
12532
12533
12534 # Check whether --with-pdfdir or --without-pdfdir was given.
12535 if test "${with_pdfdir+set}" = set; then
12536   withval="$with_pdfdir"
12537   pdfdir="\${prefix}/${withval}"
12538 else
12539   pdfdir="\${docdir}"
12540 fi;
12541
12542
12543 # Check whether --with-htmldir or --without-htmldir was given.
12544 if test "${with_htmldir+set}" = set; then
12545   withval="$with_htmldir"
12546   htmldir="\${prefix}/${withval}"
12547 else
12548   htmldir="\${docdir}"
12549 fi;
12550
12551
12552
12553
12554
12555
12556           ac_config_files="$ac_config_files Makefile"
12557 cat >confcache <<\_ACEOF
12558 # This file is a shell script that caches the results of configure
12559 # tests run on this system so they can be shared between configure
12560 # scripts and configure runs, see configure's option --config-cache.
12561 # It is not useful on other systems.  If it contains results you don't
12562 # want to keep, you may remove or edit it.
12563 #
12564 # config.status only pays attention to the cache file if you give it
12565 # the --recheck option to rerun configure.
12566 #
12567 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12568 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12569 # following values.
12570
12571 _ACEOF
12572
12573 # The following way of writing the cache mishandles newlines in values,
12574 # but we know of no workaround that is simple, portable, and efficient.
12575 # So, don't put newlines in cache variables' values.
12576 # Ultrix sh set writes to stderr and can't be redirected directly,
12577 # and sets the high bit in the cache file unless we assign to the vars.
12578 {
12579   (set) 2>&1 |
12580     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12581     *ac_space=\ *)
12582       # `set' does not quote correctly, so add quotes (double-quote
12583       # substitution turns \\\\ into \\, and sed turns \\ into \).
12584       sed -n \
12585         "s/'/'\\\\''/g;
12586           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12587       ;;
12588     *)
12589       # `set' quotes correctly as required by POSIX, so do not add quotes.
12590       sed -n \
12591         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12592       ;;
12593     esac;
12594 } |
12595   sed '
12596      t clear
12597      : clear
12598      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12599      t end
12600      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12601      : end' >>confcache
12602 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12603   if test -w $cache_file; then
12604     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12605     cat confcache >$cache_file
12606   else
12607     echo "not updating unwritable cache $cache_file"
12608   fi
12609 fi
12610 rm -f confcache
12611
12612 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12613 # Let make expand exec_prefix.
12614 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12615
12616 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12617 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12618 # trailing colons and then remove the whole line if VPATH becomes empty
12619 # (actually we leave an empty line to preserve line numbers).
12620 if test "x$srcdir" = x.; then
12621   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12622 s/:*\$(srcdir):*/:/;
12623 s/:*\${srcdir}:*/:/;
12624 s/:*@srcdir@:*/:/;
12625 s/^\([^=]*=[     ]*\):*/\1/;
12626 s/:*$//;
12627 s/^[^=]*=[       ]*$//;
12628 }'
12629 fi
12630
12631 # Transform confdefs.h into DEFS.
12632 # Protect against shell expansion while executing Makefile rules.
12633 # Protect against Makefile macro expansion.
12634 #
12635 # If the first sed substitution is executed (which looks for macros that
12636 # take arguments), then we branch to the quote section.  Otherwise,
12637 # look for a macro that doesn't take arguments.
12638 cat >confdef2opt.sed <<\_ACEOF
12639 t clear
12640 : clear
12641 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12642 t quote
12643 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12644 t quote
12645 d
12646 : quote
12647 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12648 s,\[,\\&,g
12649 s,\],\\&,g
12650 s,\$,$$,g
12651 p
12652 _ACEOF
12653 # We use echo to avoid assuming a particular line-breaking character.
12654 # The extra dot is to prevent the shell from consuming trailing
12655 # line-breaks from the sub-command output.  A line-break within
12656 # single-quotes doesn't work because, if this script is created in a
12657 # platform that uses two characters for line-breaks (e.g., DOS), tr
12658 # would break.
12659 ac_LF_and_DOT=`echo; echo .`
12660 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12661 rm -f confdef2opt.sed
12662
12663
12664 ac_libobjs=
12665 ac_ltlibobjs=
12666 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12667   # 1. Remove the extension, and $U if already installed.
12668   ac_i=`echo "$ac_i" |
12669          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12670   # 2. Add them.
12671   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12672   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12673 done
12674 LIBOBJS=$ac_libobjs
12675
12676 LTLIBOBJS=$ac_ltlibobjs
12677
12678
12679
12680 : ${CONFIG_STATUS=./config.status}
12681 ac_clean_files_save=$ac_clean_files
12682 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12683 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12684 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12685 cat >$CONFIG_STATUS <<_ACEOF
12686 #! $SHELL
12687 # Generated by $as_me.
12688 # Run this file to recreate the current configuration.
12689 # Compiler output produced by configure, useful for debugging
12690 # configure, is in config.log if it exists.
12691
12692 debug=false
12693 ac_cs_recheck=false
12694 ac_cs_silent=false
12695 SHELL=\${CONFIG_SHELL-$SHELL}
12696 _ACEOF
12697
12698 cat >>$CONFIG_STATUS <<\_ACEOF
12699 ## --------------------- ##
12700 ## M4sh Initialization.  ##
12701 ## --------------------- ##
12702
12703 # Be Bourne compatible
12704 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12705   emulate sh
12706   NULLCMD=:
12707   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12708   # is contrary to our usage.  Disable this feature.
12709   alias -g '${1+"$@"}'='"$@"'
12710 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12711   set -o posix
12712 fi
12713 DUALCASE=1; export DUALCASE # for MKS sh
12714
12715 # Support unset when possible.
12716 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12717   as_unset=unset
12718 else
12719   as_unset=false
12720 fi
12721
12722
12723 # Work around bugs in pre-3.0 UWIN ksh.
12724 $as_unset ENV MAIL MAILPATH
12725 PS1='$ '
12726 PS2='> '
12727 PS4='+ '
12728
12729 # NLS nuisances.
12730 for as_var in \
12731   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12732   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12733   LC_TELEPHONE LC_TIME
12734 do
12735   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12736     eval $as_var=C; export $as_var
12737   else
12738     $as_unset $as_var
12739   fi
12740 done
12741
12742 # Required to use basename.
12743 if expr a : '\(a\)' >/dev/null 2>&1; then
12744   as_expr=expr
12745 else
12746   as_expr=false
12747 fi
12748
12749 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12750   as_basename=basename
12751 else
12752   as_basename=false
12753 fi
12754
12755
12756 # Name of the executable.
12757 as_me=`$as_basename "$0" ||
12758 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12759          X"$0" : 'X\(//\)$' \| \
12760          X"$0" : 'X\(/\)$' \| \
12761          .     : '\(.\)' 2>/dev/null ||
12762 echo X/"$0" |
12763     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12764           /^X\/\(\/\/\)$/{ s//\1/; q; }
12765           /^X\/\(\/\).*/{ s//\1/; q; }
12766           s/.*/./; q'`
12767
12768
12769 # PATH needs CR, and LINENO needs CR and PATH.
12770 # Avoid depending upon Character Ranges.
12771 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12772 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12773 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12774 as_cr_digits='0123456789'
12775 as_cr_alnum=$as_cr_Letters$as_cr_digits
12776
12777 # The user is always right.
12778 if test "${PATH_SEPARATOR+set}" != set; then
12779   echo "#! /bin/sh" >conf$$.sh
12780   echo  "exit 0"   >>conf$$.sh
12781   chmod +x conf$$.sh
12782   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12783     PATH_SEPARATOR=';'
12784   else
12785     PATH_SEPARATOR=:
12786   fi
12787   rm -f conf$$.sh
12788 fi
12789
12790
12791   as_lineno_1=$LINENO
12792   as_lineno_2=$LINENO
12793   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12794   test "x$as_lineno_1" != "x$as_lineno_2" &&
12795   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12796   # Find who we are.  Look in the path if we contain no path at all
12797   # relative or not.
12798   case $0 in
12799     *[\\/]* ) as_myself=$0 ;;
12800     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12801 for as_dir in $PATH
12802 do
12803   IFS=$as_save_IFS
12804   test -z "$as_dir" && as_dir=.
12805   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12806 done
12807
12808        ;;
12809   esac
12810   # We did not find ourselves, most probably we were run as `sh COMMAND'
12811   # in which case we are not to be found in the path.
12812   if test "x$as_myself" = x; then
12813     as_myself=$0
12814   fi
12815   if test ! -f "$as_myself"; then
12816     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12817 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12818    { (exit 1); exit 1; }; }
12819   fi
12820   case $CONFIG_SHELL in
12821   '')
12822     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12823 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12824 do
12825   IFS=$as_save_IFS
12826   test -z "$as_dir" && as_dir=.
12827   for as_base in sh bash ksh sh5; do
12828          case $as_dir in
12829          /*)
12830            if ("$as_dir/$as_base" -c '
12831   as_lineno_1=$LINENO
12832   as_lineno_2=$LINENO
12833   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12834   test "x$as_lineno_1" != "x$as_lineno_2" &&
12835   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12836              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12837              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12838              CONFIG_SHELL=$as_dir/$as_base
12839              export CONFIG_SHELL
12840              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12841            fi;;
12842          esac
12843        done
12844 done
12845 ;;
12846   esac
12847
12848   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12849   # uniformly replaced by the line number.  The first 'sed' inserts a
12850   # line-number line before each line; the second 'sed' does the real
12851   # work.  The second script uses 'N' to pair each line-number line
12852   # with the numbered line, and appends trailing '-' during
12853   # substitution so that $LINENO is not a special case at line end.
12854   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12855   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12856   sed '=' <$as_myself |
12857     sed '
12858       N
12859       s,$,-,
12860       : loop
12861       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12862       t loop
12863       s,-$,,
12864       s,^['$as_cr_digits']*\n,,
12865     ' >$as_me.lineno &&
12866   chmod +x $as_me.lineno ||
12867     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12868 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12869    { (exit 1); exit 1; }; }
12870
12871   # Don't try to exec as it changes $[0], causing all sort of problems
12872   # (the dirname of $[0] is not the place where we might find the
12873   # original and so on.  Autoconf is especially sensible to this).
12874   . ./$as_me.lineno
12875   # Exit status is that of the last command.
12876   exit
12877 }
12878
12879
12880 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12881   *c*,-n*) ECHO_N= ECHO_C='
12882 ' ECHO_T='      ' ;;
12883   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12884   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12885 esac
12886
12887 if expr a : '\(a\)' >/dev/null 2>&1; then
12888   as_expr=expr
12889 else
12890   as_expr=false
12891 fi
12892
12893 rm -f conf$$ conf$$.exe conf$$.file
12894 echo >conf$$.file
12895 if ln -s conf$$.file conf$$ 2>/dev/null; then
12896   # We could just check for DJGPP; but this test a) works b) is more generic
12897   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12898   if test -f conf$$.exe; then
12899     # Don't use ln at all; we don't have any links
12900     as_ln_s='cp -p'
12901   else
12902     as_ln_s='ln -s'
12903   fi
12904 elif ln conf$$.file conf$$ 2>/dev/null; then
12905   as_ln_s=ln
12906 else
12907   as_ln_s='cp -p'
12908 fi
12909 rm -f conf$$ conf$$.exe conf$$.file
12910
12911 if mkdir -p . 2>/dev/null; then
12912   as_mkdir_p=:
12913 else
12914   test -d ./-p && rmdir ./-p
12915   as_mkdir_p=false
12916 fi
12917
12918 as_executable_p="test -f"
12919
12920 # Sed expression to map a string onto a valid CPP name.
12921 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12922
12923 # Sed expression to map a string onto a valid variable name.
12924 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12925
12926
12927 # IFS
12928 # We need space, tab and new line, in precisely that order.
12929 as_nl='
12930 '
12931 IFS="   $as_nl"
12932
12933 # CDPATH.
12934 $as_unset CDPATH
12935
12936 exec 6>&1
12937
12938 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12939 # report actual input values of CONFIG_FILES etc. instead of their
12940 # values after options handling.  Logging --version etc. is OK.
12941 exec 5>>config.log
12942 {
12943   echo
12944   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12945 ## Running $as_me. ##
12946 _ASBOX
12947 } >&5
12948 cat >&5 <<_CSEOF
12949
12950 This file was extended by $as_me, which was
12951 generated by GNU Autoconf 2.59.  Invocation command line was
12952
12953   CONFIG_FILES    = $CONFIG_FILES
12954   CONFIG_HEADERS  = $CONFIG_HEADERS
12955   CONFIG_LINKS    = $CONFIG_LINKS
12956   CONFIG_COMMANDS = $CONFIG_COMMANDS
12957   $ $0 $@
12958
12959 _CSEOF
12960 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12961 echo >&5
12962 _ACEOF
12963
12964 # Files that config.status was made for.
12965 if test -n "$ac_config_files"; then
12966   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12967 fi
12968
12969 if test -n "$ac_config_headers"; then
12970   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12971 fi
12972
12973 if test -n "$ac_config_links"; then
12974   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12975 fi
12976
12977 if test -n "$ac_config_commands"; then
12978   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12979 fi
12980
12981 cat >>$CONFIG_STATUS <<\_ACEOF
12982
12983 ac_cs_usage="\
12984 \`$as_me' instantiates files from templates according to the
12985 current configuration.
12986
12987 Usage: $0 [OPTIONS] [FILE]...
12988
12989   -h, --help       print this help, then exit
12990   -V, --version    print version number, then exit
12991   -q, --quiet      do not print progress messages
12992   -d, --debug      don't remove temporary files
12993       --recheck    update $as_me by reconfiguring in the same conditions
12994   --file=FILE[:TEMPLATE]
12995                    instantiate the configuration file FILE
12996
12997 Configuration files:
12998 $config_files
12999
13000 Report bugs to <bug-autoconf@gnu.org>."
13001 _ACEOF
13002
13003 cat >>$CONFIG_STATUS <<_ACEOF
13004 ac_cs_version="\\
13005 config.status
13006 configured by $0, generated by GNU Autoconf 2.59,
13007   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13008
13009 Copyright (C) 2003 Free Software Foundation, Inc.
13010 This config.status script is free software; the Free Software Foundation
13011 gives unlimited permission to copy, distribute and modify it."
13012 srcdir=$srcdir
13013 INSTALL="$INSTALL"
13014 _ACEOF
13015
13016 cat >>$CONFIG_STATUS <<\_ACEOF
13017 # If no file are specified by the user, then we need to provide default
13018 # value.  By we need to know if files were specified by the user.
13019 ac_need_defaults=:
13020 while test $# != 0
13021 do
13022   case $1 in
13023   --*=*)
13024     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13025     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13026     ac_shift=:
13027     ;;
13028   -*)
13029     ac_option=$1
13030     ac_optarg=$2
13031     ac_shift=shift
13032     ;;
13033   *) # This is not an option, so the user has probably given explicit
13034      # arguments.
13035      ac_option=$1
13036      ac_need_defaults=false;;
13037   esac
13038
13039   case $ac_option in
13040   # Handling of the options.
13041 _ACEOF
13042 cat >>$CONFIG_STATUS <<\_ACEOF
13043   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13044     ac_cs_recheck=: ;;
13045   --version | --vers* | -V )
13046     echo "$ac_cs_version"; exit 0 ;;
13047   --he | --h)
13048     # Conflict between --help and --header
13049     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13050 Try \`$0 --help' for more information." >&5
13051 echo "$as_me: error: ambiguous option: $1
13052 Try \`$0 --help' for more information." >&2;}
13053    { (exit 1); exit 1; }; };;
13054   --help | --hel | -h )
13055     echo "$ac_cs_usage"; exit 0 ;;
13056   --debug | --d* | -d )
13057     debug=: ;;
13058   --file | --fil | --fi | --f )
13059     $ac_shift
13060     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13061     ac_need_defaults=false;;
13062   --header | --heade | --head | --hea )
13063     $ac_shift
13064     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13065     ac_need_defaults=false;;
13066   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13067   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13068     ac_cs_silent=: ;;
13069
13070   # This is an error.
13071   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13072 Try \`$0 --help' for more information." >&5
13073 echo "$as_me: error: unrecognized option: $1
13074 Try \`$0 --help' for more information." >&2;}
13075    { (exit 1); exit 1; }; } ;;
13076
13077   *) ac_config_targets="$ac_config_targets $1" ;;
13078
13079   esac
13080   shift
13081 done
13082
13083 ac_configure_extra_args=
13084
13085 if $ac_cs_silent; then
13086   exec 6>/dev/null
13087   ac_configure_extra_args="$ac_configure_extra_args --silent"
13088 fi
13089
13090 _ACEOF
13091 cat >>$CONFIG_STATUS <<_ACEOF
13092 if \$ac_cs_recheck; then
13093   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13094   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13095 fi
13096
13097 _ACEOF
13098
13099
13100
13101
13102
13103 cat >>$CONFIG_STATUS <<\_ACEOF
13104 for ac_config_target in $ac_config_targets
13105 do
13106   case "$ac_config_target" in
13107   # Handling of arguments.
13108   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13109   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13110 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13111    { (exit 1); exit 1; }; };;
13112   esac
13113 done
13114
13115 # If the user did not use the arguments to specify the items to instantiate,
13116 # then the envvar interface is used.  Set only those that are not.
13117 # We use the long form for the default assignment because of an extremely
13118 # bizarre bug on SunOS 4.1.3.
13119 if $ac_need_defaults; then
13120   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13121 fi
13122
13123 # Have a temporary directory for convenience.  Make it in the build tree
13124 # simply because there is no reason to put it here, and in addition,
13125 # creating and moving files from /tmp can sometimes cause problems.
13126 # Create a temporary directory, and hook for its removal unless debugging.
13127 $debug ||
13128 {
13129   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13130   trap '{ (exit 1); exit 1; }' 1 2 13 15
13131 }
13132
13133 # Create a (secure) tmp directory for tmp files.
13134
13135 {
13136   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13137   test -n "$tmp" && test -d "$tmp"
13138 }  ||
13139 {
13140   tmp=./confstat$$-$RANDOM
13141   (umask 077 && mkdir $tmp)
13142 } ||
13143 {
13144    echo "$me: cannot create a temporary directory in ." >&2
13145    { (exit 1); exit 1; }
13146 }
13147
13148 _ACEOF
13149
13150 cat >>$CONFIG_STATUS <<_ACEOF
13151
13152 #
13153 # CONFIG_FILES section.
13154 #
13155
13156 # No need to generate the scripts if there are no CONFIG_FILES.
13157 # This happens for instance when ./config.status config.h
13158 if test -n "\$CONFIG_FILES"; then
13159   # Protect against being on the right side of a sed subst in config.status.
13160   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13161    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13162 s,@SHELL@,$SHELL,;t t
13163 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13164 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13165 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13166 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13167 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13168 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13169 s,@exec_prefix@,$exec_prefix,;t t
13170 s,@prefix@,$prefix,;t t
13171 s,@program_transform_name@,$program_transform_name,;t t
13172 s,@bindir@,$bindir,;t t
13173 s,@sbindir@,$sbindir,;t t
13174 s,@libexecdir@,$libexecdir,;t t
13175 s,@datadir@,$datadir,;t t
13176 s,@sysconfdir@,$sysconfdir,;t t
13177 s,@sharedstatedir@,$sharedstatedir,;t t
13178 s,@localstatedir@,$localstatedir,;t t
13179 s,@libdir@,$libdir,;t t
13180 s,@includedir@,$includedir,;t t
13181 s,@oldincludedir@,$oldincludedir,;t t
13182 s,@infodir@,$infodir,;t t
13183 s,@mandir@,$mandir,;t t
13184 s,@build_alias@,$build_alias,;t t
13185 s,@host_alias@,$host_alias,;t t
13186 s,@target_alias@,$target_alias,;t t
13187 s,@DEFS@,$DEFS,;t t
13188 s,@ECHO_C@,$ECHO_C,;t t
13189 s,@ECHO_N@,$ECHO_N,;t t
13190 s,@ECHO_T@,$ECHO_T,;t t
13191 s,@LIBS@,$LIBS,;t t
13192 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13193 s,@build@,$build,;t t
13194 s,@build_cpu@,$build_cpu,;t t
13195 s,@build_vendor@,$build_vendor,;t t
13196 s,@build_os@,$build_os,;t t
13197 s,@build_noncanonical@,$build_noncanonical,;t t
13198 s,@host_noncanonical@,$host_noncanonical,;t t
13199 s,@target_noncanonical@,$target_noncanonical,;t t
13200 s,@host@,$host,;t t
13201 s,@host_cpu@,$host_cpu,;t t
13202 s,@host_vendor@,$host_vendor,;t t
13203 s,@host_os@,$host_os,;t t
13204 s,@target@,$target,;t t
13205 s,@target_cpu@,$target_cpu,;t t
13206 s,@target_vendor@,$target_vendor,;t t
13207 s,@target_os@,$target_os,;t t
13208 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13209 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13210 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13211 s,@LN@,$LN,;t t
13212 s,@LN_S@,$LN_S,;t t
13213 s,@build_libsubdir@,$build_libsubdir,;t t
13214 s,@build_subdir@,$build_subdir,;t t
13215 s,@host_subdir@,$host_subdir,;t t
13216 s,@target_subdir@,$target_subdir,;t t
13217 s,@CC@,$CC,;t t
13218 s,@CFLAGS@,$CFLAGS,;t t
13219 s,@LDFLAGS@,$LDFLAGS,;t t
13220 s,@CPPFLAGS@,$CPPFLAGS,;t t
13221 s,@ac_ct_CC@,$ac_ct_CC,;t t
13222 s,@EXEEXT@,$EXEEXT,;t t
13223 s,@OBJEXT@,$OBJEXT,;t t
13224 s,@CXX@,$CXX,;t t
13225 s,@CXXFLAGS@,$CXXFLAGS,;t t
13226 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13227 s,@GNATBIND@,$GNATBIND,;t t
13228 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13229 s,@GNATMAKE@,$GNATMAKE,;t t
13230 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13231 s,@do_compare@,$do_compare,;t t
13232 s,@gmplibs@,$gmplibs,;t t
13233 s,@gmpinc@,$gmpinc,;t t
13234 s,@ppllibs@,$ppllibs,;t t
13235 s,@pplinc@,$pplinc,;t t
13236 s,@clooglibs@,$clooglibs,;t t
13237 s,@clooginc@,$clooginc,;t t
13238 s,@stage1_languages@,$stage1_languages,;t t
13239 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13240 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13241 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13242 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13243 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13244 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13245 s,@tooldir@,$tooldir,;t t
13246 s,@build_tooldir@,$build_tooldir,;t t
13247 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13248 s,@GDB_TK@,$GDB_TK,;t t
13249 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13250 s,@build_configargs@,$build_configargs,;t t
13251 s,@build_configdirs@,$build_configdirs,;t t
13252 s,@host_configargs@,$host_configargs,;t t
13253 s,@configdirs@,$configdirs,;t t
13254 s,@target_configargs@,$target_configargs,;t t
13255 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13256 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13257 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13258 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13259 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13260 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13261 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13262 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13263 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13264 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13265 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13266 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13267 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13268 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13269 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13270 s,@config_shell@,$config_shell,;t t
13271 s,@YACC@,$YACC,;t t
13272 s,@BISON@,$BISON,;t t
13273 s,@M4@,$M4,;t t
13274 s,@LEX@,$LEX,;t t
13275 s,@FLEX@,$FLEX,;t t
13276 s,@MAKEINFO@,$MAKEINFO,;t t
13277 s,@EXPECT@,$EXPECT,;t t
13278 s,@RUNTEST@,$RUNTEST,;t t
13279 s,@AR@,$AR,;t t
13280 s,@AS@,$AS,;t t
13281 s,@DLLTOOL@,$DLLTOOL,;t t
13282 s,@LD@,$LD,;t t
13283 s,@LIPO@,$LIPO,;t t
13284 s,@NM@,$NM,;t t
13285 s,@RANLIB@,$RANLIB,;t t
13286 s,@STRIP@,$STRIP,;t t
13287 s,@WINDRES@,$WINDRES,;t t
13288 s,@WINDMC@,$WINDMC,;t t
13289 s,@OBJCOPY@,$OBJCOPY,;t t
13290 s,@OBJDUMP@,$OBJDUMP,;t t
13291 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13292 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13293 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13294 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13295 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13296 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13297 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13298 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13299 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13300 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13301 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13302 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13303 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13304 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13305 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13306 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13307 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13308 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13309 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13310 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13311 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13312 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13313 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13314 s,@MAINT@,$MAINT,;t t
13315 s,@stage1_cflags@,$stage1_cflags,;t t
13316 s,@stage1_checking@,$stage1_checking,;t t
13317 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13318 s,@datarootdir@,$datarootdir,;t t
13319 s,@docdir@,$docdir,;t t
13320 s,@pdfdir@,$pdfdir,;t t
13321 s,@htmldir@,$htmldir,;t t
13322 s,@LIBOBJS@,$LIBOBJS,;t t
13323 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13324 /@serialization_dependencies@/r $serialization_dependencies
13325 s,@serialization_dependencies@,,;t t
13326 /@host_makefile_frag@/r $host_makefile_frag
13327 s,@host_makefile_frag@,,;t t
13328 /@target_makefile_frag@/r $target_makefile_frag
13329 s,@target_makefile_frag@,,;t t
13330 /@alphaieee_frag@/r $alphaieee_frag
13331 s,@alphaieee_frag@,,;t t
13332 /@ospace_frag@/r $ospace_frag
13333 s,@ospace_frag@,,;t t
13334 CEOF
13335
13336 _ACEOF
13337
13338   cat >>$CONFIG_STATUS <<\_ACEOF
13339   # Split the substitutions into bite-sized pieces for seds with
13340   # small command number limits, like on Digital OSF/1 and HP-UX.
13341   ac_max_sed_lines=48
13342   ac_sed_frag=1 # Number of current file.
13343   ac_beg=1 # First line for current file.
13344   ac_end=$ac_max_sed_lines # Line after last line for current file.
13345   ac_more_lines=:
13346   ac_sed_cmds=
13347   while $ac_more_lines; do
13348     if test $ac_beg -gt 1; then
13349       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13350     else
13351       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13352     fi
13353     if test ! -s $tmp/subs.frag; then
13354       ac_more_lines=false
13355     else
13356       # The purpose of the label and of the branching condition is to
13357       # speed up the sed processing (if there are no `@' at all, there
13358       # is no need to browse any of the substitutions).
13359       # These are the two extra sed commands mentioned above.
13360       (echo ':t
13361   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13362       if test -z "$ac_sed_cmds"; then
13363         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13364       else
13365         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13366       fi
13367       ac_sed_frag=`expr $ac_sed_frag + 1`
13368       ac_beg=$ac_end
13369       ac_end=`expr $ac_end + $ac_max_sed_lines`
13370     fi
13371   done
13372   if test -z "$ac_sed_cmds"; then
13373     ac_sed_cmds=cat
13374   fi
13375 fi # test -n "$CONFIG_FILES"
13376
13377 _ACEOF
13378 cat >>$CONFIG_STATUS <<\_ACEOF
13379 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13380   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13381   case $ac_file in
13382   - | *:- | *:-:* ) # input from stdin
13383         cat >$tmp/stdin
13384         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13385         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13386   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13387         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13388   * )   ac_file_in=$ac_file.in ;;
13389   esac
13390
13391   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13392   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13393 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13394          X"$ac_file" : 'X\(//\)[^/]' \| \
13395          X"$ac_file" : 'X\(//\)$' \| \
13396          X"$ac_file" : 'X\(/\)' \| \
13397          .     : '\(.\)' 2>/dev/null ||
13398 echo X"$ac_file" |
13399     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13400           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13401           /^X\(\/\/\)$/{ s//\1/; q; }
13402           /^X\(\/\).*/{ s//\1/; q; }
13403           s/.*/./; q'`
13404   { if $as_mkdir_p; then
13405     mkdir -p "$ac_dir"
13406   else
13407     as_dir="$ac_dir"
13408     as_dirs=
13409     while test ! -d "$as_dir"; do
13410       as_dirs="$as_dir $as_dirs"
13411       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13412 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13413          X"$as_dir" : 'X\(//\)[^/]' \| \
13414          X"$as_dir" : 'X\(//\)$' \| \
13415          X"$as_dir" : 'X\(/\)' \| \
13416          .     : '\(.\)' 2>/dev/null ||
13417 echo X"$as_dir" |
13418     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13419           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13420           /^X\(\/\/\)$/{ s//\1/; q; }
13421           /^X\(\/\).*/{ s//\1/; q; }
13422           s/.*/./; q'`
13423     done
13424     test ! -n "$as_dirs" || mkdir $as_dirs
13425   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13426 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13427    { (exit 1); exit 1; }; }; }
13428
13429   ac_builddir=.
13430
13431 if test "$ac_dir" != .; then
13432   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13433   # A "../" for each directory in $ac_dir_suffix.
13434   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13435 else
13436   ac_dir_suffix= ac_top_builddir=
13437 fi
13438
13439 case $srcdir in
13440   .)  # No --srcdir option.  We are building in place.
13441     ac_srcdir=.
13442     if test -z "$ac_top_builddir"; then
13443        ac_top_srcdir=.
13444     else
13445        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13446     fi ;;
13447   [\\/]* | ?:[\\/]* )  # Absolute path.
13448     ac_srcdir=$srcdir$ac_dir_suffix;
13449     ac_top_srcdir=$srcdir ;;
13450   *) # Relative path.
13451     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13452     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13453 esac
13454
13455 # Do not use `cd foo && pwd` to compute absolute paths, because
13456 # the directories may not exist.
13457 case `pwd` in
13458 .) ac_abs_builddir="$ac_dir";;
13459 *)
13460   case "$ac_dir" in
13461   .) ac_abs_builddir=`pwd`;;
13462   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13463   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13464   esac;;
13465 esac
13466 case $ac_abs_builddir in
13467 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13468 *)
13469   case ${ac_top_builddir}. in
13470   .) ac_abs_top_builddir=$ac_abs_builddir;;
13471   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13472   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13473   esac;;
13474 esac
13475 case $ac_abs_builddir in
13476 .) ac_abs_srcdir=$ac_srcdir;;
13477 *)
13478   case $ac_srcdir in
13479   .) ac_abs_srcdir=$ac_abs_builddir;;
13480   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13481   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13482   esac;;
13483 esac
13484 case $ac_abs_builddir in
13485 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13486 *)
13487   case $ac_top_srcdir in
13488   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13489   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13490   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13491   esac;;
13492 esac
13493
13494
13495   case $INSTALL in
13496   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13497   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13498   esac
13499
13500   if test x"$ac_file" != x-; then
13501     { echo "$as_me:$LINENO: creating $ac_file" >&5
13502 echo "$as_me: creating $ac_file" >&6;}
13503     rm -f "$ac_file"
13504   fi
13505   # Let's still pretend it is `configure' which instantiates (i.e., don't
13506   # use $as_me), people would be surprised to read:
13507   #    /* config.h.  Generated by config.status.  */
13508   if test x"$ac_file" = x-; then
13509     configure_input=
13510   else
13511     configure_input="$ac_file.  "
13512   fi
13513   configure_input=$configure_input"Generated from `echo $ac_file_in |
13514                                      sed 's,.*/,,'` by configure."
13515
13516   # First look for the input files in the build tree, otherwise in the
13517   # src tree.
13518   ac_file_inputs=`IFS=:
13519     for f in $ac_file_in; do
13520       case $f in
13521       -) echo $tmp/stdin ;;
13522       [\\/$]*)
13523          # Absolute (can't be DOS-style, as IFS=:)
13524          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13525 echo "$as_me: error: cannot find input file: $f" >&2;}
13526    { (exit 1); exit 1; }; }
13527          echo "$f";;
13528       *) # Relative
13529          if test -f "$f"; then
13530            # Build tree
13531            echo "$f"
13532          elif test -f "$srcdir/$f"; then
13533            # Source tree
13534            echo "$srcdir/$f"
13535          else
13536            # /dev/null tree
13537            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13538 echo "$as_me: error: cannot find input file: $f" >&2;}
13539    { (exit 1); exit 1; }; }
13540          fi;;
13541       esac
13542     done` || { (exit 1); exit 1; }
13543 _ACEOF
13544 cat >>$CONFIG_STATUS <<_ACEOF
13545   sed "$ac_vpsub
13546 $extrasub
13547 _ACEOF
13548 cat >>$CONFIG_STATUS <<\_ACEOF
13549 :t
13550 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13551 s,@configure_input@,$configure_input,;t t
13552 s,@srcdir@,$ac_srcdir,;t t
13553 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13554 s,@top_srcdir@,$ac_top_srcdir,;t t
13555 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13556 s,@builddir@,$ac_builddir,;t t
13557 s,@abs_builddir@,$ac_abs_builddir,;t t
13558 s,@top_builddir@,$ac_top_builddir,;t t
13559 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13560 s,@INSTALL@,$ac_INSTALL,;t t
13561 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13562   rm -f $tmp/stdin
13563   if test x"$ac_file" != x-; then
13564     mv $tmp/out $ac_file
13565   else
13566     cat $tmp/out
13567     rm -f $tmp/out
13568   fi
13569
13570 done
13571 _ACEOF
13572
13573 cat >>$CONFIG_STATUS <<\_ACEOF
13574
13575 { (exit 0); exit 0; }
13576 _ACEOF
13577 chmod +x $CONFIG_STATUS
13578 ac_clean_files=$ac_clean_files_save
13579
13580
13581 # configure is writing to config.log, and then calls config.status.
13582 # config.status does its own redirection, appending to config.log.
13583 # Unfortunately, on DOS this fails, as config.log is still kept open
13584 # by configure, so config.status won't be able to write to it; its
13585 # output is simply discarded.  So we exec the FD to /dev/null,
13586 # effectively closing config.log, so it can be properly (re)opened and
13587 # appended to by config.status.  When coming back to configure, we
13588 # need to make the FD available again.
13589 if test "$no_create" != yes; then
13590   ac_cs_success=:
13591   ac_config_status_args=
13592   test "$silent" = yes &&
13593     ac_config_status_args="$ac_config_status_args --quiet"
13594   exec 5>/dev/null
13595   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13596   exec 5>>config.log
13597   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13598   # would make configure fail if this is the last instruction.
13599   $ac_cs_success || { (exit 1); exit 1; }
13600 fi
13601