configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S TOPLEVEL_CONFIGURE_ARGUMENTS build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277
 278 # Initialize some variables set by options.
 279 ac_init_help=
 280 ac_init_version=false
 281 # The variables have the same names as the options, with
 282 # dashes changed to underlines.
 283 cache_file=/dev/null
 284 exec_prefix=NONE
 285 no_create=
 286 no_recursion=
 287 prefix=NONE
 288 program_prefix=NONE
 289 program_suffix=NONE
 290 program_transform_name=s,x,x,
 291 silent=
 292 site=
 293 srcdir=
 294 verbose=
 295 x_includes=NONE
 296 x_libraries=NONE
 297
 298 # Installation directory options.
 299 # These are left unexpanded so users can "make install exec_prefix=/foo"
 300 # and all the variables that are supposed to be based on exec_prefix
 301 # by default will actually change.
 302 # Use braces instead of parens because sh, perl, etc. also accept them.
 303 bindir='${exec_prefix}/bin'
 304 sbindir='${exec_prefix}/sbin'
 305 libexecdir='${exec_prefix}/libexec'
 306 datadir='${prefix}/share'
 307 sysconfdir='${prefix}/etc'
 308 sharedstatedir='${prefix}/com'
 309 localstatedir='${prefix}/var'
 310 libdir='${exec_prefix}/lib'
 311 includedir='${prefix}/include'
 312 oldincludedir='/usr/include'
 313 infodir='${prefix}/info'
 314 mandir='${prefix}/man'
 315
 316 ac_prev=
 317 for ac_option
 318 do
 319   # If the previous option needs an argument, assign it.
 320   if test -n "$ac_prev"; then
 321     eval "$ac_prev=\$ac_option"
 322     ac_prev=
 323     continue
 324   fi
 325
 326   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 327
 328   # Accept the important Cygnus configure options, so we can diagnose typos.
 329
 330   case $ac_option in
 331
 332   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 333     ac_prev=bindir ;;
 334   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 335     bindir=$ac_optarg ;;
 336
 337   -build | --build | --buil | --bui | --bu)
 338     ac_prev=build_alias ;;
 339   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 340     build_alias=$ac_optarg ;;
 341
 342   -cache-file | --cache-file | --cache-fil | --cache-fi \
 343   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 344     ac_prev=cache_file ;;
 345   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 346   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 347     cache_file=$ac_optarg ;;
 348
 349   --config-cache | -C)
 350     cache_file=config.cache ;;
 351
 352   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 353     ac_prev=datadir ;;
 354   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 355   | --da=*)
 356     datadir=$ac_optarg ;;
 357
 358   -disable-* | --disable-*)
 359     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 360     # Reject names that are not valid shell variable names.
 361     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 362       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 363    { (exit 1); exit 1; }; }
 364     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 365     eval "enable_$ac_feature=no" ;;
 366
 367   -enable-* | --enable-*)
 368     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 369     # Reject names that are not valid shell variable names.
 370     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 371       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 372    { (exit 1); exit 1; }; }
 373     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 374     case $ac_option in
 375       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 376       *) ac_optarg=yes ;;
 377     esac
 378     eval "enable_$ac_feature='$ac_optarg'" ;;
 379
 380   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 381   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 382   | --exec | --exe | --ex)
 383     ac_prev=exec_prefix ;;
 384   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 385   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 386   | --exec=* | --exe=* | --ex=*)
 387     exec_prefix=$ac_optarg ;;
 388
 389   -gas | --gas | --ga | --g)
 390     # Obsolete; use --with-gas.
 391     with_gas=yes ;;
 392
 393   -help | --help | --hel | --he | -h)
 394     ac_init_help=long ;;
 395   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 396     ac_init_help=recursive ;;
 397   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 398     ac_init_help=short ;;
 399
 400   -host | --host | --hos | --ho)
 401     ac_prev=host_alias ;;
 402   -host=* | --host=* | --hos=* | --ho=*)
 403     host_alias=$ac_optarg ;;
 404
 405   -includedir | --includedir | --includedi | --included | --include \
 406   | --includ | --inclu | --incl | --inc)
 407     ac_prev=includedir ;;
 408   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 409   | --includ=* | --inclu=* | --incl=* | --inc=*)
 410     includedir=$ac_optarg ;;
 411
 412   -infodir | --infodir | --infodi | --infod | --info | --inf)
 413     ac_prev=infodir ;;
 414   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 415     infodir=$ac_optarg ;;
 416
 417   -libdir | --libdir | --libdi | --libd)
 418     ac_prev=libdir ;;
 419   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 420     libdir=$ac_optarg ;;
 421
 422   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 423   | --libexe | --libex | --libe)
 424     ac_prev=libexecdir ;;
 425   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 426   | --libexe=* | --libex=* | --libe=*)
 427     libexecdir=$ac_optarg ;;
 428
 429   -localstatedir | --localstatedir | --localstatedi | --localstated \
 430   | --localstate | --localstat | --localsta | --localst \
 431   | --locals | --local | --loca | --loc | --lo)
 432     ac_prev=localstatedir ;;
 433   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 434   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 435   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 436     localstatedir=$ac_optarg ;;
 437
 438   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 439     ac_prev=mandir ;;
 440   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 441     mandir=$ac_optarg ;;
 442
 443   -nfp | --nfp | --nf)
 444     # Obsolete; use --without-fp.
 445     with_fp=no ;;
 446
 447   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 448   | --no-cr | --no-c | -n)
 449     no_create=yes ;;
 450
 451   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 452   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 453     no_recursion=yes ;;
 454
 455   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 456   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 457   | --oldin | --oldi | --old | --ol | --o)
 458     ac_prev=oldincludedir ;;
 459   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 460   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 461   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 462     oldincludedir=$ac_optarg ;;
 463
 464   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 465     ac_prev=prefix ;;
 466   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 467     prefix=$ac_optarg ;;
 468
 469   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 470   | --program-pre | --program-pr | --program-p)
 471     ac_prev=program_prefix ;;
 472   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 473   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 474     program_prefix=$ac_optarg ;;
 475
 476   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 477   | --program-suf | --program-su | --program-s)
 478     ac_prev=program_suffix ;;
 479   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 480   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 481     program_suffix=$ac_optarg ;;
 482
 483   -program-transform-name | --program-transform-name \
 484   | --program-transform-nam | --program-transform-na \
 485   | --program-transform-n | --program-transform- \
 486   | --program-transform | --program-transfor \
 487   | --program-transfo | --program-transf \
 488   | --program-trans | --program-tran \
 489   | --progr-tra | --program-tr | --program-t)
 490     ac_prev=program_transform_name ;;
 491   -program-transform-name=* | --program-transform-name=* \
 492   | --program-transform-nam=* | --program-transform-na=* \
 493   | --program-transform-n=* | --program-transform-=* \
 494   | --program-transform=* | --program-transfor=* \
 495   | --program-transfo=* | --program-transf=* \
 496   | --program-trans=* | --program-tran=* \
 497   | --progr-tra=* | --program-tr=* | --program-t=*)
 498     program_transform_name=$ac_optarg ;;
 499
 500   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 501   | -silent | --silent | --silen | --sile | --sil)
 502     silent=yes ;;
 503
 504   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 505     ac_prev=sbindir ;;
 506   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 507   | --sbi=* | --sb=*)
 508     sbindir=$ac_optarg ;;
 509
 510   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 511   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 512   | --sharedst | --shareds | --shared | --share | --shar \
 513   | --sha | --sh)
 514     ac_prev=sharedstatedir ;;
 515   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 516   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 517   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 518   | --sha=* | --sh=*)
 519     sharedstatedir=$ac_optarg ;;
 520
 521   -site | --site | --sit)
 522     ac_prev=site ;;
 523   -site=* | --site=* | --sit=*)
 524     site=$ac_optarg ;;
 525
 526   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 527     ac_prev=srcdir ;;
 528   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 529     srcdir=$ac_optarg ;;
 530
 531   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 532   | --syscon | --sysco | --sysc | --sys | --sy)
 533     ac_prev=sysconfdir ;;
 534   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 535   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 536     sysconfdir=$ac_optarg ;;
 537
 538   -target | --target | --targe | --targ | --tar | --ta | --t)
 539     ac_prev=target_alias ;;
 540   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 541     target_alias=$ac_optarg ;;
 542
 543   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 544     verbose=yes ;;
 545
 546   -version | --version | --versio | --versi | --vers | -V)
 547     ac_init_version=: ;;
 548
 549   -with-* | --with-*)
 550     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 551     # Reject names that are not valid shell variable names.
 552     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 553       { echo "$as_me: error: invalid package name: $ac_package" >&2
 554    { (exit 1); exit 1; }; }
 555     ac_package=`echo $ac_package| sed 's/-/_/g'`
 556     case $ac_option in
 557       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 558       *) ac_optarg=yes ;;
 559     esac
 560     eval "with_$ac_package='$ac_optarg'" ;;
 561
 562   -without-* | --without-*)
 563     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 564     # Reject names that are not valid shell variable names.
 565     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 566       { echo "$as_me: error: invalid package name: $ac_package" >&2
 567    { (exit 1); exit 1; }; }
 568     ac_package=`echo $ac_package | sed 's/-/_/g'`
 569     eval "with_$ac_package=no" ;;
 570
 571   --x)
 572     # Obsolete; use --with-x.
 573     with_x=yes ;;
 574
 575   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 576   | --x-incl | --x-inc | --x-in | --x-i)
 577     ac_prev=x_includes ;;
 578   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 579   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 580     x_includes=$ac_optarg ;;
 581
 582   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 583   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 584     ac_prev=x_libraries ;;
 585   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 586   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 587     x_libraries=$ac_optarg ;;
 588
 589   -*) { echo "$as_me: error: unrecognized option: $ac_option
 590 Try \`$0 --help' for more information." >&2
 591    { (exit 1); exit 1; }; }
 592     ;;
 593
 594   *=*)
 595     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 596     # Reject names that are not valid shell variable names.
 597     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 598       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 599    { (exit 1); exit 1; }; }
 600     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 601     eval "$ac_envvar='$ac_optarg'"
 602     export $ac_envvar ;;
 603
 604   *)
 605     # FIXME: should be removed in autoconf 3.0.
 606     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 607     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 608       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 609     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 610     ;;
 611
 612   esac
 613 done
 614
 615 if test -n "$ac_prev"; then
 616   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 617   { echo "$as_me: error: missing argument to $ac_option" >&2
 618    { (exit 1); exit 1; }; }
 619 fi
 620
 621 # Be sure to have absolute paths.
 622 for ac_var in exec_prefix prefix
 623 do
 624   eval ac_val=$`echo $ac_var`
 625   case $ac_val in
 626     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 627     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 628    { (exit 1); exit 1; }; };;
 629   esac
 630 done
 631
 632 # Be sure to have absolute paths.
 633 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 634               localstatedir libdir includedir oldincludedir infodir mandir
 635 do
 636   eval ac_val=$`echo $ac_var`
 637   case $ac_val in
 638     [\\/$]* | ?:[\\/]* ) ;;
 639     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 640    { (exit 1); exit 1; }; };;
 641   esac
 642 done
 643
 644 # There might be people who depend on the old broken behavior: `$host'
 645 # used to hold the argument of --host etc.
 646 # FIXME: To remove some day.
 647 build=$build_alias
 648 host=$host_alias
 649 target=$target_alias
 650
 651 # FIXME: To remove some day.
 652 if test "x$host_alias" != x; then
 653   if test "x$build_alias" = x; then
 654     cross_compiling=maybe
 655     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 656     If a cross compiler is detected then cross compile mode will be used." >&2
 657   elif test "x$build_alias" != "x$host_alias"; then
 658     cross_compiling=yes
 659   fi
 660 fi
 661
 662 ac_tool_prefix=
 663 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 664
 665 test "$silent" = yes && exec 6>/dev/null
 666
 667
 668 # Find the source files, if location was not specified.
 669 if test -z "$srcdir"; then
 670   ac_srcdir_defaulted=yes
 671   # Try the directory containing this script, then its parent.
 672   ac_confdir=`(dirname "$0") 2>/dev/null ||
 673 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 674          X"$0" : 'X\(//\)[^/]' \| \
 675          X"$0" : 'X\(//\)$' \| \
 676          X"$0" : 'X\(/\)' \| \
 677          .     : '\(.\)' 2>/dev/null ||
 678 echo X"$0" |
 679     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 680           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 681           /^X\(\/\/\)$/{ s//\1/; q; }
 682           /^X\(\/\).*/{ s//\1/; q; }
 683           s/.*/./; q'`
 684   srcdir=$ac_confdir
 685   if test ! -r $srcdir/$ac_unique_file; then
 686     srcdir=..
 687   fi
 688 else
 689   ac_srcdir_defaulted=no
 690 fi
 691 if test ! -r $srcdir/$ac_unique_file; then
 692   if test "$ac_srcdir_defaulted" = yes; then
 693     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 694    { (exit 1); exit 1; }; }
 695   else
 696     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 697    { (exit 1); exit 1; }; }
 698   fi
 699 fi
 700 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 701   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 702    { (exit 1); exit 1; }; }
 703 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 704 ac_env_build_alias_set=${build_alias+set}
 705 ac_env_build_alias_value=$build_alias
 706 ac_cv_env_build_alias_set=${build_alias+set}
 707 ac_cv_env_build_alias_value=$build_alias
 708 ac_env_host_alias_set=${host_alias+set}
 709 ac_env_host_alias_value=$host_alias
 710 ac_cv_env_host_alias_set=${host_alias+set}
 711 ac_cv_env_host_alias_value=$host_alias
 712 ac_env_target_alias_set=${target_alias+set}
 713 ac_env_target_alias_value=$target_alias
 714 ac_cv_env_target_alias_set=${target_alias+set}
 715 ac_cv_env_target_alias_value=$target_alias
 716 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 717
 718 ac_env_CC_set=${CC+set}
 719 ac_env_CC_value=$CC
 720 ac_cv_env_CC_set=${CC+set}
 721 ac_cv_env_CC_value=$CC
 722 ac_env_CFLAGS_set=${CFLAGS+set}
 723 ac_env_CFLAGS_value=$CFLAGS
 724 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 725 ac_cv_env_CFLAGS_value=$CFLAGS
 726 ac_env_LDFLAGS_set=${LDFLAGS+set}
 727 ac_env_LDFLAGS_value=$LDFLAGS
 728 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 729 ac_cv_env_LDFLAGS_value=$LDFLAGS
 730 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 731 ac_env_CPPFLAGS_value=$CPPFLAGS
 732 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 733 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 734 ac_env_CXX_set=${CXX+set}
 735 ac_env_CXX_value=$CXX
 736 ac_cv_env_CXX_set=${CXX+set}
 737 ac_cv_env_CXX_value=$CXX
 738 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 739 ac_env_CXXFLAGS_value=$CXXFLAGS
 740 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 741 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 742 ac_env_AR_set=${AR+set}
 743 ac_env_AR_value=$AR
 744 ac_cv_env_AR_set=${AR+set}
 745 ac_cv_env_AR_value=$AR
 746 ac_env_AS_set=${AS+set}
 747 ac_env_AS_value=$AS
 748 ac_cv_env_AS_set=${AS+set}
 749 ac_cv_env_AS_value=$AS
 750 ac_env_DLLTOOL_set=${DLLTOOL+set}
 751 ac_env_DLLTOOL_value=$DLLTOOL
 752 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 753 ac_cv_env_DLLTOOL_value=$DLLTOOL
 754 ac_env_LD_set=${LD+set}
 755 ac_env_LD_value=$LD
 756 ac_cv_env_LD_set=${LD+set}
 757 ac_cv_env_LD_value=$LD
 758 ac_env_LIPO_set=${LIPO+set}
 759 ac_env_LIPO_value=$LIPO
 760 ac_cv_env_LIPO_set=${LIPO+set}
 761 ac_cv_env_LIPO_value=$LIPO
 762 ac_env_NM_set=${NM+set}
 763 ac_env_NM_value=$NM
 764 ac_cv_env_NM_set=${NM+set}
 765 ac_cv_env_NM_value=$NM
 766 ac_env_RANLIB_set=${RANLIB+set}
 767 ac_env_RANLIB_value=$RANLIB
 768 ac_cv_env_RANLIB_set=${RANLIB+set}
 769 ac_cv_env_RANLIB_value=$RANLIB
 770 ac_env_STRIP_set=${STRIP+set}
 771 ac_env_STRIP_value=$STRIP
 772 ac_cv_env_STRIP_set=${STRIP+set}
 773 ac_cv_env_STRIP_value=$STRIP
 774 ac_env_WINDRES_set=${WINDRES+set}
 775 ac_env_WINDRES_value=$WINDRES
 776 ac_cv_env_WINDRES_set=${WINDRES+set}
 777 ac_cv_env_WINDRES_value=$WINDRES
 778 ac_env_WINDMC_set=${WINDMC+set}
 779 ac_env_WINDMC_value=$WINDMC
 780 ac_cv_env_WINDMC_set=${WINDMC+set}
 781 ac_cv_env_WINDMC_value=$WINDMC
 782 ac_env_OBJCOPY_set=${OBJCOPY+set}
 783 ac_env_OBJCOPY_value=$OBJCOPY
 784 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 785 ac_cv_env_OBJCOPY_value=$OBJCOPY
 786 ac_env_OBJDUMP_set=${OBJDUMP+set}
 787 ac_env_OBJDUMP_value=$OBJDUMP
 788 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 789 ac_cv_env_OBJDUMP_value=$OBJDUMP
 790 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 791 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 792 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 793 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 794 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 795 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 796 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 797 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 798 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 799 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 800 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 801 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 802 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 803 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 804 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 805 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 806 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 807 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 808 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 809 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 810 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 811 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 812 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 813 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 814 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 815 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 816 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 817 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 818 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 819 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 820 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 821 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 822 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 823 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 824 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 825 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 826 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 827 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 828 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 829 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 830 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 831 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 832 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 833 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 834 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 835 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 836 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 837 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 838 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 839 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 840 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 841 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 842 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 843 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 844 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 845 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 846 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 847 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 848 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 849 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 850 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 851 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 852 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 853 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 854
 855 #
 856 # Report the --help message.
 857 #
 858 if test "$ac_init_help" = "long"; then
 859   # Omit some internal or obsolete options to make the list less imposing.
 860   # This message is too long to be a string in the A/UX 3.1 sh.
 861   cat <<_ACEOF
 862 \`configure' configures this package to adapt to many kinds of systems.
 863
 864 Usage: $0 [OPTION]... [VAR=VALUE]...
 865
 866 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 867 VAR=VALUE.  See below for descriptions of some of the useful variables.
 868
 869 Defaults for the options are specified in brackets.
 870
 871 Configuration:
 872   -h, --help              display this help and exit
 873       --help=short        display options specific to this package
 874       --help=recursive    display the short help of all the included packages
 875   -V, --version           display version information and exit
 876   -q, --quiet, --silent   do not print \`checking...' messages
 877       --cache-file=FILE   cache test results in FILE [disabled]
 878   -C, --config-cache      alias for \`--cache-file=config.cache'
 879   -n, --no-create         do not create output files
 880       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 881
 882 _ACEOF
 883
 884   cat <<_ACEOF
 885 Installation directories:
 886   --prefix=PREFIX         install architecture-independent files in PREFIX
 887                           [$ac_default_prefix]
 888   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 889                           [PREFIX]
 890
 891 By default, \`make install' will install all the files in
 892 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 893 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 894 for instance \`--prefix=\$HOME'.
 895
 896 For better control, use the options below.
 897
 898 Fine tuning of the installation directories:
 899   --bindir=DIR           user executables [EPREFIX/bin]
 900   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 901   --libexecdir=DIR       program executables [EPREFIX/libexec]
 902   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 903   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 904   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 905   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 906   --libdir=DIR           object code libraries [EPREFIX/lib]
 907   --includedir=DIR       C header files [PREFIX/include]
 908   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 909   --infodir=DIR          info documentation [PREFIX/info]
 910   --mandir=DIR           man documentation [PREFIX/man]
 911 _ACEOF
 912
 913   cat <<\_ACEOF
 914
 915 Program names:
 916   --program-prefix=PREFIX            prepend PREFIX to installed program names
 917   --program-suffix=SUFFIX            append SUFFIX to installed program names
 918   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 919
 920 System types:
 921   --build=BUILD     configure for building on BUILD [guessed]
 922   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 923   --target=TARGET   configure for building compilers for TARGET [HOST]
 924 _ACEOF
 925 fi
 926
 927 if test -n "$ac_init_help"; then
 928
 929   cat <<\_ACEOF
 930
 931 Optional Features:
 932   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 933   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 934   --enable-gold           use gold instead of ld
 935   --enable-libada         build libada directory
 936   --enable-libssp         build libssp directory
 937   --enable-stage1-languages[=all]   choose additional languages to build during
 938                           stage1.  Mostly useful for compiler development.
 939   --enable-objc-gc        enable use of Boehm's garbage collector with the
 940                           GNU Objective-C runtime
 941   --enable-bootstrap      enable bootstrapping [yes if native build]
 942   --enable-serial-[{host,target,build}-]configure
 943                           force sequential configuration of
 944                           sub-packages for the host, target or build
 945                           machine, or all sub-packages
 946   --enable-maintainer-mode enable make rules and dependencies not useful
 947                           (and sometimes confusing) to the casual installer
 948   --enable-stage1-checking[=all]   choose additional checking for stage1
 949                           of the compiler
 950   --enable-werror         enable -Werror in bootstrap stage2 and later
 951
 952 Optional Packages:
 953   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 954   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 955   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 956   --with-mpfr-dir=PATH    this option has been REMOVED
 957   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 958                           Equivalent to --with-mpfr-include=PATH/include
 959                           plus --with-mpfr-lib=PATH/lib
 960   --with-mpfr-include=PATH
 961                           specify directory for installed MPFR include files
 962   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 963   --with-gmp-dir=PATH     this option has been REMOVED
 964   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 965                           Equivalent to --with-gmp-include=PATH/include
 966                           plus --with-gmp-lib=PATH/lib
 967   --with-gmp-include=PATH specify directory for installed GMP include files
 968   --with-gmp-lib=PATH     specify directory for the installed GMP library
 969   --with-build-sysroot=SYSROOT
 970                           use sysroot as the system root during the build
 971   --with-debug-prefix-map='A=B C=D ...'
 972                              map A to B, C to D ... in debug information
 973   --with-build-time-tools=PATH
 974                           use given path to find target tools during the build
 975   --with-datarootdir      use datarootdir as the data root directory.
 976   --with-docdir           install documentation in this directory.
 977   --with-pdfdir           install pdf in this directory.
 978   --with-htmldir          install html in this directory.
 979
 980 Some influential environment variables:
 981   CC          C compiler command
 982   CFLAGS      C compiler flags
 983   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 984               nonstandard directory <lib dir>
 985   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 986               headers in a nonstandard directory <include dir>
 987   CXX         C++ compiler command
 988   CXXFLAGS    C++ compiler flags
 989   AR          AR for the host
 990   AS          AS for the host
 991   DLLTOOL     DLLTOOL for the host
 992   LD          LD for the host
 993   LIPO        LIPO for the host
 994   NM          NM for the host
 995   RANLIB      RANLIB for the host
 996   STRIP       STRIP for the host
 997   WINDRES     WINDRES for the host
 998   WINDMC      WINDMC for the host
 999   OBJCOPY     OBJCOPY for the host
1000   OBJDUMP     OBJDUMP for the host
1001   CC_FOR_TARGET
1002               CC for the target
1003   CXX_FOR_TARGET
1004               CXX for the target
1005   GCC_FOR_TARGET
1006               GCC for the target
1007   GCJ_FOR_TARGET
1008               GCJ for the target
1009   GFORTRAN_FOR_TARGET
1010               GFORTRAN for the target
1011   AR_FOR_TARGET
1012               AR for the target
1013   AS_FOR_TARGET
1014               AS for the target
1015   DLLTOOL_FOR_TARGET
1016               DLLTOOL for the target
1017   LD_FOR_TARGET
1018               LD for the target
1019   LIPO_FOR_TARGET
1020               LIPO for the target
1021   NM_FOR_TARGET
1022               NM for the target
1023   OBJDUMP_FOR_TARGET
1024               OBJDUMP for the target
1025   RANLIB_FOR_TARGET
1026               RANLIB for the target
1027   STRIP_FOR_TARGET
1028               STRIP for the target
1029   WINDRES_FOR_TARGET
1030               WINDRES for the target
1031   WINDMC_FOR_TARGET
1032               WINDMC for the target
1033
1034 Use these variables to override the choices made by `configure' or to help
1035 it to find libraries and programs with nonstandard names/locations.
1036
1037 _ACEOF
1038 fi
1039
1040 if test "$ac_init_help" = "recursive"; then
1041   # If there are subdirs, report their specific --help.
1042   ac_popdir=`pwd`
1043   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1044     test -d $ac_dir || continue
1045     ac_builddir=.
1046
1047 if test "$ac_dir" != .; then
1048   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1049   # A "../" for each directory in $ac_dir_suffix.
1050   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1051 else
1052   ac_dir_suffix= ac_top_builddir=
1053 fi
1054
1055 case $srcdir in
1056   .)  # No --srcdir option.  We are building in place.
1057     ac_srcdir=.
1058     if test -z "$ac_top_builddir"; then
1059        ac_top_srcdir=.
1060     else
1061        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1062     fi ;;
1063   [\\/]* | ?:[\\/]* )  # Absolute path.
1064     ac_srcdir=$srcdir$ac_dir_suffix;
1065     ac_top_srcdir=$srcdir ;;
1066   *) # Relative path.
1067     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1068     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1069 esac
1070
1071 # Do not use `cd foo && pwd` to compute absolute paths, because
1072 # the directories may not exist.
1073 case `pwd` in
1074 .) ac_abs_builddir="$ac_dir";;
1075 *)
1076   case "$ac_dir" in
1077   .) ac_abs_builddir=`pwd`;;
1078   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1079   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1080   esac;;
1081 esac
1082 case $ac_abs_builddir in
1083 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1084 *)
1085   case ${ac_top_builddir}. in
1086   .) ac_abs_top_builddir=$ac_abs_builddir;;
1087   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1088   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1089   esac;;
1090 esac
1091 case $ac_abs_builddir in
1092 .) ac_abs_srcdir=$ac_srcdir;;
1093 *)
1094   case $ac_srcdir in
1095   .) ac_abs_srcdir=$ac_abs_builddir;;
1096   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1097   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1098   esac;;
1099 esac
1100 case $ac_abs_builddir in
1101 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1102 *)
1103   case $ac_top_srcdir in
1104   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1105   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1106   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1107   esac;;
1108 esac
1109
1110     cd $ac_dir
1111     # Check for guested configure; otherwise get Cygnus style configure.
1112     if test -f $ac_srcdir/configure.gnu; then
1113       echo
1114       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1115     elif test -f $ac_srcdir/configure; then
1116       echo
1117       $SHELL $ac_srcdir/configure  --help=recursive
1118     elif test -f $ac_srcdir/configure.ac ||
1119            test -f $ac_srcdir/configure.in; then
1120       echo
1121       $ac_configure --help
1122     else
1123       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1124     fi
1125     cd $ac_popdir
1126   done
1127 fi
1128
1129 test -n "$ac_init_help" && exit 0
1130 if $ac_init_version; then
1131   cat <<\_ACEOF
1132
1133 Copyright (C) 2003 Free Software Foundation, Inc.
1134 This configure script is free software; the Free Software Foundation
1135 gives unlimited permission to copy, distribute and modify it.
1136 _ACEOF
1137   exit 0
1138 fi
1139 exec 5>config.log
1140 cat >&5 <<_ACEOF
1141 This file contains any messages produced by compilers while
1142 running configure, to aid debugging if configure makes a mistake.
1143
1144 It was created by $as_me, which was
1145 generated by GNU Autoconf 2.59.  Invocation command line was
1146
1147   $ $0 $@
1148
1149 _ACEOF
1150 {
1151 cat <<_ASUNAME
1152 ## --------- ##
1153 ## Platform. ##
1154 ## --------- ##
1155
1156 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1157 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1158 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1159 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1160 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1161
1162 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1163 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1164
1165 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1166 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1167 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1168 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1169 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1170 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1171 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1172
1173 _ASUNAME
1174
1175 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1176 for as_dir in $PATH
1177 do
1178   IFS=$as_save_IFS
1179   test -z "$as_dir" && as_dir=.
1180   echo "PATH: $as_dir"
1181 done
1182
1183 } >&5
1184
1185 cat >&5 <<_ACEOF
1186
1187
1188 ## ----------- ##
1189 ## Core tests. ##
1190 ## ----------- ##
1191
1192 _ACEOF
1193
1194
1195 # Keep a trace of the command line.
1196 # Strip out --no-create and --no-recursion so they do not pile up.
1197 # Strip out --silent because we don't want to record it for future runs.
1198 # Also quote any args containing shell meta-characters.
1199 # Make two passes to allow for proper duplicate-argument suppression.
1200 ac_configure_args=
1201 ac_configure_args0=
1202 ac_configure_args1=
1203 ac_sep=
1204 ac_must_keep_next=false
1205 for ac_pass in 1 2
1206 do
1207   for ac_arg
1208   do
1209     case $ac_arg in
1210     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1211     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1212     | -silent | --silent | --silen | --sile | --sil)
1213       continue ;;
1214     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1215       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1216     esac
1217     case $ac_pass in
1218     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1219     2)
1220       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1221       if test $ac_must_keep_next = true; then
1222         ac_must_keep_next=false # Got value, back to normal.
1223       else
1224         case $ac_arg in
1225           *=* | --config-cache | -C | -disable-* | --disable-* \
1226           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1227           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1228           | -with-* | --with-* | -without-* | --without-* | --x)
1229             case "$ac_configure_args0 " in
1230               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1231             esac
1232             ;;
1233           -* ) ac_must_keep_next=true ;;
1234         esac
1235       fi
1236       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1237       # Get rid of the leading space.
1238       ac_sep=" "
1239       ;;
1240     esac
1241   done
1242 done
1243 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1244 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1245
1246 # When interrupted or exit'd, cleanup temporary files, and complete
1247 # config.log.  We remove comments because anyway the quotes in there
1248 # would cause problems or look ugly.
1249 # WARNING: Be sure not to use single quotes in there, as some shells,
1250 # such as our DU 5.0 friend, will then `close' the trap.
1251 trap 'exit_status=$?
1252   # Save into config.log some information that might help in debugging.
1253   {
1254     echo
1255
1256     cat <<\_ASBOX
1257 ## ---------------- ##
1258 ## Cache variables. ##
1259 ## ---------------- ##
1260 _ASBOX
1261     echo
1262     # The following way of writing the cache mishandles newlines in values,
1263 {
1264   (set) 2>&1 |
1265     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1266     *ac_space=\ *)
1267       sed -n \
1268         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1269           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1270       ;;
1271     *)
1272       sed -n \
1273         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1274       ;;
1275     esac;
1276 }
1277     echo
1278
1279     cat <<\_ASBOX
1280 ## ----------------- ##
1281 ## Output variables. ##
1282 ## ----------------- ##
1283 _ASBOX
1284     echo
1285     for ac_var in $ac_subst_vars
1286     do
1287       eval ac_val=$`echo $ac_var`
1288       echo "$ac_var='"'"'$ac_val'"'"'"
1289     done | sort
1290     echo
1291
1292     if test -n "$ac_subst_files"; then
1293       cat <<\_ASBOX
1294 ## ------------- ##
1295 ## Output files. ##
1296 ## ------------- ##
1297 _ASBOX
1298       echo
1299       for ac_var in $ac_subst_files
1300       do
1301         eval ac_val=$`echo $ac_var`
1302         echo "$ac_var='"'"'$ac_val'"'"'"
1303       done | sort
1304       echo
1305     fi
1306
1307     if test -s confdefs.h; then
1308       cat <<\_ASBOX
1309 ## ----------- ##
1310 ## confdefs.h. ##
1311 ## ----------- ##
1312 _ASBOX
1313       echo
1314       sed "/^$/d" confdefs.h | sort
1315       echo
1316     fi
1317     test "$ac_signal" != 0 &&
1318       echo "$as_me: caught signal $ac_signal"
1319     echo "$as_me: exit $exit_status"
1320   } >&5
1321   rm -f core *.core &&
1322   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1323     exit $exit_status
1324      ' 0
1325 for ac_signal in 1 2 13 15; do
1326   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1327 done
1328 ac_signal=0
1329
1330 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1331 rm -rf conftest* confdefs.h
1332 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1333 echo >confdefs.h
1334
1335 # Predefined preprocessor variables.
1336
1337 cat >>confdefs.h <<_ACEOF
1338 #define PACKAGE_NAME "$PACKAGE_NAME"
1339 _ACEOF
1340
1341
1342 cat >>confdefs.h <<_ACEOF
1343 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1344 _ACEOF
1345
1346
1347 cat >>confdefs.h <<_ACEOF
1348 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1349 _ACEOF
1350
1351
1352 cat >>confdefs.h <<_ACEOF
1353 #define PACKAGE_STRING "$PACKAGE_STRING"
1354 _ACEOF
1355
1356
1357 cat >>confdefs.h <<_ACEOF
1358 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1359 _ACEOF
1360
1361
1362 # Let the site file select an alternate cache file if it wants to.
1363 # Prefer explicitly selected file to automatically selected ones.
1364 if test -z "$CONFIG_SITE"; then
1365   if test "x$prefix" != xNONE; then
1366     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1367   else
1368     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1369   fi
1370 fi
1371 for ac_site_file in $CONFIG_SITE; do
1372   if test -r "$ac_site_file"; then
1373     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1374 echo "$as_me: loading site script $ac_site_file" >&6;}
1375     sed 's/^/| /' "$ac_site_file" >&5
1376     . "$ac_site_file"
1377   fi
1378 done
1379
1380 if test -r "$cache_file"; then
1381   # Some versions of bash will fail to source /dev/null (special
1382   # files actually), so we avoid doing that.
1383   if test -f "$cache_file"; then
1384     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1385 echo "$as_me: loading cache $cache_file" >&6;}
1386     case $cache_file in
1387       [\\/]* | ?:[\\/]* ) . $cache_file;;
1388       *)                      . ./$cache_file;;
1389     esac
1390   fi
1391 else
1392   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1393 echo "$as_me: creating cache $cache_file" >&6;}
1394   >$cache_file
1395 fi
1396
1397 # Check that the precious variables saved in the cache have kept the same
1398 # value.
1399 ac_cache_corrupted=false
1400 for ac_var in `(set) 2>&1 |
1401                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1402   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1403   eval ac_new_set=\$ac_env_${ac_var}_set
1404   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1405   eval ac_new_val="\$ac_env_${ac_var}_value"
1406   case $ac_old_set,$ac_new_set in
1407     set,)
1408       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1409 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1410       ac_cache_corrupted=: ;;
1411     ,set)
1412       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1413 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1414       ac_cache_corrupted=: ;;
1415     ,);;
1416     *)
1417       if test "x$ac_old_val" != "x$ac_new_val"; then
1418         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1419 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1420         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1421 echo "$as_me:   former value:  $ac_old_val" >&2;}
1422         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1423 echo "$as_me:   current value: $ac_new_val" >&2;}
1424         ac_cache_corrupted=:
1425       fi;;
1426   esac
1427   # Pass precious variables to config.status.
1428   if test "$ac_new_set" = set; then
1429     case $ac_new_val in
1430     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1431       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1432     *) ac_arg=$ac_var=$ac_new_val ;;
1433     esac
1434     case " $ac_configure_args " in
1435       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1436       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1437     esac
1438   fi
1439 done
1440 if $ac_cache_corrupted; then
1441   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1442 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1443   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1444 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1445    { (exit 1); exit 1; }; }
1446 fi
1447
1448 ac_ext=c
1449 ac_cpp='$CPP $CPPFLAGS'
1450 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1451 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1452 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474 # Find the build, host, and target systems.
1475 ac_aux_dir=
1476 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1477   if test -f $ac_dir/install-sh; then
1478     ac_aux_dir=$ac_dir
1479     ac_install_sh="$ac_aux_dir/install-sh -c"
1480     break
1481   elif test -f $ac_dir/install.sh; then
1482     ac_aux_dir=$ac_dir
1483     ac_install_sh="$ac_aux_dir/install.sh -c"
1484     break
1485   elif test -f $ac_dir/shtool; then
1486     ac_aux_dir=$ac_dir
1487     ac_install_sh="$ac_aux_dir/shtool install -c"
1488     break
1489   fi
1490 done
1491 if test -z "$ac_aux_dir"; then
1492   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1493 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1494    { (exit 1); exit 1; }; }
1495 fi
1496 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1497 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1498 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1499
1500 # Make sure we can run config.sub.
1501 $ac_config_sub sun4 >/dev/null 2>&1 ||
1502   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1503 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1504    { (exit 1); exit 1; }; }
1505
1506 echo "$as_me:$LINENO: checking build system type" >&5
1507 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1508 if test "${ac_cv_build+set}" = set; then
1509   echo $ECHO_N "(cached) $ECHO_C" >&6
1510 else
1511   ac_cv_build_alias=$build_alias
1512 test -z "$ac_cv_build_alias" &&
1513   ac_cv_build_alias=`$ac_config_guess`
1514 test -z "$ac_cv_build_alias" &&
1515   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1516 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1517    { (exit 1); exit 1; }; }
1518 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1519   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1520 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1521    { (exit 1); exit 1; }; }
1522
1523 fi
1524 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1525 echo "${ECHO_T}$ac_cv_build" >&6
1526 build=$ac_cv_build
1527 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1528 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1529 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1530
1531
1532  case ${build_alias} in
1533   "") build_noncanonical=${build} ;;
1534   *) build_noncanonical=${build_alias} ;;
1535 esac
1536
1537
1538
1539  case ${host_alias} in
1540   "") host_noncanonical=${build_noncanonical} ;;
1541   *) host_noncanonical=${host_alias} ;;
1542 esac
1543
1544
1545
1546  case ${target_alias} in
1547   "") target_noncanonical=${host_noncanonical} ;;
1548   *) target_noncanonical=${target_alias} ;;
1549 esac
1550
1551
1552
1553
1554 test "$host_noncanonical" = "$target_noncanonical" &&
1555   test "$program_prefix$program_suffix$program_transform_name" = \
1556     NONENONEs,x,x, &&
1557   program_transform_name=s,y,y,
1558
1559 echo "$as_me:$LINENO: checking host system type" >&5
1560 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1561 if test "${ac_cv_host+set}" = set; then
1562   echo $ECHO_N "(cached) $ECHO_C" >&6
1563 else
1564   ac_cv_host_alias=$host_alias
1565 test -z "$ac_cv_host_alias" &&
1566   ac_cv_host_alias=$ac_cv_build_alias
1567 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1568   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1569 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1570    { (exit 1); exit 1; }; }
1571
1572 fi
1573 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1574 echo "${ECHO_T}$ac_cv_host" >&6
1575 host=$ac_cv_host
1576 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1577 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1578 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1579
1580
1581 echo "$as_me:$LINENO: checking target system type" >&5
1582 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1583 if test "${ac_cv_target+set}" = set; then
1584   echo $ECHO_N "(cached) $ECHO_C" >&6
1585 else
1586   ac_cv_target_alias=$target_alias
1587 test "x$ac_cv_target_alias" = "x" &&
1588   ac_cv_target_alias=$ac_cv_host_alias
1589 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1590   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1591 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1592    { (exit 1); exit 1; }; }
1593
1594 fi
1595 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1596 echo "${ECHO_T}$ac_cv_target" >&6
1597 target=$ac_cv_target
1598 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1599 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1600 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1601
1602
1603 # The aliases save the names the user supplied, while $host etc.
1604 # will get canonicalized.
1605 test -n "$target_alias" &&
1606   test "$program_prefix$program_suffix$program_transform_name" = \
1607     NONENONEs,x,x, &&
1608   program_prefix=${target_alias}-
1609 test "$program_prefix" != NONE &&
1610   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1611 # Use a double $ so make ignores it.
1612 test "$program_suffix" != NONE &&
1613   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1614 # Double any \ or $.  echo might interpret backslashes.
1615 # By default was `s,x,x', remove it if useless.
1616 cat <<\_ACEOF >conftest.sed
1617 s/[\\$]/&&/g;s/;s,x,x,$//
1618 _ACEOF
1619 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1620 rm conftest.sed
1621
1622
1623
1624 # Get 'install' or 'install-sh' and its variants.
1625 # Find a good install program.  We prefer a C program (faster),
1626 # so one script is as good as another.  But avoid the broken or
1627 # incompatible versions:
1628 # SysV /etc/install, /usr/sbin/install
1629 # SunOS /usr/etc/install
1630 # IRIX /sbin/install
1631 # AIX /bin/install
1632 # AmigaOS /C/install, which installs bootblocks on floppy discs
1633 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1634 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1635 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1636 # OS/2's system install, which has a completely different semantic
1637 # ./install, which can be erroneously created by make from ./install.sh.
1638 # Reject install programs that cannot install multiple files.
1639 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1640 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1641 if test -z "$INSTALL"; then
1642 if test "${ac_cv_path_install+set}" = set; then
1643   echo $ECHO_N "(cached) $ECHO_C" >&6
1644 else
1645   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1646 for as_dir in $PATH
1647 do
1648   IFS=$as_save_IFS
1649   test -z "$as_dir" && as_dir=.
1650   # Account for people who put trailing slashes in PATH elements.
1651 case $as_dir/ in
1652   ./ | .// | /cC/* | \
1653   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1654   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1655   /usr/ucb/* ) ;;
1656   *)
1657     # OSF1 and SCO ODT 3.0 have their own names for install.
1658     # Don't use installbsd from OSF since it installs stuff as root
1659     # by default.
1660     for ac_prog in ginstall scoinst install; do
1661       for ac_exec_ext in '' $ac_executable_extensions; do
1662         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1663           if test $ac_prog = install &&
1664             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1665             # AIX install.  It has an incompatible calling convention.
1666             :
1667           elif test $ac_prog = install &&
1668             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1669             # program-specific install script used by HP pwplus--don't use.
1670             :
1671           else
1672             rm -rf conftest.one conftest.two conftest.dir
1673             echo one > conftest.one
1674             echo two > conftest.two
1675             mkdir conftest.dir
1676             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1677               test -s conftest.one && test -s conftest.two &&
1678               test -s conftest.dir/conftest.one &&
1679               test -s conftest.dir/conftest.two
1680             then
1681               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1682               break 3
1683             fi
1684           fi
1685         fi
1686       done
1687     done
1688     ;;
1689 esac
1690 done
1691
1692 rm -rf conftest.one conftest.two conftest.dir
1693
1694 fi
1695   if test "${ac_cv_path_install+set}" = set; then
1696     INSTALL=$ac_cv_path_install
1697   else
1698     # As a last resort, use the slow shell script.  Don't cache a
1699     # value for INSTALL within a source directory, because that will
1700     # break other packages using the cache if that directory is
1701     # removed, or if the value is a relative name.
1702     INSTALL=$ac_install_sh
1703   fi
1704 fi
1705 echo "$as_me:$LINENO: result: $INSTALL" >&5
1706 echo "${ECHO_T}$INSTALL" >&6
1707
1708 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1709 # It thinks the first close brace ends the variable substitution.
1710 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1711
1712 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1713
1714 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1715
1716 echo "$as_me:$LINENO: checking whether ln works" >&5
1717 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1718 if test "${acx_cv_prog_LN+set}" = set; then
1719   echo $ECHO_N "(cached) $ECHO_C" >&6
1720 else
1721   rm -f conftestdata_t
1722 echo >conftestdata_f
1723 if ln conftestdata_f conftestdata_t 2>/dev/null
1724 then
1725   acx_cv_prog_LN=ln
1726 else
1727   acx_cv_prog_LN=no
1728 fi
1729 rm -f conftestdata_f conftestdata_t
1730
1731 fi
1732 if test $acx_cv_prog_LN = no; then
1733   LN="cp"
1734   echo "$as_me:$LINENO: result: no, using $LN" >&5
1735 echo "${ECHO_T}no, using $LN" >&6
1736 else
1737   LN="$acx_cv_prog_LN"
1738   echo "$as_me:$LINENO: result: yes" >&5
1739 echo "${ECHO_T}yes" >&6
1740 fi
1741
1742 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1743 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1744 LN_S=$as_ln_s
1745 if test "$LN_S" = "ln -s"; then
1746   echo "$as_me:$LINENO: result: yes" >&5
1747 echo "${ECHO_T}yes" >&6
1748 else
1749   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1750 echo "${ECHO_T}no, using $LN_S" >&6
1751 fi
1752
1753
1754 ### we might need to use some other shell than /bin/sh for running subshells
1755 ### If we are on Windows, search for the shell.  This will permit people
1756 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1757 ### without also having to set CONFIG_SHELL.  This code will work when
1758 ### using bash, which sets OSTYPE.
1759 case "${OSTYPE}" in
1760 *win32*)
1761   if test x${CONFIG_SHELL} = x ; then
1762     if test ! -f /bin/sh ; then
1763       if test x${SHELL} != x && test -f ${SHELL} ; then
1764         CONFIG_SHELL=${SHELL}
1765         export CONFIG_SHELL
1766       else
1767         for prog in sh sh.exe bash bash.exe; do
1768           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1769           for dir in $PATH; do
1770             test -z "$dir" && dir=.
1771             if test -f $dir/$prog; then
1772               CONFIG_SHELL=$dir/$prog
1773               export CONFIG_SHELL
1774               break
1775             fi
1776           done
1777           IFS="$save_ifs"
1778           test -n "${CONFIG_SHELL}" && break
1779         done
1780       fi
1781     fi
1782   fi
1783   ;;
1784 esac
1785
1786 config_shell=${CONFIG_SHELL-/bin/sh}
1787
1788 progname=$0
1789 # if PWD already has a value, it is probably wrong.
1790 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1791
1792 # Export original configure arguments for use by sub-configures.
1793 # Quote arguments with shell meta charatcers.
1794 TOPLEVEL_CONFIGURE_ARGUMENTS=
1795 set -- "$progname" "$@"
1796 for ac_arg
1797 do
1798   case "$ac_arg" in
1799   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1800     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1801     # if the argument is of the form -foo=baz, quote the baz part only
1802     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1803   *) ;;
1804   esac
1805   # Add the quoted argument to the list.
1806   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1807 done
1808 if test "$silent" = yes; then
1809   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1810 fi
1811 # Remove the initial space we just introduced and, as these will be
1812 # expanded by make, quote '$'.
1813 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1814
1815
1816 moveifchange=${srcdir}/move-if-change
1817
1818 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1819
1820 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1821 # a relative path.
1822 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1823   INSTALL="${srcpwd}/install-sh -c"
1824 fi
1825
1826 # Set srcdir to "." if that's what it is.
1827 # This is important for multilib support.
1828 pwd=`${PWDCMD-pwd}`
1829 if test "${pwd}" = "${srcpwd}" ; then
1830   srcdir=.
1831 fi
1832
1833 topsrcdir=$srcpwd
1834
1835 extra_host_args=
1836
1837 ### To add a new directory to the tree, first choose whether it is a target
1838 ### or a host dependent tool.  Then put it into the appropriate list
1839 ### (library or tools, host or target), doing a dependency sort.
1840
1841 # Subdirs will be configured in the order listed in build_configdirs,
1842 # configdirs, or target_configdirs; see the serialization section below.
1843
1844 # Dependency sorting is only needed when *configuration* must be done in
1845 # a particular order.  In all cases a dependency should be specified in
1846 # the Makefile, whether or not it's implicitly specified here.
1847
1848 # Double entries in build_configdirs, configdirs, or target_configdirs may
1849 # cause circular dependencies and break everything horribly.
1850
1851 # these library is used by various programs built for the build
1852 # environment
1853 #
1854 build_libs="build-libiberty"
1855
1856 # these tools are built for the build environment
1857 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1858
1859 # these libraries are used by various programs built for the host environment
1860 #
1861 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1862
1863 # these tools are built for the host environment
1864 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1865 # know that we are building the simulator.
1866 # binutils, gas and ld appear in that order because it makes sense to run
1867 # "make check" in that particular order.
1868 # If --enable-gold is used, "gold" will replace "ld".
1869 host_tools="texinfo byacc flex bison binutils gas ld fixincludes gcc sid sim gdb make patch prms send-pr gprof etc expect dejagnu ash bash bzip2 m4 autoconf automake libtool diff rcs fileutils shellutils time textutils wdiff find uudecode hello tar gzip indent recode release sed utils guile perl gawk findutils gettext zip fastjar gnattools"
1870
1871 # libgcj represents the runtime libraries only used by gcj.
1872 libgcj="target-libffi \
1873         target-zlib \
1874         target-qthreads \
1875         target-libjava"
1876
1877 # these libraries are built for the target environment, and are built after
1878 # the host libraries and the host tools (which may be a cross compiler)
1879 #
1880 target_libraries="target-libgcc \
1881                 target-libiberty \
1882                 target-libgloss \
1883                 target-newlib \
1884                 target-libgomp \
1885                 target-libstdc++-v3 \
1886                 target-libmudflap \
1887                 target-libssp \
1888                 target-libgfortran \
1889                 target-boehm-gc \
1890                 ${libgcj} \
1891                 target-libobjc \
1892                 target-libada"
1893
1894 # these tools are built using the target libraries, and are intended to
1895 # run only in the target environment
1896 #
1897 # note: any program that *uses* libraries that are in the "target_libraries"
1898 # list belongs in this list.  those programs are also very likely
1899 # candidates for the "native_only" list which follows
1900 #
1901 target_tools="target-examples target-groff target-gperf target-rda"
1902
1903 ################################################################################
1904
1905 ## All tools belong in one of the four categories, and are assigned above
1906 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1907 ## is important because configure will choke if they ever get through.
1908 ## ${configdirs} is directories we build using the host tools.
1909 ## ${target_configdirs} is directories we build using the target tools.
1910 configdirs=`echo ${host_libs} ${host_tools}`
1911 target_configdirs=`echo ${target_libraries} ${target_tools}`
1912 build_configdirs=`echo ${build_libs} ${build_tools}`
1913
1914
1915
1916 ################################################################################
1917
1918 srcname="gnu development package"
1919
1920 # This gets set non-empty for some net releases of packages.
1921 appdirs=""
1922
1923 # Define is_cross_compiler to save on calls to 'test'.
1924 is_cross_compiler=
1925 if test x"${host}" = x"${target}" ; then
1926   is_cross_compiler=no
1927 else
1928   is_cross_compiler=yes
1929 fi
1930
1931 # Find the build and target subdir names.
1932
1933 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1934 # have matching libraries, they should use host libraries: Makefile.tpl
1935 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1936 # However, they still use the build modules, because the corresponding
1937 # host modules (e.g. bison) are only built for the host when bootstrap
1938 # finishes. So:
1939 # - build_subdir is where we find build modules, and never changes.
1940 # - build_libsubdir is where we find build libraries, and can be overridden.
1941
1942 # Prefix 'build-' so this never conflicts with target_subdir.
1943 build_subdir="build-${build_noncanonical}"
1944
1945 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1946 if test "${with_build_libsubdir+set}" = set; then
1947   withval="$with_build_libsubdir"
1948   build_libsubdir="$withval"
1949 else
1950   build_libsubdir="$build_subdir"
1951 fi;
1952 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1953 if ( test $srcdir = . && test -d gcc ) \
1954    || test -d $srcdir/../host-${host_noncanonical}; then
1955   host_subdir="host-${host_noncanonical}"
1956 else
1957   host_subdir=.
1958 fi
1959 # No prefix.
1960 target_subdir=${target_noncanonical}
1961
1962
1963 # Skipdirs are removed silently.
1964 skipdirs=
1965 # Noconfigdirs are removed loudly.
1966 noconfigdirs=""
1967
1968 use_gnu_ld=
1969 # Make sure we don't let GNU ld be added if we didn't want it.
1970 if test x$with_gnu_ld = xno ; then
1971   use_gnu_ld=no
1972   noconfigdirs="$noconfigdirs ld gold"
1973 fi
1974
1975 use_gnu_as=
1976 # Make sure we don't let GNU as be added if we didn't want it.
1977 if test x$with_gnu_as = xno ; then
1978   use_gnu_as=no
1979   noconfigdirs="$noconfigdirs gas"
1980 fi
1981
1982 # some tools are so dependent upon X11 that if we're not building with X,
1983 # it's not even worth trying to configure, much less build, that tool.
1984
1985 case ${with_x} in
1986   yes | "") ;; # the default value for this tree is that X11 is available
1987   no)
1988     skipdirs="${skipdirs} tk itcl libgui"
1989     # We won't be able to build gdbtk without X.
1990     enable_gdbtk=no
1991     ;;
1992   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1993 esac
1994
1995 # Some tools are only suitable for building in a "native" situation.
1996 # Remove these if host!=target.
1997 native_only="autoconf automake libtool fileutils find gawk gettext gzip hello indent m4 rcs recode sed shellutils tar textutils uudecode wdiff target-groff guile perl time ash bash bzip2 prms gnuserv target-gperf"
1998
1999 # Similarly, some are only suitable for cross toolchains.
2000 # Remove these if host=target.
2001 cross_only="target-libgloss target-newlib target-opcodes"
2002
2003 case $is_cross_compiler in
2004   no) skipdirs="${skipdirs} ${cross_only}" ;;
2005   yes) skipdirs="${skipdirs} ${native_only}" ;;
2006 esac
2007
2008 # If both --with-headers and --with-libs are specified, default to
2009 # --without-newlib.
2010 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2011    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2012   if test x"${with_newlib}" = x ; then
2013     with_newlib=no
2014   fi
2015 fi
2016
2017 # Recognize --with-newlib/--without-newlib.
2018 case ${with_newlib} in
2019   no) skipdirs="${skipdirs} target-newlib" ;;
2020   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2021 esac
2022
2023 # Handle --enable-gold.
2024
2025 # Check whether --enable-gold or --disable-gold was given.
2026 if test "${enable_gold+set}" = set; then
2027   enableval="$enable_gold"
2028   ENABLE_GOLD=$enableval
2029 else
2030   ENABLE_GOLD=no
2031 fi;
2032 if test "${ENABLE_GOLD}" = "yes"; then
2033   # Check for ELF target.
2034   is_elf=no
2035   case "${target}" in
2036     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2037     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2038     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2039       case "${target}" in
2040         *-*-linux*aout* | *-*-linux*oldld*)
2041           ;;
2042         *)
2043           is_elf=yes
2044           ;;
2045       esac
2046   esac
2047
2048   if test "$is_elf" = "yes"; then
2049     # Check for target supported by gold.
2050     case "${target}" in
2051       i?86-*-* | x86_64-*-*)
2052         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2053         ;;
2054     esac
2055   fi
2056 fi
2057
2058 # Configure extra directories which are host specific
2059
2060 case "${host}" in
2061   *-cygwin*)
2062     configdirs="$configdirs libtermcap" ;;
2063 esac
2064
2065 # A target can indicate whether a language isn't supported for some reason.
2066 # Only spaces may be used in this macro; not newlines or tabs.
2067 unsupported_languages=
2068
2069 # Remove more programs from consideration, based on the host or
2070 # target this usually means that a port of the program doesn't
2071 # exist yet.
2072
2073 case "${host}" in
2074   hppa*64*-*-*)
2075     noconfigdirs="$noconfigdirs byacc"
2076     ;;
2077   i[3456789]86-*-vsta)
2078     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2079     ;;
2080   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2081     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2082     ;;
2083   x86_64-*-mingw*)
2084     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2085     ;;
2086   i[3456789]86-*-mingw32*)
2087     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2088     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2089     ;;
2090   i[3456789]86-*-beos*)
2091     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2092     ;;
2093   *-*-cygwin*)
2094     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2095     ;;
2096   *-*-netbsd*)
2097     noconfigdirs="$noconfigdirs rcs"
2098     ;;
2099   ppc*-*-pe)
2100     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2101     ;;
2102   powerpc-*-beos*)
2103     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2104     ;;
2105 esac
2106
2107
2108 # Check whether --enable-libada or --disable-libada was given.
2109 if test "${enable_libada+set}" = set; then
2110   enableval="$enable_libada"
2111   ENABLE_LIBADA=$enableval
2112 else
2113   ENABLE_LIBADA=yes
2114 fi;
2115 if test "${ENABLE_LIBADA}" != "yes" ; then
2116   noconfigdirs="$noconfigdirs gnattools"
2117 fi
2118
2119 # Check whether --enable-libssp or --disable-libssp was given.
2120 if test "${enable_libssp+set}" = set; then
2121   enableval="$enable_libssp"
2122   ENABLE_LIBSSP=$enableval
2123 else
2124   ENABLE_LIBSSP=yes
2125 fi;
2126
2127 # Save it here so that, even in case of --enable-libgcj, if the Java
2128 # front-end isn't enabled, we still get libgcj disabled.
2129 libgcj_saved=$libgcj
2130 case $enable_libgcj in
2131 yes)
2132   # If we reset it here, it won't get added to noconfigdirs in the
2133   # target-specific build rules, so it will be forcibly enabled
2134   # (unless the Java language itself isn't enabled).
2135   libgcj=
2136   ;;
2137 no)
2138   # Make sure we get it printed in the list of not supported target libs.
2139   noconfigdirs="$noconfigdirs ${libgcj}"
2140   ;;
2141 esac
2142
2143
2144 # Disable libmudflap on some systems.
2145 if test x$enable_libmudflap = x ; then
2146     case "${target}" in
2147     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2148         # Enable libmudflap by default in GNU and friends.
2149         ;;
2150     *-*-freebsd*)
2151         # Enable libmudflap by default in FreeBSD.
2152         ;;
2153     *)
2154         # Disable it by default everywhere else.
2155         noconfigdirs="$noconfigdirs target-libmudflap"
2156         ;;
2157     esac
2158 fi
2159
2160 # Disable libgomp on non POSIX hosted systems.
2161 if test x$enable_libgomp = x ; then
2162     # Enable libgomp by default on hosted POSIX systems.
2163     case "${target}" in
2164     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2165         ;;
2166     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2167         ;;
2168     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2169         ;;
2170     *-*-darwin* | *-*-aix*)
2171         ;;
2172     *)
2173         noconfigdirs="$noconfigdirs target-libgomp"
2174         ;;
2175     esac
2176 fi
2177
2178 # Default libgloss CPU subdirectory.
2179 libgloss_dir="$target_cpu"
2180
2181 case "${target}" in
2182   *-*-chorusos)
2183     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2184     ;;
2185   powerpc-*-darwin* | i[3456789]86-*-darwin* | x86_64-*-darwin9*)
2186     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2187     noconfigdirs="$noconfigdirs sim target-rda"
2188     ;;
2189   *-*-darwin*)
2190     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2191     noconfigdirs="$noconfigdirs sim target-rda"
2192     noconfigdirs="$noconfigdirs ${libgcj}"
2193     ;;
2194   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2195     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2196     ;;
2197   *-*-freebsd*)
2198     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2199     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2200         && test -f /usr/local/include/gmp.h; then
2201       with_gmp=/usr/local
2202     fi
2203
2204     # Skip some stuff that's unsupported on some FreeBSD configurations.
2205     case "${target}" in
2206       i*86-*-*) ;;
2207       alpha*-*-*) ;;
2208       *)
2209         noconfigdirs="$noconfigdirs ${libgcj}"
2210         ;;
2211     esac
2212     ;;
2213   *-*-kaos*)
2214     # Remove unsupported stuff on all kaOS configurations.
2215     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2216     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2217     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2218     noconfigdirs="$noconfigdirs target-libgloss"
2219     ;;
2220   *-*-netbsd*)
2221     # Skip some stuff on all NetBSD configurations.
2222     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2223
2224     # Skip some stuff that's unsupported on some NetBSD configurations.
2225     case "${target}" in
2226       i*86-*-netbsdelf*) ;;
2227       arm*-*-netbsdelf*) ;;
2228       *)
2229         noconfigdirs="$noconfigdirs ${libgcj}"
2230         ;;
2231     esac
2232     ;;
2233   *-*-netware*)
2234     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2235     ;;
2236   *-*-rtems*)
2237     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2238     ;;
2239     # The tpf target doesn't support gdb yet.
2240   *-*-tpf*)
2241     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2242     ;;
2243   *-*-uclinux*)
2244     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2245     ;;
2246   *-*-vxworks*)
2247     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2248     ;;
2249   alpha*-dec-osf*)
2250     # ld works, but does not support shared libraries.
2251     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2252     # gas doesn't generate exception information.
2253     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2254     ;;
2255   alpha*-*-*vms*)
2256     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2257     ;;
2258   alpha*-*-linux*)
2259     # newlib is not 64 bit ready
2260     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2261     ;;
2262   alpha*-*-*)
2263     # newlib is not 64 bit ready
2264     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2265     ;;
2266   am33_2.0-*-linux*)
2267     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2268     ;;
2269   sh-*-linux*)
2270     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2271     ;;
2272   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2273     noconfigdirs="$noconfigdirs ${libgcj}"
2274     noconfigdirs="$noconfigdirs target-examples"
2275     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2276     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2277     noconfigdirs="$noconfigdirs expect dejagnu"
2278     # the C++ libraries don't build on top of CE's C libraries
2279     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2280     noconfigdirs="$noconfigdirs target-newlib"
2281     case "${host}" in
2282       *-*-cygwin*) ;; # keep gdb and readline
2283       *) noconfigdirs="$noconfigdirs gdb readline"
2284          ;;
2285     esac
2286     libgloss_dir=wince
2287     ;;
2288   arc-*-*)
2289     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2290     ;;
2291   arm-semi-aof )
2292     ;;
2293   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2294     noconfigdirs="$noconfigdirs ${libgcj}"
2295     libgloss_dir=arm
2296     ;;
2297   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2298     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2299     libgloss_dir=arm
2300     ;;
2301   arm*-*-linux-gnueabi)
2302     noconfigdirs="$noconfigdirs target-qthreads"
2303     noconfigdirs="$noconfigdirs target-libobjc"
2304     case ${with_newlib} in
2305       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2306     esac
2307     libgloss_dir=arm
2308     ;;
2309   arm*-*-symbianelf*)
2310     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2311     libgloss_dir=arm
2312     ;;
2313   arm-*-pe*)
2314     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2315     ;;
2316   thumb-*-coff)
2317     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2318     ;;
2319   thumb-*-elf)
2320     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2321     ;;
2322   thumb-*-pe)
2323     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2324     ;;
2325   arm-*-riscix*)
2326     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2327     ;;
2328   avr-*-*)
2329     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2330     ;;
2331   bfin-*-*)
2332     noconfigdirs="$noconfigdirs gdb"
2333     if test x${is_cross_compiler} != xno ; then
2334       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2335     fi
2336     ;;
2337   c4x-*-* | tic4x-*-*)
2338     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2339     ;;
2340   c54x*-*-* | tic54x-*-*)
2341     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2342     ;;
2343   cris-*-* | crisv32-*-*)
2344     unsupported_languages="$unsupported_languages java"
2345     case "${target}" in
2346       *-*-aout)
2347         unsupported_languages="$unsupported_languages fortran"
2348         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2349       *-*-elf)
2350         noconfigdirs="$noconfigdirs target-boehm-gc";;
2351       *-*-linux*)
2352         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2353       *)
2354         unsupported_languages="$unsupported_languages fortran"
2355         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2356     esac
2357     libgloss_dir=cris
2358     ;;
2359   crx-*-*)
2360     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2361     ;;
2362   d10v-*-*)
2363     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2364     ;;
2365   d30v-*-*)
2366     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2367     ;;
2368   ep9312-*-elf | ep9312-*-coff)
2369     libgloss_dir=arm
2370     ;;
2371   fr30-*-elf*)
2372     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2373     ;;
2374   frv-*-*)
2375     noconfigdirs="$noconfigdirs ${libgcj}"
2376     ;;
2377   h8300*-*-*)
2378     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2379     ;;
2380   h8500-*-*)
2381     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2382     ;;
2383   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2384     ;;
2385   hppa*64*-*-linux* | parisc*64*-*-linux*)
2386     # In this case, it's because the hppa64-linux target is for
2387     # the kernel only at this point and has no libc, and thus no
2388     # headers, crt*.o, etc., all of which are needed by these.
2389     noconfigdirs="$noconfigdirs target-zlib"
2390     ;;
2391   parisc*-*-linux* | hppa*-*-linux*)
2392     ;;
2393   hppa*-*-*elf* | \
2394   hppa*-*-lites* | \
2395   hppa*-*-openbsd* | \
2396   hppa*64*-*-*)
2397     noconfigdirs="$noconfigdirs ${libgcj}"
2398     ;;
2399   hppa*-hp-hpux11*)
2400     noconfigdirs="$noconfigdirs ld shellutils"
2401     ;;
2402   hppa*-*-pro*)
2403     libgloss_dir=pa
2404     ;;
2405   hppa*-*-*)
2406     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2407     # build on HP-UX 10.20.
2408     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2409     ;;
2410   i960-*-*)
2411     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2412     ;;
2413   ia64*-*-elf*)
2414     # No gdb support yet.
2415     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2416     ;;
2417   ia64*-**-hpux*)
2418     # No gdb or ld support yet.
2419     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2420     ;;
2421   i370-*-opened*)
2422     ;;
2423   i[3456789]86-*-coff | i[3456789]86-*-elf)
2424     noconfigdirs="$noconfigdirs ${libgcj}"
2425     libgloss_dir=i386
2426     ;;
2427   i[3456789]86-*-linux*)
2428     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2429     # not build java stuff by default.
2430     case "${target}" in
2431       *-*-*libc1*)
2432         noconfigdirs="$noconfigdirs ${libgcj}";;
2433     esac
2434
2435     # This section makes it possible to build newlib natively on linux.
2436     # If we are using a cross compiler then don't configure newlib.
2437     if test x${is_cross_compiler} != xno ; then
2438       noconfigdirs="$noconfigdirs target-newlib"
2439     fi
2440     noconfigdirs="$noconfigdirs target-libgloss"
2441     # If we are not using a cross compiler, do configure newlib.
2442     # Note however, that newlib will only be configured in this situation
2443     # if the --with-newlib option has been given, because otherwise
2444     # 'target-newlib' will appear in skipdirs.
2445     ;;
2446   i[3456789]86-*-mingw32*)
2447     target_configdirs="$target_configdirs target-winsup"
2448     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2449     ;;
2450   x86_64-*-mingw*)
2451     target_configdirs="$target_configdirs target-winsup"
2452     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2453     ;;
2454   *-*-cygwin*)
2455     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2456     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2457     # always build newlib if winsup directory is present.
2458     if test -d "$srcdir/winsup/cygwin"; then
2459       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2460     elif test -d "$srcdir/newlib"; then
2461       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2462     fi
2463     ;;
2464   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2465   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2466     ;;
2467   i[3456789]86-*-pe)
2468     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2469     ;;
2470   i[3456789]86-*-sco3.2v5*)
2471     # The linker does not yet know about weak symbols in COFF,
2472     # and is not configured to handle mixed ELF and COFF.
2473     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2474     ;;
2475   i[3456789]86-*-sco*)
2476     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2477     ;;
2478   i[3456789]86-*-solaris2*)
2479     noconfigdirs="$noconfigdirs target-libgloss"
2480     ;;
2481   i[3456789]86-*-sysv4*)
2482     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2483     ;;
2484   i[3456789]86-*-beos*)
2485     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2486     ;;
2487   i[3456789]86-*-rdos*)
2488     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2489     ;;
2490   m32r-*-*)
2491     noconfigdirs="$noconfigdirs ${libgcj}"
2492     ;;
2493   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2494     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2495     libgloss_dir=m68hc11
2496     ;;
2497   m68k-*-elf*)
2498     noconfigdirs="$noconfigdirs ${libgcj}"
2499     ;;
2500   m68k-*-coff*)
2501     noconfigdirs="$noconfigdirs ${libgcj}"
2502     ;;
2503   m68*-*-* | fido-*-*)
2504     libgloss_dir=m68k
2505     ;;
2506   mcore-*-pe*)
2507   # The EPOC C++ environment does not support exceptions or rtti,
2508   # and so building libstdc++-v3 tends not to always work.
2509     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2510     ;;
2511   mmix-*-*)
2512     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2513     unsupported_languages="$unsupported_languages fortran java"
2514     ;;
2515   mn10200-*-*)
2516     noconfigdirs="$noconfigdirs ${libgcj}"
2517     ;;
2518   mn10300-*-*)
2519     noconfigdirs="$noconfigdirs ${libgcj}"
2520     ;;
2521   mt-*-*)
2522     noconfigdirs="$noconfigdirs sim"
2523     ;;
2524   powerpc-*-aix*)
2525     # copied from rs6000-*-* entry
2526     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2527     ;;
2528   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2529     target_configdirs="$target_configdirs target-winsup"
2530     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2531     # always build newlib.
2532     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2533     ;;
2534     # This is temporary until we can link against shared libraries
2535   powerpcle-*-solaris*)
2536     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2537     libgloss_dir=rs6000
2538     ;;
2539   powerpc-*-beos*)
2540     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2541     ;;
2542   powerpc-*-eabi)
2543     noconfigdirs="$noconfigdirs ${libgcj}"
2544     libgloss_dir=rs6000
2545     ;;
2546   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2547     libgloss_dir=rs6000
2548     ;;
2549   rs6000-*-lynxos*)
2550     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2551     ;;
2552   rs6000-*-aix*)
2553     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2554     ;;
2555   rs6000-*-*)
2556     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2557     ;;
2558   m68k-apollo-*)
2559     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2560     ;;
2561   mips*-sde-elf*)
2562     skipdirs="$skipdirs target-libiberty"
2563     noconfigdirs="$noconfigdirs ${libgcj}"
2564     if test x$with_newlib = xyes; then
2565       noconfigdirs="$noconfigdirs gprof"
2566     fi
2567     libgloss_dir=mips
2568     ;;
2569   mips*-*-irix5*)
2570     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2571     ;;
2572   mips*-*-irix6*)
2573     # Linking libjava exceeds command-line length limits on at least
2574     # IRIX 6.2, but not on IRIX 6.5.
2575     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2576     # <oldham@codesourcery.com>
2577     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2578     ;;
2579   mips*-*-bsd*)
2580     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2581     ;;
2582   mips*-*-linux*)
2583     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2584     ;;
2585   mips*-*-*)
2586     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2587     libgloss_dir=mips
2588     ;;
2589   romp-*-*)
2590     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2591     ;;
2592   sh-*-* | sh64-*-*)
2593     case "${host}" in
2594       i[3456789]86-*-vsta) ;; # don't add gprof back in
2595       i[3456789]86-*-go32*) ;; # don't add gprof back in
2596       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2597       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2598     esac
2599     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2600     ;;
2601   sparclet-*-aout* | sparc86x-*-*)
2602     libgloss_dir=sparc
2603     ;;
2604   sparc-*-elf*)
2605     noconfigdirs="$noconfigdirs ${libgcj}"
2606     ;;
2607   sparc64-*-elf*)
2608     noconfigdirs="$noconfigdirs ${libgcj}"
2609     libgloss_dir=sparc
2610     ;;
2611   sparclite-*-*)
2612     noconfigdirs="$noconfigdirs ${libgcj}"
2613     libgloss_dir=sparc
2614     ;;
2615   sparc-*-sunos4*)
2616     noconfigdirs="$noconfigdirs ${libgcj}"
2617     if test x${is_cross_compiler} != xno ; then
2618            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2619     else
2620            use_gnu_ld=no
2621     fi
2622     ;;
2623   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2624     noconfigdirs="$noconfigdirs ${libgcj}"
2625     ;;
2626   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2627     ;;
2628   spu-*-*)
2629     skipdirs="target-libssp"
2630     ;;
2631   v810-*-*)
2632     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2633     ;;
2634   v850-*-*)
2635     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2636     ;;
2637   v850e-*-*)
2638     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2639     ;;
2640   v850ea-*-*)
2641     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2642     ;;
2643   vax-*-vms)
2644     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2645     ;;
2646   vax-*-*)
2647     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2648     ;;
2649   xtensa*-*-*)
2650     noconfigdirs="$noconfigdirs ${libgcj}"
2651     ;;
2652   ip2k-*-*)
2653     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2654     ;;
2655   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2656     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2657     ;;
2658   *-*-lynxos*)
2659     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2660     ;;
2661   *-*-*)
2662     noconfigdirs="$noconfigdirs ${libgcj}"
2663     ;;
2664 esac
2665
2666 # If we aren't building newlib, then don't build libgloss, since libgloss
2667 # depends upon some newlib header files.
2668 case "${noconfigdirs}" in
2669   *target-libgloss*) ;;
2670   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2671 esac
2672
2673 # Work in distributions that contain no compiler tools, like Autoconf.
2674 tentative_cc=""
2675 host_makefile_frag=/dev/null
2676 if test -d ${srcdir}/config ; then
2677 case "${host}" in
2678   m68k-hp-hpux*)
2679     # Avoid "too much defining" errors from HPUX compiler.
2680     tentative_cc="cc -Wp,-H256000"
2681     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2682     # If it's HP/UX ar, this should be harmless.
2683     RANLIB="ar ts"
2684     ;;
2685   m68k-apollo-sysv*)
2686     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2687     ;;
2688   m68k-apollo-bsd*)
2689     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2690     # chokes on bfd, the compiler won't let you assign integers to enums, and
2691     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2692     # the apollo compiler" (the preferred version of GCC could be called cc,
2693     # or whatever), but I'm not sure leaving CC as cc is any better...
2694     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2695     # Used to have BISON=yacc.
2696     tentative_cc=gcc
2697     ;;
2698   m88k-dg-dgux*)
2699     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2700     ;;
2701   m88k-harris-cxux*)
2702     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2703     tentative_cc="cc -Xa"
2704     host_makefile_frag="config/mh-cxux"
2705     ;;
2706   m88k-motorola-sysv*)
2707     ;;
2708   mips*-dec-ultrix*)
2709     tentative_cc="cc -Wf,-XNg1000"
2710     host_makefile_frag="config/mh-decstation"
2711     ;;
2712   mips*-nec-sysv4*)
2713     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2714     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2715     host_makefile_frag="config/mh-necv4"
2716     ;;
2717   mips*-sgi-irix4*)
2718     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2719     # environment.  Also bump switch table size so that cp-parse will
2720     # compile.  Bump string length limit so linker builds.
2721     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2722     ;;
2723   mips*-*-sysv4*)
2724     host_makefile_frag="config/mh-sysv4"
2725     ;;
2726   mips*-*-sysv*)
2727     # This is for a MIPS running RISC/os 4.52C.
2728
2729     # This is needed for GDB, but needs to be in the top-level make because
2730     # if a library is compiled with the bsd headers and gets linked with the
2731     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2732     # a different size).
2733     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2734     # known except to select the sysv environment.  Could we use /proc instead?
2735     # These "sysv environments" and "bsd environments" often end up being a pain.
2736     #
2737     # This is not part of CFLAGS because perhaps not all C compilers have this
2738     # option.
2739     tentative_cc="cc -systype sysv"
2740     ;;
2741   i370-ibm-opened*)
2742     tentative_cc="c89"
2743     ;;
2744   i[3456789]86-*-sysv5*)
2745     host_makefile_frag="config/mh-sysv5"
2746     ;;
2747   i[3456789]86-*-dgux*)
2748     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2749     host_makefile_frag="config/mh-dgux386"
2750     ;;
2751   i[3456789]86-ncr-sysv4.3*)
2752     # The MetaWare compiler will generate a copyright message unless you
2753     # turn it off by adding the -Hnocopyr flag.
2754     tentative_cc="cc -Hnocopyr"
2755     ;;
2756   i[3456789]86-ncr-sysv4*)
2757     # for an NCR 3000 (i486/SVR4) system.
2758     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2759     # This compiler not only emits obnoxious copyright messages every time
2760     # you run it, but it chokes and dies on a whole bunch of GNU source
2761     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2762     tentative_cc="/usr/ccs/ATT/cc"
2763     host_makefile_frag="config/mh-ncr3000"
2764     ;;
2765   i[3456789]86-*-sco3.2v5*)
2766     ;;
2767   i[3456789]86-*-sco*)
2768     # The native C compiler botches some simple uses of const.  Unfortunately,
2769     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2770     tentative_cc="cc -Dconst="
2771     host_makefile_frag="config/mh-sco"
2772     ;;
2773   i[3456789]86-*-udk*)
2774     host_makefile_frag="config/mh-sysv5"
2775     ;;
2776   i[3456789]86-*-solaris2*)
2777     host_makefile_frag="config/mh-sysv4"
2778     ;;
2779   i[3456789]86-*-msdosdjgpp*)
2780     host_makefile_frag="config/mh-djgpp"
2781     ;;
2782   *-cygwin*)
2783     host_makefile_frag="config/mh-cygwin"
2784     ;;
2785   *-mingw32*)
2786     host_makefile_frag="config/mh-mingw"
2787     ;;
2788   *-mingw64*)
2789     host_makefile_frag="config/mh-mingw"
2790     ;;
2791   *-interix*)
2792     host_makefile_frag="config/mh-interix"
2793     ;;
2794   vax-*-ultrix2*)
2795     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2796     tentative_cc=gcc
2797     ;;
2798   *-*-solaris2*)
2799     host_makefile_frag="config/mh-solaris"
2800     ;;
2801   m68k-sun-sunos*)
2802     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2803     # without overflowing the jump tables (-J says to use a 32 bit table)
2804     tentative_cc="cc -J"
2805     ;;
2806   *-hp-hpux*)
2807     tentative_cc="cc -Wp,-H256000"
2808     ;;
2809   *-*-hiux*)
2810     tentative_cc="cc -Wp,-H256000"
2811     ;;
2812   rs6000-*-lynxos*)
2813     # /bin/cc is less than useful for our purposes.  Always use GCC
2814     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2815     host_makefile_frag="config/mh-lynxrs6k"
2816     ;;
2817   powerpc-*-darwin*)
2818     host_makefile_frag="config/mh-ppc-darwin"
2819     ;;
2820   powerpc-*-aix*)
2821     host_makefile_frag="config/mh-ppc-aix"
2822     ;;
2823   rs6000-*-aix*)
2824     host_makefile_frag="config/mh-ppc-aix"
2825     ;;
2826   *-*-lynxos*)
2827     # /bin/cc is less than useful for our purposes.  Always use GCC
2828     tentative_cc="/bin/gcc"
2829     ;;
2830   *-*-sysv4*)
2831     host_makefile_frag="config/mh-sysv4"
2832     ;;
2833   # This is placed last to prevent interfering with the cases above.
2834   i[3456789]86-*-*)
2835     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2836     host_makefile_frag="config/mh-x86omitfp"
2837     ;;
2838 esac
2839 fi
2840
2841 # If we aren't going to be using gcc, see if we can extract a definition
2842 # of CC from the fragment.
2843 # Actually, use the 'pre-extracted' version above.
2844 if test -z "${CC}" && test "${build}" = "${host}" ; then
2845   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2846   found=
2847   for dir in $PATH; do
2848     test -z "$dir" && dir=.
2849     if test -f $dir/gcc; then
2850       found=yes
2851       break
2852     fi
2853   done
2854   IFS="$save_ifs"
2855   if test -z "${found}" && test -n "${tentative_cc}" ; then
2856     CC=$tentative_cc
2857   fi
2858 fi
2859
2860 if test "${build}" != "${host}" ; then
2861   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2862   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2863   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2864   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2865   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2866   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2867   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2868   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2869   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2870   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2871   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2872   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2873 else
2874   AR_FOR_BUILD="\$(AR)"
2875   AS_FOR_BUILD="\$(AS)"
2876   CC_FOR_BUILD="\$(CC)"
2877   CXX_FOR_BUILD="\$(CXX)"
2878   GCJ_FOR_BUILD="\$(GCJ)"
2879   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2880   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2881   LD_FOR_BUILD="\$(LD)"
2882   NM_FOR_BUILD="\$(NM)"
2883   RANLIB_FOR_BUILD="\$(RANLIB)"
2884   WINDRES_FOR_BUILD="\$(WINDRES)"
2885   WINDMC_FOR_BUILD="\$(WINDMC)"
2886 fi
2887
2888 ac_ext=c
2889 ac_cpp='$CPP $CPPFLAGS'
2890 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2891 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2892 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2893 if test -n "$ac_tool_prefix"; then
2894   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2895 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2896 echo "$as_me:$LINENO: checking for $ac_word" >&5
2897 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2898 if test "${ac_cv_prog_CC+set}" = set; then
2899   echo $ECHO_N "(cached) $ECHO_C" >&6
2900 else
2901   if test -n "$CC"; then
2902   ac_cv_prog_CC="$CC" # Let the user override the test.
2903 else
2904 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2905 for as_dir in $PATH
2906 do
2907   IFS=$as_save_IFS
2908   test -z "$as_dir" && as_dir=.
2909   for ac_exec_ext in '' $ac_executable_extensions; do
2910   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2911     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2912     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2913     break 2
2914   fi
2915 done
2916 done
2917
2918 fi
2919 fi
2920 CC=$ac_cv_prog_CC
2921 if test -n "$CC"; then
2922   echo "$as_me:$LINENO: result: $CC" >&5
2923 echo "${ECHO_T}$CC" >&6
2924 else
2925   echo "$as_me:$LINENO: result: no" >&5
2926 echo "${ECHO_T}no" >&6
2927 fi
2928
2929 fi
2930 if test -z "$ac_cv_prog_CC"; then
2931   ac_ct_CC=$CC
2932   # Extract the first word of "gcc", so it can be a program name with args.
2933 set dummy gcc; ac_word=$2
2934 echo "$as_me:$LINENO: checking for $ac_word" >&5
2935 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2936 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2937   echo $ECHO_N "(cached) $ECHO_C" >&6
2938 else
2939   if test -n "$ac_ct_CC"; then
2940   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2941 else
2942 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2943 for as_dir in $PATH
2944 do
2945   IFS=$as_save_IFS
2946   test -z "$as_dir" && as_dir=.
2947   for ac_exec_ext in '' $ac_executable_extensions; do
2948   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2949     ac_cv_prog_ac_ct_CC="gcc"
2950     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2951     break 2
2952   fi
2953 done
2954 done
2955
2956 fi
2957 fi
2958 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2959 if test -n "$ac_ct_CC"; then
2960   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2961 echo "${ECHO_T}$ac_ct_CC" >&6
2962 else
2963   echo "$as_me:$LINENO: result: no" >&5
2964 echo "${ECHO_T}no" >&6
2965 fi
2966
2967   CC=$ac_ct_CC
2968 else
2969   CC="$ac_cv_prog_CC"
2970 fi
2971
2972 if test -z "$CC"; then
2973   if test -n "$ac_tool_prefix"; then
2974   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2975 set dummy ${ac_tool_prefix}cc; ac_word=$2
2976 echo "$as_me:$LINENO: checking for $ac_word" >&5
2977 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2978 if test "${ac_cv_prog_CC+set}" = set; then
2979   echo $ECHO_N "(cached) $ECHO_C" >&6
2980 else
2981   if test -n "$CC"; then
2982   ac_cv_prog_CC="$CC" # Let the user override the test.
2983 else
2984 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2985 for as_dir in $PATH
2986 do
2987   IFS=$as_save_IFS
2988   test -z "$as_dir" && as_dir=.
2989   for ac_exec_ext in '' $ac_executable_extensions; do
2990   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2991     ac_cv_prog_CC="${ac_tool_prefix}cc"
2992     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2993     break 2
2994   fi
2995 done
2996 done
2997
2998 fi
2999 fi
3000 CC=$ac_cv_prog_CC
3001 if test -n "$CC"; then
3002   echo "$as_me:$LINENO: result: $CC" >&5
3003 echo "${ECHO_T}$CC" >&6
3004 else
3005   echo "$as_me:$LINENO: result: no" >&5
3006 echo "${ECHO_T}no" >&6
3007 fi
3008
3009 fi
3010 if test -z "$ac_cv_prog_CC"; then
3011   ac_ct_CC=$CC
3012   # Extract the first word of "cc", so it can be a program name with args.
3013 set dummy cc; ac_word=$2
3014 echo "$as_me:$LINENO: checking for $ac_word" >&5
3015 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3016 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3017   echo $ECHO_N "(cached) $ECHO_C" >&6
3018 else
3019   if test -n "$ac_ct_CC"; then
3020   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3021 else
3022 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3023 for as_dir in $PATH
3024 do
3025   IFS=$as_save_IFS
3026   test -z "$as_dir" && as_dir=.
3027   for ac_exec_ext in '' $ac_executable_extensions; do
3028   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3029     ac_cv_prog_ac_ct_CC="cc"
3030     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3031     break 2
3032   fi
3033 done
3034 done
3035
3036 fi
3037 fi
3038 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3039 if test -n "$ac_ct_CC"; then
3040   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3041 echo "${ECHO_T}$ac_ct_CC" >&6
3042 else
3043   echo "$as_me:$LINENO: result: no" >&5
3044 echo "${ECHO_T}no" >&6
3045 fi
3046
3047   CC=$ac_ct_CC
3048 else
3049   CC="$ac_cv_prog_CC"
3050 fi
3051
3052 fi
3053 if test -z "$CC"; then
3054   # Extract the first word of "cc", so it can be a program name with args.
3055 set dummy cc; ac_word=$2
3056 echo "$as_me:$LINENO: checking for $ac_word" >&5
3057 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3058 if test "${ac_cv_prog_CC+set}" = set; then
3059   echo $ECHO_N "(cached) $ECHO_C" >&6
3060 else
3061   if test -n "$CC"; then
3062   ac_cv_prog_CC="$CC" # Let the user override the test.
3063 else
3064   ac_prog_rejected=no
3065 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3066 for as_dir in $PATH
3067 do
3068   IFS=$as_save_IFS
3069   test -z "$as_dir" && as_dir=.
3070   for ac_exec_ext in '' $ac_executable_extensions; do
3071   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3072     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3073        ac_prog_rejected=yes
3074        continue
3075      fi
3076     ac_cv_prog_CC="cc"
3077     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3078     break 2
3079   fi
3080 done
3081 done
3082
3083 if test $ac_prog_rejected = yes; then
3084   # We found a bogon in the path, so make sure we never use it.
3085   set dummy $ac_cv_prog_CC
3086   shift
3087   if test $# != 0; then
3088     # We chose a different compiler from the bogus one.
3089     # However, it has the same basename, so the bogon will be chosen
3090     # first if we set CC to just the basename; use the full file name.
3091     shift
3092     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3093   fi
3094 fi
3095 fi
3096 fi
3097 CC=$ac_cv_prog_CC
3098 if test -n "$CC"; then
3099   echo "$as_me:$LINENO: result: $CC" >&5
3100 echo "${ECHO_T}$CC" >&6
3101 else
3102   echo "$as_me:$LINENO: result: no" >&5
3103 echo "${ECHO_T}no" >&6
3104 fi
3105
3106 fi
3107 if test -z "$CC"; then
3108   if test -n "$ac_tool_prefix"; then
3109   for ac_prog in cl
3110   do
3111     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3112 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3113 echo "$as_me:$LINENO: checking for $ac_word" >&5
3114 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3115 if test "${ac_cv_prog_CC+set}" = set; then
3116   echo $ECHO_N "(cached) $ECHO_C" >&6
3117 else
3118   if test -n "$CC"; then
3119   ac_cv_prog_CC="$CC" # Let the user override the test.
3120 else
3121 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3122 for as_dir in $PATH
3123 do
3124   IFS=$as_save_IFS
3125   test -z "$as_dir" && as_dir=.
3126   for ac_exec_ext in '' $ac_executable_extensions; do
3127   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3128     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3129     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3130     break 2
3131   fi
3132 done
3133 done
3134
3135 fi
3136 fi
3137 CC=$ac_cv_prog_CC
3138 if test -n "$CC"; then
3139   echo "$as_me:$LINENO: result: $CC" >&5
3140 echo "${ECHO_T}$CC" >&6
3141 else
3142   echo "$as_me:$LINENO: result: no" >&5
3143 echo "${ECHO_T}no" >&6
3144 fi
3145
3146     test -n "$CC" && break
3147   done
3148 fi
3149 if test -z "$CC"; then
3150   ac_ct_CC=$CC
3151   for ac_prog in cl
3152 do
3153   # Extract the first word of "$ac_prog", so it can be a program name with args.
3154 set dummy $ac_prog; ac_word=$2
3155 echo "$as_me:$LINENO: checking for $ac_word" >&5
3156 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3157 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3158   echo $ECHO_N "(cached) $ECHO_C" >&6
3159 else
3160   if test -n "$ac_ct_CC"; then
3161   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3162 else
3163 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3164 for as_dir in $PATH
3165 do
3166   IFS=$as_save_IFS
3167   test -z "$as_dir" && as_dir=.
3168   for ac_exec_ext in '' $ac_executable_extensions; do
3169   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3170     ac_cv_prog_ac_ct_CC="$ac_prog"
3171     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3172     break 2
3173   fi
3174 done
3175 done
3176
3177 fi
3178 fi
3179 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3180 if test -n "$ac_ct_CC"; then
3181   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3182 echo "${ECHO_T}$ac_ct_CC" >&6
3183 else
3184   echo "$as_me:$LINENO: result: no" >&5
3185 echo "${ECHO_T}no" >&6
3186 fi
3187
3188   test -n "$ac_ct_CC" && break
3189 done
3190
3191   CC=$ac_ct_CC
3192 fi
3193
3194 fi
3195
3196
3197 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3198 See \`config.log' for more details." >&5
3199 echo "$as_me: error: no acceptable C compiler found in \$PATH
3200 See \`config.log' for more details." >&2;}
3201    { (exit 1); exit 1; }; }
3202
3203 # Provide some information about the compiler.
3204 echo "$as_me:$LINENO:" \
3205      "checking for C compiler version" >&5
3206 ac_compiler=`set X $ac_compile; echo $2`
3207 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3208   (eval $ac_compiler --version </dev/null >&5) 2>&5
3209   ac_status=$?
3210   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3211   (exit $ac_status); }
3212 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3213   (eval $ac_compiler -v </dev/null >&5) 2>&5
3214   ac_status=$?
3215   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3216   (exit $ac_status); }
3217 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3218   (eval $ac_compiler -V </dev/null >&5) 2>&5
3219   ac_status=$?
3220   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3221   (exit $ac_status); }
3222
3223 cat >conftest.$ac_ext <<_ACEOF
3224 /* confdefs.h.  */
3225 _ACEOF
3226 cat confdefs.h >>conftest.$ac_ext
3227 cat >>conftest.$ac_ext <<_ACEOF
3228 /* end confdefs.h.  */
3229
3230 int
3231 main ()
3232 {
3233
3234   ;
3235   return 0;
3236 }
3237 _ACEOF
3238 ac_clean_files_save=$ac_clean_files
3239 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3240 # Try to create an executable without -o first, disregard a.out.
3241 # It will help us diagnose broken compilers, and finding out an intuition
3242 # of exeext.
3243 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3244 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3245 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3246 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3247   (eval $ac_link_default) 2>&5
3248   ac_status=$?
3249   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3250   (exit $ac_status); }; then
3251   # Find the output, starting from the most likely.  This scheme is
3252 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3253 # resort.
3254
3255 # Be careful to initialize this variable, since it used to be cached.
3256 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3257 ac_cv_exeext=
3258 # b.out is created by i960 compilers.
3259 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3260 do
3261   test -f "$ac_file" || continue
3262   case $ac_file in
3263     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3264         ;;
3265     conftest.$ac_ext )
3266         # This is the source file.
3267         ;;
3268     [ab].out )
3269         # We found the default executable, but exeext='' is most
3270         # certainly right.
3271         break;;
3272     *.* )
3273         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3274         # FIXME: I believe we export ac_cv_exeext for Libtool,
3275         # but it would be cool to find out if it's true.  Does anybody
3276         # maintain Libtool? --akim.
3277         export ac_cv_exeext
3278         break;;
3279     * )
3280         break;;
3281   esac
3282 done
3283 else
3284   echo "$as_me: failed program was:" >&5
3285 sed 's/^/| /' conftest.$ac_ext >&5
3286
3287 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3288 See \`config.log' for more details." >&5
3289 echo "$as_me: error: C compiler cannot create executables
3290 See \`config.log' for more details." >&2;}
3291    { (exit 77); exit 77; }; }
3292 fi
3293
3294 ac_exeext=$ac_cv_exeext
3295 echo "$as_me:$LINENO: result: $ac_file" >&5
3296 echo "${ECHO_T}$ac_file" >&6
3297
3298 # Check the compiler produces executables we can run.  If not, either
3299 # the compiler is broken, or we cross compile.
3300 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3301 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3302 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3303 # If not cross compiling, check that we can run a simple program.
3304 if test "$cross_compiling" != yes; then
3305   if { ac_try='./$ac_file'
3306   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3307   (eval $ac_try) 2>&5
3308   ac_status=$?
3309   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3310   (exit $ac_status); }; }; then
3311     cross_compiling=no
3312   else
3313     if test "$cross_compiling" = maybe; then
3314         cross_compiling=yes
3315     else
3316         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3317 If you meant to cross compile, use \`--host'.
3318 See \`config.log' for more details." >&5
3319 echo "$as_me: error: cannot run C compiled programs.
3320 If you meant to cross compile, use \`--host'.
3321 See \`config.log' for more details." >&2;}
3322    { (exit 1); exit 1; }; }
3323     fi
3324   fi
3325 fi
3326 echo "$as_me:$LINENO: result: yes" >&5
3327 echo "${ECHO_T}yes" >&6
3328
3329 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3330 ac_clean_files=$ac_clean_files_save
3331 # Check the compiler produces executables we can run.  If not, either
3332 # the compiler is broken, or we cross compile.
3333 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3334 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3335 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3336 echo "${ECHO_T}$cross_compiling" >&6
3337
3338 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3339 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3340 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3341   (eval $ac_link) 2>&5
3342   ac_status=$?
3343   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3344   (exit $ac_status); }; then
3345   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3346 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3347 # work properly (i.e., refer to `conftest.exe'), while it won't with
3348 # `rm'.
3349 for ac_file in conftest.exe conftest conftest.*; do
3350   test -f "$ac_file" || continue
3351   case $ac_file in
3352     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3353     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3354           export ac_cv_exeext
3355           break;;
3356     * ) break;;
3357   esac
3358 done
3359 else
3360   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3361 See \`config.log' for more details." >&5
3362 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3363 See \`config.log' for more details." >&2;}
3364    { (exit 1); exit 1; }; }
3365 fi
3366
3367 rm -f conftest$ac_cv_exeext
3368 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3369 echo "${ECHO_T}$ac_cv_exeext" >&6
3370
3371 rm -f conftest.$ac_ext
3372 EXEEXT=$ac_cv_exeext
3373 ac_exeext=$EXEEXT
3374 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3375 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3376 if test "${ac_cv_objext+set}" = set; then
3377   echo $ECHO_N "(cached) $ECHO_C" >&6
3378 else
3379   cat >conftest.$ac_ext <<_ACEOF
3380 /* confdefs.h.  */
3381 _ACEOF
3382 cat confdefs.h >>conftest.$ac_ext
3383 cat >>conftest.$ac_ext <<_ACEOF
3384 /* end confdefs.h.  */
3385
3386 int
3387 main ()
3388 {
3389
3390   ;
3391   return 0;
3392 }
3393 _ACEOF
3394 rm -f conftest.o conftest.obj
3395 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3396   (eval $ac_compile) 2>&5
3397   ac_status=$?
3398   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3399   (exit $ac_status); }; then
3400   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3401   case $ac_file in
3402     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3403     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3404        break;;
3405   esac
3406 done
3407 else
3408   echo "$as_me: failed program was:" >&5
3409 sed 's/^/| /' conftest.$ac_ext >&5
3410
3411 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3412 See \`config.log' for more details." >&5
3413 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3414 See \`config.log' for more details." >&2;}
3415    { (exit 1); exit 1; }; }
3416 fi
3417
3418 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3419 fi
3420 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3421 echo "${ECHO_T}$ac_cv_objext" >&6
3422 OBJEXT=$ac_cv_objext
3423 ac_objext=$OBJEXT
3424 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3425 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3426 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3427   echo $ECHO_N "(cached) $ECHO_C" >&6
3428 else
3429   cat >conftest.$ac_ext <<_ACEOF
3430 /* confdefs.h.  */
3431 _ACEOF
3432 cat confdefs.h >>conftest.$ac_ext
3433 cat >>conftest.$ac_ext <<_ACEOF
3434 /* end confdefs.h.  */
3435
3436 int
3437 main ()
3438 {
3439 #ifndef __GNUC__
3440        choke me
3441 #endif
3442
3443   ;
3444   return 0;
3445 }
3446 _ACEOF
3447 rm -f conftest.$ac_objext
3448 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3449   (eval $ac_compile) 2>conftest.er1
3450   ac_status=$?
3451   grep -v '^ *+' conftest.er1 >conftest.err
3452   rm -f conftest.er1
3453   cat conftest.err >&5
3454   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3455   (exit $ac_status); } &&
3456          { ac_try='test -z "$ac_c_werror_flag"
3457                          || test ! -s conftest.err'
3458   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3459   (eval $ac_try) 2>&5
3460   ac_status=$?
3461   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3462   (exit $ac_status); }; } &&
3463          { ac_try='test -s conftest.$ac_objext'
3464   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3465   (eval $ac_try) 2>&5
3466   ac_status=$?
3467   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3468   (exit $ac_status); }; }; then
3469   ac_compiler_gnu=yes
3470 else
3471   echo "$as_me: failed program was:" >&5
3472 sed 's/^/| /' conftest.$ac_ext >&5
3473
3474 ac_compiler_gnu=no
3475 fi
3476 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3477 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3478
3479 fi
3480 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3481 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3482 GCC=`test $ac_compiler_gnu = yes && echo yes`
3483 ac_test_CFLAGS=${CFLAGS+set}
3484 ac_save_CFLAGS=$CFLAGS
3485 CFLAGS="-g"
3486 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3487 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3488 if test "${ac_cv_prog_cc_g+set}" = set; then
3489   echo $ECHO_N "(cached) $ECHO_C" >&6
3490 else
3491   cat >conftest.$ac_ext <<_ACEOF
3492 /* confdefs.h.  */
3493 _ACEOF
3494 cat confdefs.h >>conftest.$ac_ext
3495 cat >>conftest.$ac_ext <<_ACEOF
3496 /* end confdefs.h.  */
3497
3498 int
3499 main ()
3500 {
3501
3502   ;
3503   return 0;
3504 }
3505 _ACEOF
3506 rm -f conftest.$ac_objext
3507 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3508   (eval $ac_compile) 2>conftest.er1
3509   ac_status=$?
3510   grep -v '^ *+' conftest.er1 >conftest.err
3511   rm -f conftest.er1
3512   cat conftest.err >&5
3513   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3514   (exit $ac_status); } &&
3515          { ac_try='test -z "$ac_c_werror_flag"
3516                          || test ! -s conftest.err'
3517   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3518   (eval $ac_try) 2>&5
3519   ac_status=$?
3520   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3521   (exit $ac_status); }; } &&
3522          { ac_try='test -s conftest.$ac_objext'
3523   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3524   (eval $ac_try) 2>&5
3525   ac_status=$?
3526   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3527   (exit $ac_status); }; }; then
3528   ac_cv_prog_cc_g=yes
3529 else
3530   echo "$as_me: failed program was:" >&5
3531 sed 's/^/| /' conftest.$ac_ext >&5
3532
3533 ac_cv_prog_cc_g=no
3534 fi
3535 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3536 fi
3537 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3538 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3539 if test "$ac_test_CFLAGS" = set; then
3540   CFLAGS=$ac_save_CFLAGS
3541 elif test $ac_cv_prog_cc_g = yes; then
3542   if test "$GCC" = yes; then
3543     CFLAGS="-g -O2"
3544   else
3545     CFLAGS="-g"
3546   fi
3547 else
3548   if test "$GCC" = yes; then
3549     CFLAGS="-O2"
3550   else
3551     CFLAGS=
3552   fi
3553 fi
3554 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3555 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3556 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3557   echo $ECHO_N "(cached) $ECHO_C" >&6
3558 else
3559   ac_cv_prog_cc_stdc=no
3560 ac_save_CC=$CC
3561 cat >conftest.$ac_ext <<_ACEOF
3562 /* confdefs.h.  */
3563 _ACEOF
3564 cat confdefs.h >>conftest.$ac_ext
3565 cat >>conftest.$ac_ext <<_ACEOF
3566 /* end confdefs.h.  */
3567 #include <stdarg.h>
3568 #include <stdio.h>
3569 #include <sys/types.h>
3570 #include <sys/stat.h>
3571 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3572 struct buf { int x; };
3573 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3574 static char *e (p, i)
3575      char **p;
3576      int i;
3577 {
3578   return p[i];
3579 }
3580 static char *f (char * (*g) (char **, int), char **p, ...)
3581 {
3582   char *s;
3583   va_list v;
3584   va_start (v,p);
3585   s = g (p, va_arg (v,int));
3586   va_end (v);
3587   return s;
3588 }
3589
3590 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3591    function prototypes and stuff, but not '\xHH' hex character constants.
3592    These don't provoke an error unfortunately, instead are silently treated
3593    as 'x'.  The following induces an error, until -std1 is added to get
3594    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3595    array size at least.  It's necessary to write '\x00'==0 to get something
3596    that's true only with -std1.  */
3597 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3598
3599 int test (int i, double x);
3600 struct s1 {int (*f) (int a);};
3601 struct s2 {int (*f) (double a);};
3602 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3603 int argc;
3604 char **argv;
3605 int
3606 main ()
3607 {
3608 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3609   ;
3610   return 0;
3611 }
3612 _ACEOF
3613 # Don't try gcc -ansi; that turns off useful extensions and
3614 # breaks some systems' header files.
3615 # AIX                   -qlanglvl=ansi
3616 # Ultrix and OSF/1      -std1
3617 # HP-UX 10.20 and later -Ae
3618 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3619 # SVR4                  -Xc -D__EXTENSIONS__
3620 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3621 do
3622   CC="$ac_save_CC $ac_arg"
3623   rm -f conftest.$ac_objext
3624 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3625   (eval $ac_compile) 2>conftest.er1
3626   ac_status=$?
3627   grep -v '^ *+' conftest.er1 >conftest.err
3628   rm -f conftest.er1
3629   cat conftest.err >&5
3630   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3631   (exit $ac_status); } &&
3632          { ac_try='test -z "$ac_c_werror_flag"
3633                          || test ! -s conftest.err'
3634   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3635   (eval $ac_try) 2>&5
3636   ac_status=$?
3637   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3638   (exit $ac_status); }; } &&
3639          { ac_try='test -s conftest.$ac_objext'
3640   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3641   (eval $ac_try) 2>&5
3642   ac_status=$?
3643   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3644   (exit $ac_status); }; }; then
3645   ac_cv_prog_cc_stdc=$ac_arg
3646 break
3647 else
3648   echo "$as_me: failed program was:" >&5
3649 sed 's/^/| /' conftest.$ac_ext >&5
3650
3651 fi
3652 rm -f conftest.err conftest.$ac_objext
3653 done
3654 rm -f conftest.$ac_ext conftest.$ac_objext
3655 CC=$ac_save_CC
3656
3657 fi
3658
3659 case "x$ac_cv_prog_cc_stdc" in
3660   x|xno)
3661     echo "$as_me:$LINENO: result: none needed" >&5
3662 echo "${ECHO_T}none needed" >&6 ;;
3663   *)
3664     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3665 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3666     CC="$CC $ac_cv_prog_cc_stdc" ;;
3667 esac
3668
3669 # Some people use a C++ compiler to compile C.  Since we use `exit',
3670 # in C++ we need to declare it.  In case someone uses the same compiler
3671 # for both compiling C and C++ we need to have the C++ compiler decide
3672 # the declaration of exit, since it's the most demanding environment.
3673 cat >conftest.$ac_ext <<_ACEOF
3674 #ifndef __cplusplus
3675   choke me
3676 #endif
3677 _ACEOF
3678 rm -f conftest.$ac_objext
3679 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3680   (eval $ac_compile) 2>conftest.er1
3681   ac_status=$?
3682   grep -v '^ *+' conftest.er1 >conftest.err
3683   rm -f conftest.er1
3684   cat conftest.err >&5
3685   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3686   (exit $ac_status); } &&
3687          { ac_try='test -z "$ac_c_werror_flag"
3688                          || test ! -s conftest.err'
3689   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3690   (eval $ac_try) 2>&5
3691   ac_status=$?
3692   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3693   (exit $ac_status); }; } &&
3694          { ac_try='test -s conftest.$ac_objext'
3695   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3696   (eval $ac_try) 2>&5
3697   ac_status=$?
3698   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3699   (exit $ac_status); }; }; then
3700   for ac_declaration in \
3701    '' \
3702    'extern "C" void std::exit (int) throw (); using std::exit;' \
3703    'extern "C" void std::exit (int); using std::exit;' \
3704    'extern "C" void exit (int) throw ();' \
3705    'extern "C" void exit (int);' \
3706    'void exit (int);'
3707 do
3708   cat >conftest.$ac_ext <<_ACEOF
3709 /* confdefs.h.  */
3710 _ACEOF
3711 cat confdefs.h >>conftest.$ac_ext
3712 cat >>conftest.$ac_ext <<_ACEOF
3713 /* end confdefs.h.  */
3714 $ac_declaration
3715 #include <stdlib.h>
3716 int
3717 main ()
3718 {
3719 exit (42);
3720   ;
3721   return 0;
3722 }
3723 _ACEOF
3724 rm -f conftest.$ac_objext
3725 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3726   (eval $ac_compile) 2>conftest.er1
3727   ac_status=$?
3728   grep -v '^ *+' conftest.er1 >conftest.err
3729   rm -f conftest.er1
3730   cat conftest.err >&5
3731   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3732   (exit $ac_status); } &&
3733          { ac_try='test -z "$ac_c_werror_flag"
3734                          || test ! -s conftest.err'
3735   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3736   (eval $ac_try) 2>&5
3737   ac_status=$?
3738   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3739   (exit $ac_status); }; } &&
3740          { ac_try='test -s conftest.$ac_objext'
3741   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3742   (eval $ac_try) 2>&5
3743   ac_status=$?
3744   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3745   (exit $ac_status); }; }; then
3746   :
3747 else
3748   echo "$as_me: failed program was:" >&5
3749 sed 's/^/| /' conftest.$ac_ext >&5
3750
3751 continue
3752 fi
3753 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3754   cat >conftest.$ac_ext <<_ACEOF
3755 /* confdefs.h.  */
3756 _ACEOF
3757 cat confdefs.h >>conftest.$ac_ext
3758 cat >>conftest.$ac_ext <<_ACEOF
3759 /* end confdefs.h.  */
3760 $ac_declaration
3761 int
3762 main ()
3763 {
3764 exit (42);
3765   ;
3766   return 0;
3767 }
3768 _ACEOF
3769 rm -f conftest.$ac_objext
3770 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3771   (eval $ac_compile) 2>conftest.er1
3772   ac_status=$?
3773   grep -v '^ *+' conftest.er1 >conftest.err
3774   rm -f conftest.er1
3775   cat conftest.err >&5
3776   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3777   (exit $ac_status); } &&
3778          { ac_try='test -z "$ac_c_werror_flag"
3779                          || test ! -s conftest.err'
3780   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3781   (eval $ac_try) 2>&5
3782   ac_status=$?
3783   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3784   (exit $ac_status); }; } &&
3785          { ac_try='test -s conftest.$ac_objext'
3786   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3787   (eval $ac_try) 2>&5
3788   ac_status=$?
3789   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3790   (exit $ac_status); }; }; then
3791   break
3792 else
3793   echo "$as_me: failed program was:" >&5
3794 sed 's/^/| /' conftest.$ac_ext >&5
3795
3796 fi
3797 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3798 done
3799 rm -f conftest*
3800 if test -n "$ac_declaration"; then
3801   echo '#ifdef __cplusplus' >>confdefs.h
3802   echo $ac_declaration      >>confdefs.h
3803   echo '#endif'             >>confdefs.h
3804 fi
3805
3806 else
3807   echo "$as_me: failed program was:" >&5
3808 sed 's/^/| /' conftest.$ac_ext >&5
3809
3810 fi
3811 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3812 ac_ext=c
3813 ac_cpp='$CPP $CPPFLAGS'
3814 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3815 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3816 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3817
3818 ac_ext=cc
3819 ac_cpp='$CXXCPP $CPPFLAGS'
3820 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3821 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3822 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3823 if test -n "$ac_tool_prefix"; then
3824   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3825   do
3826     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3827 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3828 echo "$as_me:$LINENO: checking for $ac_word" >&5
3829 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3830 if test "${ac_cv_prog_CXX+set}" = set; then
3831   echo $ECHO_N "(cached) $ECHO_C" >&6
3832 else
3833   if test -n "$CXX"; then
3834   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3835 else
3836 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3837 for as_dir in $PATH
3838 do
3839   IFS=$as_save_IFS
3840   test -z "$as_dir" && as_dir=.
3841   for ac_exec_ext in '' $ac_executable_extensions; do
3842   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3843     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3844     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3845     break 2
3846   fi
3847 done
3848 done
3849
3850 fi
3851 fi
3852 CXX=$ac_cv_prog_CXX
3853 if test -n "$CXX"; then
3854   echo "$as_me:$LINENO: result: $CXX" >&5
3855 echo "${ECHO_T}$CXX" >&6
3856 else
3857   echo "$as_me:$LINENO: result: no" >&5
3858 echo "${ECHO_T}no" >&6
3859 fi
3860
3861     test -n "$CXX" && break
3862   done
3863 fi
3864 if test -z "$CXX"; then
3865   ac_ct_CXX=$CXX
3866   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3867 do
3868   # Extract the first word of "$ac_prog", so it can be a program name with args.
3869 set dummy $ac_prog; ac_word=$2
3870 echo "$as_me:$LINENO: checking for $ac_word" >&5
3871 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3872 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3873   echo $ECHO_N "(cached) $ECHO_C" >&6
3874 else
3875   if test -n "$ac_ct_CXX"; then
3876   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3877 else
3878 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3879 for as_dir in $PATH
3880 do
3881   IFS=$as_save_IFS
3882   test -z "$as_dir" && as_dir=.
3883   for ac_exec_ext in '' $ac_executable_extensions; do
3884   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3885     ac_cv_prog_ac_ct_CXX="$ac_prog"
3886     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3887     break 2
3888   fi
3889 done
3890 done
3891
3892 fi
3893 fi
3894 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3895 if test -n "$ac_ct_CXX"; then
3896   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3897 echo "${ECHO_T}$ac_ct_CXX" >&6
3898 else
3899   echo "$as_me:$LINENO: result: no" >&5
3900 echo "${ECHO_T}no" >&6
3901 fi
3902
3903   test -n "$ac_ct_CXX" && break
3904 done
3905 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3906
3907   CXX=$ac_ct_CXX
3908 fi
3909
3910
3911 # Provide some information about the compiler.
3912 echo "$as_me:$LINENO:" \
3913      "checking for C++ compiler version" >&5
3914 ac_compiler=`set X $ac_compile; echo $2`
3915 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3916   (eval $ac_compiler --version </dev/null >&5) 2>&5
3917   ac_status=$?
3918   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3919   (exit $ac_status); }
3920 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3921   (eval $ac_compiler -v </dev/null >&5) 2>&5
3922   ac_status=$?
3923   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3924   (exit $ac_status); }
3925 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3926   (eval $ac_compiler -V </dev/null >&5) 2>&5
3927   ac_status=$?
3928   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3929   (exit $ac_status); }
3930
3931 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3932 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3933 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3934   echo $ECHO_N "(cached) $ECHO_C" >&6
3935 else
3936   cat >conftest.$ac_ext <<_ACEOF
3937 /* confdefs.h.  */
3938 _ACEOF
3939 cat confdefs.h >>conftest.$ac_ext
3940 cat >>conftest.$ac_ext <<_ACEOF
3941 /* end confdefs.h.  */
3942
3943 int
3944 main ()
3945 {
3946 #ifndef __GNUC__
3947        choke me
3948 #endif
3949
3950   ;
3951   return 0;
3952 }
3953 _ACEOF
3954 rm -f conftest.$ac_objext
3955 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3956   (eval $ac_compile) 2>conftest.er1
3957   ac_status=$?
3958   grep -v '^ *+' conftest.er1 >conftest.err
3959   rm -f conftest.er1
3960   cat conftest.err >&5
3961   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3962   (exit $ac_status); } &&
3963          { ac_try='test -z "$ac_cxx_werror_flag"
3964                          || test ! -s conftest.err'
3965   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3966   (eval $ac_try) 2>&5
3967   ac_status=$?
3968   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3969   (exit $ac_status); }; } &&
3970          { ac_try='test -s conftest.$ac_objext'
3971   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3972   (eval $ac_try) 2>&5
3973   ac_status=$?
3974   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3975   (exit $ac_status); }; }; then
3976   ac_compiler_gnu=yes
3977 else
3978   echo "$as_me: failed program was:" >&5
3979 sed 's/^/| /' conftest.$ac_ext >&5
3980
3981 ac_compiler_gnu=no
3982 fi
3983 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3984 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3985
3986 fi
3987 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3988 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3989 GXX=`test $ac_compiler_gnu = yes && echo yes`
3990 ac_test_CXXFLAGS=${CXXFLAGS+set}
3991 ac_save_CXXFLAGS=$CXXFLAGS
3992 CXXFLAGS="-g"
3993 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3994 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3995 if test "${ac_cv_prog_cxx_g+set}" = set; then
3996   echo $ECHO_N "(cached) $ECHO_C" >&6
3997 else
3998   cat >conftest.$ac_ext <<_ACEOF
3999 /* confdefs.h.  */
4000 _ACEOF
4001 cat confdefs.h >>conftest.$ac_ext
4002 cat >>conftest.$ac_ext <<_ACEOF
4003 /* end confdefs.h.  */
4004
4005 int
4006 main ()
4007 {
4008
4009   ;
4010   return 0;
4011 }
4012 _ACEOF
4013 rm -f conftest.$ac_objext
4014 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4015   (eval $ac_compile) 2>conftest.er1
4016   ac_status=$?
4017   grep -v '^ *+' conftest.er1 >conftest.err
4018   rm -f conftest.er1
4019   cat conftest.err >&5
4020   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4021   (exit $ac_status); } &&
4022          { ac_try='test -z "$ac_cxx_werror_flag"
4023                          || test ! -s conftest.err'
4024   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4025   (eval $ac_try) 2>&5
4026   ac_status=$?
4027   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4028   (exit $ac_status); }; } &&
4029          { ac_try='test -s conftest.$ac_objext'
4030   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4031   (eval $ac_try) 2>&5
4032   ac_status=$?
4033   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4034   (exit $ac_status); }; }; then
4035   ac_cv_prog_cxx_g=yes
4036 else
4037   echo "$as_me: failed program was:" >&5
4038 sed 's/^/| /' conftest.$ac_ext >&5
4039
4040 ac_cv_prog_cxx_g=no
4041 fi
4042 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4043 fi
4044 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4045 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4046 if test "$ac_test_CXXFLAGS" = set; then
4047   CXXFLAGS=$ac_save_CXXFLAGS
4048 elif test $ac_cv_prog_cxx_g = yes; then
4049   if test "$GXX" = yes; then
4050     CXXFLAGS="-g -O2"
4051   else
4052     CXXFLAGS="-g"
4053   fi
4054 else
4055   if test "$GXX" = yes; then
4056     CXXFLAGS="-O2"
4057   else
4058     CXXFLAGS=
4059   fi
4060 fi
4061 for ac_declaration in \
4062    '' \
4063    'extern "C" void std::exit (int) throw (); using std::exit;' \
4064    'extern "C" void std::exit (int); using std::exit;' \
4065    'extern "C" void exit (int) throw ();' \
4066    'extern "C" void exit (int);' \
4067    'void exit (int);'
4068 do
4069   cat >conftest.$ac_ext <<_ACEOF
4070 /* confdefs.h.  */
4071 _ACEOF
4072 cat confdefs.h >>conftest.$ac_ext
4073 cat >>conftest.$ac_ext <<_ACEOF
4074 /* end confdefs.h.  */
4075 $ac_declaration
4076 #include <stdlib.h>
4077 int
4078 main ()
4079 {
4080 exit (42);
4081   ;
4082   return 0;
4083 }
4084 _ACEOF
4085 rm -f conftest.$ac_objext
4086 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4087   (eval $ac_compile) 2>conftest.er1
4088   ac_status=$?
4089   grep -v '^ *+' conftest.er1 >conftest.err
4090   rm -f conftest.er1
4091   cat conftest.err >&5
4092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4093   (exit $ac_status); } &&
4094          { ac_try='test -z "$ac_cxx_werror_flag"
4095                          || test ! -s conftest.err'
4096   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4097   (eval $ac_try) 2>&5
4098   ac_status=$?
4099   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4100   (exit $ac_status); }; } &&
4101          { ac_try='test -s conftest.$ac_objext'
4102   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4103   (eval $ac_try) 2>&5
4104   ac_status=$?
4105   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4106   (exit $ac_status); }; }; then
4107   :
4108 else
4109   echo "$as_me: failed program was:" >&5
4110 sed 's/^/| /' conftest.$ac_ext >&5
4111
4112 continue
4113 fi
4114 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4115   cat >conftest.$ac_ext <<_ACEOF
4116 /* confdefs.h.  */
4117 _ACEOF
4118 cat confdefs.h >>conftest.$ac_ext
4119 cat >>conftest.$ac_ext <<_ACEOF
4120 /* end confdefs.h.  */
4121 $ac_declaration
4122 int
4123 main ()
4124 {
4125 exit (42);
4126   ;
4127   return 0;
4128 }
4129 _ACEOF
4130 rm -f conftest.$ac_objext
4131 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4132   (eval $ac_compile) 2>conftest.er1
4133   ac_status=$?
4134   grep -v '^ *+' conftest.er1 >conftest.err
4135   rm -f conftest.er1
4136   cat conftest.err >&5
4137   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4138   (exit $ac_status); } &&
4139          { ac_try='test -z "$ac_cxx_werror_flag"
4140                          || test ! -s conftest.err'
4141   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4142   (eval $ac_try) 2>&5
4143   ac_status=$?
4144   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4145   (exit $ac_status); }; } &&
4146          { ac_try='test -s conftest.$ac_objext'
4147   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4148   (eval $ac_try) 2>&5
4149   ac_status=$?
4150   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4151   (exit $ac_status); }; }; then
4152   break
4153 else
4154   echo "$as_me: failed program was:" >&5
4155 sed 's/^/| /' conftest.$ac_ext >&5
4156
4157 fi
4158 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4159 done
4160 rm -f conftest*
4161 if test -n "$ac_declaration"; then
4162   echo '#ifdef __cplusplus' >>confdefs.h
4163   echo $ac_declaration      >>confdefs.h
4164   echo '#endif'             >>confdefs.h
4165 fi
4166
4167 ac_ext=c
4168 ac_cpp='$CPP $CPPFLAGS'
4169 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4170 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4171 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4172
4173
4174 # We must set the default linker to the linker used by gcc for the correct
4175 # operation of libtool.  If LD is not defined and we are using gcc, try to
4176 # set the LD default to the ld used by gcc.
4177 if test -z "$LD"; then
4178   if test "$GCC" = yes; then
4179     case $build in
4180     *-*-mingw*)
4181       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4182     *)
4183       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4184     esac
4185     case $gcc_prog_ld in
4186     # Accept absolute paths.
4187     [\\/]* | [A-Za-z]:[\\/]*)
4188       LD="$gcc_prog_ld" ;;
4189     esac
4190   fi
4191 fi
4192
4193
4194
4195
4196 if test -n "$ac_tool_prefix"; then
4197   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4198 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4199 echo "$as_me:$LINENO: checking for $ac_word" >&5
4200 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4201 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4202   echo $ECHO_N "(cached) $ECHO_C" >&6
4203 else
4204   if test -n "$GNATBIND"; then
4205   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4206 else
4207 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4208 for as_dir in $PATH
4209 do
4210   IFS=$as_save_IFS
4211   test -z "$as_dir" && as_dir=.
4212   for ac_exec_ext in '' $ac_executable_extensions; do
4213   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4214     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4215     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4216     break 2
4217   fi
4218 done
4219 done
4220
4221 fi
4222 fi
4223 GNATBIND=$ac_cv_prog_GNATBIND
4224 if test -n "$GNATBIND"; then
4225   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4226 echo "${ECHO_T}$GNATBIND" >&6
4227 else
4228   echo "$as_me:$LINENO: result: no" >&5
4229 echo "${ECHO_T}no" >&6
4230 fi
4231
4232 fi
4233 if test -z "$ac_cv_prog_GNATBIND"; then
4234   ac_ct_GNATBIND=$GNATBIND
4235   # Extract the first word of "gnatbind", so it can be a program name with args.
4236 set dummy gnatbind; ac_word=$2
4237 echo "$as_me:$LINENO: checking for $ac_word" >&5
4238 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4239 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4240   echo $ECHO_N "(cached) $ECHO_C" >&6
4241 else
4242   if test -n "$ac_ct_GNATBIND"; then
4243   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4244 else
4245 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4246 for as_dir in $PATH
4247 do
4248   IFS=$as_save_IFS
4249   test -z "$as_dir" && as_dir=.
4250   for ac_exec_ext in '' $ac_executable_extensions; do
4251   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4252     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4253     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4254     break 2
4255   fi
4256 done
4257 done
4258
4259   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4260 fi
4261 fi
4262 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4263 if test -n "$ac_ct_GNATBIND"; then
4264   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4265 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4266 else
4267   echo "$as_me:$LINENO: result: no" >&5
4268 echo "${ECHO_T}no" >&6
4269 fi
4270
4271   GNATBIND=$ac_ct_GNATBIND
4272 else
4273   GNATBIND="$ac_cv_prog_GNATBIND"
4274 fi
4275
4276 if test -n "$ac_tool_prefix"; then
4277   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4278 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4279 echo "$as_me:$LINENO: checking for $ac_word" >&5
4280 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4281 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4282   echo $ECHO_N "(cached) $ECHO_C" >&6
4283 else
4284   if test -n "$GNATMAKE"; then
4285   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4286 else
4287 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4288 for as_dir in $PATH
4289 do
4290   IFS=$as_save_IFS
4291   test -z "$as_dir" && as_dir=.
4292   for ac_exec_ext in '' $ac_executable_extensions; do
4293   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4294     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4295     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4296     break 2
4297   fi
4298 done
4299 done
4300
4301 fi
4302 fi
4303 GNATMAKE=$ac_cv_prog_GNATMAKE
4304 if test -n "$GNATMAKE"; then
4305   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4306 echo "${ECHO_T}$GNATMAKE" >&6
4307 else
4308   echo "$as_me:$LINENO: result: no" >&5
4309 echo "${ECHO_T}no" >&6
4310 fi
4311
4312 fi
4313 if test -z "$ac_cv_prog_GNATMAKE"; then
4314   ac_ct_GNATMAKE=$GNATMAKE
4315   # Extract the first word of "gnatmake", so it can be a program name with args.
4316 set dummy gnatmake; ac_word=$2
4317 echo "$as_me:$LINENO: checking for $ac_word" >&5
4318 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4319 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4320   echo $ECHO_N "(cached) $ECHO_C" >&6
4321 else
4322   if test -n "$ac_ct_GNATMAKE"; then
4323   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4324 else
4325 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4326 for as_dir in $PATH
4327 do
4328   IFS=$as_save_IFS
4329   test -z "$as_dir" && as_dir=.
4330   for ac_exec_ext in '' $ac_executable_extensions; do
4331   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4332     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4333     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4334     break 2
4335   fi
4336 done
4337 done
4338
4339   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4340 fi
4341 fi
4342 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4343 if test -n "$ac_ct_GNATMAKE"; then
4344   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4345 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4346 else
4347   echo "$as_me:$LINENO: result: no" >&5
4348 echo "${ECHO_T}no" >&6
4349 fi
4350
4351   GNATMAKE=$ac_ct_GNATMAKE
4352 else
4353   GNATMAKE="$ac_cv_prog_GNATMAKE"
4354 fi
4355
4356 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4357 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4358 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4359   echo $ECHO_N "(cached) $ECHO_C" >&6
4360 else
4361   cat >conftest.adb <<EOF
4362 procedure conftest is begin null; end conftest;
4363 EOF
4364 acx_cv_cc_gcc_supports_ada=no
4365 # There is a bug in old released versions of GCC which causes the
4366 # driver to exit successfully when the appropriate language module
4367 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4368 # Therefore we must check for the error message as well as an
4369 # unsuccessful exit.
4370 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4371 # given a .adb file, but produce no object file.  So we must check
4372 # if an object file was really produced to guard against this.
4373 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4374 if test x"$errors" = x && test -f conftest.$ac_objext; then
4375   acx_cv_cc_gcc_supports_ada=yes
4376 fi
4377 rm -f conftest.*
4378 fi
4379 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4380 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4381
4382 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4383   have_gnat=yes
4384 else
4385   have_gnat=no
4386 fi
4387
4388 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4389 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4390 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4391   echo $ECHO_N "(cached) $ECHO_C" >&6
4392 else
4393    echo abfoo >t1
4394   echo cdfoo >t2
4395   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4396   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4397     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4398       :
4399     else
4400       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4401     fi
4402   fi
4403   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4404     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4405       :
4406     else
4407       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4408     fi
4409   fi
4410   rm t1 t2
4411
4412 fi
4413 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4414 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4415 do_compare="$gcc_cv_prog_cmp_skip"
4416
4417
4418
4419 # Check for GMP and MPFR
4420 gmplibs="-lmpfr -lgmp"
4421 gmpinc=
4422 have_gmp=no
4423
4424 # Specify a location for mpfr
4425 # check for this first so it ends up on the link line before gmp.
4426
4427 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4428 if test "${with_mpfr_dir+set}" = set; then
4429   withval="$with_mpfr_dir"
4430   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4431 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4432 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4433 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4434    { (exit 1); exit 1; }; }
4435 fi;
4436
4437
4438 # Check whether --with-mpfr or --without-mpfr was given.
4439 if test "${with_mpfr+set}" = set; then
4440   withval="$with_mpfr"
4441
4442 fi;
4443
4444 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4445 if test "${with_mpfr_include+set}" = set; then
4446   withval="$with_mpfr_include"
4447
4448 fi;
4449
4450 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4451 if test "${with_mpfr_lib+set}" = set; then
4452   withval="$with_mpfr_lib"
4453
4454 fi;
4455
4456 if test "x$with_mpfr" != x; then
4457   gmplibs="-L$with_mpfr/lib $gmplibs"
4458   gmpinc="-I$with_mpfr/include"
4459 fi
4460 if test "x$with_mpfr_include" != x; then
4461   gmpinc="-I$with_mpfr_include"
4462 fi
4463 if test "x$with_mpfr_lib" != x; then
4464   gmplibs="-L$with_mpfr_lib $gmplibs"
4465 fi
4466 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4467   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4468   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4469   # Do not test the mpfr version.  Assume that it is sufficient, since
4470   # it is in the source tree, and the library has not been built yet
4471   # but it would be included on the link line in the version check below
4472   # hence making the test fail.
4473   have_gmp=yes
4474 fi
4475
4476 # Specify a location for gmp
4477
4478 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4479 if test "${with_gmp_dir+set}" = set; then
4480   withval="$with_gmp_dir"
4481   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4482 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4483 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4484 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4485    { (exit 1); exit 1; }; }
4486 fi;
4487
4488
4489 # Check whether --with-gmp or --without-gmp was given.
4490 if test "${with_gmp+set}" = set; then
4491   withval="$with_gmp"
4492
4493 fi;
4494
4495 # Check whether --with-gmp_include or --without-gmp_include was given.
4496 if test "${with_gmp_include+set}" = set; then
4497   withval="$with_gmp_include"
4498
4499 fi;
4500
4501 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4502 if test "${with_gmp_lib+set}" = set; then
4503   withval="$with_gmp_lib"
4504
4505 fi;
4506
4507
4508 if test "x$with_gmp" != x; then
4509   gmplibs="-L$with_gmp/lib $gmplibs"
4510   gmpinc="-I$with_gmp/include $gmpinc"
4511 fi
4512 if test "x$with_gmp_include" != x; then
4513   gmpinc="-I$with_gmp_include $gmpinc"
4514 fi
4515 if test "x$with_gmp_lib" != x; then
4516   gmplibs="-L$with_gmp_lib $gmplibs"
4517 fi
4518 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4519   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4520   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4521   # Do not test the gmp version.  Assume that it is sufficient, since
4522   # it is in the source tree, and the library has not been built yet
4523   # but it would be included on the link line in the version check below
4524   # hence making the test fail.
4525   have_gmp=yes
4526 fi
4527
4528 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4529   have_gmp=yes
4530   saved_CFLAGS="$CFLAGS"
4531   CFLAGS="$CFLAGS $gmpinc"
4532   # Check GMP actually works
4533   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4534 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4535
4536 cat >conftest.$ac_ext <<_ACEOF
4537 /* confdefs.h.  */
4538 _ACEOF
4539 cat confdefs.h >>conftest.$ac_ext
4540 cat >>conftest.$ac_ext <<_ACEOF
4541 /* end confdefs.h.  */
4542 #include "gmp.h"
4543 int
4544 main ()
4545 {
4546
4547   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4548   choke me
4549   #endif
4550
4551   ;
4552   return 0;
4553 }
4554 _ACEOF
4555 rm -f conftest.$ac_objext
4556 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4557   (eval $ac_compile) 2>conftest.er1
4558   ac_status=$?
4559   grep -v '^ *+' conftest.er1 >conftest.err
4560   rm -f conftest.er1
4561   cat conftest.err >&5
4562   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4563   (exit $ac_status); } &&
4564          { ac_try='test -z "$ac_c_werror_flag"
4565                          || test ! -s conftest.err'
4566   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4567   (eval $ac_try) 2>&5
4568   ac_status=$?
4569   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4570   (exit $ac_status); }; } &&
4571          { ac_try='test -s conftest.$ac_objext'
4572   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4573   (eval $ac_try) 2>&5
4574   ac_status=$?
4575   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4576   (exit $ac_status); }; }; then
4577   echo "$as_me:$LINENO: result: yes" >&5
4578 echo "${ECHO_T}yes" >&6
4579 else
4580   echo "$as_me: failed program was:" >&5
4581 sed 's/^/| /' conftest.$ac_ext >&5
4582
4583 echo "$as_me:$LINENO: result: no" >&5
4584 echo "${ECHO_T}no" >&6; have_gmp=no
4585 fi
4586 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4587
4588   if test x"$have_gmp" = xyes; then
4589     saved_LIBS="$LIBS"
4590     LIBS="$LIBS $gmplibs"
4591         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4592 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4593     cat >conftest.$ac_ext <<_ACEOF
4594 /* confdefs.h.  */
4595 _ACEOF
4596 cat confdefs.h >>conftest.$ac_ext
4597 cat >>conftest.$ac_ext <<_ACEOF
4598 /* end confdefs.h.  */
4599 #include <gmp.h>
4600     #include <mpfr.h>
4601 int
4602 main ()
4603 {
4604
4605     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4606     choke me
4607     #endif
4608     mpfr_t n;
4609     mpfr_t x;
4610     int t;
4611     mpfr_init (n);
4612     mpfr_init (x);
4613     mpfr_atan2 (n, n, x, GMP_RNDN);
4614     mpfr_erfc (n, x, GMP_RNDN);
4615     mpfr_subnormalize (x, t, GMP_RNDN);
4616
4617   ;
4618   return 0;
4619 }
4620 _ACEOF
4621 rm -f conftest.$ac_objext conftest$ac_exeext
4622 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4623   (eval $ac_link) 2>conftest.er1
4624   ac_status=$?
4625   grep -v '^ *+' conftest.er1 >conftest.err
4626   rm -f conftest.er1
4627   cat conftest.err >&5
4628   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4629   (exit $ac_status); } &&
4630          { ac_try='test -z "$ac_c_werror_flag"
4631                          || test ! -s conftest.err'
4632   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4633   (eval $ac_try) 2>&5
4634   ac_status=$?
4635   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4636   (exit $ac_status); }; } &&
4637          { ac_try='test -s conftest$ac_exeext'
4638   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4639   (eval $ac_try) 2>&5
4640   ac_status=$?
4641   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4642   (exit $ac_status); }; }; then
4643   cat >conftest.$ac_ext <<_ACEOF
4644 /* confdefs.h.  */
4645 _ACEOF
4646 cat confdefs.h >>conftest.$ac_ext
4647 cat >>conftest.$ac_ext <<_ACEOF
4648 /* end confdefs.h.  */
4649 #include <gmp.h>
4650     #include <mpfr.h>
4651 int
4652 main ()
4653 {
4654
4655     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4656     choke me
4657     #endif
4658     mpfr_t n; mpfr_init(n);
4659
4660   ;
4661   return 0;
4662 }
4663 _ACEOF
4664 rm -f conftest.$ac_objext conftest$ac_exeext
4665 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4666   (eval $ac_link) 2>conftest.er1
4667   ac_status=$?
4668   grep -v '^ *+' conftest.er1 >conftest.err
4669   rm -f conftest.er1
4670   cat conftest.err >&5
4671   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4672   (exit $ac_status); } &&
4673          { ac_try='test -z "$ac_c_werror_flag"
4674                          || test ! -s conftest.err'
4675   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4676   (eval $ac_try) 2>&5
4677   ac_status=$?
4678   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4679   (exit $ac_status); }; } &&
4680          { ac_try='test -s conftest$ac_exeext'
4681   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4682   (eval $ac_try) 2>&5
4683   ac_status=$?
4684   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4685   (exit $ac_status); }; }; then
4686   echo "$as_me:$LINENO: result: yes" >&5
4687 echo "${ECHO_T}yes" >&6
4688 else
4689   echo "$as_me: failed program was:" >&5
4690 sed 's/^/| /' conftest.$ac_ext >&5
4691
4692 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4693 echo "${ECHO_T}buggy but acceptable" >&6
4694 fi
4695 rm -f conftest.err conftest.$ac_objext \
4696       conftest$ac_exeext conftest.$ac_ext
4697 else
4698   echo "$as_me: failed program was:" >&5
4699 sed 's/^/| /' conftest.$ac_ext >&5
4700
4701 echo "$as_me:$LINENO: result: no" >&5
4702 echo "${ECHO_T}no" >&6; have_gmp=no
4703 fi
4704 rm -f conftest.err conftest.$ac_objext \
4705       conftest$ac_exeext conftest.$ac_ext
4706       LIBS="$saved_LIBS"
4707   fi
4708   CFLAGS="$saved_CFLAGS"
4709
4710   if test x$have_gmp != xyes; then
4711     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4712 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4713 Copies of these libraries' source code can be found at their respective
4714 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4715 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4716 If you obtained GMP and/or MPFR from a vendor distribution package, make
4717 sure that you have installed both the libraries and the header files.
4718 They may be located in separate packages." >&5
4719 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4720 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4721 Copies of these libraries' source code can be found at their respective
4722 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4723 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4724 If you obtained GMP and/or MPFR from a vendor distribution package, make
4725 sure that you have installed both the libraries and the header files.
4726 They may be located in separate packages." >&2;}
4727    { (exit 1); exit 1; }; }
4728   fi
4729 fi
4730
4731 # Flags needed for both GMP and/or MPFR
4732
4733
4734
4735 # By default, C is the only stage 1 language.
4736 stage1_languages=,c,
4737
4738 # Figure out what language subdirectories are present.
4739 # Look if the user specified --enable-languages="..."; if not, use
4740 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4741 # go away some day.
4742 # NB:  embedded tabs in this IF block -- do not untabify
4743 if test -d ${srcdir}/gcc; then
4744   if test x"${enable_languages+set}" != xset; then
4745     if test x"${LANGUAGES+set}" = xset; then
4746       enable_languages="${LANGUAGES}"
4747         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4748     else
4749       enable_languages=all
4750     fi
4751   else
4752     if test x"${enable_languages}" = x ||
4753        test x"${enable_languages}" = xyes;
4754        then
4755       echo configure.in: --enable-languages needs at least one language argument 1>&2
4756       exit 1
4757     fi
4758   fi
4759   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4760
4761   # 'f95' is the old name for the 'fortran' language. We issue a warning
4762   # and make the substitution.
4763   case ,${enable_languages}, in
4764     *,f95,*)
4765       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4766       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4767       ;;
4768   esac
4769
4770   # First scan to see if an enabled language requires some other language.
4771   # We assume that a given config-lang.in will list all the language
4772   # front ends it requires, even if some are required indirectly.
4773   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4774     case ${lang_frag} in
4775       ..) ;;
4776       # The odd quoting in the next line works around
4777       # an apparent bug in bash 1.12 on linux.
4778       ${srcdir}/gcc/[*]/config-lang.in) ;;
4779       *)
4780         # From the config-lang.in, get $language, $lang_requires
4781         language=
4782         lang_requires=
4783         . ${lang_frag}
4784         for other in ${lang_requires} ; do
4785           case ,${enable_languages}, in
4786             *,$other,*) ;;
4787             *,all,*) ;;
4788             *,$language,*)
4789               echo " \`$other' language required by \`$language'; enabling" 1>&2
4790               enable_languages="${enable_languages},${other}"
4791               ;;
4792           esac
4793         done
4794         ;;
4795     esac
4796   done
4797
4798   new_enable_languages=,c,
4799   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4800   potential_languages=,c,
4801
4802   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4803     case ${lang_frag} in
4804       ..) ;;
4805       # The odd quoting in the next line works around
4806       # an apparent bug in bash 1.12 on linux.
4807       ${srcdir}/gcc/[*]/config-lang.in) ;;
4808       *)
4809         # From the config-lang.in, get $language, $target_libs,
4810         # $lang_dirs, $boot_language, and $build_by_default
4811         language=
4812         target_libs=
4813         lang_dirs=
4814         subdir_requires=
4815         boot_language=no
4816         build_by_default=yes
4817         . ${lang_frag}
4818         if test x${language} = x; then
4819           echo "${lang_frag} doesn't set \$language." 1>&2
4820           exit 1
4821         fi
4822
4823         case ,${enable_languages}, in
4824           *,${language},*)
4825             # Language was explicitly selected; include it.
4826             add_this_lang=yes
4827             ;;
4828           *,all,*)
4829             # 'all' was selected, select it if it is a default language
4830             add_this_lang=${build_by_default}
4831             ;;
4832           *)
4833             add_this_lang=no
4834             ;;
4835         esac
4836
4837         # Disable languages that need other directories if these aren't available.
4838         for i in $subdir_requires; do
4839           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4840           case ,${enable_languages}, in
4841             *,${language},*)
4842               # Specifically requested language; tell them.
4843               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4844 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4845    { (exit 1); exit 1; }; }
4846               ;;
4847             *)
4848               # Silently disable.
4849               add_this_lang=unsupported
4850               ;;
4851           esac
4852         done
4853
4854         # Disable Ada if no preexisting GNAT is available.
4855         case ,${enable_languages},:${language}:${have_gnat} in
4856           *,${language},*:ada:no)
4857             # Specifically requested language; tell them.
4858             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4859 echo "$as_me: error: GNAT is required to build $language" >&2;}
4860    { (exit 1); exit 1; }; }
4861             ;;
4862           *:ada:no)
4863             # Silently disable.
4864             add_this_lang=unsupported
4865             ;;
4866         esac
4867
4868         # Disable a language that is unsupported by the target.
4869         case " $unsupported_languages " in
4870           *" $language "*)
4871             add_this_lang=unsupported
4872             ;;
4873         esac
4874
4875         case $add_this_lang in
4876           unsupported)
4877             # Remove language-dependent dirs.
4878             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4879             ;;
4880           no)
4881             # Remove language-dependent dirs; still show language as supported.
4882             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4883             potential_languages="${potential_languages}${language},"
4884             ;;
4885           yes)
4886             new_enable_languages="${new_enable_languages}${language},"
4887             potential_languages="${potential_languages}${language},"
4888             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4889             case ${boot_language} in
4890               yes)
4891                 # Add to (comma-separated) list of stage 1 languages.
4892                 stage1_languages="${stage1_languages}${language},"
4893                 ;;
4894             esac
4895             ;;
4896         esac
4897         ;;
4898     esac
4899   done
4900
4901   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4902 if test "${enable_stage1_languages+set}" = set; then
4903   enableval="$enable_stage1_languages"
4904   case ,${enable_stage1_languages}, in
4905     ,no,|,,)
4906       # Set it to something that will have no effect in the loop below
4907       enable_stage1_languages=c ;;
4908     ,yes,)
4909       enable_stage1_languages=`echo $new_enable_languages | \
4910         sed -e "s/^,//" -e "s/,$//" ` ;;
4911     *,all,*)
4912       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4913         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4914   esac
4915
4916   # Add "good" languages from enable_stage1_languages to stage1_languages,
4917   # while "bad" languages go in missing_languages.  Leave no duplicates.
4918   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4919     case $potential_languages in
4920       *,$i,*)
4921         case $stage1_languages in
4922           *,$i,*) ;;
4923           *) stage1_languages="$stage1_languages$i," ;;
4924         esac ;;
4925       *)
4926         case $missing_languages in
4927           *,$i,*) ;;
4928           *) missing_languages="$missing_languages$i," ;;
4929         esac ;;
4930      esac
4931   done
4932 fi;
4933
4934   # Remove leading/trailing commas that were added for simplicity
4935   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4936   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4937   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4938   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4939
4940   if test "x$missing_languages" != x; then
4941     { { echo "$as_me:$LINENO: error:
4942 The following requested languages could not be built: ${missing_languages}
4943 Supported languages are: ${potential_languages}" >&5
4944 echo "$as_me: error:
4945 The following requested languages could not be built: ${missing_languages}
4946 Supported languages are: ${potential_languages}" >&2;}
4947    { (exit 1); exit 1; }; }
4948   fi
4949   if test "x$new_enable_languages" != "x$enable_languages"; then
4950     echo The following languages will be built: ${new_enable_languages}
4951     enable_languages="$new_enable_languages"
4952   fi
4953
4954
4955   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4956 fi
4957
4958 # Handle --disable-<component> generically.
4959 for dir in $configdirs $build_configdirs $target_configdirs ; do
4960   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4961   varname=`echo $dirname | sed -e s/+/_/g`
4962   if eval test x\${enable_${varname}} "=" xno ; then
4963     noconfigdirs="$noconfigdirs $dir"
4964   fi
4965 done
4966
4967 # Check for Boehm's garbage collector
4968 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4969 if test "${enable_objc_gc+set}" = set; then
4970   enableval="$enable_objc_gc"
4971   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4972   *,objc,*:*:yes:*target-boehm-gc*)
4973     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4974 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4975    { (exit 1); exit 1; }; }
4976     ;;
4977 esac
4978 fi;
4979
4980 # Make sure we only build Boehm's garbage collector if required.
4981 case ,${enable_languages},:${enable_objc_gc} in
4982   *,objc,*:yes)
4983     # Keep target-boehm-gc if requested for Objective-C.
4984     ;;
4985   *)
4986     # Otherwise remove target-boehm-gc depending on target-libjava.
4987     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4988       noconfigdirs="$noconfigdirs target-boehm-gc"
4989     fi
4990     ;;
4991 esac
4992
4993 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4994 # $build_configdirs and $target_configdirs.
4995 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4996
4997 notsupp=""
4998 for dir in . $skipdirs $noconfigdirs ; do
4999   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5000   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5001     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5002     if test -r $srcdir/$dirname/configure ; then
5003       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5004         true
5005       else
5006         notsupp="$notsupp $dir"
5007       fi
5008     fi
5009   fi
5010   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5011     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5012     if test -r $srcdir/$dirname/configure ; then
5013       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5014         true
5015       else
5016         notsupp="$notsupp $dir"
5017       fi
5018     fi
5019   fi
5020   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5021     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5022     if test -r $srcdir/$dirname/configure ; then
5023       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5024         true
5025       else
5026         notsupp="$notsupp $dir"
5027       fi
5028     fi
5029   fi
5030 done
5031
5032 # Sometimes the tools are distributed with libiberty but with no other
5033 # libraries.  In that case, we don't want to build target-libiberty.
5034 # Don't let libgcc imply libiberty either.
5035 if test -n "${target_configdirs}" ; then
5036   libgcc=
5037   others=
5038   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5039     if test "$i" = "libgcc"; then
5040       libgcc=target-libgcc
5041     elif test "$i" != "libiberty" ; then
5042       if test -r $srcdir/$i/configure ; then
5043         others=yes;
5044         break;
5045       fi
5046     fi
5047   done
5048   if test -z "${others}" ; then
5049     target_configdirs=$libgcc
5050   fi
5051 fi
5052
5053 # Quietly strip out all directories which aren't configurable in this tree.
5054 # This relies on all configurable subdirectories being autoconfiscated, which
5055 # is now the case.
5056 build_configdirs_all="$build_configdirs"
5057 build_configdirs=
5058 for i in ${build_configdirs_all} ; do
5059   j=`echo $i | sed -e s/build-//g`
5060   if test -f ${srcdir}/$j/configure ; then
5061     build_configdirs="${build_configdirs} $i"
5062   fi
5063 done
5064
5065 configdirs_all="$configdirs"
5066 configdirs=
5067 for i in ${configdirs_all} ; do
5068   if test -f ${srcdir}/$i/configure ; then
5069     configdirs="${configdirs} $i"
5070   fi
5071 done
5072
5073 target_configdirs_all="$target_configdirs"
5074 target_configdirs=
5075 for i in ${target_configdirs_all} ; do
5076   j=`echo $i | sed -e s/target-//g`
5077   if test -f ${srcdir}/$j/configure ; then
5078     target_configdirs="${target_configdirs} $i"
5079   fi
5080 done
5081
5082 # Produce a warning message for the subdirs we can't configure.
5083 # This isn't especially interesting in the Cygnus tree, but in the individual
5084 # FSF releases, it's important to let people know when their machine isn't
5085 # supported by the one or two programs in a package.
5086
5087 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5088   # If $appdirs is non-empty, at least one of those directories must still
5089   # be configured, or we error out.  (E.g., if the gas release supports a
5090   # specified target in some subdirs but not the gas subdir, we shouldn't
5091   # pretend that all is well.)
5092   if test -n "$appdirs" ; then
5093     for dir in $appdirs ; do
5094       if test -r $dir/Makefile.in ; then
5095         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5096           appdirs=""
5097           break
5098         fi
5099         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5100           appdirs=""
5101           break
5102         fi
5103       fi
5104     done
5105     if test -n "$appdirs" ; then
5106       echo "*** This configuration is not supported by this package." 1>&2
5107       exit 1
5108     fi
5109   fi
5110   # Okay, some application will build, or we don't care to check.  Still
5111   # notify of subdirs not getting built.
5112   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5113   echo "    ${notsupp}" 1>&2
5114   echo "    (Any other directories should still work fine.)" 1>&2
5115 fi
5116
5117 case "$host" in
5118   *msdosdjgpp*)
5119     enable_gdbtk=no ;;
5120 esac
5121
5122 # To find our prefix, in gcc_cv_tool_prefix.
5123
5124 # The user is always right.
5125 if test "${PATH_SEPARATOR+set}" != set; then
5126   echo "#! /bin/sh" >conf$$.sh
5127   echo  "exit 0"   >>conf$$.sh
5128   chmod +x conf$$.sh
5129   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5130     PATH_SEPARATOR=';'
5131   else
5132     PATH_SEPARATOR=:
5133   fi
5134   rm -f conf$$.sh
5135 fi
5136
5137
5138
5139 if test "x$exec_prefix" = xNONE; then
5140         if test "x$prefix" = xNONE; then
5141                 gcc_cv_tool_prefix=$ac_default_prefix
5142         else
5143                 gcc_cv_tool_prefix=$prefix
5144         fi
5145 else
5146         gcc_cv_tool_prefix=$exec_prefix
5147 fi
5148
5149 # If there is no compiler in the tree, use the PATH only.  In any
5150 # case, if there is no compiler in the tree nobody should use
5151 # AS_FOR_TARGET and LD_FOR_TARGET.
5152 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5153     gcc_version=`cat $srcdir/gcc/BASE-VER`
5154     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5155     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5156     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5157     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5158     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5159     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5160 else
5161     gcc_cv_tool_dirs=
5162 fi
5163
5164 if test x$build = x$target && test -n "$md_exec_prefix"; then
5165         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5166 fi
5167
5168
5169
5170 copy_dirs=
5171
5172
5173 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5174 if test "${with_build_sysroot+set}" = set; then
5175   withval="$with_build_sysroot"
5176   if test x"$withval" != x ; then
5177      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5178    fi
5179 else
5180   SYSROOT_CFLAGS_FOR_TARGET=
5181 fi;
5182
5183
5184
5185 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5186 if test "${with_debug_prefix_map+set}" = set; then
5187   withval="$with_debug_prefix_map"
5188   if test x"$withval" != x; then
5189      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5190      for debug_map in $withval; do
5191        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5192      done
5193    fi
5194 else
5195   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5196 fi;
5197
5198
5199 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5200 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5201 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5202 # We want to ensure that TARGET libraries (which we know are built with
5203 # gcc) are built with "-O2 -g", so include those options when setting
5204 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5205 if test "x$CFLAGS_FOR_TARGET" = x; then
5206   CFLAGS_FOR_TARGET=$CFLAGS
5207   case " $CFLAGS " in
5208     *" -O2 "*) ;;
5209     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5210   esac
5211   case " $CFLAGS " in
5212     *" -g "* | *" -g3 "*) ;;
5213     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5214   esac
5215 fi
5216
5217
5218 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5219   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5220   case " $CXXFLAGS " in
5221     *" -O2 "*) ;;
5222     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5223   esac
5224   case " $CXXFLAGS " in
5225     *" -g "* | *" -g3 "*) ;;
5226     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5227   esac
5228 fi
5229
5230
5231 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5232 # the named directory are copied to $(tooldir)/sys-include.
5233 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5234   if test x${is_cross_compiler} = xno ; then
5235     echo 1>&2 '***' --with-headers is only supported when cross compiling
5236     exit 1
5237   fi
5238   if test x"${with_headers}" != xyes ; then
5239     x=${gcc_cv_tool_prefix}
5240     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5241   fi
5242 fi
5243
5244 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5245 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5246 # are permitted.
5247 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5248   if test x${is_cross_compiler} = xno ; then
5249     echo 1>&2 '***' --with-libs is only supported when cross compiling
5250     exit 1
5251   fi
5252   if test x"${with_libs}" != xyes ; then
5253     # Copy the libraries in reverse order, so that files in the first named
5254     # library override files in subsequent libraries.
5255     x=${gcc_cv_tool_prefix}
5256     for l in ${with_libs}; do
5257       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5258     done
5259   fi
5260 fi
5261
5262 # Set with_gnu_as and with_gnu_ld as appropriate.
5263 #
5264 # This is done by determining whether or not the appropriate directory
5265 # is available, and by checking whether or not specific configurations
5266 # have requested that this magic not happen.
5267 #
5268 # The command line options always override the explicit settings in
5269 # configure.in, and the settings in configure.in override this magic.
5270 #
5271 # If the default for a toolchain is to use GNU as and ld, and you don't
5272 # want to do that, then you should use the --without-gnu-as and
5273 # --without-gnu-ld options for the configure script.
5274
5275 if test x${use_gnu_as} = x &&
5276    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5277   with_gnu_as=yes
5278   extra_host_args="$extra_host_args --with-gnu-as"
5279 fi
5280
5281 if test x${use_gnu_ld} = x &&
5282    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5283   with_gnu_ld=yes
5284   extra_host_args="$extra_host_args --with-gnu-ld"
5285 fi
5286
5287 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5288 # can detect this case.
5289
5290 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5291   with_newlib=yes
5292   extra_host_args="$extra_host_args --with-newlib"
5293 fi
5294
5295 # Handle ${copy_dirs}
5296 set fnord ${copy_dirs}
5297 shift
5298 while test $# != 0 ; do
5299   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5300     :
5301   else
5302     echo Copying $1 to $2
5303
5304     # Use the install script to create the directory and all required
5305     # parent directories.
5306     if test -d $2 ; then
5307       :
5308     else
5309       echo >config.temp
5310       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5311     fi
5312
5313     # Copy the directory, assuming we have tar.
5314     # FIXME: Should we use B in the second tar?  Not all systems support it.
5315     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5316
5317     # It is the responsibility of the user to correctly adjust all
5318     # symlinks.  If somebody can figure out how to handle them correctly
5319     # here, feel free to add the code.
5320
5321     echo $1 > $2/COPIED
5322   fi
5323   shift; shift
5324 done
5325
5326 # Determine a target-dependent exec_prefix that the installed
5327 # gcc will search in.  Keep this list sorted by triplet, with
5328 # the *-*-osname triplets last.
5329 md_exec_prefix=
5330 case "${target}" in
5331   alpha*-*-*vms*)
5332     md_exec_prefix=/gnu/lib/gcc-lib
5333     ;;
5334   i[34567]86-pc-msdosdjgpp*)
5335     md_exec_prefix=/dev/env/DJDIR/bin
5336     ;;
5337   i[34567]86-*-sco3.2v5*)
5338     if test $with_gnu_as = yes; then
5339       md_exec_prefix=/usr/gnu/bin
5340     else
5341       md_exec_prefix=/usr/ccs/bin/elf
5342     fi
5343     ;;
5344
5345   mn10300-*-* | \
5346   powerpc-*-chorusos* | \
5347   powerpc*-*-eabi* | \
5348   powerpc*-*-sysv* | \
5349   powerpc*-*-kaos* | \
5350   s390x-ibm-tpf*)
5351     md_exec_prefix=/usr/ccs/bin
5352     ;;
5353   sparc64-*-elf*)
5354     ;;
5355   v850*-*-*)
5356     md_exec_prefix=/usr/ccs/bin
5357     ;;
5358   xtensa*-*-elf*)
5359     ;;
5360
5361   *-*-beos* | \
5362   *-*-elf* | \
5363   *-*-hpux* | \
5364   *-*-netware* | \
5365   *-*-nto-qnx* | \
5366   *-*-rtems* | \
5367   *-*-solaris2* | \
5368   *-*-sysv[45]* | \
5369   *-*-vxworks* | \
5370   *-wrs-windiss)
5371     md_exec_prefix=/usr/ccs/bin
5372     ;;
5373 esac
5374
5375 extra_arflags_for_target=
5376 extra_nmflags_for_target=
5377 extra_ranlibflags_for_target=
5378 target_makefile_frag=/dev/null
5379 case "${target}" in
5380   mep*-*-*)
5381     target_makefile_frag="config/mt-mep"
5382     ;;
5383   spu-*-*)
5384     target_makefile_frag="config/mt-spu"
5385     ;;
5386   mips*-sde-elf*)
5387     target_makefile_frag="config/mt-sde"
5388     ;;
5389   mipsisa*-*-elfoabi*)
5390     target_makefile_frag="config/mt-mips-elfoabi"
5391     ;;
5392   *-*-netware*)
5393     target_makefile_frag="config/mt-netware"
5394     ;;
5395   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5396     target_makefile_frag="config/mt-gnu"
5397     ;;
5398   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5399     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5400     # commands to handle both 32-bit and 64-bit objects.  These flags are
5401     # harmless if we're using GNU nm or ar.
5402     extra_arflags_for_target=" -X32_64"
5403     extra_nmflags_for_target=" -B -X32_64"
5404     ;;
5405   *-*-darwin*)
5406     # ranlib from Darwin requires the -c flag to look at common symbols.
5407     extra_ranlibflags_for_target=" -c"
5408     ;;
5409   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5410     target_makefile_frag="config/mt-wince"
5411     ;;
5412 esac
5413
5414 alphaieee_frag=/dev/null
5415 case $target in
5416   alpha*-*-*)
5417     # This just makes sure to use the -mieee option to build target libs.
5418     # This should probably be set individually by each library.
5419     alphaieee_frag="config/mt-alphaieee"
5420     ;;
5421 esac
5422
5423 # If --enable-target-optspace always use -Os instead of -O2 to build
5424 # the target libraries, similarly if it is not specified, use -Os
5425 # on selected platforms.
5426 ospace_frag=/dev/null
5427 case "${enable_target_optspace}:${target}" in
5428   yes:*)
5429     ospace_frag="config/mt-ospace"
5430     ;;
5431   :d30v-*)
5432     ospace_frag="config/mt-d30v"
5433     ;;
5434   :m32r-* | :d10v-* | :fr30-*)
5435     ospace_frag="config/mt-ospace"
5436     ;;
5437   no:* | :*)
5438     ;;
5439   *)
5440     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5441     ;;
5442 esac
5443
5444 # Default to using --with-stabs for certain targets.
5445 if test x${with_stabs} = x ; then
5446   case "${target}" in
5447   mips*-*-irix[56]*)
5448     ;;
5449   mips*-*-* | alpha*-*-osf*)
5450     with_stabs=yes;
5451     extra_host_args="${extra_host_args} --with-stabs"
5452     ;;
5453   esac
5454 fi
5455
5456 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5457 # them automatically.
5458 case "${host}" in
5459   hppa*64*-*-hpux11*)
5460     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5461     ;;
5462 esac
5463
5464 # Some systems (e.g., one of the i386-aix systems the gas testers are
5465 # using) don't handle "\$" correctly, so don't use it here.
5466 tooldir='${exec_prefix}'/${target_noncanonical}
5467 build_tooldir=${tooldir}
5468
5469 # Create a .gdbinit file which runs the one in srcdir
5470 # and tells GDB to look there for source files.
5471
5472 if test -r ${srcdir}/.gdbinit ; then
5473   case ${srcdir} in
5474     .) ;;
5475     *) cat > ./.gdbinit <<EOF
5476 # ${NO_EDIT}
5477 dir ${srcdir}
5478 dir .
5479 source ${srcdir}/.gdbinit
5480 EOF
5481     ;;
5482   esac
5483 fi
5484
5485 # Make sure that the compiler is able to generate an executable.  If it
5486 # can't, we are probably in trouble.  We don't care whether we can run the
5487 # executable--we might be using a cross compiler--we only care whether it
5488 # can be created.  At this point the main configure script has set CC.
5489 we_are_ok=no
5490 echo "int main () { return 0; }" > conftest.c
5491 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5492 if test $? = 0 ; then
5493   if test -s conftest || test -s conftest.exe ; then
5494     we_are_ok=yes
5495   fi
5496 fi
5497 case $we_are_ok in
5498   no)
5499     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5500     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5501     rm -f conftest*
5502     exit 1
5503     ;;
5504 esac
5505 rm -f conftest*
5506
5507 # The Solaris /usr/ucb/cc compiler does not appear to work.
5508 case "${host}" in
5509   sparc-sun-solaris2*)
5510       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5511       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5512           could_use=
5513           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5514           if test -d /opt/cygnus/bin ; then
5515               if test "$could_use" = "" ; then
5516                   could_use="/opt/cygnus/bin"
5517               else
5518                   could_use="$could_use or /opt/cygnus/bin"
5519               fi
5520           fi
5521         if test "$could_use" = "" ; then
5522             echo "Warning: compilation may fail because you're using"
5523             echo "/usr/ucb/cc.  You should change your PATH or CC "
5524             echo "variable and rerun configure."
5525         else
5526             echo "Warning: compilation may fail because you're using"
5527             echo "/usr/ucb/cc, when you should use the C compiler from"
5528             echo "$could_use.  You should change your"
5529             echo "PATH or CC variable and rerun configure."
5530         fi
5531       fi
5532   ;;
5533 esac
5534
5535 case "${host}" in
5536   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5537   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5538   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5539 esac
5540
5541 # Record target_configdirs and the configure arguments for target and
5542 # build configuration in Makefile.
5543 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5544 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5545
5546 # Determine whether gdb needs tk/tcl or not.
5547 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5548 # and in that case we want gdb to be built without tk.  Ugh!
5549 # In fact I believe gdb is the *only* package directly dependent on tk,
5550 # so we should be able to put the 'maybe's in unconditionally and
5551 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5552 # 100% sure that that's safe though.
5553
5554 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5555 case "$enable_gdbtk" in
5556   no)
5557     GDB_TK="" ;;
5558   yes)
5559     GDB_TK="${gdb_tk}" ;;
5560   *)
5561     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5562     # distro.  Eventually someone will fix this and move Insight, nee
5563     # gdbtk to a separate directory.
5564     if test -d ${srcdir}/gdb/gdbtk ; then
5565       GDB_TK="${gdb_tk}"
5566     else
5567       GDB_TK=""
5568     fi
5569     ;;
5570 esac
5571 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5572 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5573
5574 # Strip out unwanted targets.
5575
5576 # While at that, we remove Makefiles if we were started for recursive
5577 # configuration, so that the top-level Makefile reconfigures them,
5578 # like we used to do when configure itself was recursive.
5579
5580 # Loop over modules.  $extrasub must be used with care, limiting as
5581 # much as possible the usage of range addresses.  That's because autoconf
5582 # splits the sed script to overcome limits in the number of commands,
5583 # and relying on carefully-timed sed passes may turn out to be very hard
5584 # to maintain later.  In this particular case, you just have to be careful
5585 # not to nest @if/@endif pairs, because configure will not warn you at all.
5586
5587 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5588 if test "${enable_bootstrap+set}" = set; then
5589   enableval="$enable_bootstrap"
5590
5591 else
5592   enable_bootstrap=default
5593 fi;
5594
5595 # Issue errors and warnings for invalid/strange bootstrap combinations.
5596 case "$configdirs" in
5597   *gcc*) have_compiler=yes ;;
5598   *) have_compiler=no ;;
5599 esac
5600
5601 case "$have_compiler:$host:$target:$enable_bootstrap" in
5602   *:*:*:no) ;;
5603
5604   # Default behavior.  Enable bootstrap if we have a compiler
5605   # and we are in a native configuration.
5606   yes:$build:$build:default)
5607     enable_bootstrap=yes ;;
5608
5609   *:*:*:default)
5610     enable_bootstrap=no ;;
5611
5612   # We have a compiler and we are in a native configuration, bootstrap is ok
5613   yes:$build:$build:yes)
5614     ;;
5615
5616   # Other configurations, but we have a compiler.  Assume the user knows
5617   # what he's doing.
5618   yes:*:*:yes)
5619     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5620 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5621     ;;
5622
5623   # No compiler: if they passed --enable-bootstrap explicitly, fail
5624   no:*:*:yes)
5625     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5626 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5627    { (exit 1); exit 1; }; } ;;
5628
5629   # Fail if wrong command line
5630   *)
5631     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5632 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5633    { (exit 1); exit 1; }; }
5634     ;;
5635 esac
5636
5637 # Adjust the toplevel makefile according to whether bootstrap was selected.
5638 case "$enable_bootstrap" in
5639   yes)
5640     bootstrap_suffix=bootstrap ;;
5641   no)
5642     bootstrap_suffix=no-bootstrap ;;
5643 esac
5644
5645 for module in ${build_configdirs} ; do
5646   if test -z "${no_recursion}" \
5647      && test -f ${build_subdir}/${module}/Makefile; then
5648     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5649     rm -f ${build_subdir}/${module}/Makefile
5650   fi
5651   extrasub="$extrasub
5652 /^@if build-$module\$/d
5653 /^@endif build-$module\$/d
5654 /^@if build-$module-$bootstrap_suffix\$/d
5655 /^@endif build-$module-$bootstrap_suffix\$/d"
5656 done
5657 for module in ${configdirs} ; do
5658   if test -z "${no_recursion}"; then
5659     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5660       if test -f ${file}; then
5661         echo 1>&2 "*** removing ${file} to force reconfigure"
5662         rm -f ${file}
5663       fi
5664     done
5665   fi
5666   extrasub="$extrasub
5667 /^@if $module\$/d
5668 /^@endif $module\$/d
5669 /^@if $module-$bootstrap_suffix\$/d
5670 /^@endif $module-$bootstrap_suffix\$/d"
5671 done
5672 for module in ${target_configdirs} ; do
5673   if test -z "${no_recursion}" \
5674      && test -f ${target_subdir}/${module}/Makefile; then
5675     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5676     rm -f ${target_subdir}/${module}/Makefile
5677   fi
5678   extrasub="$extrasub
5679 /^@if target-$module\$/d
5680 /^@endif target-$module\$/d
5681 /^@if target-$module-$bootstrap_suffix\$/d
5682 /^@endif target-$module-$bootstrap_suffix\$/d"
5683 done
5684
5685 extrasub="$extrasub
5686 /^@if /,/^@endif /d"
5687
5688 # Create the serialization dependencies.  This uses a temporary file.
5689
5690 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5691 if test "${enable_serial_configure+set}" = set; then
5692   enableval="$enable_serial_configure"
5693
5694 fi;
5695
5696 case ${enable_serial_configure} in
5697   yes)
5698     enable_serial_build_configure=yes
5699     enable_serial_host_configure=yes
5700     enable_serial_target_configure=yes
5701     ;;
5702 esac
5703
5704 # These force 'configure's to be done one at a time, to avoid problems
5705 # with contention over a shared config.cache.
5706 rm -f serdep.tmp
5707 echo '# serdep.tmp' > serdep.tmp
5708 olditem=
5709 test "x${enable_serial_build_configure}" = xyes &&
5710 for item in ${build_configdirs} ; do
5711   case ${olditem} in
5712     "") ;;
5713     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5714   esac
5715   olditem=${item}
5716 done
5717 olditem=
5718 test "x${enable_serial_host_configure}" = xyes &&
5719 for item in ${configdirs} ; do
5720   case ${olditem} in
5721     "") ;;
5722     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5723   esac
5724   olditem=${item}
5725 done
5726 olditem=
5727 test "x${enable_serial_target_configure}" = xyes &&
5728 for item in ${target_configdirs} ; do
5729   case ${olditem} in
5730     "") ;;
5731     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5732   esac
5733   olditem=${item}
5734 done
5735 serialization_dependencies=serdep.tmp
5736
5737
5738 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5739 # target, nonopt, and variable assignments.  These are the ones we
5740 # might not want to pass down to subconfigures.  Also strip
5741 # program-prefix, program-suffix, and program-transform-name, so that
5742 # we can pass down a consistent program-transform-name.
5743 baseargs=
5744 keep_next=no
5745 skip_next=no
5746 eval "set -- $ac_configure_args"
5747 for ac_arg
5748 do
5749   if test X"$skip_next" = X"yes"; then
5750     skip_next=no
5751     continue
5752   fi
5753   if test X"$keep_next" = X"yes"; then
5754     case $ac_arg in
5755       *\'*)
5756         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5757     esac
5758     baseargs="$baseargs '$ac_arg'"
5759     keep_next=no
5760     continue
5761   fi
5762
5763   # Handle separated arguments.  Based on the logic generated by
5764   # autoconf 2.59.
5765   case $ac_arg in
5766     *=* | --config-cache | -C | -disable-* | --disable-* \
5767       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5768       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5769       | -with-* | --with-* | -without-* | --without-* | --x)
5770       separate_arg=no
5771       ;;
5772     -*)
5773       separate_arg=yes
5774       ;;
5775     *)
5776       separate_arg=no
5777       ;;
5778   esac
5779
5780   case "$ac_arg" in
5781     --no*)
5782       continue
5783       ;;
5784     --c* | \
5785     --sr* | \
5786     --ho* | \
5787     --bu* | \
5788     --t* | \
5789     --program-* | \
5790     -cache_file* | \
5791     -srcdir* | \
5792     -host* | \
5793     -build* | \
5794     -target* | \
5795     -program-prefix* | \
5796     -program-suffix* | \
5797     -program-transform-name* )
5798       skip_next=$separate_arg
5799       continue
5800       ;;
5801     -*)
5802       # An option.  Add it.
5803       case $ac_arg in
5804         *\'*)
5805           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5806       esac
5807       baseargs="$baseargs '$ac_arg'"
5808       keep_next=$separate_arg
5809       ;;
5810     *)
5811       # Either a variable assignment, or a nonopt (triplet).  Don't
5812       # pass it down; let the Makefile handle this.
5813       continue
5814       ;;
5815   esac
5816 done
5817 # Remove the initial space we just introduced and, as these will be
5818 # expanded by make, quote '$'.
5819 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5820
5821 # Add in --program-transform-name, after --program-prefix and
5822 # --program-suffix have been applied to it.  Autoconf has already
5823 # doubled dollar signs and backslashes in program_transform_name; we want
5824 # the backslashes un-doubled, and then the entire thing wrapped in single
5825 # quotes, because this will be expanded first by make and then by the shell.
5826 # Also, because we want to override the logic in subdir configure scripts to
5827 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5828 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5829 ${program_transform_name}
5830 EOF_SED
5831 gcc_transform_name=`cat conftestsed.out`
5832 rm -f conftestsed.out
5833 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5834 if test "$silent" = yes; then
5835   baseargs="$baseargs --silent"
5836 fi
5837
5838 # For the build-side libraries, we just need to pretend we're native,
5839 # and not use the same cache file.  Multilibs are neither needed nor
5840 # desired.
5841 build_configargs="--cache-file=../config.cache ${baseargs}"
5842
5843 # For host modules, accept cache file option, or specification as blank.
5844 case "${cache_file}" in
5845 "") # empty
5846   cache_file_option="" ;;
5847 /* | [A-Za-z]:[\\/]* ) # absolute path
5848   cache_file_option="--cache-file=${cache_file}" ;;
5849 *) # relative path
5850   cache_file_option="--cache-file=../${cache_file}" ;;
5851 esac
5852
5853 # Host dirs don't like to share a cache file either, horribly enough.
5854 # This seems to be due to autoconf 2.5x stupidity.
5855 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5856
5857 target_configargs=${baseargs}
5858
5859 # Passing a --with-cross-host argument lets the target libraries know
5860 # whether they are being built with a cross-compiler or being built
5861 # native.  However, it would be better to use other mechanisms to make the
5862 # sorts of decisions they want to make on this basis.  Please consider
5863 # this option to be deprecated.  FIXME.
5864 if test x${is_cross_compiler} = xyes ; then
5865   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5866 fi
5867
5868 # Default to --enable-multilib.
5869 if test x${enable_multilib} = x ; then
5870   target_configargs="--enable-multilib ${target_configargs}"
5871 fi
5872
5873 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5874 # changed from the earlier setting of with_newlib.
5875 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5876   target_configargs="--with-newlib ${target_configargs}"
5877 fi
5878
5879 # Different target subdirs use different values of certain variables
5880 # (notably CXX).  Worse, multilibs use *lots* of different values.
5881 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5882 # it doesn't automatically accept command-line overrides of them.
5883 # This means it's not safe for target subdirs to share a cache file,
5884 # which is disgusting, but there you have it.  Hopefully this can be
5885 # fixed in future.  It's still worthwhile to use a cache file for each
5886 # directory.  I think.
5887
5888 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5889 # We need to pass --target, as newer autoconf's requires consistency
5890 # for target_alias and gcc doesn't manage it consistently.
5891 target_configargs="--cache-file=./config.cache ${target_configargs}"
5892
5893 FLAGS_FOR_TARGET=
5894 case " $target_configdirs " in
5895  *" newlib "*)
5896   case " $target_configargs " in
5897   *" --with-newlib "*)
5898    case "$target" in
5899    *-cygwin*)
5900      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' ;;
5901    esac
5902
5903    # If we're not building GCC, don't discard standard headers.
5904    if test -d ${srcdir}/gcc; then
5905      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5906
5907      if test "${build}" != "${host}"; then
5908        # On Canadian crosses, CC_FOR_TARGET will have already been set
5909        # by `configure', so we won't have an opportunity to add -Bgcc/
5910        # to it.  This is right: we don't want to search that directory
5911        # for binaries, but we want the header files in there, so add
5912        # them explicitly.
5913        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5914
5915        # Someone might think of using the pre-installed headers on
5916        # Canadian crosses, in case the installed compiler is not fully
5917        # compatible with the compiler being built.  In this case, it
5918        # would be better to flag an error than risking having
5919        # incompatible object files being constructed.  We can't
5920        # guarantee that an error will be flagged, but let's hope the
5921        # compiler will do it, when presented with incompatible header
5922        # files.
5923      fi
5924    fi
5925
5926    case "${target}-${is_cross_compiler}" in
5927    i[3456789]86-*-linux*-no)
5928       # Here host == target, so we don't need to build gcc,
5929       # so we don't want to discard standard headers.
5930       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5931       ;;
5932    *)
5933       # If we're building newlib, use its generic headers last, but search
5934       # for any libc-related directories first (so make it the last -B
5935       # switch).
5936       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5937
5938       # If we're building libgloss, find the startup file, simulator library
5939       # and linker script.
5940       case " $target_configdirs " in
5941         *" libgloss "*)
5942         # Look for startup file, simulator library and maybe linker script.
5943         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
5944         # Look for libnosys.a in case the target needs it.
5945         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5946         # Most targets have the linker script in the source directory.
5947         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
5948         ;;
5949       esac
5950       ;;
5951    esac
5952    ;;
5953   esac
5954   ;;
5955 esac
5956 case "$target" in
5957 *-mingw*)
5958   # Can't be handled as Cygwin above since Mingw does not use newlib.
5959   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' ;;
5960 esac
5961
5962 # Allow the user to override the flags for
5963 # our build compiler if desired.
5964 if test x"${build}" = x"${host}" ; then
5965   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5966   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
5967   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
5968 fi
5969
5970 # On Canadian crosses, we'll be searching the right directories for
5971 # the previously-installed cross compiler, so don't bother to add
5972 # flags for directories within the install tree of the compiler
5973 # being built; programs in there won't even run.
5974 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5975   # Search for pre-installed headers if nothing else fits.
5976   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5977 fi
5978
5979 if test "x${use_gnu_ld}" = x &&
5980    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5981   # Arrange for us to find uninstalled linker scripts.
5982   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5983 fi
5984
5985 # Search for other target-specific linker scripts and such.
5986 case "${target}" in
5987   mep*)
5988     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5989     ;;
5990 esac
5991
5992 # Makefile fragments.
5993 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5994 do
5995   eval fragval=\$$frag
5996   if test $fragval != /dev/null; then
5997     eval $frag=${srcdir}/$fragval
5998   fi
5999 done
6000
6001
6002
6003
6004
6005 # Miscellanea: directories, flags, etc.
6006
6007
6008
6009
6010
6011
6012
6013 # Build module lists & subconfigure args.
6014
6015
6016
6017 # Host module lists & subconfigure args.
6018
6019
6020
6021 # Target module lists & subconfigure args.
6022
6023
6024
6025 # Build tools.
6026
6027
6028
6029
6030
6031
6032
6033
6034
6035
6036
6037
6038
6039
6040
6041
6042
6043 # Generate default definitions for YACC, M4, LEX and other programs that run
6044 # on the build machine.  These are used if the Makefile can't locate these
6045 # programs in objdir.
6046 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6047
6048 for ac_prog in 'bison -y' byacc yacc
6049 do
6050   # Extract the first word of "$ac_prog", so it can be a program name with args.
6051 set dummy $ac_prog; ac_word=$2
6052 echo "$as_me:$LINENO: checking for $ac_word" >&5
6053 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6054 if test "${ac_cv_prog_YACC+set}" = set; then
6055   echo $ECHO_N "(cached) $ECHO_C" >&6
6056 else
6057   if test -n "$YACC"; then
6058   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6059 else
6060 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6061 for as_dir in $PATH
6062 do
6063   IFS=$as_save_IFS
6064   test -z "$as_dir" && as_dir=.
6065   for ac_exec_ext in '' $ac_executable_extensions; do
6066   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6067     ac_cv_prog_YACC="$ac_prog"
6068     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6069     break 2
6070   fi
6071 done
6072 done
6073
6074 fi
6075 fi
6076 YACC=$ac_cv_prog_YACC
6077 if test -n "$YACC"; then
6078   echo "$as_me:$LINENO: result: $YACC" >&5
6079 echo "${ECHO_T}$YACC" >&6
6080 else
6081   echo "$as_me:$LINENO: result: no" >&5
6082 echo "${ECHO_T}no" >&6
6083 fi
6084
6085   test -n "$YACC" && break
6086 done
6087 test -n "$YACC" || YACC="$MISSING bison -y"
6088
6089 case " $build_configdirs " in
6090   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6091   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6092 esac
6093
6094 for ac_prog in bison
6095 do
6096   # Extract the first word of "$ac_prog", so it can be a program name with args.
6097 set dummy $ac_prog; ac_word=$2
6098 echo "$as_me:$LINENO: checking for $ac_word" >&5
6099 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6100 if test "${ac_cv_prog_BISON+set}" = set; then
6101   echo $ECHO_N "(cached) $ECHO_C" >&6
6102 else
6103   if test -n "$BISON"; then
6104   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6105 else
6106 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6107 for as_dir in $PATH
6108 do
6109   IFS=$as_save_IFS
6110   test -z "$as_dir" && as_dir=.
6111   for ac_exec_ext in '' $ac_executable_extensions; do
6112   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6113     ac_cv_prog_BISON="$ac_prog"
6114     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6115     break 2
6116   fi
6117 done
6118 done
6119
6120 fi
6121 fi
6122 BISON=$ac_cv_prog_BISON
6123 if test -n "$BISON"; then
6124   echo "$as_me:$LINENO: result: $BISON" >&5
6125 echo "${ECHO_T}$BISON" >&6
6126 else
6127   echo "$as_me:$LINENO: result: no" >&5
6128 echo "${ECHO_T}no" >&6
6129 fi
6130
6131   test -n "$BISON" && break
6132 done
6133 test -n "$BISON" || BISON="$MISSING bison"
6134
6135 case " $build_configdirs " in
6136   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6137 esac
6138
6139 for ac_prog in gm4 gnum4 m4
6140 do
6141   # Extract the first word of "$ac_prog", so it can be a program name with args.
6142 set dummy $ac_prog; ac_word=$2
6143 echo "$as_me:$LINENO: checking for $ac_word" >&5
6144 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6145 if test "${ac_cv_prog_M4+set}" = set; then
6146   echo $ECHO_N "(cached) $ECHO_C" >&6
6147 else
6148   if test -n "$M4"; then
6149   ac_cv_prog_M4="$M4" # Let the user override the test.
6150 else
6151 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6152 for as_dir in $PATH
6153 do
6154   IFS=$as_save_IFS
6155   test -z "$as_dir" && as_dir=.
6156   for ac_exec_ext in '' $ac_executable_extensions; do
6157   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6158     ac_cv_prog_M4="$ac_prog"
6159     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6160     break 2
6161   fi
6162 done
6163 done
6164
6165 fi
6166 fi
6167 M4=$ac_cv_prog_M4
6168 if test -n "$M4"; then
6169   echo "$as_me:$LINENO: result: $M4" >&5
6170 echo "${ECHO_T}$M4" >&6
6171 else
6172   echo "$as_me:$LINENO: result: no" >&5
6173 echo "${ECHO_T}no" >&6
6174 fi
6175
6176   test -n "$M4" && break
6177 done
6178 test -n "$M4" || M4="$MISSING m4"
6179
6180 case " $build_configdirs " in
6181   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6182 esac
6183
6184 for ac_prog in flex lex
6185 do
6186   # Extract the first word of "$ac_prog", so it can be a program name with args.
6187 set dummy $ac_prog; ac_word=$2
6188 echo "$as_me:$LINENO: checking for $ac_word" >&5
6189 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6190 if test "${ac_cv_prog_LEX+set}" = set; then
6191   echo $ECHO_N "(cached) $ECHO_C" >&6
6192 else
6193   if test -n "$LEX"; then
6194   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6195 else
6196 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6197 for as_dir in $PATH
6198 do
6199   IFS=$as_save_IFS
6200   test -z "$as_dir" && as_dir=.
6201   for ac_exec_ext in '' $ac_executable_extensions; do
6202   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6203     ac_cv_prog_LEX="$ac_prog"
6204     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6205     break 2
6206   fi
6207 done
6208 done
6209
6210 fi
6211 fi
6212 LEX=$ac_cv_prog_LEX
6213 if test -n "$LEX"; then
6214   echo "$as_me:$LINENO: result: $LEX" >&5
6215 echo "${ECHO_T}$LEX" >&6
6216 else
6217   echo "$as_me:$LINENO: result: no" >&5
6218 echo "${ECHO_T}no" >&6
6219 fi
6220
6221   test -n "$LEX" && break
6222 done
6223 test -n "$LEX" || LEX="$MISSING flex"
6224
6225 case " $build_configdirs " in
6226   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6227   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6228 esac
6229
6230 for ac_prog in flex
6231 do
6232   # Extract the first word of "$ac_prog", so it can be a program name with args.
6233 set dummy $ac_prog; ac_word=$2
6234 echo "$as_me:$LINENO: checking for $ac_word" >&5
6235 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6236 if test "${ac_cv_prog_FLEX+set}" = set; then
6237   echo $ECHO_N "(cached) $ECHO_C" >&6
6238 else
6239   if test -n "$FLEX"; then
6240   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6241 else
6242 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6243 for as_dir in $PATH
6244 do
6245   IFS=$as_save_IFS
6246   test -z "$as_dir" && as_dir=.
6247   for ac_exec_ext in '' $ac_executable_extensions; do
6248   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6249     ac_cv_prog_FLEX="$ac_prog"
6250     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6251     break 2
6252   fi
6253 done
6254 done
6255
6256 fi
6257 fi
6258 FLEX=$ac_cv_prog_FLEX
6259 if test -n "$FLEX"; then
6260   echo "$as_me:$LINENO: result: $FLEX" >&5
6261 echo "${ECHO_T}$FLEX" >&6
6262 else
6263   echo "$as_me:$LINENO: result: no" >&5
6264 echo "${ECHO_T}no" >&6
6265 fi
6266
6267   test -n "$FLEX" && break
6268 done
6269 test -n "$FLEX" || FLEX="$MISSING flex"
6270
6271 case " $build_configdirs " in
6272   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6273 esac
6274
6275 for ac_prog in makeinfo
6276 do
6277   # Extract the first word of "$ac_prog", so it can be a program name with args.
6278 set dummy $ac_prog; ac_word=$2
6279 echo "$as_me:$LINENO: checking for $ac_word" >&5
6280 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6281 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6282   echo $ECHO_N "(cached) $ECHO_C" >&6
6283 else
6284   if test -n "$MAKEINFO"; then
6285   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6286 else
6287 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6288 for as_dir in $PATH
6289 do
6290   IFS=$as_save_IFS
6291   test -z "$as_dir" && as_dir=.
6292   for ac_exec_ext in '' $ac_executable_extensions; do
6293   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6294     ac_cv_prog_MAKEINFO="$ac_prog"
6295     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6296     break 2
6297   fi
6298 done
6299 done
6300
6301 fi
6302 fi
6303 MAKEINFO=$ac_cv_prog_MAKEINFO
6304 if test -n "$MAKEINFO"; then
6305   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6306 echo "${ECHO_T}$MAKEINFO" >&6
6307 else
6308   echo "$as_me:$LINENO: result: no" >&5
6309 echo "${ECHO_T}no" >&6
6310 fi
6311
6312   test -n "$MAKEINFO" && break
6313 done
6314 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6315
6316 case " $build_configdirs " in
6317   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6318   *)
6319
6320     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6321     # higher, else we use the "missing" dummy.
6322     if ${MAKEINFO} --version \
6323        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6324       :
6325     else
6326       MAKEINFO="$MISSING makeinfo"
6327     fi
6328     ;;
6329
6330 esac
6331
6332 # FIXME: expect and dejagnu may become build tools?
6333
6334 for ac_prog in expect
6335 do
6336   # Extract the first word of "$ac_prog", so it can be a program name with args.
6337 set dummy $ac_prog; ac_word=$2
6338 echo "$as_me:$LINENO: checking for $ac_word" >&5
6339 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6340 if test "${ac_cv_prog_EXPECT+set}" = set; then
6341   echo $ECHO_N "(cached) $ECHO_C" >&6
6342 else
6343   if test -n "$EXPECT"; then
6344   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6345 else
6346 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6347 for as_dir in $PATH
6348 do
6349   IFS=$as_save_IFS
6350   test -z "$as_dir" && as_dir=.
6351   for ac_exec_ext in '' $ac_executable_extensions; do
6352   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6353     ac_cv_prog_EXPECT="$ac_prog"
6354     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6355     break 2
6356   fi
6357 done
6358 done
6359
6360 fi
6361 fi
6362 EXPECT=$ac_cv_prog_EXPECT
6363 if test -n "$EXPECT"; then
6364   echo "$as_me:$LINENO: result: $EXPECT" >&5
6365 echo "${ECHO_T}$EXPECT" >&6
6366 else
6367   echo "$as_me:$LINENO: result: no" >&5
6368 echo "${ECHO_T}no" >&6
6369 fi
6370
6371   test -n "$EXPECT" && break
6372 done
6373 test -n "$EXPECT" || EXPECT="expect"
6374
6375 case " $configdirs " in
6376   *" expect "*)
6377     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6378     ;;
6379 esac
6380
6381 for ac_prog in runtest
6382 do
6383   # Extract the first word of "$ac_prog", so it can be a program name with args.
6384 set dummy $ac_prog; ac_word=$2
6385 echo "$as_me:$LINENO: checking for $ac_word" >&5
6386 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6387 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6388   echo $ECHO_N "(cached) $ECHO_C" >&6
6389 else
6390   if test -n "$RUNTEST"; then
6391   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6392 else
6393 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6394 for as_dir in $PATH
6395 do
6396   IFS=$as_save_IFS
6397   test -z "$as_dir" && as_dir=.
6398   for ac_exec_ext in '' $ac_executable_extensions; do
6399   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6400     ac_cv_prog_RUNTEST="$ac_prog"
6401     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6402     break 2
6403   fi
6404 done
6405 done
6406
6407 fi
6408 fi
6409 RUNTEST=$ac_cv_prog_RUNTEST
6410 if test -n "$RUNTEST"; then
6411   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6412 echo "${ECHO_T}$RUNTEST" >&6
6413 else
6414   echo "$as_me:$LINENO: result: no" >&5
6415 echo "${ECHO_T}no" >&6
6416 fi
6417
6418   test -n "$RUNTEST" && break
6419 done
6420 test -n "$RUNTEST" || RUNTEST="runtest"
6421
6422 case " $configdirs " in
6423   *" dejagnu "*)
6424     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6425     ;;
6426 esac
6427
6428
6429 # Host tools.
6430 ncn_tool_prefix=
6431 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6432 ncn_target_tool_prefix=
6433 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6434
6435
6436
6437 if test -n "$AR"; then
6438   ac_cv_prog_AR=$AR
6439 elif test -n "$ac_cv_prog_AR"; then
6440   AR=$ac_cv_prog_AR
6441 fi
6442
6443 if test -n "$ac_cv_prog_AR"; then
6444   for ncn_progname in ar; do
6445     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6446 set dummy ${ncn_progname}; ac_word=$2
6447 echo "$as_me:$LINENO: checking for $ac_word" >&5
6448 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6449 if test "${ac_cv_prog_AR+set}" = set; then
6450   echo $ECHO_N "(cached) $ECHO_C" >&6
6451 else
6452   if test -n "$AR"; then
6453   ac_cv_prog_AR="$AR" # Let the user override the test.
6454 else
6455 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6456 for as_dir in $PATH
6457 do
6458   IFS=$as_save_IFS
6459   test -z "$as_dir" && as_dir=.
6460   for ac_exec_ext in '' $ac_executable_extensions; do
6461   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6462     ac_cv_prog_AR="${ncn_progname}"
6463     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6464     break 2
6465   fi
6466 done
6467 done
6468
6469 fi
6470 fi
6471 AR=$ac_cv_prog_AR
6472 if test -n "$AR"; then
6473   echo "$as_me:$LINENO: result: $AR" >&5
6474 echo "${ECHO_T}$AR" >&6
6475 else
6476   echo "$as_me:$LINENO: result: no" >&5
6477 echo "${ECHO_T}no" >&6
6478 fi
6479
6480   done
6481 fi
6482
6483 for ncn_progname in ar; do
6484   if test -n "$ncn_tool_prefix"; then
6485     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6486 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6487 echo "$as_me:$LINENO: checking for $ac_word" >&5
6488 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6489 if test "${ac_cv_prog_AR+set}" = set; then
6490   echo $ECHO_N "(cached) $ECHO_C" >&6
6491 else
6492   if test -n "$AR"; then
6493   ac_cv_prog_AR="$AR" # Let the user override the test.
6494 else
6495 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6496 for as_dir in $PATH
6497 do
6498   IFS=$as_save_IFS
6499   test -z "$as_dir" && as_dir=.
6500   for ac_exec_ext in '' $ac_executable_extensions; do
6501   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6502     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6503     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6504     break 2
6505   fi
6506 done
6507 done
6508
6509 fi
6510 fi
6511 AR=$ac_cv_prog_AR
6512 if test -n "$AR"; then
6513   echo "$as_me:$LINENO: result: $AR" >&5
6514 echo "${ECHO_T}$AR" >&6
6515 else
6516   echo "$as_me:$LINENO: result: no" >&5
6517 echo "${ECHO_T}no" >&6
6518 fi
6519
6520   fi
6521   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6522     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6523 set dummy ${ncn_progname}; ac_word=$2
6524 echo "$as_me:$LINENO: checking for $ac_word" >&5
6525 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6526 if test "${ac_cv_prog_AR+set}" = set; then
6527   echo $ECHO_N "(cached) $ECHO_C" >&6
6528 else
6529   if test -n "$AR"; then
6530   ac_cv_prog_AR="$AR" # Let the user override the test.
6531 else
6532 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6533 for as_dir in $PATH
6534 do
6535   IFS=$as_save_IFS
6536   test -z "$as_dir" && as_dir=.
6537   for ac_exec_ext in '' $ac_executable_extensions; do
6538   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6539     ac_cv_prog_AR="${ncn_progname}"
6540     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6541     break 2
6542   fi
6543 done
6544 done
6545
6546 fi
6547 fi
6548 AR=$ac_cv_prog_AR
6549 if test -n "$AR"; then
6550   echo "$as_me:$LINENO: result: $AR" >&5
6551 echo "${ECHO_T}$AR" >&6
6552 else
6553   echo "$as_me:$LINENO: result: no" >&5
6554 echo "${ECHO_T}no" >&6
6555 fi
6556
6557   fi
6558   test -n "$ac_cv_prog_AR" && break
6559 done
6560
6561 if test -z "$ac_cv_prog_AR" ; then
6562   set dummy ar
6563   if test $build = $host ; then
6564     AR="$2"
6565   else
6566     AR="${ncn_tool_prefix}$2"
6567   fi
6568 fi
6569
6570
6571
6572 if test -n "$AS"; then
6573   ac_cv_prog_AS=$AS
6574 elif test -n "$ac_cv_prog_AS"; then
6575   AS=$ac_cv_prog_AS
6576 fi
6577
6578 if test -n "$ac_cv_prog_AS"; then
6579   for ncn_progname in as; do
6580     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6581 set dummy ${ncn_progname}; ac_word=$2
6582 echo "$as_me:$LINENO: checking for $ac_word" >&5
6583 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6584 if test "${ac_cv_prog_AS+set}" = set; then
6585   echo $ECHO_N "(cached) $ECHO_C" >&6
6586 else
6587   if test -n "$AS"; then
6588   ac_cv_prog_AS="$AS" # Let the user override the test.
6589 else
6590 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6591 for as_dir in $PATH
6592 do
6593   IFS=$as_save_IFS
6594   test -z "$as_dir" && as_dir=.
6595   for ac_exec_ext in '' $ac_executable_extensions; do
6596   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6597     ac_cv_prog_AS="${ncn_progname}"
6598     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6599     break 2
6600   fi
6601 done
6602 done
6603
6604 fi
6605 fi
6606 AS=$ac_cv_prog_AS
6607 if test -n "$AS"; then
6608   echo "$as_me:$LINENO: result: $AS" >&5
6609 echo "${ECHO_T}$AS" >&6
6610 else
6611   echo "$as_me:$LINENO: result: no" >&5
6612 echo "${ECHO_T}no" >&6
6613 fi
6614
6615   done
6616 fi
6617
6618 for ncn_progname in as; do
6619   if test -n "$ncn_tool_prefix"; then
6620     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6621 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6622 echo "$as_me:$LINENO: checking for $ac_word" >&5
6623 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6624 if test "${ac_cv_prog_AS+set}" = set; then
6625   echo $ECHO_N "(cached) $ECHO_C" >&6
6626 else
6627   if test -n "$AS"; then
6628   ac_cv_prog_AS="$AS" # Let the user override the test.
6629 else
6630 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6631 for as_dir in $PATH
6632 do
6633   IFS=$as_save_IFS
6634   test -z "$as_dir" && as_dir=.
6635   for ac_exec_ext in '' $ac_executable_extensions; do
6636   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6637     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6638     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6639     break 2
6640   fi
6641 done
6642 done
6643
6644 fi
6645 fi
6646 AS=$ac_cv_prog_AS
6647 if test -n "$AS"; then
6648   echo "$as_me:$LINENO: result: $AS" >&5
6649 echo "${ECHO_T}$AS" >&6
6650 else
6651   echo "$as_me:$LINENO: result: no" >&5
6652 echo "${ECHO_T}no" >&6
6653 fi
6654
6655   fi
6656   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6657     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6658 set dummy ${ncn_progname}; ac_word=$2
6659 echo "$as_me:$LINENO: checking for $ac_word" >&5
6660 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6661 if test "${ac_cv_prog_AS+set}" = set; then
6662   echo $ECHO_N "(cached) $ECHO_C" >&6
6663 else
6664   if test -n "$AS"; then
6665   ac_cv_prog_AS="$AS" # Let the user override the test.
6666 else
6667 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6668 for as_dir in $PATH
6669 do
6670   IFS=$as_save_IFS
6671   test -z "$as_dir" && as_dir=.
6672   for ac_exec_ext in '' $ac_executable_extensions; do
6673   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6674     ac_cv_prog_AS="${ncn_progname}"
6675     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6676     break 2
6677   fi
6678 done
6679 done
6680
6681 fi
6682 fi
6683 AS=$ac_cv_prog_AS
6684 if test -n "$AS"; then
6685   echo "$as_me:$LINENO: result: $AS" >&5
6686 echo "${ECHO_T}$AS" >&6
6687 else
6688   echo "$as_me:$LINENO: result: no" >&5
6689 echo "${ECHO_T}no" >&6
6690 fi
6691
6692   fi
6693   test -n "$ac_cv_prog_AS" && break
6694 done
6695
6696 if test -z "$ac_cv_prog_AS" ; then
6697   set dummy as
6698   if test $build = $host ; then
6699     AS="$2"
6700   else
6701     AS="${ncn_tool_prefix}$2"
6702   fi
6703 fi
6704
6705
6706
6707 if test -n "$DLLTOOL"; then
6708   ac_cv_prog_DLLTOOL=$DLLTOOL
6709 elif test -n "$ac_cv_prog_DLLTOOL"; then
6710   DLLTOOL=$ac_cv_prog_DLLTOOL
6711 fi
6712
6713 if test -n "$ac_cv_prog_DLLTOOL"; then
6714   for ncn_progname in dlltool; do
6715     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6716 set dummy ${ncn_progname}; ac_word=$2
6717 echo "$as_me:$LINENO: checking for $ac_word" >&5
6718 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6719 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6720   echo $ECHO_N "(cached) $ECHO_C" >&6
6721 else
6722   if test -n "$DLLTOOL"; then
6723   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6724 else
6725 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6726 for as_dir in $PATH
6727 do
6728   IFS=$as_save_IFS
6729   test -z "$as_dir" && as_dir=.
6730   for ac_exec_ext in '' $ac_executable_extensions; do
6731   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6732     ac_cv_prog_DLLTOOL="${ncn_progname}"
6733     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6734     break 2
6735   fi
6736 done
6737 done
6738
6739 fi
6740 fi
6741 DLLTOOL=$ac_cv_prog_DLLTOOL
6742 if test -n "$DLLTOOL"; then
6743   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6744 echo "${ECHO_T}$DLLTOOL" >&6
6745 else
6746   echo "$as_me:$LINENO: result: no" >&5
6747 echo "${ECHO_T}no" >&6
6748 fi
6749
6750   done
6751 fi
6752
6753 for ncn_progname in dlltool; do
6754   if test -n "$ncn_tool_prefix"; then
6755     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6756 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6757 echo "$as_me:$LINENO: checking for $ac_word" >&5
6758 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6759 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6760   echo $ECHO_N "(cached) $ECHO_C" >&6
6761 else
6762   if test -n "$DLLTOOL"; then
6763   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6764 else
6765 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6766 for as_dir in $PATH
6767 do
6768   IFS=$as_save_IFS
6769   test -z "$as_dir" && as_dir=.
6770   for ac_exec_ext in '' $ac_executable_extensions; do
6771   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6772     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6773     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6774     break 2
6775   fi
6776 done
6777 done
6778
6779 fi
6780 fi
6781 DLLTOOL=$ac_cv_prog_DLLTOOL
6782 if test -n "$DLLTOOL"; then
6783   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6784 echo "${ECHO_T}$DLLTOOL" >&6
6785 else
6786   echo "$as_me:$LINENO: result: no" >&5
6787 echo "${ECHO_T}no" >&6
6788 fi
6789
6790   fi
6791   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6792     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6793 set dummy ${ncn_progname}; ac_word=$2
6794 echo "$as_me:$LINENO: checking for $ac_word" >&5
6795 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6796 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6797   echo $ECHO_N "(cached) $ECHO_C" >&6
6798 else
6799   if test -n "$DLLTOOL"; then
6800   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6801 else
6802 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6803 for as_dir in $PATH
6804 do
6805   IFS=$as_save_IFS
6806   test -z "$as_dir" && as_dir=.
6807   for ac_exec_ext in '' $ac_executable_extensions; do
6808   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6809     ac_cv_prog_DLLTOOL="${ncn_progname}"
6810     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6811     break 2
6812   fi
6813 done
6814 done
6815
6816 fi
6817 fi
6818 DLLTOOL=$ac_cv_prog_DLLTOOL
6819 if test -n "$DLLTOOL"; then
6820   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6821 echo "${ECHO_T}$DLLTOOL" >&6
6822 else
6823   echo "$as_me:$LINENO: result: no" >&5
6824 echo "${ECHO_T}no" >&6
6825 fi
6826
6827   fi
6828   test -n "$ac_cv_prog_DLLTOOL" && break
6829 done
6830
6831 if test -z "$ac_cv_prog_DLLTOOL" ; then
6832   set dummy dlltool
6833   if test $build = $host ; then
6834     DLLTOOL="$2"
6835   else
6836     DLLTOOL="${ncn_tool_prefix}$2"
6837   fi
6838 fi
6839
6840
6841
6842 if test -n "$LD"; then
6843   ac_cv_prog_LD=$LD
6844 elif test -n "$ac_cv_prog_LD"; then
6845   LD=$ac_cv_prog_LD
6846 fi
6847
6848 if test -n "$ac_cv_prog_LD"; then
6849   for ncn_progname in ld; do
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_LD+set}" = set; then
6855   echo $ECHO_N "(cached) $ECHO_C" >&6
6856 else
6857   if test -n "$LD"; then
6858   ac_cv_prog_LD="$LD" # 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_LD="${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 LD=$ac_cv_prog_LD
6877 if test -n "$LD"; then
6878   echo "$as_me:$LINENO: result: $LD" >&5
6879 echo "${ECHO_T}$LD" >&6
6880 else
6881   echo "$as_me:$LINENO: result: no" >&5
6882 echo "${ECHO_T}no" >&6
6883 fi
6884
6885   done
6886 fi
6887
6888 for ncn_progname in ld; do
6889   if test -n "$ncn_tool_prefix"; then
6890     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6891 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6892 echo "$as_me:$LINENO: checking for $ac_word" >&5
6893 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6894 if test "${ac_cv_prog_LD+set}" = set; then
6895   echo $ECHO_N "(cached) $ECHO_C" >&6
6896 else
6897   if test -n "$LD"; then
6898   ac_cv_prog_LD="$LD" # Let the user override the test.
6899 else
6900 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6901 for as_dir in $PATH
6902 do
6903   IFS=$as_save_IFS
6904   test -z "$as_dir" && as_dir=.
6905   for ac_exec_ext in '' $ac_executable_extensions; do
6906   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6907     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6908     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6909     break 2
6910   fi
6911 done
6912 done
6913
6914 fi
6915 fi
6916 LD=$ac_cv_prog_LD
6917 if test -n "$LD"; then
6918   echo "$as_me:$LINENO: result: $LD" >&5
6919 echo "${ECHO_T}$LD" >&6
6920 else
6921   echo "$as_me:$LINENO: result: no" >&5
6922 echo "${ECHO_T}no" >&6
6923 fi
6924
6925   fi
6926   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6927     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6928 set dummy ${ncn_progname}; ac_word=$2
6929 echo "$as_me:$LINENO: checking for $ac_word" >&5
6930 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6931 if test "${ac_cv_prog_LD+set}" = set; then
6932   echo $ECHO_N "(cached) $ECHO_C" >&6
6933 else
6934   if test -n "$LD"; then
6935   ac_cv_prog_LD="$LD" # Let the user override the test.
6936 else
6937 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6938 for as_dir in $PATH
6939 do
6940   IFS=$as_save_IFS
6941   test -z "$as_dir" && as_dir=.
6942   for ac_exec_ext in '' $ac_executable_extensions; do
6943   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6944     ac_cv_prog_LD="${ncn_progname}"
6945     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6946     break 2
6947   fi
6948 done
6949 done
6950
6951 fi
6952 fi
6953 LD=$ac_cv_prog_LD
6954 if test -n "$LD"; then
6955   echo "$as_me:$LINENO: result: $LD" >&5
6956 echo "${ECHO_T}$LD" >&6
6957 else
6958   echo "$as_me:$LINENO: result: no" >&5
6959 echo "${ECHO_T}no" >&6
6960 fi
6961
6962   fi
6963   test -n "$ac_cv_prog_LD" && break
6964 done
6965
6966 if test -z "$ac_cv_prog_LD" ; then
6967   set dummy ld
6968   if test $build = $host ; then
6969     LD="$2"
6970   else
6971     LD="${ncn_tool_prefix}$2"
6972   fi
6973 fi
6974
6975
6976
6977 if test -n "$LIPO"; then
6978   ac_cv_prog_LIPO=$LIPO
6979 elif test -n "$ac_cv_prog_LIPO"; then
6980   LIPO=$ac_cv_prog_LIPO
6981 fi
6982
6983 if test -n "$ac_cv_prog_LIPO"; then
6984   for ncn_progname in lipo; do
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_LIPO+set}" = set; then
6990   echo $ECHO_N "(cached) $ECHO_C" >&6
6991 else
6992   if test -n "$LIPO"; then
6993   ac_cv_prog_LIPO="$LIPO" # 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_LIPO="${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 LIPO=$ac_cv_prog_LIPO
7012 if test -n "$LIPO"; then
7013   echo "$as_me:$LINENO: result: $LIPO" >&5
7014 echo "${ECHO_T}$LIPO" >&6
7015 else
7016   echo "$as_me:$LINENO: result: no" >&5
7017 echo "${ECHO_T}no" >&6
7018 fi
7019
7020   done
7021 fi
7022
7023 for ncn_progname in lipo; do
7024   if test -n "$ncn_tool_prefix"; then
7025     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7026 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7027 echo "$as_me:$LINENO: checking for $ac_word" >&5
7028 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7029 if test "${ac_cv_prog_LIPO+set}" = set; then
7030   echo $ECHO_N "(cached) $ECHO_C" >&6
7031 else
7032   if test -n "$LIPO"; then
7033   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7034 else
7035 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7036 for as_dir in $PATH
7037 do
7038   IFS=$as_save_IFS
7039   test -z "$as_dir" && as_dir=.
7040   for ac_exec_ext in '' $ac_executable_extensions; do
7041   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7042     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7043     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7044     break 2
7045   fi
7046 done
7047 done
7048
7049 fi
7050 fi
7051 LIPO=$ac_cv_prog_LIPO
7052 if test -n "$LIPO"; then
7053   echo "$as_me:$LINENO: result: $LIPO" >&5
7054 echo "${ECHO_T}$LIPO" >&6
7055 else
7056   echo "$as_me:$LINENO: result: no" >&5
7057 echo "${ECHO_T}no" >&6
7058 fi
7059
7060   fi
7061   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7062     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7063 set dummy ${ncn_progname}; ac_word=$2
7064 echo "$as_me:$LINENO: checking for $ac_word" >&5
7065 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7066 if test "${ac_cv_prog_LIPO+set}" = set; then
7067   echo $ECHO_N "(cached) $ECHO_C" >&6
7068 else
7069   if test -n "$LIPO"; then
7070   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7071 else
7072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7073 for as_dir in $PATH
7074 do
7075   IFS=$as_save_IFS
7076   test -z "$as_dir" && as_dir=.
7077   for ac_exec_ext in '' $ac_executable_extensions; do
7078   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7079     ac_cv_prog_LIPO="${ncn_progname}"
7080     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7081     break 2
7082   fi
7083 done
7084 done
7085
7086 fi
7087 fi
7088 LIPO=$ac_cv_prog_LIPO
7089 if test -n "$LIPO"; then
7090   echo "$as_me:$LINENO: result: $LIPO" >&5
7091 echo "${ECHO_T}$LIPO" >&6
7092 else
7093   echo "$as_me:$LINENO: result: no" >&5
7094 echo "${ECHO_T}no" >&6
7095 fi
7096
7097   fi
7098   test -n "$ac_cv_prog_LIPO" && break
7099 done
7100
7101 if test -z "$ac_cv_prog_LIPO" ; then
7102   set dummy lipo
7103   if test $build = $host ; then
7104     LIPO="$2"
7105   else
7106     LIPO="${ncn_tool_prefix}$2"
7107   fi
7108 fi
7109
7110
7111
7112 if test -n "$NM"; then
7113   ac_cv_prog_NM=$NM
7114 elif test -n "$ac_cv_prog_NM"; then
7115   NM=$ac_cv_prog_NM
7116 fi
7117
7118 if test -n "$ac_cv_prog_NM"; then
7119   for ncn_progname in nm; do
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_NM+set}" = set; then
7125   echo $ECHO_N "(cached) $ECHO_C" >&6
7126 else
7127   if test -n "$NM"; then
7128   ac_cv_prog_NM="$NM" # 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_NM="${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 NM=$ac_cv_prog_NM
7147 if test -n "$NM"; then
7148   echo "$as_me:$LINENO: result: $NM" >&5
7149 echo "${ECHO_T}$NM" >&6
7150 else
7151   echo "$as_me:$LINENO: result: no" >&5
7152 echo "${ECHO_T}no" >&6
7153 fi
7154
7155   done
7156 fi
7157
7158 for ncn_progname in nm; do
7159   if test -n "$ncn_tool_prefix"; then
7160     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7161 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7162 echo "$as_me:$LINENO: checking for $ac_word" >&5
7163 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7164 if test "${ac_cv_prog_NM+set}" = set; then
7165   echo $ECHO_N "(cached) $ECHO_C" >&6
7166 else
7167   if test -n "$NM"; then
7168   ac_cv_prog_NM="$NM" # Let the user override the test.
7169 else
7170 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7171 for as_dir in $PATH
7172 do
7173   IFS=$as_save_IFS
7174   test -z "$as_dir" && as_dir=.
7175   for ac_exec_ext in '' $ac_executable_extensions; do
7176   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7177     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7178     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7179     break 2
7180   fi
7181 done
7182 done
7183
7184 fi
7185 fi
7186 NM=$ac_cv_prog_NM
7187 if test -n "$NM"; then
7188   echo "$as_me:$LINENO: result: $NM" >&5
7189 echo "${ECHO_T}$NM" >&6
7190 else
7191   echo "$as_me:$LINENO: result: no" >&5
7192 echo "${ECHO_T}no" >&6
7193 fi
7194
7195   fi
7196   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7197     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7198 set dummy ${ncn_progname}; ac_word=$2
7199 echo "$as_me:$LINENO: checking for $ac_word" >&5
7200 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7201 if test "${ac_cv_prog_NM+set}" = set; then
7202   echo $ECHO_N "(cached) $ECHO_C" >&6
7203 else
7204   if test -n "$NM"; then
7205   ac_cv_prog_NM="$NM" # Let the user override the test.
7206 else
7207 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7208 for as_dir in $PATH
7209 do
7210   IFS=$as_save_IFS
7211   test -z "$as_dir" && as_dir=.
7212   for ac_exec_ext in '' $ac_executable_extensions; do
7213   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7214     ac_cv_prog_NM="${ncn_progname}"
7215     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7216     break 2
7217   fi
7218 done
7219 done
7220
7221 fi
7222 fi
7223 NM=$ac_cv_prog_NM
7224 if test -n "$NM"; then
7225   echo "$as_me:$LINENO: result: $NM" >&5
7226 echo "${ECHO_T}$NM" >&6
7227 else
7228   echo "$as_me:$LINENO: result: no" >&5
7229 echo "${ECHO_T}no" >&6
7230 fi
7231
7232   fi
7233   test -n "$ac_cv_prog_NM" && break
7234 done
7235
7236 if test -z "$ac_cv_prog_NM" ; then
7237   set dummy nm
7238   if test $build = $host ; then
7239     NM="$2"
7240   else
7241     NM="${ncn_tool_prefix}$2"
7242   fi
7243 fi
7244
7245
7246
7247 if test -n "$RANLIB"; then
7248   ac_cv_prog_RANLIB=$RANLIB
7249 elif test -n "$ac_cv_prog_RANLIB"; then
7250   RANLIB=$ac_cv_prog_RANLIB
7251 fi
7252
7253 if test -n "$ac_cv_prog_RANLIB"; then
7254   for ncn_progname in ranlib; do
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_RANLIB+set}" = set; then
7260   echo $ECHO_N "(cached) $ECHO_C" >&6
7261 else
7262   if test -n "$RANLIB"; then
7263   ac_cv_prog_RANLIB="$RANLIB" # 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_RANLIB="${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 RANLIB=$ac_cv_prog_RANLIB
7282 if test -n "$RANLIB"; then
7283   echo "$as_me:$LINENO: result: $RANLIB" >&5
7284 echo "${ECHO_T}$RANLIB" >&6
7285 else
7286   echo "$as_me:$LINENO: result: no" >&5
7287 echo "${ECHO_T}no" >&6
7288 fi
7289
7290   done
7291 fi
7292
7293 for ncn_progname in ranlib; do
7294   if test -n "$ncn_tool_prefix"; then
7295     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7296 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7297 echo "$as_me:$LINENO: checking for $ac_word" >&5
7298 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7299 if test "${ac_cv_prog_RANLIB+set}" = set; then
7300   echo $ECHO_N "(cached) $ECHO_C" >&6
7301 else
7302   if test -n "$RANLIB"; then
7303   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7304 else
7305 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7306 for as_dir in $PATH
7307 do
7308   IFS=$as_save_IFS
7309   test -z "$as_dir" && as_dir=.
7310   for ac_exec_ext in '' $ac_executable_extensions; do
7311   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7312     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7313     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7314     break 2
7315   fi
7316 done
7317 done
7318
7319 fi
7320 fi
7321 RANLIB=$ac_cv_prog_RANLIB
7322 if test -n "$RANLIB"; then
7323   echo "$as_me:$LINENO: result: $RANLIB" >&5
7324 echo "${ECHO_T}$RANLIB" >&6
7325 else
7326   echo "$as_me:$LINENO: result: no" >&5
7327 echo "${ECHO_T}no" >&6
7328 fi
7329
7330   fi
7331   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7332     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7333 set dummy ${ncn_progname}; ac_word=$2
7334 echo "$as_me:$LINENO: checking for $ac_word" >&5
7335 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7336 if test "${ac_cv_prog_RANLIB+set}" = set; then
7337   echo $ECHO_N "(cached) $ECHO_C" >&6
7338 else
7339   if test -n "$RANLIB"; then
7340   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7341 else
7342 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7343 for as_dir in $PATH
7344 do
7345   IFS=$as_save_IFS
7346   test -z "$as_dir" && as_dir=.
7347   for ac_exec_ext in '' $ac_executable_extensions; do
7348   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7349     ac_cv_prog_RANLIB="${ncn_progname}"
7350     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7351     break 2
7352   fi
7353 done
7354 done
7355
7356 fi
7357 fi
7358 RANLIB=$ac_cv_prog_RANLIB
7359 if test -n "$RANLIB"; then
7360   echo "$as_me:$LINENO: result: $RANLIB" >&5
7361 echo "${ECHO_T}$RANLIB" >&6
7362 else
7363   echo "$as_me:$LINENO: result: no" >&5
7364 echo "${ECHO_T}no" >&6
7365 fi
7366
7367   fi
7368   test -n "$ac_cv_prog_RANLIB" && break
7369 done
7370
7371 if test -z "$ac_cv_prog_RANLIB" ; then
7372   RANLIB=":"
7373 fi
7374
7375
7376
7377 if test -n "$STRIP"; then
7378   ac_cv_prog_STRIP=$STRIP
7379 elif test -n "$ac_cv_prog_STRIP"; then
7380   STRIP=$ac_cv_prog_STRIP
7381 fi
7382
7383 if test -n "$ac_cv_prog_STRIP"; then
7384   for ncn_progname in strip; do
7385     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7386 set dummy ${ncn_progname}; ac_word=$2
7387 echo "$as_me:$LINENO: checking for $ac_word" >&5
7388 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7389 if test "${ac_cv_prog_STRIP+set}" = set; then
7390   echo $ECHO_N "(cached) $ECHO_C" >&6
7391 else
7392   if test -n "$STRIP"; then
7393   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7394 else
7395 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7396 for as_dir in $PATH
7397 do
7398   IFS=$as_save_IFS
7399   test -z "$as_dir" && as_dir=.
7400   for ac_exec_ext in '' $ac_executable_extensions; do
7401   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7402     ac_cv_prog_STRIP="${ncn_progname}"
7403     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7404     break 2
7405   fi
7406 done
7407 done
7408
7409 fi
7410 fi
7411 STRIP=$ac_cv_prog_STRIP
7412 if test -n "$STRIP"; then
7413   echo "$as_me:$LINENO: result: $STRIP" >&5
7414 echo "${ECHO_T}$STRIP" >&6
7415 else
7416   echo "$as_me:$LINENO: result: no" >&5
7417 echo "${ECHO_T}no" >&6
7418 fi
7419
7420   done
7421 fi
7422
7423 for ncn_progname in strip; do
7424   if test -n "$ncn_tool_prefix"; then
7425     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7426 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7427 echo "$as_me:$LINENO: checking for $ac_word" >&5
7428 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7429 if test "${ac_cv_prog_STRIP+set}" = set; then
7430   echo $ECHO_N "(cached) $ECHO_C" >&6
7431 else
7432   if test -n "$STRIP"; then
7433   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7434 else
7435 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7436 for as_dir in $PATH
7437 do
7438   IFS=$as_save_IFS
7439   test -z "$as_dir" && as_dir=.
7440   for ac_exec_ext in '' $ac_executable_extensions; do
7441   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7442     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7443     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7444     break 2
7445   fi
7446 done
7447 done
7448
7449 fi
7450 fi
7451 STRIP=$ac_cv_prog_STRIP
7452 if test -n "$STRIP"; then
7453   echo "$as_me:$LINENO: result: $STRIP" >&5
7454 echo "${ECHO_T}$STRIP" >&6
7455 else
7456   echo "$as_me:$LINENO: result: no" >&5
7457 echo "${ECHO_T}no" >&6
7458 fi
7459
7460   fi
7461   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7462     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7463 set dummy ${ncn_progname}; ac_word=$2
7464 echo "$as_me:$LINENO: checking for $ac_word" >&5
7465 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7466 if test "${ac_cv_prog_STRIP+set}" = set; then
7467   echo $ECHO_N "(cached) $ECHO_C" >&6
7468 else
7469   if test -n "$STRIP"; then
7470   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7471 else
7472 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7473 for as_dir in $PATH
7474 do
7475   IFS=$as_save_IFS
7476   test -z "$as_dir" && as_dir=.
7477   for ac_exec_ext in '' $ac_executable_extensions; do
7478   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7479     ac_cv_prog_STRIP="${ncn_progname}"
7480     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7481     break 2
7482   fi
7483 done
7484 done
7485
7486 fi
7487 fi
7488 STRIP=$ac_cv_prog_STRIP
7489 if test -n "$STRIP"; then
7490   echo "$as_me:$LINENO: result: $STRIP" >&5
7491 echo "${ECHO_T}$STRIP" >&6
7492 else
7493   echo "$as_me:$LINENO: result: no" >&5
7494 echo "${ECHO_T}no" >&6
7495 fi
7496
7497   fi
7498   test -n "$ac_cv_prog_STRIP" && break
7499 done
7500
7501 if test -z "$ac_cv_prog_STRIP" ; then
7502   STRIP=":"
7503 fi
7504
7505
7506
7507 if test -n "$WINDRES"; then
7508   ac_cv_prog_WINDRES=$WINDRES
7509 elif test -n "$ac_cv_prog_WINDRES"; then
7510   WINDRES=$ac_cv_prog_WINDRES
7511 fi
7512
7513 if test -n "$ac_cv_prog_WINDRES"; then
7514   for ncn_progname in windres; do
7515     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7516 set dummy ${ncn_progname}; ac_word=$2
7517 echo "$as_me:$LINENO: checking for $ac_word" >&5
7518 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7519 if test "${ac_cv_prog_WINDRES+set}" = set; then
7520   echo $ECHO_N "(cached) $ECHO_C" >&6
7521 else
7522   if test -n "$WINDRES"; then
7523   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7524 else
7525 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7526 for as_dir in $PATH
7527 do
7528   IFS=$as_save_IFS
7529   test -z "$as_dir" && as_dir=.
7530   for ac_exec_ext in '' $ac_executable_extensions; do
7531   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7532     ac_cv_prog_WINDRES="${ncn_progname}"
7533     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7534     break 2
7535   fi
7536 done
7537 done
7538
7539 fi
7540 fi
7541 WINDRES=$ac_cv_prog_WINDRES
7542 if test -n "$WINDRES"; then
7543   echo "$as_me:$LINENO: result: $WINDRES" >&5
7544 echo "${ECHO_T}$WINDRES" >&6
7545 else
7546   echo "$as_me:$LINENO: result: no" >&5
7547 echo "${ECHO_T}no" >&6
7548 fi
7549
7550   done
7551 fi
7552
7553 for ncn_progname in windres; do
7554   if test -n "$ncn_tool_prefix"; then
7555     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7556 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7557 echo "$as_me:$LINENO: checking for $ac_word" >&5
7558 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7559 if test "${ac_cv_prog_WINDRES+set}" = set; then
7560   echo $ECHO_N "(cached) $ECHO_C" >&6
7561 else
7562   if test -n "$WINDRES"; then
7563   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7564 else
7565 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7566 for as_dir in $PATH
7567 do
7568   IFS=$as_save_IFS
7569   test -z "$as_dir" && as_dir=.
7570   for ac_exec_ext in '' $ac_executable_extensions; do
7571   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7572     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7573     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7574     break 2
7575   fi
7576 done
7577 done
7578
7579 fi
7580 fi
7581 WINDRES=$ac_cv_prog_WINDRES
7582 if test -n "$WINDRES"; then
7583   echo "$as_me:$LINENO: result: $WINDRES" >&5
7584 echo "${ECHO_T}$WINDRES" >&6
7585 else
7586   echo "$as_me:$LINENO: result: no" >&5
7587 echo "${ECHO_T}no" >&6
7588 fi
7589
7590   fi
7591   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7592     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7593 set dummy ${ncn_progname}; ac_word=$2
7594 echo "$as_me:$LINENO: checking for $ac_word" >&5
7595 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7596 if test "${ac_cv_prog_WINDRES+set}" = set; then
7597   echo $ECHO_N "(cached) $ECHO_C" >&6
7598 else
7599   if test -n "$WINDRES"; then
7600   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7601 else
7602 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7603 for as_dir in $PATH
7604 do
7605   IFS=$as_save_IFS
7606   test -z "$as_dir" && as_dir=.
7607   for ac_exec_ext in '' $ac_executable_extensions; do
7608   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7609     ac_cv_prog_WINDRES="${ncn_progname}"
7610     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7611     break 2
7612   fi
7613 done
7614 done
7615
7616 fi
7617 fi
7618 WINDRES=$ac_cv_prog_WINDRES
7619 if test -n "$WINDRES"; then
7620   echo "$as_me:$LINENO: result: $WINDRES" >&5
7621 echo "${ECHO_T}$WINDRES" >&6
7622 else
7623   echo "$as_me:$LINENO: result: no" >&5
7624 echo "${ECHO_T}no" >&6
7625 fi
7626
7627   fi
7628   test -n "$ac_cv_prog_WINDRES" && break
7629 done
7630
7631 if test -z "$ac_cv_prog_WINDRES" ; then
7632   set dummy windres
7633   if test $build = $host ; then
7634     WINDRES="$2"
7635   else
7636     WINDRES="${ncn_tool_prefix}$2"
7637   fi
7638 fi
7639
7640
7641
7642 if test -n "$WINDMC"; then
7643   ac_cv_prog_WINDMC=$WINDMC
7644 elif test -n "$ac_cv_prog_WINDMC"; then
7645   WINDMC=$ac_cv_prog_WINDMC
7646 fi
7647
7648 if test -n "$ac_cv_prog_WINDMC"; then
7649   for ncn_progname in windmc; do
7650     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7651 set dummy ${ncn_progname}; ac_word=$2
7652 echo "$as_me:$LINENO: checking for $ac_word" >&5
7653 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7654 if test "${ac_cv_prog_WINDMC+set}" = set; then
7655   echo $ECHO_N "(cached) $ECHO_C" >&6
7656 else
7657   if test -n "$WINDMC"; then
7658   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7659 else
7660 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7661 for as_dir in $PATH
7662 do
7663   IFS=$as_save_IFS
7664   test -z "$as_dir" && as_dir=.
7665   for ac_exec_ext in '' $ac_executable_extensions; do
7666   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7667     ac_cv_prog_WINDMC="${ncn_progname}"
7668     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7669     break 2
7670   fi
7671 done
7672 done
7673
7674 fi
7675 fi
7676 WINDMC=$ac_cv_prog_WINDMC
7677 if test -n "$WINDMC"; then
7678   echo "$as_me:$LINENO: result: $WINDMC" >&5
7679 echo "${ECHO_T}$WINDMC" >&6
7680 else
7681   echo "$as_me:$LINENO: result: no" >&5
7682 echo "${ECHO_T}no" >&6
7683 fi
7684
7685   done
7686 fi
7687
7688 for ncn_progname in windmc; do
7689   if test -n "$ncn_tool_prefix"; then
7690     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7691 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7692 echo "$as_me:$LINENO: checking for $ac_word" >&5
7693 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7694 if test "${ac_cv_prog_WINDMC+set}" = set; then
7695   echo $ECHO_N "(cached) $ECHO_C" >&6
7696 else
7697   if test -n "$WINDMC"; then
7698   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7699 else
7700 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7701 for as_dir in $PATH
7702 do
7703   IFS=$as_save_IFS
7704   test -z "$as_dir" && as_dir=.
7705   for ac_exec_ext in '' $ac_executable_extensions; do
7706   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7707     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7708     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7709     break 2
7710   fi
7711 done
7712 done
7713
7714 fi
7715 fi
7716 WINDMC=$ac_cv_prog_WINDMC
7717 if test -n "$WINDMC"; then
7718   echo "$as_me:$LINENO: result: $WINDMC" >&5
7719 echo "${ECHO_T}$WINDMC" >&6
7720 else
7721   echo "$as_me:$LINENO: result: no" >&5
7722 echo "${ECHO_T}no" >&6
7723 fi
7724
7725   fi
7726   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7727     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7728 set dummy ${ncn_progname}; ac_word=$2
7729 echo "$as_me:$LINENO: checking for $ac_word" >&5
7730 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7731 if test "${ac_cv_prog_WINDMC+set}" = set; then
7732   echo $ECHO_N "(cached) $ECHO_C" >&6
7733 else
7734   if test -n "$WINDMC"; then
7735   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7736 else
7737 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7738 for as_dir in $PATH
7739 do
7740   IFS=$as_save_IFS
7741   test -z "$as_dir" && as_dir=.
7742   for ac_exec_ext in '' $ac_executable_extensions; do
7743   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7744     ac_cv_prog_WINDMC="${ncn_progname}"
7745     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7746     break 2
7747   fi
7748 done
7749 done
7750
7751 fi
7752 fi
7753 WINDMC=$ac_cv_prog_WINDMC
7754 if test -n "$WINDMC"; then
7755   echo "$as_me:$LINENO: result: $WINDMC" >&5
7756 echo "${ECHO_T}$WINDMC" >&6
7757 else
7758   echo "$as_me:$LINENO: result: no" >&5
7759 echo "${ECHO_T}no" >&6
7760 fi
7761
7762   fi
7763   test -n "$ac_cv_prog_WINDMC" && break
7764 done
7765
7766 if test -z "$ac_cv_prog_WINDMC" ; then
7767   set dummy windmc
7768   if test $build = $host ; then
7769     WINDMC="$2"
7770   else
7771     WINDMC="${ncn_tool_prefix}$2"
7772   fi
7773 fi
7774
7775
7776
7777 if test -n "$OBJCOPY"; then
7778   ac_cv_prog_OBJCOPY=$OBJCOPY
7779 elif test -n "$ac_cv_prog_OBJCOPY"; then
7780   OBJCOPY=$ac_cv_prog_OBJCOPY
7781 fi
7782
7783 if test -n "$ac_cv_prog_OBJCOPY"; then
7784   for ncn_progname in objcopy; do
7785     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7786 set dummy ${ncn_progname}; ac_word=$2
7787 echo "$as_me:$LINENO: checking for $ac_word" >&5
7788 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7789 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7790   echo $ECHO_N "(cached) $ECHO_C" >&6
7791 else
7792   if test -n "$OBJCOPY"; then
7793   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7794 else
7795 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7796 for as_dir in $PATH
7797 do
7798   IFS=$as_save_IFS
7799   test -z "$as_dir" && as_dir=.
7800   for ac_exec_ext in '' $ac_executable_extensions; do
7801   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7802     ac_cv_prog_OBJCOPY="${ncn_progname}"
7803     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7804     break 2
7805   fi
7806 done
7807 done
7808
7809 fi
7810 fi
7811 OBJCOPY=$ac_cv_prog_OBJCOPY
7812 if test -n "$OBJCOPY"; then
7813   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7814 echo "${ECHO_T}$OBJCOPY" >&6
7815 else
7816   echo "$as_me:$LINENO: result: no" >&5
7817 echo "${ECHO_T}no" >&6
7818 fi
7819
7820   done
7821 fi
7822
7823 for ncn_progname in objcopy; do
7824   if test -n "$ncn_tool_prefix"; then
7825     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7826 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7827 echo "$as_me:$LINENO: checking for $ac_word" >&5
7828 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7829 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7830   echo $ECHO_N "(cached) $ECHO_C" >&6
7831 else
7832   if test -n "$OBJCOPY"; then
7833   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7834 else
7835 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7836 for as_dir in $PATH
7837 do
7838   IFS=$as_save_IFS
7839   test -z "$as_dir" && as_dir=.
7840   for ac_exec_ext in '' $ac_executable_extensions; do
7841   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7842     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7843     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7844     break 2
7845   fi
7846 done
7847 done
7848
7849 fi
7850 fi
7851 OBJCOPY=$ac_cv_prog_OBJCOPY
7852 if test -n "$OBJCOPY"; then
7853   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7854 echo "${ECHO_T}$OBJCOPY" >&6
7855 else
7856   echo "$as_me:$LINENO: result: no" >&5
7857 echo "${ECHO_T}no" >&6
7858 fi
7859
7860   fi
7861   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7862     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7863 set dummy ${ncn_progname}; ac_word=$2
7864 echo "$as_me:$LINENO: checking for $ac_word" >&5
7865 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7866 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7867   echo $ECHO_N "(cached) $ECHO_C" >&6
7868 else
7869   if test -n "$OBJCOPY"; then
7870   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7871 else
7872 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7873 for as_dir in $PATH
7874 do
7875   IFS=$as_save_IFS
7876   test -z "$as_dir" && as_dir=.
7877   for ac_exec_ext in '' $ac_executable_extensions; do
7878   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7879     ac_cv_prog_OBJCOPY="${ncn_progname}"
7880     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7881     break 2
7882   fi
7883 done
7884 done
7885
7886 fi
7887 fi
7888 OBJCOPY=$ac_cv_prog_OBJCOPY
7889 if test -n "$OBJCOPY"; then
7890   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7891 echo "${ECHO_T}$OBJCOPY" >&6
7892 else
7893   echo "$as_me:$LINENO: result: no" >&5
7894 echo "${ECHO_T}no" >&6
7895 fi
7896
7897   fi
7898   test -n "$ac_cv_prog_OBJCOPY" && break
7899 done
7900
7901 if test -z "$ac_cv_prog_OBJCOPY" ; then
7902   set dummy objcopy
7903   if test $build = $host ; then
7904     OBJCOPY="$2"
7905   else
7906     OBJCOPY="${ncn_tool_prefix}$2"
7907   fi
7908 fi
7909
7910
7911
7912 if test -n "$OBJDUMP"; then
7913   ac_cv_prog_OBJDUMP=$OBJDUMP
7914 elif test -n "$ac_cv_prog_OBJDUMP"; then
7915   OBJDUMP=$ac_cv_prog_OBJDUMP
7916 fi
7917
7918 if test -n "$ac_cv_prog_OBJDUMP"; then
7919   for ncn_progname in objdump; do
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_OBJDUMP+set}" = set; then
7925   echo $ECHO_N "(cached) $ECHO_C" >&6
7926 else
7927   if test -n "$OBJDUMP"; then
7928   ac_cv_prog_OBJDUMP="$OBJDUMP" # 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_OBJDUMP="${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 OBJDUMP=$ac_cv_prog_OBJDUMP
7947 if test -n "$OBJDUMP"; then
7948   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7949 echo "${ECHO_T}$OBJDUMP" >&6
7950 else
7951   echo "$as_me:$LINENO: result: no" >&5
7952 echo "${ECHO_T}no" >&6
7953 fi
7954
7955   done
7956 fi
7957
7958 for ncn_progname in objdump; do
7959   if test -n "$ncn_tool_prefix"; then
7960     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7961 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7962 echo "$as_me:$LINENO: checking for $ac_word" >&5
7963 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7964 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7965   echo $ECHO_N "(cached) $ECHO_C" >&6
7966 else
7967   if test -n "$OBJDUMP"; then
7968   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7969 else
7970 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7971 for as_dir in $PATH
7972 do
7973   IFS=$as_save_IFS
7974   test -z "$as_dir" && as_dir=.
7975   for ac_exec_ext in '' $ac_executable_extensions; do
7976   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7977     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7978     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7979     break 2
7980   fi
7981 done
7982 done
7983
7984 fi
7985 fi
7986 OBJDUMP=$ac_cv_prog_OBJDUMP
7987 if test -n "$OBJDUMP"; then
7988   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7989 echo "${ECHO_T}$OBJDUMP" >&6
7990 else
7991   echo "$as_me:$LINENO: result: no" >&5
7992 echo "${ECHO_T}no" >&6
7993 fi
7994
7995   fi
7996   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7997     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7998 set dummy ${ncn_progname}; ac_word=$2
7999 echo "$as_me:$LINENO: checking for $ac_word" >&5
8000 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8001 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8002   echo $ECHO_N "(cached) $ECHO_C" >&6
8003 else
8004   if test -n "$OBJDUMP"; then
8005   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8006 else
8007 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8008 for as_dir in $PATH
8009 do
8010   IFS=$as_save_IFS
8011   test -z "$as_dir" && as_dir=.
8012   for ac_exec_ext in '' $ac_executable_extensions; do
8013   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8014     ac_cv_prog_OBJDUMP="${ncn_progname}"
8015     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8016     break 2
8017   fi
8018 done
8019 done
8020
8021 fi
8022 fi
8023 OBJDUMP=$ac_cv_prog_OBJDUMP
8024 if test -n "$OBJDUMP"; then
8025   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8026 echo "${ECHO_T}$OBJDUMP" >&6
8027 else
8028   echo "$as_me:$LINENO: result: no" >&5
8029 echo "${ECHO_T}no" >&6
8030 fi
8031
8032   fi
8033   test -n "$ac_cv_prog_OBJDUMP" && break
8034 done
8035
8036 if test -z "$ac_cv_prog_OBJDUMP" ; then
8037   set dummy objdump
8038   if test $build = $host ; then
8039     OBJDUMP="$2"
8040   else
8041     OBJDUMP="${ncn_tool_prefix}$2"
8042   fi
8043 fi
8044
8045
8046
8047
8048
8049
8050 # Target tools.
8051
8052 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8053 if test "${with_build_time_tools+set}" = set; then
8054   withval="$with_build_time_tools"
8055   case x"$withval" in
8056      x/*) ;;
8057      *)
8058        with_build_time_tools=
8059        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8060 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8061        ;;
8062    esac
8063 else
8064   with_build_time_tools=
8065 fi;
8066
8067
8068
8069 if test -n "$CC_FOR_TARGET"; then
8070   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8071 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8072   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8073 fi
8074
8075 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8076   for ncn_progname in cc gcc; do
8077     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8078 set dummy ${ncn_progname}; ac_word=$2
8079 echo "$as_me:$LINENO: checking for $ac_word" >&5
8080 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8081 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8082   echo $ECHO_N "(cached) $ECHO_C" >&6
8083 else
8084   if test -n "$CC_FOR_TARGET"; then
8085   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8086 else
8087 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8088 for as_dir in $PATH
8089 do
8090   IFS=$as_save_IFS
8091   test -z "$as_dir" && as_dir=.
8092   for ac_exec_ext in '' $ac_executable_extensions; do
8093   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8094     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8095     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8096     break 2
8097   fi
8098 done
8099 done
8100
8101 fi
8102 fi
8103 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8104 if test -n "$CC_FOR_TARGET"; then
8105   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8106 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8107 else
8108   echo "$as_me:$LINENO: result: no" >&5
8109 echo "${ECHO_T}no" >&6
8110 fi
8111
8112   done
8113 fi
8114
8115 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8116   for ncn_progname in cc gcc; do
8117     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8118 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8119     if test -x $with_build_time_tools/${ncn_progname}; then
8120       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8121       echo "$as_me:$LINENO: result: yes" >&5
8122 echo "${ECHO_T}yes" >&6
8123       break
8124     else
8125       echo "$as_me:$LINENO: result: no" >&5
8126 echo "${ECHO_T}no" >&6
8127     fi
8128   done
8129 fi
8130
8131 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8132   for ncn_progname in cc gcc; do
8133     if test -n "$ncn_target_tool_prefix"; then
8134       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8135 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8136 echo "$as_me:$LINENO: checking for $ac_word" >&5
8137 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8138 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8139   echo $ECHO_N "(cached) $ECHO_C" >&6
8140 else
8141   if test -n "$CC_FOR_TARGET"; then
8142   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8143 else
8144 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8145 for as_dir in $PATH
8146 do
8147   IFS=$as_save_IFS
8148   test -z "$as_dir" && as_dir=.
8149   for ac_exec_ext in '' $ac_executable_extensions; do
8150   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8151     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8152     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8153     break 2
8154   fi
8155 done
8156 done
8157
8158 fi
8159 fi
8160 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8161 if test -n "$CC_FOR_TARGET"; then
8162   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8163 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8164 else
8165   echo "$as_me:$LINENO: result: no" >&5
8166 echo "${ECHO_T}no" >&6
8167 fi
8168
8169     fi
8170     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8171       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8172 set dummy ${ncn_progname}; ac_word=$2
8173 echo "$as_me:$LINENO: checking for $ac_word" >&5
8174 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8175 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8176   echo $ECHO_N "(cached) $ECHO_C" >&6
8177 else
8178   if test -n "$CC_FOR_TARGET"; then
8179   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8180 else
8181 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8182 for as_dir in $PATH
8183 do
8184   IFS=$as_save_IFS
8185   test -z "$as_dir" && as_dir=.
8186   for ac_exec_ext in '' $ac_executable_extensions; do
8187   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8188     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8189     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8190     break 2
8191   fi
8192 done
8193 done
8194
8195 fi
8196 fi
8197 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8198 if test -n "$CC_FOR_TARGET"; then
8199   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8200 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8201 else
8202   echo "$as_me:$LINENO: result: no" >&5
8203 echo "${ECHO_T}no" >&6
8204 fi
8205
8206     fi
8207     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8208   done
8209 fi
8210
8211 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8212   set dummy cc gcc
8213   if test $build = $target ; then
8214     CC_FOR_TARGET="$2"
8215   else
8216     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8217   fi
8218 else
8219   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8220 fi
8221
8222
8223
8224 if test -n "$CXX_FOR_TARGET"; then
8225   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8226 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8227   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8228 fi
8229
8230 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8231   for ncn_progname in c++ g++ cxx gxx; do
8232     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8233 set dummy ${ncn_progname}; ac_word=$2
8234 echo "$as_me:$LINENO: checking for $ac_word" >&5
8235 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8236 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8237   echo $ECHO_N "(cached) $ECHO_C" >&6
8238 else
8239   if test -n "$CXX_FOR_TARGET"; then
8240   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8241 else
8242 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8243 for as_dir in $PATH
8244 do
8245   IFS=$as_save_IFS
8246   test -z "$as_dir" && as_dir=.
8247   for ac_exec_ext in '' $ac_executable_extensions; do
8248   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8249     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8250     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8251     break 2
8252   fi
8253 done
8254 done
8255
8256 fi
8257 fi
8258 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8259 if test -n "$CXX_FOR_TARGET"; then
8260   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8261 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8262 else
8263   echo "$as_me:$LINENO: result: no" >&5
8264 echo "${ECHO_T}no" >&6
8265 fi
8266
8267   done
8268 fi
8269
8270 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8271   for ncn_progname in c++ g++ cxx gxx; do
8272     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8273 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8274     if test -x $with_build_time_tools/${ncn_progname}; then
8275       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8276       echo "$as_me:$LINENO: result: yes" >&5
8277 echo "${ECHO_T}yes" >&6
8278       break
8279     else
8280       echo "$as_me:$LINENO: result: no" >&5
8281 echo "${ECHO_T}no" >&6
8282     fi
8283   done
8284 fi
8285
8286 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8287   for ncn_progname in c++ g++ cxx gxx; do
8288     if test -n "$ncn_target_tool_prefix"; then
8289       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8290 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8291 echo "$as_me:$LINENO: checking for $ac_word" >&5
8292 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8293 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8294   echo $ECHO_N "(cached) $ECHO_C" >&6
8295 else
8296   if test -n "$CXX_FOR_TARGET"; then
8297   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8298 else
8299 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8300 for as_dir in $PATH
8301 do
8302   IFS=$as_save_IFS
8303   test -z "$as_dir" && as_dir=.
8304   for ac_exec_ext in '' $ac_executable_extensions; do
8305   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8306     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8307     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8308     break 2
8309   fi
8310 done
8311 done
8312
8313 fi
8314 fi
8315 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8316 if test -n "$CXX_FOR_TARGET"; then
8317   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8318 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8319 else
8320   echo "$as_me:$LINENO: result: no" >&5
8321 echo "${ECHO_T}no" >&6
8322 fi
8323
8324     fi
8325     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8326       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8327 set dummy ${ncn_progname}; ac_word=$2
8328 echo "$as_me:$LINENO: checking for $ac_word" >&5
8329 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8330 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8331   echo $ECHO_N "(cached) $ECHO_C" >&6
8332 else
8333   if test -n "$CXX_FOR_TARGET"; then
8334   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8335 else
8336 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8337 for as_dir in $PATH
8338 do
8339   IFS=$as_save_IFS
8340   test -z "$as_dir" && as_dir=.
8341   for ac_exec_ext in '' $ac_executable_extensions; do
8342   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8343     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8344     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8345     break 2
8346   fi
8347 done
8348 done
8349
8350 fi
8351 fi
8352 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8353 if test -n "$CXX_FOR_TARGET"; then
8354   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8355 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8356 else
8357   echo "$as_me:$LINENO: result: no" >&5
8358 echo "${ECHO_T}no" >&6
8359 fi
8360
8361     fi
8362     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8363   done
8364 fi
8365
8366 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8367   set dummy c++ g++ cxx gxx
8368   if test $build = $target ; then
8369     CXX_FOR_TARGET="$2"
8370   else
8371     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8372   fi
8373 else
8374   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8375 fi
8376
8377
8378
8379 if test -n "$GCC_FOR_TARGET"; then
8380   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8381 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8382   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8383 fi
8384
8385 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8386   for ncn_progname in gcc; do
8387     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8388 set dummy ${ncn_progname}; ac_word=$2
8389 echo "$as_me:$LINENO: checking for $ac_word" >&5
8390 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8391 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8392   echo $ECHO_N "(cached) $ECHO_C" >&6
8393 else
8394   if test -n "$GCC_FOR_TARGET"; then
8395   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8396 else
8397 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8398 for as_dir in $PATH
8399 do
8400   IFS=$as_save_IFS
8401   test -z "$as_dir" && as_dir=.
8402   for ac_exec_ext in '' $ac_executable_extensions; do
8403   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8404     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8405     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8406     break 2
8407   fi
8408 done
8409 done
8410
8411 fi
8412 fi
8413 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8414 if test -n "$GCC_FOR_TARGET"; then
8415   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8416 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8417 else
8418   echo "$as_me:$LINENO: result: no" >&5
8419 echo "${ECHO_T}no" >&6
8420 fi
8421
8422   done
8423 fi
8424
8425 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8426   for ncn_progname in gcc; do
8427     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8428 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8429     if test -x $with_build_time_tools/${ncn_progname}; then
8430       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8431       echo "$as_me:$LINENO: result: yes" >&5
8432 echo "${ECHO_T}yes" >&6
8433       break
8434     else
8435       echo "$as_me:$LINENO: result: no" >&5
8436 echo "${ECHO_T}no" >&6
8437     fi
8438   done
8439 fi
8440
8441 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8442   for ncn_progname in gcc; do
8443     if test -n "$ncn_target_tool_prefix"; then
8444       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8445 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8446 echo "$as_me:$LINENO: checking for $ac_word" >&5
8447 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8448 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8449   echo $ECHO_N "(cached) $ECHO_C" >&6
8450 else
8451   if test -n "$GCC_FOR_TARGET"; then
8452   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8453 else
8454 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8455 for as_dir in $PATH
8456 do
8457   IFS=$as_save_IFS
8458   test -z "$as_dir" && as_dir=.
8459   for ac_exec_ext in '' $ac_executable_extensions; do
8460   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8461     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8462     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8463     break 2
8464   fi
8465 done
8466 done
8467
8468 fi
8469 fi
8470 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8471 if test -n "$GCC_FOR_TARGET"; then
8472   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8473 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8474 else
8475   echo "$as_me:$LINENO: result: no" >&5
8476 echo "${ECHO_T}no" >&6
8477 fi
8478
8479     fi
8480     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8481       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8482 set dummy ${ncn_progname}; ac_word=$2
8483 echo "$as_me:$LINENO: checking for $ac_word" >&5
8484 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8485 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8486   echo $ECHO_N "(cached) $ECHO_C" >&6
8487 else
8488   if test -n "$GCC_FOR_TARGET"; then
8489   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8490 else
8491 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8492 for as_dir in $PATH
8493 do
8494   IFS=$as_save_IFS
8495   test -z "$as_dir" && as_dir=.
8496   for ac_exec_ext in '' $ac_executable_extensions; do
8497   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8498     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8499     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8500     break 2
8501   fi
8502 done
8503 done
8504
8505 fi
8506 fi
8507 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8508 if test -n "$GCC_FOR_TARGET"; then
8509   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8510 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8511 else
8512   echo "$as_me:$LINENO: result: no" >&5
8513 echo "${ECHO_T}no" >&6
8514 fi
8515
8516     fi
8517     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8518   done
8519 fi
8520
8521 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8522   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8523 else
8524   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8525 fi
8526
8527
8528
8529 if test -n "$GCJ_FOR_TARGET"; then
8530   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8531 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8532   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8533 fi
8534
8535 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8536   for ncn_progname in gcj; do
8537     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8538 set dummy ${ncn_progname}; ac_word=$2
8539 echo "$as_me:$LINENO: checking for $ac_word" >&5
8540 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8541 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8542   echo $ECHO_N "(cached) $ECHO_C" >&6
8543 else
8544   if test -n "$GCJ_FOR_TARGET"; then
8545   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8546 else
8547 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8548 for as_dir in $PATH
8549 do
8550   IFS=$as_save_IFS
8551   test -z "$as_dir" && as_dir=.
8552   for ac_exec_ext in '' $ac_executable_extensions; do
8553   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8554     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8555     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8556     break 2
8557   fi
8558 done
8559 done
8560
8561 fi
8562 fi
8563 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8564 if test -n "$GCJ_FOR_TARGET"; then
8565   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8566 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8567 else
8568   echo "$as_me:$LINENO: result: no" >&5
8569 echo "${ECHO_T}no" >&6
8570 fi
8571
8572   done
8573 fi
8574
8575 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8576   for ncn_progname in gcj; do
8577     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8578 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8579     if test -x $with_build_time_tools/${ncn_progname}; then
8580       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8581       echo "$as_me:$LINENO: result: yes" >&5
8582 echo "${ECHO_T}yes" >&6
8583       break
8584     else
8585       echo "$as_me:$LINENO: result: no" >&5
8586 echo "${ECHO_T}no" >&6
8587     fi
8588   done
8589 fi
8590
8591 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8592   for ncn_progname in gcj; do
8593     if test -n "$ncn_target_tool_prefix"; then
8594       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8595 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8596 echo "$as_me:$LINENO: checking for $ac_word" >&5
8597 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8598 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8599   echo $ECHO_N "(cached) $ECHO_C" >&6
8600 else
8601   if test -n "$GCJ_FOR_TARGET"; then
8602   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8603 else
8604 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8605 for as_dir in $PATH
8606 do
8607   IFS=$as_save_IFS
8608   test -z "$as_dir" && as_dir=.
8609   for ac_exec_ext in '' $ac_executable_extensions; do
8610   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8611     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8612     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8613     break 2
8614   fi
8615 done
8616 done
8617
8618 fi
8619 fi
8620 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8621 if test -n "$GCJ_FOR_TARGET"; then
8622   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8623 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8624 else
8625   echo "$as_me:$LINENO: result: no" >&5
8626 echo "${ECHO_T}no" >&6
8627 fi
8628
8629     fi
8630     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8631       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8632 set dummy ${ncn_progname}; ac_word=$2
8633 echo "$as_me:$LINENO: checking for $ac_word" >&5
8634 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8635 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8636   echo $ECHO_N "(cached) $ECHO_C" >&6
8637 else
8638   if test -n "$GCJ_FOR_TARGET"; then
8639   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8640 else
8641 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8642 for as_dir in $PATH
8643 do
8644   IFS=$as_save_IFS
8645   test -z "$as_dir" && as_dir=.
8646   for ac_exec_ext in '' $ac_executable_extensions; do
8647   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8648     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8649     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8650     break 2
8651   fi
8652 done
8653 done
8654
8655 fi
8656 fi
8657 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8658 if test -n "$GCJ_FOR_TARGET"; then
8659   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8660 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8661 else
8662   echo "$as_me:$LINENO: result: no" >&5
8663 echo "${ECHO_T}no" >&6
8664 fi
8665
8666     fi
8667     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8668   done
8669 fi
8670
8671 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8672   set dummy gcj
8673   if test $build = $target ; then
8674     GCJ_FOR_TARGET="$2"
8675   else
8676     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8677   fi
8678 else
8679   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8680 fi
8681
8682
8683
8684 if test -n "$GFORTRAN_FOR_TARGET"; then
8685   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8686 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8687   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8688 fi
8689
8690 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8691   for ncn_progname in gfortran; do
8692     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8693 set dummy ${ncn_progname}; ac_word=$2
8694 echo "$as_me:$LINENO: checking for $ac_word" >&5
8695 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8696 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8697   echo $ECHO_N "(cached) $ECHO_C" >&6
8698 else
8699   if test -n "$GFORTRAN_FOR_TARGET"; then
8700   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8701 else
8702 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8703 for as_dir in $PATH
8704 do
8705   IFS=$as_save_IFS
8706   test -z "$as_dir" && as_dir=.
8707   for ac_exec_ext in '' $ac_executable_extensions; do
8708   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8709     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8710     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8711     break 2
8712   fi
8713 done
8714 done
8715
8716 fi
8717 fi
8718 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8719 if test -n "$GFORTRAN_FOR_TARGET"; then
8720   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8721 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8722 else
8723   echo "$as_me:$LINENO: result: no" >&5
8724 echo "${ECHO_T}no" >&6
8725 fi
8726
8727   done
8728 fi
8729
8730 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8731   for ncn_progname in gfortran; do
8732     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8733 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8734     if test -x $with_build_time_tools/${ncn_progname}; then
8735       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8736       echo "$as_me:$LINENO: result: yes" >&5
8737 echo "${ECHO_T}yes" >&6
8738       break
8739     else
8740       echo "$as_me:$LINENO: result: no" >&5
8741 echo "${ECHO_T}no" >&6
8742     fi
8743   done
8744 fi
8745
8746 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8747   for ncn_progname in gfortran; do
8748     if test -n "$ncn_target_tool_prefix"; then
8749       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8750 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8751 echo "$as_me:$LINENO: checking for $ac_word" >&5
8752 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8753 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8754   echo $ECHO_N "(cached) $ECHO_C" >&6
8755 else
8756   if test -n "$GFORTRAN_FOR_TARGET"; then
8757   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8758 else
8759 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8760 for as_dir in $PATH
8761 do
8762   IFS=$as_save_IFS
8763   test -z "$as_dir" && as_dir=.
8764   for ac_exec_ext in '' $ac_executable_extensions; do
8765   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8766     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8767     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8768     break 2
8769   fi
8770 done
8771 done
8772
8773 fi
8774 fi
8775 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8776 if test -n "$GFORTRAN_FOR_TARGET"; then
8777   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8778 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8779 else
8780   echo "$as_me:$LINENO: result: no" >&5
8781 echo "${ECHO_T}no" >&6
8782 fi
8783
8784     fi
8785     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8786       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8787 set dummy ${ncn_progname}; ac_word=$2
8788 echo "$as_me:$LINENO: checking for $ac_word" >&5
8789 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8790 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8791   echo $ECHO_N "(cached) $ECHO_C" >&6
8792 else
8793   if test -n "$GFORTRAN_FOR_TARGET"; then
8794   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8795 else
8796 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8797 for as_dir in $PATH
8798 do
8799   IFS=$as_save_IFS
8800   test -z "$as_dir" && as_dir=.
8801   for ac_exec_ext in '' $ac_executable_extensions; do
8802   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8803     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8804     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8805     break 2
8806   fi
8807 done
8808 done
8809
8810 fi
8811 fi
8812 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8813 if test -n "$GFORTRAN_FOR_TARGET"; then
8814   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8815 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8816 else
8817   echo "$as_me:$LINENO: result: no" >&5
8818 echo "${ECHO_T}no" >&6
8819 fi
8820
8821     fi
8822     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8823   done
8824 fi
8825
8826 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8827   set dummy gfortran
8828   if test $build = $target ; then
8829     GFORTRAN_FOR_TARGET="$2"
8830   else
8831     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8832   fi
8833 else
8834   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8835 fi
8836
8837
8838
8839 cat > conftest.c << \EOF
8840 #ifdef __GNUC__
8841   gcc_yay;
8842 #endif
8843 EOF
8844 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8845   have_gcc_for_target=yes
8846 else
8847   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8848   have_gcc_for_target=no
8849 fi
8850 rm conftest.c
8851
8852
8853
8854
8855 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8856   if test -n "$with_build_time_tools"; then
8857     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8858 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8859     if test -x $with_build_time_tools/ar; then
8860       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8861       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8862       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8863 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8864     else
8865       echo "$as_me:$LINENO: result: no" >&5
8866 echo "${ECHO_T}no" >&6
8867     fi
8868   elif test $build != $host && test $have_gcc_for_target = yes; then
8869     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8870     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8871     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8872   fi
8873 fi
8874 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8875   # Extract the first word of "ar", so it can be a program name with args.
8876 set dummy ar; ac_word=$2
8877 echo "$as_me:$LINENO: checking for $ac_word" >&5
8878 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8879 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8880   echo $ECHO_N "(cached) $ECHO_C" >&6
8881 else
8882   case $AR_FOR_TARGET in
8883   [\\/]* | ?:[\\/]*)
8884   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8885   ;;
8886   *)
8887   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8888 for as_dir in $gcc_cv_tool_dirs
8889 do
8890   IFS=$as_save_IFS
8891   test -z "$as_dir" && as_dir=.
8892   for ac_exec_ext in '' $ac_executable_extensions; do
8893   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8894     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8895     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8896     break 2
8897   fi
8898 done
8899 done
8900
8901   ;;
8902 esac
8903 fi
8904 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8905
8906 if test -n "$AR_FOR_TARGET"; then
8907   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8908 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8909 else
8910   echo "$as_me:$LINENO: result: no" >&5
8911 echo "${ECHO_T}no" >&6
8912 fi
8913
8914 fi
8915 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8916
8917
8918 if test -n "$AR_FOR_TARGET"; then
8919   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8920 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8921   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8922 fi
8923
8924 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8925   for ncn_progname in ar; do
8926     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8927 set dummy ${ncn_progname}; ac_word=$2
8928 echo "$as_me:$LINENO: checking for $ac_word" >&5
8929 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8930 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8931   echo $ECHO_N "(cached) $ECHO_C" >&6
8932 else
8933   if test -n "$AR_FOR_TARGET"; then
8934   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8935 else
8936 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8937 for as_dir in $PATH
8938 do
8939   IFS=$as_save_IFS
8940   test -z "$as_dir" && as_dir=.
8941   for ac_exec_ext in '' $ac_executable_extensions; do
8942   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8943     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8944     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8945     break 2
8946   fi
8947 done
8948 done
8949
8950 fi
8951 fi
8952 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8953 if test -n "$AR_FOR_TARGET"; then
8954   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8955 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8956 else
8957   echo "$as_me:$LINENO: result: no" >&5
8958 echo "${ECHO_T}no" >&6
8959 fi
8960
8961   done
8962 fi
8963
8964 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8965   for ncn_progname in ar; do
8966     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8967 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8968     if test -x $with_build_time_tools/${ncn_progname}; then
8969       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8970       echo "$as_me:$LINENO: result: yes" >&5
8971 echo "${ECHO_T}yes" >&6
8972       break
8973     else
8974       echo "$as_me:$LINENO: result: no" >&5
8975 echo "${ECHO_T}no" >&6
8976     fi
8977   done
8978 fi
8979
8980 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8981   for ncn_progname in ar; do
8982     if test -n "$ncn_target_tool_prefix"; then
8983       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8984 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8985 echo "$as_me:$LINENO: checking for $ac_word" >&5
8986 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8987 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8988   echo $ECHO_N "(cached) $ECHO_C" >&6
8989 else
8990   if test -n "$AR_FOR_TARGET"; then
8991   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8992 else
8993 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8994 for as_dir in $PATH
8995 do
8996   IFS=$as_save_IFS
8997   test -z "$as_dir" && as_dir=.
8998   for ac_exec_ext in '' $ac_executable_extensions; do
8999   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9000     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9001     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9002     break 2
9003   fi
9004 done
9005 done
9006
9007 fi
9008 fi
9009 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9010 if test -n "$AR_FOR_TARGET"; then
9011   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9012 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9013 else
9014   echo "$as_me:$LINENO: result: no" >&5
9015 echo "${ECHO_T}no" >&6
9016 fi
9017
9018     fi
9019     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
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_AR_FOR_TARGET+set}" = set; then
9025   echo $ECHO_N "(cached) $ECHO_C" >&6
9026 else
9027   if test -n "$AR_FOR_TARGET"; then
9028   ac_cv_prog_AR_FOR_TARGET="$AR_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_AR_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 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9047 if test -n "$AR_FOR_TARGET"; then
9048   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9049 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9050 else
9051   echo "$as_me:$LINENO: result: no" >&5
9052 echo "${ECHO_T}no" >&6
9053 fi
9054
9055     fi
9056     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9057   done
9058 fi
9059
9060 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9061   set dummy ar
9062   if test $build = $target ; then
9063     AR_FOR_TARGET="$2"
9064   else
9065     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9066   fi
9067 else
9068   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9069 fi
9070
9071 else
9072   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9073 fi
9074
9075
9076
9077
9078 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9079   if test -n "$with_build_time_tools"; then
9080     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9081 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9082     if test -x $with_build_time_tools/as; then
9083       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9084       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9085       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9086 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9087     else
9088       echo "$as_me:$LINENO: result: no" >&5
9089 echo "${ECHO_T}no" >&6
9090     fi
9091   elif test $build != $host && test $have_gcc_for_target = yes; then
9092     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9093     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9094     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9095   fi
9096 fi
9097 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9098   # Extract the first word of "as", so it can be a program name with args.
9099 set dummy as; ac_word=$2
9100 echo "$as_me:$LINENO: checking for $ac_word" >&5
9101 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9102 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9103   echo $ECHO_N "(cached) $ECHO_C" >&6
9104 else
9105   case $AS_FOR_TARGET in
9106   [\\/]* | ?:[\\/]*)
9107   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9108   ;;
9109   *)
9110   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9111 for as_dir in $gcc_cv_tool_dirs
9112 do
9113   IFS=$as_save_IFS
9114   test -z "$as_dir" && as_dir=.
9115   for ac_exec_ext in '' $ac_executable_extensions; do
9116   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9117     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9118     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9119     break 2
9120   fi
9121 done
9122 done
9123
9124   ;;
9125 esac
9126 fi
9127 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9128
9129 if test -n "$AS_FOR_TARGET"; then
9130   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9131 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9132 else
9133   echo "$as_me:$LINENO: result: no" >&5
9134 echo "${ECHO_T}no" >&6
9135 fi
9136
9137 fi
9138 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9139
9140
9141 if test -n "$AS_FOR_TARGET"; then
9142   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9143 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9144   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9145 fi
9146
9147 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9148   for ncn_progname in as; do
9149     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9150 set dummy ${ncn_progname}; ac_word=$2
9151 echo "$as_me:$LINENO: checking for $ac_word" >&5
9152 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9153 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9154   echo $ECHO_N "(cached) $ECHO_C" >&6
9155 else
9156   if test -n "$AS_FOR_TARGET"; then
9157   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9158 else
9159 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9160 for as_dir in $PATH
9161 do
9162   IFS=$as_save_IFS
9163   test -z "$as_dir" && as_dir=.
9164   for ac_exec_ext in '' $ac_executable_extensions; do
9165   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9166     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9167     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9168     break 2
9169   fi
9170 done
9171 done
9172
9173 fi
9174 fi
9175 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9176 if test -n "$AS_FOR_TARGET"; then
9177   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9178 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9179 else
9180   echo "$as_me:$LINENO: result: no" >&5
9181 echo "${ECHO_T}no" >&6
9182 fi
9183
9184   done
9185 fi
9186
9187 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9188   for ncn_progname in as; do
9189     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9190 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9191     if test -x $with_build_time_tools/${ncn_progname}; then
9192       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9193       echo "$as_me:$LINENO: result: yes" >&5
9194 echo "${ECHO_T}yes" >&6
9195       break
9196     else
9197       echo "$as_me:$LINENO: result: no" >&5
9198 echo "${ECHO_T}no" >&6
9199     fi
9200   done
9201 fi
9202
9203 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9204   for ncn_progname in as; do
9205     if test -n "$ncn_target_tool_prefix"; then
9206       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9207 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9208 echo "$as_me:$LINENO: checking for $ac_word" >&5
9209 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9210 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9211   echo $ECHO_N "(cached) $ECHO_C" >&6
9212 else
9213   if test -n "$AS_FOR_TARGET"; then
9214   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9215 else
9216 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9217 for as_dir in $PATH
9218 do
9219   IFS=$as_save_IFS
9220   test -z "$as_dir" && as_dir=.
9221   for ac_exec_ext in '' $ac_executable_extensions; do
9222   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9223     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9224     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9225     break 2
9226   fi
9227 done
9228 done
9229
9230 fi
9231 fi
9232 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9233 if test -n "$AS_FOR_TARGET"; then
9234   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9235 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9236 else
9237   echo "$as_me:$LINENO: result: no" >&5
9238 echo "${ECHO_T}no" >&6
9239 fi
9240
9241     fi
9242     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9243       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9244 set dummy ${ncn_progname}; ac_word=$2
9245 echo "$as_me:$LINENO: checking for $ac_word" >&5
9246 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9247 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9248   echo $ECHO_N "(cached) $ECHO_C" >&6
9249 else
9250   if test -n "$AS_FOR_TARGET"; then
9251   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9252 else
9253 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9254 for as_dir in $PATH
9255 do
9256   IFS=$as_save_IFS
9257   test -z "$as_dir" && as_dir=.
9258   for ac_exec_ext in '' $ac_executable_extensions; do
9259   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9260     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9261     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9262     break 2
9263   fi
9264 done
9265 done
9266
9267 fi
9268 fi
9269 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9270 if test -n "$AS_FOR_TARGET"; then
9271   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9272 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9273 else
9274   echo "$as_me:$LINENO: result: no" >&5
9275 echo "${ECHO_T}no" >&6
9276 fi
9277
9278     fi
9279     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9280   done
9281 fi
9282
9283 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9284   set dummy as
9285   if test $build = $target ; then
9286     AS_FOR_TARGET="$2"
9287   else
9288     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9289   fi
9290 else
9291   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9292 fi
9293
9294 else
9295   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9296 fi
9297
9298
9299
9300
9301 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9302   if test -n "$with_build_time_tools"; then
9303     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9304 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9305     if test -x $with_build_time_tools/dlltool; then
9306       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9307       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9308       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9309 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9310     else
9311       echo "$as_me:$LINENO: result: no" >&5
9312 echo "${ECHO_T}no" >&6
9313     fi
9314   elif test $build != $host && test $have_gcc_for_target = yes; then
9315     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9316     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9317     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9318   fi
9319 fi
9320 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9321   # Extract the first word of "dlltool", so it can be a program name with args.
9322 set dummy dlltool; ac_word=$2
9323 echo "$as_me:$LINENO: checking for $ac_word" >&5
9324 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9325 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9326   echo $ECHO_N "(cached) $ECHO_C" >&6
9327 else
9328   case $DLLTOOL_FOR_TARGET in
9329   [\\/]* | ?:[\\/]*)
9330   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9331   ;;
9332   *)
9333   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9334 for as_dir in $gcc_cv_tool_dirs
9335 do
9336   IFS=$as_save_IFS
9337   test -z "$as_dir" && as_dir=.
9338   for ac_exec_ext in '' $ac_executable_extensions; do
9339   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9340     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9341     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9342     break 2
9343   fi
9344 done
9345 done
9346
9347   ;;
9348 esac
9349 fi
9350 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9351
9352 if test -n "$DLLTOOL_FOR_TARGET"; then
9353   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9354 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9355 else
9356   echo "$as_me:$LINENO: result: no" >&5
9357 echo "${ECHO_T}no" >&6
9358 fi
9359
9360 fi
9361 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9362
9363
9364 if test -n "$DLLTOOL_FOR_TARGET"; then
9365   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9366 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9367   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9368 fi
9369
9370 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9371   for ncn_progname in dlltool; do
9372     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9373 set dummy ${ncn_progname}; ac_word=$2
9374 echo "$as_me:$LINENO: checking for $ac_word" >&5
9375 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9376 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9377   echo $ECHO_N "(cached) $ECHO_C" >&6
9378 else
9379   if test -n "$DLLTOOL_FOR_TARGET"; then
9380   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9381 else
9382 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9383 for as_dir in $PATH
9384 do
9385   IFS=$as_save_IFS
9386   test -z "$as_dir" && as_dir=.
9387   for ac_exec_ext in '' $ac_executable_extensions; do
9388   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9389     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9390     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9391     break 2
9392   fi
9393 done
9394 done
9395
9396 fi
9397 fi
9398 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9399 if test -n "$DLLTOOL_FOR_TARGET"; then
9400   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9401 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9402 else
9403   echo "$as_me:$LINENO: result: no" >&5
9404 echo "${ECHO_T}no" >&6
9405 fi
9406
9407   done
9408 fi
9409
9410 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9411   for ncn_progname in dlltool; do
9412     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9413 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9414     if test -x $with_build_time_tools/${ncn_progname}; then
9415       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9416       echo "$as_me:$LINENO: result: yes" >&5
9417 echo "${ECHO_T}yes" >&6
9418       break
9419     else
9420       echo "$as_me:$LINENO: result: no" >&5
9421 echo "${ECHO_T}no" >&6
9422     fi
9423   done
9424 fi
9425
9426 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9427   for ncn_progname in dlltool; do
9428     if test -n "$ncn_target_tool_prefix"; then
9429       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9430 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9431 echo "$as_me:$LINENO: checking for $ac_word" >&5
9432 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9433 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9434   echo $ECHO_N "(cached) $ECHO_C" >&6
9435 else
9436   if test -n "$DLLTOOL_FOR_TARGET"; then
9437   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9438 else
9439 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9440 for as_dir in $PATH
9441 do
9442   IFS=$as_save_IFS
9443   test -z "$as_dir" && as_dir=.
9444   for ac_exec_ext in '' $ac_executable_extensions; do
9445   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9446     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9447     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9448     break 2
9449   fi
9450 done
9451 done
9452
9453 fi
9454 fi
9455 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9456 if test -n "$DLLTOOL_FOR_TARGET"; then
9457   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9458 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9459 else
9460   echo "$as_me:$LINENO: result: no" >&5
9461 echo "${ECHO_T}no" >&6
9462 fi
9463
9464     fi
9465     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9466       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9467 set dummy ${ncn_progname}; ac_word=$2
9468 echo "$as_me:$LINENO: checking for $ac_word" >&5
9469 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9470 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9471   echo $ECHO_N "(cached) $ECHO_C" >&6
9472 else
9473   if test -n "$DLLTOOL_FOR_TARGET"; then
9474   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9475 else
9476 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9477 for as_dir in $PATH
9478 do
9479   IFS=$as_save_IFS
9480   test -z "$as_dir" && as_dir=.
9481   for ac_exec_ext in '' $ac_executable_extensions; do
9482   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9483     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9484     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9485     break 2
9486   fi
9487 done
9488 done
9489
9490 fi
9491 fi
9492 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9493 if test -n "$DLLTOOL_FOR_TARGET"; then
9494   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9495 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9496 else
9497   echo "$as_me:$LINENO: result: no" >&5
9498 echo "${ECHO_T}no" >&6
9499 fi
9500
9501     fi
9502     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9503   done
9504 fi
9505
9506 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9507   set dummy dlltool
9508   if test $build = $target ; then
9509     DLLTOOL_FOR_TARGET="$2"
9510   else
9511     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9512   fi
9513 else
9514   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9515 fi
9516
9517 else
9518   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9519 fi
9520
9521
9522
9523
9524 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9525   if test -n "$with_build_time_tools"; then
9526     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9527 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9528     if test -x $with_build_time_tools/ld; then
9529       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9530       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9531       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9532 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9533     else
9534       echo "$as_me:$LINENO: result: no" >&5
9535 echo "${ECHO_T}no" >&6
9536     fi
9537   elif test $build != $host && test $have_gcc_for_target = yes; then
9538     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9539     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9540     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9541   fi
9542 fi
9543 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9544   # Extract the first word of "ld", so it can be a program name with args.
9545 set dummy ld; ac_word=$2
9546 echo "$as_me:$LINENO: checking for $ac_word" >&5
9547 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9548 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9549   echo $ECHO_N "(cached) $ECHO_C" >&6
9550 else
9551   case $LD_FOR_TARGET in
9552   [\\/]* | ?:[\\/]*)
9553   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9554   ;;
9555   *)
9556   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9557 for as_dir in $gcc_cv_tool_dirs
9558 do
9559   IFS=$as_save_IFS
9560   test -z "$as_dir" && as_dir=.
9561   for ac_exec_ext in '' $ac_executable_extensions; do
9562   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9563     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9564     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9565     break 2
9566   fi
9567 done
9568 done
9569
9570   ;;
9571 esac
9572 fi
9573 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9574
9575 if test -n "$LD_FOR_TARGET"; then
9576   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9577 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9578 else
9579   echo "$as_me:$LINENO: result: no" >&5
9580 echo "${ECHO_T}no" >&6
9581 fi
9582
9583 fi
9584 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9585
9586
9587 if test -n "$LD_FOR_TARGET"; then
9588   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9589 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9590   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9591 fi
9592
9593 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9594   for ncn_progname in ld; do
9595     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9596 set dummy ${ncn_progname}; ac_word=$2
9597 echo "$as_me:$LINENO: checking for $ac_word" >&5
9598 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9599 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9600   echo $ECHO_N "(cached) $ECHO_C" >&6
9601 else
9602   if test -n "$LD_FOR_TARGET"; then
9603   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9604 else
9605 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9606 for as_dir in $PATH
9607 do
9608   IFS=$as_save_IFS
9609   test -z "$as_dir" && as_dir=.
9610   for ac_exec_ext in '' $ac_executable_extensions; do
9611   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9612     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9613     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9614     break 2
9615   fi
9616 done
9617 done
9618
9619 fi
9620 fi
9621 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9622 if test -n "$LD_FOR_TARGET"; then
9623   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9624 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9625 else
9626   echo "$as_me:$LINENO: result: no" >&5
9627 echo "${ECHO_T}no" >&6
9628 fi
9629
9630   done
9631 fi
9632
9633 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9634   for ncn_progname in ld; do
9635     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9636 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9637     if test -x $with_build_time_tools/${ncn_progname}; then
9638       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9639       echo "$as_me:$LINENO: result: yes" >&5
9640 echo "${ECHO_T}yes" >&6
9641       break
9642     else
9643       echo "$as_me:$LINENO: result: no" >&5
9644 echo "${ECHO_T}no" >&6
9645     fi
9646   done
9647 fi
9648
9649 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9650   for ncn_progname in ld; do
9651     if test -n "$ncn_target_tool_prefix"; then
9652       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9653 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9654 echo "$as_me:$LINENO: checking for $ac_word" >&5
9655 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9656 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9657   echo $ECHO_N "(cached) $ECHO_C" >&6
9658 else
9659   if test -n "$LD_FOR_TARGET"; then
9660   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9661 else
9662 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9663 for as_dir in $PATH
9664 do
9665   IFS=$as_save_IFS
9666   test -z "$as_dir" && as_dir=.
9667   for ac_exec_ext in '' $ac_executable_extensions; do
9668   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9669     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9670     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9671     break 2
9672   fi
9673 done
9674 done
9675
9676 fi
9677 fi
9678 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9679 if test -n "$LD_FOR_TARGET"; then
9680   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9681 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9682 else
9683   echo "$as_me:$LINENO: result: no" >&5
9684 echo "${ECHO_T}no" >&6
9685 fi
9686
9687     fi
9688     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9689       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9690 set dummy ${ncn_progname}; ac_word=$2
9691 echo "$as_me:$LINENO: checking for $ac_word" >&5
9692 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9693 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9694   echo $ECHO_N "(cached) $ECHO_C" >&6
9695 else
9696   if test -n "$LD_FOR_TARGET"; then
9697   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9698 else
9699 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9700 for as_dir in $PATH
9701 do
9702   IFS=$as_save_IFS
9703   test -z "$as_dir" && as_dir=.
9704   for ac_exec_ext in '' $ac_executable_extensions; do
9705   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9706     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9707     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9708     break 2
9709   fi
9710 done
9711 done
9712
9713 fi
9714 fi
9715 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9716 if test -n "$LD_FOR_TARGET"; then
9717   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9718 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9719 else
9720   echo "$as_me:$LINENO: result: no" >&5
9721 echo "${ECHO_T}no" >&6
9722 fi
9723
9724     fi
9725     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9726   done
9727 fi
9728
9729 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9730   set dummy ld
9731   if test $build = $target ; then
9732     LD_FOR_TARGET="$2"
9733   else
9734     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9735   fi
9736 else
9737   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9738 fi
9739
9740 else
9741   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9742 fi
9743
9744
9745
9746
9747 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9748   if test -n "$with_build_time_tools"; then
9749     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9750 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9751     if test -x $with_build_time_tools/lipo; then
9752       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9753       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9754       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9755 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9756     else
9757       echo "$as_me:$LINENO: result: no" >&5
9758 echo "${ECHO_T}no" >&6
9759     fi
9760   elif test $build != $host && test $have_gcc_for_target = yes; then
9761     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9762     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9763     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9764   fi
9765 fi
9766 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9767   # Extract the first word of "lipo", so it can be a program name with args.
9768 set dummy lipo; ac_word=$2
9769 echo "$as_me:$LINENO: checking for $ac_word" >&5
9770 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9771 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9772   echo $ECHO_N "(cached) $ECHO_C" >&6
9773 else
9774   case $LIPO_FOR_TARGET in
9775   [\\/]* | ?:[\\/]*)
9776   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9777   ;;
9778   *)
9779   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9780 for as_dir in $gcc_cv_tool_dirs
9781 do
9782   IFS=$as_save_IFS
9783   test -z "$as_dir" && as_dir=.
9784   for ac_exec_ext in '' $ac_executable_extensions; do
9785   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9786     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9787     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9788     break 2
9789   fi
9790 done
9791 done
9792
9793   ;;
9794 esac
9795 fi
9796 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9797
9798 if test -n "$LIPO_FOR_TARGET"; then
9799   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9800 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9801 else
9802   echo "$as_me:$LINENO: result: no" >&5
9803 echo "${ECHO_T}no" >&6
9804 fi
9805
9806 fi
9807 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9808
9809
9810 if test -n "$LIPO_FOR_TARGET"; then
9811   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9812 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9813   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9814 fi
9815
9816 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9817   for ncn_progname in lipo; do
9818     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9819 set dummy ${ncn_progname}; ac_word=$2
9820 echo "$as_me:$LINENO: checking for $ac_word" >&5
9821 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9822 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9823   echo $ECHO_N "(cached) $ECHO_C" >&6
9824 else
9825   if test -n "$LIPO_FOR_TARGET"; then
9826   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9827 else
9828 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9829 for as_dir in $PATH
9830 do
9831   IFS=$as_save_IFS
9832   test -z "$as_dir" && as_dir=.
9833   for ac_exec_ext in '' $ac_executable_extensions; do
9834   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9835     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9836     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9837     break 2
9838   fi
9839 done
9840 done
9841
9842 fi
9843 fi
9844 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9845 if test -n "$LIPO_FOR_TARGET"; then
9846   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9847 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9848 else
9849   echo "$as_me:$LINENO: result: no" >&5
9850 echo "${ECHO_T}no" >&6
9851 fi
9852
9853   done
9854 fi
9855
9856 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9857   for ncn_progname in lipo; do
9858     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9859 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9860     if test -x $with_build_time_tools/${ncn_progname}; then
9861       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9862       echo "$as_me:$LINENO: result: yes" >&5
9863 echo "${ECHO_T}yes" >&6
9864       break
9865     else
9866       echo "$as_me:$LINENO: result: no" >&5
9867 echo "${ECHO_T}no" >&6
9868     fi
9869   done
9870 fi
9871
9872 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9873   for ncn_progname in lipo; do
9874     if test -n "$ncn_target_tool_prefix"; then
9875       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9876 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9877 echo "$as_me:$LINENO: checking for $ac_word" >&5
9878 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9879 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9880   echo $ECHO_N "(cached) $ECHO_C" >&6
9881 else
9882   if test -n "$LIPO_FOR_TARGET"; then
9883   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9884 else
9885 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9886 for as_dir in $PATH
9887 do
9888   IFS=$as_save_IFS
9889   test -z "$as_dir" && as_dir=.
9890   for ac_exec_ext in '' $ac_executable_extensions; do
9891   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9892     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9893     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9894     break 2
9895   fi
9896 done
9897 done
9898
9899 fi
9900 fi
9901 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9902 if test -n "$LIPO_FOR_TARGET"; then
9903   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9904 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9905 else
9906   echo "$as_me:$LINENO: result: no" >&5
9907 echo "${ECHO_T}no" >&6
9908 fi
9909
9910     fi
9911     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9912       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9913 set dummy ${ncn_progname}; ac_word=$2
9914 echo "$as_me:$LINENO: checking for $ac_word" >&5
9915 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9916 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9917   echo $ECHO_N "(cached) $ECHO_C" >&6
9918 else
9919   if test -n "$LIPO_FOR_TARGET"; then
9920   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9921 else
9922 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9923 for as_dir in $PATH
9924 do
9925   IFS=$as_save_IFS
9926   test -z "$as_dir" && as_dir=.
9927   for ac_exec_ext in '' $ac_executable_extensions; do
9928   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9929     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9930     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9931     break 2
9932   fi
9933 done
9934 done
9935
9936 fi
9937 fi
9938 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9939 if test -n "$LIPO_FOR_TARGET"; then
9940   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9941 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9942 else
9943   echo "$as_me:$LINENO: result: no" >&5
9944 echo "${ECHO_T}no" >&6
9945 fi
9946
9947     fi
9948     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9949   done
9950 fi
9951
9952 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9953   set dummy lipo
9954   if test $build = $target ; then
9955     LIPO_FOR_TARGET="$2"
9956   else
9957     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9958   fi
9959 else
9960   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9961 fi
9962
9963 else
9964   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9965 fi
9966
9967
9968
9969
9970 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9971   if test -n "$with_build_time_tools"; then
9972     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9973 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9974     if test -x $with_build_time_tools/nm; then
9975       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9976       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9977       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9978 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9979     else
9980       echo "$as_me:$LINENO: result: no" >&5
9981 echo "${ECHO_T}no" >&6
9982     fi
9983   elif test $build != $host && test $have_gcc_for_target = yes; then
9984     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9985     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
9986     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9987   fi
9988 fi
9989 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9990   # Extract the first word of "nm", so it can be a program name with args.
9991 set dummy nm; ac_word=$2
9992 echo "$as_me:$LINENO: checking for $ac_word" >&5
9993 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9994 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9995   echo $ECHO_N "(cached) $ECHO_C" >&6
9996 else
9997   case $NM_FOR_TARGET in
9998   [\\/]* | ?:[\\/]*)
9999   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10000   ;;
10001   *)
10002   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10003 for as_dir in $gcc_cv_tool_dirs
10004 do
10005   IFS=$as_save_IFS
10006   test -z "$as_dir" && as_dir=.
10007   for ac_exec_ext in '' $ac_executable_extensions; do
10008   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10009     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10010     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10011     break 2
10012   fi
10013 done
10014 done
10015
10016   ;;
10017 esac
10018 fi
10019 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10020
10021 if test -n "$NM_FOR_TARGET"; then
10022   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10023 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10024 else
10025   echo "$as_me:$LINENO: result: no" >&5
10026 echo "${ECHO_T}no" >&6
10027 fi
10028
10029 fi
10030 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10031
10032
10033 if test -n "$NM_FOR_TARGET"; then
10034   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10035 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10036   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10037 fi
10038
10039 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10040   for ncn_progname in nm; do
10041     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10042 set dummy ${ncn_progname}; ac_word=$2
10043 echo "$as_me:$LINENO: checking for $ac_word" >&5
10044 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10045 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10046   echo $ECHO_N "(cached) $ECHO_C" >&6
10047 else
10048   if test -n "$NM_FOR_TARGET"; then
10049   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10050 else
10051 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10052 for as_dir in $PATH
10053 do
10054   IFS=$as_save_IFS
10055   test -z "$as_dir" && as_dir=.
10056   for ac_exec_ext in '' $ac_executable_extensions; do
10057   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10058     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10059     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10060     break 2
10061   fi
10062 done
10063 done
10064
10065 fi
10066 fi
10067 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10068 if test -n "$NM_FOR_TARGET"; then
10069   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10070 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10071 else
10072   echo "$as_me:$LINENO: result: no" >&5
10073 echo "${ECHO_T}no" >&6
10074 fi
10075
10076   done
10077 fi
10078
10079 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10080   for ncn_progname in nm; do
10081     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10082 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10083     if test -x $with_build_time_tools/${ncn_progname}; then
10084       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10085       echo "$as_me:$LINENO: result: yes" >&5
10086 echo "${ECHO_T}yes" >&6
10087       break
10088     else
10089       echo "$as_me:$LINENO: result: no" >&5
10090 echo "${ECHO_T}no" >&6
10091     fi
10092   done
10093 fi
10094
10095 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10096   for ncn_progname in nm; do
10097     if test -n "$ncn_target_tool_prefix"; then
10098       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10099 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10100 echo "$as_me:$LINENO: checking for $ac_word" >&5
10101 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10102 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10103   echo $ECHO_N "(cached) $ECHO_C" >&6
10104 else
10105   if test -n "$NM_FOR_TARGET"; then
10106   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10107 else
10108 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10109 for as_dir in $PATH
10110 do
10111   IFS=$as_save_IFS
10112   test -z "$as_dir" && as_dir=.
10113   for ac_exec_ext in '' $ac_executable_extensions; do
10114   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10115     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10116     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10117     break 2
10118   fi
10119 done
10120 done
10121
10122 fi
10123 fi
10124 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10125 if test -n "$NM_FOR_TARGET"; then
10126   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10127 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10128 else
10129   echo "$as_me:$LINENO: result: no" >&5
10130 echo "${ECHO_T}no" >&6
10131 fi
10132
10133     fi
10134     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10135       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10136 set dummy ${ncn_progname}; ac_word=$2
10137 echo "$as_me:$LINENO: checking for $ac_word" >&5
10138 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10139 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10140   echo $ECHO_N "(cached) $ECHO_C" >&6
10141 else
10142   if test -n "$NM_FOR_TARGET"; then
10143   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10144 else
10145 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10146 for as_dir in $PATH
10147 do
10148   IFS=$as_save_IFS
10149   test -z "$as_dir" && as_dir=.
10150   for ac_exec_ext in '' $ac_executable_extensions; do
10151   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10152     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10153     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10154     break 2
10155   fi
10156 done
10157 done
10158
10159 fi
10160 fi
10161 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10162 if test -n "$NM_FOR_TARGET"; then
10163   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10164 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10165 else
10166   echo "$as_me:$LINENO: result: no" >&5
10167 echo "${ECHO_T}no" >&6
10168 fi
10169
10170     fi
10171     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10172   done
10173 fi
10174
10175 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10176   set dummy nm
10177   if test $build = $target ; then
10178     NM_FOR_TARGET="$2"
10179   else
10180     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10181   fi
10182 else
10183   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10184 fi
10185
10186 else
10187   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10188 fi
10189
10190
10191
10192
10193 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10194   if test -n "$with_build_time_tools"; then
10195     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10196 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10197     if test -x $with_build_time_tools/objdump; then
10198       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10199       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10200       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10201 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10202     else
10203       echo "$as_me:$LINENO: result: no" >&5
10204 echo "${ECHO_T}no" >&6
10205     fi
10206   elif test $build != $host && test $have_gcc_for_target = yes; then
10207     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10208     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10209     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10210   fi
10211 fi
10212 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10213   # Extract the first word of "objdump", so it can be a program name with args.
10214 set dummy objdump; ac_word=$2
10215 echo "$as_me:$LINENO: checking for $ac_word" >&5
10216 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10217 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10218   echo $ECHO_N "(cached) $ECHO_C" >&6
10219 else
10220   case $OBJDUMP_FOR_TARGET in
10221   [\\/]* | ?:[\\/]*)
10222   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10223   ;;
10224   *)
10225   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10226 for as_dir in $gcc_cv_tool_dirs
10227 do
10228   IFS=$as_save_IFS
10229   test -z "$as_dir" && as_dir=.
10230   for ac_exec_ext in '' $ac_executable_extensions; do
10231   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10232     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10233     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10234     break 2
10235   fi
10236 done
10237 done
10238
10239   ;;
10240 esac
10241 fi
10242 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10243
10244 if test -n "$OBJDUMP_FOR_TARGET"; then
10245   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10246 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10247 else
10248   echo "$as_me:$LINENO: result: no" >&5
10249 echo "${ECHO_T}no" >&6
10250 fi
10251
10252 fi
10253 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10254
10255
10256 if test -n "$OBJDUMP_FOR_TARGET"; then
10257   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10258 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10259   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10260 fi
10261
10262 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10263   for ncn_progname in objdump; do
10264     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10265 set dummy ${ncn_progname}; ac_word=$2
10266 echo "$as_me:$LINENO: checking for $ac_word" >&5
10267 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10268 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10269   echo $ECHO_N "(cached) $ECHO_C" >&6
10270 else
10271   if test -n "$OBJDUMP_FOR_TARGET"; then
10272   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10273 else
10274 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10275 for as_dir in $PATH
10276 do
10277   IFS=$as_save_IFS
10278   test -z "$as_dir" && as_dir=.
10279   for ac_exec_ext in '' $ac_executable_extensions; do
10280   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10281     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10282     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10283     break 2
10284   fi
10285 done
10286 done
10287
10288 fi
10289 fi
10290 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10291 if test -n "$OBJDUMP_FOR_TARGET"; then
10292   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10293 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10294 else
10295   echo "$as_me:$LINENO: result: no" >&5
10296 echo "${ECHO_T}no" >&6
10297 fi
10298
10299   done
10300 fi
10301
10302 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10303   for ncn_progname in objdump; do
10304     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10305 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10306     if test -x $with_build_time_tools/${ncn_progname}; then
10307       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10308       echo "$as_me:$LINENO: result: yes" >&5
10309 echo "${ECHO_T}yes" >&6
10310       break
10311     else
10312       echo "$as_me:$LINENO: result: no" >&5
10313 echo "${ECHO_T}no" >&6
10314     fi
10315   done
10316 fi
10317
10318 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10319   for ncn_progname in objdump; do
10320     if test -n "$ncn_target_tool_prefix"; then
10321       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10322 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10323 echo "$as_me:$LINENO: checking for $ac_word" >&5
10324 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10325 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10326   echo $ECHO_N "(cached) $ECHO_C" >&6
10327 else
10328   if test -n "$OBJDUMP_FOR_TARGET"; then
10329   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10330 else
10331 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10332 for as_dir in $PATH
10333 do
10334   IFS=$as_save_IFS
10335   test -z "$as_dir" && as_dir=.
10336   for ac_exec_ext in '' $ac_executable_extensions; do
10337   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10338     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10339     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10340     break 2
10341   fi
10342 done
10343 done
10344
10345 fi
10346 fi
10347 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10348 if test -n "$OBJDUMP_FOR_TARGET"; then
10349   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10350 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10351 else
10352   echo "$as_me:$LINENO: result: no" >&5
10353 echo "${ECHO_T}no" >&6
10354 fi
10355
10356     fi
10357     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10358       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10359 set dummy ${ncn_progname}; ac_word=$2
10360 echo "$as_me:$LINENO: checking for $ac_word" >&5
10361 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10362 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10363   echo $ECHO_N "(cached) $ECHO_C" >&6
10364 else
10365   if test -n "$OBJDUMP_FOR_TARGET"; then
10366   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10367 else
10368 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10369 for as_dir in $PATH
10370 do
10371   IFS=$as_save_IFS
10372   test -z "$as_dir" && as_dir=.
10373   for ac_exec_ext in '' $ac_executable_extensions; do
10374   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10375     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10376     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10377     break 2
10378   fi
10379 done
10380 done
10381
10382 fi
10383 fi
10384 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10385 if test -n "$OBJDUMP_FOR_TARGET"; then
10386   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10387 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10388 else
10389   echo "$as_me:$LINENO: result: no" >&5
10390 echo "${ECHO_T}no" >&6
10391 fi
10392
10393     fi
10394     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10395   done
10396 fi
10397
10398 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10399   set dummy objdump
10400   if test $build = $target ; then
10401     OBJDUMP_FOR_TARGET="$2"
10402   else
10403     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10404   fi
10405 else
10406   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10407 fi
10408
10409 else
10410   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10411 fi
10412
10413
10414
10415
10416 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10417   if test -n "$with_build_time_tools"; then
10418     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10419 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10420     if test -x $with_build_time_tools/ranlib; then
10421       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10422       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10423       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10424 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10425     else
10426       echo "$as_me:$LINENO: result: no" >&5
10427 echo "${ECHO_T}no" >&6
10428     fi
10429   elif test $build != $host && test $have_gcc_for_target = yes; then
10430     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10431     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10432     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10433   fi
10434 fi
10435 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10436   # Extract the first word of "ranlib", so it can be a program name with args.
10437 set dummy ranlib; ac_word=$2
10438 echo "$as_me:$LINENO: checking for $ac_word" >&5
10439 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10440 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10441   echo $ECHO_N "(cached) $ECHO_C" >&6
10442 else
10443   case $RANLIB_FOR_TARGET in
10444   [\\/]* | ?:[\\/]*)
10445   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10446   ;;
10447   *)
10448   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10449 for as_dir in $gcc_cv_tool_dirs
10450 do
10451   IFS=$as_save_IFS
10452   test -z "$as_dir" && as_dir=.
10453   for ac_exec_ext in '' $ac_executable_extensions; do
10454   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10455     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10456     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10457     break 2
10458   fi
10459 done
10460 done
10461
10462   ;;
10463 esac
10464 fi
10465 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10466
10467 if test -n "$RANLIB_FOR_TARGET"; then
10468   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10469 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10470 else
10471   echo "$as_me:$LINENO: result: no" >&5
10472 echo "${ECHO_T}no" >&6
10473 fi
10474
10475 fi
10476 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10477
10478
10479 if test -n "$RANLIB_FOR_TARGET"; then
10480   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10481 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10482   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10483 fi
10484
10485 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10486   for ncn_progname in ranlib; do
10487     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10488 set dummy ${ncn_progname}; ac_word=$2
10489 echo "$as_me:$LINENO: checking for $ac_word" >&5
10490 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10491 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10492   echo $ECHO_N "(cached) $ECHO_C" >&6
10493 else
10494   if test -n "$RANLIB_FOR_TARGET"; then
10495   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10496 else
10497 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10498 for as_dir in $PATH
10499 do
10500   IFS=$as_save_IFS
10501   test -z "$as_dir" && as_dir=.
10502   for ac_exec_ext in '' $ac_executable_extensions; do
10503   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10504     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10505     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10506     break 2
10507   fi
10508 done
10509 done
10510
10511 fi
10512 fi
10513 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10514 if test -n "$RANLIB_FOR_TARGET"; then
10515   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10516 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10517 else
10518   echo "$as_me:$LINENO: result: no" >&5
10519 echo "${ECHO_T}no" >&6
10520 fi
10521
10522   done
10523 fi
10524
10525 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10526   for ncn_progname in ranlib; do
10527     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10528 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10529     if test -x $with_build_time_tools/${ncn_progname}; then
10530       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10531       echo "$as_me:$LINENO: result: yes" >&5
10532 echo "${ECHO_T}yes" >&6
10533       break
10534     else
10535       echo "$as_me:$LINENO: result: no" >&5
10536 echo "${ECHO_T}no" >&6
10537     fi
10538   done
10539 fi
10540
10541 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10542   for ncn_progname in ranlib; do
10543     if test -n "$ncn_target_tool_prefix"; then
10544       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10545 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10546 echo "$as_me:$LINENO: checking for $ac_word" >&5
10547 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10548 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10549   echo $ECHO_N "(cached) $ECHO_C" >&6
10550 else
10551   if test -n "$RANLIB_FOR_TARGET"; then
10552   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10553 else
10554 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10555 for as_dir in $PATH
10556 do
10557   IFS=$as_save_IFS
10558   test -z "$as_dir" && as_dir=.
10559   for ac_exec_ext in '' $ac_executable_extensions; do
10560   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10561     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10562     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10563     break 2
10564   fi
10565 done
10566 done
10567
10568 fi
10569 fi
10570 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10571 if test -n "$RANLIB_FOR_TARGET"; then
10572   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10573 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10574 else
10575   echo "$as_me:$LINENO: result: no" >&5
10576 echo "${ECHO_T}no" >&6
10577 fi
10578
10579     fi
10580     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10581       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10582 set dummy ${ncn_progname}; ac_word=$2
10583 echo "$as_me:$LINENO: checking for $ac_word" >&5
10584 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10585 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10586   echo $ECHO_N "(cached) $ECHO_C" >&6
10587 else
10588   if test -n "$RANLIB_FOR_TARGET"; then
10589   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10590 else
10591 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10592 for as_dir in $PATH
10593 do
10594   IFS=$as_save_IFS
10595   test -z "$as_dir" && as_dir=.
10596   for ac_exec_ext in '' $ac_executable_extensions; do
10597   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10598     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10599     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10600     break 2
10601   fi
10602 done
10603 done
10604
10605 fi
10606 fi
10607 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10608 if test -n "$RANLIB_FOR_TARGET"; then
10609   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10610 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10611 else
10612   echo "$as_me:$LINENO: result: no" >&5
10613 echo "${ECHO_T}no" >&6
10614 fi
10615
10616     fi
10617     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10618   done
10619 fi
10620
10621 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10622   set dummy ranlib
10623   if test $build = $target ; then
10624     RANLIB_FOR_TARGET="$2"
10625   else
10626     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10627   fi
10628 else
10629   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10630 fi
10631
10632 else
10633   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10634 fi
10635
10636
10637
10638
10639 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10640   if test -n "$with_build_time_tools"; then
10641     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10642 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10643     if test -x $with_build_time_tools/strip; then
10644       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10645       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10646       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10647 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10648     else
10649       echo "$as_me:$LINENO: result: no" >&5
10650 echo "${ECHO_T}no" >&6
10651     fi
10652   elif test $build != $host && test $have_gcc_for_target = yes; then
10653     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10654     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10655     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10656   fi
10657 fi
10658 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10659   # Extract the first word of "strip", so it can be a program name with args.
10660 set dummy strip; ac_word=$2
10661 echo "$as_me:$LINENO: checking for $ac_word" >&5
10662 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10663 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10664   echo $ECHO_N "(cached) $ECHO_C" >&6
10665 else
10666   case $STRIP_FOR_TARGET in
10667   [\\/]* | ?:[\\/]*)
10668   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10669   ;;
10670   *)
10671   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10672 for as_dir in $gcc_cv_tool_dirs
10673 do
10674   IFS=$as_save_IFS
10675   test -z "$as_dir" && as_dir=.
10676   for ac_exec_ext in '' $ac_executable_extensions; do
10677   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10678     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10679     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10680     break 2
10681   fi
10682 done
10683 done
10684
10685   ;;
10686 esac
10687 fi
10688 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10689
10690 if test -n "$STRIP_FOR_TARGET"; then
10691   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10692 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10693 else
10694   echo "$as_me:$LINENO: result: no" >&5
10695 echo "${ECHO_T}no" >&6
10696 fi
10697
10698 fi
10699 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10700
10701
10702 if test -n "$STRIP_FOR_TARGET"; then
10703   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10704 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10705   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10706 fi
10707
10708 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10709   for ncn_progname in strip; do
10710     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10711 set dummy ${ncn_progname}; ac_word=$2
10712 echo "$as_me:$LINENO: checking for $ac_word" >&5
10713 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10714 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10715   echo $ECHO_N "(cached) $ECHO_C" >&6
10716 else
10717   if test -n "$STRIP_FOR_TARGET"; then
10718   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10719 else
10720 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10721 for as_dir in $PATH
10722 do
10723   IFS=$as_save_IFS
10724   test -z "$as_dir" && as_dir=.
10725   for ac_exec_ext in '' $ac_executable_extensions; do
10726   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10727     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10728     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10729     break 2
10730   fi
10731 done
10732 done
10733
10734 fi
10735 fi
10736 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10737 if test -n "$STRIP_FOR_TARGET"; then
10738   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10739 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10740 else
10741   echo "$as_me:$LINENO: result: no" >&5
10742 echo "${ECHO_T}no" >&6
10743 fi
10744
10745   done
10746 fi
10747
10748 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10749   for ncn_progname in strip; do
10750     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10751 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10752     if test -x $with_build_time_tools/${ncn_progname}; then
10753       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10754       echo "$as_me:$LINENO: result: yes" >&5
10755 echo "${ECHO_T}yes" >&6
10756       break
10757     else
10758       echo "$as_me:$LINENO: result: no" >&5
10759 echo "${ECHO_T}no" >&6
10760     fi
10761   done
10762 fi
10763
10764 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10765   for ncn_progname in strip; do
10766     if test -n "$ncn_target_tool_prefix"; then
10767       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10768 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10769 echo "$as_me:$LINENO: checking for $ac_word" >&5
10770 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10771 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10772   echo $ECHO_N "(cached) $ECHO_C" >&6
10773 else
10774   if test -n "$STRIP_FOR_TARGET"; then
10775   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10776 else
10777 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10778 for as_dir in $PATH
10779 do
10780   IFS=$as_save_IFS
10781   test -z "$as_dir" && as_dir=.
10782   for ac_exec_ext in '' $ac_executable_extensions; do
10783   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10784     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10785     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10786     break 2
10787   fi
10788 done
10789 done
10790
10791 fi
10792 fi
10793 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10794 if test -n "$STRIP_FOR_TARGET"; then
10795   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10796 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10797 else
10798   echo "$as_me:$LINENO: result: no" >&5
10799 echo "${ECHO_T}no" >&6
10800 fi
10801
10802     fi
10803     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10804       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10805 set dummy ${ncn_progname}; ac_word=$2
10806 echo "$as_me:$LINENO: checking for $ac_word" >&5
10807 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10808 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10809   echo $ECHO_N "(cached) $ECHO_C" >&6
10810 else
10811   if test -n "$STRIP_FOR_TARGET"; then
10812   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10813 else
10814 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10815 for as_dir in $PATH
10816 do
10817   IFS=$as_save_IFS
10818   test -z "$as_dir" && as_dir=.
10819   for ac_exec_ext in '' $ac_executable_extensions; do
10820   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10821     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10822     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10823     break 2
10824   fi
10825 done
10826 done
10827
10828 fi
10829 fi
10830 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10831 if test -n "$STRIP_FOR_TARGET"; then
10832   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10833 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10834 else
10835   echo "$as_me:$LINENO: result: no" >&5
10836 echo "${ECHO_T}no" >&6
10837 fi
10838
10839     fi
10840     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10841   done
10842 fi
10843
10844 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10845   set dummy strip
10846   if test $build = $target ; then
10847     STRIP_FOR_TARGET="$2"
10848   else
10849     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10850   fi
10851 else
10852   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10853 fi
10854
10855 else
10856   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10857 fi
10858
10859
10860
10861
10862 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10863   if test -n "$with_build_time_tools"; then
10864     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10865 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10866     if test -x $with_build_time_tools/windres; then
10867       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10868       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10869       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10870 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10871     else
10872       echo "$as_me:$LINENO: result: no" >&5
10873 echo "${ECHO_T}no" >&6
10874     fi
10875   elif test $build != $host && test $have_gcc_for_target = yes; then
10876     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10877     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10878     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10879   fi
10880 fi
10881 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10882   # Extract the first word of "windres", so it can be a program name with args.
10883 set dummy windres; ac_word=$2
10884 echo "$as_me:$LINENO: checking for $ac_word" >&5
10885 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10886 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10887   echo $ECHO_N "(cached) $ECHO_C" >&6
10888 else
10889   case $WINDRES_FOR_TARGET in
10890   [\\/]* | ?:[\\/]*)
10891   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10892   ;;
10893   *)
10894   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10895 for as_dir in $gcc_cv_tool_dirs
10896 do
10897   IFS=$as_save_IFS
10898   test -z "$as_dir" && as_dir=.
10899   for ac_exec_ext in '' $ac_executable_extensions; do
10900   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10901     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10902     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10903     break 2
10904   fi
10905 done
10906 done
10907
10908   ;;
10909 esac
10910 fi
10911 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10912
10913 if test -n "$WINDRES_FOR_TARGET"; then
10914   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10915 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10916 else
10917   echo "$as_me:$LINENO: result: no" >&5
10918 echo "${ECHO_T}no" >&6
10919 fi
10920
10921 fi
10922 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10923
10924
10925 if test -n "$WINDRES_FOR_TARGET"; then
10926   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10927 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10928   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10929 fi
10930
10931 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10932   for ncn_progname in windres; do
10933     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10934 set dummy ${ncn_progname}; ac_word=$2
10935 echo "$as_me:$LINENO: checking for $ac_word" >&5
10936 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10937 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10938   echo $ECHO_N "(cached) $ECHO_C" >&6
10939 else
10940   if test -n "$WINDRES_FOR_TARGET"; then
10941   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10942 else
10943 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10944 for as_dir in $PATH
10945 do
10946   IFS=$as_save_IFS
10947   test -z "$as_dir" && as_dir=.
10948   for ac_exec_ext in '' $ac_executable_extensions; do
10949   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10950     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10951     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10952     break 2
10953   fi
10954 done
10955 done
10956
10957 fi
10958 fi
10959 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10960 if test -n "$WINDRES_FOR_TARGET"; then
10961   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10962 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10963 else
10964   echo "$as_me:$LINENO: result: no" >&5
10965 echo "${ECHO_T}no" >&6
10966 fi
10967
10968   done
10969 fi
10970
10971 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10972   for ncn_progname in windres; do
10973     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10974 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10975     if test -x $with_build_time_tools/${ncn_progname}; then
10976       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10977       echo "$as_me:$LINENO: result: yes" >&5
10978 echo "${ECHO_T}yes" >&6
10979       break
10980     else
10981       echo "$as_me:$LINENO: result: no" >&5
10982 echo "${ECHO_T}no" >&6
10983     fi
10984   done
10985 fi
10986
10987 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10988   for ncn_progname in windres; do
10989     if test -n "$ncn_target_tool_prefix"; then
10990       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10991 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10992 echo "$as_me:$LINENO: checking for $ac_word" >&5
10993 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10994 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10995   echo $ECHO_N "(cached) $ECHO_C" >&6
10996 else
10997   if test -n "$WINDRES_FOR_TARGET"; then
10998   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10999 else
11000 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11001 for as_dir in $PATH
11002 do
11003   IFS=$as_save_IFS
11004   test -z "$as_dir" && as_dir=.
11005   for ac_exec_ext in '' $ac_executable_extensions; do
11006   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11007     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11008     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11009     break 2
11010   fi
11011 done
11012 done
11013
11014 fi
11015 fi
11016 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11017 if test -n "$WINDRES_FOR_TARGET"; then
11018   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11019 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11020 else
11021   echo "$as_me:$LINENO: result: no" >&5
11022 echo "${ECHO_T}no" >&6
11023 fi
11024
11025     fi
11026     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11027       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11028 set dummy ${ncn_progname}; ac_word=$2
11029 echo "$as_me:$LINENO: checking for $ac_word" >&5
11030 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11031 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11032   echo $ECHO_N "(cached) $ECHO_C" >&6
11033 else
11034   if test -n "$WINDRES_FOR_TARGET"; then
11035   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11036 else
11037 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11038 for as_dir in $PATH
11039 do
11040   IFS=$as_save_IFS
11041   test -z "$as_dir" && as_dir=.
11042   for ac_exec_ext in '' $ac_executable_extensions; do
11043   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11044     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11045     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11046     break 2
11047   fi
11048 done
11049 done
11050
11051 fi
11052 fi
11053 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11054 if test -n "$WINDRES_FOR_TARGET"; then
11055   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11056 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11057 else
11058   echo "$as_me:$LINENO: result: no" >&5
11059 echo "${ECHO_T}no" >&6
11060 fi
11061
11062     fi
11063     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11064   done
11065 fi
11066
11067 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11068   set dummy windres
11069   if test $build = $target ; then
11070     WINDRES_FOR_TARGET="$2"
11071   else
11072     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11073   fi
11074 else
11075   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11076 fi
11077
11078 else
11079   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11080 fi
11081
11082
11083
11084
11085 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11086   if test -n "$with_build_time_tools"; then
11087     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11088 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11089     if test -x $with_build_time_tools/windmc; then
11090       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11091       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11092       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11093 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11094     else
11095       echo "$as_me:$LINENO: result: no" >&5
11096 echo "${ECHO_T}no" >&6
11097     fi
11098   elif test $build != $host && test $have_gcc_for_target = yes; then
11099     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11100     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11101     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11102   fi
11103 fi
11104 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11105   # Extract the first word of "windmc", so it can be a program name with args.
11106 set dummy windmc; ac_word=$2
11107 echo "$as_me:$LINENO: checking for $ac_word" >&5
11108 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11109 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11110   echo $ECHO_N "(cached) $ECHO_C" >&6
11111 else
11112   case $WINDMC_FOR_TARGET in
11113   [\\/]* | ?:[\\/]*)
11114   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11115   ;;
11116   *)
11117   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11118 for as_dir in $gcc_cv_tool_dirs
11119 do
11120   IFS=$as_save_IFS
11121   test -z "$as_dir" && as_dir=.
11122   for ac_exec_ext in '' $ac_executable_extensions; do
11123   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11124     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11125     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11126     break 2
11127   fi
11128 done
11129 done
11130
11131   ;;
11132 esac
11133 fi
11134 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11135
11136 if test -n "$WINDMC_FOR_TARGET"; then
11137   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11138 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11139 else
11140   echo "$as_me:$LINENO: result: no" >&5
11141 echo "${ECHO_T}no" >&6
11142 fi
11143
11144 fi
11145 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11146
11147
11148 if test -n "$WINDMC_FOR_TARGET"; then
11149   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11150 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11151   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11152 fi
11153
11154 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11155   for ncn_progname in windmc; do
11156     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11157 set dummy ${ncn_progname}; ac_word=$2
11158 echo "$as_me:$LINENO: checking for $ac_word" >&5
11159 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11160 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11161   echo $ECHO_N "(cached) $ECHO_C" >&6
11162 else
11163   if test -n "$WINDMC_FOR_TARGET"; then
11164   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11165 else
11166 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11167 for as_dir in $PATH
11168 do
11169   IFS=$as_save_IFS
11170   test -z "$as_dir" && as_dir=.
11171   for ac_exec_ext in '' $ac_executable_extensions; do
11172   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11173     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11174     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11175     break 2
11176   fi
11177 done
11178 done
11179
11180 fi
11181 fi
11182 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11183 if test -n "$WINDMC_FOR_TARGET"; then
11184   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11185 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11186 else
11187   echo "$as_me:$LINENO: result: no" >&5
11188 echo "${ECHO_T}no" >&6
11189 fi
11190
11191   done
11192 fi
11193
11194 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11195   for ncn_progname in windmc; do
11196     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11197 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11198     if test -x $with_build_time_tools/${ncn_progname}; then
11199       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11200       echo "$as_me:$LINENO: result: yes" >&5
11201 echo "${ECHO_T}yes" >&6
11202       break
11203     else
11204       echo "$as_me:$LINENO: result: no" >&5
11205 echo "${ECHO_T}no" >&6
11206     fi
11207   done
11208 fi
11209
11210 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11211   for ncn_progname in windmc; do
11212     if test -n "$ncn_target_tool_prefix"; then
11213       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11214 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11215 echo "$as_me:$LINENO: checking for $ac_word" >&5
11216 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11217 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11218   echo $ECHO_N "(cached) $ECHO_C" >&6
11219 else
11220   if test -n "$WINDMC_FOR_TARGET"; then
11221   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11222 else
11223 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11224 for as_dir in $PATH
11225 do
11226   IFS=$as_save_IFS
11227   test -z "$as_dir" && as_dir=.
11228   for ac_exec_ext in '' $ac_executable_extensions; do
11229   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11230     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11231     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11232     break 2
11233   fi
11234 done
11235 done
11236
11237 fi
11238 fi
11239 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11240 if test -n "$WINDMC_FOR_TARGET"; then
11241   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11242 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11243 else
11244   echo "$as_me:$LINENO: result: no" >&5
11245 echo "${ECHO_T}no" >&6
11246 fi
11247
11248     fi
11249     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11250       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11251 set dummy ${ncn_progname}; ac_word=$2
11252 echo "$as_me:$LINENO: checking for $ac_word" >&5
11253 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11254 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11255   echo $ECHO_N "(cached) $ECHO_C" >&6
11256 else
11257   if test -n "$WINDMC_FOR_TARGET"; then
11258   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11259 else
11260 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11261 for as_dir in $PATH
11262 do
11263   IFS=$as_save_IFS
11264   test -z "$as_dir" && as_dir=.
11265   for ac_exec_ext in '' $ac_executable_extensions; do
11266   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11267     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11268     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11269     break 2
11270   fi
11271 done
11272 done
11273
11274 fi
11275 fi
11276 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11277 if test -n "$WINDMC_FOR_TARGET"; then
11278   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11279 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11280 else
11281   echo "$as_me:$LINENO: result: no" >&5
11282 echo "${ECHO_T}no" >&6
11283 fi
11284
11285     fi
11286     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11287   done
11288 fi
11289
11290 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11291   set dummy windmc
11292   if test $build = $target ; then
11293     WINDMC_FOR_TARGET="$2"
11294   else
11295     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11296   fi
11297 else
11298   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11299 fi
11300
11301 else
11302   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11303 fi
11304
11305
11306 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11307
11308 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11309 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11310 if test "x${build}" != "x${host}" ; then
11311   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11312     # We already found the complete path
11313     ac_dir=`dirname $AR_FOR_TARGET`
11314     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11315 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11316   else
11317     # Canadian cross, just use what we found
11318     echo "$as_me:$LINENO: result: pre-installed" >&5
11319 echo "${ECHO_T}pre-installed" >&6
11320   fi
11321 else
11322   ok=yes
11323   case " ${configdirs} " in
11324     *" binutils "*) ;;
11325     *) ok=no ;;
11326   esac
11327
11328   if test $ok = yes; then
11329     # An in-tree tool is available and we can use it
11330     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11331     echo "$as_me:$LINENO: result: just compiled" >&5
11332 echo "${ECHO_T}just compiled" >&6
11333   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11334     # We already found the complete path
11335     ac_dir=`dirname $AR_FOR_TARGET`
11336     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11337 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11338   elif test "x$target" = "x$host"; then
11339     # We can use an host tool
11340     AR_FOR_TARGET='$(AR)'
11341     echo "$as_me:$LINENO: result: host tool" >&5
11342 echo "${ECHO_T}host tool" >&6
11343   else
11344     # We need a cross tool
11345     echo "$as_me:$LINENO: result: pre-installed" >&5
11346 echo "${ECHO_T}pre-installed" >&6
11347   fi
11348 fi
11349
11350 echo "$as_me:$LINENO: checking where to find the target as" >&5
11351 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11352 if test "x${build}" != "x${host}" ; then
11353   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11354     # We already found the complete path
11355     ac_dir=`dirname $AS_FOR_TARGET`
11356     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11357 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11358   else
11359     # Canadian cross, just use what we found
11360     echo "$as_me:$LINENO: result: pre-installed" >&5
11361 echo "${ECHO_T}pre-installed" >&6
11362   fi
11363 else
11364   ok=yes
11365   case " ${configdirs} " in
11366     *" gas "*) ;;
11367     *) ok=no ;;
11368   esac
11369
11370   if test $ok = yes; then
11371     # An in-tree tool is available and we can use it
11372     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11373     echo "$as_me:$LINENO: result: just compiled" >&5
11374 echo "${ECHO_T}just compiled" >&6
11375   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11376     # We already found the complete path
11377     ac_dir=`dirname $AS_FOR_TARGET`
11378     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11379 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11380   elif test "x$target" = "x$host"; then
11381     # We can use an host tool
11382     AS_FOR_TARGET='$(AS)'
11383     echo "$as_me:$LINENO: result: host tool" >&5
11384 echo "${ECHO_T}host tool" >&6
11385   else
11386     # We need a cross tool
11387     echo "$as_me:$LINENO: result: pre-installed" >&5
11388 echo "${ECHO_T}pre-installed" >&6
11389   fi
11390 fi
11391
11392 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11393 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11394 if test "x${build}" != "x${host}" ; then
11395   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11396     # We already found the complete path
11397     ac_dir=`dirname $CC_FOR_TARGET`
11398     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11399 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11400   else
11401     # Canadian cross, just use what we found
11402     echo "$as_me:$LINENO: result: pre-installed" >&5
11403 echo "${ECHO_T}pre-installed" >&6
11404   fi
11405 else
11406   ok=yes
11407   case " ${configdirs} " in
11408     *" gcc "*) ;;
11409     *) ok=no ;;
11410   esac
11411
11412   if test $ok = yes; then
11413     # An in-tree tool is available and we can use it
11414     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11415     echo "$as_me:$LINENO: result: just compiled" >&5
11416 echo "${ECHO_T}just compiled" >&6
11417   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11418     # We already found the complete path
11419     ac_dir=`dirname $CC_FOR_TARGET`
11420     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11421 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11422   elif test "x$target" = "x$host"; then
11423     # We can use an host tool
11424     CC_FOR_TARGET='$(CC)'
11425     echo "$as_me:$LINENO: result: host tool" >&5
11426 echo "${ECHO_T}host tool" >&6
11427   else
11428     # We need a cross tool
11429     echo "$as_me:$LINENO: result: pre-installed" >&5
11430 echo "${ECHO_T}pre-installed" >&6
11431   fi
11432 fi
11433
11434 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11435 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11436 if test "x${build}" != "x${host}" ; then
11437   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11438     # We already found the complete path
11439     ac_dir=`dirname $CXX_FOR_TARGET`
11440     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11441 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11442   else
11443     # Canadian cross, just use what we found
11444     echo "$as_me:$LINENO: result: pre-installed" >&5
11445 echo "${ECHO_T}pre-installed" >&6
11446   fi
11447 else
11448   ok=yes
11449   case " ${configdirs} " in
11450     *" gcc "*) ;;
11451     *) ok=no ;;
11452   esac
11453   case ,${enable_languages}, in
11454     *,c++,*) ;;
11455     *) ok=no ;;
11456   esac
11457   if test $ok = yes; then
11458     # An in-tree tool is available and we can use it
11459     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'
11460     echo "$as_me:$LINENO: result: just compiled" >&5
11461 echo "${ECHO_T}just compiled" >&6
11462   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11463     # We already found the complete path
11464     ac_dir=`dirname $CXX_FOR_TARGET`
11465     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11466 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11467   elif test "x$target" = "x$host"; then
11468     # We can use an host tool
11469     CXX_FOR_TARGET='$(CXX)'
11470     echo "$as_me:$LINENO: result: host tool" >&5
11471 echo "${ECHO_T}host tool" >&6
11472   else
11473     # We need a cross tool
11474     echo "$as_me:$LINENO: result: pre-installed" >&5
11475 echo "${ECHO_T}pre-installed" >&6
11476   fi
11477 fi
11478
11479 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11480 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11481 if test "x${build}" != "x${host}" ; then
11482   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11483     # We already found the complete path
11484     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11485     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11486 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11487   else
11488     # Canadian cross, just use what we found
11489     echo "$as_me:$LINENO: result: pre-installed" >&5
11490 echo "${ECHO_T}pre-installed" >&6
11491   fi
11492 else
11493   ok=yes
11494   case " ${configdirs} " in
11495     *" gcc "*) ;;
11496     *) ok=no ;;
11497   esac
11498   case ,${enable_languages}, in
11499     *,c++,*) ;;
11500     *) ok=no ;;
11501   esac
11502   if test $ok = yes; then
11503     # An in-tree tool is available and we can use it
11504     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'
11505     echo "$as_me:$LINENO: result: just compiled" >&5
11506 echo "${ECHO_T}just compiled" >&6
11507   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11508     # We already found the complete path
11509     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11510     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11511 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11512   elif test "x$target" = "x$host"; then
11513     # We can use an host tool
11514     RAW_CXX_FOR_TARGET='$(CXX)'
11515     echo "$as_me:$LINENO: result: host tool" >&5
11516 echo "${ECHO_T}host tool" >&6
11517   else
11518     # We need a cross tool
11519     echo "$as_me:$LINENO: result: pre-installed" >&5
11520 echo "${ECHO_T}pre-installed" >&6
11521   fi
11522 fi
11523
11524 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11525 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11526 if test "x${build}" != "x${host}" ; then
11527   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11528     # We already found the complete path
11529     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11530     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11531 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11532   else
11533     # Canadian cross, just use what we found
11534     echo "$as_me:$LINENO: result: pre-installed" >&5
11535 echo "${ECHO_T}pre-installed" >&6
11536   fi
11537 else
11538   ok=yes
11539   case " ${configdirs} " in
11540     *" binutils "*) ;;
11541     *) ok=no ;;
11542   esac
11543
11544   if test $ok = yes; then
11545     # An in-tree tool is available and we can use it
11546     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11547     echo "$as_me:$LINENO: result: just compiled" >&5
11548 echo "${ECHO_T}just compiled" >&6
11549   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11550     # We already found the complete path
11551     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11552     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11553 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11554   elif test "x$target" = "x$host"; then
11555     # We can use an host tool
11556     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11557     echo "$as_me:$LINENO: result: host tool" >&5
11558 echo "${ECHO_T}host tool" >&6
11559   else
11560     # We need a cross tool
11561     echo "$as_me:$LINENO: result: pre-installed" >&5
11562 echo "${ECHO_T}pre-installed" >&6
11563   fi
11564 fi
11565
11566 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11567 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11568 if test "x${build}" != "x${host}" ; then
11569   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11570     # We already found the complete path
11571     ac_dir=`dirname $GCC_FOR_TARGET`
11572     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11573 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11574   else
11575     # Canadian cross, just use what we found
11576     echo "$as_me:$LINENO: result: pre-installed" >&5
11577 echo "${ECHO_T}pre-installed" >&6
11578   fi
11579 else
11580   ok=yes
11581   case " ${configdirs} " in
11582     *" gcc "*) ;;
11583     *) ok=no ;;
11584   esac
11585
11586   if test $ok = yes; then
11587     # An in-tree tool is available and we can use it
11588     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11589     echo "$as_me:$LINENO: result: just compiled" >&5
11590 echo "${ECHO_T}just compiled" >&6
11591   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11592     # We already found the complete path
11593     ac_dir=`dirname $GCC_FOR_TARGET`
11594     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11595 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11596   elif test "x$target" = "x$host"; then
11597     # We can use an host tool
11598     GCC_FOR_TARGET='$()'
11599     echo "$as_me:$LINENO: result: host tool" >&5
11600 echo "${ECHO_T}host tool" >&6
11601   else
11602     # We need a cross tool
11603     echo "$as_me:$LINENO: result: pre-installed" >&5
11604 echo "${ECHO_T}pre-installed" >&6
11605   fi
11606 fi
11607
11608 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11609 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11610 if test "x${build}" != "x${host}" ; then
11611   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11612     # We already found the complete path
11613     ac_dir=`dirname $GCJ_FOR_TARGET`
11614     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11615 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11616   else
11617     # Canadian cross, just use what we found
11618     echo "$as_me:$LINENO: result: pre-installed" >&5
11619 echo "${ECHO_T}pre-installed" >&6
11620   fi
11621 else
11622   ok=yes
11623   case " ${configdirs} " in
11624     *" gcc "*) ;;
11625     *) ok=no ;;
11626   esac
11627   case ,${enable_languages}, in
11628     *,java,*) ;;
11629     *) ok=no ;;
11630   esac
11631   if test $ok = yes; then
11632     # An in-tree tool is available and we can use it
11633     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11634     echo "$as_me:$LINENO: result: just compiled" >&5
11635 echo "${ECHO_T}just compiled" >&6
11636   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11637     # We already found the complete path
11638     ac_dir=`dirname $GCJ_FOR_TARGET`
11639     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11640 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11641   elif test "x$target" = "x$host"; then
11642     # We can use an host tool
11643     GCJ_FOR_TARGET='$(GCJ)'
11644     echo "$as_me:$LINENO: result: host tool" >&5
11645 echo "${ECHO_T}host tool" >&6
11646   else
11647     # We need a cross tool
11648     echo "$as_me:$LINENO: result: pre-installed" >&5
11649 echo "${ECHO_T}pre-installed" >&6
11650   fi
11651 fi
11652
11653 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11654 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11655 if test "x${build}" != "x${host}" ; then
11656   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11657     # We already found the complete path
11658     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11659     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11660 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11661   else
11662     # Canadian cross, just use what we found
11663     echo "$as_me:$LINENO: result: pre-installed" >&5
11664 echo "${ECHO_T}pre-installed" >&6
11665   fi
11666 else
11667   ok=yes
11668   case " ${configdirs} " in
11669     *" gcc "*) ;;
11670     *) ok=no ;;
11671   esac
11672   case ,${enable_languages}, in
11673     *,fortran,*) ;;
11674     *) ok=no ;;
11675   esac
11676   if test $ok = yes; then
11677     # An in-tree tool is available and we can use it
11678     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11679     echo "$as_me:$LINENO: result: just compiled" >&5
11680 echo "${ECHO_T}just compiled" >&6
11681   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11682     # We already found the complete path
11683     ac_dir=`dirname $GFORTRAN_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   elif test "x$target" = "x$host"; then
11687     # We can use an host tool
11688     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11689     echo "$as_me:$LINENO: result: host tool" >&5
11690 echo "${ECHO_T}host tool" >&6
11691   else
11692     # We need a cross tool
11693     echo "$as_me:$LINENO: result: pre-installed" >&5
11694 echo "${ECHO_T}pre-installed" >&6
11695   fi
11696 fi
11697
11698 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11699 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11700 if test "x${build}" != "x${host}" ; then
11701   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11702     # We already found the complete path
11703     ac_dir=`dirname $LD_FOR_TARGET`
11704     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11705 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11706   else
11707     # Canadian cross, just use what we found
11708     echo "$as_me:$LINENO: result: pre-installed" >&5
11709 echo "${ECHO_T}pre-installed" >&6
11710   fi
11711 else
11712   ok=yes
11713   case " ${configdirs} " in
11714     *" ld "*) ;;
11715     *) ok=no ;;
11716   esac
11717
11718   if test $ok = yes; then
11719     # An in-tree tool is available and we can use it
11720     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11721     echo "$as_me:$LINENO: result: just compiled" >&5
11722 echo "${ECHO_T}just compiled" >&6
11723   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11724     # We already found the complete path
11725     ac_dir=`dirname $LD_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   elif test "x$target" = "x$host"; then
11729     # We can use an host tool
11730     LD_FOR_TARGET='$(LD)'
11731     echo "$as_me:$LINENO: result: host tool" >&5
11732 echo "${ECHO_T}host tool" >&6
11733   else
11734     # We need a cross tool
11735     echo "$as_me:$LINENO: result: pre-installed" >&5
11736 echo "${ECHO_T}pre-installed" >&6
11737   fi
11738 fi
11739
11740 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11741 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11742 if test "x${build}" != "x${host}" ; then
11743   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11744     # We already found the complete path
11745     ac_dir=`dirname $LIPO_FOR_TARGET`
11746     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11747 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11748   else
11749     # Canadian cross, just use what we found
11750     echo "$as_me:$LINENO: result: pre-installed" >&5
11751 echo "${ECHO_T}pre-installed" >&6
11752   fi
11753 else
11754   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11755     # We already found the complete path
11756     ac_dir=`dirname $LIPO_FOR_TARGET`
11757     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11758 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11759   elif test "x$target" = "x$host"; then
11760     # We can use an host tool
11761     LIPO_FOR_TARGET='$(LIPO)'
11762     echo "$as_me:$LINENO: result: host tool" >&5
11763 echo "${ECHO_T}host tool" >&6
11764   else
11765     # We need a cross tool
11766     echo "$as_me:$LINENO: result: pre-installed" >&5
11767 echo "${ECHO_T}pre-installed" >&6
11768   fi
11769 fi
11770
11771 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11772 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11773 if test "x${build}" != "x${host}" ; then
11774   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11775     # We already found the complete path
11776     ac_dir=`dirname $NM_FOR_TARGET`
11777     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11778 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11779   else
11780     # Canadian cross, just use what we found
11781     echo "$as_me:$LINENO: result: pre-installed" >&5
11782 echo "${ECHO_T}pre-installed" >&6
11783   fi
11784 else
11785   ok=yes
11786   case " ${configdirs} " in
11787     *" binutils "*) ;;
11788     *) ok=no ;;
11789   esac
11790
11791   if test $ok = yes; then
11792     # An in-tree tool is available and we can use it
11793     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11794     echo "$as_me:$LINENO: result: just compiled" >&5
11795 echo "${ECHO_T}just compiled" >&6
11796   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11797     # We already found the complete path
11798     ac_dir=`dirname $NM_FOR_TARGET`
11799     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11800 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11801   elif test "x$target" = "x$host"; then
11802     # We can use an host tool
11803     NM_FOR_TARGET='$(NM)'
11804     echo "$as_me:$LINENO: result: host tool" >&5
11805 echo "${ECHO_T}host tool" >&6
11806   else
11807     # We need a cross tool
11808     echo "$as_me:$LINENO: result: pre-installed" >&5
11809 echo "${ECHO_T}pre-installed" >&6
11810   fi
11811 fi
11812
11813 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11814 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11815 if test "x${build}" != "x${host}" ; then
11816   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11817     # We already found the complete path
11818     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11819     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11820 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11821   else
11822     # Canadian cross, just use what we found
11823     echo "$as_me:$LINENO: result: pre-installed" >&5
11824 echo "${ECHO_T}pre-installed" >&6
11825   fi
11826 else
11827   ok=yes
11828   case " ${configdirs} " in
11829     *" binutils "*) ;;
11830     *) ok=no ;;
11831   esac
11832
11833   if test $ok = yes; then
11834     # An in-tree tool is available and we can use it
11835     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11836     echo "$as_me:$LINENO: result: just compiled" >&5
11837 echo "${ECHO_T}just compiled" >&6
11838   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11839     # We already found the complete path
11840     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11841     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11842 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11843   elif test "x$target" = "x$host"; then
11844     # We can use an host tool
11845     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11846     echo "$as_me:$LINENO: result: host tool" >&5
11847 echo "${ECHO_T}host tool" >&6
11848   else
11849     # We need a cross tool
11850     echo "$as_me:$LINENO: result: pre-installed" >&5
11851 echo "${ECHO_T}pre-installed" >&6
11852   fi
11853 fi
11854
11855 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11856 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11857 if test "x${build}" != "x${host}" ; then
11858   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11859     # We already found the complete path
11860     ac_dir=`dirname $RANLIB_FOR_TARGET`
11861     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11862 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11863   else
11864     # Canadian cross, just use what we found
11865     echo "$as_me:$LINENO: result: pre-installed" >&5
11866 echo "${ECHO_T}pre-installed" >&6
11867   fi
11868 else
11869   ok=yes
11870   case " ${configdirs} " in
11871     *" binutils "*) ;;
11872     *) ok=no ;;
11873   esac
11874
11875   if test $ok = yes; then
11876     # An in-tree tool is available and we can use it
11877     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11878     echo "$as_me:$LINENO: result: just compiled" >&5
11879 echo "${ECHO_T}just compiled" >&6
11880   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11881     # We already found the complete path
11882     ac_dir=`dirname $RANLIB_FOR_TARGET`
11883     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11884 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11885   elif test "x$target" = "x$host"; then
11886     # We can use an host tool
11887     RANLIB_FOR_TARGET='$(RANLIB)'
11888     echo "$as_me:$LINENO: result: host tool" >&5
11889 echo "${ECHO_T}host tool" >&6
11890   else
11891     # We need a cross tool
11892     echo "$as_me:$LINENO: result: pre-installed" >&5
11893 echo "${ECHO_T}pre-installed" >&6
11894   fi
11895 fi
11896
11897 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11898 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11899 if test "x${build}" != "x${host}" ; then
11900   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11901     # We already found the complete path
11902     ac_dir=`dirname $STRIP_FOR_TARGET`
11903     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11904 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11905   else
11906     # Canadian cross, just use what we found
11907     echo "$as_me:$LINENO: result: pre-installed" >&5
11908 echo "${ECHO_T}pre-installed" >&6
11909   fi
11910 else
11911   ok=yes
11912   case " ${configdirs} " in
11913     *" binutils "*) ;;
11914     *) ok=no ;;
11915   esac
11916
11917   if test $ok = yes; then
11918     # An in-tree tool is available and we can use it
11919     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11920     echo "$as_me:$LINENO: result: just compiled" >&5
11921 echo "${ECHO_T}just compiled" >&6
11922   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11923     # We already found the complete path
11924     ac_dir=`dirname $STRIP_FOR_TARGET`
11925     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11926 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11927   elif test "x$target" = "x$host"; then
11928     # We can use an host tool
11929     STRIP_FOR_TARGET='$(STRIP)'
11930     echo "$as_me:$LINENO: result: host tool" >&5
11931 echo "${ECHO_T}host tool" >&6
11932   else
11933     # We need a cross tool
11934     echo "$as_me:$LINENO: result: pre-installed" >&5
11935 echo "${ECHO_T}pre-installed" >&6
11936   fi
11937 fi
11938
11939 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11940 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11941 if test "x${build}" != "x${host}" ; then
11942   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11943     # We already found the complete path
11944     ac_dir=`dirname $WINDRES_FOR_TARGET`
11945     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11946 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11947   else
11948     # Canadian cross, just use what we found
11949     echo "$as_me:$LINENO: result: pre-installed" >&5
11950 echo "${ECHO_T}pre-installed" >&6
11951   fi
11952 else
11953   ok=yes
11954   case " ${configdirs} " in
11955     *" binutils "*) ;;
11956     *) ok=no ;;
11957   esac
11958
11959   if test $ok = yes; then
11960     # An in-tree tool is available and we can use it
11961     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11962     echo "$as_me:$LINENO: result: just compiled" >&5
11963 echo "${ECHO_T}just compiled" >&6
11964   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11965     # We already found the complete path
11966     ac_dir=`dirname $WINDRES_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     WINDRES_FOR_TARGET='$(WINDRES)'
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 windmc" >&5
11982 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
11983 if test "x${build}" != "x${host}" ; then
11984   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11985     # We already found the complete path
11986     ac_dir=`dirname $WINDMC_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     *" binutils "*) ;;
11998     *) ok=no ;;
11999   esac
12000
12001   if test $ok = yes; then
12002     # An in-tree tool is available and we can use it
12003     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12004     echo "$as_me:$LINENO: result: just compiled" >&5
12005 echo "${ECHO_T}just compiled" >&6
12006   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12007     # We already found the complete path
12008     ac_dir=`dirname $WINDMC_FOR_TARGET`
12009     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12010 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12011   elif test "x$target" = "x$host"; then
12012     # We can use an host tool
12013     WINDMC_FOR_TARGET='$(WINDMC)'
12014     echo "$as_me:$LINENO: result: host tool" >&5
12015 echo "${ECHO_T}host tool" >&6
12016   else
12017     # We need a cross tool
12018     echo "$as_me:$LINENO: result: pre-installed" >&5
12019 echo "${ECHO_T}pre-installed" >&6
12020   fi
12021 fi
12022
12023
12024
12025
12026
12027 # Certain tools may need extra flags.
12028 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12029 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12030 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12031
12032 # When building target libraries, except in a Canadian cross, we use
12033 # the same toolchain as the compiler we just built.
12034 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12035 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12036 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12037 if test $host = $build; then
12038   case " $configdirs " in
12039     *" gcc "*)
12040       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12041       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12042       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12043       ;;
12044   esac
12045 fi
12046
12047
12048
12049
12050
12051 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12052 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12053 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12054 if test "${enable_maintainer_mode+set}" = set; then
12055   enableval="$enable_maintainer_mode"
12056   USE_MAINTAINER_MODE=$enableval
12057 else
12058   USE_MAINTAINER_MODE=no
12059 fi;
12060 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12061 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12062
12063
12064 if test "$USE_MAINTAINER_MODE" = yes; then
12065   MAINTAINER_MODE_TRUE=
12066   MAINTAINER_MODE_FALSE='#'
12067 else
12068   MAINTAINER_MODE_TRUE='#'
12069   MAINTAINER_MODE_FALSE=
12070 fi
12071 MAINT=$MAINTAINER_MODE_TRUE
12072
12073 # ---------------------
12074 # GCC bootstrap support
12075 # ---------------------
12076
12077 # Stage specific cflags for build.
12078 stage1_cflags="-g"
12079 case $build in
12080   vax-*-*)
12081     case ${GCC} in
12082       yes) stage1_cflags="-g -Wa,-J" ;;
12083       *) stage1_cflags="-g -J" ;;
12084     esac ;;
12085 esac
12086
12087 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12088 if test "$GCC" = yes; then
12089   saved_CFLAGS="$CFLAGS"
12090
12091   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12092   CFLAGS="$CFLAGS -fkeep-inline-functions"
12093   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12094 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12095   cat >conftest.$ac_ext <<_ACEOF
12096 /* confdefs.h.  */
12097 _ACEOF
12098 cat confdefs.h >>conftest.$ac_ext
12099 cat >>conftest.$ac_ext <<_ACEOF
12100 /* end confdefs.h.  */
12101
12102 #if (__GNUC__ < 3) \
12103     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12104                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12105 #error http://gcc.gnu.org/PR29382
12106 #endif
12107
12108 int
12109 main ()
12110 {
12111
12112   ;
12113   return 0;
12114 }
12115 _ACEOF
12116 rm -f conftest.$ac_objext
12117 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12118   (eval $ac_compile) 2>conftest.er1
12119   ac_status=$?
12120   grep -v '^ *+' conftest.er1 >conftest.err
12121   rm -f conftest.er1
12122   cat conftest.err >&5
12123   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12124   (exit $ac_status); } &&
12125          { ac_try='test -z "$ac_c_werror_flag"
12126                          || test ! -s conftest.err'
12127   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12128   (eval $ac_try) 2>&5
12129   ac_status=$?
12130   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12131   (exit $ac_status); }; } &&
12132          { ac_try='test -s conftest.$ac_objext'
12133   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12134   (eval $ac_try) 2>&5
12135   ac_status=$?
12136   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12137   (exit $ac_status); }; }; then
12138   echo "$as_me:$LINENO: result: yes" >&5
12139 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12140 else
12141   echo "$as_me: failed program was:" >&5
12142 sed 's/^/| /' conftest.$ac_ext >&5
12143
12144 echo "$as_me:$LINENO: result: no" >&5
12145 echo "${ECHO_T}no" >&6
12146 fi
12147 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12148
12149   CFLAGS="$saved_CFLAGS"
12150 fi
12151
12152
12153
12154 # Enable --enable-checking in stage1 of the compiler.
12155 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12156 if test "${enable_stage1_checking+set}" = set; then
12157   enableval="$enable_stage1_checking"
12158   stage1_checking=--enable-checking=${enable_stage1_checking}
12159 else
12160   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12161   stage1_checking=--enable-checking=yes,types
12162 else
12163   stage1_checking=--enable-checking=$enable_checking,types
12164 fi
12165 fi;
12166
12167
12168 # Enable -Werror in bootstrap stage2 and later.
12169 # Check whether --enable-werror or --disable-werror was given.
12170 if test "${enable_werror+set}" = set; then
12171   enableval="$enable_werror"
12172
12173 else
12174   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12175   enable_werror=yes
12176 else
12177   enable_werror=no
12178 fi
12179 fi;
12180 case ${enable_werror} in
12181   yes) stage2_werror_flag="--enable-werror-always" ;;
12182   *) stage2_werror_flag="" ;;
12183 esac
12184
12185
12186 # Flags needed to enable html installing and building
12187
12188 # Check whether --with-datarootdir or --without-datarootdir was given.
12189 if test "${with_datarootdir+set}" = set; then
12190   withval="$with_datarootdir"
12191   datarootdir="\${prefix}/${withval}"
12192 else
12193   datarootdir="\${prefix}/share"
12194 fi;
12195
12196
12197 # Check whether --with-docdir or --without-docdir was given.
12198 if test "${with_docdir+set}" = set; then
12199   withval="$with_docdir"
12200   docdir="\${prefix}/${withval}"
12201 else
12202   docdir="\${datarootdir}/doc"
12203 fi;
12204
12205
12206 # Check whether --with-pdfdir or --without-pdfdir was given.
12207 if test "${with_pdfdir+set}" = set; then
12208   withval="$with_pdfdir"
12209   pdfdir="\${prefix}/${withval}"
12210 else
12211   pdfdir="\${docdir}"
12212 fi;
12213
12214
12215 # Check whether --with-htmldir or --without-htmldir was given.
12216 if test "${with_htmldir+set}" = set; then
12217   withval="$with_htmldir"
12218   htmldir="\${prefix}/${withval}"
12219 else
12220   htmldir="\${docdir}"
12221 fi;
12222
12223
12224
12225
12226
12227
12228           ac_config_files="$ac_config_files Makefile"
12229 cat >confcache <<\_ACEOF
12230 # This file is a shell script that caches the results of configure
12231 # tests run on this system so they can be shared between configure
12232 # scripts and configure runs, see configure's option --config-cache.
12233 # It is not useful on other systems.  If it contains results you don't
12234 # want to keep, you may remove or edit it.
12235 #
12236 # config.status only pays attention to the cache file if you give it
12237 # the --recheck option to rerun configure.
12238 #
12239 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12240 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12241 # following values.
12242
12243 _ACEOF
12244
12245 # The following way of writing the cache mishandles newlines in values,
12246 # but we know of no workaround that is simple, portable, and efficient.
12247 # So, don't put newlines in cache variables' values.
12248 # Ultrix sh set writes to stderr and can't be redirected directly,
12249 # and sets the high bit in the cache file unless we assign to the vars.
12250 {
12251   (set) 2>&1 |
12252     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12253     *ac_space=\ *)
12254       # `set' does not quote correctly, so add quotes (double-quote
12255       # substitution turns \\\\ into \\, and sed turns \\ into \).
12256       sed -n \
12257         "s/'/'\\\\''/g;
12258           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12259       ;;
12260     *)
12261       # `set' quotes correctly as required by POSIX, so do not add quotes.
12262       sed -n \
12263         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12264       ;;
12265     esac;
12266 } |
12267   sed '
12268      t clear
12269      : clear
12270      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12271      t end
12272      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12273      : end' >>confcache
12274 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12275   if test -w $cache_file; then
12276     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12277     cat confcache >$cache_file
12278   else
12279     echo "not updating unwritable cache $cache_file"
12280   fi
12281 fi
12282 rm -f confcache
12283
12284 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12285 # Let make expand exec_prefix.
12286 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12287
12288 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12289 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12290 # trailing colons and then remove the whole line if VPATH becomes empty
12291 # (actually we leave an empty line to preserve line numbers).
12292 if test "x$srcdir" = x.; then
12293   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12294 s/:*\$(srcdir):*/:/;
12295 s/:*\${srcdir}:*/:/;
12296 s/:*@srcdir@:*/:/;
12297 s/^\([^=]*=[     ]*\):*/\1/;
12298 s/:*$//;
12299 s/^[^=]*=[       ]*$//;
12300 }'
12301 fi
12302
12303 # Transform confdefs.h into DEFS.
12304 # Protect against shell expansion while executing Makefile rules.
12305 # Protect against Makefile macro expansion.
12306 #
12307 # If the first sed substitution is executed (which looks for macros that
12308 # take arguments), then we branch to the quote section.  Otherwise,
12309 # look for a macro that doesn't take arguments.
12310 cat >confdef2opt.sed <<\_ACEOF
12311 t clear
12312 : clear
12313 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12314 t quote
12315 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12316 t quote
12317 d
12318 : quote
12319 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12320 s,\[,\\&,g
12321 s,\],\\&,g
12322 s,\$,$$,g
12323 p
12324 _ACEOF
12325 # We use echo to avoid assuming a particular line-breaking character.
12326 # The extra dot is to prevent the shell from consuming trailing
12327 # line-breaks from the sub-command output.  A line-break within
12328 # single-quotes doesn't work because, if this script is created in a
12329 # platform that uses two characters for line-breaks (e.g., DOS), tr
12330 # would break.
12331 ac_LF_and_DOT=`echo; echo .`
12332 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12333 rm -f confdef2opt.sed
12334
12335
12336 ac_libobjs=
12337 ac_ltlibobjs=
12338 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12339   # 1. Remove the extension, and $U if already installed.
12340   ac_i=`echo "$ac_i" |
12341          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12342   # 2. Add them.
12343   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12344   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12345 done
12346 LIBOBJS=$ac_libobjs
12347
12348 LTLIBOBJS=$ac_ltlibobjs
12349
12350
12351
12352 : ${CONFIG_STATUS=./config.status}
12353 ac_clean_files_save=$ac_clean_files
12354 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12355 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12356 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12357 cat >$CONFIG_STATUS <<_ACEOF
12358 #! $SHELL
12359 # Generated by $as_me.
12360 # Run this file to recreate the current configuration.
12361 # Compiler output produced by configure, useful for debugging
12362 # configure, is in config.log if it exists.
12363
12364 debug=false
12365 ac_cs_recheck=false
12366 ac_cs_silent=false
12367 SHELL=\${CONFIG_SHELL-$SHELL}
12368 _ACEOF
12369
12370 cat >>$CONFIG_STATUS <<\_ACEOF
12371 ## --------------------- ##
12372 ## M4sh Initialization.  ##
12373 ## --------------------- ##
12374
12375 # Be Bourne compatible
12376 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12377   emulate sh
12378   NULLCMD=:
12379   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12380   # is contrary to our usage.  Disable this feature.
12381   alias -g '${1+"$@"}'='"$@"'
12382 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12383   set -o posix
12384 fi
12385 DUALCASE=1; export DUALCASE # for MKS sh
12386
12387 # Support unset when possible.
12388 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12389   as_unset=unset
12390 else
12391   as_unset=false
12392 fi
12393
12394
12395 # Work around bugs in pre-3.0 UWIN ksh.
12396 $as_unset ENV MAIL MAILPATH
12397 PS1='$ '
12398 PS2='> '
12399 PS4='+ '
12400
12401 # NLS nuisances.
12402 for as_var in \
12403   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12404   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12405   LC_TELEPHONE LC_TIME
12406 do
12407   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12408     eval $as_var=C; export $as_var
12409   else
12410     $as_unset $as_var
12411   fi
12412 done
12413
12414 # Required to use basename.
12415 if expr a : '\(a\)' >/dev/null 2>&1; then
12416   as_expr=expr
12417 else
12418   as_expr=false
12419 fi
12420
12421 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12422   as_basename=basename
12423 else
12424   as_basename=false
12425 fi
12426
12427
12428 # Name of the executable.
12429 as_me=`$as_basename "$0" ||
12430 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12431          X"$0" : 'X\(//\)$' \| \
12432          X"$0" : 'X\(/\)$' \| \
12433          .     : '\(.\)' 2>/dev/null ||
12434 echo X/"$0" |
12435     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12436           /^X\/\(\/\/\)$/{ s//\1/; q; }
12437           /^X\/\(\/\).*/{ s//\1/; q; }
12438           s/.*/./; q'`
12439
12440
12441 # PATH needs CR, and LINENO needs CR and PATH.
12442 # Avoid depending upon Character Ranges.
12443 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12444 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12445 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12446 as_cr_digits='0123456789'
12447 as_cr_alnum=$as_cr_Letters$as_cr_digits
12448
12449 # The user is always right.
12450 if test "${PATH_SEPARATOR+set}" != set; then
12451   echo "#! /bin/sh" >conf$$.sh
12452   echo  "exit 0"   >>conf$$.sh
12453   chmod +x conf$$.sh
12454   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12455     PATH_SEPARATOR=';'
12456   else
12457     PATH_SEPARATOR=:
12458   fi
12459   rm -f conf$$.sh
12460 fi
12461
12462
12463   as_lineno_1=$LINENO
12464   as_lineno_2=$LINENO
12465   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12466   test "x$as_lineno_1" != "x$as_lineno_2" &&
12467   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12468   # Find who we are.  Look in the path if we contain no path at all
12469   # relative or not.
12470   case $0 in
12471     *[\\/]* ) as_myself=$0 ;;
12472     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12473 for as_dir in $PATH
12474 do
12475   IFS=$as_save_IFS
12476   test -z "$as_dir" && as_dir=.
12477   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12478 done
12479
12480        ;;
12481   esac
12482   # We did not find ourselves, most probably we were run as `sh COMMAND'
12483   # in which case we are not to be found in the path.
12484   if test "x$as_myself" = x; then
12485     as_myself=$0
12486   fi
12487   if test ! -f "$as_myself"; then
12488     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12489 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12490    { (exit 1); exit 1; }; }
12491   fi
12492   case $CONFIG_SHELL in
12493   '')
12494     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12495 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12496 do
12497   IFS=$as_save_IFS
12498   test -z "$as_dir" && as_dir=.
12499   for as_base in sh bash ksh sh5; do
12500          case $as_dir in
12501          /*)
12502            if ("$as_dir/$as_base" -c '
12503   as_lineno_1=$LINENO
12504   as_lineno_2=$LINENO
12505   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12506   test "x$as_lineno_1" != "x$as_lineno_2" &&
12507   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12508              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12509              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12510              CONFIG_SHELL=$as_dir/$as_base
12511              export CONFIG_SHELL
12512              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12513            fi;;
12514          esac
12515        done
12516 done
12517 ;;
12518   esac
12519
12520   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12521   # uniformly replaced by the line number.  The first 'sed' inserts a
12522   # line-number line before each line; the second 'sed' does the real
12523   # work.  The second script uses 'N' to pair each line-number line
12524   # with the numbered line, and appends trailing '-' during
12525   # substitution so that $LINENO is not a special case at line end.
12526   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12527   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12528   sed '=' <$as_myself |
12529     sed '
12530       N
12531       s,$,-,
12532       : loop
12533       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12534       t loop
12535       s,-$,,
12536       s,^['$as_cr_digits']*\n,,
12537     ' >$as_me.lineno &&
12538   chmod +x $as_me.lineno ||
12539     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12540 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12541    { (exit 1); exit 1; }; }
12542
12543   # Don't try to exec as it changes $[0], causing all sort of problems
12544   # (the dirname of $[0] is not the place where we might find the
12545   # original and so on.  Autoconf is especially sensible to this).
12546   . ./$as_me.lineno
12547   # Exit status is that of the last command.
12548   exit
12549 }
12550
12551
12552 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12553   *c*,-n*) ECHO_N= ECHO_C='
12554 ' ECHO_T='      ' ;;
12555   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12556   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12557 esac
12558
12559 if expr a : '\(a\)' >/dev/null 2>&1; then
12560   as_expr=expr
12561 else
12562   as_expr=false
12563 fi
12564
12565 rm -f conf$$ conf$$.exe conf$$.file
12566 echo >conf$$.file
12567 if ln -s conf$$.file conf$$ 2>/dev/null; then
12568   # We could just check for DJGPP; but this test a) works b) is more generic
12569   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12570   if test -f conf$$.exe; then
12571     # Don't use ln at all; we don't have any links
12572     as_ln_s='cp -p'
12573   else
12574     as_ln_s='ln -s'
12575   fi
12576 elif ln conf$$.file conf$$ 2>/dev/null; then
12577   as_ln_s=ln
12578 else
12579   as_ln_s='cp -p'
12580 fi
12581 rm -f conf$$ conf$$.exe conf$$.file
12582
12583 if mkdir -p . 2>/dev/null; then
12584   as_mkdir_p=:
12585 else
12586   test -d ./-p && rmdir ./-p
12587   as_mkdir_p=false
12588 fi
12589
12590 as_executable_p="test -f"
12591
12592 # Sed expression to map a string onto a valid CPP name.
12593 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12594
12595 # Sed expression to map a string onto a valid variable name.
12596 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12597
12598
12599 # IFS
12600 # We need space, tab and new line, in precisely that order.
12601 as_nl='
12602 '
12603 IFS="   $as_nl"
12604
12605 # CDPATH.
12606 $as_unset CDPATH
12607
12608 exec 6>&1
12609
12610 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12611 # report actual input values of CONFIG_FILES etc. instead of their
12612 # values after options handling.  Logging --version etc. is OK.
12613 exec 5>>config.log
12614 {
12615   echo
12616   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12617 ## Running $as_me. ##
12618 _ASBOX
12619 } >&5
12620 cat >&5 <<_CSEOF
12621
12622 This file was extended by $as_me, which was
12623 generated by GNU Autoconf 2.59.  Invocation command line was
12624
12625   CONFIG_FILES    = $CONFIG_FILES
12626   CONFIG_HEADERS  = $CONFIG_HEADERS
12627   CONFIG_LINKS    = $CONFIG_LINKS
12628   CONFIG_COMMANDS = $CONFIG_COMMANDS
12629   $ $0 $@
12630
12631 _CSEOF
12632 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12633 echo >&5
12634 _ACEOF
12635
12636 # Files that config.status was made for.
12637 if test -n "$ac_config_files"; then
12638   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12639 fi
12640
12641 if test -n "$ac_config_headers"; then
12642   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12643 fi
12644
12645 if test -n "$ac_config_links"; then
12646   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12647 fi
12648
12649 if test -n "$ac_config_commands"; then
12650   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12651 fi
12652
12653 cat >>$CONFIG_STATUS <<\_ACEOF
12654
12655 ac_cs_usage="\
12656 \`$as_me' instantiates files from templates according to the
12657 current configuration.
12658
12659 Usage: $0 [OPTIONS] [FILE]...
12660
12661   -h, --help       print this help, then exit
12662   -V, --version    print version number, then exit
12663   -q, --quiet      do not print progress messages
12664   -d, --debug      don't remove temporary files
12665       --recheck    update $as_me by reconfiguring in the same conditions
12666   --file=FILE[:TEMPLATE]
12667                    instantiate the configuration file FILE
12668
12669 Configuration files:
12670 $config_files
12671
12672 Report bugs to <bug-autoconf@gnu.org>."
12673 _ACEOF
12674
12675 cat >>$CONFIG_STATUS <<_ACEOF
12676 ac_cs_version="\\
12677 config.status
12678 configured by $0, generated by GNU Autoconf 2.59,
12679   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12680
12681 Copyright (C) 2003 Free Software Foundation, Inc.
12682 This config.status script is free software; the Free Software Foundation
12683 gives unlimited permission to copy, distribute and modify it."
12684 srcdir=$srcdir
12685 INSTALL="$INSTALL"
12686 _ACEOF
12687
12688 cat >>$CONFIG_STATUS <<\_ACEOF
12689 # If no file are specified by the user, then we need to provide default
12690 # value.  By we need to know if files were specified by the user.
12691 ac_need_defaults=:
12692 while test $# != 0
12693 do
12694   case $1 in
12695   --*=*)
12696     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12697     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12698     ac_shift=:
12699     ;;
12700   -*)
12701     ac_option=$1
12702     ac_optarg=$2
12703     ac_shift=shift
12704     ;;
12705   *) # This is not an option, so the user has probably given explicit
12706      # arguments.
12707      ac_option=$1
12708      ac_need_defaults=false;;
12709   esac
12710
12711   case $ac_option in
12712   # Handling of the options.
12713 _ACEOF
12714 cat >>$CONFIG_STATUS <<\_ACEOF
12715   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12716     ac_cs_recheck=: ;;
12717   --version | --vers* | -V )
12718     echo "$ac_cs_version"; exit 0 ;;
12719   --he | --h)
12720     # Conflict between --help and --header
12721     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12722 Try \`$0 --help' for more information." >&5
12723 echo "$as_me: error: ambiguous option: $1
12724 Try \`$0 --help' for more information." >&2;}
12725    { (exit 1); exit 1; }; };;
12726   --help | --hel | -h )
12727     echo "$ac_cs_usage"; exit 0 ;;
12728   --debug | --d* | -d )
12729     debug=: ;;
12730   --file | --fil | --fi | --f )
12731     $ac_shift
12732     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12733     ac_need_defaults=false;;
12734   --header | --heade | --head | --hea )
12735     $ac_shift
12736     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12737     ac_need_defaults=false;;
12738   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12739   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12740     ac_cs_silent=: ;;
12741
12742   # This is an error.
12743   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12744 Try \`$0 --help' for more information." >&5
12745 echo "$as_me: error: unrecognized option: $1
12746 Try \`$0 --help' for more information." >&2;}
12747    { (exit 1); exit 1; }; } ;;
12748
12749   *) ac_config_targets="$ac_config_targets $1" ;;
12750
12751   esac
12752   shift
12753 done
12754
12755 ac_configure_extra_args=
12756
12757 if $ac_cs_silent; then
12758   exec 6>/dev/null
12759   ac_configure_extra_args="$ac_configure_extra_args --silent"
12760 fi
12761
12762 _ACEOF
12763 cat >>$CONFIG_STATUS <<_ACEOF
12764 if \$ac_cs_recheck; then
12765   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12766   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12767 fi
12768
12769 _ACEOF
12770
12771
12772
12773
12774
12775 cat >>$CONFIG_STATUS <<\_ACEOF
12776 for ac_config_target in $ac_config_targets
12777 do
12778   case "$ac_config_target" in
12779   # Handling of arguments.
12780   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12781   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12782 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12783    { (exit 1); exit 1; }; };;
12784   esac
12785 done
12786
12787 # If the user did not use the arguments to specify the items to instantiate,
12788 # then the envvar interface is used.  Set only those that are not.
12789 # We use the long form for the default assignment because of an extremely
12790 # bizarre bug on SunOS 4.1.3.
12791 if $ac_need_defaults; then
12792   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12793 fi
12794
12795 # Have a temporary directory for convenience.  Make it in the build tree
12796 # simply because there is no reason to put it here, and in addition,
12797 # creating and moving files from /tmp can sometimes cause problems.
12798 # Create a temporary directory, and hook for its removal unless debugging.
12799 $debug ||
12800 {
12801   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12802   trap '{ (exit 1); exit 1; }' 1 2 13 15
12803 }
12804
12805 # Create a (secure) tmp directory for tmp files.
12806
12807 {
12808   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12809   test -n "$tmp" && test -d "$tmp"
12810 }  ||
12811 {
12812   tmp=./confstat$$-$RANDOM
12813   (umask 077 && mkdir $tmp)
12814 } ||
12815 {
12816    echo "$me: cannot create a temporary directory in ." >&2
12817    { (exit 1); exit 1; }
12818 }
12819
12820 _ACEOF
12821
12822 cat >>$CONFIG_STATUS <<_ACEOF
12823
12824 #
12825 # CONFIG_FILES section.
12826 #
12827
12828 # No need to generate the scripts if there are no CONFIG_FILES.
12829 # This happens for instance when ./config.status config.h
12830 if test -n "\$CONFIG_FILES"; then
12831   # Protect against being on the right side of a sed subst in config.status.
12832   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12833    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12834 s,@SHELL@,$SHELL,;t t
12835 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12836 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12837 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12838 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12839 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12840 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12841 s,@exec_prefix@,$exec_prefix,;t t
12842 s,@prefix@,$prefix,;t t
12843 s,@program_transform_name@,$program_transform_name,;t t
12844 s,@bindir@,$bindir,;t t
12845 s,@sbindir@,$sbindir,;t t
12846 s,@libexecdir@,$libexecdir,;t t
12847 s,@datadir@,$datadir,;t t
12848 s,@sysconfdir@,$sysconfdir,;t t
12849 s,@sharedstatedir@,$sharedstatedir,;t t
12850 s,@localstatedir@,$localstatedir,;t t
12851 s,@libdir@,$libdir,;t t
12852 s,@includedir@,$includedir,;t t
12853 s,@oldincludedir@,$oldincludedir,;t t
12854 s,@infodir@,$infodir,;t t
12855 s,@mandir@,$mandir,;t t
12856 s,@build_alias@,$build_alias,;t t
12857 s,@host_alias@,$host_alias,;t t
12858 s,@target_alias@,$target_alias,;t t
12859 s,@DEFS@,$DEFS,;t t
12860 s,@ECHO_C@,$ECHO_C,;t t
12861 s,@ECHO_N@,$ECHO_N,;t t
12862 s,@ECHO_T@,$ECHO_T,;t t
12863 s,@LIBS@,$LIBS,;t t
12864 s,@build@,$build,;t t
12865 s,@build_cpu@,$build_cpu,;t t
12866 s,@build_vendor@,$build_vendor,;t t
12867 s,@build_os@,$build_os,;t t
12868 s,@build_noncanonical@,$build_noncanonical,;t t
12869 s,@host_noncanonical@,$host_noncanonical,;t t
12870 s,@target_noncanonical@,$target_noncanonical,;t t
12871 s,@host@,$host,;t t
12872 s,@host_cpu@,$host_cpu,;t t
12873 s,@host_vendor@,$host_vendor,;t t
12874 s,@host_os@,$host_os,;t t
12875 s,@target@,$target,;t t
12876 s,@target_cpu@,$target_cpu,;t t
12877 s,@target_vendor@,$target_vendor,;t t
12878 s,@target_os@,$target_os,;t t
12879 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12880 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12881 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12882 s,@LN@,$LN,;t t
12883 s,@LN_S@,$LN_S,;t t
12884 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12885 s,@build_libsubdir@,$build_libsubdir,;t t
12886 s,@build_subdir@,$build_subdir,;t t
12887 s,@host_subdir@,$host_subdir,;t t
12888 s,@target_subdir@,$target_subdir,;t t
12889 s,@CC@,$CC,;t t
12890 s,@CFLAGS@,$CFLAGS,;t t
12891 s,@LDFLAGS@,$LDFLAGS,;t t
12892 s,@CPPFLAGS@,$CPPFLAGS,;t t
12893 s,@ac_ct_CC@,$ac_ct_CC,;t t
12894 s,@EXEEXT@,$EXEEXT,;t t
12895 s,@OBJEXT@,$OBJEXT,;t t
12896 s,@CXX@,$CXX,;t t
12897 s,@CXXFLAGS@,$CXXFLAGS,;t t
12898 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12899 s,@GNATBIND@,$GNATBIND,;t t
12900 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12901 s,@GNATMAKE@,$GNATMAKE,;t t
12902 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12903 s,@do_compare@,$do_compare,;t t
12904 s,@gmplibs@,$gmplibs,;t t
12905 s,@gmpinc@,$gmpinc,;t t
12906 s,@stage1_languages@,$stage1_languages,;t t
12907 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12908 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12909 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
12910 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
12911 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12912 s,@tooldir@,$tooldir,;t t
12913 s,@build_tooldir@,$build_tooldir,;t t
12914 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12915 s,@GDB_TK@,$GDB_TK,;t t
12916 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12917 s,@build_configargs@,$build_configargs,;t t
12918 s,@build_configdirs@,$build_configdirs,;t t
12919 s,@host_configargs@,$host_configargs,;t t
12920 s,@configdirs@,$configdirs,;t t
12921 s,@target_configargs@,$target_configargs,;t t
12922 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
12923 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
12924 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12925 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12926 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
12927 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
12928 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
12929 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
12930 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
12931 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
12932 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
12933 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
12934 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
12935 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
12936 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
12937 s,@config_shell@,$config_shell,;t t
12938 s,@YACC@,$YACC,;t t
12939 s,@BISON@,$BISON,;t t
12940 s,@M4@,$M4,;t t
12941 s,@LEX@,$LEX,;t t
12942 s,@FLEX@,$FLEX,;t t
12943 s,@MAKEINFO@,$MAKEINFO,;t t
12944 s,@EXPECT@,$EXPECT,;t t
12945 s,@RUNTEST@,$RUNTEST,;t t
12946 s,@AR@,$AR,;t t
12947 s,@AS@,$AS,;t t
12948 s,@DLLTOOL@,$DLLTOOL,;t t
12949 s,@LD@,$LD,;t t
12950 s,@LIPO@,$LIPO,;t t
12951 s,@NM@,$NM,;t t
12952 s,@RANLIB@,$RANLIB,;t t
12953 s,@STRIP@,$STRIP,;t t
12954 s,@WINDRES@,$WINDRES,;t t
12955 s,@WINDMC@,$WINDMC,;t t
12956 s,@OBJCOPY@,$OBJCOPY,;t t
12957 s,@OBJDUMP@,$OBJDUMP,;t t
12958 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12959 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12960 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12961 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12962 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12963 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12964 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12965 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12966 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12967 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12968 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12969 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12970 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12971 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12972 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12973 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
12974 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12975 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12976 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12977 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12978 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12979 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12980 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12981 s,@MAINT@,$MAINT,;t t
12982 s,@stage1_cflags@,$stage1_cflags,;t t
12983 s,@stage1_checking@,$stage1_checking,;t t
12984 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12985 s,@datarootdir@,$datarootdir,;t t
12986 s,@docdir@,$docdir,;t t
12987 s,@pdfdir@,$pdfdir,;t t
12988 s,@htmldir@,$htmldir,;t t
12989 s,@LIBOBJS@,$LIBOBJS,;t t
12990 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12991 /@serialization_dependencies@/r $serialization_dependencies
12992 s,@serialization_dependencies@,,;t t
12993 /@host_makefile_frag@/r $host_makefile_frag
12994 s,@host_makefile_frag@,,;t t
12995 /@target_makefile_frag@/r $target_makefile_frag
12996 s,@target_makefile_frag@,,;t t
12997 /@alphaieee_frag@/r $alphaieee_frag
12998 s,@alphaieee_frag@,,;t t
12999 /@ospace_frag@/r $ospace_frag
13000 s,@ospace_frag@,,;t t
13001 CEOF
13002
13003 _ACEOF
13004
13005   cat >>$CONFIG_STATUS <<\_ACEOF
13006   # Split the substitutions into bite-sized pieces for seds with
13007   # small command number limits, like on Digital OSF/1 and HP-UX.
13008   ac_max_sed_lines=48
13009   ac_sed_frag=1 # Number of current file.
13010   ac_beg=1 # First line for current file.
13011   ac_end=$ac_max_sed_lines # Line after last line for current file.
13012   ac_more_lines=:
13013   ac_sed_cmds=
13014   while $ac_more_lines; do
13015     if test $ac_beg -gt 1; then
13016       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13017     else
13018       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13019     fi
13020     if test ! -s $tmp/subs.frag; then
13021       ac_more_lines=false
13022     else
13023       # The purpose of the label and of the branching condition is to
13024       # speed up the sed processing (if there are no `@' at all, there
13025       # is no need to browse any of the substitutions).
13026       # These are the two extra sed commands mentioned above.
13027       (echo ':t
13028   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13029       if test -z "$ac_sed_cmds"; then
13030         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13031       else
13032         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13033       fi
13034       ac_sed_frag=`expr $ac_sed_frag + 1`
13035       ac_beg=$ac_end
13036       ac_end=`expr $ac_end + $ac_max_sed_lines`
13037     fi
13038   done
13039   if test -z "$ac_sed_cmds"; then
13040     ac_sed_cmds=cat
13041   fi
13042 fi # test -n "$CONFIG_FILES"
13043
13044 _ACEOF
13045 cat >>$CONFIG_STATUS <<\_ACEOF
13046 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13047   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13048   case $ac_file in
13049   - | *:- | *:-:* ) # input from stdin
13050         cat >$tmp/stdin
13051         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13052         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13053   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13054         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13055   * )   ac_file_in=$ac_file.in ;;
13056   esac
13057
13058   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13059   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13060 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13061          X"$ac_file" : 'X\(//\)[^/]' \| \
13062          X"$ac_file" : 'X\(//\)$' \| \
13063          X"$ac_file" : 'X\(/\)' \| \
13064          .     : '\(.\)' 2>/dev/null ||
13065 echo X"$ac_file" |
13066     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13067           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13068           /^X\(\/\/\)$/{ s//\1/; q; }
13069           /^X\(\/\).*/{ s//\1/; q; }
13070           s/.*/./; q'`
13071   { if $as_mkdir_p; then
13072     mkdir -p "$ac_dir"
13073   else
13074     as_dir="$ac_dir"
13075     as_dirs=
13076     while test ! -d "$as_dir"; do
13077       as_dirs="$as_dir $as_dirs"
13078       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13079 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13080          X"$as_dir" : 'X\(//\)[^/]' \| \
13081          X"$as_dir" : 'X\(//\)$' \| \
13082          X"$as_dir" : 'X\(/\)' \| \
13083          .     : '\(.\)' 2>/dev/null ||
13084 echo X"$as_dir" |
13085     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13086           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13087           /^X\(\/\/\)$/{ s//\1/; q; }
13088           /^X\(\/\).*/{ s//\1/; q; }
13089           s/.*/./; q'`
13090     done
13091     test ! -n "$as_dirs" || mkdir $as_dirs
13092   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13093 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13094    { (exit 1); exit 1; }; }; }
13095
13096   ac_builddir=.
13097
13098 if test "$ac_dir" != .; then
13099   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13100   # A "../" for each directory in $ac_dir_suffix.
13101   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13102 else
13103   ac_dir_suffix= ac_top_builddir=
13104 fi
13105
13106 case $srcdir in
13107   .)  # No --srcdir option.  We are building in place.
13108     ac_srcdir=.
13109     if test -z "$ac_top_builddir"; then
13110        ac_top_srcdir=.
13111     else
13112        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13113     fi ;;
13114   [\\/]* | ?:[\\/]* )  # Absolute path.
13115     ac_srcdir=$srcdir$ac_dir_suffix;
13116     ac_top_srcdir=$srcdir ;;
13117   *) # Relative path.
13118     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13119     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13120 esac
13121
13122 # Do not use `cd foo && pwd` to compute absolute paths, because
13123 # the directories may not exist.
13124 case `pwd` in
13125 .) ac_abs_builddir="$ac_dir";;
13126 *)
13127   case "$ac_dir" in
13128   .) ac_abs_builddir=`pwd`;;
13129   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13130   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13131   esac;;
13132 esac
13133 case $ac_abs_builddir in
13134 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13135 *)
13136   case ${ac_top_builddir}. in
13137   .) ac_abs_top_builddir=$ac_abs_builddir;;
13138   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13139   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13140   esac;;
13141 esac
13142 case $ac_abs_builddir in
13143 .) ac_abs_srcdir=$ac_srcdir;;
13144 *)
13145   case $ac_srcdir in
13146   .) ac_abs_srcdir=$ac_abs_builddir;;
13147   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13148   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13149   esac;;
13150 esac
13151 case $ac_abs_builddir in
13152 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13153 *)
13154   case $ac_top_srcdir in
13155   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13156   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13157   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13158   esac;;
13159 esac
13160
13161
13162   case $INSTALL in
13163   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13164   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13165   esac
13166
13167   if test x"$ac_file" != x-; then
13168     { echo "$as_me:$LINENO: creating $ac_file" >&5
13169 echo "$as_me: creating $ac_file" >&6;}
13170     rm -f "$ac_file"
13171   fi
13172   # Let's still pretend it is `configure' which instantiates (i.e., don't
13173   # use $as_me), people would be surprised to read:
13174   #    /* config.h.  Generated by config.status.  */
13175   if test x"$ac_file" = x-; then
13176     configure_input=
13177   else
13178     configure_input="$ac_file.  "
13179   fi
13180   configure_input=$configure_input"Generated from `echo $ac_file_in |
13181                                      sed 's,.*/,,'` by configure."
13182
13183   # First look for the input files in the build tree, otherwise in the
13184   # src tree.
13185   ac_file_inputs=`IFS=:
13186     for f in $ac_file_in; do
13187       case $f in
13188       -) echo $tmp/stdin ;;
13189       [\\/$]*)
13190          # Absolute (can't be DOS-style, as IFS=:)
13191          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13192 echo "$as_me: error: cannot find input file: $f" >&2;}
13193    { (exit 1); exit 1; }; }
13194          echo "$f";;
13195       *) # Relative
13196          if test -f "$f"; then
13197            # Build tree
13198            echo "$f"
13199          elif test -f "$srcdir/$f"; then
13200            # Source tree
13201            echo "$srcdir/$f"
13202          else
13203            # /dev/null tree
13204            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13205 echo "$as_me: error: cannot find input file: $f" >&2;}
13206    { (exit 1); exit 1; }; }
13207          fi;;
13208       esac
13209     done` || { (exit 1); exit 1; }
13210 _ACEOF
13211 cat >>$CONFIG_STATUS <<_ACEOF
13212   sed "$ac_vpsub
13213 $extrasub
13214 _ACEOF
13215 cat >>$CONFIG_STATUS <<\_ACEOF
13216 :t
13217 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13218 s,@configure_input@,$configure_input,;t t
13219 s,@srcdir@,$ac_srcdir,;t t
13220 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13221 s,@top_srcdir@,$ac_top_srcdir,;t t
13222 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13223 s,@builddir@,$ac_builddir,;t t
13224 s,@abs_builddir@,$ac_abs_builddir,;t t
13225 s,@top_builddir@,$ac_top_builddir,;t t
13226 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13227 s,@INSTALL@,$ac_INSTALL,;t t
13228 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13229   rm -f $tmp/stdin
13230   if test x"$ac_file" != x-; then
13231     mv $tmp/out $ac_file
13232   else
13233     cat $tmp/out
13234     rm -f $tmp/out
13235   fi
13236
13237 done
13238 _ACEOF
13239
13240 cat >>$CONFIG_STATUS <<\_ACEOF
13241
13242 { (exit 0); exit 0; }
13243 _ACEOF
13244 chmod +x $CONFIG_STATUS
13245 ac_clean_files=$ac_clean_files_save
13246
13247
13248 # configure is writing to config.log, and then calls config.status.
13249 # config.status does its own redirection, appending to config.log.
13250 # Unfortunately, on DOS this fails, as config.log is still kept open
13251 # by configure, so config.status won't be able to write to it; its
13252 # output is simply discarded.  So we exec the FD to /dev/null,
13253 # effectively closing config.log, so it can be properly (re)opened and
13254 # appended to by config.status.  When coming back to configure, we
13255 # need to make the FD available again.
13256 if test "$no_create" != yes; then
13257   ac_cs_success=:
13258   ac_config_status_args=
13259   test "$silent" = yes &&
13260     ac_config_status_args="$ac_config_status_args --quiet"
13261   exec 5>/dev/null
13262   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13263   exec 5>>config.log
13264   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13265   # would make configure fail if this is the last instruction.
13266   $ac_cs_success || { (exit 1); exit 1; }
13267 fi
13268