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 RPATH_ENVVAR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs CC_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CFLAGS_FOR_BUILD 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_env_CC_set=${CC+set}
 717 ac_env_CC_value=$CC
 718 ac_cv_env_CC_set=${CC+set}
 719 ac_cv_env_CC_value=$CC
 720 ac_env_CFLAGS_set=${CFLAGS+set}
 721 ac_env_CFLAGS_value=$CFLAGS
 722 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 723 ac_cv_env_CFLAGS_value=$CFLAGS
 724 ac_env_LDFLAGS_set=${LDFLAGS+set}
 725 ac_env_LDFLAGS_value=$LDFLAGS
 726 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 727 ac_cv_env_LDFLAGS_value=$LDFLAGS
 728 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 729 ac_env_CPPFLAGS_value=$CPPFLAGS
 730 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 731 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 732 ac_env_CXX_set=${CXX+set}
 733 ac_env_CXX_value=$CXX
 734 ac_cv_env_CXX_set=${CXX+set}
 735 ac_cv_env_CXX_value=$CXX
 736 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 737 ac_env_CXXFLAGS_value=$CXXFLAGS
 738 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 739 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 740 ac_env_AR_set=${AR+set}
 741 ac_env_AR_value=$AR
 742 ac_cv_env_AR_set=${AR+set}
 743 ac_cv_env_AR_value=$AR
 744 ac_env_AS_set=${AS+set}
 745 ac_env_AS_value=$AS
 746 ac_cv_env_AS_set=${AS+set}
 747 ac_cv_env_AS_value=$AS
 748 ac_env_DLLTOOL_set=${DLLTOOL+set}
 749 ac_env_DLLTOOL_value=$DLLTOOL
 750 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 751 ac_cv_env_DLLTOOL_value=$DLLTOOL
 752 ac_env_LD_set=${LD+set}
 753 ac_env_LD_value=$LD
 754 ac_cv_env_LD_set=${LD+set}
 755 ac_cv_env_LD_value=$LD
 756 ac_env_LIPO_set=${LIPO+set}
 757 ac_env_LIPO_value=$LIPO
 758 ac_cv_env_LIPO_set=${LIPO+set}
 759 ac_cv_env_LIPO_value=$LIPO
 760 ac_env_NM_set=${NM+set}
 761 ac_env_NM_value=$NM
 762 ac_cv_env_NM_set=${NM+set}
 763 ac_cv_env_NM_value=$NM
 764 ac_env_RANLIB_set=${RANLIB+set}
 765 ac_env_RANLIB_value=$RANLIB
 766 ac_cv_env_RANLIB_set=${RANLIB+set}
 767 ac_cv_env_RANLIB_value=$RANLIB
 768 ac_env_STRIP_set=${STRIP+set}
 769 ac_env_STRIP_value=$STRIP
 770 ac_cv_env_STRIP_set=${STRIP+set}
 771 ac_cv_env_STRIP_value=$STRIP
 772 ac_env_WINDRES_set=${WINDRES+set}
 773 ac_env_WINDRES_value=$WINDRES
 774 ac_cv_env_WINDRES_set=${WINDRES+set}
 775 ac_cv_env_WINDRES_value=$WINDRES
 776 ac_env_WINDMC_set=${WINDMC+set}
 777 ac_env_WINDMC_value=$WINDMC
 778 ac_cv_env_WINDMC_set=${WINDMC+set}
 779 ac_cv_env_WINDMC_value=$WINDMC
 780 ac_env_OBJCOPY_set=${OBJCOPY+set}
 781 ac_env_OBJCOPY_value=$OBJCOPY
 782 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 783 ac_cv_env_OBJCOPY_value=$OBJCOPY
 784 ac_env_OBJDUMP_set=${OBJDUMP+set}
 785 ac_env_OBJDUMP_value=$OBJDUMP
 786 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 787 ac_cv_env_OBJDUMP_value=$OBJDUMP
 788 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 789 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 790 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 791 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 792 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 793 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 794 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 795 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 796 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 797 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 798 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 799 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 800 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 801 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 802 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 803 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 804 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 805 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 806 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 807 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 808 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 809 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 810 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 811 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 812 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 813 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 814 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 815 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 816 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 817 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 818 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 819 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 820 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 821 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 822 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 823 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 824 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 825 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 826 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 827 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 828 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 829 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 830 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 831 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 832 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 833 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 834 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 835 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 836 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 837 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 838 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 839 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 840 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 841 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 842 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 843 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 844 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 845 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 846 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 847 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 848 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 849 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 850 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 851 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 852
 853 #
 854 # Report the --help message.
 855 #
 856 if test "$ac_init_help" = "long"; then
 857   # Omit some internal or obsolete options to make the list less imposing.
 858   # This message is too long to be a string in the A/UX 3.1 sh.
 859   cat <<_ACEOF
 860 \`configure' configures this package to adapt to many kinds of systems.
 861
 862 Usage: $0 [OPTION]... [VAR=VALUE]...
 863
 864 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 865 VAR=VALUE.  See below for descriptions of some of the useful variables.
 866
 867 Defaults for the options are specified in brackets.
 868
 869 Configuration:
 870   -h, --help              display this help and exit
 871       --help=short        display options specific to this package
 872       --help=recursive    display the short help of all the included packages
 873   -V, --version           display version information and exit
 874   -q, --quiet, --silent   do not print \`checking...' messages
 875       --cache-file=FILE   cache test results in FILE [disabled]
 876   -C, --config-cache      alias for \`--cache-file=config.cache'
 877   -n, --no-create         do not create output files
 878       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 879
 880 _ACEOF
 881
 882   cat <<_ACEOF
 883 Installation directories:
 884   --prefix=PREFIX         install architecture-independent files in PREFIX
 885                           [$ac_default_prefix]
 886   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 887                           [PREFIX]
 888
 889 By default, \`make install' will install all the files in
 890 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 891 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 892 for instance \`--prefix=\$HOME'.
 893
 894 For better control, use the options below.
 895
 896 Fine tuning of the installation directories:
 897   --bindir=DIR           user executables [EPREFIX/bin]
 898   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 899   --libexecdir=DIR       program executables [EPREFIX/libexec]
 900   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 901   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 902   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 903   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 904   --libdir=DIR           object code libraries [EPREFIX/lib]
 905   --includedir=DIR       C header files [PREFIX/include]
 906   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 907   --infodir=DIR          info documentation [PREFIX/info]
 908   --mandir=DIR           man documentation [PREFIX/man]
 909 _ACEOF
 910
 911   cat <<\_ACEOF
 912
 913 Program names:
 914   --program-prefix=PREFIX            prepend PREFIX to installed program names
 915   --program-suffix=SUFFIX            append SUFFIX to installed program names
 916   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 917
 918 System types:
 919   --build=BUILD     configure for building on BUILD [guessed]
 920   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 921   --target=TARGET   configure for building compilers for TARGET [HOST]
 922 _ACEOF
 923 fi
 924
 925 if test -n "$ac_init_help"; then
 926
 927   cat <<\_ACEOF
 928
 929 Optional Features:
 930   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 931   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 932   --enable-libada         build libada directory
 933   --enable-libssp         build libssp directory
 934   --enable-stage1-languages[=all]   choose additional languages to build during
 935                           stage1.  Mostly useful for compiler development.
 936   --enable-objc-gc        enable use of Boehm's garbage collector with the
 937                           GNU Objective-C runtime
 938   --enable-bootstrap      enable bootstrapping [yes if native build]
 939   --enable-serial-[{host,target,build}-]configure
 940                           force sequential configuration of
 941                           sub-packages for the host, target or build
 942                           machine, or all sub-packages
 943   --enable-maintainer-mode enable make rules and dependencies not useful
 944                           (and sometimes confusing) to the casual installer
 945   --enable-stage1-checking[=all]   choose additional checking for stage1
 946                           of the compiler
 947   --enable-werror         enable -Werror in bootstrap stage2 and later
 948
 949 Optional Packages:
 950   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 951   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 952   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 953   --with-mpfr-dir=PATH    this option has been REMOVED
 954   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 955                           Equivalent to --with-mpfr-include=PATH/include
 956                           plus --with-mpfr-lib=PATH/lib
 957   --with-mpfr-include=PATH
 958                           specify directory for installed MPFR include files
 959   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 960   --with-gmp-dir=PATH     this option has been REMOVED
 961   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 962                           Equivalent to --with-gmp-include=PATH/include
 963                           plus --with-gmp-lib=PATH/lib
 964   --with-gmp-include=PATH specify directory for installed GMP include files
 965   --with-gmp-lib=PATH     specify directory for the installed GMP library
 966   --with-build-sysroot=SYSROOT
 967                           use sysroot as the system root during the build
 968   --with-debug-prefix-map='A=B C=D ...'
 969                              map A to B, C to D ... in debug information
 970   --with-build-time-tools=PATH
 971                           use given path to find target tools during the build
 972   --with-datarootdir      use datarootdir as the data root directory.
 973   --with-docdir           install documentation in this directory.
 974   --with-pdfdir           install pdf in this directory.
 975   --with-htmldir          install html in this directory.
 976
 977 Some influential environment variables:
 978   CC          C compiler command
 979   CFLAGS      C compiler flags
 980   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 981               nonstandard directory <lib dir>
 982   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 983               headers in a nonstandard directory <include dir>
 984   CXX         C++ compiler command
 985   CXXFLAGS    C++ compiler flags
 986   AR          AR for the host
 987   AS          AS for the host
 988   DLLTOOL     DLLTOOL for the host
 989   LD          LD for the host
 990   LIPO        LIPO for the host
 991   NM          NM for the host
 992   RANLIB      RANLIB for the host
 993   STRIP       STRIP for the host
 994   WINDRES     WINDRES for the host
 995   WINDMC      WINDMC for the host
 996   OBJCOPY     OBJCOPY for the host
 997   OBJDUMP     OBJDUMP for the host
 998   CC_FOR_TARGET
 999               CC for the target
1000   CXX_FOR_TARGET
1001               CXX for the target
1002   GCC_FOR_TARGET
1003               GCC for the target
1004   GCJ_FOR_TARGET
1005               GCJ for the target
1006   GFORTRAN_FOR_TARGET
1007               GFORTRAN for the target
1008   AR_FOR_TARGET
1009               AR for the target
1010   AS_FOR_TARGET
1011               AS for the target
1012   DLLTOOL_FOR_TARGET
1013               DLLTOOL for the target
1014   LD_FOR_TARGET
1015               LD for the target
1016   LIPO_FOR_TARGET
1017               LIPO for the target
1018   NM_FOR_TARGET
1019               NM for the target
1020   OBJDUMP_FOR_TARGET
1021               OBJDUMP for the target
1022   RANLIB_FOR_TARGET
1023               RANLIB for the target
1024   STRIP_FOR_TARGET
1025               STRIP for the target
1026   WINDRES_FOR_TARGET
1027               WINDRES for the target
1028   WINDMC_FOR_TARGET
1029               WINDMC for the target
1030
1031 Use these variables to override the choices made by `configure' or to help
1032 it to find libraries and programs with nonstandard names/locations.
1033
1034 _ACEOF
1035 fi
1036
1037 if test "$ac_init_help" = "recursive"; then
1038   # If there are subdirs, report their specific --help.
1039   ac_popdir=`pwd`
1040   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1041     test -d $ac_dir || continue
1042     ac_builddir=.
1043
1044 if test "$ac_dir" != .; then
1045   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1046   # A "../" for each directory in $ac_dir_suffix.
1047   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1048 else
1049   ac_dir_suffix= ac_top_builddir=
1050 fi
1051
1052 case $srcdir in
1053   .)  # No --srcdir option.  We are building in place.
1054     ac_srcdir=.
1055     if test -z "$ac_top_builddir"; then
1056        ac_top_srcdir=.
1057     else
1058        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1059     fi ;;
1060   [\\/]* | ?:[\\/]* )  # Absolute path.
1061     ac_srcdir=$srcdir$ac_dir_suffix;
1062     ac_top_srcdir=$srcdir ;;
1063   *) # Relative path.
1064     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1065     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1066 esac
1067
1068 # Do not use `cd foo && pwd` to compute absolute paths, because
1069 # the directories may not exist.
1070 case `pwd` in
1071 .) ac_abs_builddir="$ac_dir";;
1072 *)
1073   case "$ac_dir" in
1074   .) ac_abs_builddir=`pwd`;;
1075   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1076   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1077   esac;;
1078 esac
1079 case $ac_abs_builddir in
1080 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1081 *)
1082   case ${ac_top_builddir}. in
1083   .) ac_abs_top_builddir=$ac_abs_builddir;;
1084   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1085   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1086   esac;;
1087 esac
1088 case $ac_abs_builddir in
1089 .) ac_abs_srcdir=$ac_srcdir;;
1090 *)
1091   case $ac_srcdir in
1092   .) ac_abs_srcdir=$ac_abs_builddir;;
1093   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1094   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1095   esac;;
1096 esac
1097 case $ac_abs_builddir in
1098 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1099 *)
1100   case $ac_top_srcdir in
1101   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1102   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1103   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1104   esac;;
1105 esac
1106
1107     cd $ac_dir
1108     # Check for guested configure; otherwise get Cygnus style configure.
1109     if test -f $ac_srcdir/configure.gnu; then
1110       echo
1111       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1112     elif test -f $ac_srcdir/configure; then
1113       echo
1114       $SHELL $ac_srcdir/configure  --help=recursive
1115     elif test -f $ac_srcdir/configure.ac ||
1116            test -f $ac_srcdir/configure.in; then
1117       echo
1118       $ac_configure --help
1119     else
1120       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1121     fi
1122     cd $ac_popdir
1123   done
1124 fi
1125
1126 test -n "$ac_init_help" && exit 0
1127 if $ac_init_version; then
1128   cat <<\_ACEOF
1129
1130 Copyright (C) 2003 Free Software Foundation, Inc.
1131 This configure script is free software; the Free Software Foundation
1132 gives unlimited permission to copy, distribute and modify it.
1133 _ACEOF
1134   exit 0
1135 fi
1136 exec 5>config.log
1137 cat >&5 <<_ACEOF
1138 This file contains any messages produced by compilers while
1139 running configure, to aid debugging if configure makes a mistake.
1140
1141 It was created by $as_me, which was
1142 generated by GNU Autoconf 2.59.  Invocation command line was
1143
1144   $ $0 $@
1145
1146 _ACEOF
1147 {
1148 cat <<_ASUNAME
1149 ## --------- ##
1150 ## Platform. ##
1151 ## --------- ##
1152
1153 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1154 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1155 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1156 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1157 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1158
1159 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1160 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1161
1162 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1163 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1164 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1165 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1166 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1167 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1168 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1169
1170 _ASUNAME
1171
1172 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1173 for as_dir in $PATH
1174 do
1175   IFS=$as_save_IFS
1176   test -z "$as_dir" && as_dir=.
1177   echo "PATH: $as_dir"
1178 done
1179
1180 } >&5
1181
1182 cat >&5 <<_ACEOF
1183
1184
1185 ## ----------- ##
1186 ## Core tests. ##
1187 ## ----------- ##
1188
1189 _ACEOF
1190
1191
1192 # Keep a trace of the command line.
1193 # Strip out --no-create and --no-recursion so they do not pile up.
1194 # Strip out --silent because we don't want to record it for future runs.
1195 # Also quote any args containing shell meta-characters.
1196 # Make two passes to allow for proper duplicate-argument suppression.
1197 ac_configure_args=
1198 ac_configure_args0=
1199 ac_configure_args1=
1200 ac_sep=
1201 ac_must_keep_next=false
1202 for ac_pass in 1 2
1203 do
1204   for ac_arg
1205   do
1206     case $ac_arg in
1207     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1208     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1209     | -silent | --silent | --silen | --sile | --sil)
1210       continue ;;
1211     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1212       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1213     esac
1214     case $ac_pass in
1215     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1216     2)
1217       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1218       if test $ac_must_keep_next = true; then
1219         ac_must_keep_next=false # Got value, back to normal.
1220       else
1221         case $ac_arg in
1222           *=* | --config-cache | -C | -disable-* | --disable-* \
1223           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1224           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1225           | -with-* | --with-* | -without-* | --without-* | --x)
1226             case "$ac_configure_args0 " in
1227               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1228             esac
1229             ;;
1230           -* ) ac_must_keep_next=true ;;
1231         esac
1232       fi
1233       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1234       # Get rid of the leading space.
1235       ac_sep=" "
1236       ;;
1237     esac
1238   done
1239 done
1240 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1241 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1242
1243 # When interrupted or exit'd, cleanup temporary files, and complete
1244 # config.log.  We remove comments because anyway the quotes in there
1245 # would cause problems or look ugly.
1246 # WARNING: Be sure not to use single quotes in there, as some shells,
1247 # such as our DU 5.0 friend, will then `close' the trap.
1248 trap 'exit_status=$?
1249   # Save into config.log some information that might help in debugging.
1250   {
1251     echo
1252
1253     cat <<\_ASBOX
1254 ## ---------------- ##
1255 ## Cache variables. ##
1256 ## ---------------- ##
1257 _ASBOX
1258     echo
1259     # The following way of writing the cache mishandles newlines in values,
1260 {
1261   (set) 2>&1 |
1262     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1263     *ac_space=\ *)
1264       sed -n \
1265         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1266           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1267       ;;
1268     *)
1269       sed -n \
1270         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1271       ;;
1272     esac;
1273 }
1274     echo
1275
1276     cat <<\_ASBOX
1277 ## ----------------- ##
1278 ## Output variables. ##
1279 ## ----------------- ##
1280 _ASBOX
1281     echo
1282     for ac_var in $ac_subst_vars
1283     do
1284       eval ac_val=$`echo $ac_var`
1285       echo "$ac_var='"'"'$ac_val'"'"'"
1286     done | sort
1287     echo
1288
1289     if test -n "$ac_subst_files"; then
1290       cat <<\_ASBOX
1291 ## ------------- ##
1292 ## Output files. ##
1293 ## ------------- ##
1294 _ASBOX
1295       echo
1296       for ac_var in $ac_subst_files
1297       do
1298         eval ac_val=$`echo $ac_var`
1299         echo "$ac_var='"'"'$ac_val'"'"'"
1300       done | sort
1301       echo
1302     fi
1303
1304     if test -s confdefs.h; then
1305       cat <<\_ASBOX
1306 ## ----------- ##
1307 ## confdefs.h. ##
1308 ## ----------- ##
1309 _ASBOX
1310       echo
1311       sed "/^$/d" confdefs.h | sort
1312       echo
1313     fi
1314     test "$ac_signal" != 0 &&
1315       echo "$as_me: caught signal $ac_signal"
1316     echo "$as_me: exit $exit_status"
1317   } >&5
1318   rm -f core *.core &&
1319   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1320     exit $exit_status
1321      ' 0
1322 for ac_signal in 1 2 13 15; do
1323   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1324 done
1325 ac_signal=0
1326
1327 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1328 rm -rf conftest* confdefs.h
1329 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1330 echo >confdefs.h
1331
1332 # Predefined preprocessor variables.
1333
1334 cat >>confdefs.h <<_ACEOF
1335 #define PACKAGE_NAME "$PACKAGE_NAME"
1336 _ACEOF
1337
1338
1339 cat >>confdefs.h <<_ACEOF
1340 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1341 _ACEOF
1342
1343
1344 cat >>confdefs.h <<_ACEOF
1345 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1346 _ACEOF
1347
1348
1349 cat >>confdefs.h <<_ACEOF
1350 #define PACKAGE_STRING "$PACKAGE_STRING"
1351 _ACEOF
1352
1353
1354 cat >>confdefs.h <<_ACEOF
1355 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1356 _ACEOF
1357
1358
1359 # Let the site file select an alternate cache file if it wants to.
1360 # Prefer explicitly selected file to automatically selected ones.
1361 if test -z "$CONFIG_SITE"; then
1362   if test "x$prefix" != xNONE; then
1363     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1364   else
1365     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1366   fi
1367 fi
1368 for ac_site_file in $CONFIG_SITE; do
1369   if test -r "$ac_site_file"; then
1370     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1371 echo "$as_me: loading site script $ac_site_file" >&6;}
1372     sed 's/^/| /' "$ac_site_file" >&5
1373     . "$ac_site_file"
1374   fi
1375 done
1376
1377 if test -r "$cache_file"; then
1378   # Some versions of bash will fail to source /dev/null (special
1379   # files actually), so we avoid doing that.
1380   if test -f "$cache_file"; then
1381     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1382 echo "$as_me: loading cache $cache_file" >&6;}
1383     case $cache_file in
1384       [\\/]* | ?:[\\/]* ) . $cache_file;;
1385       *)                      . ./$cache_file;;
1386     esac
1387   fi
1388 else
1389   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1390 echo "$as_me: creating cache $cache_file" >&6;}
1391   >$cache_file
1392 fi
1393
1394 # Check that the precious variables saved in the cache have kept the same
1395 # value.
1396 ac_cache_corrupted=false
1397 for ac_var in `(set) 2>&1 |
1398                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1399   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1400   eval ac_new_set=\$ac_env_${ac_var}_set
1401   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1402   eval ac_new_val="\$ac_env_${ac_var}_value"
1403   case $ac_old_set,$ac_new_set in
1404     set,)
1405       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1406 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1407       ac_cache_corrupted=: ;;
1408     ,set)
1409       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1410 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1411       ac_cache_corrupted=: ;;
1412     ,);;
1413     *)
1414       if test "x$ac_old_val" != "x$ac_new_val"; then
1415         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1416 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1417         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1418 echo "$as_me:   former value:  $ac_old_val" >&2;}
1419         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1420 echo "$as_me:   current value: $ac_new_val" >&2;}
1421         ac_cache_corrupted=:
1422       fi;;
1423   esac
1424   # Pass precious variables to config.status.
1425   if test "$ac_new_set" = set; then
1426     case $ac_new_val in
1427     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1428       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1429     *) ac_arg=$ac_var=$ac_new_val ;;
1430     esac
1431     case " $ac_configure_args " in
1432       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1433       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1434     esac
1435   fi
1436 done
1437 if $ac_cache_corrupted; then
1438   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1439 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1440   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1441 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1442    { (exit 1); exit 1; }; }
1443 fi
1444
1445 ac_ext=c
1446 ac_cpp='$CPP $CPPFLAGS'
1447 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1448 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1449 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471 # Find the build, host, and target systems.
1472 ac_aux_dir=
1473 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1474   if test -f $ac_dir/install-sh; then
1475     ac_aux_dir=$ac_dir
1476     ac_install_sh="$ac_aux_dir/install-sh -c"
1477     break
1478   elif test -f $ac_dir/install.sh; then
1479     ac_aux_dir=$ac_dir
1480     ac_install_sh="$ac_aux_dir/install.sh -c"
1481     break
1482   elif test -f $ac_dir/shtool; then
1483     ac_aux_dir=$ac_dir
1484     ac_install_sh="$ac_aux_dir/shtool install -c"
1485     break
1486   fi
1487 done
1488 if test -z "$ac_aux_dir"; then
1489   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1490 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1491    { (exit 1); exit 1; }; }
1492 fi
1493 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1494 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1495 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1496
1497 # Make sure we can run config.sub.
1498 $ac_config_sub sun4 >/dev/null 2>&1 ||
1499   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1500 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1501    { (exit 1); exit 1; }; }
1502
1503 echo "$as_me:$LINENO: checking build system type" >&5
1504 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1505 if test "${ac_cv_build+set}" = set; then
1506   echo $ECHO_N "(cached) $ECHO_C" >&6
1507 else
1508   ac_cv_build_alias=$build_alias
1509 test -z "$ac_cv_build_alias" &&
1510   ac_cv_build_alias=`$ac_config_guess`
1511 test -z "$ac_cv_build_alias" &&
1512   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1513 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1514    { (exit 1); exit 1; }; }
1515 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1516   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1517 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1518    { (exit 1); exit 1; }; }
1519
1520 fi
1521 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1522 echo "${ECHO_T}$ac_cv_build" >&6
1523 build=$ac_cv_build
1524 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1525 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1526 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1527
1528
1529  case ${build_alias} in
1530   "") build_noncanonical=${build} ;;
1531   *) build_noncanonical=${build_alias} ;;
1532 esac
1533
1534
1535
1536  case ${host_alias} in
1537   "") host_noncanonical=${build_noncanonical} ;;
1538   *) host_noncanonical=${host_alias} ;;
1539 esac
1540
1541
1542
1543  case ${target_alias} in
1544   "") target_noncanonical=${host_noncanonical} ;;
1545   *) target_noncanonical=${target_alias} ;;
1546 esac
1547
1548
1549
1550
1551 test "$host_noncanonical" = "$target_noncanonical" &&
1552   test "$program_prefix$program_suffix$program_transform_name" = \
1553     NONENONEs,x,x, &&
1554   program_transform_name=s,y,y,
1555
1556 echo "$as_me:$LINENO: checking host system type" >&5
1557 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1558 if test "${ac_cv_host+set}" = set; then
1559   echo $ECHO_N "(cached) $ECHO_C" >&6
1560 else
1561   ac_cv_host_alias=$host_alias
1562 test -z "$ac_cv_host_alias" &&
1563   ac_cv_host_alias=$ac_cv_build_alias
1564 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1565   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1566 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1567    { (exit 1); exit 1; }; }
1568
1569 fi
1570 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1571 echo "${ECHO_T}$ac_cv_host" >&6
1572 host=$ac_cv_host
1573 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1574 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1575 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1576
1577
1578 echo "$as_me:$LINENO: checking target system type" >&5
1579 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1580 if test "${ac_cv_target+set}" = set; then
1581   echo $ECHO_N "(cached) $ECHO_C" >&6
1582 else
1583   ac_cv_target_alias=$target_alias
1584 test "x$ac_cv_target_alias" = "x" &&
1585   ac_cv_target_alias=$ac_cv_host_alias
1586 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1587   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1588 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1589    { (exit 1); exit 1; }; }
1590
1591 fi
1592 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1593 echo "${ECHO_T}$ac_cv_target" >&6
1594 target=$ac_cv_target
1595 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1596 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1597 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1598
1599
1600 # The aliases save the names the user supplied, while $host etc.
1601 # will get canonicalized.
1602 test -n "$target_alias" &&
1603   test "$program_prefix$program_suffix$program_transform_name" = \
1604     NONENONEs,x,x, &&
1605   program_prefix=${target_alias}-
1606 test "$program_prefix" != NONE &&
1607   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1608 # Use a double $ so make ignores it.
1609 test "$program_suffix" != NONE &&
1610   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1611 # Double any \ or $.  echo might interpret backslashes.
1612 # By default was `s,x,x', remove it if useless.
1613 cat <<\_ACEOF >conftest.sed
1614 s/[\\$]/&&/g;s/;s,x,x,$//
1615 _ACEOF
1616 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1617 rm conftest.sed
1618
1619
1620
1621 # Get 'install' or 'install-sh' and its variants.
1622 # Find a good install program.  We prefer a C program (faster),
1623 # so one script is as good as another.  But avoid the broken or
1624 # incompatible versions:
1625 # SysV /etc/install, /usr/sbin/install
1626 # SunOS /usr/etc/install
1627 # IRIX /sbin/install
1628 # AIX /bin/install
1629 # AmigaOS /C/install, which installs bootblocks on floppy discs
1630 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1631 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1632 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1633 # OS/2's system install, which has a completely different semantic
1634 # ./install, which can be erroneously created by make from ./install.sh.
1635 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1636 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1637 if test -z "$INSTALL"; then
1638 if test "${ac_cv_path_install+set}" = set; then
1639   echo $ECHO_N "(cached) $ECHO_C" >&6
1640 else
1641   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1642 for as_dir in $PATH
1643 do
1644   IFS=$as_save_IFS
1645   test -z "$as_dir" && as_dir=.
1646   # Account for people who put trailing slashes in PATH elements.
1647 case $as_dir/ in
1648   ./ | .// | /cC/* | \
1649   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1650   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1651   /usr/ucb/* ) ;;
1652   *)
1653     # OSF1 and SCO ODT 3.0 have their own names for install.
1654     # Don't use installbsd from OSF since it installs stuff as root
1655     # by default.
1656     for ac_prog in ginstall scoinst install; do
1657       for ac_exec_ext in '' $ac_executable_extensions; do
1658         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1659           if test $ac_prog = install &&
1660             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1661             # AIX install.  It has an incompatible calling convention.
1662             :
1663           elif test $ac_prog = install &&
1664             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1665             # program-specific install script used by HP pwplus--don't use.
1666             :
1667           else
1668             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1669             break 3
1670           fi
1671         fi
1672       done
1673     done
1674     ;;
1675 esac
1676 done
1677
1678
1679 fi
1680   if test "${ac_cv_path_install+set}" = set; then
1681     INSTALL=$ac_cv_path_install
1682   else
1683     # As a last resort, use the slow shell script.  We don't cache a
1684     # path for INSTALL within a source directory, because that will
1685     # break other packages using the cache if that directory is
1686     # removed, or if the path is relative.
1687     INSTALL=$ac_install_sh
1688   fi
1689 fi
1690 echo "$as_me:$LINENO: result: $INSTALL" >&5
1691 echo "${ECHO_T}$INSTALL" >&6
1692
1693 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1694 # It thinks the first close brace ends the variable substitution.
1695 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1696
1697 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1698
1699 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1700
1701 echo "$as_me:$LINENO: checking whether ln works" >&5
1702 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1703 if test "${acx_cv_prog_LN+set}" = set; then
1704   echo $ECHO_N "(cached) $ECHO_C" >&6
1705 else
1706   rm -f conftestdata_t
1707 echo >conftestdata_f
1708 if ln conftestdata_f conftestdata_t 2>/dev/null
1709 then
1710   acx_cv_prog_LN=ln
1711 else
1712   acx_cv_prog_LN=no
1713 fi
1714 rm -f conftestdata_f conftestdata_t
1715
1716 fi
1717 if test $acx_cv_prog_LN = no; then
1718   LN="cp"
1719   echo "$as_me:$LINENO: result: no, using $LN" >&5
1720 echo "${ECHO_T}no, using $LN" >&6
1721 else
1722   LN="$acx_cv_prog_LN"
1723   echo "$as_me:$LINENO: result: yes" >&5
1724 echo "${ECHO_T}yes" >&6
1725 fi
1726
1727 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1728 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1729 LN_S=$as_ln_s
1730 if test "$LN_S" = "ln -s"; then
1731   echo "$as_me:$LINENO: result: yes" >&5
1732 echo "${ECHO_T}yes" >&6
1733 else
1734   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1735 echo "${ECHO_T}no, using $LN_S" >&6
1736 fi
1737
1738
1739 ### we might need to use some other shell than /bin/sh for running subshells
1740 ### If we are on Windows, search for the shell.  This will permit people
1741 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1742 ### without also having to set CONFIG_SHELL.  This code will work when
1743 ### using bash, which sets OSTYPE.
1744 case "${OSTYPE}" in
1745 *win32*)
1746   if test x${CONFIG_SHELL} = x ; then
1747     if test ! -f /bin/sh ; then
1748       if test x${SHELL} != x && test -f ${SHELL} ; then
1749         CONFIG_SHELL=${SHELL}
1750         export CONFIG_SHELL
1751       else
1752         for prog in sh sh.exe bash bash.exe; do
1753           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1754           for dir in $PATH; do
1755             test -z "$dir" && dir=.
1756             if test -f $dir/$prog; then
1757               CONFIG_SHELL=$dir/$prog
1758               export CONFIG_SHELL
1759               break
1760             fi
1761           done
1762           IFS="$save_ifs"
1763           test -n "${CONFIG_SHELL}" && break
1764         done
1765       fi
1766     fi
1767   fi
1768   ;;
1769 esac
1770
1771 config_shell=${CONFIG_SHELL-/bin/sh}
1772
1773 progname=$0
1774 # if PWD already has a value, it is probably wrong.
1775 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1776
1777 # Export original configure arguments for use by sub-configures.
1778 # Quote arguments with shell meta charatcers.
1779 TOPLEVEL_CONFIGURE_ARGUMENTS=
1780 set -- "$progname" "$@"
1781 for ac_arg
1782 do
1783   case "$ac_arg" in
1784   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1785     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1786     # if the argument is of the form -foo=baz, quote the baz part only
1787     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1788   *) ;;
1789   esac
1790   # Add the quoted argument to the list.
1791   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1792 done
1793 if test "$silent" = yes; then
1794   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1795 fi
1796 # Remove the initial space we just introduced and, as these will be
1797 # expanded by make, quote '$'.
1798 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1799
1800
1801 moveifchange=${srcdir}/move-if-change
1802
1803 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1804
1805 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1806 # a relative path.
1807 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1808   INSTALL="${srcpwd}/install-sh -c"
1809 fi
1810
1811 # Set srcdir to "." if that's what it is.
1812 # This is important for multilib support.
1813 pwd=`${PWDCMD-pwd}`
1814 if test "${pwd}" = "${srcpwd}" ; then
1815   srcdir=.
1816 fi
1817
1818 topsrcdir=$srcpwd
1819
1820 extra_host_args=
1821
1822 ### To add a new directory to the tree, first choose whether it is a target
1823 ### or a host dependent tool.  Then put it into the appropriate list
1824 ### (library or tools, host or target), doing a dependency sort.
1825
1826 # Subdirs will be configured in the order listed in build_configdirs,
1827 # configdirs, or target_configdirs; see the serialization section below.
1828
1829 # Dependency sorting is only needed when *configuration* must be done in
1830 # a particular order.  In all cases a dependency should be specified in
1831 # the Makefile, whether or not it's implicitly specified here.
1832
1833 # Double entries in build_configdirs, configdirs, or target_configdirs may
1834 # cause circular dependencies and break everything horribly.
1835
1836 # these library is used by various programs built for the build
1837 # environment
1838 #
1839 build_libs="build-libiberty"
1840
1841 # these tools are built for the build environment
1842 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1843
1844 # these libraries are used by various programs built for the host environment
1845 #
1846 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1847
1848 # these tools are built for the host environment
1849 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1850 # know that we are building the simulator.
1851 # binutils, gas and ld appear in that order because it makes sense to run
1852 # "make check" in that particular order.
1853 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"
1854
1855 # libgcj represents the runtime libraries only used by gcj.
1856 libgcj="target-libffi \
1857         target-zlib \
1858         target-qthreads \
1859         target-libjava"
1860
1861 # these libraries are built for the target environment, and are built after
1862 # the host libraries and the host tools (which may be a cross compiler)
1863 #
1864 target_libraries="target-libgcc \
1865                 target-libiberty \
1866                 target-libgloss \
1867                 target-newlib \
1868                 target-libstdc++-v3 \
1869                 target-libmudflap \
1870                 target-libssp \
1871                 target-libgfortran \
1872                 target-boehm-gc \
1873                 ${libgcj} \
1874                 target-libobjc \
1875                 target-libada \
1876                 target-libgomp"
1877
1878 # these tools are built using the target libraries, and are intended to
1879 # run only in the target environment
1880 #
1881 # note: any program that *uses* libraries that are in the "target_libraries"
1882 # list belongs in this list.  those programs are also very likely
1883 # candidates for the "native_only" list which follows
1884 #
1885 target_tools="target-examples target-groff target-gperf target-rda"
1886
1887 ################################################################################
1888
1889 ## All tools belong in one of the four categories, and are assigned above
1890 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1891 ## is important because configure will choke if they ever get through.
1892 ## ${configdirs} is directories we build using the host tools.
1893 ## ${target_configdirs} is directories we build using the target tools.
1894 configdirs=`echo ${host_libs} ${host_tools}`
1895 target_configdirs=`echo ${target_libraries} ${target_tools}`
1896 build_configdirs=`echo ${build_libs} ${build_tools}`
1897
1898 ################################################################################
1899
1900 srcname="gnu development package"
1901
1902 # This gets set non-empty for some net releases of packages.
1903 appdirs=""
1904
1905 # Define is_cross_compiler to save on calls to 'test'.
1906 is_cross_compiler=
1907 if test x"${host}" = x"${target}" ; then
1908   is_cross_compiler=no
1909 else
1910   is_cross_compiler=yes
1911 fi
1912
1913 # Find the build and target subdir names.
1914
1915 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1916 # have matching libraries, they should use host libraries: Makefile.tpl
1917 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1918 # However, they still use the build modules, because the corresponding
1919 # host modules (e.g. bison) are only built for the host when bootstrap
1920 # finishes. So:
1921 # - build_subdir is where we find build modules, and never changes.
1922 # - build_libsubdir is where we find build libraries, and can be overridden.
1923
1924 # Prefix 'build-' so this never conflicts with target_subdir.
1925 build_subdir="build-${build_noncanonical}"
1926
1927 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1928 if test "${with_build_libsubdir+set}" = set; then
1929   withval="$with_build_libsubdir"
1930   build_libsubdir="$withval"
1931 else
1932   build_libsubdir="$build_subdir"
1933 fi;
1934 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1935 if ( test $srcdir = . && test -d gcc ) \
1936    || test -d $srcdir/../host-${host_noncanonical}; then
1937   host_subdir="host-${host_noncanonical}"
1938 else
1939   host_subdir=.
1940 fi
1941 # No prefix.
1942 target_subdir=${target_noncanonical}
1943
1944
1945 # Skipdirs are removed silently.
1946 skipdirs=
1947 # Noconfigdirs are removed loudly.
1948 noconfigdirs=""
1949
1950 use_gnu_ld=
1951 # Make sure we don't let GNU ld be added if we didn't want it.
1952 if test x$with_gnu_ld = xno ; then
1953   use_gnu_ld=no
1954   noconfigdirs="$noconfigdirs ld"
1955 fi
1956
1957 use_gnu_as=
1958 # Make sure we don't let GNU as be added if we didn't want it.
1959 if test x$with_gnu_as = xno ; then
1960   use_gnu_as=no
1961   noconfigdirs="$noconfigdirs gas"
1962 fi
1963
1964 # some tools are so dependent upon X11 that if we're not building with X,
1965 # it's not even worth trying to configure, much less build, that tool.
1966
1967 case ${with_x} in
1968   yes | "") ;; # the default value for this tree is that X11 is available
1969   no)
1970     skipdirs="${skipdirs} tk itcl libgui"
1971     # We won't be able to build gdbtk without X.
1972     enable_gdbtk=no
1973     ;;
1974   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1975 esac
1976
1977 # Some tools are only suitable for building in a "native" situation.
1978 # Remove these if host!=target.
1979 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"
1980
1981 # Similarly, some are only suitable for cross toolchains.
1982 # Remove these if host=target.
1983 cross_only="target-libgloss target-newlib target-opcodes"
1984
1985 case $is_cross_compiler in
1986   no) skipdirs="${skipdirs} ${cross_only}" ;;
1987   yes) skipdirs="${skipdirs} ${native_only}" ;;
1988 esac
1989
1990 # If both --with-headers and --with-libs are specified, default to
1991 # --without-newlib.
1992 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
1993    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
1994   if test x"${with_newlib}" = x ; then
1995     with_newlib=no
1996   fi
1997 fi
1998
1999 # Recognize --with-newlib/--without-newlib.
2000 case ${with_newlib} in
2001   no) skipdirs="${skipdirs} target-newlib" ;;
2002   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2003 esac
2004
2005 # Configure extra directories which are host specific
2006
2007 case "${host}" in
2008   *-cygwin*)
2009     configdirs="$configdirs libtermcap" ;;
2010 esac
2011
2012 # A target can indicate whether a language isn't supported for some reason.
2013 # Only spaces may be used in this macro; not newlines or tabs.
2014 unsupported_languages=
2015
2016 # Remove more programs from consideration, based on the host or
2017 # target this usually means that a port of the program doesn't
2018 # exist yet.
2019
2020 case "${host}" in
2021   hppa*64*-*-*)
2022     noconfigdirs="$noconfigdirs byacc"
2023     ;;
2024   i[3456789]86-*-vsta)
2025     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2026     ;;
2027   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2028     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2029     ;;
2030   x86_64-*-mingw*)
2031     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2032     ;;
2033   i[3456789]86-*-mingw32*)
2034     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2035     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2036     ;;
2037   i[3456789]86-*-beos*)
2038     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2039     ;;
2040   *-*-cygwin*)
2041     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2042     ;;
2043   *-*-netbsd*)
2044     noconfigdirs="$noconfigdirs rcs"
2045     ;;
2046   ppc*-*-pe)
2047     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2048     ;;
2049   powerpc-*-beos*)
2050     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2051     ;;
2052 esac
2053
2054
2055 # Check whether --enable-libada or --disable-libada was given.
2056 if test "${enable_libada+set}" = set; then
2057   enableval="$enable_libada"
2058   ENABLE_LIBADA=$enableval
2059 else
2060   ENABLE_LIBADA=yes
2061 fi;
2062 if test "${ENABLE_LIBADA}" != "yes" ; then
2063   noconfigdirs="$noconfigdirs gnattools"
2064 fi
2065
2066 # Check whether --enable-libssp or --disable-libssp was given.
2067 if test "${enable_libssp+set}" = set; then
2068   enableval="$enable_libssp"
2069   ENABLE_LIBSSP=$enableval
2070 else
2071   ENABLE_LIBSSP=yes
2072 fi;
2073
2074 # Save it here so that, even in case of --enable-libgcj, if the Java
2075 # front-end isn't enabled, we still get libgcj disabled.
2076 libgcj_saved=$libgcj
2077 case $enable_libgcj in
2078 yes)
2079   # If we reset it here, it won't get added to noconfigdirs in the
2080   # target-specific build rules, so it will be forcibly enabled
2081   # (unless the Java language itself isn't enabled).
2082   libgcj=
2083   ;;
2084 no)
2085   # Make sure we get it printed in the list of not supported target libs.
2086   noconfigdirs="$noconfigdirs ${libgcj}"
2087   ;;
2088 esac
2089
2090
2091 # Disable libmudflap on some systems.
2092 if test x$enable_libmudflap = x ; then
2093     case "${target}" in
2094     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2095         # Enable libmudflap by default in GNU and friends.
2096         ;;
2097     *-*-freebsd*)
2098         # Enable libmudflap by default in FreeBSD.
2099         ;;
2100     *)
2101         # Disable it by default everywhere else.
2102         noconfigdirs="$noconfigdirs target-libmudflap"
2103         ;;
2104     esac
2105 fi
2106
2107 # Disable libgomp on non POSIX hosted systems.
2108 if test x$enable_libgomp = x ; then
2109     # Enable libgomp by default on hosted POSIX systems.
2110     case "${target}" in
2111     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2112         ;;
2113     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2114         ;;
2115     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2116         ;;
2117     *-*-darwin* | *-*-aix*)
2118         ;;
2119     *)
2120         noconfigdirs="$noconfigdirs target-libgomp"
2121         ;;
2122     esac
2123 fi
2124
2125 # Default libgloss CPU subdirectory.
2126 libgloss_dir="$target_cpu"
2127
2128 case "${target}" in
2129   *-*-chorusos)
2130     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2131     ;;
2132   powerpc-*-darwin* | i[3456789]86-*-darwin*)
2133     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2134     noconfigdirs="$noconfigdirs sim target-rda"
2135     ;;
2136   *-*-darwin*)
2137     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2138     noconfigdirs="$noconfigdirs sim target-rda"
2139     noconfigdirs="$noconfigdirs ${libgcj}"
2140     ;;
2141   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2142     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2143     ;;
2144   *-*-freebsd*)
2145     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2146     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2147         && test -f /usr/local/include/gmp.h; then
2148       with_gmp=/usr/local
2149     fi
2150
2151     # Skip some stuff that's unsupported on some FreeBSD configurations.
2152     case "${target}" in
2153       i*86-*-*) ;;
2154       alpha*-*-*) ;;
2155       *)
2156         noconfigdirs="$noconfigdirs ${libgcj}"
2157         ;;
2158     esac
2159     ;;
2160   *-*-kaos*)
2161     # Remove unsupported stuff on all kaOS configurations.
2162     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2163     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2164     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2165     noconfigdirs="$noconfigdirs target-libgloss"
2166     ;;
2167   *-*-netbsd*)
2168     # Skip some stuff on all NetBSD configurations.
2169     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2170
2171     # Skip some stuff that's unsupported on some NetBSD configurations.
2172     case "${target}" in
2173       i*86-*-netbsdelf*) ;;
2174       arm*-*-netbsdelf*) ;;
2175       *)
2176         noconfigdirs="$noconfigdirs ${libgcj}"
2177         ;;
2178     esac
2179     ;;
2180   *-*-netware*)
2181     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2182     ;;
2183   *-*-rtems*)
2184     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2185     ;;
2186     # The tpf target doesn't support gdb yet.
2187   *-*-tpf*)
2188     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2189     ;;
2190   *-*-uclinux*)
2191     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2192     ;;
2193   *-*-vxworks*)
2194     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2195     ;;
2196   alpha*-dec-osf*)
2197     # ld works, but does not support shared libraries.
2198     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2199     # gas doesn't generate exception information.
2200     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2201     ;;
2202   alpha*-*-*vms*)
2203     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2204     ;;
2205   alpha*-*-linux*)
2206     # newlib is not 64 bit ready
2207     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2208     ;;
2209   alpha*-*-*)
2210     # newlib is not 64 bit ready
2211     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2212     ;;
2213   am33_2.0-*-linux*)
2214     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2215     ;;
2216   sh-*-linux*)
2217     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2218     ;;
2219   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2220     noconfigdirs="$noconfigdirs ${libgcj}"
2221     noconfigdirs="$noconfigdirs target-examples"
2222     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2223     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2224     noconfigdirs="$noconfigdirs expect dejagnu"
2225     # the C++ libraries don't build on top of CE's C libraries
2226     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2227     noconfigdirs="$noconfigdirs target-newlib"
2228     case "${host}" in
2229       *-*-cygwin*) ;; # keep gdb and readline
2230       *) noconfigdirs="$noconfigdirs gdb readline"
2231          ;;
2232     esac
2233     libgloss_dir=wince
2234     ;;
2235   arc-*-*)
2236     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2237     ;;
2238   arm-semi-aof )
2239     ;;
2240   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2241     noconfigdirs="$noconfigdirs ${libgcj}"
2242     libgloss_dir=arm
2243     ;;
2244   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2245     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2246     libgloss_dir=arm
2247     ;;
2248   arm*-*-linux-gnueabi)
2249     noconfigdirs="$noconfigdirs target-qthreads"
2250     noconfigdirs="$noconfigdirs target-libobjc"
2251     case ${with_newlib} in
2252       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2253     esac
2254     libgloss_dir=arm
2255     ;;
2256   arm*-*-symbianelf*)
2257     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2258     libgloss_dir=arm
2259     ;;
2260   arm-*-pe*)
2261     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2262     ;;
2263   thumb-*-coff)
2264     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2265     ;;
2266   thumb-*-elf)
2267     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2268     ;;
2269   thumb-*-pe)
2270     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2271     ;;
2272   arm-*-riscix*)
2273     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2274     ;;
2275   avr-*-*)
2276     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2277     ;;
2278   bfin-*-*)
2279     noconfigdirs="$noconfigdirs gdb"
2280     if test x${is_cross_compiler} != xno ; then
2281       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2282     fi
2283     ;;
2284   c4x-*-* | tic4x-*-*)
2285     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2286     ;;
2287   c54x*-*-* | tic54x-*-*)
2288     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2289     ;;
2290   cris-*-* | crisv32-*-*)
2291     unsupported_languages="$unsupported_languages java"
2292     case "${target}" in
2293       *-*-aout)
2294         unsupported_languages="$unsupported_languages fortran"
2295         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2296       *-*-elf)
2297         unsupported_languages="$unsupported_languages fortran"
2298         noconfigdirs="$noconfigdirs target-boehm-gc";;
2299       *-*-linux*)
2300         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2301       *)
2302         unsupported_languages="$unsupported_languages fortran"
2303         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2304     esac
2305     libgloss_dir=cris
2306     ;;
2307   crx-*-*)
2308     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2309     ;;
2310   d10v-*-*)
2311     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2312     ;;
2313   d30v-*-*)
2314     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2315     ;;
2316   ep9312-*-elf | ep9312-*-coff)
2317     libgloss_dir=arm
2318     ;;
2319   fr30-*-elf*)
2320     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2321     ;;
2322   frv-*-*)
2323     noconfigdirs="$noconfigdirs ${libgcj}"
2324     ;;
2325   h8300*-*-*)
2326     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2327     ;;
2328   h8500-*-*)
2329     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2330     ;;
2331   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2332     ;;
2333   hppa*64*-*-linux* | parisc*64*-*-linux*)
2334     # In this case, it's because the hppa64-linux target is for
2335     # the kernel only at this point and has no libc, and thus no
2336     # headers, crt*.o, etc., all of which are needed by these.
2337     noconfigdirs="$noconfigdirs target-zlib"
2338     ;;
2339   parisc*-*-linux* | hppa*-*-linux*)
2340     ;;
2341   hppa*-*-*elf* | \
2342   hppa*-*-lites* | \
2343   hppa*-*-openbsd* | \
2344   hppa*64*-*-*)
2345     noconfigdirs="$noconfigdirs ${libgcj}"
2346     ;;
2347   hppa*-hp-hpux11*)
2348     noconfigdirs="$noconfigdirs ld shellutils"
2349     ;;
2350   hppa*-*-pro*)
2351     libgloss_dir=pa
2352     ;;
2353   hppa*-*-*)
2354     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2355     # build on HP-UX 10.20.
2356     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2357     ;;
2358   i960-*-*)
2359     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2360     ;;
2361   ia64*-*-elf*)
2362     # No gdb support yet.
2363     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2364     ;;
2365   ia64*-**-hpux*)
2366     # No gdb or ld support yet.
2367     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2368     ;;
2369   i370-*-opened*)
2370     ;;
2371   i[3456789]86-*-coff | i[3456789]86-*-elf)
2372     noconfigdirs="$noconfigdirs ${libgcj}"
2373     libgloss_dir=i386
2374     ;;
2375   i[3456789]86-*-linux*)
2376     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2377     # not build java stuff by default.
2378     case "${target}" in
2379       *-*-*libc1*)
2380         noconfigdirs="$noconfigdirs ${libgcj}";;
2381     esac
2382
2383     # This section makes it possible to build newlib natively on linux.
2384     # If we are using a cross compiler then don't configure newlib.
2385     if test x${is_cross_compiler} != xno ; then
2386       noconfigdirs="$noconfigdirs target-newlib"
2387     fi
2388     noconfigdirs="$noconfigdirs target-libgloss"
2389     # If we are not using a cross compiler, do configure newlib.
2390     # Note however, that newlib will only be configured in this situation
2391     # if the --with-newlib option has been given, because otherwise
2392     # 'target-newlib' will appear in skipdirs.
2393     ;;
2394   i[3456789]86-*-mingw32*)
2395     target_configdirs="$target_configdirs target-winsup"
2396     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2397     ;;
2398   x86_64-*-mingw*)
2399     target_configdirs="$target_configdirs target-winsup"
2400     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2401     ;;
2402   *-*-cygwin*)
2403     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2404     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2405     # always build newlib if winsup directory is present.
2406     if test -d "$srcdir/winsup/cygwin"; then
2407       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2408     elif test -d "$srcdir/newlib"; then
2409       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2410     fi
2411     ;;
2412   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2413   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2414     ;;
2415   i[3456789]86-*-pe)
2416     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2417     ;;
2418   i[3456789]86-*-sco3.2v5*)
2419     # The linker does not yet know about weak symbols in COFF,
2420     # and is not configured to handle mixed ELF and COFF.
2421     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2422     ;;
2423   i[3456789]86-*-sco*)
2424     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2425     ;;
2426   i[3456789]86-*-solaris2*)
2427     noconfigdirs="$noconfigdirs target-libgloss"
2428     ;;
2429   i[3456789]86-*-sysv4*)
2430     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2431     ;;
2432   i[3456789]86-*-beos*)
2433     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2434     ;;
2435   i[3456789]86-*-rdos*)
2436     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2437     ;;
2438   m32r-*-*)
2439     noconfigdirs="$noconfigdirs ${libgcj}"
2440     ;;
2441   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2442     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2443     libgloss_dir=m68hc11
2444     ;;
2445   m68k-*-elf*)
2446     noconfigdirs="$noconfigdirs ${libgcj}"
2447     ;;
2448   m68k-*-coff*)
2449     noconfigdirs="$noconfigdirs ${libgcj}"
2450     ;;
2451   m68*-*-* | fido-*-*)
2452     libgloss_dir=m68k
2453     ;;
2454   mcore-*-pe*)
2455   # The EPOC C++ environment does not support exceptions or rtti,
2456   # and so building libstdc++-v3 tends not to always work.
2457     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2458     ;;
2459   mmix-*-*)
2460     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2461     unsupported_languages="$unsupported_languages fortran java"
2462     ;;
2463   mn10200-*-*)
2464     noconfigdirs="$noconfigdirs ${libgcj}"
2465     ;;
2466   mn10300-*-*)
2467     noconfigdirs="$noconfigdirs ${libgcj}"
2468     ;;
2469   mt-*-*)
2470     noconfigdirs="$noconfigdirs sim"
2471     ;;
2472   powerpc-*-aix*)
2473     # copied from rs6000-*-* entry
2474     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2475     ;;
2476   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2477     target_configdirs="$target_configdirs target-winsup"
2478     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2479     # always build newlib.
2480     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2481     ;;
2482     # This is temporary until we can link against shared libraries
2483   powerpcle-*-solaris*)
2484     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2485     libgloss_dir=rs6000
2486     ;;
2487   powerpc-*-beos*)
2488     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2489     ;;
2490   powerpc-*-eabi)
2491     noconfigdirs="$noconfigdirs ${libgcj}"
2492     libgloss_dir=rs6000
2493     ;;
2494   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2495     libgloss_dir=rs6000
2496     ;;
2497   rs6000-*-lynxos*)
2498     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2499     ;;
2500   rs6000-*-aix*)
2501     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2502     ;;
2503   rs6000-*-*)
2504     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2505     ;;
2506   m68k-apollo-*)
2507     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2508     ;;
2509   mips*-sde-elf*)
2510     skipdirs="$skipdirs target-libiberty"
2511     noconfigdirs="$noconfigdirs ${libgcj}"
2512     if test x$with_newlib = xyes; then
2513       noconfigdirs="$noconfigdirs gprof"
2514     fi
2515     libgloss_dir=mips
2516     ;;
2517   mips*-*-irix5*)
2518     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2519     ;;
2520   mips*-*-irix6*)
2521     # Linking libjava exceeds command-line length limits on at least
2522     # IRIX 6.2, but not on IRIX 6.5.
2523     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2524     # <oldham@codesourcery.com>
2525     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2526     ;;
2527   mips*-*-bsd*)
2528     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2529     ;;
2530   mips*-*-linux*)
2531     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2532     ;;
2533   mips*-*-*)
2534     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2535     libgloss_dir=mips
2536     ;;
2537   romp-*-*)
2538     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2539     ;;
2540   sh-*-* | sh64-*-*)
2541     case "${host}" in
2542       i[3456789]86-*-vsta) ;; # don't add gprof back in
2543       i[3456789]86-*-go32*) ;; # don't add gprof back in
2544       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2545       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2546     esac
2547     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2548     ;;
2549   sparclet-*-aout* | sparc86x-*-*)
2550     libgloss_dir=sparc
2551     ;;
2552   sparc-*-elf*)
2553     noconfigdirs="$noconfigdirs ${libgcj}"
2554     ;;
2555   sparc64-*-elf*)
2556     noconfigdirs="$noconfigdirs ${libgcj}"
2557     libgloss_dir=sparc
2558     ;;
2559   sparclite-*-*)
2560     noconfigdirs="$noconfigdirs ${libgcj}"
2561     libgloss_dir=sparc
2562     ;;
2563   sparc-*-sunos4*)
2564     noconfigdirs="$noconfigdirs ${libgcj}"
2565     if test x${is_cross_compiler} != xno ; then
2566            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2567     else
2568            use_gnu_ld=no
2569     fi
2570     ;;
2571   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2572     noconfigdirs="$noconfigdirs ${libgcj}"
2573     ;;
2574   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2575     ;;
2576   spu-*-*)
2577     skipdirs="target-libssp"
2578     ;;
2579   v810-*-*)
2580     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2581     ;;
2582   v850-*-*)
2583     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2584     ;;
2585   v850e-*-*)
2586     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2587     ;;
2588   v850ea-*-*)
2589     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2590     ;;
2591   vax-*-vms)
2592     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2593     ;;
2594   vax-*-*)
2595     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2596     ;;
2597   xtensa-*-*)
2598     noconfigdirs="$noconfigdirs ${libgcj}"
2599     ;;
2600   ip2k-*-*)
2601     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2602     ;;
2603   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2604     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2605     ;;
2606   *-*-lynxos*)
2607     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2608     ;;
2609   *-*-*)
2610     noconfigdirs="$noconfigdirs ${libgcj}"
2611     ;;
2612 esac
2613
2614 # If we aren't building newlib, then don't build libgloss, since libgloss
2615 # depends upon some newlib header files.
2616 case "${noconfigdirs}" in
2617   *target-libgloss*) ;;
2618   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2619 esac
2620
2621 # Work in distributions that contain no compiler tools, like Autoconf.
2622 tentative_cc=""
2623 host_makefile_frag=/dev/null
2624 if test -d ${srcdir}/config ; then
2625 case "${host}" in
2626   m68k-hp-hpux*)
2627     # Avoid "too much defining" errors from HPUX compiler.
2628     tentative_cc="cc -Wp,-H256000"
2629     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2630     # If it's HP/UX ar, this should be harmless.
2631     RANLIB="ar ts"
2632     ;;
2633   m68k-apollo-sysv*)
2634     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2635     ;;
2636   m68k-apollo-bsd*)
2637     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2638     # chokes on bfd, the compiler won't let you assign integers to enums, and
2639     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2640     # the apollo compiler" (the preferred version of GCC could be called cc,
2641     # or whatever), but I'm not sure leaving CC as cc is any better...
2642     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2643     # Used to have BISON=yacc.
2644     tentative_cc=gcc
2645     ;;
2646   m88k-dg-dgux*)
2647     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2648     ;;
2649   m88k-harris-cxux*)
2650     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2651     tentative_cc="cc -Xa"
2652     host_makefile_frag="config/mh-cxux"
2653     ;;
2654   m88k-motorola-sysv*)
2655     ;;
2656   mips*-dec-ultrix*)
2657     tentative_cc="cc -Wf,-XNg1000"
2658     host_makefile_frag="config/mh-decstation"
2659     ;;
2660   mips*-nec-sysv4*)
2661     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2662     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2663     host_makefile_frag="config/mh-necv4"
2664     ;;
2665   mips*-sgi-irix4*)
2666     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2667     # environment.  Also bump switch table size so that cp-parse will
2668     # compile.  Bump string length limit so linker builds.
2669     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2670     ;;
2671   mips*-*-sysv4*)
2672     host_makefile_frag="config/mh-sysv4"
2673     ;;
2674   mips*-*-sysv*)
2675     # This is for a MIPS running RISC/os 4.52C.
2676
2677     # This is needed for GDB, but needs to be in the top-level make because
2678     # if a library is compiled with the bsd headers and gets linked with the
2679     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2680     # a different size).
2681     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2682     # known except to select the sysv environment.  Could we use /proc instead?
2683     # These "sysv environments" and "bsd environments" often end up being a pain.
2684     #
2685     # This is not part of CFLAGS because perhaps not all C compilers have this
2686     # option.
2687     tentative_cc="cc -systype sysv"
2688     ;;
2689   i370-ibm-opened*)
2690     tentative_cc="c89"
2691     ;;
2692   i[3456789]86-*-sysv5*)
2693     host_makefile_frag="config/mh-sysv5"
2694     ;;
2695   i[3456789]86-*-dgux*)
2696     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2697     host_makefile_frag="config/mh-dgux386"
2698     ;;
2699   i[3456789]86-ncr-sysv4.3*)
2700     # The MetaWare compiler will generate a copyright message unless you
2701     # turn it off by adding the -Hnocopyr flag.
2702     tentative_cc="cc -Hnocopyr"
2703     ;;
2704   i[3456789]86-ncr-sysv4*)
2705     # for an NCR 3000 (i486/SVR4) system.
2706     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2707     # This compiler not only emits obnoxious copyright messages every time
2708     # you run it, but it chokes and dies on a whole bunch of GNU source
2709     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2710     tentative_cc="/usr/ccs/ATT/cc"
2711     host_makefile_frag="config/mh-ncr3000"
2712     ;;
2713   i[3456789]86-*-sco3.2v5*)
2714     ;;
2715   i[3456789]86-*-sco*)
2716     # The native C compiler botches some simple uses of const.  Unfortunately,
2717     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2718     tentative_cc="cc -Dconst="
2719     host_makefile_frag="config/mh-sco"
2720     ;;
2721   i[3456789]86-*-udk*)
2722     host_makefile_frag="config/mh-sysv5"
2723     ;;
2724   i[3456789]86-*-solaris2*)
2725     host_makefile_frag="config/mh-sysv4"
2726     ;;
2727   i[3456789]86-*-msdosdjgpp*)
2728     host_makefile_frag="config/mh-djgpp"
2729     ;;
2730   *-cygwin*)
2731     host_makefile_frag="config/mh-cygwin"
2732     ;;
2733   *-mingw32*)
2734     host_makefile_frag="config/mh-mingw"
2735     ;;
2736   *-mingw64*)
2737     host_makefile_frag="config/mh-mingw"
2738     ;;
2739   *-interix*)
2740     host_makefile_frag="config/mh-interix"
2741     ;;
2742   vax-*-ultrix2*)
2743     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2744     tentative_cc=gcc
2745     ;;
2746   *-*-solaris2*)
2747     host_makefile_frag="config/mh-solaris"
2748     ;;
2749   m68k-sun-sunos*)
2750     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2751     # without overflowing the jump tables (-J says to use a 32 bit table)
2752     tentative_cc="cc -J"
2753     ;;
2754   *-hp-hpux*)
2755     tentative_cc="cc -Wp,-H256000"
2756     ;;
2757   *-*-hiux*)
2758     tentative_cc="cc -Wp,-H256000"
2759     ;;
2760   rs6000-*-lynxos*)
2761     # /bin/cc is less than useful for our purposes.  Always use GCC
2762     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2763     host_makefile_frag="config/mh-lynxrs6k"
2764     ;;
2765   powerpc-*-darwin*)
2766     host_makefile_frag="config/mh-ppc-darwin"
2767     ;;
2768   powerpc-*-aix*)
2769     host_makefile_frag="config/mh-ppc-aix"
2770     ;;
2771   rs6000-*-aix*)
2772     host_makefile_frag="config/mh-ppc-aix"
2773     ;;
2774   *-*-lynxos*)
2775     # /bin/cc is less than useful for our purposes.  Always use GCC
2776     tentative_cc="/bin/gcc"
2777     ;;
2778   *-*-sysv4*)
2779     host_makefile_frag="config/mh-sysv4"
2780     ;;
2781   # This is placed last to prevent interfering with the cases above.
2782   i[3456789]86-*-*)
2783     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2784     host_makefile_frag="config/mh-x86omitfp"
2785     ;;
2786 esac
2787 fi
2788
2789 # If we aren't going to be using gcc, see if we can extract a definition
2790 # of CC from the fragment.
2791 # Actually, use the 'pre-extracted' version above.
2792 if test -z "${CC}" && test "${build}" = "${host}" ; then
2793   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2794   found=
2795   for dir in $PATH; do
2796     test -z "$dir" && dir=.
2797     if test -f $dir/gcc; then
2798       found=yes
2799       break
2800     fi
2801   done
2802   IFS="$save_ifs"
2803   if test -z "${found}" && test -n "${tentative_cc}" ; then
2804     CC=$tentative_cc
2805   fi
2806 fi
2807
2808 if test "${build}" != "${host}" ; then
2809   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2810 else
2811   CC_FOR_BUILD="\$(CC)"
2812 fi
2813
2814 ac_ext=c
2815 ac_cpp='$CPP $CPPFLAGS'
2816 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2817 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2818 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2819 if test -n "$ac_tool_prefix"; then
2820   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2821 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2822 echo "$as_me:$LINENO: checking for $ac_word" >&5
2823 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2824 if test "${ac_cv_prog_CC+set}" = set; then
2825   echo $ECHO_N "(cached) $ECHO_C" >&6
2826 else
2827   if test -n "$CC"; then
2828   ac_cv_prog_CC="$CC" # Let the user override the test.
2829 else
2830 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2831 for as_dir in $PATH
2832 do
2833   IFS=$as_save_IFS
2834   test -z "$as_dir" && as_dir=.
2835   for ac_exec_ext in '' $ac_executable_extensions; do
2836   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2837     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2838     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2839     break 2
2840   fi
2841 done
2842 done
2843
2844 fi
2845 fi
2846 CC=$ac_cv_prog_CC
2847 if test -n "$CC"; then
2848   echo "$as_me:$LINENO: result: $CC" >&5
2849 echo "${ECHO_T}$CC" >&6
2850 else
2851   echo "$as_me:$LINENO: result: no" >&5
2852 echo "${ECHO_T}no" >&6
2853 fi
2854
2855 fi
2856 if test -z "$ac_cv_prog_CC"; then
2857   ac_ct_CC=$CC
2858   # Extract the first word of "gcc", so it can be a program name with args.
2859 set dummy gcc; ac_word=$2
2860 echo "$as_me:$LINENO: checking for $ac_word" >&5
2861 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2862 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2863   echo $ECHO_N "(cached) $ECHO_C" >&6
2864 else
2865   if test -n "$ac_ct_CC"; then
2866   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2867 else
2868 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2869 for as_dir in $PATH
2870 do
2871   IFS=$as_save_IFS
2872   test -z "$as_dir" && as_dir=.
2873   for ac_exec_ext in '' $ac_executable_extensions; do
2874   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2875     ac_cv_prog_ac_ct_CC="gcc"
2876     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2877     break 2
2878   fi
2879 done
2880 done
2881
2882 fi
2883 fi
2884 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2885 if test -n "$ac_ct_CC"; then
2886   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2887 echo "${ECHO_T}$ac_ct_CC" >&6
2888 else
2889   echo "$as_me:$LINENO: result: no" >&5
2890 echo "${ECHO_T}no" >&6
2891 fi
2892
2893   CC=$ac_ct_CC
2894 else
2895   CC="$ac_cv_prog_CC"
2896 fi
2897
2898 if test -z "$CC"; then
2899   if test -n "$ac_tool_prefix"; then
2900   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2901 set dummy ${ac_tool_prefix}cc; ac_word=$2
2902 echo "$as_me:$LINENO: checking for $ac_word" >&5
2903 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2904 if test "${ac_cv_prog_CC+set}" = set; then
2905   echo $ECHO_N "(cached) $ECHO_C" >&6
2906 else
2907   if test -n "$CC"; then
2908   ac_cv_prog_CC="$CC" # Let the user override the test.
2909 else
2910 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2911 for as_dir in $PATH
2912 do
2913   IFS=$as_save_IFS
2914   test -z "$as_dir" && as_dir=.
2915   for ac_exec_ext in '' $ac_executable_extensions; do
2916   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2917     ac_cv_prog_CC="${ac_tool_prefix}cc"
2918     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2919     break 2
2920   fi
2921 done
2922 done
2923
2924 fi
2925 fi
2926 CC=$ac_cv_prog_CC
2927 if test -n "$CC"; then
2928   echo "$as_me:$LINENO: result: $CC" >&5
2929 echo "${ECHO_T}$CC" >&6
2930 else
2931   echo "$as_me:$LINENO: result: no" >&5
2932 echo "${ECHO_T}no" >&6
2933 fi
2934
2935 fi
2936 if test -z "$ac_cv_prog_CC"; then
2937   ac_ct_CC=$CC
2938   # Extract the first word of "cc", so it can be a program name with args.
2939 set dummy cc; ac_word=$2
2940 echo "$as_me:$LINENO: checking for $ac_word" >&5
2941 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2942 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2943   echo $ECHO_N "(cached) $ECHO_C" >&6
2944 else
2945   if test -n "$ac_ct_CC"; then
2946   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2947 else
2948 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2949 for as_dir in $PATH
2950 do
2951   IFS=$as_save_IFS
2952   test -z "$as_dir" && as_dir=.
2953   for ac_exec_ext in '' $ac_executable_extensions; do
2954   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2955     ac_cv_prog_ac_ct_CC="cc"
2956     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2957     break 2
2958   fi
2959 done
2960 done
2961
2962 fi
2963 fi
2964 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2965 if test -n "$ac_ct_CC"; then
2966   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2967 echo "${ECHO_T}$ac_ct_CC" >&6
2968 else
2969   echo "$as_me:$LINENO: result: no" >&5
2970 echo "${ECHO_T}no" >&6
2971 fi
2972
2973   CC=$ac_ct_CC
2974 else
2975   CC="$ac_cv_prog_CC"
2976 fi
2977
2978 fi
2979 if test -z "$CC"; then
2980   # Extract the first word of "cc", so it can be a program name with args.
2981 set dummy cc; ac_word=$2
2982 echo "$as_me:$LINENO: checking for $ac_word" >&5
2983 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2984 if test "${ac_cv_prog_CC+set}" = set; then
2985   echo $ECHO_N "(cached) $ECHO_C" >&6
2986 else
2987   if test -n "$CC"; then
2988   ac_cv_prog_CC="$CC" # Let the user override the test.
2989 else
2990   ac_prog_rejected=no
2991 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2992 for as_dir in $PATH
2993 do
2994   IFS=$as_save_IFS
2995   test -z "$as_dir" && as_dir=.
2996   for ac_exec_ext in '' $ac_executable_extensions; do
2997   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2998     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2999        ac_prog_rejected=yes
3000        continue
3001      fi
3002     ac_cv_prog_CC="cc"
3003     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3004     break 2
3005   fi
3006 done
3007 done
3008
3009 if test $ac_prog_rejected = yes; then
3010   # We found a bogon in the path, so make sure we never use it.
3011   set dummy $ac_cv_prog_CC
3012   shift
3013   if test $# != 0; then
3014     # We chose a different compiler from the bogus one.
3015     # However, it has the same basename, so the bogon will be chosen
3016     # first if we set CC to just the basename; use the full file name.
3017     shift
3018     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3019   fi
3020 fi
3021 fi
3022 fi
3023 CC=$ac_cv_prog_CC
3024 if test -n "$CC"; then
3025   echo "$as_me:$LINENO: result: $CC" >&5
3026 echo "${ECHO_T}$CC" >&6
3027 else
3028   echo "$as_me:$LINENO: result: no" >&5
3029 echo "${ECHO_T}no" >&6
3030 fi
3031
3032 fi
3033 if test -z "$CC"; then
3034   if test -n "$ac_tool_prefix"; then
3035   for ac_prog in cl
3036   do
3037     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3038 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3039 echo "$as_me:$LINENO: checking for $ac_word" >&5
3040 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3041 if test "${ac_cv_prog_CC+set}" = set; then
3042   echo $ECHO_N "(cached) $ECHO_C" >&6
3043 else
3044   if test -n "$CC"; then
3045   ac_cv_prog_CC="$CC" # Let the user override the test.
3046 else
3047 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3048 for as_dir in $PATH
3049 do
3050   IFS=$as_save_IFS
3051   test -z "$as_dir" && as_dir=.
3052   for ac_exec_ext in '' $ac_executable_extensions; do
3053   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3054     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3055     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3056     break 2
3057   fi
3058 done
3059 done
3060
3061 fi
3062 fi
3063 CC=$ac_cv_prog_CC
3064 if test -n "$CC"; then
3065   echo "$as_me:$LINENO: result: $CC" >&5
3066 echo "${ECHO_T}$CC" >&6
3067 else
3068   echo "$as_me:$LINENO: result: no" >&5
3069 echo "${ECHO_T}no" >&6
3070 fi
3071
3072     test -n "$CC" && break
3073   done
3074 fi
3075 if test -z "$CC"; then
3076   ac_ct_CC=$CC
3077   for ac_prog in cl
3078 do
3079   # Extract the first word of "$ac_prog", so it can be a program name with args.
3080 set dummy $ac_prog; ac_word=$2
3081 echo "$as_me:$LINENO: checking for $ac_word" >&5
3082 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3083 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3084   echo $ECHO_N "(cached) $ECHO_C" >&6
3085 else
3086   if test -n "$ac_ct_CC"; then
3087   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3088 else
3089 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3090 for as_dir in $PATH
3091 do
3092   IFS=$as_save_IFS
3093   test -z "$as_dir" && as_dir=.
3094   for ac_exec_ext in '' $ac_executable_extensions; do
3095   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3096     ac_cv_prog_ac_ct_CC="$ac_prog"
3097     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3098     break 2
3099   fi
3100 done
3101 done
3102
3103 fi
3104 fi
3105 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3106 if test -n "$ac_ct_CC"; then
3107   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3108 echo "${ECHO_T}$ac_ct_CC" >&6
3109 else
3110   echo "$as_me:$LINENO: result: no" >&5
3111 echo "${ECHO_T}no" >&6
3112 fi
3113
3114   test -n "$ac_ct_CC" && break
3115 done
3116
3117   CC=$ac_ct_CC
3118 fi
3119
3120 fi
3121
3122
3123 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3124 See \`config.log' for more details." >&5
3125 echo "$as_me: error: no acceptable C compiler found in \$PATH
3126 See \`config.log' for more details." >&2;}
3127    { (exit 1); exit 1; }; }
3128
3129 # Provide some information about the compiler.
3130 echo "$as_me:$LINENO:" \
3131      "checking for C compiler version" >&5
3132 ac_compiler=`set X $ac_compile; echo $2`
3133 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3134   (eval $ac_compiler --version </dev/null >&5) 2>&5
3135   ac_status=$?
3136   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3137   (exit $ac_status); }
3138 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3139   (eval $ac_compiler -v </dev/null >&5) 2>&5
3140   ac_status=$?
3141   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3142   (exit $ac_status); }
3143 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3144   (eval $ac_compiler -V </dev/null >&5) 2>&5
3145   ac_status=$?
3146   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3147   (exit $ac_status); }
3148
3149 cat >conftest.$ac_ext <<_ACEOF
3150 /* confdefs.h.  */
3151 _ACEOF
3152 cat confdefs.h >>conftest.$ac_ext
3153 cat >>conftest.$ac_ext <<_ACEOF
3154 /* end confdefs.h.  */
3155
3156 int
3157 main ()
3158 {
3159
3160   ;
3161   return 0;
3162 }
3163 _ACEOF
3164 ac_clean_files_save=$ac_clean_files
3165 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3166 # Try to create an executable without -o first, disregard a.out.
3167 # It will help us diagnose broken compilers, and finding out an intuition
3168 # of exeext.
3169 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3170 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3171 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3172 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3173   (eval $ac_link_default) 2>&5
3174   ac_status=$?
3175   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3176   (exit $ac_status); }; then
3177   # Find the output, starting from the most likely.  This scheme is
3178 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3179 # resort.
3180
3181 # Be careful to initialize this variable, since it used to be cached.
3182 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3183 ac_cv_exeext=
3184 # b.out is created by i960 compilers.
3185 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3186 do
3187   test -f "$ac_file" || continue
3188   case $ac_file in
3189     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3190         ;;
3191     conftest.$ac_ext )
3192         # This is the source file.
3193         ;;
3194     [ab].out )
3195         # We found the default executable, but exeext='' is most
3196         # certainly right.
3197         break;;
3198     *.* )
3199         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3200         # FIXME: I believe we export ac_cv_exeext for Libtool,
3201         # but it would be cool to find out if it's true.  Does anybody
3202         # maintain Libtool? --akim.
3203         export ac_cv_exeext
3204         break;;
3205     * )
3206         break;;
3207   esac
3208 done
3209 else
3210   echo "$as_me: failed program was:" >&5
3211 sed 's/^/| /' conftest.$ac_ext >&5
3212
3213 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3214 See \`config.log' for more details." >&5
3215 echo "$as_me: error: C compiler cannot create executables
3216 See \`config.log' for more details." >&2;}
3217    { (exit 77); exit 77; }; }
3218 fi
3219
3220 ac_exeext=$ac_cv_exeext
3221 echo "$as_me:$LINENO: result: $ac_file" >&5
3222 echo "${ECHO_T}$ac_file" >&6
3223
3224 # Check the compiler produces executables we can run.  If not, either
3225 # the compiler is broken, or we cross compile.
3226 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3227 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3228 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3229 # If not cross compiling, check that we can run a simple program.
3230 if test "$cross_compiling" != yes; then
3231   if { ac_try='./$ac_file'
3232   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3233   (eval $ac_try) 2>&5
3234   ac_status=$?
3235   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3236   (exit $ac_status); }; }; then
3237     cross_compiling=no
3238   else
3239     if test "$cross_compiling" = maybe; then
3240         cross_compiling=yes
3241     else
3242         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3243 If you meant to cross compile, use \`--host'.
3244 See \`config.log' for more details." >&5
3245 echo "$as_me: error: cannot run C compiled programs.
3246 If you meant to cross compile, use \`--host'.
3247 See \`config.log' for more details." >&2;}
3248    { (exit 1); exit 1; }; }
3249     fi
3250   fi
3251 fi
3252 echo "$as_me:$LINENO: result: yes" >&5
3253 echo "${ECHO_T}yes" >&6
3254
3255 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3256 ac_clean_files=$ac_clean_files_save
3257 # Check the compiler produces executables we can run.  If not, either
3258 # the compiler is broken, or we cross compile.
3259 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3260 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3261 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3262 echo "${ECHO_T}$cross_compiling" >&6
3263
3264 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3265 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3266 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3267   (eval $ac_link) 2>&5
3268   ac_status=$?
3269   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3270   (exit $ac_status); }; then
3271   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3272 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3273 # work properly (i.e., refer to `conftest.exe'), while it won't with
3274 # `rm'.
3275 for ac_file in conftest.exe conftest conftest.*; do
3276   test -f "$ac_file" || continue
3277   case $ac_file in
3278     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3279     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3280           export ac_cv_exeext
3281           break;;
3282     * ) break;;
3283   esac
3284 done
3285 else
3286   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3287 See \`config.log' for more details." >&5
3288 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3289 See \`config.log' for more details." >&2;}
3290    { (exit 1); exit 1; }; }
3291 fi
3292
3293 rm -f conftest$ac_cv_exeext
3294 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3295 echo "${ECHO_T}$ac_cv_exeext" >&6
3296
3297 rm -f conftest.$ac_ext
3298 EXEEXT=$ac_cv_exeext
3299 ac_exeext=$EXEEXT
3300 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3301 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3302 if test "${ac_cv_objext+set}" = set; then
3303   echo $ECHO_N "(cached) $ECHO_C" >&6
3304 else
3305   cat >conftest.$ac_ext <<_ACEOF
3306 /* confdefs.h.  */
3307 _ACEOF
3308 cat confdefs.h >>conftest.$ac_ext
3309 cat >>conftest.$ac_ext <<_ACEOF
3310 /* end confdefs.h.  */
3311
3312 int
3313 main ()
3314 {
3315
3316   ;
3317   return 0;
3318 }
3319 _ACEOF
3320 rm -f conftest.o conftest.obj
3321 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3322   (eval $ac_compile) 2>&5
3323   ac_status=$?
3324   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3325   (exit $ac_status); }; then
3326   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3327   case $ac_file in
3328     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3329     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3330        break;;
3331   esac
3332 done
3333 else
3334   echo "$as_me: failed program was:" >&5
3335 sed 's/^/| /' conftest.$ac_ext >&5
3336
3337 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3338 See \`config.log' for more details." >&5
3339 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3340 See \`config.log' for more details." >&2;}
3341    { (exit 1); exit 1; }; }
3342 fi
3343
3344 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3345 fi
3346 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3347 echo "${ECHO_T}$ac_cv_objext" >&6
3348 OBJEXT=$ac_cv_objext
3349 ac_objext=$OBJEXT
3350 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3351 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3352 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3353   echo $ECHO_N "(cached) $ECHO_C" >&6
3354 else
3355   cat >conftest.$ac_ext <<_ACEOF
3356 /* confdefs.h.  */
3357 _ACEOF
3358 cat confdefs.h >>conftest.$ac_ext
3359 cat >>conftest.$ac_ext <<_ACEOF
3360 /* end confdefs.h.  */
3361
3362 int
3363 main ()
3364 {
3365 #ifndef __GNUC__
3366        choke me
3367 #endif
3368
3369   ;
3370   return 0;
3371 }
3372 _ACEOF
3373 rm -f conftest.$ac_objext
3374 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3375   (eval $ac_compile) 2>conftest.er1
3376   ac_status=$?
3377   grep -v '^ *+' conftest.er1 >conftest.err
3378   rm -f conftest.er1
3379   cat conftest.err >&5
3380   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3381   (exit $ac_status); } &&
3382          { ac_try='test -z "$ac_c_werror_flag"
3383                          || test ! -s conftest.err'
3384   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3385   (eval $ac_try) 2>&5
3386   ac_status=$?
3387   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3388   (exit $ac_status); }; } &&
3389          { ac_try='test -s conftest.$ac_objext'
3390   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3391   (eval $ac_try) 2>&5
3392   ac_status=$?
3393   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3394   (exit $ac_status); }; }; then
3395   ac_compiler_gnu=yes
3396 else
3397   echo "$as_me: failed program was:" >&5
3398 sed 's/^/| /' conftest.$ac_ext >&5
3399
3400 ac_compiler_gnu=no
3401 fi
3402 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3403 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3404
3405 fi
3406 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3407 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3408 GCC=`test $ac_compiler_gnu = yes && echo yes`
3409 ac_test_CFLAGS=${CFLAGS+set}
3410 ac_save_CFLAGS=$CFLAGS
3411 CFLAGS="-g"
3412 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3413 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3414 if test "${ac_cv_prog_cc_g+set}" = set; then
3415   echo $ECHO_N "(cached) $ECHO_C" >&6
3416 else
3417   cat >conftest.$ac_ext <<_ACEOF
3418 /* confdefs.h.  */
3419 _ACEOF
3420 cat confdefs.h >>conftest.$ac_ext
3421 cat >>conftest.$ac_ext <<_ACEOF
3422 /* end confdefs.h.  */
3423
3424 int
3425 main ()
3426 {
3427
3428   ;
3429   return 0;
3430 }
3431 _ACEOF
3432 rm -f conftest.$ac_objext
3433 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3434   (eval $ac_compile) 2>conftest.er1
3435   ac_status=$?
3436   grep -v '^ *+' conftest.er1 >conftest.err
3437   rm -f conftest.er1
3438   cat conftest.err >&5
3439   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3440   (exit $ac_status); } &&
3441          { ac_try='test -z "$ac_c_werror_flag"
3442                          || test ! -s conftest.err'
3443   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3444   (eval $ac_try) 2>&5
3445   ac_status=$?
3446   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3447   (exit $ac_status); }; } &&
3448          { ac_try='test -s conftest.$ac_objext'
3449   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3450   (eval $ac_try) 2>&5
3451   ac_status=$?
3452   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3453   (exit $ac_status); }; }; then
3454   ac_cv_prog_cc_g=yes
3455 else
3456   echo "$as_me: failed program was:" >&5
3457 sed 's/^/| /' conftest.$ac_ext >&5
3458
3459 ac_cv_prog_cc_g=no
3460 fi
3461 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3462 fi
3463 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3464 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3465 if test "$ac_test_CFLAGS" = set; then
3466   CFLAGS=$ac_save_CFLAGS
3467 elif test $ac_cv_prog_cc_g = yes; then
3468   if test "$GCC" = yes; then
3469     CFLAGS="-g -O2"
3470   else
3471     CFLAGS="-g"
3472   fi
3473 else
3474   if test "$GCC" = yes; then
3475     CFLAGS="-O2"
3476   else
3477     CFLAGS=
3478   fi
3479 fi
3480 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3481 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3482 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3483   echo $ECHO_N "(cached) $ECHO_C" >&6
3484 else
3485   ac_cv_prog_cc_stdc=no
3486 ac_save_CC=$CC
3487 cat >conftest.$ac_ext <<_ACEOF
3488 /* confdefs.h.  */
3489 _ACEOF
3490 cat confdefs.h >>conftest.$ac_ext
3491 cat >>conftest.$ac_ext <<_ACEOF
3492 /* end confdefs.h.  */
3493 #include <stdarg.h>
3494 #include <stdio.h>
3495 #include <sys/types.h>
3496 #include <sys/stat.h>
3497 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3498 struct buf { int x; };
3499 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3500 static char *e (p, i)
3501      char **p;
3502      int i;
3503 {
3504   return p[i];
3505 }
3506 static char *f (char * (*g) (char **, int), char **p, ...)
3507 {
3508   char *s;
3509   va_list v;
3510   va_start (v,p);
3511   s = g (p, va_arg (v,int));
3512   va_end (v);
3513   return s;
3514 }
3515
3516 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3517    function prototypes and stuff, but not '\xHH' hex character constants.
3518    These don't provoke an error unfortunately, instead are silently treated
3519    as 'x'.  The following induces an error, until -std1 is added to get
3520    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3521    array size at least.  It's necessary to write '\x00'==0 to get something
3522    that's true only with -std1.  */
3523 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3524
3525 int test (int i, double x);
3526 struct s1 {int (*f) (int a);};
3527 struct s2 {int (*f) (double a);};
3528 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3529 int argc;
3530 char **argv;
3531 int
3532 main ()
3533 {
3534 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3535   ;
3536   return 0;
3537 }
3538 _ACEOF
3539 # Don't try gcc -ansi; that turns off useful extensions and
3540 # breaks some systems' header files.
3541 # AIX                   -qlanglvl=ansi
3542 # Ultrix and OSF/1      -std1
3543 # HP-UX 10.20 and later -Ae
3544 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3545 # SVR4                  -Xc -D__EXTENSIONS__
3546 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3547 do
3548   CC="$ac_save_CC $ac_arg"
3549   rm -f conftest.$ac_objext
3550 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3551   (eval $ac_compile) 2>conftest.er1
3552   ac_status=$?
3553   grep -v '^ *+' conftest.er1 >conftest.err
3554   rm -f conftest.er1
3555   cat conftest.err >&5
3556   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3557   (exit $ac_status); } &&
3558          { ac_try='test -z "$ac_c_werror_flag"
3559                          || test ! -s conftest.err'
3560   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3561   (eval $ac_try) 2>&5
3562   ac_status=$?
3563   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3564   (exit $ac_status); }; } &&
3565          { ac_try='test -s conftest.$ac_objext'
3566   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3567   (eval $ac_try) 2>&5
3568   ac_status=$?
3569   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3570   (exit $ac_status); }; }; then
3571   ac_cv_prog_cc_stdc=$ac_arg
3572 break
3573 else
3574   echo "$as_me: failed program was:" >&5
3575 sed 's/^/| /' conftest.$ac_ext >&5
3576
3577 fi
3578 rm -f conftest.err conftest.$ac_objext
3579 done
3580 rm -f conftest.$ac_ext conftest.$ac_objext
3581 CC=$ac_save_CC
3582
3583 fi
3584
3585 case "x$ac_cv_prog_cc_stdc" in
3586   x|xno)
3587     echo "$as_me:$LINENO: result: none needed" >&5
3588 echo "${ECHO_T}none needed" >&6 ;;
3589   *)
3590     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3591 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3592     CC="$CC $ac_cv_prog_cc_stdc" ;;
3593 esac
3594
3595 # Some people use a C++ compiler to compile C.  Since we use `exit',
3596 # in C++ we need to declare it.  In case someone uses the same compiler
3597 # for both compiling C and C++ we need to have the C++ compiler decide
3598 # the declaration of exit, since it's the most demanding environment.
3599 cat >conftest.$ac_ext <<_ACEOF
3600 #ifndef __cplusplus
3601   choke me
3602 #endif
3603 _ACEOF
3604 rm -f conftest.$ac_objext
3605 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3606   (eval $ac_compile) 2>conftest.er1
3607   ac_status=$?
3608   grep -v '^ *+' conftest.er1 >conftest.err
3609   rm -f conftest.er1
3610   cat conftest.err >&5
3611   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3612   (exit $ac_status); } &&
3613          { ac_try='test -z "$ac_c_werror_flag"
3614                          || test ! -s conftest.err'
3615   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3616   (eval $ac_try) 2>&5
3617   ac_status=$?
3618   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3619   (exit $ac_status); }; } &&
3620          { ac_try='test -s conftest.$ac_objext'
3621   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3622   (eval $ac_try) 2>&5
3623   ac_status=$?
3624   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3625   (exit $ac_status); }; }; then
3626   for ac_declaration in \
3627    '' \
3628    'extern "C" void std::exit (int) throw (); using std::exit;' \
3629    'extern "C" void std::exit (int); using std::exit;' \
3630    'extern "C" void exit (int) throw ();' \
3631    'extern "C" void exit (int);' \
3632    'void exit (int);'
3633 do
3634   cat >conftest.$ac_ext <<_ACEOF
3635 /* confdefs.h.  */
3636 _ACEOF
3637 cat confdefs.h >>conftest.$ac_ext
3638 cat >>conftest.$ac_ext <<_ACEOF
3639 /* end confdefs.h.  */
3640 $ac_declaration
3641 #include <stdlib.h>
3642 int
3643 main ()
3644 {
3645 exit (42);
3646   ;
3647   return 0;
3648 }
3649 _ACEOF
3650 rm -f conftest.$ac_objext
3651 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3652   (eval $ac_compile) 2>conftest.er1
3653   ac_status=$?
3654   grep -v '^ *+' conftest.er1 >conftest.err
3655   rm -f conftest.er1
3656   cat conftest.err >&5
3657   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3658   (exit $ac_status); } &&
3659          { ac_try='test -z "$ac_c_werror_flag"
3660                          || test ! -s conftest.err'
3661   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3662   (eval $ac_try) 2>&5
3663   ac_status=$?
3664   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3665   (exit $ac_status); }; } &&
3666          { ac_try='test -s conftest.$ac_objext'
3667   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3668   (eval $ac_try) 2>&5
3669   ac_status=$?
3670   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3671   (exit $ac_status); }; }; then
3672   :
3673 else
3674   echo "$as_me: failed program was:" >&5
3675 sed 's/^/| /' conftest.$ac_ext >&5
3676
3677 continue
3678 fi
3679 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3680   cat >conftest.$ac_ext <<_ACEOF
3681 /* confdefs.h.  */
3682 _ACEOF
3683 cat confdefs.h >>conftest.$ac_ext
3684 cat >>conftest.$ac_ext <<_ACEOF
3685 /* end confdefs.h.  */
3686 $ac_declaration
3687 int
3688 main ()
3689 {
3690 exit (42);
3691   ;
3692   return 0;
3693 }
3694 _ACEOF
3695 rm -f conftest.$ac_objext
3696 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3697   (eval $ac_compile) 2>conftest.er1
3698   ac_status=$?
3699   grep -v '^ *+' conftest.er1 >conftest.err
3700   rm -f conftest.er1
3701   cat conftest.err >&5
3702   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3703   (exit $ac_status); } &&
3704          { ac_try='test -z "$ac_c_werror_flag"
3705                          || test ! -s conftest.err'
3706   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3707   (eval $ac_try) 2>&5
3708   ac_status=$?
3709   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3710   (exit $ac_status); }; } &&
3711          { ac_try='test -s conftest.$ac_objext'
3712   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3713   (eval $ac_try) 2>&5
3714   ac_status=$?
3715   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3716   (exit $ac_status); }; }; then
3717   break
3718 else
3719   echo "$as_me: failed program was:" >&5
3720 sed 's/^/| /' conftest.$ac_ext >&5
3721
3722 fi
3723 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3724 done
3725 rm -f conftest*
3726 if test -n "$ac_declaration"; then
3727   echo '#ifdef __cplusplus' >>confdefs.h
3728   echo $ac_declaration      >>confdefs.h
3729   echo '#endif'             >>confdefs.h
3730 fi
3731
3732 else
3733   echo "$as_me: failed program was:" >&5
3734 sed 's/^/| /' conftest.$ac_ext >&5
3735
3736 fi
3737 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3738 ac_ext=c
3739 ac_cpp='$CPP $CPPFLAGS'
3740 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3741 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3742 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3743
3744 ac_ext=cc
3745 ac_cpp='$CXXCPP $CPPFLAGS'
3746 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3747 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3748 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3749 if test -n "$ac_tool_prefix"; then
3750   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3751   do
3752     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3753 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3754 echo "$as_me:$LINENO: checking for $ac_word" >&5
3755 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3756 if test "${ac_cv_prog_CXX+set}" = set; then
3757   echo $ECHO_N "(cached) $ECHO_C" >&6
3758 else
3759   if test -n "$CXX"; then
3760   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3761 else
3762 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3763 for as_dir in $PATH
3764 do
3765   IFS=$as_save_IFS
3766   test -z "$as_dir" && as_dir=.
3767   for ac_exec_ext in '' $ac_executable_extensions; do
3768   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3769     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3770     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3771     break 2
3772   fi
3773 done
3774 done
3775
3776 fi
3777 fi
3778 CXX=$ac_cv_prog_CXX
3779 if test -n "$CXX"; then
3780   echo "$as_me:$LINENO: result: $CXX" >&5
3781 echo "${ECHO_T}$CXX" >&6
3782 else
3783   echo "$as_me:$LINENO: result: no" >&5
3784 echo "${ECHO_T}no" >&6
3785 fi
3786
3787     test -n "$CXX" && break
3788   done
3789 fi
3790 if test -z "$CXX"; then
3791   ac_ct_CXX=$CXX
3792   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3793 do
3794   # Extract the first word of "$ac_prog", so it can be a program name with args.
3795 set dummy $ac_prog; ac_word=$2
3796 echo "$as_me:$LINENO: checking for $ac_word" >&5
3797 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3798 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3799   echo $ECHO_N "(cached) $ECHO_C" >&6
3800 else
3801   if test -n "$ac_ct_CXX"; then
3802   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3803 else
3804 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3805 for as_dir in $PATH
3806 do
3807   IFS=$as_save_IFS
3808   test -z "$as_dir" && as_dir=.
3809   for ac_exec_ext in '' $ac_executable_extensions; do
3810   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3811     ac_cv_prog_ac_ct_CXX="$ac_prog"
3812     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3813     break 2
3814   fi
3815 done
3816 done
3817
3818 fi
3819 fi
3820 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3821 if test -n "$ac_ct_CXX"; then
3822   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3823 echo "${ECHO_T}$ac_ct_CXX" >&6
3824 else
3825   echo "$as_me:$LINENO: result: no" >&5
3826 echo "${ECHO_T}no" >&6
3827 fi
3828
3829   test -n "$ac_ct_CXX" && break
3830 done
3831 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3832
3833   CXX=$ac_ct_CXX
3834 fi
3835
3836
3837 # Provide some information about the compiler.
3838 echo "$as_me:$LINENO:" \
3839      "checking for C++ compiler version" >&5
3840 ac_compiler=`set X $ac_compile; echo $2`
3841 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3842   (eval $ac_compiler --version </dev/null >&5) 2>&5
3843   ac_status=$?
3844   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3845   (exit $ac_status); }
3846 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3847   (eval $ac_compiler -v </dev/null >&5) 2>&5
3848   ac_status=$?
3849   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3850   (exit $ac_status); }
3851 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3852   (eval $ac_compiler -V </dev/null >&5) 2>&5
3853   ac_status=$?
3854   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3855   (exit $ac_status); }
3856
3857 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3858 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3859 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3860   echo $ECHO_N "(cached) $ECHO_C" >&6
3861 else
3862   cat >conftest.$ac_ext <<_ACEOF
3863 /* confdefs.h.  */
3864 _ACEOF
3865 cat confdefs.h >>conftest.$ac_ext
3866 cat >>conftest.$ac_ext <<_ACEOF
3867 /* end confdefs.h.  */
3868
3869 int
3870 main ()
3871 {
3872 #ifndef __GNUC__
3873        choke me
3874 #endif
3875
3876   ;
3877   return 0;
3878 }
3879 _ACEOF
3880 rm -f conftest.$ac_objext
3881 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3882   (eval $ac_compile) 2>conftest.er1
3883   ac_status=$?
3884   grep -v '^ *+' conftest.er1 >conftest.err
3885   rm -f conftest.er1
3886   cat conftest.err >&5
3887   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3888   (exit $ac_status); } &&
3889          { ac_try='test -z "$ac_cxx_werror_flag"
3890                          || test ! -s conftest.err'
3891   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3892   (eval $ac_try) 2>&5
3893   ac_status=$?
3894   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3895   (exit $ac_status); }; } &&
3896          { ac_try='test -s conftest.$ac_objext'
3897   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3898   (eval $ac_try) 2>&5
3899   ac_status=$?
3900   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3901   (exit $ac_status); }; }; then
3902   ac_compiler_gnu=yes
3903 else
3904   echo "$as_me: failed program was:" >&5
3905 sed 's/^/| /' conftest.$ac_ext >&5
3906
3907 ac_compiler_gnu=no
3908 fi
3909 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3910 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3911
3912 fi
3913 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3914 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3915 GXX=`test $ac_compiler_gnu = yes && echo yes`
3916 ac_test_CXXFLAGS=${CXXFLAGS+set}
3917 ac_save_CXXFLAGS=$CXXFLAGS
3918 CXXFLAGS="-g"
3919 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3920 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3921 if test "${ac_cv_prog_cxx_g+set}" = set; then
3922   echo $ECHO_N "(cached) $ECHO_C" >&6
3923 else
3924   cat >conftest.$ac_ext <<_ACEOF
3925 /* confdefs.h.  */
3926 _ACEOF
3927 cat confdefs.h >>conftest.$ac_ext
3928 cat >>conftest.$ac_ext <<_ACEOF
3929 /* end confdefs.h.  */
3930
3931 int
3932 main ()
3933 {
3934
3935   ;
3936   return 0;
3937 }
3938 _ACEOF
3939 rm -f conftest.$ac_objext
3940 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3941   (eval $ac_compile) 2>conftest.er1
3942   ac_status=$?
3943   grep -v '^ *+' conftest.er1 >conftest.err
3944   rm -f conftest.er1
3945   cat conftest.err >&5
3946   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3947   (exit $ac_status); } &&
3948          { ac_try='test -z "$ac_cxx_werror_flag"
3949                          || test ! -s conftest.err'
3950   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3951   (eval $ac_try) 2>&5
3952   ac_status=$?
3953   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3954   (exit $ac_status); }; } &&
3955          { ac_try='test -s conftest.$ac_objext'
3956   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3957   (eval $ac_try) 2>&5
3958   ac_status=$?
3959   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3960   (exit $ac_status); }; }; then
3961   ac_cv_prog_cxx_g=yes
3962 else
3963   echo "$as_me: failed program was:" >&5
3964 sed 's/^/| /' conftest.$ac_ext >&5
3965
3966 ac_cv_prog_cxx_g=no
3967 fi
3968 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3969 fi
3970 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3971 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
3972 if test "$ac_test_CXXFLAGS" = set; then
3973   CXXFLAGS=$ac_save_CXXFLAGS
3974 elif test $ac_cv_prog_cxx_g = yes; then
3975   if test "$GXX" = yes; then
3976     CXXFLAGS="-g -O2"
3977   else
3978     CXXFLAGS="-g"
3979   fi
3980 else
3981   if test "$GXX" = yes; then
3982     CXXFLAGS="-O2"
3983   else
3984     CXXFLAGS=
3985   fi
3986 fi
3987 for ac_declaration in \
3988    '' \
3989    'extern "C" void std::exit (int) throw (); using std::exit;' \
3990    'extern "C" void std::exit (int); using std::exit;' \
3991    'extern "C" void exit (int) throw ();' \
3992    'extern "C" void exit (int);' \
3993    'void exit (int);'
3994 do
3995   cat >conftest.$ac_ext <<_ACEOF
3996 /* confdefs.h.  */
3997 _ACEOF
3998 cat confdefs.h >>conftest.$ac_ext
3999 cat >>conftest.$ac_ext <<_ACEOF
4000 /* end confdefs.h.  */
4001 $ac_declaration
4002 #include <stdlib.h>
4003 int
4004 main ()
4005 {
4006 exit (42);
4007   ;
4008   return 0;
4009 }
4010 _ACEOF
4011 rm -f conftest.$ac_objext
4012 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4013   (eval $ac_compile) 2>conftest.er1
4014   ac_status=$?
4015   grep -v '^ *+' conftest.er1 >conftest.err
4016   rm -f conftest.er1
4017   cat conftest.err >&5
4018   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4019   (exit $ac_status); } &&
4020          { ac_try='test -z "$ac_cxx_werror_flag"
4021                          || test ! -s conftest.err'
4022   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4023   (eval $ac_try) 2>&5
4024   ac_status=$?
4025   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4026   (exit $ac_status); }; } &&
4027          { ac_try='test -s conftest.$ac_objext'
4028   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4029   (eval $ac_try) 2>&5
4030   ac_status=$?
4031   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4032   (exit $ac_status); }; }; then
4033   :
4034 else
4035   echo "$as_me: failed program was:" >&5
4036 sed 's/^/| /' conftest.$ac_ext >&5
4037
4038 continue
4039 fi
4040 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4041   cat >conftest.$ac_ext <<_ACEOF
4042 /* confdefs.h.  */
4043 _ACEOF
4044 cat confdefs.h >>conftest.$ac_ext
4045 cat >>conftest.$ac_ext <<_ACEOF
4046 /* end confdefs.h.  */
4047 $ac_declaration
4048 int
4049 main ()
4050 {
4051 exit (42);
4052   ;
4053   return 0;
4054 }
4055 _ACEOF
4056 rm -f conftest.$ac_objext
4057 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4058   (eval $ac_compile) 2>conftest.er1
4059   ac_status=$?
4060   grep -v '^ *+' conftest.er1 >conftest.err
4061   rm -f conftest.er1
4062   cat conftest.err >&5
4063   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4064   (exit $ac_status); } &&
4065          { ac_try='test -z "$ac_cxx_werror_flag"
4066                          || test ! -s conftest.err'
4067   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4068   (eval $ac_try) 2>&5
4069   ac_status=$?
4070   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4071   (exit $ac_status); }; } &&
4072          { ac_try='test -s conftest.$ac_objext'
4073   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4074   (eval $ac_try) 2>&5
4075   ac_status=$?
4076   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4077   (exit $ac_status); }; }; then
4078   break
4079 else
4080   echo "$as_me: failed program was:" >&5
4081 sed 's/^/| /' conftest.$ac_ext >&5
4082
4083 fi
4084 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4085 done
4086 rm -f conftest*
4087 if test -n "$ac_declaration"; then
4088   echo '#ifdef __cplusplus' >>confdefs.h
4089   echo $ac_declaration      >>confdefs.h
4090   echo '#endif'             >>confdefs.h
4091 fi
4092
4093 ac_ext=c
4094 ac_cpp='$CPP $CPPFLAGS'
4095 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4096 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4097 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4098
4099
4100 # We must set the default linker to the linker used by gcc for the correct
4101 # operation of libtool.  If LD is not defined and we are using gcc, try to
4102 # set the LD default to the ld used by gcc.
4103 if test -z "$LD"; then
4104   if test "$GCC" = yes; then
4105     case $build in
4106     *-*-mingw*)
4107       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4108     *)
4109       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4110     esac
4111     case $gcc_prog_ld in
4112     # Accept absolute paths.
4113     [\\/]* | [A-Za-z]:[\\/]*)
4114       LD="$gcc_prog_ld" ;;
4115     esac
4116   fi
4117 fi
4118
4119
4120
4121
4122 if test -n "$ac_tool_prefix"; then
4123   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4124 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4125 echo "$as_me:$LINENO: checking for $ac_word" >&5
4126 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4127 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4128   echo $ECHO_N "(cached) $ECHO_C" >&6
4129 else
4130   if test -n "$GNATBIND"; then
4131   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4132 else
4133 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4134 for as_dir in $PATH
4135 do
4136   IFS=$as_save_IFS
4137   test -z "$as_dir" && as_dir=.
4138   for ac_exec_ext in '' $ac_executable_extensions; do
4139   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4140     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4141     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4142     break 2
4143   fi
4144 done
4145 done
4146
4147 fi
4148 fi
4149 GNATBIND=$ac_cv_prog_GNATBIND
4150 if test -n "$GNATBIND"; then
4151   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4152 echo "${ECHO_T}$GNATBIND" >&6
4153 else
4154   echo "$as_me:$LINENO: result: no" >&5
4155 echo "${ECHO_T}no" >&6
4156 fi
4157
4158 fi
4159 if test -z "$ac_cv_prog_GNATBIND"; then
4160   ac_ct_GNATBIND=$GNATBIND
4161   # Extract the first word of "gnatbind", so it can be a program name with args.
4162 set dummy gnatbind; ac_word=$2
4163 echo "$as_me:$LINENO: checking for $ac_word" >&5
4164 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4165 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4166   echo $ECHO_N "(cached) $ECHO_C" >&6
4167 else
4168   if test -n "$ac_ct_GNATBIND"; then
4169   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4170 else
4171 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4172 for as_dir in $PATH
4173 do
4174   IFS=$as_save_IFS
4175   test -z "$as_dir" && as_dir=.
4176   for ac_exec_ext in '' $ac_executable_extensions; do
4177   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4178     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4179     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4180     break 2
4181   fi
4182 done
4183 done
4184
4185   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4186 fi
4187 fi
4188 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4189 if test -n "$ac_ct_GNATBIND"; then
4190   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4191 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4192 else
4193   echo "$as_me:$LINENO: result: no" >&5
4194 echo "${ECHO_T}no" >&6
4195 fi
4196
4197   GNATBIND=$ac_ct_GNATBIND
4198 else
4199   GNATBIND="$ac_cv_prog_GNATBIND"
4200 fi
4201
4202 if test -n "$ac_tool_prefix"; then
4203   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4204 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4205 echo "$as_me:$LINENO: checking for $ac_word" >&5
4206 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4207 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4208   echo $ECHO_N "(cached) $ECHO_C" >&6
4209 else
4210   if test -n "$GNATMAKE"; then
4211   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4212 else
4213 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4214 for as_dir in $PATH
4215 do
4216   IFS=$as_save_IFS
4217   test -z "$as_dir" && as_dir=.
4218   for ac_exec_ext in '' $ac_executable_extensions; do
4219   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4220     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4221     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4222     break 2
4223   fi
4224 done
4225 done
4226
4227 fi
4228 fi
4229 GNATMAKE=$ac_cv_prog_GNATMAKE
4230 if test -n "$GNATMAKE"; then
4231   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4232 echo "${ECHO_T}$GNATMAKE" >&6
4233 else
4234   echo "$as_me:$LINENO: result: no" >&5
4235 echo "${ECHO_T}no" >&6
4236 fi
4237
4238 fi
4239 if test -z "$ac_cv_prog_GNATMAKE"; then
4240   ac_ct_GNATMAKE=$GNATMAKE
4241   # Extract the first word of "gnatmake", so it can be a program name with args.
4242 set dummy gnatmake; ac_word=$2
4243 echo "$as_me:$LINENO: checking for $ac_word" >&5
4244 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4245 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4246   echo $ECHO_N "(cached) $ECHO_C" >&6
4247 else
4248   if test -n "$ac_ct_GNATMAKE"; then
4249   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4250 else
4251 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4252 for as_dir in $PATH
4253 do
4254   IFS=$as_save_IFS
4255   test -z "$as_dir" && as_dir=.
4256   for ac_exec_ext in '' $ac_executable_extensions; do
4257   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4258     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4259     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4260     break 2
4261   fi
4262 done
4263 done
4264
4265   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4266 fi
4267 fi
4268 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4269 if test -n "$ac_ct_GNATMAKE"; then
4270   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4271 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4272 else
4273   echo "$as_me:$LINENO: result: no" >&5
4274 echo "${ECHO_T}no" >&6
4275 fi
4276
4277   GNATMAKE=$ac_ct_GNATMAKE
4278 else
4279   GNATMAKE="$ac_cv_prog_GNATMAKE"
4280 fi
4281
4282 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4283 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4284 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4285   echo $ECHO_N "(cached) $ECHO_C" >&6
4286 else
4287   cat >conftest.adb <<EOF
4288 procedure conftest is begin null; end conftest;
4289 EOF
4290 acx_cv_cc_gcc_supports_ada=no
4291 # There is a bug in old released versions of GCC which causes the
4292 # driver to exit successfully when the appropriate language module
4293 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4294 # Therefore we must check for the error message as well as an
4295 # unsuccessful exit.
4296 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4297 # given a .adb file, but produce no object file.  So we must check
4298 # if an object file was really produced to guard against this.
4299 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4300 if test x"$errors" = x && test -f conftest.$ac_objext; then
4301   acx_cv_cc_gcc_supports_ada=yes
4302 fi
4303 rm -f conftest.*
4304 fi
4305 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4306 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4307
4308 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4309   have_gnat=yes
4310 else
4311   have_gnat=no
4312 fi
4313
4314 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4315 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4316 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4317   echo $ECHO_N "(cached) $ECHO_C" >&6
4318 else
4319    echo abfoo >t1
4320   echo cdfoo >t2
4321   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4322   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4323     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4324       :
4325     else
4326       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4327     fi
4328   fi
4329   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4330     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4331       :
4332     else
4333       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4334     fi
4335   fi
4336   rm t1 t2
4337
4338 fi
4339 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4340 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4341 do_compare="$gcc_cv_prog_cmp_skip"
4342
4343
4344
4345 # Check for GMP and MPFR
4346 gmplibs="-lmpfr -lgmp"
4347 gmpinc=
4348 have_gmp=no
4349
4350 # Specify a location for mpfr
4351 # check for this first so it ends up on the link line before gmp.
4352
4353 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4354 if test "${with_mpfr_dir+set}" = set; then
4355   withval="$with_mpfr_dir"
4356   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4357 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4358 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4359 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4360    { (exit 1); exit 1; }; }
4361 fi;
4362
4363
4364 # Check whether --with-mpfr or --without-mpfr was given.
4365 if test "${with_mpfr+set}" = set; then
4366   withval="$with_mpfr"
4367
4368 fi;
4369
4370 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4371 if test "${with_mpfr_include+set}" = set; then
4372   withval="$with_mpfr_include"
4373
4374 fi;
4375
4376 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4377 if test "${with_mpfr_lib+set}" = set; then
4378   withval="$with_mpfr_lib"
4379
4380 fi;
4381
4382 if test "x$with_mpfr" != x; then
4383   gmplibs="-L$with_mpfr/lib $gmplibs"
4384   gmpinc="-I$with_mpfr/include"
4385 fi
4386 if test "x$with_mpfr_include" != x; then
4387   gmpinc="-I$with_mpfr_include"
4388 fi
4389 if test "x$with_mpfr_lib" != x; then
4390   gmplibs="-L$with_mpfr_lib $gmplibs"
4391 fi
4392 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4393   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4394   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4395   # Do not test the mpfr version.  Assume that it is sufficient, since
4396   # it is in the source tree, and the library has not been built yet
4397   # but it would be included on the link line in the version check below
4398   # hence making the test fail.
4399   have_gmp=yes
4400 fi
4401
4402 # Specify a location for gmp
4403
4404 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4405 if test "${with_gmp_dir+set}" = set; then
4406   withval="$with_gmp_dir"
4407   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4408 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4409 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4410 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4411    { (exit 1); exit 1; }; }
4412 fi;
4413
4414
4415 # Check whether --with-gmp or --without-gmp was given.
4416 if test "${with_gmp+set}" = set; then
4417   withval="$with_gmp"
4418
4419 fi;
4420
4421 # Check whether --with-gmp_include or --without-gmp_include was given.
4422 if test "${with_gmp_include+set}" = set; then
4423   withval="$with_gmp_include"
4424
4425 fi;
4426
4427 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4428 if test "${with_gmp_lib+set}" = set; then
4429   withval="$with_gmp_lib"
4430
4431 fi;
4432
4433
4434 if test "x$with_gmp" != x; then
4435   gmplibs="-L$with_gmp/lib $gmplibs"
4436   gmpinc="-I$with_gmp/include $gmpinc"
4437 fi
4438 if test "x$with_gmp_include" != x; then
4439   gmpinc="-I$with_gmp_include $gmpinc"
4440 fi
4441 if test "x$with_gmp_lib" != x; then
4442   gmplibs="-L$with_gmp_lib $gmplibs"
4443 fi
4444 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4445   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4446   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4447   # Do not test the gmp version.  Assume that it is sufficient, since
4448   # it is in the source tree, and the library has not been built yet
4449   # but it would be included on the link line in the version check below
4450   # hence making the test fail.
4451   have_gmp=yes
4452 fi
4453
4454 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4455   have_gmp=yes
4456   saved_CFLAGS="$CFLAGS"
4457   CFLAGS="$CFLAGS $gmpinc"
4458   # Check GMP actually works
4459   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4460 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4461
4462 cat >conftest.$ac_ext <<_ACEOF
4463 /* confdefs.h.  */
4464 _ACEOF
4465 cat confdefs.h >>conftest.$ac_ext
4466 cat >>conftest.$ac_ext <<_ACEOF
4467 /* end confdefs.h.  */
4468 #include "gmp.h"
4469 int
4470 main ()
4471 {
4472
4473   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4474   choke me
4475   #endif
4476
4477   ;
4478   return 0;
4479 }
4480 _ACEOF
4481 rm -f conftest.$ac_objext
4482 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4483   (eval $ac_compile) 2>conftest.er1
4484   ac_status=$?
4485   grep -v '^ *+' conftest.er1 >conftest.err
4486   rm -f conftest.er1
4487   cat conftest.err >&5
4488   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4489   (exit $ac_status); } &&
4490          { ac_try='test -z "$ac_c_werror_flag"
4491                          || test ! -s conftest.err'
4492   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4493   (eval $ac_try) 2>&5
4494   ac_status=$?
4495   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4496   (exit $ac_status); }; } &&
4497          { ac_try='test -s conftest.$ac_objext'
4498   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4499   (eval $ac_try) 2>&5
4500   ac_status=$?
4501   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4502   (exit $ac_status); }; }; then
4503   echo "$as_me:$LINENO: result: yes" >&5
4504 echo "${ECHO_T}yes" >&6
4505 else
4506   echo "$as_me: failed program was:" >&5
4507 sed 's/^/| /' conftest.$ac_ext >&5
4508
4509 echo "$as_me:$LINENO: result: no" >&5
4510 echo "${ECHO_T}no" >&6; have_gmp=no
4511 fi
4512 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4513
4514   if test x"$have_gmp" = xyes; then
4515     saved_LIBS="$LIBS"
4516     LIBS="$LIBS $gmplibs"
4517         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4518 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4519     cat >conftest.$ac_ext <<_ACEOF
4520 /* confdefs.h.  */
4521 _ACEOF
4522 cat confdefs.h >>conftest.$ac_ext
4523 cat >>conftest.$ac_ext <<_ACEOF
4524 /* end confdefs.h.  */
4525 #include <gmp.h>
4526     #include <mpfr.h>
4527 int
4528 main ()
4529 {
4530
4531     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,0)
4532     choke me
4533     #endif
4534     mpfr_t n;
4535     mpfr_t x;
4536     int t;
4537     mpfr_init (n);
4538     mpfr_init (x);
4539     mpfr_atan2 (n, n, x, GMP_RNDN);
4540     mpfr_erfc (n, x, GMP_RNDN);
4541     mpfr_subnormalize (x, t, GMP_RNDN);
4542
4543   ;
4544   return 0;
4545 }
4546 _ACEOF
4547 rm -f conftest.$ac_objext conftest$ac_exeext
4548 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4549   (eval $ac_link) 2>conftest.er1
4550   ac_status=$?
4551   grep -v '^ *+' conftest.er1 >conftest.err
4552   rm -f conftest.er1
4553   cat conftest.err >&5
4554   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4555   (exit $ac_status); } &&
4556          { ac_try='test -z "$ac_c_werror_flag"
4557                          || test ! -s conftest.err'
4558   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4559   (eval $ac_try) 2>&5
4560   ac_status=$?
4561   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4562   (exit $ac_status); }; } &&
4563          { ac_try='test -s conftest$ac_exeext'
4564   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4565   (eval $ac_try) 2>&5
4566   ac_status=$?
4567   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4568   (exit $ac_status); }; }; then
4569   cat >conftest.$ac_ext <<_ACEOF
4570 /* confdefs.h.  */
4571 _ACEOF
4572 cat confdefs.h >>conftest.$ac_ext
4573 cat >>conftest.$ac_ext <<_ACEOF
4574 /* end confdefs.h.  */
4575 #include <gmp.h>
4576     #include <mpfr.h>
4577 int
4578 main ()
4579 {
4580
4581     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4582     choke me
4583     #endif
4584     mpfr_t n; mpfr_init(n);
4585
4586   ;
4587   return 0;
4588 }
4589 _ACEOF
4590 rm -f conftest.$ac_objext conftest$ac_exeext
4591 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4592   (eval $ac_link) 2>conftest.er1
4593   ac_status=$?
4594   grep -v '^ *+' conftest.er1 >conftest.err
4595   rm -f conftest.er1
4596   cat conftest.err >&5
4597   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4598   (exit $ac_status); } &&
4599          { ac_try='test -z "$ac_c_werror_flag"
4600                          || test ! -s conftest.err'
4601   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4602   (eval $ac_try) 2>&5
4603   ac_status=$?
4604   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4605   (exit $ac_status); }; } &&
4606          { ac_try='test -s conftest$ac_exeext'
4607   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4608   (eval $ac_try) 2>&5
4609   ac_status=$?
4610   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4611   (exit $ac_status); }; }; then
4612   echo "$as_me:$LINENO: result: yes" >&5
4613 echo "${ECHO_T}yes" >&6
4614 else
4615   echo "$as_me: failed program was:" >&5
4616 sed 's/^/| /' conftest.$ac_ext >&5
4617
4618 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4619 echo "${ECHO_T}buggy but acceptable" >&6
4620 fi
4621 rm -f conftest.err conftest.$ac_objext \
4622       conftest$ac_exeext conftest.$ac_ext
4623 else
4624   echo "$as_me: failed program was:" >&5
4625 sed 's/^/| /' conftest.$ac_ext >&5
4626
4627 echo "$as_me:$LINENO: result: no" >&5
4628 echo "${ECHO_T}no" >&6; have_gmp=no
4629 fi
4630 rm -f conftest.err conftest.$ac_objext \
4631       conftest$ac_exeext conftest.$ac_ext
4632       LIBS="$saved_LIBS"
4633   fi
4634   CFLAGS="$saved_CFLAGS"
4635
4636   if test x$have_gmp != xyes; then
4637     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4638 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4639 Copies of these libraries' source code can be found at their respective
4640 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4641 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4642 If you obtained GMP and/or MPFR from a vendor distribution package, make
4643 sure that you have installed both the libraries and the header files.
4644 They may be located in separate packages." >&5
4645 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4646 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4647 Copies of these libraries' source code can be found at their respective
4648 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4649 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4650 If you obtained GMP and/or MPFR from a vendor distribution package, make
4651 sure that you have installed both the libraries and the header files.
4652 They may be located in separate packages." >&2;}
4653    { (exit 1); exit 1; }; }
4654   fi
4655 fi
4656
4657 # Flags needed for both GMP and/or MPFR
4658
4659
4660
4661 # By default, C is the only stage 1 language.
4662 stage1_languages=,c,
4663
4664 # Figure out what language subdirectories are present.
4665 # Look if the user specified --enable-languages="..."; if not, use
4666 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4667 # go away some day.
4668 # NB:  embedded tabs in this IF block -- do not untabify
4669 if test -d ${srcdir}/gcc; then
4670   if test x"${enable_languages+set}" != xset; then
4671     if test x"${LANGUAGES+set}" = xset; then
4672       enable_languages="${LANGUAGES}"
4673         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4674     else
4675       enable_languages=all
4676     fi
4677   else
4678     if test x"${enable_languages}" = x ||
4679        test x"${enable_languages}" = xyes;
4680        then
4681       echo configure.in: --enable-languages needs at least one language argument 1>&2
4682       exit 1
4683     fi
4684   fi
4685   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4686
4687   # 'f95' is the old name for the 'fortran' language. We issue a warning
4688   # and make the substitution.
4689   case ,${enable_languages}, in
4690     *,f95,*)
4691       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4692       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4693       ;;
4694   esac
4695
4696   # First scan to see if an enabled language requires some other language.
4697   # We assume that a given config-lang.in will list all the language
4698   # front ends it requires, even if some are required indirectly.
4699   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4700     case ${lang_frag} in
4701       ..) ;;
4702       # The odd quoting in the next line works around
4703       # an apparent bug in bash 1.12 on linux.
4704       ${srcdir}/gcc/[*]/config-lang.in) ;;
4705       *)
4706         # From the config-lang.in, get $language, $lang_requires
4707         language=
4708         lang_requires=
4709         . ${lang_frag}
4710         for other in ${lang_requires} ; do
4711           case ,${enable_languages}, in
4712             *,$other,*) ;;
4713             *,all,*) ;;
4714             *,$language,*)
4715               echo " \`$other' language required by \`$language'; enabling" 1>&2
4716               enable_languages="${enable_languages},${other}"
4717               ;;
4718           esac
4719         done
4720         ;;
4721     esac
4722   done
4723
4724   new_enable_languages=,c,
4725   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4726   potential_languages=,c,
4727
4728   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4729     case ${lang_frag} in
4730       ..) ;;
4731       # The odd quoting in the next line works around
4732       # an apparent bug in bash 1.12 on linux.
4733       ${srcdir}/gcc/[*]/config-lang.in) ;;
4734       *)
4735         # From the config-lang.in, get $language, $target_libs,
4736         # $lang_dirs, $boot_language, and $build_by_default
4737         language=
4738         target_libs=
4739         lang_dirs=
4740         subdir_requires=
4741         boot_language=no
4742         build_by_default=yes
4743         . ${lang_frag}
4744         if test x${language} = x; then
4745           echo "${lang_frag} doesn't set \$language." 1>&2
4746           exit 1
4747         fi
4748
4749         case ,${enable_languages}, in
4750           *,${language},*)
4751             # Language was explicitly selected; include it.
4752             add_this_lang=yes
4753             ;;
4754           *,all,*)
4755             # 'all' was selected, select it if it is a default language
4756             add_this_lang=${build_by_default}
4757             ;;
4758           *)
4759             add_this_lang=no
4760             ;;
4761         esac
4762
4763         # Disable languages that need other directories if these aren't available.
4764         for i in $subdir_requires; do
4765           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4766           case ,${enable_languages}, in
4767             *,${language},*)
4768               # Specifically requested language; tell them.
4769               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4770 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4771    { (exit 1); exit 1; }; }
4772               ;;
4773             *)
4774               # Silently disable.
4775               add_this_lang=unsupported
4776               ;;
4777           esac
4778         done
4779
4780         # Disable Ada if no preexisting GNAT is available.
4781         case ,${enable_languages},:${language}:${have_gnat} in
4782           *,${language},*:ada:no)
4783             # Specifically requested language; tell them.
4784             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4785 echo "$as_me: error: GNAT is required to build $language" >&2;}
4786    { (exit 1); exit 1; }; }
4787             ;;
4788           *:ada:no)
4789             # Silently disable.
4790             add_this_lang=unsupported
4791             ;;
4792         esac
4793
4794         # Disable a language that is unsupported by the target.
4795         case " $unsupported_languages " in
4796           *" $language "*)
4797             add_this_lang=unsupported
4798             ;;
4799         esac
4800
4801         case $add_this_lang in
4802           unsupported)
4803             # Remove language-dependent dirs.
4804             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4805             ;;
4806           no)
4807             # Remove language-dependent dirs; still show language as supported.
4808             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4809             potential_languages="${potential_languages}${language},"
4810             ;;
4811           yes)
4812             new_enable_languages="${new_enable_languages}${language},"
4813             potential_languages="${potential_languages}${language},"
4814             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4815             case ${boot_language} in
4816               yes)
4817                 # Add to (comma-separated) list of stage 1 languages.
4818                 stage1_languages="${stage1_languages}${language},"
4819                 ;;
4820             esac
4821             ;;
4822         esac
4823         ;;
4824     esac
4825   done
4826
4827   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4828 if test "${enable_stage1_languages+set}" = set; then
4829   enableval="$enable_stage1_languages"
4830   case ,${enable_stage1_languages}, in
4831     ,no,|,,)
4832       # Set it to something that will have no effect in the loop below
4833       enable_stage1_languages=c ;;
4834     ,yes,)
4835       enable_stage1_languages=`echo $new_enable_languages | \
4836         sed -e "s/^,//" -e "s/,$//" ` ;;
4837     *,all,*)
4838       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4839         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4840   esac
4841
4842   # Add "good" languages from enable_stage1_languages to stage1_languages,
4843   # while "bad" languages go in missing_languages.  Leave no duplicates.
4844   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4845     case $potential_languages in
4846       *,$i,*)
4847         case $stage1_languages in
4848           *,$i,*) ;;
4849           *) stage1_languages="$stage1_languages$i," ;;
4850         esac ;;
4851       *)
4852         case $missing_languages in
4853           *,$i,*) ;;
4854           *) missing_languages="$missing_languages$i," ;;
4855         esac ;;
4856      esac
4857   done
4858 fi;
4859
4860   # Remove leading/trailing commas that were added for simplicity
4861   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4862   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4863   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4864   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4865
4866   if test "x$missing_languages" != x; then
4867     { { echo "$as_me:$LINENO: error:
4868 The following requested languages could not be built: ${missing_languages}
4869 Supported languages are: ${potential_languages}" >&5
4870 echo "$as_me: error:
4871 The following requested languages could not be built: ${missing_languages}
4872 Supported languages are: ${potential_languages}" >&2;}
4873    { (exit 1); exit 1; }; }
4874   fi
4875   if test "x$new_enable_languages" != "x$enable_languages"; then
4876     echo The following languages will be built: ${new_enable_languages}
4877     enable_languages="$new_enable_languages"
4878   fi
4879
4880
4881   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4882 fi
4883
4884 # Handle --disable-<component> generically.
4885 for dir in $configdirs $build_configdirs $target_configdirs ; do
4886   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4887   if eval test x\${enable_${dirname}} "=" xno ; then
4888     noconfigdirs="$noconfigdirs $dir"
4889   fi
4890 done
4891
4892 # Check for Boehm's garbage collector
4893 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4894 if test "${enable_objc_gc+set}" = set; then
4895   enableval="$enable_objc_gc"
4896   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4897   *,objc,*:*:yes:*target-boehm-gc*)
4898     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4899 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4900    { (exit 1); exit 1; }; }
4901     ;;
4902 esac
4903 fi;
4904
4905 # Make sure we only build Boehm's garbage collector if required.
4906 case ,${enable_languages},:${enable_objc_gc} in
4907   *,objc,*:yes)
4908     # Keep target-boehm-gc if requested for Objective-C.
4909     ;;
4910   *)
4911     # Otherwise remove target-boehm-gc depending on target-libjava.
4912     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4913       noconfigdirs="$noconfigdirs target-boehm-gc"
4914     fi
4915     ;;
4916 esac
4917
4918 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4919 # $build_configdirs and $target_configdirs.
4920 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4921
4922 notsupp=""
4923 for dir in . $skipdirs $noconfigdirs ; do
4924   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4925   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4926     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4927     if test -r $srcdir/$dirname/configure ; then
4928       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4929         true
4930       else
4931         notsupp="$notsupp $dir"
4932       fi
4933     fi
4934   fi
4935   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4936     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
4937     if test -r $srcdir/$dirname/configure ; then
4938       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4939         true
4940       else
4941         notsupp="$notsupp $dir"
4942       fi
4943     fi
4944   fi
4945   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4946     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
4947     if test -r $srcdir/$dirname/configure ; then
4948       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4949         true
4950       else
4951         notsupp="$notsupp $dir"
4952       fi
4953     fi
4954   fi
4955 done
4956
4957 # Sometimes the tools are distributed with libiberty but with no other
4958 # libraries.  In that case, we don't want to build target-libiberty.
4959 # Don't let libgcc imply libiberty either.
4960 if test -n "${target_configdirs}" ; then
4961   libgcc=
4962   others=
4963   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
4964     if test "$i" = "libgcc"; then
4965       libgcc=target-libgcc
4966     elif test "$i" != "libiberty" ; then
4967       if test -r $srcdir/$i/configure ; then
4968         others=yes;
4969         break;
4970       fi
4971     fi
4972   done
4973   if test -z "${others}" ; then
4974     target_configdirs=$libgcc
4975   fi
4976 fi
4977
4978 # Quietly strip out all directories which aren't configurable in this tree.
4979 # This relies on all configurable subdirectories being autoconfiscated, which
4980 # is now the case.
4981 build_configdirs_all="$build_configdirs"
4982 build_configdirs=
4983 for i in ${build_configdirs_all} ; do
4984   j=`echo $i | sed -e s/build-//g`
4985   if test -f ${srcdir}/$j/configure ; then
4986     build_configdirs="${build_configdirs} $i"
4987   fi
4988 done
4989
4990 configdirs_all="$configdirs"
4991 configdirs=
4992 for i in ${configdirs_all} ; do
4993   if test -f ${srcdir}/$i/configure ; then
4994     configdirs="${configdirs} $i"
4995   fi
4996 done
4997
4998 target_configdirs_all="$target_configdirs"
4999 target_configdirs=
5000 for i in ${target_configdirs_all} ; do
5001   j=`echo $i | sed -e s/target-//g`
5002   if test -f ${srcdir}/$j/configure ; then
5003     target_configdirs="${target_configdirs} $i"
5004   fi
5005 done
5006
5007 # Produce a warning message for the subdirs we can't configure.
5008 # This isn't especially interesting in the Cygnus tree, but in the individual
5009 # FSF releases, it's important to let people know when their machine isn't
5010 # supported by the one or two programs in a package.
5011
5012 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5013   # If $appdirs is non-empty, at least one of those directories must still
5014   # be configured, or we error out.  (E.g., if the gas release supports a
5015   # specified target in some subdirs but not the gas subdir, we shouldn't
5016   # pretend that all is well.)
5017   if test -n "$appdirs" ; then
5018     for dir in $appdirs ; do
5019       if test -r $dir/Makefile.in ; then
5020         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5021           appdirs=""
5022           break
5023         fi
5024         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5025           appdirs=""
5026           break
5027         fi
5028       fi
5029     done
5030     if test -n "$appdirs" ; then
5031       echo "*** This configuration is not supported by this package." 1>&2
5032       exit 1
5033     fi
5034   fi
5035   # Okay, some application will build, or we don't care to check.  Still
5036   # notify of subdirs not getting built.
5037   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5038   echo "    ${notsupp}" 1>&2
5039   echo "    (Any other directories should still work fine.)" 1>&2
5040 fi
5041
5042 case "$host" in
5043   *msdosdjgpp*)
5044     enable_gdbtk=no ;;
5045 esac
5046
5047 # To find our prefix, in gcc_cv_tool_prefix.
5048
5049 # The user is always right.
5050 if test "${PATH_SEPARATOR+set}" != set; then
5051   echo "#! /bin/sh" >conf$$.sh
5052   echo  "exit 0"   >>conf$$.sh
5053   chmod +x conf$$.sh
5054   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5055     PATH_SEPARATOR=';'
5056   else
5057     PATH_SEPARATOR=:
5058   fi
5059   rm -f conf$$.sh
5060 fi
5061
5062
5063
5064 if test "x$exec_prefix" = xNONE; then
5065         if test "x$prefix" = xNONE; then
5066                 gcc_cv_tool_prefix=$ac_default_prefix
5067         else
5068                 gcc_cv_tool_prefix=$prefix
5069         fi
5070 else
5071         gcc_cv_tool_prefix=$exec_prefix
5072 fi
5073
5074 # If there is no compiler in the tree, use the PATH only.  In any
5075 # case, if there is no compiler in the tree nobody should use
5076 # AS_FOR_TARGET and LD_FOR_TARGET.
5077 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5078     gcc_version=`cat $srcdir/gcc/BASE-VER`
5079     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5080     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5081     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5082     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5083     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5084     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5085 else
5086     gcc_cv_tool_dirs=
5087 fi
5088
5089 if test x$build = x$target && test -n "$md_exec_prefix"; then
5090         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5091 fi
5092
5093
5094
5095 copy_dirs=
5096
5097
5098 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5099 if test "${with_build_sysroot+set}" = set; then
5100   withval="$with_build_sysroot"
5101   if test x"$withval" != x ; then
5102      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5103    fi
5104 else
5105   SYSROOT_CFLAGS_FOR_TARGET=
5106 fi;
5107
5108
5109
5110 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5111 if test "${with_debug_prefix_map+set}" = set; then
5112   withval="$with_debug_prefix_map"
5113   if test x"$withval" != x; then
5114      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5115      for debug_map in $withval; do
5116        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5117      done
5118    fi
5119 else
5120   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5121 fi;
5122
5123
5124 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5125 # the named directory are copied to $(tooldir)/sys-include.
5126 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5127   if test x${is_cross_compiler} = xno ; then
5128     echo 1>&2 '***' --with-headers is only supported when cross compiling
5129     exit 1
5130   fi
5131   if test x"${with_headers}" != xyes ; then
5132     x=${gcc_cv_tool_prefix}
5133     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5134   fi
5135 fi
5136
5137 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5138 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5139 # are permitted.
5140 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5141   if test x${is_cross_compiler} = xno ; then
5142     echo 1>&2 '***' --with-libs is only supported when cross compiling
5143     exit 1
5144   fi
5145   if test x"${with_libs}" != xyes ; then
5146     # Copy the libraries in reverse order, so that files in the first named
5147     # library override files in subsequent libraries.
5148     x=${gcc_cv_tool_prefix}
5149     for l in ${with_libs}; do
5150       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5151     done
5152   fi
5153 fi
5154
5155 # Set with_gnu_as and with_gnu_ld as appropriate.
5156 #
5157 # This is done by determining whether or not the appropriate directory
5158 # is available, and by checking whether or not specific configurations
5159 # have requested that this magic not happen.
5160 #
5161 # The command line options always override the explicit settings in
5162 # configure.in, and the settings in configure.in override this magic.
5163 #
5164 # If the default for a toolchain is to use GNU as and ld, and you don't
5165 # want to do that, then you should use the --without-gnu-as and
5166 # --without-gnu-ld options for the configure script.
5167
5168 if test x${use_gnu_as} = x &&
5169    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5170   with_gnu_as=yes
5171   extra_host_args="$extra_host_args --with-gnu-as"
5172 fi
5173
5174 if test x${use_gnu_ld} = x &&
5175    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
5176   with_gnu_ld=yes
5177   extra_host_args="$extra_host_args --with-gnu-ld"
5178 fi
5179
5180 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5181 # can detect this case.
5182
5183 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5184   with_newlib=yes
5185   extra_host_args="$extra_host_args --with-newlib"
5186 fi
5187
5188 # Handle ${copy_dirs}
5189 set fnord ${copy_dirs}
5190 shift
5191 while test $# != 0 ; do
5192   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5193     :
5194   else
5195     echo Copying $1 to $2
5196
5197     # Use the install script to create the directory and all required
5198     # parent directories.
5199     if test -d $2 ; then
5200       :
5201     else
5202       echo >config.temp
5203       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5204     fi
5205
5206     # Copy the directory, assuming we have tar.
5207     # FIXME: Should we use B in the second tar?  Not all systems support it.
5208     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5209
5210     # It is the responsibility of the user to correctly adjust all
5211     # symlinks.  If somebody can figure out how to handle them correctly
5212     # here, feel free to add the code.
5213
5214     echo $1 > $2/COPIED
5215   fi
5216   shift; shift
5217 done
5218
5219 # Determine a target-dependent exec_prefix that the installed
5220 # gcc will search in.  Keep this list sorted by triplet, with
5221 # the *-*-osname triplets last.
5222 md_exec_prefix=
5223 case "${target}" in
5224   alpha*-*-*vms*)
5225     md_exec_prefix=/gnu/lib/gcc-lib
5226     ;;
5227   i[34567]86-pc-msdosdjgpp*)
5228     md_exec_prefix=/dev/env/DJDIR/bin
5229     ;;
5230   i[34567]86-*-sco3.2v5*)
5231     if test $with_gnu_as = yes; then
5232       md_exec_prefix=/usr/gnu/bin
5233     else
5234       md_exec_prefix=/usr/ccs/bin/elf
5235     fi
5236     ;;
5237
5238   mn10300-*-* | \
5239   powerpc-*-chorusos* | \
5240   powerpc*-*-eabi* | \
5241   powerpc*-*-sysv* | \
5242   powerpc*-*-kaos* | \
5243   s390x-ibm-tpf*)
5244     md_exec_prefix=/usr/ccs/bin
5245     ;;
5246   sparc64-*-elf*)
5247     ;;
5248   v850*-*-*)
5249     md_exec_prefix=/usr/ccs/bin
5250     ;;
5251   xtensa-*-elf*)
5252     ;;
5253
5254   *-*-beos* | \
5255   *-*-elf* | \
5256   *-*-hpux* | \
5257   *-*-netware* | \
5258   *-*-nto-qnx* | \
5259   *-*-rtems* | \
5260   *-*-solaris2* | \
5261   *-*-sysv[45]* | \
5262   *-*-vxworks* | \
5263   *-wrs-windiss)
5264     md_exec_prefix=/usr/ccs/bin
5265     ;;
5266 esac
5267
5268 extra_arflags_for_target=
5269 extra_nmflags_for_target=
5270 extra_ranlibflags_for_target=
5271 target_makefile_frag=/dev/null
5272 case "${target}" in
5273   mep*-*-*)
5274     target_makefile_frag="config/mt-mep"
5275     ;;
5276   spu-*-*)
5277     target_makefile_frag="config/mt-spu"
5278     ;;
5279   mips*-sde-elf*)
5280     target_makefile_frag="config/mt-sde"
5281     ;;
5282   *-*-netware*)
5283     target_makefile_frag="config/mt-netware"
5284     ;;
5285   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5286     target_makefile_frag="config/mt-gnu"
5287     ;;
5288   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5289     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5290     # commands to handle both 32-bit and 64-bit objects.  These flags are
5291     # harmless if we're using GNU nm or ar.
5292     extra_arflags_for_target=" -X32_64"
5293     extra_nmflags_for_target=" -B -X32_64"
5294     ;;
5295   *-*-darwin*)
5296     # ranlib from Darwin requires the -c flag to look at common symbols.
5297     extra_ranlibflags_for_target=" -c"
5298     ;;
5299   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5300     target_makefile_frag="config/mt-wince"
5301     ;;
5302 esac
5303
5304 alphaieee_frag=/dev/null
5305 case $target in
5306   alpha*-*-*)
5307     # This just makes sure to use the -mieee option to build target libs.
5308     # This should probably be set individually by each library.
5309     alphaieee_frag="config/mt-alphaieee"
5310     ;;
5311 esac
5312
5313 # If --enable-target-optspace always use -Os instead of -O2 to build
5314 # the target libraries, similarly if it is not specified, use -Os
5315 # on selected platforms.
5316 ospace_frag=/dev/null
5317 case "${enable_target_optspace}:${target}" in
5318   yes:*)
5319     ospace_frag="config/mt-ospace"
5320     ;;
5321   :d30v-*)
5322     ospace_frag="config/mt-d30v"
5323     ;;
5324   :m32r-* | :d10v-* | :fr30-*)
5325     ospace_frag="config/mt-ospace"
5326     ;;
5327   no:* | :*)
5328     ;;
5329   *)
5330     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5331     ;;
5332 esac
5333
5334 # Default to using --with-stabs for certain targets.
5335 if test x${with_stabs} = x ; then
5336   case "${target}" in
5337   mips*-*-irix[56]*)
5338     ;;
5339   mips*-*-* | alpha*-*-osf*)
5340     with_stabs=yes;
5341     extra_host_args="${extra_host_args} --with-stabs"
5342     ;;
5343   esac
5344 fi
5345
5346 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5347 # them automatically.
5348 case "${host}" in
5349   hppa*64*-*-hpux11*)
5350     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5351     ;;
5352 esac
5353
5354 # Some systems (e.g., one of the i386-aix systems the gas testers are
5355 # using) don't handle "\$" correctly, so don't use it here.
5356 tooldir='${exec_prefix}'/${target_noncanonical}
5357 build_tooldir=${tooldir}
5358
5359 # Create a .gdbinit file which runs the one in srcdir
5360 # and tells GDB to look there for source files.
5361
5362 if test -r ${srcdir}/.gdbinit ; then
5363   case ${srcdir} in
5364     .) ;;
5365     *) cat > ./.gdbinit <<EOF
5366 # ${NO_EDIT}
5367 dir ${srcdir}
5368 dir .
5369 source ${srcdir}/.gdbinit
5370 EOF
5371     ;;
5372   esac
5373 fi
5374
5375 # Make sure that the compiler is able to generate an executable.  If it
5376 # can't, we are probably in trouble.  We don't care whether we can run the
5377 # executable--we might be using a cross compiler--we only care whether it
5378 # can be created.  At this point the main configure script has set CC.
5379 we_are_ok=no
5380 echo "int main () { return 0; }" > conftest.c
5381 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5382 if test $? = 0 ; then
5383   if test -s conftest || test -s conftest.exe ; then
5384     we_are_ok=yes
5385   fi
5386 fi
5387 case $we_are_ok in
5388   no)
5389     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5390     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5391     rm -f conftest*
5392     exit 1
5393     ;;
5394 esac
5395 rm -f conftest*
5396
5397 # The Solaris /usr/ucb/cc compiler does not appear to work.
5398 case "${host}" in
5399   sparc-sun-solaris2*)
5400       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5401       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5402           could_use=
5403           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5404           if test -d /opt/cygnus/bin ; then
5405               if test "$could_use" = "" ; then
5406                   could_use="/opt/cygnus/bin"
5407               else
5408                   could_use="$could_use or /opt/cygnus/bin"
5409               fi
5410           fi
5411         if test "$could_use" = "" ; then
5412             echo "Warning: compilation may fail because you're using"
5413             echo "/usr/ucb/cc.  You should change your PATH or CC "
5414             echo "variable and rerun configure."
5415         else
5416             echo "Warning: compilation may fail because you're using"
5417             echo "/usr/ucb/cc, when you should use the C compiler from"
5418             echo "$could_use.  You should change your"
5419             echo "PATH or CC variable and rerun configure."
5420         fi
5421       fi
5422   ;;
5423 esac
5424
5425 case "${host}" in
5426   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5427   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5428   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5429 esac
5430
5431 # Record target_configdirs and the configure arguments for target and
5432 # build configuration in Makefile.
5433 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5434 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5435
5436 # Determine whether gdb needs tk/tcl or not.
5437 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5438 # and in that case we want gdb to be built without tk.  Ugh!
5439 # In fact I believe gdb is the *only* package directly dependent on tk,
5440 # so we should be able to put the 'maybe's in unconditionally and
5441 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5442 # 100% sure that that's safe though.
5443
5444 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5445 case "$enable_gdbtk" in
5446   no)
5447     GDB_TK="" ;;
5448   yes)
5449     GDB_TK="${gdb_tk}" ;;
5450   *)
5451     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5452     # distro.  Eventually someone will fix this and move Insight, nee
5453     # gdbtk to a separate directory.
5454     if test -d ${srcdir}/gdb/gdbtk ; then
5455       GDB_TK="${gdb_tk}"
5456     else
5457       GDB_TK=""
5458     fi
5459     ;;
5460 esac
5461 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5462 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5463
5464 # Strip out unwanted targets.
5465
5466 # While at that, we remove Makefiles if we were started for recursive
5467 # configuration, so that the top-level Makefile reconfigures them,
5468 # like we used to do when configure itself was recursive.
5469
5470 # Loop over modules.  $extrasub must be used with care, limiting as
5471 # much as possible the usage of range addresses.  That's because autoconf
5472 # splits the sed script to overcome limits in the number of commands,
5473 # and relying on carefully-timed sed passes may turn out to be very hard
5474 # to maintain later.  In this particular case, you just have to be careful
5475 # not to nest @if/@endif pairs, because configure will not warn you at all.
5476
5477 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5478 if test "${enable_bootstrap+set}" = set; then
5479   enableval="$enable_bootstrap"
5480
5481 else
5482   enable_bootstrap=default
5483 fi;
5484
5485 # Issue errors and warnings for invalid/strange bootstrap combinations.
5486 case "$configdirs" in
5487   *gcc*) have_compiler=yes ;;
5488   *) have_compiler=no ;;
5489 esac
5490
5491 case "$have_compiler:$host:$target:$enable_bootstrap" in
5492   *:*:*:no) ;;
5493
5494   # Default behavior.  Enable bootstrap if we have a compiler
5495   # and we are in a native configuration.
5496   yes:$build:$build:default)
5497     enable_bootstrap=yes ;;
5498
5499   *:*:*:default)
5500     enable_bootstrap=no ;;
5501
5502   # We have a compiler and we are in a native configuration, bootstrap is ok
5503   yes:$build:$build:yes)
5504     ;;
5505
5506   # Other configurations, but we have a compiler.  Assume the user knows
5507   # what he's doing.
5508   yes:*:*:yes)
5509     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5510 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5511     ;;
5512
5513   # No compiler: if they passed --enable-bootstrap explicitly, fail
5514   no:*:*:yes)
5515     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5516 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5517    { (exit 1); exit 1; }; } ;;
5518
5519   # Fail if wrong command line
5520   *)
5521     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5522 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5523    { (exit 1); exit 1; }; }
5524     ;;
5525 esac
5526
5527 # Adjust the toplevel makefile according to whether bootstrap was selected.
5528 case "$enable_bootstrap" in
5529   yes)
5530     bootstrap_suffix=bootstrap ;;
5531   no)
5532     bootstrap_suffix=no-bootstrap ;;
5533 esac
5534
5535 for module in ${build_configdirs} ; do
5536   if test -z "${no_recursion}" \
5537      && test -f ${build_subdir}/${module}/Makefile; then
5538     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5539     rm -f ${build_subdir}/${module}/Makefile
5540   fi
5541   extrasub="$extrasub
5542 /^@if build-$module\$/d
5543 /^@endif build-$module\$/d
5544 /^@if build-$module-$bootstrap_suffix\$/d
5545 /^@endif build-$module-$bootstrap_suffix\$/d"
5546 done
5547 for module in ${configdirs} ; do
5548   if test -z "${no_recursion}"; then
5549     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5550       if test -f ${file}; then
5551         echo 1>&2 "*** removing ${file} to force reconfigure"
5552         rm -f ${file}
5553       fi
5554     done
5555   fi
5556   extrasub="$extrasub
5557 /^@if $module\$/d
5558 /^@endif $module\$/d
5559 /^@if $module-$bootstrap_suffix\$/d
5560 /^@endif $module-$bootstrap_suffix\$/d"
5561 done
5562 for module in ${target_configdirs} ; do
5563   if test -z "${no_recursion}" \
5564      && test -f ${target_subdir}/${module}/Makefile; then
5565     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5566     rm -f ${target_subdir}/${module}/Makefile
5567   fi
5568   extrasub="$extrasub
5569 /^@if target-$module\$/d
5570 /^@endif target-$module\$/d
5571 /^@if target-$module-$bootstrap_suffix\$/d
5572 /^@endif target-$module-$bootstrap_suffix\$/d"
5573 done
5574
5575 extrasub="$extrasub
5576 /^@if /,/^@endif /d"
5577
5578 # Create the serialization dependencies.  This uses a temporary file.
5579
5580 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5581 if test "${enable_serial_configure+set}" = set; then
5582   enableval="$enable_serial_configure"
5583
5584 fi;
5585
5586 case ${enable_serial_configure} in
5587   yes)
5588     enable_serial_build_configure=yes
5589     enable_serial_host_configure=yes
5590     enable_serial_target_configure=yes
5591     ;;
5592 esac
5593
5594 # These force 'configure's to be done one at a time, to avoid problems
5595 # with contention over a shared config.cache.
5596 rm -f serdep.tmp
5597 echo '# serdep.tmp' > serdep.tmp
5598 olditem=
5599 test "x${enable_serial_build_configure}" = xyes &&
5600 for item in ${build_configdirs} ; do
5601   case ${olditem} in
5602     "") ;;
5603     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5604   esac
5605   olditem=${item}
5606 done
5607 olditem=
5608 test "x${enable_serial_host_configure}" = xyes &&
5609 for item in ${configdirs} ; do
5610   case ${olditem} in
5611     "") ;;
5612     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5613   esac
5614   olditem=${item}
5615 done
5616 olditem=
5617 test "x${enable_serial_target_configure}" = xyes &&
5618 for item in ${target_configdirs} ; do
5619   case ${olditem} in
5620     "") ;;
5621     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5622   esac
5623   olditem=${item}
5624 done
5625 serialization_dependencies=serdep.tmp
5626
5627
5628 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5629 # target, nonopt, and variable assignments.  These are the ones we
5630 # might not want to pass down to subconfigures.  Also strip
5631 # program-prefix, program-suffix, and program-transform-name, so that
5632 # we can pass down a consistent program-transform-name.
5633 baseargs=
5634 keep_next=no
5635 skip_next=no
5636 eval "set -- $ac_configure_args"
5637 for ac_arg
5638 do
5639   if test X"$skip_next" = X"yes"; then
5640     skip_next=no
5641     continue
5642   fi
5643   if test X"$keep_next" = X"yes"; then
5644     case $ac_arg in
5645       *\'*)
5646         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5647     esac
5648     baseargs="$baseargs '$ac_arg'"
5649     keep_next=no
5650     continue
5651   fi
5652
5653   # Handle separated arguments.  Based on the logic generated by
5654   # autoconf 2.59.
5655   case $ac_arg in
5656     *=* | --config-cache | -C | -disable-* | --disable-* \
5657       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5658       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5659       | -with-* | --with-* | -without-* | --without-* | --x)
5660       separate_arg=no
5661       ;;
5662     -*)
5663       separate_arg=yes
5664       ;;
5665     *)
5666       separate_arg=no
5667       ;;
5668   esac
5669
5670   case "$ac_arg" in
5671     --no*)
5672       continue
5673       ;;
5674     --c* | \
5675     --sr* | \
5676     --ho* | \
5677     --bu* | \
5678     --t* | \
5679     --program-* | \
5680     -cache_file* | \
5681     -srcdir* | \
5682     -host* | \
5683     -build* | \
5684     -target* | \
5685     -program-prefix* | \
5686     -program-suffix* | \
5687     -program-transform-name* )
5688       skip_next=$separate_arg
5689       continue
5690       ;;
5691     -*)
5692       # An option.  Add it.
5693       case $ac_arg in
5694         *\'*)
5695           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5696       esac
5697       baseargs="$baseargs '$ac_arg'"
5698       keep_next=$separate_arg
5699       ;;
5700     *)
5701       # Either a variable assignment, or a nonopt (triplet).  Don't
5702       # pass it down; let the Makefile handle this.
5703       continue
5704       ;;
5705   esac
5706 done
5707 # Remove the initial space we just introduced and, as these will be
5708 # expanded by make, quote '$'.
5709 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5710
5711 # Add in --program-transform-name, after --program-prefix and
5712 # --program-suffix have been applied to it.  Autoconf has already
5713 # doubled dollar signs and backslashes in program_transform_name; we want
5714 # the backslashes un-doubled, and then the entire thing wrapped in single
5715 # quotes, because this will be expanded first by make and then by the shell.
5716 # Also, because we want to override the logic in subdir configure scripts to
5717 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5718 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5719 ${program_transform_name}
5720 EOF_SED
5721 gcc_transform_name=`cat conftestsed.out`
5722 rm -f conftestsed.out
5723 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5724 if test "$silent" = yes; then
5725   baseargs="$baseargs --silent"
5726 fi
5727
5728 # For the build-side libraries, we just need to pretend we're native,
5729 # and not use the same cache file.  Multilibs are neither needed nor
5730 # desired.
5731 build_configargs="--cache-file=../config.cache ${baseargs}"
5732
5733 # For host modules, accept cache file option, or specification as blank.
5734 case "${cache_file}" in
5735 "") # empty
5736   cache_file_option="" ;;
5737 /* | [A-Za-z]:[\\/]* ) # absolute path
5738   cache_file_option="--cache-file=${cache_file}" ;;
5739 *) # relative path
5740   cache_file_option="--cache-file=../${cache_file}" ;;
5741 esac
5742
5743 # Host dirs don't like to share a cache file either, horribly enough.
5744 # This seems to be due to autoconf 2.5x stupidity.
5745 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5746
5747 target_configargs=${baseargs}
5748
5749 # Passing a --with-cross-host argument lets the target libraries know
5750 # whether they are being built with a cross-compiler or being built
5751 # native.  However, it would be better to use other mechanisms to make the
5752 # sorts of decisions they want to make on this basis.  Please consider
5753 # this option to be deprecated.  FIXME.
5754 if test x${is_cross_compiler} = xyes ; then
5755   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5756 fi
5757
5758 # Default to --enable-multilib.
5759 if test x${enable_multilib} = x ; then
5760   target_configargs="--enable-multilib ${target_configargs}"
5761 fi
5762
5763 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5764 # changed from the earlier setting of with_newlib.
5765 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5766   target_configargs="--with-newlib ${target_configargs}"
5767 fi
5768
5769 # Different target subdirs use different values of certain variables
5770 # (notably CXX).  Worse, multilibs use *lots* of different values.
5771 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5772 # it doesn't automatically accept command-line overrides of them.
5773 # This means it's not safe for target subdirs to share a cache file,
5774 # which is disgusting, but there you have it.  Hopefully this can be
5775 # fixed in future.  It's still worthwhile to use a cache file for each
5776 # directory.  I think.
5777
5778 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5779 # We need to pass --target, as newer autoconf's requires consistency
5780 # for target_alias and gcc doesn't manage it consistently.
5781 target_configargs="--cache-file=./config.cache ${target_configargs}"
5782
5783 FLAGS_FOR_TARGET=
5784 case " $target_configdirs " in
5785  *" newlib "*)
5786   case " $target_configargs " in
5787   *" --with-newlib "*)
5788    case "$target" in
5789    *-cygwin*)
5790      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' ;;
5791    esac
5792
5793    # If we're not building GCC, don't discard standard headers.
5794    if test -d ${srcdir}/gcc; then
5795      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5796
5797      if test "${build}" != "${host}"; then
5798        # On Canadian crosses, CC_FOR_TARGET will have already been set
5799        # by `configure', so we won't have an opportunity to add -Bgcc/
5800        # to it.  This is right: we don't want to search that directory
5801        # for binaries, but we want the header files in there, so add
5802        # them explicitly.
5803        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5804
5805        # Someone might think of using the pre-installed headers on
5806        # Canadian crosses, in case the installed compiler is not fully
5807        # compatible with the compiler being built.  In this case, it
5808        # would be better to flag an error than risking having
5809        # incompatible object files being constructed.  We can't
5810        # guarantee that an error will be flagged, but let's hope the
5811        # compiler will do it, when presented with incompatible header
5812        # files.
5813      fi
5814    fi
5815
5816    case "${target}-${is_cross_compiler}" in
5817    i[3456789]86-*-linux*-no)
5818       # Here host == target, so we don't need to build gcc,
5819       # so we don't want to discard standard headers.
5820       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5821       ;;
5822    *)
5823       # If we're building newlib, use its generic headers last, but search
5824       # for any libc-related directories first (so make it the last -B
5825       # switch).
5826       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5827
5828       # If we're building libgloss, find the startup file, simulator library
5829       # and linker script.
5830       case " $target_configdirs " in
5831         *" libgloss "*)
5832         # Look for startup file, simulator library and maybe linker script.
5833         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
5834         # Look for libnosys.a in case the target needs it.
5835         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5836         # Most targets have the linker script in the source directory.
5837         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
5838         ;;
5839       esac
5840       ;;
5841    esac
5842    ;;
5843   esac
5844   ;;
5845 esac
5846 case "$target" in
5847 *-mingw*)
5848   # Can't be handled as Cygwin above since Mingw does not use newlib.
5849   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' ;;
5850 esac
5851
5852 # Allow the user to override the flags for
5853 # our build compiler if desired.
5854 CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5855
5856 # On Canadian crosses, we'll be searching the right directories for
5857 # the previously-installed cross compiler, so don't bother to add
5858 # flags for directories within the install tree of the compiler
5859 # being built; programs in there won't even run.
5860 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5861   # Search for pre-installed headers if nothing else fits.
5862   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5863 fi
5864
5865 if test "x${use_gnu_ld}" = x &&
5866    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5867   # Arrange for us to find uninstalled linker scripts.
5868   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5869 fi
5870
5871 # Search for other target-specific linker scripts and such.
5872 case "${target}" in
5873   mep*)
5874     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5875     ;;
5876 esac
5877
5878 # Makefile fragments.
5879 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5880 do
5881   eval fragval=\$$frag
5882   if test $fragval != /dev/null; then
5883     eval $frag=${srcdir}/$fragval
5884   fi
5885 done
5886
5887
5888
5889
5890
5891 # Miscellanea: directories, flags, etc.
5892
5893
5894
5895
5896
5897
5898
5899 # Build module lists & subconfigure args.
5900
5901
5902
5903 # Host module lists & subconfigure args.
5904
5905
5906
5907 # Target module lists & subconfigure args.
5908
5909
5910
5911 # Build tools.
5912
5913
5914
5915 # Generate default definitions for YACC, M4, LEX and other programs that run
5916 # on the build machine.  These are used if the Makefile can't locate these
5917 # programs in objdir.
5918 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5919
5920 for ac_prog in 'bison -y' byacc yacc
5921 do
5922   # Extract the first word of "$ac_prog", so it can be a program name with args.
5923 set dummy $ac_prog; ac_word=$2
5924 echo "$as_me:$LINENO: checking for $ac_word" >&5
5925 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5926 if test "${ac_cv_prog_YACC+set}" = set; then
5927   echo $ECHO_N "(cached) $ECHO_C" >&6
5928 else
5929   if test -n "$YACC"; then
5930   ac_cv_prog_YACC="$YACC" # Let the user override the test.
5931 else
5932 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5933 for as_dir in $PATH
5934 do
5935   IFS=$as_save_IFS
5936   test -z "$as_dir" && as_dir=.
5937   for ac_exec_ext in '' $ac_executable_extensions; do
5938   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5939     ac_cv_prog_YACC="$ac_prog"
5940     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5941     break 2
5942   fi
5943 done
5944 done
5945
5946 fi
5947 fi
5948 YACC=$ac_cv_prog_YACC
5949 if test -n "$YACC"; then
5950   echo "$as_me:$LINENO: result: $YACC" >&5
5951 echo "${ECHO_T}$YACC" >&6
5952 else
5953   echo "$as_me:$LINENO: result: no" >&5
5954 echo "${ECHO_T}no" >&6
5955 fi
5956
5957   test -n "$YACC" && break
5958 done
5959 test -n "$YACC" || YACC="$MISSING bison -y"
5960
5961 case " $build_configdirs " in
5962   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
5963   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
5964 esac
5965
5966 for ac_prog in bison
5967 do
5968   # Extract the first word of "$ac_prog", so it can be a program name with args.
5969 set dummy $ac_prog; ac_word=$2
5970 echo "$as_me:$LINENO: checking for $ac_word" >&5
5971 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5972 if test "${ac_cv_prog_BISON+set}" = set; then
5973   echo $ECHO_N "(cached) $ECHO_C" >&6
5974 else
5975   if test -n "$BISON"; then
5976   ac_cv_prog_BISON="$BISON" # Let the user override the test.
5977 else
5978 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5979 for as_dir in $PATH
5980 do
5981   IFS=$as_save_IFS
5982   test -z "$as_dir" && as_dir=.
5983   for ac_exec_ext in '' $ac_executable_extensions; do
5984   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5985     ac_cv_prog_BISON="$ac_prog"
5986     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5987     break 2
5988   fi
5989 done
5990 done
5991
5992 fi
5993 fi
5994 BISON=$ac_cv_prog_BISON
5995 if test -n "$BISON"; then
5996   echo "$as_me:$LINENO: result: $BISON" >&5
5997 echo "${ECHO_T}$BISON" >&6
5998 else
5999   echo "$as_me:$LINENO: result: no" >&5
6000 echo "${ECHO_T}no" >&6
6001 fi
6002
6003   test -n "$BISON" && break
6004 done
6005 test -n "$BISON" || BISON="$MISSING bison"
6006
6007 case " $build_configdirs " in
6008   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6009 esac
6010
6011 for ac_prog in gm4 gnum4 m4
6012 do
6013   # Extract the first word of "$ac_prog", so it can be a program name with args.
6014 set dummy $ac_prog; ac_word=$2
6015 echo "$as_me:$LINENO: checking for $ac_word" >&5
6016 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6017 if test "${ac_cv_prog_M4+set}" = set; then
6018   echo $ECHO_N "(cached) $ECHO_C" >&6
6019 else
6020   if test -n "$M4"; then
6021   ac_cv_prog_M4="$M4" # Let the user override the test.
6022 else
6023 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6024 for as_dir in $PATH
6025 do
6026   IFS=$as_save_IFS
6027   test -z "$as_dir" && as_dir=.
6028   for ac_exec_ext in '' $ac_executable_extensions; do
6029   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6030     ac_cv_prog_M4="$ac_prog"
6031     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6032     break 2
6033   fi
6034 done
6035 done
6036
6037 fi
6038 fi
6039 M4=$ac_cv_prog_M4
6040 if test -n "$M4"; then
6041   echo "$as_me:$LINENO: result: $M4" >&5
6042 echo "${ECHO_T}$M4" >&6
6043 else
6044   echo "$as_me:$LINENO: result: no" >&5
6045 echo "${ECHO_T}no" >&6
6046 fi
6047
6048   test -n "$M4" && break
6049 done
6050 test -n "$M4" || M4="$MISSING m4"
6051
6052 case " $build_configdirs " in
6053   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6054 esac
6055
6056 for ac_prog in flex lex
6057 do
6058   # Extract the first word of "$ac_prog", so it can be a program name with args.
6059 set dummy $ac_prog; ac_word=$2
6060 echo "$as_me:$LINENO: checking for $ac_word" >&5
6061 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6062 if test "${ac_cv_prog_LEX+set}" = set; then
6063   echo $ECHO_N "(cached) $ECHO_C" >&6
6064 else
6065   if test -n "$LEX"; then
6066   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6067 else
6068 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6069 for as_dir in $PATH
6070 do
6071   IFS=$as_save_IFS
6072   test -z "$as_dir" && as_dir=.
6073   for ac_exec_ext in '' $ac_executable_extensions; do
6074   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6075     ac_cv_prog_LEX="$ac_prog"
6076     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6077     break 2
6078   fi
6079 done
6080 done
6081
6082 fi
6083 fi
6084 LEX=$ac_cv_prog_LEX
6085 if test -n "$LEX"; then
6086   echo "$as_me:$LINENO: result: $LEX" >&5
6087 echo "${ECHO_T}$LEX" >&6
6088 else
6089   echo "$as_me:$LINENO: result: no" >&5
6090 echo "${ECHO_T}no" >&6
6091 fi
6092
6093   test -n "$LEX" && break
6094 done
6095 test -n "$LEX" || LEX="$MISSING flex"
6096
6097 case " $build_configdirs " in
6098   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6099   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6100 esac
6101
6102 for ac_prog in flex
6103 do
6104   # Extract the first word of "$ac_prog", so it can be a program name with args.
6105 set dummy $ac_prog; ac_word=$2
6106 echo "$as_me:$LINENO: checking for $ac_word" >&5
6107 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6108 if test "${ac_cv_prog_FLEX+set}" = set; then
6109   echo $ECHO_N "(cached) $ECHO_C" >&6
6110 else
6111   if test -n "$FLEX"; then
6112   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6113 else
6114 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6115 for as_dir in $PATH
6116 do
6117   IFS=$as_save_IFS
6118   test -z "$as_dir" && as_dir=.
6119   for ac_exec_ext in '' $ac_executable_extensions; do
6120   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6121     ac_cv_prog_FLEX="$ac_prog"
6122     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6123     break 2
6124   fi
6125 done
6126 done
6127
6128 fi
6129 fi
6130 FLEX=$ac_cv_prog_FLEX
6131 if test -n "$FLEX"; then
6132   echo "$as_me:$LINENO: result: $FLEX" >&5
6133 echo "${ECHO_T}$FLEX" >&6
6134 else
6135   echo "$as_me:$LINENO: result: no" >&5
6136 echo "${ECHO_T}no" >&6
6137 fi
6138
6139   test -n "$FLEX" && break
6140 done
6141 test -n "$FLEX" || FLEX="$MISSING flex"
6142
6143 case " $build_configdirs " in
6144   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6145 esac
6146
6147 for ac_prog in makeinfo
6148 do
6149   # Extract the first word of "$ac_prog", so it can be a program name with args.
6150 set dummy $ac_prog; ac_word=$2
6151 echo "$as_me:$LINENO: checking for $ac_word" >&5
6152 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6153 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6154   echo $ECHO_N "(cached) $ECHO_C" >&6
6155 else
6156   if test -n "$MAKEINFO"; then
6157   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6158 else
6159 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6160 for as_dir in $PATH
6161 do
6162   IFS=$as_save_IFS
6163   test -z "$as_dir" && as_dir=.
6164   for ac_exec_ext in '' $ac_executable_extensions; do
6165   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6166     ac_cv_prog_MAKEINFO="$ac_prog"
6167     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6168     break 2
6169   fi
6170 done
6171 done
6172
6173 fi
6174 fi
6175 MAKEINFO=$ac_cv_prog_MAKEINFO
6176 if test -n "$MAKEINFO"; then
6177   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6178 echo "${ECHO_T}$MAKEINFO" >&6
6179 else
6180   echo "$as_me:$LINENO: result: no" >&5
6181 echo "${ECHO_T}no" >&6
6182 fi
6183
6184   test -n "$MAKEINFO" && break
6185 done
6186 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6187
6188 case " $build_configdirs " in
6189   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6190   *)
6191
6192     # For an installed makeinfo, we require it to be from texinfo 4.4 or
6193     # higher, else we use the "missing" dummy.
6194     if ${MAKEINFO} --version \
6195        | egrep 'texinfo[^0-9]*(4\.([4-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6196       :
6197     else
6198       MAKEINFO="$MISSING makeinfo"
6199     fi
6200     ;;
6201
6202 esac
6203
6204 # FIXME: expect and dejagnu may become build tools?
6205
6206 for ac_prog in expect
6207 do
6208   # Extract the first word of "$ac_prog", so it can be a program name with args.
6209 set dummy $ac_prog; ac_word=$2
6210 echo "$as_me:$LINENO: checking for $ac_word" >&5
6211 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6212 if test "${ac_cv_prog_EXPECT+set}" = set; then
6213   echo $ECHO_N "(cached) $ECHO_C" >&6
6214 else
6215   if test -n "$EXPECT"; then
6216   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6217 else
6218 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6219 for as_dir in $PATH
6220 do
6221   IFS=$as_save_IFS
6222   test -z "$as_dir" && as_dir=.
6223   for ac_exec_ext in '' $ac_executable_extensions; do
6224   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6225     ac_cv_prog_EXPECT="$ac_prog"
6226     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6227     break 2
6228   fi
6229 done
6230 done
6231
6232 fi
6233 fi
6234 EXPECT=$ac_cv_prog_EXPECT
6235 if test -n "$EXPECT"; then
6236   echo "$as_me:$LINENO: result: $EXPECT" >&5
6237 echo "${ECHO_T}$EXPECT" >&6
6238 else
6239   echo "$as_me:$LINENO: result: no" >&5
6240 echo "${ECHO_T}no" >&6
6241 fi
6242
6243   test -n "$EXPECT" && break
6244 done
6245 test -n "$EXPECT" || EXPECT="expect"
6246
6247 case " $configdirs " in
6248   *" expect "*)
6249     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6250     ;;
6251 esac
6252
6253 for ac_prog in runtest
6254 do
6255   # Extract the first word of "$ac_prog", so it can be a program name with args.
6256 set dummy $ac_prog; ac_word=$2
6257 echo "$as_me:$LINENO: checking for $ac_word" >&5
6258 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6259 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6260   echo $ECHO_N "(cached) $ECHO_C" >&6
6261 else
6262   if test -n "$RUNTEST"; then
6263   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6264 else
6265 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6266 for as_dir in $PATH
6267 do
6268   IFS=$as_save_IFS
6269   test -z "$as_dir" && as_dir=.
6270   for ac_exec_ext in '' $ac_executable_extensions; do
6271   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6272     ac_cv_prog_RUNTEST="$ac_prog"
6273     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6274     break 2
6275   fi
6276 done
6277 done
6278
6279 fi
6280 fi
6281 RUNTEST=$ac_cv_prog_RUNTEST
6282 if test -n "$RUNTEST"; then
6283   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6284 echo "${ECHO_T}$RUNTEST" >&6
6285 else
6286   echo "$as_me:$LINENO: result: no" >&5
6287 echo "${ECHO_T}no" >&6
6288 fi
6289
6290   test -n "$RUNTEST" && break
6291 done
6292 test -n "$RUNTEST" || RUNTEST="runtest"
6293
6294 case " $configdirs " in
6295   *" dejagnu "*)
6296     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6297     ;;
6298 esac
6299
6300
6301 # Host tools.
6302 ncn_tool_prefix=
6303 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6304 ncn_target_tool_prefix=
6305 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6306
6307
6308
6309 if test -n "$AR"; then
6310   ac_cv_prog_AR=$AR
6311 elif test -n "$ac_cv_prog_AR"; then
6312   AR=$ac_cv_prog_AR
6313 fi
6314
6315 if test -n "$ac_cv_prog_AR"; then
6316   for ncn_progname in ar; do
6317     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6318 set dummy ${ncn_progname}; ac_word=$2
6319 echo "$as_me:$LINENO: checking for $ac_word" >&5
6320 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6321 if test "${ac_cv_prog_AR+set}" = set; then
6322   echo $ECHO_N "(cached) $ECHO_C" >&6
6323 else
6324   if test -n "$AR"; then
6325   ac_cv_prog_AR="$AR" # Let the user override the test.
6326 else
6327 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6328 for as_dir in $PATH
6329 do
6330   IFS=$as_save_IFS
6331   test -z "$as_dir" && as_dir=.
6332   for ac_exec_ext in '' $ac_executable_extensions; do
6333   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6334     ac_cv_prog_AR="${ncn_progname}"
6335     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6336     break 2
6337   fi
6338 done
6339 done
6340
6341 fi
6342 fi
6343 AR=$ac_cv_prog_AR
6344 if test -n "$AR"; then
6345   echo "$as_me:$LINENO: result: $AR" >&5
6346 echo "${ECHO_T}$AR" >&6
6347 else
6348   echo "$as_me:$LINENO: result: no" >&5
6349 echo "${ECHO_T}no" >&6
6350 fi
6351
6352   done
6353 fi
6354
6355 for ncn_progname in ar; do
6356   if test -n "$ncn_tool_prefix"; then
6357     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6358 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6359 echo "$as_me:$LINENO: checking for $ac_word" >&5
6360 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6361 if test "${ac_cv_prog_AR+set}" = set; then
6362   echo $ECHO_N "(cached) $ECHO_C" >&6
6363 else
6364   if test -n "$AR"; then
6365   ac_cv_prog_AR="$AR" # Let the user override the test.
6366 else
6367 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6368 for as_dir in $PATH
6369 do
6370   IFS=$as_save_IFS
6371   test -z "$as_dir" && as_dir=.
6372   for ac_exec_ext in '' $ac_executable_extensions; do
6373   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6374     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6375     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6376     break 2
6377   fi
6378 done
6379 done
6380
6381 fi
6382 fi
6383 AR=$ac_cv_prog_AR
6384 if test -n "$AR"; then
6385   echo "$as_me:$LINENO: result: $AR" >&5
6386 echo "${ECHO_T}$AR" >&6
6387 else
6388   echo "$as_me:$LINENO: result: no" >&5
6389 echo "${ECHO_T}no" >&6
6390 fi
6391
6392   fi
6393   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6394     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6395 set dummy ${ncn_progname}; ac_word=$2
6396 echo "$as_me:$LINENO: checking for $ac_word" >&5
6397 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6398 if test "${ac_cv_prog_AR+set}" = set; then
6399   echo $ECHO_N "(cached) $ECHO_C" >&6
6400 else
6401   if test -n "$AR"; then
6402   ac_cv_prog_AR="$AR" # Let the user override the test.
6403 else
6404 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6405 for as_dir in $PATH
6406 do
6407   IFS=$as_save_IFS
6408   test -z "$as_dir" && as_dir=.
6409   for ac_exec_ext in '' $ac_executable_extensions; do
6410   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6411     ac_cv_prog_AR="${ncn_progname}"
6412     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6413     break 2
6414   fi
6415 done
6416 done
6417
6418 fi
6419 fi
6420 AR=$ac_cv_prog_AR
6421 if test -n "$AR"; then
6422   echo "$as_me:$LINENO: result: $AR" >&5
6423 echo "${ECHO_T}$AR" >&6
6424 else
6425   echo "$as_me:$LINENO: result: no" >&5
6426 echo "${ECHO_T}no" >&6
6427 fi
6428
6429   fi
6430   test -n "$ac_cv_prog_AR" && break
6431 done
6432
6433 if test -z "$ac_cv_prog_AR" ; then
6434   set dummy ar
6435   if test $build = $host ; then
6436     AR="$2"
6437   else
6438     AR="${ncn_tool_prefix}$2"
6439   fi
6440 fi
6441
6442
6443
6444 if test -n "$AS"; then
6445   ac_cv_prog_AS=$AS
6446 elif test -n "$ac_cv_prog_AS"; then
6447   AS=$ac_cv_prog_AS
6448 fi
6449
6450 if test -n "$ac_cv_prog_AS"; then
6451   for ncn_progname in as; do
6452     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6453 set dummy ${ncn_progname}; ac_word=$2
6454 echo "$as_me:$LINENO: checking for $ac_word" >&5
6455 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6456 if test "${ac_cv_prog_AS+set}" = set; then
6457   echo $ECHO_N "(cached) $ECHO_C" >&6
6458 else
6459   if test -n "$AS"; then
6460   ac_cv_prog_AS="$AS" # Let the user override the test.
6461 else
6462 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6463 for as_dir in $PATH
6464 do
6465   IFS=$as_save_IFS
6466   test -z "$as_dir" && as_dir=.
6467   for ac_exec_ext in '' $ac_executable_extensions; do
6468   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6469     ac_cv_prog_AS="${ncn_progname}"
6470     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6471     break 2
6472   fi
6473 done
6474 done
6475
6476 fi
6477 fi
6478 AS=$ac_cv_prog_AS
6479 if test -n "$AS"; then
6480   echo "$as_me:$LINENO: result: $AS" >&5
6481 echo "${ECHO_T}$AS" >&6
6482 else
6483   echo "$as_me:$LINENO: result: no" >&5
6484 echo "${ECHO_T}no" >&6
6485 fi
6486
6487   done
6488 fi
6489
6490 for ncn_progname in as; do
6491   if test -n "$ncn_tool_prefix"; then
6492     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6493 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6494 echo "$as_me:$LINENO: checking for $ac_word" >&5
6495 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6496 if test "${ac_cv_prog_AS+set}" = set; then
6497   echo $ECHO_N "(cached) $ECHO_C" >&6
6498 else
6499   if test -n "$AS"; then
6500   ac_cv_prog_AS="$AS" # Let the user override the test.
6501 else
6502 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6503 for as_dir in $PATH
6504 do
6505   IFS=$as_save_IFS
6506   test -z "$as_dir" && as_dir=.
6507   for ac_exec_ext in '' $ac_executable_extensions; do
6508   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6509     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6510     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6511     break 2
6512   fi
6513 done
6514 done
6515
6516 fi
6517 fi
6518 AS=$ac_cv_prog_AS
6519 if test -n "$AS"; then
6520   echo "$as_me:$LINENO: result: $AS" >&5
6521 echo "${ECHO_T}$AS" >&6
6522 else
6523   echo "$as_me:$LINENO: result: no" >&5
6524 echo "${ECHO_T}no" >&6
6525 fi
6526
6527   fi
6528   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6529     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6530 set dummy ${ncn_progname}; ac_word=$2
6531 echo "$as_me:$LINENO: checking for $ac_word" >&5
6532 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6533 if test "${ac_cv_prog_AS+set}" = set; then
6534   echo $ECHO_N "(cached) $ECHO_C" >&6
6535 else
6536   if test -n "$AS"; then
6537   ac_cv_prog_AS="$AS" # Let the user override the test.
6538 else
6539 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6540 for as_dir in $PATH
6541 do
6542   IFS=$as_save_IFS
6543   test -z "$as_dir" && as_dir=.
6544   for ac_exec_ext in '' $ac_executable_extensions; do
6545   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6546     ac_cv_prog_AS="${ncn_progname}"
6547     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6548     break 2
6549   fi
6550 done
6551 done
6552
6553 fi
6554 fi
6555 AS=$ac_cv_prog_AS
6556 if test -n "$AS"; then
6557   echo "$as_me:$LINENO: result: $AS" >&5
6558 echo "${ECHO_T}$AS" >&6
6559 else
6560   echo "$as_me:$LINENO: result: no" >&5
6561 echo "${ECHO_T}no" >&6
6562 fi
6563
6564   fi
6565   test -n "$ac_cv_prog_AS" && break
6566 done
6567
6568 if test -z "$ac_cv_prog_AS" ; then
6569   set dummy as
6570   if test $build = $host ; then
6571     AS="$2"
6572   else
6573     AS="${ncn_tool_prefix}$2"
6574   fi
6575 fi
6576
6577
6578
6579 if test -n "$DLLTOOL"; then
6580   ac_cv_prog_DLLTOOL=$DLLTOOL
6581 elif test -n "$ac_cv_prog_DLLTOOL"; then
6582   DLLTOOL=$ac_cv_prog_DLLTOOL
6583 fi
6584
6585 if test -n "$ac_cv_prog_DLLTOOL"; then
6586   for ncn_progname in dlltool; do
6587     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6588 set dummy ${ncn_progname}; ac_word=$2
6589 echo "$as_me:$LINENO: checking for $ac_word" >&5
6590 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6591 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6592   echo $ECHO_N "(cached) $ECHO_C" >&6
6593 else
6594   if test -n "$DLLTOOL"; then
6595   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6596 else
6597 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6598 for as_dir in $PATH
6599 do
6600   IFS=$as_save_IFS
6601   test -z "$as_dir" && as_dir=.
6602   for ac_exec_ext in '' $ac_executable_extensions; do
6603   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6604     ac_cv_prog_DLLTOOL="${ncn_progname}"
6605     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6606     break 2
6607   fi
6608 done
6609 done
6610
6611 fi
6612 fi
6613 DLLTOOL=$ac_cv_prog_DLLTOOL
6614 if test -n "$DLLTOOL"; then
6615   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6616 echo "${ECHO_T}$DLLTOOL" >&6
6617 else
6618   echo "$as_me:$LINENO: result: no" >&5
6619 echo "${ECHO_T}no" >&6
6620 fi
6621
6622   done
6623 fi
6624
6625 for ncn_progname in dlltool; do
6626   if test -n "$ncn_tool_prefix"; then
6627     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6628 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6629 echo "$as_me:$LINENO: checking for $ac_word" >&5
6630 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6631 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6632   echo $ECHO_N "(cached) $ECHO_C" >&6
6633 else
6634   if test -n "$DLLTOOL"; then
6635   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6636 else
6637 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6638 for as_dir in $PATH
6639 do
6640   IFS=$as_save_IFS
6641   test -z "$as_dir" && as_dir=.
6642   for ac_exec_ext in '' $ac_executable_extensions; do
6643   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6644     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6645     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6646     break 2
6647   fi
6648 done
6649 done
6650
6651 fi
6652 fi
6653 DLLTOOL=$ac_cv_prog_DLLTOOL
6654 if test -n "$DLLTOOL"; then
6655   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6656 echo "${ECHO_T}$DLLTOOL" >&6
6657 else
6658   echo "$as_me:$LINENO: result: no" >&5
6659 echo "${ECHO_T}no" >&6
6660 fi
6661
6662   fi
6663   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6664     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6665 set dummy ${ncn_progname}; ac_word=$2
6666 echo "$as_me:$LINENO: checking for $ac_word" >&5
6667 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6668 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6669   echo $ECHO_N "(cached) $ECHO_C" >&6
6670 else
6671   if test -n "$DLLTOOL"; then
6672   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6673 else
6674 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6675 for as_dir in $PATH
6676 do
6677   IFS=$as_save_IFS
6678   test -z "$as_dir" && as_dir=.
6679   for ac_exec_ext in '' $ac_executable_extensions; do
6680   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6681     ac_cv_prog_DLLTOOL="${ncn_progname}"
6682     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6683     break 2
6684   fi
6685 done
6686 done
6687
6688 fi
6689 fi
6690 DLLTOOL=$ac_cv_prog_DLLTOOL
6691 if test -n "$DLLTOOL"; then
6692   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6693 echo "${ECHO_T}$DLLTOOL" >&6
6694 else
6695   echo "$as_me:$LINENO: result: no" >&5
6696 echo "${ECHO_T}no" >&6
6697 fi
6698
6699   fi
6700   test -n "$ac_cv_prog_DLLTOOL" && break
6701 done
6702
6703 if test -z "$ac_cv_prog_DLLTOOL" ; then
6704   set dummy dlltool
6705   if test $build = $host ; then
6706     DLLTOOL="$2"
6707   else
6708     DLLTOOL="${ncn_tool_prefix}$2"
6709   fi
6710 fi
6711
6712
6713
6714 if test -n "$LD"; then
6715   ac_cv_prog_LD=$LD
6716 elif test -n "$ac_cv_prog_LD"; then
6717   LD=$ac_cv_prog_LD
6718 fi
6719
6720 if test -n "$ac_cv_prog_LD"; then
6721   for ncn_progname in ld; do
6722     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6723 set dummy ${ncn_progname}; ac_word=$2
6724 echo "$as_me:$LINENO: checking for $ac_word" >&5
6725 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6726 if test "${ac_cv_prog_LD+set}" = set; then
6727   echo $ECHO_N "(cached) $ECHO_C" >&6
6728 else
6729   if test -n "$LD"; then
6730   ac_cv_prog_LD="$LD" # Let the user override the test.
6731 else
6732 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6733 for as_dir in $PATH
6734 do
6735   IFS=$as_save_IFS
6736   test -z "$as_dir" && as_dir=.
6737   for ac_exec_ext in '' $ac_executable_extensions; do
6738   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6739     ac_cv_prog_LD="${ncn_progname}"
6740     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6741     break 2
6742   fi
6743 done
6744 done
6745
6746 fi
6747 fi
6748 LD=$ac_cv_prog_LD
6749 if test -n "$LD"; then
6750   echo "$as_me:$LINENO: result: $LD" >&5
6751 echo "${ECHO_T}$LD" >&6
6752 else
6753   echo "$as_me:$LINENO: result: no" >&5
6754 echo "${ECHO_T}no" >&6
6755 fi
6756
6757   done
6758 fi
6759
6760 for ncn_progname in ld; do
6761   if test -n "$ncn_tool_prefix"; then
6762     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6763 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6764 echo "$as_me:$LINENO: checking for $ac_word" >&5
6765 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6766 if test "${ac_cv_prog_LD+set}" = set; then
6767   echo $ECHO_N "(cached) $ECHO_C" >&6
6768 else
6769   if test -n "$LD"; then
6770   ac_cv_prog_LD="$LD" # Let the user override the test.
6771 else
6772 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6773 for as_dir in $PATH
6774 do
6775   IFS=$as_save_IFS
6776   test -z "$as_dir" && as_dir=.
6777   for ac_exec_ext in '' $ac_executable_extensions; do
6778   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6779     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6780     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6781     break 2
6782   fi
6783 done
6784 done
6785
6786 fi
6787 fi
6788 LD=$ac_cv_prog_LD
6789 if test -n "$LD"; then
6790   echo "$as_me:$LINENO: result: $LD" >&5
6791 echo "${ECHO_T}$LD" >&6
6792 else
6793   echo "$as_me:$LINENO: result: no" >&5
6794 echo "${ECHO_T}no" >&6
6795 fi
6796
6797   fi
6798   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6799     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6800 set dummy ${ncn_progname}; ac_word=$2
6801 echo "$as_me:$LINENO: checking for $ac_word" >&5
6802 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6803 if test "${ac_cv_prog_LD+set}" = set; then
6804   echo $ECHO_N "(cached) $ECHO_C" >&6
6805 else
6806   if test -n "$LD"; then
6807   ac_cv_prog_LD="$LD" # Let the user override the test.
6808 else
6809 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6810 for as_dir in $PATH
6811 do
6812   IFS=$as_save_IFS
6813   test -z "$as_dir" && as_dir=.
6814   for ac_exec_ext in '' $ac_executable_extensions; do
6815   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6816     ac_cv_prog_LD="${ncn_progname}"
6817     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6818     break 2
6819   fi
6820 done
6821 done
6822
6823 fi
6824 fi
6825 LD=$ac_cv_prog_LD
6826 if test -n "$LD"; then
6827   echo "$as_me:$LINENO: result: $LD" >&5
6828 echo "${ECHO_T}$LD" >&6
6829 else
6830   echo "$as_me:$LINENO: result: no" >&5
6831 echo "${ECHO_T}no" >&6
6832 fi
6833
6834   fi
6835   test -n "$ac_cv_prog_LD" && break
6836 done
6837
6838 if test -z "$ac_cv_prog_LD" ; then
6839   set dummy ld
6840   if test $build = $host ; then
6841     LD="$2"
6842   else
6843     LD="${ncn_tool_prefix}$2"
6844   fi
6845 fi
6846
6847
6848
6849 if test -n "$LIPO"; then
6850   ac_cv_prog_LIPO=$LIPO
6851 elif test -n "$ac_cv_prog_LIPO"; then
6852   LIPO=$ac_cv_prog_LIPO
6853 fi
6854
6855 if test -n "$ac_cv_prog_LIPO"; then
6856   for ncn_progname in lipo; do
6857     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6858 set dummy ${ncn_progname}; ac_word=$2
6859 echo "$as_me:$LINENO: checking for $ac_word" >&5
6860 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6861 if test "${ac_cv_prog_LIPO+set}" = set; then
6862   echo $ECHO_N "(cached) $ECHO_C" >&6
6863 else
6864   if test -n "$LIPO"; then
6865   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6866 else
6867 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6868 for as_dir in $PATH
6869 do
6870   IFS=$as_save_IFS
6871   test -z "$as_dir" && as_dir=.
6872   for ac_exec_ext in '' $ac_executable_extensions; do
6873   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6874     ac_cv_prog_LIPO="${ncn_progname}"
6875     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6876     break 2
6877   fi
6878 done
6879 done
6880
6881 fi
6882 fi
6883 LIPO=$ac_cv_prog_LIPO
6884 if test -n "$LIPO"; then
6885   echo "$as_me:$LINENO: result: $LIPO" >&5
6886 echo "${ECHO_T}$LIPO" >&6
6887 else
6888   echo "$as_me:$LINENO: result: no" >&5
6889 echo "${ECHO_T}no" >&6
6890 fi
6891
6892   done
6893 fi
6894
6895 for ncn_progname in lipo; do
6896   if test -n "$ncn_tool_prefix"; then
6897     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6898 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6899 echo "$as_me:$LINENO: checking for $ac_word" >&5
6900 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6901 if test "${ac_cv_prog_LIPO+set}" = set; then
6902   echo $ECHO_N "(cached) $ECHO_C" >&6
6903 else
6904   if test -n "$LIPO"; then
6905   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6906 else
6907 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6908 for as_dir in $PATH
6909 do
6910   IFS=$as_save_IFS
6911   test -z "$as_dir" && as_dir=.
6912   for ac_exec_ext in '' $ac_executable_extensions; do
6913   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6914     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6915     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6916     break 2
6917   fi
6918 done
6919 done
6920
6921 fi
6922 fi
6923 LIPO=$ac_cv_prog_LIPO
6924 if test -n "$LIPO"; then
6925   echo "$as_me:$LINENO: result: $LIPO" >&5
6926 echo "${ECHO_T}$LIPO" >&6
6927 else
6928   echo "$as_me:$LINENO: result: no" >&5
6929 echo "${ECHO_T}no" >&6
6930 fi
6931
6932   fi
6933   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
6934     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6935 set dummy ${ncn_progname}; ac_word=$2
6936 echo "$as_me:$LINENO: checking for $ac_word" >&5
6937 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6938 if test "${ac_cv_prog_LIPO+set}" = set; then
6939   echo $ECHO_N "(cached) $ECHO_C" >&6
6940 else
6941   if test -n "$LIPO"; then
6942   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6943 else
6944 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6945 for as_dir in $PATH
6946 do
6947   IFS=$as_save_IFS
6948   test -z "$as_dir" && as_dir=.
6949   for ac_exec_ext in '' $ac_executable_extensions; do
6950   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6951     ac_cv_prog_LIPO="${ncn_progname}"
6952     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6953     break 2
6954   fi
6955 done
6956 done
6957
6958 fi
6959 fi
6960 LIPO=$ac_cv_prog_LIPO
6961 if test -n "$LIPO"; then
6962   echo "$as_me:$LINENO: result: $LIPO" >&5
6963 echo "${ECHO_T}$LIPO" >&6
6964 else
6965   echo "$as_me:$LINENO: result: no" >&5
6966 echo "${ECHO_T}no" >&6
6967 fi
6968
6969   fi
6970   test -n "$ac_cv_prog_LIPO" && break
6971 done
6972
6973 if test -z "$ac_cv_prog_LIPO" ; then
6974   set dummy lipo
6975   if test $build = $host ; then
6976     LIPO="$2"
6977   else
6978     LIPO="${ncn_tool_prefix}$2"
6979   fi
6980 fi
6981
6982
6983
6984 if test -n "$NM"; then
6985   ac_cv_prog_NM=$NM
6986 elif test -n "$ac_cv_prog_NM"; then
6987   NM=$ac_cv_prog_NM
6988 fi
6989
6990 if test -n "$ac_cv_prog_NM"; then
6991   for ncn_progname in nm; do
6992     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6993 set dummy ${ncn_progname}; ac_word=$2
6994 echo "$as_me:$LINENO: checking for $ac_word" >&5
6995 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6996 if test "${ac_cv_prog_NM+set}" = set; then
6997   echo $ECHO_N "(cached) $ECHO_C" >&6
6998 else
6999   if test -n "$NM"; then
7000   ac_cv_prog_NM="$NM" # Let the user override the test.
7001 else
7002 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7003 for as_dir in $PATH
7004 do
7005   IFS=$as_save_IFS
7006   test -z "$as_dir" && as_dir=.
7007   for ac_exec_ext in '' $ac_executable_extensions; do
7008   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7009     ac_cv_prog_NM="${ncn_progname}"
7010     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7011     break 2
7012   fi
7013 done
7014 done
7015
7016 fi
7017 fi
7018 NM=$ac_cv_prog_NM
7019 if test -n "$NM"; then
7020   echo "$as_me:$LINENO: result: $NM" >&5
7021 echo "${ECHO_T}$NM" >&6
7022 else
7023   echo "$as_me:$LINENO: result: no" >&5
7024 echo "${ECHO_T}no" >&6
7025 fi
7026
7027   done
7028 fi
7029
7030 for ncn_progname in nm; do
7031   if test -n "$ncn_tool_prefix"; then
7032     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7033 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7034 echo "$as_me:$LINENO: checking for $ac_word" >&5
7035 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7036 if test "${ac_cv_prog_NM+set}" = set; then
7037   echo $ECHO_N "(cached) $ECHO_C" >&6
7038 else
7039   if test -n "$NM"; then
7040   ac_cv_prog_NM="$NM" # Let the user override the test.
7041 else
7042 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7043 for as_dir in $PATH
7044 do
7045   IFS=$as_save_IFS
7046   test -z "$as_dir" && as_dir=.
7047   for ac_exec_ext in '' $ac_executable_extensions; do
7048   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7049     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7050     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7051     break 2
7052   fi
7053 done
7054 done
7055
7056 fi
7057 fi
7058 NM=$ac_cv_prog_NM
7059 if test -n "$NM"; then
7060   echo "$as_me:$LINENO: result: $NM" >&5
7061 echo "${ECHO_T}$NM" >&6
7062 else
7063   echo "$as_me:$LINENO: result: no" >&5
7064 echo "${ECHO_T}no" >&6
7065 fi
7066
7067   fi
7068   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7069     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7070 set dummy ${ncn_progname}; ac_word=$2
7071 echo "$as_me:$LINENO: checking for $ac_word" >&5
7072 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7073 if test "${ac_cv_prog_NM+set}" = set; then
7074   echo $ECHO_N "(cached) $ECHO_C" >&6
7075 else
7076   if test -n "$NM"; then
7077   ac_cv_prog_NM="$NM" # Let the user override the test.
7078 else
7079 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7080 for as_dir in $PATH
7081 do
7082   IFS=$as_save_IFS
7083   test -z "$as_dir" && as_dir=.
7084   for ac_exec_ext in '' $ac_executable_extensions; do
7085   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7086     ac_cv_prog_NM="${ncn_progname}"
7087     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7088     break 2
7089   fi
7090 done
7091 done
7092
7093 fi
7094 fi
7095 NM=$ac_cv_prog_NM
7096 if test -n "$NM"; then
7097   echo "$as_me:$LINENO: result: $NM" >&5
7098 echo "${ECHO_T}$NM" >&6
7099 else
7100   echo "$as_me:$LINENO: result: no" >&5
7101 echo "${ECHO_T}no" >&6
7102 fi
7103
7104   fi
7105   test -n "$ac_cv_prog_NM" && break
7106 done
7107
7108 if test -z "$ac_cv_prog_NM" ; then
7109   set dummy nm
7110   if test $build = $host ; then
7111     NM="$2"
7112   else
7113     NM="${ncn_tool_prefix}$2"
7114   fi
7115 fi
7116
7117
7118
7119 if test -n "$RANLIB"; then
7120   ac_cv_prog_RANLIB=$RANLIB
7121 elif test -n "$ac_cv_prog_RANLIB"; then
7122   RANLIB=$ac_cv_prog_RANLIB
7123 fi
7124
7125 if test -n "$ac_cv_prog_RANLIB"; then
7126   for ncn_progname in ranlib; do
7127     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7128 set dummy ${ncn_progname}; ac_word=$2
7129 echo "$as_me:$LINENO: checking for $ac_word" >&5
7130 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7131 if test "${ac_cv_prog_RANLIB+set}" = set; then
7132   echo $ECHO_N "(cached) $ECHO_C" >&6
7133 else
7134   if test -n "$RANLIB"; then
7135   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7136 else
7137 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7138 for as_dir in $PATH
7139 do
7140   IFS=$as_save_IFS
7141   test -z "$as_dir" && as_dir=.
7142   for ac_exec_ext in '' $ac_executable_extensions; do
7143   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7144     ac_cv_prog_RANLIB="${ncn_progname}"
7145     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7146     break 2
7147   fi
7148 done
7149 done
7150
7151 fi
7152 fi
7153 RANLIB=$ac_cv_prog_RANLIB
7154 if test -n "$RANLIB"; then
7155   echo "$as_me:$LINENO: result: $RANLIB" >&5
7156 echo "${ECHO_T}$RANLIB" >&6
7157 else
7158   echo "$as_me:$LINENO: result: no" >&5
7159 echo "${ECHO_T}no" >&6
7160 fi
7161
7162   done
7163 fi
7164
7165 for ncn_progname in ranlib; do
7166   if test -n "$ncn_tool_prefix"; then
7167     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7168 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7169 echo "$as_me:$LINENO: checking for $ac_word" >&5
7170 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7171 if test "${ac_cv_prog_RANLIB+set}" = set; then
7172   echo $ECHO_N "(cached) $ECHO_C" >&6
7173 else
7174   if test -n "$RANLIB"; then
7175   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7176 else
7177 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7178 for as_dir in $PATH
7179 do
7180   IFS=$as_save_IFS
7181   test -z "$as_dir" && as_dir=.
7182   for ac_exec_ext in '' $ac_executable_extensions; do
7183   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7184     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7185     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7186     break 2
7187   fi
7188 done
7189 done
7190
7191 fi
7192 fi
7193 RANLIB=$ac_cv_prog_RANLIB
7194 if test -n "$RANLIB"; then
7195   echo "$as_me:$LINENO: result: $RANLIB" >&5
7196 echo "${ECHO_T}$RANLIB" >&6
7197 else
7198   echo "$as_me:$LINENO: result: no" >&5
7199 echo "${ECHO_T}no" >&6
7200 fi
7201
7202   fi
7203   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7204     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7205 set dummy ${ncn_progname}; ac_word=$2
7206 echo "$as_me:$LINENO: checking for $ac_word" >&5
7207 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7208 if test "${ac_cv_prog_RANLIB+set}" = set; then
7209   echo $ECHO_N "(cached) $ECHO_C" >&6
7210 else
7211   if test -n "$RANLIB"; then
7212   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7213 else
7214 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7215 for as_dir in $PATH
7216 do
7217   IFS=$as_save_IFS
7218   test -z "$as_dir" && as_dir=.
7219   for ac_exec_ext in '' $ac_executable_extensions; do
7220   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7221     ac_cv_prog_RANLIB="${ncn_progname}"
7222     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7223     break 2
7224   fi
7225 done
7226 done
7227
7228 fi
7229 fi
7230 RANLIB=$ac_cv_prog_RANLIB
7231 if test -n "$RANLIB"; then
7232   echo "$as_me:$LINENO: result: $RANLIB" >&5
7233 echo "${ECHO_T}$RANLIB" >&6
7234 else
7235   echo "$as_me:$LINENO: result: no" >&5
7236 echo "${ECHO_T}no" >&6
7237 fi
7238
7239   fi
7240   test -n "$ac_cv_prog_RANLIB" && break
7241 done
7242
7243 if test -z "$ac_cv_prog_RANLIB" ; then
7244   RANLIB=":"
7245 fi
7246
7247
7248
7249 if test -n "$STRIP"; then
7250   ac_cv_prog_STRIP=$STRIP
7251 elif test -n "$ac_cv_prog_STRIP"; then
7252   STRIP=$ac_cv_prog_STRIP
7253 fi
7254
7255 if test -n "$ac_cv_prog_STRIP"; then
7256   for ncn_progname in strip; do
7257     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7258 set dummy ${ncn_progname}; ac_word=$2
7259 echo "$as_me:$LINENO: checking for $ac_word" >&5
7260 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7261 if test "${ac_cv_prog_STRIP+set}" = set; then
7262   echo $ECHO_N "(cached) $ECHO_C" >&6
7263 else
7264   if test -n "$STRIP"; then
7265   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7266 else
7267 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7268 for as_dir in $PATH
7269 do
7270   IFS=$as_save_IFS
7271   test -z "$as_dir" && as_dir=.
7272   for ac_exec_ext in '' $ac_executable_extensions; do
7273   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7274     ac_cv_prog_STRIP="${ncn_progname}"
7275     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7276     break 2
7277   fi
7278 done
7279 done
7280
7281 fi
7282 fi
7283 STRIP=$ac_cv_prog_STRIP
7284 if test -n "$STRIP"; then
7285   echo "$as_me:$LINENO: result: $STRIP" >&5
7286 echo "${ECHO_T}$STRIP" >&6
7287 else
7288   echo "$as_me:$LINENO: result: no" >&5
7289 echo "${ECHO_T}no" >&6
7290 fi
7291
7292   done
7293 fi
7294
7295 for ncn_progname in strip; do
7296   if test -n "$ncn_tool_prefix"; then
7297     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7298 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7299 echo "$as_me:$LINENO: checking for $ac_word" >&5
7300 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7301 if test "${ac_cv_prog_STRIP+set}" = set; then
7302   echo $ECHO_N "(cached) $ECHO_C" >&6
7303 else
7304   if test -n "$STRIP"; then
7305   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7306 else
7307 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7308 for as_dir in $PATH
7309 do
7310   IFS=$as_save_IFS
7311   test -z "$as_dir" && as_dir=.
7312   for ac_exec_ext in '' $ac_executable_extensions; do
7313   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7314     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7315     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7316     break 2
7317   fi
7318 done
7319 done
7320
7321 fi
7322 fi
7323 STRIP=$ac_cv_prog_STRIP
7324 if test -n "$STRIP"; then
7325   echo "$as_me:$LINENO: result: $STRIP" >&5
7326 echo "${ECHO_T}$STRIP" >&6
7327 else
7328   echo "$as_me:$LINENO: result: no" >&5
7329 echo "${ECHO_T}no" >&6
7330 fi
7331
7332   fi
7333   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7334     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7335 set dummy ${ncn_progname}; ac_word=$2
7336 echo "$as_me:$LINENO: checking for $ac_word" >&5
7337 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7338 if test "${ac_cv_prog_STRIP+set}" = set; then
7339   echo $ECHO_N "(cached) $ECHO_C" >&6
7340 else
7341   if test -n "$STRIP"; then
7342   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7343 else
7344 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7345 for as_dir in $PATH
7346 do
7347   IFS=$as_save_IFS
7348   test -z "$as_dir" && as_dir=.
7349   for ac_exec_ext in '' $ac_executable_extensions; do
7350   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7351     ac_cv_prog_STRIP="${ncn_progname}"
7352     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7353     break 2
7354   fi
7355 done
7356 done
7357
7358 fi
7359 fi
7360 STRIP=$ac_cv_prog_STRIP
7361 if test -n "$STRIP"; then
7362   echo "$as_me:$LINENO: result: $STRIP" >&5
7363 echo "${ECHO_T}$STRIP" >&6
7364 else
7365   echo "$as_me:$LINENO: result: no" >&5
7366 echo "${ECHO_T}no" >&6
7367 fi
7368
7369   fi
7370   test -n "$ac_cv_prog_STRIP" && break
7371 done
7372
7373 if test -z "$ac_cv_prog_STRIP" ; then
7374   STRIP=":"
7375 fi
7376
7377
7378
7379 if test -n "$WINDRES"; then
7380   ac_cv_prog_WINDRES=$WINDRES
7381 elif test -n "$ac_cv_prog_WINDRES"; then
7382   WINDRES=$ac_cv_prog_WINDRES
7383 fi
7384
7385 if test -n "$ac_cv_prog_WINDRES"; then
7386   for ncn_progname in windres; do
7387     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7388 set dummy ${ncn_progname}; ac_word=$2
7389 echo "$as_me:$LINENO: checking for $ac_word" >&5
7390 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7391 if test "${ac_cv_prog_WINDRES+set}" = set; then
7392   echo $ECHO_N "(cached) $ECHO_C" >&6
7393 else
7394   if test -n "$WINDRES"; then
7395   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7396 else
7397 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7398 for as_dir in $PATH
7399 do
7400   IFS=$as_save_IFS
7401   test -z "$as_dir" && as_dir=.
7402   for ac_exec_ext in '' $ac_executable_extensions; do
7403   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7404     ac_cv_prog_WINDRES="${ncn_progname}"
7405     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7406     break 2
7407   fi
7408 done
7409 done
7410
7411 fi
7412 fi
7413 WINDRES=$ac_cv_prog_WINDRES
7414 if test -n "$WINDRES"; then
7415   echo "$as_me:$LINENO: result: $WINDRES" >&5
7416 echo "${ECHO_T}$WINDRES" >&6
7417 else
7418   echo "$as_me:$LINENO: result: no" >&5
7419 echo "${ECHO_T}no" >&6
7420 fi
7421
7422   done
7423 fi
7424
7425 for ncn_progname in windres; do
7426   if test -n "$ncn_tool_prefix"; then
7427     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7428 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7429 echo "$as_me:$LINENO: checking for $ac_word" >&5
7430 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7431 if test "${ac_cv_prog_WINDRES+set}" = set; then
7432   echo $ECHO_N "(cached) $ECHO_C" >&6
7433 else
7434   if test -n "$WINDRES"; then
7435   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7436 else
7437 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7438 for as_dir in $PATH
7439 do
7440   IFS=$as_save_IFS
7441   test -z "$as_dir" && as_dir=.
7442   for ac_exec_ext in '' $ac_executable_extensions; do
7443   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7444     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7445     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7446     break 2
7447   fi
7448 done
7449 done
7450
7451 fi
7452 fi
7453 WINDRES=$ac_cv_prog_WINDRES
7454 if test -n "$WINDRES"; then
7455   echo "$as_me:$LINENO: result: $WINDRES" >&5
7456 echo "${ECHO_T}$WINDRES" >&6
7457 else
7458   echo "$as_me:$LINENO: result: no" >&5
7459 echo "${ECHO_T}no" >&6
7460 fi
7461
7462   fi
7463   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7464     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7465 set dummy ${ncn_progname}; ac_word=$2
7466 echo "$as_me:$LINENO: checking for $ac_word" >&5
7467 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7468 if test "${ac_cv_prog_WINDRES+set}" = set; then
7469   echo $ECHO_N "(cached) $ECHO_C" >&6
7470 else
7471   if test -n "$WINDRES"; then
7472   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7473 else
7474 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7475 for as_dir in $PATH
7476 do
7477   IFS=$as_save_IFS
7478   test -z "$as_dir" && as_dir=.
7479   for ac_exec_ext in '' $ac_executable_extensions; do
7480   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7481     ac_cv_prog_WINDRES="${ncn_progname}"
7482     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7483     break 2
7484   fi
7485 done
7486 done
7487
7488 fi
7489 fi
7490 WINDRES=$ac_cv_prog_WINDRES
7491 if test -n "$WINDRES"; then
7492   echo "$as_me:$LINENO: result: $WINDRES" >&5
7493 echo "${ECHO_T}$WINDRES" >&6
7494 else
7495   echo "$as_me:$LINENO: result: no" >&5
7496 echo "${ECHO_T}no" >&6
7497 fi
7498
7499   fi
7500   test -n "$ac_cv_prog_WINDRES" && break
7501 done
7502
7503 if test -z "$ac_cv_prog_WINDRES" ; then
7504   set dummy windres
7505   if test $build = $host ; then
7506     WINDRES="$2"
7507   else
7508     WINDRES="${ncn_tool_prefix}$2"
7509   fi
7510 fi
7511
7512
7513
7514 if test -n "$WINDMC"; then
7515   ac_cv_prog_WINDMC=$WINDMC
7516 elif test -n "$ac_cv_prog_WINDMC"; then
7517   WINDMC=$ac_cv_prog_WINDMC
7518 fi
7519
7520 if test -n "$ac_cv_prog_WINDMC"; then
7521   for ncn_progname in windmc; do
7522     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7523 set dummy ${ncn_progname}; ac_word=$2
7524 echo "$as_me:$LINENO: checking for $ac_word" >&5
7525 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7526 if test "${ac_cv_prog_WINDMC+set}" = set; then
7527   echo $ECHO_N "(cached) $ECHO_C" >&6
7528 else
7529   if test -n "$WINDMC"; then
7530   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7531 else
7532 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7533 for as_dir in $PATH
7534 do
7535   IFS=$as_save_IFS
7536   test -z "$as_dir" && as_dir=.
7537   for ac_exec_ext in '' $ac_executable_extensions; do
7538   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7539     ac_cv_prog_WINDMC="${ncn_progname}"
7540     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7541     break 2
7542   fi
7543 done
7544 done
7545
7546 fi
7547 fi
7548 WINDMC=$ac_cv_prog_WINDMC
7549 if test -n "$WINDMC"; then
7550   echo "$as_me:$LINENO: result: $WINDMC" >&5
7551 echo "${ECHO_T}$WINDMC" >&6
7552 else
7553   echo "$as_me:$LINENO: result: no" >&5
7554 echo "${ECHO_T}no" >&6
7555 fi
7556
7557   done
7558 fi
7559
7560 for ncn_progname in windmc; do
7561   if test -n "$ncn_tool_prefix"; then
7562     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7563 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7564 echo "$as_me:$LINENO: checking for $ac_word" >&5
7565 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7566 if test "${ac_cv_prog_WINDMC+set}" = set; then
7567   echo $ECHO_N "(cached) $ECHO_C" >&6
7568 else
7569   if test -n "$WINDMC"; then
7570   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7571 else
7572 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7573 for as_dir in $PATH
7574 do
7575   IFS=$as_save_IFS
7576   test -z "$as_dir" && as_dir=.
7577   for ac_exec_ext in '' $ac_executable_extensions; do
7578   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7579     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7580     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7581     break 2
7582   fi
7583 done
7584 done
7585
7586 fi
7587 fi
7588 WINDMC=$ac_cv_prog_WINDMC
7589 if test -n "$WINDMC"; then
7590   echo "$as_me:$LINENO: result: $WINDMC" >&5
7591 echo "${ECHO_T}$WINDMC" >&6
7592 else
7593   echo "$as_me:$LINENO: result: no" >&5
7594 echo "${ECHO_T}no" >&6
7595 fi
7596
7597   fi
7598   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7599     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7600 set dummy ${ncn_progname}; ac_word=$2
7601 echo "$as_me:$LINENO: checking for $ac_word" >&5
7602 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7603 if test "${ac_cv_prog_WINDMC+set}" = set; then
7604   echo $ECHO_N "(cached) $ECHO_C" >&6
7605 else
7606   if test -n "$WINDMC"; then
7607   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7608 else
7609 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7610 for as_dir in $PATH
7611 do
7612   IFS=$as_save_IFS
7613   test -z "$as_dir" && as_dir=.
7614   for ac_exec_ext in '' $ac_executable_extensions; do
7615   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7616     ac_cv_prog_WINDMC="${ncn_progname}"
7617     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7618     break 2
7619   fi
7620 done
7621 done
7622
7623 fi
7624 fi
7625 WINDMC=$ac_cv_prog_WINDMC
7626 if test -n "$WINDMC"; then
7627   echo "$as_me:$LINENO: result: $WINDMC" >&5
7628 echo "${ECHO_T}$WINDMC" >&6
7629 else
7630   echo "$as_me:$LINENO: result: no" >&5
7631 echo "${ECHO_T}no" >&6
7632 fi
7633
7634   fi
7635   test -n "$ac_cv_prog_WINDMC" && break
7636 done
7637
7638 if test -z "$ac_cv_prog_WINDMC" ; then
7639   set dummy windmc
7640   if test $build = $host ; then
7641     WINDMC="$2"
7642   else
7643     WINDMC="${ncn_tool_prefix}$2"
7644   fi
7645 fi
7646
7647
7648
7649 if test -n "$OBJCOPY"; then
7650   ac_cv_prog_OBJCOPY=$OBJCOPY
7651 elif test -n "$ac_cv_prog_OBJCOPY"; then
7652   OBJCOPY=$ac_cv_prog_OBJCOPY
7653 fi
7654
7655 if test -n "$ac_cv_prog_OBJCOPY"; then
7656   for ncn_progname in objcopy; do
7657     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7658 set dummy ${ncn_progname}; ac_word=$2
7659 echo "$as_me:$LINENO: checking for $ac_word" >&5
7660 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7661 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7662   echo $ECHO_N "(cached) $ECHO_C" >&6
7663 else
7664   if test -n "$OBJCOPY"; then
7665   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7666 else
7667 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7668 for as_dir in $PATH
7669 do
7670   IFS=$as_save_IFS
7671   test -z "$as_dir" && as_dir=.
7672   for ac_exec_ext in '' $ac_executable_extensions; do
7673   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7674     ac_cv_prog_OBJCOPY="${ncn_progname}"
7675     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7676     break 2
7677   fi
7678 done
7679 done
7680
7681 fi
7682 fi
7683 OBJCOPY=$ac_cv_prog_OBJCOPY
7684 if test -n "$OBJCOPY"; then
7685   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7686 echo "${ECHO_T}$OBJCOPY" >&6
7687 else
7688   echo "$as_me:$LINENO: result: no" >&5
7689 echo "${ECHO_T}no" >&6
7690 fi
7691
7692   done
7693 fi
7694
7695 for ncn_progname in objcopy; do
7696   if test -n "$ncn_tool_prefix"; then
7697     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7698 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7699 echo "$as_me:$LINENO: checking for $ac_word" >&5
7700 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7701 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7702   echo $ECHO_N "(cached) $ECHO_C" >&6
7703 else
7704   if test -n "$OBJCOPY"; then
7705   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7706 else
7707 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7708 for as_dir in $PATH
7709 do
7710   IFS=$as_save_IFS
7711   test -z "$as_dir" && as_dir=.
7712   for ac_exec_ext in '' $ac_executable_extensions; do
7713   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7714     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7715     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7716     break 2
7717   fi
7718 done
7719 done
7720
7721 fi
7722 fi
7723 OBJCOPY=$ac_cv_prog_OBJCOPY
7724 if test -n "$OBJCOPY"; then
7725   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7726 echo "${ECHO_T}$OBJCOPY" >&6
7727 else
7728   echo "$as_me:$LINENO: result: no" >&5
7729 echo "${ECHO_T}no" >&6
7730 fi
7731
7732   fi
7733   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7734     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7735 set dummy ${ncn_progname}; ac_word=$2
7736 echo "$as_me:$LINENO: checking for $ac_word" >&5
7737 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7738 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7739   echo $ECHO_N "(cached) $ECHO_C" >&6
7740 else
7741   if test -n "$OBJCOPY"; then
7742   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7743 else
7744 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7745 for as_dir in $PATH
7746 do
7747   IFS=$as_save_IFS
7748   test -z "$as_dir" && as_dir=.
7749   for ac_exec_ext in '' $ac_executable_extensions; do
7750   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7751     ac_cv_prog_OBJCOPY="${ncn_progname}"
7752     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7753     break 2
7754   fi
7755 done
7756 done
7757
7758 fi
7759 fi
7760 OBJCOPY=$ac_cv_prog_OBJCOPY
7761 if test -n "$OBJCOPY"; then
7762   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7763 echo "${ECHO_T}$OBJCOPY" >&6
7764 else
7765   echo "$as_me:$LINENO: result: no" >&5
7766 echo "${ECHO_T}no" >&6
7767 fi
7768
7769   fi
7770   test -n "$ac_cv_prog_OBJCOPY" && break
7771 done
7772
7773 if test -z "$ac_cv_prog_OBJCOPY" ; then
7774   set dummy objcopy
7775   if test $build = $host ; then
7776     OBJCOPY="$2"
7777   else
7778     OBJCOPY="${ncn_tool_prefix}$2"
7779   fi
7780 fi
7781
7782
7783
7784 if test -n "$OBJDUMP"; then
7785   ac_cv_prog_OBJDUMP=$OBJDUMP
7786 elif test -n "$ac_cv_prog_OBJDUMP"; then
7787   OBJDUMP=$ac_cv_prog_OBJDUMP
7788 fi
7789
7790 if test -n "$ac_cv_prog_OBJDUMP"; then
7791   for ncn_progname in objdump; do
7792     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7793 set dummy ${ncn_progname}; ac_word=$2
7794 echo "$as_me:$LINENO: checking for $ac_word" >&5
7795 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7796 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7797   echo $ECHO_N "(cached) $ECHO_C" >&6
7798 else
7799   if test -n "$OBJDUMP"; then
7800   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7801 else
7802 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7803 for as_dir in $PATH
7804 do
7805   IFS=$as_save_IFS
7806   test -z "$as_dir" && as_dir=.
7807   for ac_exec_ext in '' $ac_executable_extensions; do
7808   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7809     ac_cv_prog_OBJDUMP="${ncn_progname}"
7810     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7811     break 2
7812   fi
7813 done
7814 done
7815
7816 fi
7817 fi
7818 OBJDUMP=$ac_cv_prog_OBJDUMP
7819 if test -n "$OBJDUMP"; then
7820   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7821 echo "${ECHO_T}$OBJDUMP" >&6
7822 else
7823   echo "$as_me:$LINENO: result: no" >&5
7824 echo "${ECHO_T}no" >&6
7825 fi
7826
7827   done
7828 fi
7829
7830 for ncn_progname in objdump; do
7831   if test -n "$ncn_tool_prefix"; then
7832     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7833 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7834 echo "$as_me:$LINENO: checking for $ac_word" >&5
7835 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7836 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7837   echo $ECHO_N "(cached) $ECHO_C" >&6
7838 else
7839   if test -n "$OBJDUMP"; then
7840   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7841 else
7842 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7843 for as_dir in $PATH
7844 do
7845   IFS=$as_save_IFS
7846   test -z "$as_dir" && as_dir=.
7847   for ac_exec_ext in '' $ac_executable_extensions; do
7848   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7849     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7850     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7851     break 2
7852   fi
7853 done
7854 done
7855
7856 fi
7857 fi
7858 OBJDUMP=$ac_cv_prog_OBJDUMP
7859 if test -n "$OBJDUMP"; then
7860   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7861 echo "${ECHO_T}$OBJDUMP" >&6
7862 else
7863   echo "$as_me:$LINENO: result: no" >&5
7864 echo "${ECHO_T}no" >&6
7865 fi
7866
7867   fi
7868   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7869     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7870 set dummy ${ncn_progname}; ac_word=$2
7871 echo "$as_me:$LINENO: checking for $ac_word" >&5
7872 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7873 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7874   echo $ECHO_N "(cached) $ECHO_C" >&6
7875 else
7876   if test -n "$OBJDUMP"; then
7877   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7878 else
7879 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7880 for as_dir in $PATH
7881 do
7882   IFS=$as_save_IFS
7883   test -z "$as_dir" && as_dir=.
7884   for ac_exec_ext in '' $ac_executable_extensions; do
7885   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7886     ac_cv_prog_OBJDUMP="${ncn_progname}"
7887     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7888     break 2
7889   fi
7890 done
7891 done
7892
7893 fi
7894 fi
7895 OBJDUMP=$ac_cv_prog_OBJDUMP
7896 if test -n "$OBJDUMP"; then
7897   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7898 echo "${ECHO_T}$OBJDUMP" >&6
7899 else
7900   echo "$as_me:$LINENO: result: no" >&5
7901 echo "${ECHO_T}no" >&6
7902 fi
7903
7904   fi
7905   test -n "$ac_cv_prog_OBJDUMP" && break
7906 done
7907
7908 if test -z "$ac_cv_prog_OBJDUMP" ; then
7909   set dummy objdump
7910   if test $build = $host ; then
7911     OBJDUMP="$2"
7912   else
7913     OBJDUMP="${ncn_tool_prefix}$2"
7914   fi
7915 fi
7916
7917
7918
7919
7920
7921
7922
7923 # Target tools.
7924
7925 # Check whether --with-build-time-tools or --without-build-time-tools was given.
7926 if test "${with_build_time_tools+set}" = set; then
7927   withval="$with_build_time_tools"
7928   case x"$withval" in
7929      x/*) ;;
7930      *)
7931        with_build_time_tools=
7932        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
7933 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
7934        ;;
7935    esac
7936 else
7937   with_build_time_tools=
7938 fi;
7939
7940
7941
7942 if test -n "$CC_FOR_TARGET"; then
7943   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
7944 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7945   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7946 fi
7947
7948 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7949   for ncn_progname in cc gcc; do
7950     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7951 set dummy ${ncn_progname}; ac_word=$2
7952 echo "$as_me:$LINENO: checking for $ac_word" >&5
7953 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7954 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7955   echo $ECHO_N "(cached) $ECHO_C" >&6
7956 else
7957   if test -n "$CC_FOR_TARGET"; then
7958   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7959 else
7960 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7961 for as_dir in $PATH
7962 do
7963   IFS=$as_save_IFS
7964   test -z "$as_dir" && as_dir=.
7965   for ac_exec_ext in '' $ac_executable_extensions; do
7966   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7967     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7968     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7969     break 2
7970   fi
7971 done
7972 done
7973
7974 fi
7975 fi
7976 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7977 if test -n "$CC_FOR_TARGET"; then
7978   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7979 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7980 else
7981   echo "$as_me:$LINENO: result: no" >&5
7982 echo "${ECHO_T}no" >&6
7983 fi
7984
7985   done
7986 fi
7987
7988 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
7989   for ncn_progname in cc gcc; do
7990     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7991 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7992     if test -x $with_build_time_tools/${ncn_progname}; then
7993       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7994       echo "$as_me:$LINENO: result: yes" >&5
7995 echo "${ECHO_T}yes" >&6
7996       break
7997     else
7998       echo "$as_me:$LINENO: result: no" >&5
7999 echo "${ECHO_T}no" >&6
8000     fi
8001   done
8002 fi
8003
8004 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8005   for ncn_progname in cc gcc; do
8006     if test -n "$ncn_target_tool_prefix"; then
8007       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8008 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8009 echo "$as_me:$LINENO: checking for $ac_word" >&5
8010 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8011 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8012   echo $ECHO_N "(cached) $ECHO_C" >&6
8013 else
8014   if test -n "$CC_FOR_TARGET"; then
8015   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8016 else
8017 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8018 for as_dir in $PATH
8019 do
8020   IFS=$as_save_IFS
8021   test -z "$as_dir" && as_dir=.
8022   for ac_exec_ext in '' $ac_executable_extensions; do
8023   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8024     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8025     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8026     break 2
8027   fi
8028 done
8029 done
8030
8031 fi
8032 fi
8033 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8034 if test -n "$CC_FOR_TARGET"; then
8035   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8036 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8037 else
8038   echo "$as_me:$LINENO: result: no" >&5
8039 echo "${ECHO_T}no" >&6
8040 fi
8041
8042     fi
8043     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8044       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8045 set dummy ${ncn_progname}; ac_word=$2
8046 echo "$as_me:$LINENO: checking for $ac_word" >&5
8047 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8048 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8049   echo $ECHO_N "(cached) $ECHO_C" >&6
8050 else
8051   if test -n "$CC_FOR_TARGET"; then
8052   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8053 else
8054 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8055 for as_dir in $PATH
8056 do
8057   IFS=$as_save_IFS
8058   test -z "$as_dir" && as_dir=.
8059   for ac_exec_ext in '' $ac_executable_extensions; do
8060   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8061     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8062     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8063     break 2
8064   fi
8065 done
8066 done
8067
8068 fi
8069 fi
8070 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8071 if test -n "$CC_FOR_TARGET"; then
8072   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8073 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8074 else
8075   echo "$as_me:$LINENO: result: no" >&5
8076 echo "${ECHO_T}no" >&6
8077 fi
8078
8079     fi
8080     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8081   done
8082 fi
8083
8084 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8085   set dummy cc gcc
8086   if test $build = $target ; then
8087     CC_FOR_TARGET="$2"
8088   else
8089     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8090   fi
8091 else
8092   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8093 fi
8094
8095
8096
8097 if test -n "$CXX_FOR_TARGET"; then
8098   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8099 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8100   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8101 fi
8102
8103 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8104   for ncn_progname in c++ g++ cxx gxx; do
8105     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8106 set dummy ${ncn_progname}; ac_word=$2
8107 echo "$as_me:$LINENO: checking for $ac_word" >&5
8108 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8109 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8110   echo $ECHO_N "(cached) $ECHO_C" >&6
8111 else
8112   if test -n "$CXX_FOR_TARGET"; then
8113   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8114 else
8115 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8116 for as_dir in $PATH
8117 do
8118   IFS=$as_save_IFS
8119   test -z "$as_dir" && as_dir=.
8120   for ac_exec_ext in '' $ac_executable_extensions; do
8121   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8122     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8123     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8124     break 2
8125   fi
8126 done
8127 done
8128
8129 fi
8130 fi
8131 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8132 if test -n "$CXX_FOR_TARGET"; then
8133   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8134 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8135 else
8136   echo "$as_me:$LINENO: result: no" >&5
8137 echo "${ECHO_T}no" >&6
8138 fi
8139
8140   done
8141 fi
8142
8143 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8144   for ncn_progname in c++ g++ cxx gxx; do
8145     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8146 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8147     if test -x $with_build_time_tools/${ncn_progname}; then
8148       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8149       echo "$as_me:$LINENO: result: yes" >&5
8150 echo "${ECHO_T}yes" >&6
8151       break
8152     else
8153       echo "$as_me:$LINENO: result: no" >&5
8154 echo "${ECHO_T}no" >&6
8155     fi
8156   done
8157 fi
8158
8159 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8160   for ncn_progname in c++ g++ cxx gxx; do
8161     if test -n "$ncn_target_tool_prefix"; then
8162       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8163 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8164 echo "$as_me:$LINENO: checking for $ac_word" >&5
8165 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8166 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8167   echo $ECHO_N "(cached) $ECHO_C" >&6
8168 else
8169   if test -n "$CXX_FOR_TARGET"; then
8170   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8171 else
8172 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8173 for as_dir in $PATH
8174 do
8175   IFS=$as_save_IFS
8176   test -z "$as_dir" && as_dir=.
8177   for ac_exec_ext in '' $ac_executable_extensions; do
8178   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8179     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8180     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8181     break 2
8182   fi
8183 done
8184 done
8185
8186 fi
8187 fi
8188 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8189 if test -n "$CXX_FOR_TARGET"; then
8190   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8191 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8192 else
8193   echo "$as_me:$LINENO: result: no" >&5
8194 echo "${ECHO_T}no" >&6
8195 fi
8196
8197     fi
8198     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8199       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8200 set dummy ${ncn_progname}; ac_word=$2
8201 echo "$as_me:$LINENO: checking for $ac_word" >&5
8202 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8203 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8204   echo $ECHO_N "(cached) $ECHO_C" >&6
8205 else
8206   if test -n "$CXX_FOR_TARGET"; then
8207   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8208 else
8209 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8210 for as_dir in $PATH
8211 do
8212   IFS=$as_save_IFS
8213   test -z "$as_dir" && as_dir=.
8214   for ac_exec_ext in '' $ac_executable_extensions; do
8215   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8216     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8217     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8218     break 2
8219   fi
8220 done
8221 done
8222
8223 fi
8224 fi
8225 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8226 if test -n "$CXX_FOR_TARGET"; then
8227   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8228 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8229 else
8230   echo "$as_me:$LINENO: result: no" >&5
8231 echo "${ECHO_T}no" >&6
8232 fi
8233
8234     fi
8235     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8236   done
8237 fi
8238
8239 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8240   set dummy c++ g++ cxx gxx
8241   if test $build = $target ; then
8242     CXX_FOR_TARGET="$2"
8243   else
8244     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8245   fi
8246 else
8247   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8248 fi
8249
8250
8251
8252 if test -n "$GCC_FOR_TARGET"; then
8253   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8254 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8255   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8256 fi
8257
8258 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8259   for ncn_progname in gcc; do
8260     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8261 set dummy ${ncn_progname}; ac_word=$2
8262 echo "$as_me:$LINENO: checking for $ac_word" >&5
8263 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8264 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8265   echo $ECHO_N "(cached) $ECHO_C" >&6
8266 else
8267   if test -n "$GCC_FOR_TARGET"; then
8268   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8269 else
8270 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8271 for as_dir in $PATH
8272 do
8273   IFS=$as_save_IFS
8274   test -z "$as_dir" && as_dir=.
8275   for ac_exec_ext in '' $ac_executable_extensions; do
8276   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8277     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8278     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8279     break 2
8280   fi
8281 done
8282 done
8283
8284 fi
8285 fi
8286 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8287 if test -n "$GCC_FOR_TARGET"; then
8288   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8289 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8290 else
8291   echo "$as_me:$LINENO: result: no" >&5
8292 echo "${ECHO_T}no" >&6
8293 fi
8294
8295   done
8296 fi
8297
8298 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8299   for ncn_progname in gcc; do
8300     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8301 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8302     if test -x $with_build_time_tools/${ncn_progname}; then
8303       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8304       echo "$as_me:$LINENO: result: yes" >&5
8305 echo "${ECHO_T}yes" >&6
8306       break
8307     else
8308       echo "$as_me:$LINENO: result: no" >&5
8309 echo "${ECHO_T}no" >&6
8310     fi
8311   done
8312 fi
8313
8314 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8315   for ncn_progname in gcc; do
8316     if test -n "$ncn_target_tool_prefix"; then
8317       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8318 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8319 echo "$as_me:$LINENO: checking for $ac_word" >&5
8320 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8321 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8322   echo $ECHO_N "(cached) $ECHO_C" >&6
8323 else
8324   if test -n "$GCC_FOR_TARGET"; then
8325   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8326 else
8327 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8328 for as_dir in $PATH
8329 do
8330   IFS=$as_save_IFS
8331   test -z "$as_dir" && as_dir=.
8332   for ac_exec_ext in '' $ac_executable_extensions; do
8333   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8334     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8335     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8336     break 2
8337   fi
8338 done
8339 done
8340
8341 fi
8342 fi
8343 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8344 if test -n "$GCC_FOR_TARGET"; then
8345   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8346 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8347 else
8348   echo "$as_me:$LINENO: result: no" >&5
8349 echo "${ECHO_T}no" >&6
8350 fi
8351
8352     fi
8353     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8354       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8355 set dummy ${ncn_progname}; ac_word=$2
8356 echo "$as_me:$LINENO: checking for $ac_word" >&5
8357 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8358 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8359   echo $ECHO_N "(cached) $ECHO_C" >&6
8360 else
8361   if test -n "$GCC_FOR_TARGET"; then
8362   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8363 else
8364 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8365 for as_dir in $PATH
8366 do
8367   IFS=$as_save_IFS
8368   test -z "$as_dir" && as_dir=.
8369   for ac_exec_ext in '' $ac_executable_extensions; do
8370   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8371     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8372     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8373     break 2
8374   fi
8375 done
8376 done
8377
8378 fi
8379 fi
8380 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8381 if test -n "$GCC_FOR_TARGET"; then
8382   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8383 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8384 else
8385   echo "$as_me:$LINENO: result: no" >&5
8386 echo "${ECHO_T}no" >&6
8387 fi
8388
8389     fi
8390     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8391   done
8392 fi
8393
8394 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8395   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8396 else
8397   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8398 fi
8399
8400
8401
8402 if test -n "$GCJ_FOR_TARGET"; then
8403   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8404 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8405   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8406 fi
8407
8408 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8409   for ncn_progname in gcj; do
8410     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8411 set dummy ${ncn_progname}; ac_word=$2
8412 echo "$as_me:$LINENO: checking for $ac_word" >&5
8413 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8414 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8415   echo $ECHO_N "(cached) $ECHO_C" >&6
8416 else
8417   if test -n "$GCJ_FOR_TARGET"; then
8418   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8419 else
8420 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8421 for as_dir in $PATH
8422 do
8423   IFS=$as_save_IFS
8424   test -z "$as_dir" && as_dir=.
8425   for ac_exec_ext in '' $ac_executable_extensions; do
8426   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8427     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8428     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8429     break 2
8430   fi
8431 done
8432 done
8433
8434 fi
8435 fi
8436 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8437 if test -n "$GCJ_FOR_TARGET"; then
8438   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8439 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8440 else
8441   echo "$as_me:$LINENO: result: no" >&5
8442 echo "${ECHO_T}no" >&6
8443 fi
8444
8445   done
8446 fi
8447
8448 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8449   for ncn_progname in gcj; do
8450     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8451 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8452     if test -x $with_build_time_tools/${ncn_progname}; then
8453       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8454       echo "$as_me:$LINENO: result: yes" >&5
8455 echo "${ECHO_T}yes" >&6
8456       break
8457     else
8458       echo "$as_me:$LINENO: result: no" >&5
8459 echo "${ECHO_T}no" >&6
8460     fi
8461   done
8462 fi
8463
8464 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8465   for ncn_progname in gcj; do
8466     if test -n "$ncn_target_tool_prefix"; then
8467       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8468 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8469 echo "$as_me:$LINENO: checking for $ac_word" >&5
8470 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8471 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8472   echo $ECHO_N "(cached) $ECHO_C" >&6
8473 else
8474   if test -n "$GCJ_FOR_TARGET"; then
8475   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8476 else
8477 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8478 for as_dir in $PATH
8479 do
8480   IFS=$as_save_IFS
8481   test -z "$as_dir" && as_dir=.
8482   for ac_exec_ext in '' $ac_executable_extensions; do
8483   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8484     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8485     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8486     break 2
8487   fi
8488 done
8489 done
8490
8491 fi
8492 fi
8493 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8494 if test -n "$GCJ_FOR_TARGET"; then
8495   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8496 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8497 else
8498   echo "$as_me:$LINENO: result: no" >&5
8499 echo "${ECHO_T}no" >&6
8500 fi
8501
8502     fi
8503     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8504       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8505 set dummy ${ncn_progname}; ac_word=$2
8506 echo "$as_me:$LINENO: checking for $ac_word" >&5
8507 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8508 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8509   echo $ECHO_N "(cached) $ECHO_C" >&6
8510 else
8511   if test -n "$GCJ_FOR_TARGET"; then
8512   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8513 else
8514 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8515 for as_dir in $PATH
8516 do
8517   IFS=$as_save_IFS
8518   test -z "$as_dir" && as_dir=.
8519   for ac_exec_ext in '' $ac_executable_extensions; do
8520   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8521     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8522     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8523     break 2
8524   fi
8525 done
8526 done
8527
8528 fi
8529 fi
8530 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8531 if test -n "$GCJ_FOR_TARGET"; then
8532   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8533 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8534 else
8535   echo "$as_me:$LINENO: result: no" >&5
8536 echo "${ECHO_T}no" >&6
8537 fi
8538
8539     fi
8540     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8541   done
8542 fi
8543
8544 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8545   set dummy gcj
8546   if test $build = $target ; then
8547     GCJ_FOR_TARGET="$2"
8548   else
8549     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8550   fi
8551 else
8552   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8553 fi
8554
8555
8556
8557 if test -n "$GFORTRAN_FOR_TARGET"; then
8558   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8559 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8560   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8561 fi
8562
8563 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8564   for ncn_progname in gfortran; do
8565     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8566 set dummy ${ncn_progname}; ac_word=$2
8567 echo "$as_me:$LINENO: checking for $ac_word" >&5
8568 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8569 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8570   echo $ECHO_N "(cached) $ECHO_C" >&6
8571 else
8572   if test -n "$GFORTRAN_FOR_TARGET"; then
8573   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8574 else
8575 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8576 for as_dir in $PATH
8577 do
8578   IFS=$as_save_IFS
8579   test -z "$as_dir" && as_dir=.
8580   for ac_exec_ext in '' $ac_executable_extensions; do
8581   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8582     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8583     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8584     break 2
8585   fi
8586 done
8587 done
8588
8589 fi
8590 fi
8591 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8592 if test -n "$GFORTRAN_FOR_TARGET"; then
8593   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8594 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8595 else
8596   echo "$as_me:$LINENO: result: no" >&5
8597 echo "${ECHO_T}no" >&6
8598 fi
8599
8600   done
8601 fi
8602
8603 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8604   for ncn_progname in gfortran; do
8605     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8606 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8607     if test -x $with_build_time_tools/${ncn_progname}; then
8608       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8609       echo "$as_me:$LINENO: result: yes" >&5
8610 echo "${ECHO_T}yes" >&6
8611       break
8612     else
8613       echo "$as_me:$LINENO: result: no" >&5
8614 echo "${ECHO_T}no" >&6
8615     fi
8616   done
8617 fi
8618
8619 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8620   for ncn_progname in gfortran; do
8621     if test -n "$ncn_target_tool_prefix"; then
8622       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8623 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8624 echo "$as_me:$LINENO: checking for $ac_word" >&5
8625 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8626 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8627   echo $ECHO_N "(cached) $ECHO_C" >&6
8628 else
8629   if test -n "$GFORTRAN_FOR_TARGET"; then
8630   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8631 else
8632 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8633 for as_dir in $PATH
8634 do
8635   IFS=$as_save_IFS
8636   test -z "$as_dir" && as_dir=.
8637   for ac_exec_ext in '' $ac_executable_extensions; do
8638   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8639     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8640     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8641     break 2
8642   fi
8643 done
8644 done
8645
8646 fi
8647 fi
8648 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8649 if test -n "$GFORTRAN_FOR_TARGET"; then
8650   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8651 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8652 else
8653   echo "$as_me:$LINENO: result: no" >&5
8654 echo "${ECHO_T}no" >&6
8655 fi
8656
8657     fi
8658     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8659       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8660 set dummy ${ncn_progname}; ac_word=$2
8661 echo "$as_me:$LINENO: checking for $ac_word" >&5
8662 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8663 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8664   echo $ECHO_N "(cached) $ECHO_C" >&6
8665 else
8666   if test -n "$GFORTRAN_FOR_TARGET"; then
8667   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8668 else
8669 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8670 for as_dir in $PATH
8671 do
8672   IFS=$as_save_IFS
8673   test -z "$as_dir" && as_dir=.
8674   for ac_exec_ext in '' $ac_executable_extensions; do
8675   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8676     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8677     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8678     break 2
8679   fi
8680 done
8681 done
8682
8683 fi
8684 fi
8685 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8686 if test -n "$GFORTRAN_FOR_TARGET"; then
8687   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8688 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8689 else
8690   echo "$as_me:$LINENO: result: no" >&5
8691 echo "${ECHO_T}no" >&6
8692 fi
8693
8694     fi
8695     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8696   done
8697 fi
8698
8699 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8700   set dummy gfortran
8701   if test $build = $target ; then
8702     GFORTRAN_FOR_TARGET="$2"
8703   else
8704     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8705   fi
8706 else
8707   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8708 fi
8709
8710
8711
8712 cat > conftest.c << \EOF
8713 #ifdef __GNUC__
8714   gcc_yay;
8715 #endif
8716 EOF
8717 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8718   have_gcc_for_target=yes
8719 else
8720   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8721   have_gcc_for_target=no
8722 fi
8723 rm conftest.c
8724
8725
8726
8727
8728 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8729   if test -n "$with_build_time_tools"; then
8730     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8731 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8732     if test -x $with_build_time_tools/ar; then
8733       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8734       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8735       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8736 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8737     else
8738       echo "$as_me:$LINENO: result: no" >&5
8739 echo "${ECHO_T}no" >&6
8740     fi
8741   elif test $build != $host && test $have_gcc_for_target = yes; then
8742     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8743     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8744     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8745   fi
8746 fi
8747 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8748   # Extract the first word of "ar", so it can be a program name with args.
8749 set dummy ar; ac_word=$2
8750 echo "$as_me:$LINENO: checking for $ac_word" >&5
8751 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8752 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8753   echo $ECHO_N "(cached) $ECHO_C" >&6
8754 else
8755   case $AR_FOR_TARGET in
8756   [\\/]* | ?:[\\/]*)
8757   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8758   ;;
8759   *)
8760   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8761 for as_dir in $gcc_cv_tool_dirs
8762 do
8763   IFS=$as_save_IFS
8764   test -z "$as_dir" && as_dir=.
8765   for ac_exec_ext in '' $ac_executable_extensions; do
8766   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8767     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8768     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8769     break 2
8770   fi
8771 done
8772 done
8773
8774   ;;
8775 esac
8776 fi
8777 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8778
8779 if test -n "$AR_FOR_TARGET"; then
8780   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8781 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8782 else
8783   echo "$as_me:$LINENO: result: no" >&5
8784 echo "${ECHO_T}no" >&6
8785 fi
8786
8787 fi
8788 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8789
8790
8791 if test -n "$AR_FOR_TARGET"; then
8792   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8793 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8794   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8795 fi
8796
8797 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8798   for ncn_progname in ar; do
8799     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8800 set dummy ${ncn_progname}; ac_word=$2
8801 echo "$as_me:$LINENO: checking for $ac_word" >&5
8802 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8803 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8804   echo $ECHO_N "(cached) $ECHO_C" >&6
8805 else
8806   if test -n "$AR_FOR_TARGET"; then
8807   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8808 else
8809 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8810 for as_dir in $PATH
8811 do
8812   IFS=$as_save_IFS
8813   test -z "$as_dir" && as_dir=.
8814   for ac_exec_ext in '' $ac_executable_extensions; do
8815   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8816     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8817     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8818     break 2
8819   fi
8820 done
8821 done
8822
8823 fi
8824 fi
8825 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8826 if test -n "$AR_FOR_TARGET"; then
8827   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8828 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8829 else
8830   echo "$as_me:$LINENO: result: no" >&5
8831 echo "${ECHO_T}no" >&6
8832 fi
8833
8834   done
8835 fi
8836
8837 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8838   for ncn_progname in ar; do
8839     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8840 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8841     if test -x $with_build_time_tools/${ncn_progname}; then
8842       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8843       echo "$as_me:$LINENO: result: yes" >&5
8844 echo "${ECHO_T}yes" >&6
8845       break
8846     else
8847       echo "$as_me:$LINENO: result: no" >&5
8848 echo "${ECHO_T}no" >&6
8849     fi
8850   done
8851 fi
8852
8853 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8854   for ncn_progname in ar; do
8855     if test -n "$ncn_target_tool_prefix"; then
8856       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8857 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8858 echo "$as_me:$LINENO: checking for $ac_word" >&5
8859 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8860 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8861   echo $ECHO_N "(cached) $ECHO_C" >&6
8862 else
8863   if test -n "$AR_FOR_TARGET"; then
8864   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8865 else
8866 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8867 for as_dir in $PATH
8868 do
8869   IFS=$as_save_IFS
8870   test -z "$as_dir" && as_dir=.
8871   for ac_exec_ext in '' $ac_executable_extensions; do
8872   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8873     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8874     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8875     break 2
8876   fi
8877 done
8878 done
8879
8880 fi
8881 fi
8882 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8883 if test -n "$AR_FOR_TARGET"; then
8884   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8885 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8886 else
8887   echo "$as_me:$LINENO: result: no" >&5
8888 echo "${ECHO_T}no" >&6
8889 fi
8890
8891     fi
8892     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8893       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8894 set dummy ${ncn_progname}; ac_word=$2
8895 echo "$as_me:$LINENO: checking for $ac_word" >&5
8896 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8897 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8898   echo $ECHO_N "(cached) $ECHO_C" >&6
8899 else
8900   if test -n "$AR_FOR_TARGET"; then
8901   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8902 else
8903 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8904 for as_dir in $PATH
8905 do
8906   IFS=$as_save_IFS
8907   test -z "$as_dir" && as_dir=.
8908   for ac_exec_ext in '' $ac_executable_extensions; do
8909   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8910     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8911     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8912     break 2
8913   fi
8914 done
8915 done
8916
8917 fi
8918 fi
8919 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8920 if test -n "$AR_FOR_TARGET"; then
8921   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8922 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8923 else
8924   echo "$as_me:$LINENO: result: no" >&5
8925 echo "${ECHO_T}no" >&6
8926 fi
8927
8928     fi
8929     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
8930   done
8931 fi
8932
8933 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
8934   set dummy ar
8935   if test $build = $target ; then
8936     AR_FOR_TARGET="$2"
8937   else
8938     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
8939   fi
8940 else
8941   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
8942 fi
8943
8944 else
8945   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8946 fi
8947
8948
8949
8950
8951 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8952   if test -n "$with_build_time_tools"; then
8953     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
8954 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
8955     if test -x $with_build_time_tools/as; then
8956       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
8957       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8958       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
8959 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
8960     else
8961       echo "$as_me:$LINENO: result: no" >&5
8962 echo "${ECHO_T}no" >&6
8963     fi
8964   elif test $build != $host && test $have_gcc_for_target = yes; then
8965     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
8966     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
8967     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8968   fi
8969 fi
8970 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8971   # Extract the first word of "as", so it can be a program name with args.
8972 set dummy as; ac_word=$2
8973 echo "$as_me:$LINENO: checking for $ac_word" >&5
8974 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8975 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
8976   echo $ECHO_N "(cached) $ECHO_C" >&6
8977 else
8978   case $AS_FOR_TARGET in
8979   [\\/]* | ?:[\\/]*)
8980   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
8981   ;;
8982   *)
8983   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8984 for as_dir in $gcc_cv_tool_dirs
8985 do
8986   IFS=$as_save_IFS
8987   test -z "$as_dir" && as_dir=.
8988   for ac_exec_ext in '' $ac_executable_extensions; do
8989   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8990     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8991     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8992     break 2
8993   fi
8994 done
8995 done
8996
8997   ;;
8998 esac
8999 fi
9000 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9001
9002 if test -n "$AS_FOR_TARGET"; then
9003   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9004 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9005 else
9006   echo "$as_me:$LINENO: result: no" >&5
9007 echo "${ECHO_T}no" >&6
9008 fi
9009
9010 fi
9011 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9012
9013
9014 if test -n "$AS_FOR_TARGET"; then
9015   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9016 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9017   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9018 fi
9019
9020 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9021   for ncn_progname in as; do
9022     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9023 set dummy ${ncn_progname}; ac_word=$2
9024 echo "$as_me:$LINENO: checking for $ac_word" >&5
9025 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9026 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9027   echo $ECHO_N "(cached) $ECHO_C" >&6
9028 else
9029   if test -n "$AS_FOR_TARGET"; then
9030   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9031 else
9032 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9033 for as_dir in $PATH
9034 do
9035   IFS=$as_save_IFS
9036   test -z "$as_dir" && as_dir=.
9037   for ac_exec_ext in '' $ac_executable_extensions; do
9038   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9039     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9040     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9041     break 2
9042   fi
9043 done
9044 done
9045
9046 fi
9047 fi
9048 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9049 if test -n "$AS_FOR_TARGET"; then
9050   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9051 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9052 else
9053   echo "$as_me:$LINENO: result: no" >&5
9054 echo "${ECHO_T}no" >&6
9055 fi
9056
9057   done
9058 fi
9059
9060 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9061   for ncn_progname in as; do
9062     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9063 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9064     if test -x $with_build_time_tools/${ncn_progname}; then
9065       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9066       echo "$as_me:$LINENO: result: yes" >&5
9067 echo "${ECHO_T}yes" >&6
9068       break
9069     else
9070       echo "$as_me:$LINENO: result: no" >&5
9071 echo "${ECHO_T}no" >&6
9072     fi
9073   done
9074 fi
9075
9076 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9077   for ncn_progname in as; do
9078     if test -n "$ncn_target_tool_prefix"; then
9079       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9080 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9081 echo "$as_me:$LINENO: checking for $ac_word" >&5
9082 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9083 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9084   echo $ECHO_N "(cached) $ECHO_C" >&6
9085 else
9086   if test -n "$AS_FOR_TARGET"; then
9087   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9088 else
9089 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9090 for as_dir in $PATH
9091 do
9092   IFS=$as_save_IFS
9093   test -z "$as_dir" && as_dir=.
9094   for ac_exec_ext in '' $ac_executable_extensions; do
9095   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9096     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9097     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9098     break 2
9099   fi
9100 done
9101 done
9102
9103 fi
9104 fi
9105 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9106 if test -n "$AS_FOR_TARGET"; then
9107   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9108 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9109 else
9110   echo "$as_me:$LINENO: result: no" >&5
9111 echo "${ECHO_T}no" >&6
9112 fi
9113
9114     fi
9115     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9116       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9117 set dummy ${ncn_progname}; ac_word=$2
9118 echo "$as_me:$LINENO: checking for $ac_word" >&5
9119 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9120 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9121   echo $ECHO_N "(cached) $ECHO_C" >&6
9122 else
9123   if test -n "$AS_FOR_TARGET"; then
9124   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9125 else
9126 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9127 for as_dir in $PATH
9128 do
9129   IFS=$as_save_IFS
9130   test -z "$as_dir" && as_dir=.
9131   for ac_exec_ext in '' $ac_executable_extensions; do
9132   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9133     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9134     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9135     break 2
9136   fi
9137 done
9138 done
9139
9140 fi
9141 fi
9142 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9143 if test -n "$AS_FOR_TARGET"; then
9144   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9145 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9146 else
9147   echo "$as_me:$LINENO: result: no" >&5
9148 echo "${ECHO_T}no" >&6
9149 fi
9150
9151     fi
9152     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9153   done
9154 fi
9155
9156 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9157   set dummy as
9158   if test $build = $target ; then
9159     AS_FOR_TARGET="$2"
9160   else
9161     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9162   fi
9163 else
9164   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9165 fi
9166
9167 else
9168   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9169 fi
9170
9171
9172
9173
9174 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9175   if test -n "$with_build_time_tools"; then
9176     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9177 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9178     if test -x $with_build_time_tools/dlltool; then
9179       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9180       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9181       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9182 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9183     else
9184       echo "$as_me:$LINENO: result: no" >&5
9185 echo "${ECHO_T}no" >&6
9186     fi
9187   elif test $build != $host && test $have_gcc_for_target = yes; then
9188     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9189     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9190     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9191   fi
9192 fi
9193 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9194   # Extract the first word of "dlltool", so it can be a program name with args.
9195 set dummy dlltool; ac_word=$2
9196 echo "$as_me:$LINENO: checking for $ac_word" >&5
9197 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9198 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9199   echo $ECHO_N "(cached) $ECHO_C" >&6
9200 else
9201   case $DLLTOOL_FOR_TARGET in
9202   [\\/]* | ?:[\\/]*)
9203   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9204   ;;
9205   *)
9206   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9207 for as_dir in $gcc_cv_tool_dirs
9208 do
9209   IFS=$as_save_IFS
9210   test -z "$as_dir" && as_dir=.
9211   for ac_exec_ext in '' $ac_executable_extensions; do
9212   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9213     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9214     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9215     break 2
9216   fi
9217 done
9218 done
9219
9220   ;;
9221 esac
9222 fi
9223 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9224
9225 if test -n "$DLLTOOL_FOR_TARGET"; then
9226   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9227 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9228 else
9229   echo "$as_me:$LINENO: result: no" >&5
9230 echo "${ECHO_T}no" >&6
9231 fi
9232
9233 fi
9234 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9235
9236
9237 if test -n "$DLLTOOL_FOR_TARGET"; then
9238   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9239 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9240   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9241 fi
9242
9243 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9244   for ncn_progname in dlltool; do
9245     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9246 set dummy ${ncn_progname}; ac_word=$2
9247 echo "$as_me:$LINENO: checking for $ac_word" >&5
9248 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9249 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9250   echo $ECHO_N "(cached) $ECHO_C" >&6
9251 else
9252   if test -n "$DLLTOOL_FOR_TARGET"; then
9253   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9254 else
9255 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9256 for as_dir in $PATH
9257 do
9258   IFS=$as_save_IFS
9259   test -z "$as_dir" && as_dir=.
9260   for ac_exec_ext in '' $ac_executable_extensions; do
9261   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9262     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9263     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9264     break 2
9265   fi
9266 done
9267 done
9268
9269 fi
9270 fi
9271 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9272 if test -n "$DLLTOOL_FOR_TARGET"; then
9273   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9274 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9275 else
9276   echo "$as_me:$LINENO: result: no" >&5
9277 echo "${ECHO_T}no" >&6
9278 fi
9279
9280   done
9281 fi
9282
9283 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9284   for ncn_progname in dlltool; do
9285     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9286 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9287     if test -x $with_build_time_tools/${ncn_progname}; then
9288       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9289       echo "$as_me:$LINENO: result: yes" >&5
9290 echo "${ECHO_T}yes" >&6
9291       break
9292     else
9293       echo "$as_me:$LINENO: result: no" >&5
9294 echo "${ECHO_T}no" >&6
9295     fi
9296   done
9297 fi
9298
9299 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9300   for ncn_progname in dlltool; do
9301     if test -n "$ncn_target_tool_prefix"; then
9302       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9303 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9304 echo "$as_me:$LINENO: checking for $ac_word" >&5
9305 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9306 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9307   echo $ECHO_N "(cached) $ECHO_C" >&6
9308 else
9309   if test -n "$DLLTOOL_FOR_TARGET"; then
9310   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9311 else
9312 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9313 for as_dir in $PATH
9314 do
9315   IFS=$as_save_IFS
9316   test -z "$as_dir" && as_dir=.
9317   for ac_exec_ext in '' $ac_executable_extensions; do
9318   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9319     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9320     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9321     break 2
9322   fi
9323 done
9324 done
9325
9326 fi
9327 fi
9328 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9329 if test -n "$DLLTOOL_FOR_TARGET"; then
9330   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9331 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9332 else
9333   echo "$as_me:$LINENO: result: no" >&5
9334 echo "${ECHO_T}no" >&6
9335 fi
9336
9337     fi
9338     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9339       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9340 set dummy ${ncn_progname}; ac_word=$2
9341 echo "$as_me:$LINENO: checking for $ac_word" >&5
9342 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9343 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9344   echo $ECHO_N "(cached) $ECHO_C" >&6
9345 else
9346   if test -n "$DLLTOOL_FOR_TARGET"; then
9347   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9348 else
9349 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9350 for as_dir in $PATH
9351 do
9352   IFS=$as_save_IFS
9353   test -z "$as_dir" && as_dir=.
9354   for ac_exec_ext in '' $ac_executable_extensions; do
9355   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9356     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9357     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9358     break 2
9359   fi
9360 done
9361 done
9362
9363 fi
9364 fi
9365 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9366 if test -n "$DLLTOOL_FOR_TARGET"; then
9367   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9368 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9369 else
9370   echo "$as_me:$LINENO: result: no" >&5
9371 echo "${ECHO_T}no" >&6
9372 fi
9373
9374     fi
9375     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9376   done
9377 fi
9378
9379 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9380   set dummy dlltool
9381   if test $build = $target ; then
9382     DLLTOOL_FOR_TARGET="$2"
9383   else
9384     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9385   fi
9386 else
9387   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9388 fi
9389
9390 else
9391   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9392 fi
9393
9394
9395
9396
9397 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9398   if test -n "$with_build_time_tools"; then
9399     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9400 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9401     if test -x $with_build_time_tools/ld; then
9402       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9403       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9404       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9405 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9406     else
9407       echo "$as_me:$LINENO: result: no" >&5
9408 echo "${ECHO_T}no" >&6
9409     fi
9410   elif test $build != $host && test $have_gcc_for_target = yes; then
9411     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9412     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9413     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9414   fi
9415 fi
9416 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9417   # Extract the first word of "ld", so it can be a program name with args.
9418 set dummy ld; ac_word=$2
9419 echo "$as_me:$LINENO: checking for $ac_word" >&5
9420 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9421 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9422   echo $ECHO_N "(cached) $ECHO_C" >&6
9423 else
9424   case $LD_FOR_TARGET in
9425   [\\/]* | ?:[\\/]*)
9426   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9427   ;;
9428   *)
9429   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9430 for as_dir in $gcc_cv_tool_dirs
9431 do
9432   IFS=$as_save_IFS
9433   test -z "$as_dir" && as_dir=.
9434   for ac_exec_ext in '' $ac_executable_extensions; do
9435   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9436     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9437     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9438     break 2
9439   fi
9440 done
9441 done
9442
9443   ;;
9444 esac
9445 fi
9446 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9447
9448 if test -n "$LD_FOR_TARGET"; then
9449   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9450 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9451 else
9452   echo "$as_me:$LINENO: result: no" >&5
9453 echo "${ECHO_T}no" >&6
9454 fi
9455
9456 fi
9457 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9458
9459
9460 if test -n "$LD_FOR_TARGET"; then
9461   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9462 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9463   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9464 fi
9465
9466 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9467   for ncn_progname in ld; do
9468     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9469 set dummy ${ncn_progname}; ac_word=$2
9470 echo "$as_me:$LINENO: checking for $ac_word" >&5
9471 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9472 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9473   echo $ECHO_N "(cached) $ECHO_C" >&6
9474 else
9475   if test -n "$LD_FOR_TARGET"; then
9476   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9477 else
9478 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9479 for as_dir in $PATH
9480 do
9481   IFS=$as_save_IFS
9482   test -z "$as_dir" && as_dir=.
9483   for ac_exec_ext in '' $ac_executable_extensions; do
9484   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9485     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9486     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9487     break 2
9488   fi
9489 done
9490 done
9491
9492 fi
9493 fi
9494 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9495 if test -n "$LD_FOR_TARGET"; then
9496   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9497 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9498 else
9499   echo "$as_me:$LINENO: result: no" >&5
9500 echo "${ECHO_T}no" >&6
9501 fi
9502
9503   done
9504 fi
9505
9506 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9507   for ncn_progname in ld; do
9508     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9509 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9510     if test -x $with_build_time_tools/${ncn_progname}; then
9511       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9512       echo "$as_me:$LINENO: result: yes" >&5
9513 echo "${ECHO_T}yes" >&6
9514       break
9515     else
9516       echo "$as_me:$LINENO: result: no" >&5
9517 echo "${ECHO_T}no" >&6
9518     fi
9519   done
9520 fi
9521
9522 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9523   for ncn_progname in ld; do
9524     if test -n "$ncn_target_tool_prefix"; then
9525       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9526 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9527 echo "$as_me:$LINENO: checking for $ac_word" >&5
9528 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9529 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9530   echo $ECHO_N "(cached) $ECHO_C" >&6
9531 else
9532   if test -n "$LD_FOR_TARGET"; then
9533   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9534 else
9535 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9536 for as_dir in $PATH
9537 do
9538   IFS=$as_save_IFS
9539   test -z "$as_dir" && as_dir=.
9540   for ac_exec_ext in '' $ac_executable_extensions; do
9541   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9542     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9543     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9544     break 2
9545   fi
9546 done
9547 done
9548
9549 fi
9550 fi
9551 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9552 if test -n "$LD_FOR_TARGET"; then
9553   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9554 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9555 else
9556   echo "$as_me:$LINENO: result: no" >&5
9557 echo "${ECHO_T}no" >&6
9558 fi
9559
9560     fi
9561     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9562       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9563 set dummy ${ncn_progname}; ac_word=$2
9564 echo "$as_me:$LINENO: checking for $ac_word" >&5
9565 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9566 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9567   echo $ECHO_N "(cached) $ECHO_C" >&6
9568 else
9569   if test -n "$LD_FOR_TARGET"; then
9570   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9571 else
9572 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9573 for as_dir in $PATH
9574 do
9575   IFS=$as_save_IFS
9576   test -z "$as_dir" && as_dir=.
9577   for ac_exec_ext in '' $ac_executable_extensions; do
9578   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9579     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9580     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9581     break 2
9582   fi
9583 done
9584 done
9585
9586 fi
9587 fi
9588 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9589 if test -n "$LD_FOR_TARGET"; then
9590   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9591 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9592 else
9593   echo "$as_me:$LINENO: result: no" >&5
9594 echo "${ECHO_T}no" >&6
9595 fi
9596
9597     fi
9598     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9599   done
9600 fi
9601
9602 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9603   set dummy ld
9604   if test $build = $target ; then
9605     LD_FOR_TARGET="$2"
9606   else
9607     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9608   fi
9609 else
9610   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9611 fi
9612
9613 else
9614   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9615 fi
9616
9617
9618
9619
9620 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9621   if test -n "$with_build_time_tools"; then
9622     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9623 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9624     if test -x $with_build_time_tools/lipo; then
9625       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9626       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9627       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9628 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9629     else
9630       echo "$as_me:$LINENO: result: no" >&5
9631 echo "${ECHO_T}no" >&6
9632     fi
9633   elif test $build != $host && test $have_gcc_for_target = yes; then
9634     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9635     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9636     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9637   fi
9638 fi
9639 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9640   # Extract the first word of "lipo", so it can be a program name with args.
9641 set dummy lipo; ac_word=$2
9642 echo "$as_me:$LINENO: checking for $ac_word" >&5
9643 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9644 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9645   echo $ECHO_N "(cached) $ECHO_C" >&6
9646 else
9647   case $LIPO_FOR_TARGET in
9648   [\\/]* | ?:[\\/]*)
9649   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9650   ;;
9651   *)
9652   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9653 for as_dir in $gcc_cv_tool_dirs
9654 do
9655   IFS=$as_save_IFS
9656   test -z "$as_dir" && as_dir=.
9657   for ac_exec_ext in '' $ac_executable_extensions; do
9658   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9659     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9660     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9661     break 2
9662   fi
9663 done
9664 done
9665
9666   ;;
9667 esac
9668 fi
9669 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9670
9671 if test -n "$LIPO_FOR_TARGET"; then
9672   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9673 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9674 else
9675   echo "$as_me:$LINENO: result: no" >&5
9676 echo "${ECHO_T}no" >&6
9677 fi
9678
9679 fi
9680 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9681
9682
9683 if test -n "$LIPO_FOR_TARGET"; then
9684   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9685 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9686   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9687 fi
9688
9689 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9690   for ncn_progname in lipo; do
9691     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9692 set dummy ${ncn_progname}; ac_word=$2
9693 echo "$as_me:$LINENO: checking for $ac_word" >&5
9694 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9695 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9696   echo $ECHO_N "(cached) $ECHO_C" >&6
9697 else
9698   if test -n "$LIPO_FOR_TARGET"; then
9699   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9700 else
9701 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9702 for as_dir in $PATH
9703 do
9704   IFS=$as_save_IFS
9705   test -z "$as_dir" && as_dir=.
9706   for ac_exec_ext in '' $ac_executable_extensions; do
9707   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9708     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9709     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9710     break 2
9711   fi
9712 done
9713 done
9714
9715 fi
9716 fi
9717 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9718 if test -n "$LIPO_FOR_TARGET"; then
9719   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9720 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9721 else
9722   echo "$as_me:$LINENO: result: no" >&5
9723 echo "${ECHO_T}no" >&6
9724 fi
9725
9726   done
9727 fi
9728
9729 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9730   for ncn_progname in lipo; do
9731     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9732 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9733     if test -x $with_build_time_tools/${ncn_progname}; then
9734       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9735       echo "$as_me:$LINENO: result: yes" >&5
9736 echo "${ECHO_T}yes" >&6
9737       break
9738     else
9739       echo "$as_me:$LINENO: result: no" >&5
9740 echo "${ECHO_T}no" >&6
9741     fi
9742   done
9743 fi
9744
9745 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9746   for ncn_progname in lipo; do
9747     if test -n "$ncn_target_tool_prefix"; then
9748       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9749 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9750 echo "$as_me:$LINENO: checking for $ac_word" >&5
9751 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9752 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9753   echo $ECHO_N "(cached) $ECHO_C" >&6
9754 else
9755   if test -n "$LIPO_FOR_TARGET"; then
9756   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9757 else
9758 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9759 for as_dir in $PATH
9760 do
9761   IFS=$as_save_IFS
9762   test -z "$as_dir" && as_dir=.
9763   for ac_exec_ext in '' $ac_executable_extensions; do
9764   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9765     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9766     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9767     break 2
9768   fi
9769 done
9770 done
9771
9772 fi
9773 fi
9774 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9775 if test -n "$LIPO_FOR_TARGET"; then
9776   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9777 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9778 else
9779   echo "$as_me:$LINENO: result: no" >&5
9780 echo "${ECHO_T}no" >&6
9781 fi
9782
9783     fi
9784     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9785       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9786 set dummy ${ncn_progname}; ac_word=$2
9787 echo "$as_me:$LINENO: checking for $ac_word" >&5
9788 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9789 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9790   echo $ECHO_N "(cached) $ECHO_C" >&6
9791 else
9792   if test -n "$LIPO_FOR_TARGET"; then
9793   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9794 else
9795 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9796 for as_dir in $PATH
9797 do
9798   IFS=$as_save_IFS
9799   test -z "$as_dir" && as_dir=.
9800   for ac_exec_ext in '' $ac_executable_extensions; do
9801   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9802     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9803     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9804     break 2
9805   fi
9806 done
9807 done
9808
9809 fi
9810 fi
9811 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9812 if test -n "$LIPO_FOR_TARGET"; then
9813   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9814 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9815 else
9816   echo "$as_me:$LINENO: result: no" >&5
9817 echo "${ECHO_T}no" >&6
9818 fi
9819
9820     fi
9821     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9822   done
9823 fi
9824
9825 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9826   set dummy lipo
9827   if test $build = $target ; then
9828     LIPO_FOR_TARGET="$2"
9829   else
9830     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9831   fi
9832 else
9833   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9834 fi
9835
9836 else
9837   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9838 fi
9839
9840
9841
9842
9843 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9844   if test -n "$with_build_time_tools"; then
9845     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9846 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9847     if test -x $with_build_time_tools/nm; then
9848       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9849       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9850       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9851 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9852     else
9853       echo "$as_me:$LINENO: result: no" >&5
9854 echo "${ECHO_T}no" >&6
9855     fi
9856   elif test $build != $host && test $have_gcc_for_target = yes; then
9857     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9858     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
9859     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9860   fi
9861 fi
9862 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9863   # Extract the first word of "nm", so it can be a program name with args.
9864 set dummy nm; ac_word=$2
9865 echo "$as_me:$LINENO: checking for $ac_word" >&5
9866 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9867 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9868   echo $ECHO_N "(cached) $ECHO_C" >&6
9869 else
9870   case $NM_FOR_TARGET in
9871   [\\/]* | ?:[\\/]*)
9872   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9873   ;;
9874   *)
9875   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9876 for as_dir in $gcc_cv_tool_dirs
9877 do
9878   IFS=$as_save_IFS
9879   test -z "$as_dir" && as_dir=.
9880   for ac_exec_ext in '' $ac_executable_extensions; do
9881   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9882     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9883     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9884     break 2
9885   fi
9886 done
9887 done
9888
9889   ;;
9890 esac
9891 fi
9892 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9893
9894 if test -n "$NM_FOR_TARGET"; then
9895   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9896 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9897 else
9898   echo "$as_me:$LINENO: result: no" >&5
9899 echo "${ECHO_T}no" >&6
9900 fi
9901
9902 fi
9903 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9904
9905
9906 if test -n "$NM_FOR_TARGET"; then
9907   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9908 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9909   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9910 fi
9911
9912 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9913   for ncn_progname in nm; do
9914     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9915 set dummy ${ncn_progname}; ac_word=$2
9916 echo "$as_me:$LINENO: checking for $ac_word" >&5
9917 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9918 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9919   echo $ECHO_N "(cached) $ECHO_C" >&6
9920 else
9921   if test -n "$NM_FOR_TARGET"; then
9922   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9923 else
9924 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9925 for as_dir in $PATH
9926 do
9927   IFS=$as_save_IFS
9928   test -z "$as_dir" && as_dir=.
9929   for ac_exec_ext in '' $ac_executable_extensions; do
9930   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9931     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9932     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9933     break 2
9934   fi
9935 done
9936 done
9937
9938 fi
9939 fi
9940 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9941 if test -n "$NM_FOR_TARGET"; then
9942   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9943 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9944 else
9945   echo "$as_me:$LINENO: result: no" >&5
9946 echo "${ECHO_T}no" >&6
9947 fi
9948
9949   done
9950 fi
9951
9952 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
9953   for ncn_progname in nm; do
9954     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9955 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9956     if test -x $with_build_time_tools/${ncn_progname}; then
9957       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9958       echo "$as_me:$LINENO: result: yes" >&5
9959 echo "${ECHO_T}yes" >&6
9960       break
9961     else
9962       echo "$as_me:$LINENO: result: no" >&5
9963 echo "${ECHO_T}no" >&6
9964     fi
9965   done
9966 fi
9967
9968 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
9969   for ncn_progname in nm; do
9970     if test -n "$ncn_target_tool_prefix"; then
9971       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9972 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9973 echo "$as_me:$LINENO: checking for $ac_word" >&5
9974 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9975 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9976   echo $ECHO_N "(cached) $ECHO_C" >&6
9977 else
9978   if test -n "$NM_FOR_TARGET"; then
9979   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9980 else
9981 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9982 for as_dir in $PATH
9983 do
9984   IFS=$as_save_IFS
9985   test -z "$as_dir" && as_dir=.
9986   for ac_exec_ext in '' $ac_executable_extensions; do
9987   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9988     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9989     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9990     break 2
9991   fi
9992 done
9993 done
9994
9995 fi
9996 fi
9997 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9998 if test -n "$NM_FOR_TARGET"; then
9999   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10000 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10001 else
10002   echo "$as_me:$LINENO: result: no" >&5
10003 echo "${ECHO_T}no" >&6
10004 fi
10005
10006     fi
10007     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10008       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10009 set dummy ${ncn_progname}; ac_word=$2
10010 echo "$as_me:$LINENO: checking for $ac_word" >&5
10011 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10012 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10013   echo $ECHO_N "(cached) $ECHO_C" >&6
10014 else
10015   if test -n "$NM_FOR_TARGET"; then
10016   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10017 else
10018 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10019 for as_dir in $PATH
10020 do
10021   IFS=$as_save_IFS
10022   test -z "$as_dir" && as_dir=.
10023   for ac_exec_ext in '' $ac_executable_extensions; do
10024   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10025     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10026     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10027     break 2
10028   fi
10029 done
10030 done
10031
10032 fi
10033 fi
10034 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10035 if test -n "$NM_FOR_TARGET"; then
10036   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10037 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10038 else
10039   echo "$as_me:$LINENO: result: no" >&5
10040 echo "${ECHO_T}no" >&6
10041 fi
10042
10043     fi
10044     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10045   done
10046 fi
10047
10048 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10049   set dummy nm
10050   if test $build = $target ; then
10051     NM_FOR_TARGET="$2"
10052   else
10053     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10054   fi
10055 else
10056   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10057 fi
10058
10059 else
10060   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10061 fi
10062
10063
10064
10065
10066 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10067   if test -n "$with_build_time_tools"; then
10068     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10069 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10070     if test -x $with_build_time_tools/objdump; then
10071       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10072       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10073       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10074 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10075     else
10076       echo "$as_me:$LINENO: result: no" >&5
10077 echo "${ECHO_T}no" >&6
10078     fi
10079   elif test $build != $host && test $have_gcc_for_target = yes; then
10080     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10081     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10082     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10083   fi
10084 fi
10085 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10086   # Extract the first word of "objdump", so it can be a program name with args.
10087 set dummy objdump; ac_word=$2
10088 echo "$as_me:$LINENO: checking for $ac_word" >&5
10089 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10090 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10091   echo $ECHO_N "(cached) $ECHO_C" >&6
10092 else
10093   case $OBJDUMP_FOR_TARGET in
10094   [\\/]* | ?:[\\/]*)
10095   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10096   ;;
10097   *)
10098   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10099 for as_dir in $gcc_cv_tool_dirs
10100 do
10101   IFS=$as_save_IFS
10102   test -z "$as_dir" && as_dir=.
10103   for ac_exec_ext in '' $ac_executable_extensions; do
10104   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10105     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10106     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10107     break 2
10108   fi
10109 done
10110 done
10111
10112   ;;
10113 esac
10114 fi
10115 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10116
10117 if test -n "$OBJDUMP_FOR_TARGET"; then
10118   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10119 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10120 else
10121   echo "$as_me:$LINENO: result: no" >&5
10122 echo "${ECHO_T}no" >&6
10123 fi
10124
10125 fi
10126 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10127
10128
10129 if test -n "$OBJDUMP_FOR_TARGET"; then
10130   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10131 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10132   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10133 fi
10134
10135 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10136   for ncn_progname in objdump; do
10137     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10138 set dummy ${ncn_progname}; ac_word=$2
10139 echo "$as_me:$LINENO: checking for $ac_word" >&5
10140 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10141 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10142   echo $ECHO_N "(cached) $ECHO_C" >&6
10143 else
10144   if test -n "$OBJDUMP_FOR_TARGET"; then
10145   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10146 else
10147 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10148 for as_dir in $PATH
10149 do
10150   IFS=$as_save_IFS
10151   test -z "$as_dir" && as_dir=.
10152   for ac_exec_ext in '' $ac_executable_extensions; do
10153   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10154     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10155     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10156     break 2
10157   fi
10158 done
10159 done
10160
10161 fi
10162 fi
10163 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10164 if test -n "$OBJDUMP_FOR_TARGET"; then
10165   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10166 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10167 else
10168   echo "$as_me:$LINENO: result: no" >&5
10169 echo "${ECHO_T}no" >&6
10170 fi
10171
10172   done
10173 fi
10174
10175 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10176   for ncn_progname in objdump; do
10177     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10178 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10179     if test -x $with_build_time_tools/${ncn_progname}; then
10180       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10181       echo "$as_me:$LINENO: result: yes" >&5
10182 echo "${ECHO_T}yes" >&6
10183       break
10184     else
10185       echo "$as_me:$LINENO: result: no" >&5
10186 echo "${ECHO_T}no" >&6
10187     fi
10188   done
10189 fi
10190
10191 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10192   for ncn_progname in objdump; do
10193     if test -n "$ncn_target_tool_prefix"; then
10194       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10195 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10196 echo "$as_me:$LINENO: checking for $ac_word" >&5
10197 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10198 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10199   echo $ECHO_N "(cached) $ECHO_C" >&6
10200 else
10201   if test -n "$OBJDUMP_FOR_TARGET"; then
10202   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10203 else
10204 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10205 for as_dir in $PATH
10206 do
10207   IFS=$as_save_IFS
10208   test -z "$as_dir" && as_dir=.
10209   for ac_exec_ext in '' $ac_executable_extensions; do
10210   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10211     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10212     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10213     break 2
10214   fi
10215 done
10216 done
10217
10218 fi
10219 fi
10220 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10221 if test -n "$OBJDUMP_FOR_TARGET"; then
10222   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10223 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10224 else
10225   echo "$as_me:$LINENO: result: no" >&5
10226 echo "${ECHO_T}no" >&6
10227 fi
10228
10229     fi
10230     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10231       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10232 set dummy ${ncn_progname}; ac_word=$2
10233 echo "$as_me:$LINENO: checking for $ac_word" >&5
10234 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10235 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10236   echo $ECHO_N "(cached) $ECHO_C" >&6
10237 else
10238   if test -n "$OBJDUMP_FOR_TARGET"; then
10239   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10240 else
10241 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10242 for as_dir in $PATH
10243 do
10244   IFS=$as_save_IFS
10245   test -z "$as_dir" && as_dir=.
10246   for ac_exec_ext in '' $ac_executable_extensions; do
10247   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10248     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10249     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10250     break 2
10251   fi
10252 done
10253 done
10254
10255 fi
10256 fi
10257 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10258 if test -n "$OBJDUMP_FOR_TARGET"; then
10259   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10260 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10261 else
10262   echo "$as_me:$LINENO: result: no" >&5
10263 echo "${ECHO_T}no" >&6
10264 fi
10265
10266     fi
10267     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10268   done
10269 fi
10270
10271 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10272   set dummy objdump
10273   if test $build = $target ; then
10274     OBJDUMP_FOR_TARGET="$2"
10275   else
10276     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10277   fi
10278 else
10279   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10280 fi
10281
10282 else
10283   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10284 fi
10285
10286
10287
10288
10289 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10290   if test -n "$with_build_time_tools"; then
10291     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10292 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10293     if test -x $with_build_time_tools/ranlib; then
10294       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10295       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10296       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10297 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10298     else
10299       echo "$as_me:$LINENO: result: no" >&5
10300 echo "${ECHO_T}no" >&6
10301     fi
10302   elif test $build != $host && test $have_gcc_for_target = yes; then
10303     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10304     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10305     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10306   fi
10307 fi
10308 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10309   # Extract the first word of "ranlib", so it can be a program name with args.
10310 set dummy ranlib; ac_word=$2
10311 echo "$as_me:$LINENO: checking for $ac_word" >&5
10312 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10313 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10314   echo $ECHO_N "(cached) $ECHO_C" >&6
10315 else
10316   case $RANLIB_FOR_TARGET in
10317   [\\/]* | ?:[\\/]*)
10318   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10319   ;;
10320   *)
10321   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10322 for as_dir in $gcc_cv_tool_dirs
10323 do
10324   IFS=$as_save_IFS
10325   test -z "$as_dir" && as_dir=.
10326   for ac_exec_ext in '' $ac_executable_extensions; do
10327   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10328     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10329     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10330     break 2
10331   fi
10332 done
10333 done
10334
10335   ;;
10336 esac
10337 fi
10338 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10339
10340 if test -n "$RANLIB_FOR_TARGET"; then
10341   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10342 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10343 else
10344   echo "$as_me:$LINENO: result: no" >&5
10345 echo "${ECHO_T}no" >&6
10346 fi
10347
10348 fi
10349 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10350
10351
10352 if test -n "$RANLIB_FOR_TARGET"; then
10353   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10354 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10355   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10356 fi
10357
10358 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10359   for ncn_progname in ranlib; do
10360     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10361 set dummy ${ncn_progname}; ac_word=$2
10362 echo "$as_me:$LINENO: checking for $ac_word" >&5
10363 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10364 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10365   echo $ECHO_N "(cached) $ECHO_C" >&6
10366 else
10367   if test -n "$RANLIB_FOR_TARGET"; then
10368   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10369 else
10370 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10371 for as_dir in $PATH
10372 do
10373   IFS=$as_save_IFS
10374   test -z "$as_dir" && as_dir=.
10375   for ac_exec_ext in '' $ac_executable_extensions; do
10376   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10377     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10378     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10379     break 2
10380   fi
10381 done
10382 done
10383
10384 fi
10385 fi
10386 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10387 if test -n "$RANLIB_FOR_TARGET"; then
10388   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10389 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10390 else
10391   echo "$as_me:$LINENO: result: no" >&5
10392 echo "${ECHO_T}no" >&6
10393 fi
10394
10395   done
10396 fi
10397
10398 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10399   for ncn_progname in ranlib; do
10400     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10401 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10402     if test -x $with_build_time_tools/${ncn_progname}; then
10403       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10404       echo "$as_me:$LINENO: result: yes" >&5
10405 echo "${ECHO_T}yes" >&6
10406       break
10407     else
10408       echo "$as_me:$LINENO: result: no" >&5
10409 echo "${ECHO_T}no" >&6
10410     fi
10411   done
10412 fi
10413
10414 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10415   for ncn_progname in ranlib; do
10416     if test -n "$ncn_target_tool_prefix"; then
10417       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10418 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10419 echo "$as_me:$LINENO: checking for $ac_word" >&5
10420 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10421 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10422   echo $ECHO_N "(cached) $ECHO_C" >&6
10423 else
10424   if test -n "$RANLIB_FOR_TARGET"; then
10425   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10426 else
10427 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10428 for as_dir in $PATH
10429 do
10430   IFS=$as_save_IFS
10431   test -z "$as_dir" && as_dir=.
10432   for ac_exec_ext in '' $ac_executable_extensions; do
10433   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10434     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10435     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10436     break 2
10437   fi
10438 done
10439 done
10440
10441 fi
10442 fi
10443 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10444 if test -n "$RANLIB_FOR_TARGET"; then
10445   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10446 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10447 else
10448   echo "$as_me:$LINENO: result: no" >&5
10449 echo "${ECHO_T}no" >&6
10450 fi
10451
10452     fi
10453     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10454       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10455 set dummy ${ncn_progname}; ac_word=$2
10456 echo "$as_me:$LINENO: checking for $ac_word" >&5
10457 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10458 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10459   echo $ECHO_N "(cached) $ECHO_C" >&6
10460 else
10461   if test -n "$RANLIB_FOR_TARGET"; then
10462   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10463 else
10464 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10465 for as_dir in $PATH
10466 do
10467   IFS=$as_save_IFS
10468   test -z "$as_dir" && as_dir=.
10469   for ac_exec_ext in '' $ac_executable_extensions; do
10470   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10471     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10472     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10473     break 2
10474   fi
10475 done
10476 done
10477
10478 fi
10479 fi
10480 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10481 if test -n "$RANLIB_FOR_TARGET"; then
10482   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10483 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10484 else
10485   echo "$as_me:$LINENO: result: no" >&5
10486 echo "${ECHO_T}no" >&6
10487 fi
10488
10489     fi
10490     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10491   done
10492 fi
10493
10494 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10495   set dummy ranlib
10496   if test $build = $target ; then
10497     RANLIB_FOR_TARGET="$2"
10498   else
10499     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10500   fi
10501 else
10502   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10503 fi
10504
10505 else
10506   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10507 fi
10508
10509
10510
10511
10512 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10513   if test -n "$with_build_time_tools"; then
10514     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10515 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10516     if test -x $with_build_time_tools/strip; then
10517       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10518       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10519       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10520 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10521     else
10522       echo "$as_me:$LINENO: result: no" >&5
10523 echo "${ECHO_T}no" >&6
10524     fi
10525   elif test $build != $host && test $have_gcc_for_target = yes; then
10526     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10527     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10528     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10529   fi
10530 fi
10531 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10532   # Extract the first word of "strip", so it can be a program name with args.
10533 set dummy strip; ac_word=$2
10534 echo "$as_me:$LINENO: checking for $ac_word" >&5
10535 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10536 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10537   echo $ECHO_N "(cached) $ECHO_C" >&6
10538 else
10539   case $STRIP_FOR_TARGET in
10540   [\\/]* | ?:[\\/]*)
10541   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10542   ;;
10543   *)
10544   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10545 for as_dir in $gcc_cv_tool_dirs
10546 do
10547   IFS=$as_save_IFS
10548   test -z "$as_dir" && as_dir=.
10549   for ac_exec_ext in '' $ac_executable_extensions; do
10550   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10551     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10552     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10553     break 2
10554   fi
10555 done
10556 done
10557
10558   ;;
10559 esac
10560 fi
10561 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10562
10563 if test -n "$STRIP_FOR_TARGET"; then
10564   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10565 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10566 else
10567   echo "$as_me:$LINENO: result: no" >&5
10568 echo "${ECHO_T}no" >&6
10569 fi
10570
10571 fi
10572 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10573
10574
10575 if test -n "$STRIP_FOR_TARGET"; then
10576   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10577 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10578   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10579 fi
10580
10581 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10582   for ncn_progname in strip; do
10583     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10584 set dummy ${ncn_progname}; ac_word=$2
10585 echo "$as_me:$LINENO: checking for $ac_word" >&5
10586 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10587 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10588   echo $ECHO_N "(cached) $ECHO_C" >&6
10589 else
10590   if test -n "$STRIP_FOR_TARGET"; then
10591   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10592 else
10593 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10594 for as_dir in $PATH
10595 do
10596   IFS=$as_save_IFS
10597   test -z "$as_dir" && as_dir=.
10598   for ac_exec_ext in '' $ac_executable_extensions; do
10599   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10600     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10601     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10602     break 2
10603   fi
10604 done
10605 done
10606
10607 fi
10608 fi
10609 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10610 if test -n "$STRIP_FOR_TARGET"; then
10611   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10612 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10613 else
10614   echo "$as_me:$LINENO: result: no" >&5
10615 echo "${ECHO_T}no" >&6
10616 fi
10617
10618   done
10619 fi
10620
10621 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10622   for ncn_progname in strip; do
10623     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10624 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10625     if test -x $with_build_time_tools/${ncn_progname}; then
10626       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10627       echo "$as_me:$LINENO: result: yes" >&5
10628 echo "${ECHO_T}yes" >&6
10629       break
10630     else
10631       echo "$as_me:$LINENO: result: no" >&5
10632 echo "${ECHO_T}no" >&6
10633     fi
10634   done
10635 fi
10636
10637 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10638   for ncn_progname in strip; do
10639     if test -n "$ncn_target_tool_prefix"; then
10640       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10641 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10642 echo "$as_me:$LINENO: checking for $ac_word" >&5
10643 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10644 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10645   echo $ECHO_N "(cached) $ECHO_C" >&6
10646 else
10647   if test -n "$STRIP_FOR_TARGET"; then
10648   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10649 else
10650 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10651 for as_dir in $PATH
10652 do
10653   IFS=$as_save_IFS
10654   test -z "$as_dir" && as_dir=.
10655   for ac_exec_ext in '' $ac_executable_extensions; do
10656   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10657     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10658     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10659     break 2
10660   fi
10661 done
10662 done
10663
10664 fi
10665 fi
10666 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10667 if test -n "$STRIP_FOR_TARGET"; then
10668   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10669 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10670 else
10671   echo "$as_me:$LINENO: result: no" >&5
10672 echo "${ECHO_T}no" >&6
10673 fi
10674
10675     fi
10676     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10677       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10678 set dummy ${ncn_progname}; ac_word=$2
10679 echo "$as_me:$LINENO: checking for $ac_word" >&5
10680 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10681 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10682   echo $ECHO_N "(cached) $ECHO_C" >&6
10683 else
10684   if test -n "$STRIP_FOR_TARGET"; then
10685   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10686 else
10687 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10688 for as_dir in $PATH
10689 do
10690   IFS=$as_save_IFS
10691   test -z "$as_dir" && as_dir=.
10692   for ac_exec_ext in '' $ac_executable_extensions; do
10693   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10694     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10695     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10696     break 2
10697   fi
10698 done
10699 done
10700
10701 fi
10702 fi
10703 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10704 if test -n "$STRIP_FOR_TARGET"; then
10705   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10706 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10707 else
10708   echo "$as_me:$LINENO: result: no" >&5
10709 echo "${ECHO_T}no" >&6
10710 fi
10711
10712     fi
10713     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10714   done
10715 fi
10716
10717 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10718   set dummy strip
10719   if test $build = $target ; then
10720     STRIP_FOR_TARGET="$2"
10721   else
10722     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10723   fi
10724 else
10725   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10726 fi
10727
10728 else
10729   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10730 fi
10731
10732
10733
10734
10735 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10736   if test -n "$with_build_time_tools"; then
10737     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10738 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10739     if test -x $with_build_time_tools/windres; then
10740       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10741       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10742       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10743 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10744     else
10745       echo "$as_me:$LINENO: result: no" >&5
10746 echo "${ECHO_T}no" >&6
10747     fi
10748   elif test $build != $host && test $have_gcc_for_target = yes; then
10749     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10750     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10751     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10752   fi
10753 fi
10754 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10755   # Extract the first word of "windres", so it can be a program name with args.
10756 set dummy windres; ac_word=$2
10757 echo "$as_me:$LINENO: checking for $ac_word" >&5
10758 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10759 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10760   echo $ECHO_N "(cached) $ECHO_C" >&6
10761 else
10762   case $WINDRES_FOR_TARGET in
10763   [\\/]* | ?:[\\/]*)
10764   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10765   ;;
10766   *)
10767   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10768 for as_dir in $gcc_cv_tool_dirs
10769 do
10770   IFS=$as_save_IFS
10771   test -z "$as_dir" && as_dir=.
10772   for ac_exec_ext in '' $ac_executable_extensions; do
10773   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10774     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10775     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10776     break 2
10777   fi
10778 done
10779 done
10780
10781   ;;
10782 esac
10783 fi
10784 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10785
10786 if test -n "$WINDRES_FOR_TARGET"; then
10787   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10788 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10789 else
10790   echo "$as_me:$LINENO: result: no" >&5
10791 echo "${ECHO_T}no" >&6
10792 fi
10793
10794 fi
10795 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10796
10797
10798 if test -n "$WINDRES_FOR_TARGET"; then
10799   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10800 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10801   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10802 fi
10803
10804 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10805   for ncn_progname in windres; do
10806     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10807 set dummy ${ncn_progname}; ac_word=$2
10808 echo "$as_me:$LINENO: checking for $ac_word" >&5
10809 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10810 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10811   echo $ECHO_N "(cached) $ECHO_C" >&6
10812 else
10813   if test -n "$WINDRES_FOR_TARGET"; then
10814   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10815 else
10816 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10817 for as_dir in $PATH
10818 do
10819   IFS=$as_save_IFS
10820   test -z "$as_dir" && as_dir=.
10821   for ac_exec_ext in '' $ac_executable_extensions; do
10822   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10823     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10824     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10825     break 2
10826   fi
10827 done
10828 done
10829
10830 fi
10831 fi
10832 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10833 if test -n "$WINDRES_FOR_TARGET"; then
10834   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10835 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10836 else
10837   echo "$as_me:$LINENO: result: no" >&5
10838 echo "${ECHO_T}no" >&6
10839 fi
10840
10841   done
10842 fi
10843
10844 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10845   for ncn_progname in windres; do
10846     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10847 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10848     if test -x $with_build_time_tools/${ncn_progname}; then
10849       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10850       echo "$as_me:$LINENO: result: yes" >&5
10851 echo "${ECHO_T}yes" >&6
10852       break
10853     else
10854       echo "$as_me:$LINENO: result: no" >&5
10855 echo "${ECHO_T}no" >&6
10856     fi
10857   done
10858 fi
10859
10860 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10861   for ncn_progname in windres; do
10862     if test -n "$ncn_target_tool_prefix"; then
10863       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10864 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10865 echo "$as_me:$LINENO: checking for $ac_word" >&5
10866 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10867 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10868   echo $ECHO_N "(cached) $ECHO_C" >&6
10869 else
10870   if test -n "$WINDRES_FOR_TARGET"; then
10871   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10872 else
10873 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10874 for as_dir in $PATH
10875 do
10876   IFS=$as_save_IFS
10877   test -z "$as_dir" && as_dir=.
10878   for ac_exec_ext in '' $ac_executable_extensions; do
10879   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10880     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10881     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10882     break 2
10883   fi
10884 done
10885 done
10886
10887 fi
10888 fi
10889 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10890 if test -n "$WINDRES_FOR_TARGET"; then
10891   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10892 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10893 else
10894   echo "$as_me:$LINENO: result: no" >&5
10895 echo "${ECHO_T}no" >&6
10896 fi
10897
10898     fi
10899     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10900       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10901 set dummy ${ncn_progname}; ac_word=$2
10902 echo "$as_me:$LINENO: checking for $ac_word" >&5
10903 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10904 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10905   echo $ECHO_N "(cached) $ECHO_C" >&6
10906 else
10907   if test -n "$WINDRES_FOR_TARGET"; then
10908   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10909 else
10910 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10911 for as_dir in $PATH
10912 do
10913   IFS=$as_save_IFS
10914   test -z "$as_dir" && as_dir=.
10915   for ac_exec_ext in '' $ac_executable_extensions; do
10916   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10917     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10918     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10919     break 2
10920   fi
10921 done
10922 done
10923
10924 fi
10925 fi
10926 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10927 if test -n "$WINDRES_FOR_TARGET"; then
10928   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10929 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10930 else
10931   echo "$as_me:$LINENO: result: no" >&5
10932 echo "${ECHO_T}no" >&6
10933 fi
10934
10935     fi
10936     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
10937   done
10938 fi
10939
10940 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
10941   set dummy windres
10942   if test $build = $target ; then
10943     WINDRES_FOR_TARGET="$2"
10944   else
10945     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
10946   fi
10947 else
10948   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
10949 fi
10950
10951 else
10952   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10953 fi
10954
10955
10956
10957
10958 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
10959   if test -n "$with_build_time_tools"; then
10960     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
10961 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
10962     if test -x $with_build_time_tools/windmc; then
10963       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
10964       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10965       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
10966 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
10967     else
10968       echo "$as_me:$LINENO: result: no" >&5
10969 echo "${ECHO_T}no" >&6
10970     fi
10971   elif test $build != $host && test $have_gcc_for_target = yes; then
10972     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
10973     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
10974     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10975   fi
10976 fi
10977 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10978   # Extract the first word of "windmc", so it can be a program name with args.
10979 set dummy windmc; ac_word=$2
10980 echo "$as_me:$LINENO: checking for $ac_word" >&5
10981 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10982 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
10983   echo $ECHO_N "(cached) $ECHO_C" >&6
10984 else
10985   case $WINDMC_FOR_TARGET in
10986   [\\/]* | ?:[\\/]*)
10987   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
10988   ;;
10989   *)
10990   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10991 for as_dir in $gcc_cv_tool_dirs
10992 do
10993   IFS=$as_save_IFS
10994   test -z "$as_dir" && as_dir=.
10995   for ac_exec_ext in '' $ac_executable_extensions; do
10996   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10997     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10998     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10999     break 2
11000   fi
11001 done
11002 done
11003
11004   ;;
11005 esac
11006 fi
11007 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11008
11009 if test -n "$WINDMC_FOR_TARGET"; then
11010   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11011 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11012 else
11013   echo "$as_me:$LINENO: result: no" >&5
11014 echo "${ECHO_T}no" >&6
11015 fi
11016
11017 fi
11018 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11019
11020
11021 if test -n "$WINDMC_FOR_TARGET"; then
11022   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11023 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11024   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11025 fi
11026
11027 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11028   for ncn_progname in windmc; do
11029     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11030 set dummy ${ncn_progname}; ac_word=$2
11031 echo "$as_me:$LINENO: checking for $ac_word" >&5
11032 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11033 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11034   echo $ECHO_N "(cached) $ECHO_C" >&6
11035 else
11036   if test -n "$WINDMC_FOR_TARGET"; then
11037   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11038 else
11039 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11040 for as_dir in $PATH
11041 do
11042   IFS=$as_save_IFS
11043   test -z "$as_dir" && as_dir=.
11044   for ac_exec_ext in '' $ac_executable_extensions; do
11045   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11046     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11047     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11048     break 2
11049   fi
11050 done
11051 done
11052
11053 fi
11054 fi
11055 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11056 if test -n "$WINDMC_FOR_TARGET"; then
11057   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11058 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11059 else
11060   echo "$as_me:$LINENO: result: no" >&5
11061 echo "${ECHO_T}no" >&6
11062 fi
11063
11064   done
11065 fi
11066
11067 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11068   for ncn_progname in windmc; do
11069     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11070 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11071     if test -x $with_build_time_tools/${ncn_progname}; then
11072       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11073       echo "$as_me:$LINENO: result: yes" >&5
11074 echo "${ECHO_T}yes" >&6
11075       break
11076     else
11077       echo "$as_me:$LINENO: result: no" >&5
11078 echo "${ECHO_T}no" >&6
11079     fi
11080   done
11081 fi
11082
11083 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11084   for ncn_progname in windmc; do
11085     if test -n "$ncn_target_tool_prefix"; then
11086       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11087 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11088 echo "$as_me:$LINENO: checking for $ac_word" >&5
11089 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11090 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11091   echo $ECHO_N "(cached) $ECHO_C" >&6
11092 else
11093   if test -n "$WINDMC_FOR_TARGET"; then
11094   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11095 else
11096 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11097 for as_dir in $PATH
11098 do
11099   IFS=$as_save_IFS
11100   test -z "$as_dir" && as_dir=.
11101   for ac_exec_ext in '' $ac_executable_extensions; do
11102   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11103     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11104     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11105     break 2
11106   fi
11107 done
11108 done
11109
11110 fi
11111 fi
11112 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11113 if test -n "$WINDMC_FOR_TARGET"; then
11114   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11115 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11116 else
11117   echo "$as_me:$LINENO: result: no" >&5
11118 echo "${ECHO_T}no" >&6
11119 fi
11120
11121     fi
11122     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11123       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11124 set dummy ${ncn_progname}; ac_word=$2
11125 echo "$as_me:$LINENO: checking for $ac_word" >&5
11126 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11127 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11128   echo $ECHO_N "(cached) $ECHO_C" >&6
11129 else
11130   if test -n "$WINDMC_FOR_TARGET"; then
11131   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11132 else
11133 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11134 for as_dir in $PATH
11135 do
11136   IFS=$as_save_IFS
11137   test -z "$as_dir" && as_dir=.
11138   for ac_exec_ext in '' $ac_executable_extensions; do
11139   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11140     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11141     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11142     break 2
11143   fi
11144 done
11145 done
11146
11147 fi
11148 fi
11149 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11150 if test -n "$WINDMC_FOR_TARGET"; then
11151   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11152 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11153 else
11154   echo "$as_me:$LINENO: result: no" >&5
11155 echo "${ECHO_T}no" >&6
11156 fi
11157
11158     fi
11159     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11160   done
11161 fi
11162
11163 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11164   set dummy windmc
11165   if test $build = $target ; then
11166     WINDMC_FOR_TARGET="$2"
11167   else
11168     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11169   fi
11170 else
11171   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11172 fi
11173
11174 else
11175   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11176 fi
11177
11178
11179 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11180
11181 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11182 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11183 if test "x${build}" != "x${host}" ; then
11184   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11185     # We already found the complete path
11186     ac_dir=`dirname $AR_FOR_TARGET`
11187     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11188 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11189   else
11190     # Canadian cross, just use what we found
11191     echo "$as_me:$LINENO: result: pre-installed" >&5
11192 echo "${ECHO_T}pre-installed" >&6
11193   fi
11194 else
11195   ok=yes
11196   case " ${configdirs} " in
11197     *" binutils "*) ;;
11198     *) ok=no ;;
11199   esac
11200
11201   if test $ok = yes; then
11202     # An in-tree tool is available and we can use it
11203     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11204     echo "$as_me:$LINENO: result: just compiled" >&5
11205 echo "${ECHO_T}just compiled" >&6
11206   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11207     # We already found the complete path
11208     ac_dir=`dirname $AR_FOR_TARGET`
11209     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11210 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11211   elif test "x$target" = "x$host"; then
11212     # We can use an host tool
11213     AR_FOR_TARGET='$(AR)'
11214     echo "$as_me:$LINENO: result: host tool" >&5
11215 echo "${ECHO_T}host tool" >&6
11216   else
11217     # We need a cross tool
11218     echo "$as_me:$LINENO: result: pre-installed" >&5
11219 echo "${ECHO_T}pre-installed" >&6
11220   fi
11221 fi
11222
11223 echo "$as_me:$LINENO: checking where to find the target as" >&5
11224 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11225 if test "x${build}" != "x${host}" ; then
11226   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11227     # We already found the complete path
11228     ac_dir=`dirname $AS_FOR_TARGET`
11229     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11230 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11231   else
11232     # Canadian cross, just use what we found
11233     echo "$as_me:$LINENO: result: pre-installed" >&5
11234 echo "${ECHO_T}pre-installed" >&6
11235   fi
11236 else
11237   ok=yes
11238   case " ${configdirs} " in
11239     *" gas "*) ;;
11240     *) ok=no ;;
11241   esac
11242
11243   if test $ok = yes; then
11244     # An in-tree tool is available and we can use it
11245     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11246     echo "$as_me:$LINENO: result: just compiled" >&5
11247 echo "${ECHO_T}just compiled" >&6
11248   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11249     # We already found the complete path
11250     ac_dir=`dirname $AS_FOR_TARGET`
11251     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11252 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11253   elif test "x$target" = "x$host"; then
11254     # We can use an host tool
11255     AS_FOR_TARGET='$(AS)'
11256     echo "$as_me:$LINENO: result: host tool" >&5
11257 echo "${ECHO_T}host tool" >&6
11258   else
11259     # We need a cross tool
11260     echo "$as_me:$LINENO: result: pre-installed" >&5
11261 echo "${ECHO_T}pre-installed" >&6
11262   fi
11263 fi
11264
11265 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11266 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11267 if test "x${build}" != "x${host}" ; then
11268   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11269     # We already found the complete path
11270     ac_dir=`dirname $CC_FOR_TARGET`
11271     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11272 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11273   else
11274     # Canadian cross, just use what we found
11275     echo "$as_me:$LINENO: result: pre-installed" >&5
11276 echo "${ECHO_T}pre-installed" >&6
11277   fi
11278 else
11279   ok=yes
11280   case " ${configdirs} " in
11281     *" gcc "*) ;;
11282     *) ok=no ;;
11283   esac
11284
11285   if test $ok = yes; then
11286     # An in-tree tool is available and we can use it
11287     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11288     echo "$as_me:$LINENO: result: just compiled" >&5
11289 echo "${ECHO_T}just compiled" >&6
11290   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11291     # We already found the complete path
11292     ac_dir=`dirname $CC_FOR_TARGET`
11293     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11294 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11295   elif test "x$target" = "x$host"; then
11296     # We can use an host tool
11297     CC_FOR_TARGET='$(CC)'
11298     echo "$as_me:$LINENO: result: host tool" >&5
11299 echo "${ECHO_T}host tool" >&6
11300   else
11301     # We need a cross tool
11302     echo "$as_me:$LINENO: result: pre-installed" >&5
11303 echo "${ECHO_T}pre-installed" >&6
11304   fi
11305 fi
11306
11307 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11308 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11309 if test "x${build}" != "x${host}" ; then
11310   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11311     # We already found the complete path
11312     ac_dir=`dirname $CXX_FOR_TARGET`
11313     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11314 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11315   else
11316     # Canadian cross, just use what we found
11317     echo "$as_me:$LINENO: result: pre-installed" >&5
11318 echo "${ECHO_T}pre-installed" >&6
11319   fi
11320 else
11321   ok=yes
11322   case " ${configdirs} " in
11323     *" gcc "*) ;;
11324     *) ok=no ;;
11325   esac
11326   case ,${enable_languages}, in
11327     *,c++,*) ;;
11328     *) ok=no ;;
11329   esac
11330   if test $ok = yes; then
11331     # An in-tree tool is available and we can use it
11332     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'
11333     echo "$as_me:$LINENO: result: just compiled" >&5
11334 echo "${ECHO_T}just compiled" >&6
11335   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11336     # We already found the complete path
11337     ac_dir=`dirname $CXX_FOR_TARGET`
11338     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11339 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11340   elif test "x$target" = "x$host"; then
11341     # We can use an host tool
11342     CXX_FOR_TARGET='$(CXX)'
11343     echo "$as_me:$LINENO: result: host tool" >&5
11344 echo "${ECHO_T}host tool" >&6
11345   else
11346     # We need a cross tool
11347     echo "$as_me:$LINENO: result: pre-installed" >&5
11348 echo "${ECHO_T}pre-installed" >&6
11349   fi
11350 fi
11351
11352 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11353 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11354 if test "x${build}" != "x${host}" ; then
11355   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11356     # We already found the complete path
11357     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11358     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11359 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11360   else
11361     # Canadian cross, just use what we found
11362     echo "$as_me:$LINENO: result: pre-installed" >&5
11363 echo "${ECHO_T}pre-installed" >&6
11364   fi
11365 else
11366   ok=yes
11367   case " ${configdirs} " in
11368     *" gcc "*) ;;
11369     *) ok=no ;;
11370   esac
11371   case ,${enable_languages}, in
11372     *,c++,*) ;;
11373     *) ok=no ;;
11374   esac
11375   if test $ok = yes; then
11376     # An in-tree tool is available and we can use it
11377     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'
11378     echo "$as_me:$LINENO: result: just compiled" >&5
11379 echo "${ECHO_T}just compiled" >&6
11380   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11381     # We already found the complete path
11382     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11383     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11384 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11385   elif test "x$target" = "x$host"; then
11386     # We can use an host tool
11387     RAW_CXX_FOR_TARGET='$(CXX)'
11388     echo "$as_me:$LINENO: result: host tool" >&5
11389 echo "${ECHO_T}host tool" >&6
11390   else
11391     # We need a cross tool
11392     echo "$as_me:$LINENO: result: pre-installed" >&5
11393 echo "${ECHO_T}pre-installed" >&6
11394   fi
11395 fi
11396
11397 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11398 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11399 if test "x${build}" != "x${host}" ; then
11400   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11401     # We already found the complete path
11402     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11403     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11404 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11405   else
11406     # Canadian cross, just use what we found
11407     echo "$as_me:$LINENO: result: pre-installed" >&5
11408 echo "${ECHO_T}pre-installed" >&6
11409   fi
11410 else
11411   ok=yes
11412   case " ${configdirs} " in
11413     *" binutils "*) ;;
11414     *) ok=no ;;
11415   esac
11416
11417   if test $ok = yes; then
11418     # An in-tree tool is available and we can use it
11419     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11420     echo "$as_me:$LINENO: result: just compiled" >&5
11421 echo "${ECHO_T}just compiled" >&6
11422   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11423     # We already found the complete path
11424     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11425     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11426 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11427   elif test "x$target" = "x$host"; then
11428     # We can use an host tool
11429     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11430     echo "$as_me:$LINENO: result: host tool" >&5
11431 echo "${ECHO_T}host tool" >&6
11432   else
11433     # We need a cross tool
11434     echo "$as_me:$LINENO: result: pre-installed" >&5
11435 echo "${ECHO_T}pre-installed" >&6
11436   fi
11437 fi
11438
11439 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11440 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11441 if test "x${build}" != "x${host}" ; then
11442   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11443     # We already found the complete path
11444     ac_dir=`dirname $GCC_FOR_TARGET`
11445     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11446 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11447   else
11448     # Canadian cross, just use what we found
11449     echo "$as_me:$LINENO: result: pre-installed" >&5
11450 echo "${ECHO_T}pre-installed" >&6
11451   fi
11452 else
11453   ok=yes
11454   case " ${configdirs} " in
11455     *" gcc "*) ;;
11456     *) ok=no ;;
11457   esac
11458
11459   if test $ok = yes; then
11460     # An in-tree tool is available and we can use it
11461     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11462     echo "$as_me:$LINENO: result: just compiled" >&5
11463 echo "${ECHO_T}just compiled" >&6
11464   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11465     # We already found the complete path
11466     ac_dir=`dirname $GCC_FOR_TARGET`
11467     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11468 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11469   elif test "x$target" = "x$host"; then
11470     # We can use an host tool
11471     GCC_FOR_TARGET='$()'
11472     echo "$as_me:$LINENO: result: host tool" >&5
11473 echo "${ECHO_T}host tool" >&6
11474   else
11475     # We need a cross tool
11476     echo "$as_me:$LINENO: result: pre-installed" >&5
11477 echo "${ECHO_T}pre-installed" >&6
11478   fi
11479 fi
11480
11481 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11482 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11483 if test "x${build}" != "x${host}" ; then
11484   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11485     # We already found the complete path
11486     ac_dir=`dirname $GCJ_FOR_TARGET`
11487     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11488 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11489   else
11490     # Canadian cross, just use what we found
11491     echo "$as_me:$LINENO: result: pre-installed" >&5
11492 echo "${ECHO_T}pre-installed" >&6
11493   fi
11494 else
11495   ok=yes
11496   case " ${configdirs} " in
11497     *" gcc "*) ;;
11498     *) ok=no ;;
11499   esac
11500   case ,${enable_languages}, in
11501     *,java,*) ;;
11502     *) ok=no ;;
11503   esac
11504   if test $ok = yes; then
11505     # An in-tree tool is available and we can use it
11506     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11507     echo "$as_me:$LINENO: result: just compiled" >&5
11508 echo "${ECHO_T}just compiled" >&6
11509   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11510     # We already found the complete path
11511     ac_dir=`dirname $GCJ_FOR_TARGET`
11512     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11513 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11514   elif test "x$target" = "x$host"; then
11515     # We can use an host tool
11516     GCJ_FOR_TARGET='$(GCJ)'
11517     echo "$as_me:$LINENO: result: host tool" >&5
11518 echo "${ECHO_T}host tool" >&6
11519   else
11520     # We need a cross tool
11521     echo "$as_me:$LINENO: result: pre-installed" >&5
11522 echo "${ECHO_T}pre-installed" >&6
11523   fi
11524 fi
11525
11526 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11527 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11528 if test "x${build}" != "x${host}" ; then
11529   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11530     # We already found the complete path
11531     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11532     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11533 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11534   else
11535     # Canadian cross, just use what we found
11536     echo "$as_me:$LINENO: result: pre-installed" >&5
11537 echo "${ECHO_T}pre-installed" >&6
11538   fi
11539 else
11540   ok=yes
11541   case " ${configdirs} " in
11542     *" gcc "*) ;;
11543     *) ok=no ;;
11544   esac
11545   case ,${enable_languages}, in
11546     *,fortran,*) ;;
11547     *) ok=no ;;
11548   esac
11549   if test $ok = yes; then
11550     # An in-tree tool is available and we can use it
11551     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11552     echo "$as_me:$LINENO: result: just compiled" >&5
11553 echo "${ECHO_T}just compiled" >&6
11554   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11555     # We already found the complete path
11556     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11557     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11558 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11559   elif test "x$target" = "x$host"; then
11560     # We can use an host tool
11561     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11562     echo "$as_me:$LINENO: result: host tool" >&5
11563 echo "${ECHO_T}host tool" >&6
11564   else
11565     # We need a cross tool
11566     echo "$as_me:$LINENO: result: pre-installed" >&5
11567 echo "${ECHO_T}pre-installed" >&6
11568   fi
11569 fi
11570
11571 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11572 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11573 if test "x${build}" != "x${host}" ; then
11574   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11575     # We already found the complete path
11576     ac_dir=`dirname $LD_FOR_TARGET`
11577     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11578 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11579   else
11580     # Canadian cross, just use what we found
11581     echo "$as_me:$LINENO: result: pre-installed" >&5
11582 echo "${ECHO_T}pre-installed" >&6
11583   fi
11584 else
11585   ok=yes
11586   case " ${configdirs} " in
11587     *" ld "*) ;;
11588     *) ok=no ;;
11589   esac
11590
11591   if test $ok = yes; then
11592     # An in-tree tool is available and we can use it
11593     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11594     echo "$as_me:$LINENO: result: just compiled" >&5
11595 echo "${ECHO_T}just compiled" >&6
11596   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11597     # We already found the complete path
11598     ac_dir=`dirname $LD_FOR_TARGET`
11599     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11600 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11601   elif test "x$target" = "x$host"; then
11602     # We can use an host tool
11603     LD_FOR_TARGET='$(LD)'
11604     echo "$as_me:$LINENO: result: host tool" >&5
11605 echo "${ECHO_T}host tool" >&6
11606   else
11607     # We need a cross tool
11608     echo "$as_me:$LINENO: result: pre-installed" >&5
11609 echo "${ECHO_T}pre-installed" >&6
11610   fi
11611 fi
11612
11613 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11614 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11615 if test "x${build}" != "x${host}" ; then
11616   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11617     # We already found the complete path
11618     ac_dir=`dirname $LIPO_FOR_TARGET`
11619     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11620 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11621   else
11622     # Canadian cross, just use what we found
11623     echo "$as_me:$LINENO: result: pre-installed" >&5
11624 echo "${ECHO_T}pre-installed" >&6
11625   fi
11626 else
11627   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11628     # We already found the complete path
11629     ac_dir=`dirname $LIPO_FOR_TARGET`
11630     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11631 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11632   elif test "x$target" = "x$host"; then
11633     # We can use an host tool
11634     LIPO_FOR_TARGET='$(LIPO)'
11635     echo "$as_me:$LINENO: result: host tool" >&5
11636 echo "${ECHO_T}host tool" >&6
11637   else
11638     # We need a cross tool
11639     echo "$as_me:$LINENO: result: pre-installed" >&5
11640 echo "${ECHO_T}pre-installed" >&6
11641   fi
11642 fi
11643
11644 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11645 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11646 if test "x${build}" != "x${host}" ; then
11647   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11648     # We already found the complete path
11649     ac_dir=`dirname $NM_FOR_TARGET`
11650     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11651 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11652   else
11653     # Canadian cross, just use what we found
11654     echo "$as_me:$LINENO: result: pre-installed" >&5
11655 echo "${ECHO_T}pre-installed" >&6
11656   fi
11657 else
11658   ok=yes
11659   case " ${configdirs} " in
11660     *" binutils "*) ;;
11661     *) ok=no ;;
11662   esac
11663
11664   if test $ok = yes; then
11665     # An in-tree tool is available and we can use it
11666     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11667     echo "$as_me:$LINENO: result: just compiled" >&5
11668 echo "${ECHO_T}just compiled" >&6
11669   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11670     # We already found the complete path
11671     ac_dir=`dirname $NM_FOR_TARGET`
11672     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11673 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11674   elif test "x$target" = "x$host"; then
11675     # We can use an host tool
11676     NM_FOR_TARGET='$(NM)'
11677     echo "$as_me:$LINENO: result: host tool" >&5
11678 echo "${ECHO_T}host tool" >&6
11679   else
11680     # We need a cross tool
11681     echo "$as_me:$LINENO: result: pre-installed" >&5
11682 echo "${ECHO_T}pre-installed" >&6
11683   fi
11684 fi
11685
11686 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11687 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11688 if test "x${build}" != "x${host}" ; then
11689   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11690     # We already found the complete path
11691     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11692     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11693 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11694   else
11695     # Canadian cross, just use what we found
11696     echo "$as_me:$LINENO: result: pre-installed" >&5
11697 echo "${ECHO_T}pre-installed" >&6
11698   fi
11699 else
11700   ok=yes
11701   case " ${configdirs} " in
11702     *" binutils "*) ;;
11703     *) ok=no ;;
11704   esac
11705
11706   if test $ok = yes; then
11707     # An in-tree tool is available and we can use it
11708     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11709     echo "$as_me:$LINENO: result: just compiled" >&5
11710 echo "${ECHO_T}just compiled" >&6
11711   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11712     # We already found the complete path
11713     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11714     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11715 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11716   elif test "x$target" = "x$host"; then
11717     # We can use an host tool
11718     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11719     echo "$as_me:$LINENO: result: host tool" >&5
11720 echo "${ECHO_T}host tool" >&6
11721   else
11722     # We need a cross tool
11723     echo "$as_me:$LINENO: result: pre-installed" >&5
11724 echo "${ECHO_T}pre-installed" >&6
11725   fi
11726 fi
11727
11728 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11729 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11730 if test "x${build}" != "x${host}" ; then
11731   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11732     # We already found the complete path
11733     ac_dir=`dirname $RANLIB_FOR_TARGET`
11734     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11735 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11736   else
11737     # Canadian cross, just use what we found
11738     echo "$as_me:$LINENO: result: pre-installed" >&5
11739 echo "${ECHO_T}pre-installed" >&6
11740   fi
11741 else
11742   ok=yes
11743   case " ${configdirs} " in
11744     *" binutils "*) ;;
11745     *) ok=no ;;
11746   esac
11747
11748   if test $ok = yes; then
11749     # An in-tree tool is available and we can use it
11750     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11751     echo "$as_me:$LINENO: result: just compiled" >&5
11752 echo "${ECHO_T}just compiled" >&6
11753   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11754     # We already found the complete path
11755     ac_dir=`dirname $RANLIB_FOR_TARGET`
11756     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11757 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11758   elif test "x$target" = "x$host"; then
11759     # We can use an host tool
11760     RANLIB_FOR_TARGET='$(RANLIB)'
11761     echo "$as_me:$LINENO: result: host tool" >&5
11762 echo "${ECHO_T}host tool" >&6
11763   else
11764     # We need a cross tool
11765     echo "$as_me:$LINENO: result: pre-installed" >&5
11766 echo "${ECHO_T}pre-installed" >&6
11767   fi
11768 fi
11769
11770 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11771 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11772 if test "x${build}" != "x${host}" ; then
11773   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11774     # We already found the complete path
11775     ac_dir=`dirname $STRIP_FOR_TARGET`
11776     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11777 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11778   else
11779     # Canadian cross, just use what we found
11780     echo "$as_me:$LINENO: result: pre-installed" >&5
11781 echo "${ECHO_T}pre-installed" >&6
11782   fi
11783 else
11784   ok=yes
11785   case " ${configdirs} " in
11786     *" binutils "*) ;;
11787     *) ok=no ;;
11788   esac
11789
11790   if test $ok = yes; then
11791     # An in-tree tool is available and we can use it
11792     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11793     echo "$as_me:$LINENO: result: just compiled" >&5
11794 echo "${ECHO_T}just compiled" >&6
11795   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11796     # We already found the complete path
11797     ac_dir=`dirname $STRIP_FOR_TARGET`
11798     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11799 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11800   elif test "x$target" = "x$host"; then
11801     # We can use an host tool
11802     STRIP_FOR_TARGET='$(STRIP)'
11803     echo "$as_me:$LINENO: result: host tool" >&5
11804 echo "${ECHO_T}host tool" >&6
11805   else
11806     # We need a cross tool
11807     echo "$as_me:$LINENO: result: pre-installed" >&5
11808 echo "${ECHO_T}pre-installed" >&6
11809   fi
11810 fi
11811
11812 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11813 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11814 if test "x${build}" != "x${host}" ; then
11815   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11816     # We already found the complete path
11817     ac_dir=`dirname $WINDRES_FOR_TARGET`
11818     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11819 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11820   else
11821     # Canadian cross, just use what we found
11822     echo "$as_me:$LINENO: result: pre-installed" >&5
11823 echo "${ECHO_T}pre-installed" >&6
11824   fi
11825 else
11826   ok=yes
11827   case " ${configdirs} " in
11828     *" binutils "*) ;;
11829     *) ok=no ;;
11830   esac
11831
11832   if test $ok = yes; then
11833     # An in-tree tool is available and we can use it
11834     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11835     echo "$as_me:$LINENO: result: just compiled" >&5
11836 echo "${ECHO_T}just compiled" >&6
11837   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11838     # We already found the complete path
11839     ac_dir=`dirname $WINDRES_FOR_TARGET`
11840     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11841 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11842   elif test "x$target" = "x$host"; then
11843     # We can use an host tool
11844     WINDRES_FOR_TARGET='$(WINDRES)'
11845     echo "$as_me:$LINENO: result: host tool" >&5
11846 echo "${ECHO_T}host tool" >&6
11847   else
11848     # We need a cross tool
11849     echo "$as_me:$LINENO: result: pre-installed" >&5
11850 echo "${ECHO_T}pre-installed" >&6
11851   fi
11852 fi
11853
11854 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
11855 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
11856 if test "x${build}" != "x${host}" ; then
11857   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11858     # We already found the complete path
11859     ac_dir=`dirname $WINDMC_FOR_TARGET`
11860     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11861 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11862   else
11863     # Canadian cross, just use what we found
11864     echo "$as_me:$LINENO: result: pre-installed" >&5
11865 echo "${ECHO_T}pre-installed" >&6
11866   fi
11867 else
11868   ok=yes
11869   case " ${configdirs} " in
11870     *" binutils "*) ;;
11871     *) ok=no ;;
11872   esac
11873
11874   if test $ok = yes; then
11875     # An in-tree tool is available and we can use it
11876     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
11877     echo "$as_me:$LINENO: result: just compiled" >&5
11878 echo "${ECHO_T}just compiled" >&6
11879   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11880     # We already found the complete path
11881     ac_dir=`dirname $WINDMC_FOR_TARGET`
11882     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11883 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11884   elif test "x$target" = "x$host"; then
11885     # We can use an host tool
11886     WINDMC_FOR_TARGET='$(WINDMC)'
11887     echo "$as_me:$LINENO: result: host tool" >&5
11888 echo "${ECHO_T}host tool" >&6
11889   else
11890     # We need a cross tool
11891     echo "$as_me:$LINENO: result: pre-installed" >&5
11892 echo "${ECHO_T}pre-installed" >&6
11893   fi
11894 fi
11895
11896
11897
11898
11899
11900 # Certain tools may need extra flags.
11901 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11902 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11903 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11904
11905 # When building target libraries, except in a Canadian cross, we use
11906 # the same toolchain as the compiler we just built.
11907 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11908 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11909 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11910 if test $host = $build; then
11911   case " $configdirs " in
11912     *" gcc "*)
11913       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11914       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11915       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11916       ;;
11917   esac
11918 fi
11919
11920
11921
11922
11923
11924 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
11925 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
11926 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
11927 if test "${enable_maintainer_mode+set}" = set; then
11928   enableval="$enable_maintainer_mode"
11929   USE_MAINTAINER_MODE=$enableval
11930 else
11931   USE_MAINTAINER_MODE=no
11932 fi;
11933 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
11934 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
11935
11936
11937 if test "$USE_MAINTAINER_MODE" = yes; then
11938   MAINTAINER_MODE_TRUE=
11939   MAINTAINER_MODE_FALSE='#'
11940 else
11941   MAINTAINER_MODE_TRUE='#'
11942   MAINTAINER_MODE_FALSE=
11943 fi
11944 MAINT=$MAINTAINER_MODE_TRUE
11945
11946 # ---------------------
11947 # GCC bootstrap support
11948 # ---------------------
11949
11950 # Stage specific cflags for build.
11951 stage1_cflags="-g"
11952 case $build in
11953   vax-*-*)
11954     case ${GCC} in
11955       yes) stage1_cflags="-g -Wa,-J" ;;
11956       *) stage1_cflags="-g -J" ;;
11957     esac ;;
11958 esac
11959
11960 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
11961 if test "$GCC" = yes; then
11962   saved_CFLAGS="$CFLAGS"
11963
11964   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
11965   CFLAGS="$CFLAGS -fkeep-inline-functions"
11966   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
11967 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
11968   cat >conftest.$ac_ext <<_ACEOF
11969 /* confdefs.h.  */
11970 _ACEOF
11971 cat confdefs.h >>conftest.$ac_ext
11972 cat >>conftest.$ac_ext <<_ACEOF
11973 /* end confdefs.h.  */
11974
11975 #if (__GNUC__ < 3) \
11976     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
11977                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
11978 #error http://gcc.gnu.org/PR29382
11979 #endif
11980
11981 int
11982 main ()
11983 {
11984
11985   ;
11986   return 0;
11987 }
11988 _ACEOF
11989 rm -f conftest.$ac_objext
11990 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11991   (eval $ac_compile) 2>conftest.er1
11992   ac_status=$?
11993   grep -v '^ *+' conftest.er1 >conftest.err
11994   rm -f conftest.er1
11995   cat conftest.err >&5
11996   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11997   (exit $ac_status); } &&
11998          { ac_try='test -z "$ac_c_werror_flag"
11999                          || test ! -s conftest.err'
12000   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12001   (eval $ac_try) 2>&5
12002   ac_status=$?
12003   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12004   (exit $ac_status); }; } &&
12005          { ac_try='test -s conftest.$ac_objext'
12006   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12007   (eval $ac_try) 2>&5
12008   ac_status=$?
12009   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12010   (exit $ac_status); }; }; then
12011   echo "$as_me:$LINENO: result: yes" >&5
12012 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12013 else
12014   echo "$as_me: failed program was:" >&5
12015 sed 's/^/| /' conftest.$ac_ext >&5
12016
12017 echo "$as_me:$LINENO: result: no" >&5
12018 echo "${ECHO_T}no" >&6
12019 fi
12020 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12021
12022   CFLAGS="$saved_CFLAGS"
12023 fi
12024
12025
12026
12027 # Enable --enable-checking in stage1 of the compiler.
12028 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12029 if test "${enable_stage1_checking+set}" = set; then
12030   enableval="$enable_stage1_checking"
12031   stage1_checking=--enable-checking=${enable_stage1_checking}
12032 else
12033   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12034   stage1_checking=--enable-checking=yes,types
12035 else
12036   stage1_checking=--enable-checking=$enable_checking,types
12037 fi
12038 fi;
12039
12040
12041 # Enable -Werror in bootstrap stage2 and later.
12042 # Check whether --enable-werror or --disable-werror was given.
12043 if test "${enable_werror+set}" = set; then
12044   enableval="$enable_werror"
12045
12046 else
12047   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12048   enable_werror=yes
12049 else
12050   enable_werror=no
12051 fi
12052 fi;
12053 case ${enable_werror} in
12054   yes) stage2_werror_flag="--enable-werror-always" ;;
12055   *) stage2_werror_flag="" ;;
12056 esac
12057
12058
12059 # Flags needed to enable html installing and building
12060
12061 # Check whether --with-datarootdir or --without-datarootdir was given.
12062 if test "${with_datarootdir+set}" = set; then
12063   withval="$with_datarootdir"
12064   datarootdir="\${prefix}/${withval}"
12065 else
12066   datarootdir="\${prefix}/share"
12067 fi;
12068
12069
12070 # Check whether --with-docdir or --without-docdir was given.
12071 if test "${with_docdir+set}" = set; then
12072   withval="$with_docdir"
12073   docdir="\${prefix}/${withval}"
12074 else
12075   docdir="\${datarootdir}/doc"
12076 fi;
12077
12078
12079 # Check whether --with-pdfdir or --without-pdfdir was given.
12080 if test "${with_pdfdir+set}" = set; then
12081   withval="$with_pdfdir"
12082   pdfdir="\${prefix}/${withval}"
12083 else
12084   pdfdir="\${docdir}"
12085 fi;
12086
12087
12088 # Check whether --with-htmldir or --without-htmldir was given.
12089 if test "${with_htmldir+set}" = set; then
12090   withval="$with_htmldir"
12091   htmldir="\${prefix}/${withval}"
12092 else
12093   htmldir="\${docdir}"
12094 fi;
12095
12096
12097
12098
12099
12100
12101           ac_config_files="$ac_config_files Makefile"
12102 cat >confcache <<\_ACEOF
12103 # This file is a shell script that caches the results of configure
12104 # tests run on this system so they can be shared between configure
12105 # scripts and configure runs, see configure's option --config-cache.
12106 # It is not useful on other systems.  If it contains results you don't
12107 # want to keep, you may remove or edit it.
12108 #
12109 # config.status only pays attention to the cache file if you give it
12110 # the --recheck option to rerun configure.
12111 #
12112 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12113 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12114 # following values.
12115
12116 _ACEOF
12117
12118 # The following way of writing the cache mishandles newlines in values,
12119 # but we know of no workaround that is simple, portable, and efficient.
12120 # So, don't put newlines in cache variables' values.
12121 # Ultrix sh set writes to stderr and can't be redirected directly,
12122 # and sets the high bit in the cache file unless we assign to the vars.
12123 {
12124   (set) 2>&1 |
12125     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12126     *ac_space=\ *)
12127       # `set' does not quote correctly, so add quotes (double-quote
12128       # substitution turns \\\\ into \\, and sed turns \\ into \).
12129       sed -n \
12130         "s/'/'\\\\''/g;
12131           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12132       ;;
12133     *)
12134       # `set' quotes correctly as required by POSIX, so do not add quotes.
12135       sed -n \
12136         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12137       ;;
12138     esac;
12139 } |
12140   sed '
12141      t clear
12142      : clear
12143      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12144      t end
12145      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12146      : end' >>confcache
12147 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12148   if test -w $cache_file; then
12149     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12150     cat confcache >$cache_file
12151   else
12152     echo "not updating unwritable cache $cache_file"
12153   fi
12154 fi
12155 rm -f confcache
12156
12157 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12158 # Let make expand exec_prefix.
12159 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12160
12161 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12162 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12163 # trailing colons and then remove the whole line if VPATH becomes empty
12164 # (actually we leave an empty line to preserve line numbers).
12165 if test "x$srcdir" = x.; then
12166   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12167 s/:*\$(srcdir):*/:/;
12168 s/:*\${srcdir}:*/:/;
12169 s/:*@srcdir@:*/:/;
12170 s/^\([^=]*=[     ]*\):*/\1/;
12171 s/:*$//;
12172 s/^[^=]*=[       ]*$//;
12173 }'
12174 fi
12175
12176 # Transform confdefs.h into DEFS.
12177 # Protect against shell expansion while executing Makefile rules.
12178 # Protect against Makefile macro expansion.
12179 #
12180 # If the first sed substitution is executed (which looks for macros that
12181 # take arguments), then we branch to the quote section.  Otherwise,
12182 # look for a macro that doesn't take arguments.
12183 cat >confdef2opt.sed <<\_ACEOF
12184 t clear
12185 : clear
12186 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12187 t quote
12188 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12189 t quote
12190 d
12191 : quote
12192 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12193 s,\[,\\&,g
12194 s,\],\\&,g
12195 s,\$,$$,g
12196 p
12197 _ACEOF
12198 # We use echo to avoid assuming a particular line-breaking character.
12199 # The extra dot is to prevent the shell from consuming trailing
12200 # line-breaks from the sub-command output.  A line-break within
12201 # single-quotes doesn't work because, if this script is created in a
12202 # platform that uses two characters for line-breaks (e.g., DOS), tr
12203 # would break.
12204 ac_LF_and_DOT=`echo; echo .`
12205 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12206 rm -f confdef2opt.sed
12207
12208
12209 ac_libobjs=
12210 ac_ltlibobjs=
12211 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12212   # 1. Remove the extension, and $U if already installed.
12213   ac_i=`echo "$ac_i" |
12214          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12215   # 2. Add them.
12216   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12217   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12218 done
12219 LIBOBJS=$ac_libobjs
12220
12221 LTLIBOBJS=$ac_ltlibobjs
12222
12223
12224
12225 : ${CONFIG_STATUS=./config.status}
12226 ac_clean_files_save=$ac_clean_files
12227 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12228 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12229 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12230 cat >$CONFIG_STATUS <<_ACEOF
12231 #! $SHELL
12232 # Generated by $as_me.
12233 # Run this file to recreate the current configuration.
12234 # Compiler output produced by configure, useful for debugging
12235 # configure, is in config.log if it exists.
12236
12237 debug=false
12238 ac_cs_recheck=false
12239 ac_cs_silent=false
12240 SHELL=\${CONFIG_SHELL-$SHELL}
12241 _ACEOF
12242
12243 cat >>$CONFIG_STATUS <<\_ACEOF
12244 ## --------------------- ##
12245 ## M4sh Initialization.  ##
12246 ## --------------------- ##
12247
12248 # Be Bourne compatible
12249 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12250   emulate sh
12251   NULLCMD=:
12252   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12253   # is contrary to our usage.  Disable this feature.
12254   alias -g '${1+"$@"}'='"$@"'
12255 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12256   set -o posix
12257 fi
12258 DUALCASE=1; export DUALCASE # for MKS sh
12259
12260 # Support unset when possible.
12261 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12262   as_unset=unset
12263 else
12264   as_unset=false
12265 fi
12266
12267
12268 # Work around bugs in pre-3.0 UWIN ksh.
12269 $as_unset ENV MAIL MAILPATH
12270 PS1='$ '
12271 PS2='> '
12272 PS4='+ '
12273
12274 # NLS nuisances.
12275 for as_var in \
12276   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12277   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12278   LC_TELEPHONE LC_TIME
12279 do
12280   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12281     eval $as_var=C; export $as_var
12282   else
12283     $as_unset $as_var
12284   fi
12285 done
12286
12287 # Required to use basename.
12288 if expr a : '\(a\)' >/dev/null 2>&1; then
12289   as_expr=expr
12290 else
12291   as_expr=false
12292 fi
12293
12294 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12295   as_basename=basename
12296 else
12297   as_basename=false
12298 fi
12299
12300
12301 # Name of the executable.
12302 as_me=`$as_basename "$0" ||
12303 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12304          X"$0" : 'X\(//\)$' \| \
12305          X"$0" : 'X\(/\)$' \| \
12306          .     : '\(.\)' 2>/dev/null ||
12307 echo X/"$0" |
12308     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12309           /^X\/\(\/\/\)$/{ s//\1/; q; }
12310           /^X\/\(\/\).*/{ s//\1/; q; }
12311           s/.*/./; q'`
12312
12313
12314 # PATH needs CR, and LINENO needs CR and PATH.
12315 # Avoid depending upon Character Ranges.
12316 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12317 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12318 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12319 as_cr_digits='0123456789'
12320 as_cr_alnum=$as_cr_Letters$as_cr_digits
12321
12322 # The user is always right.
12323 if test "${PATH_SEPARATOR+set}" != set; then
12324   echo "#! /bin/sh" >conf$$.sh
12325   echo  "exit 0"   >>conf$$.sh
12326   chmod +x conf$$.sh
12327   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12328     PATH_SEPARATOR=';'
12329   else
12330     PATH_SEPARATOR=:
12331   fi
12332   rm -f conf$$.sh
12333 fi
12334
12335
12336   as_lineno_1=$LINENO
12337   as_lineno_2=$LINENO
12338   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12339   test "x$as_lineno_1" != "x$as_lineno_2" &&
12340   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12341   # Find who we are.  Look in the path if we contain no path at all
12342   # relative or not.
12343   case $0 in
12344     *[\\/]* ) as_myself=$0 ;;
12345     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12346 for as_dir in $PATH
12347 do
12348   IFS=$as_save_IFS
12349   test -z "$as_dir" && as_dir=.
12350   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12351 done
12352
12353        ;;
12354   esac
12355   # We did not find ourselves, most probably we were run as `sh COMMAND'
12356   # in which case we are not to be found in the path.
12357   if test "x$as_myself" = x; then
12358     as_myself=$0
12359   fi
12360   if test ! -f "$as_myself"; then
12361     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12362 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12363    { (exit 1); exit 1; }; }
12364   fi
12365   case $CONFIG_SHELL in
12366   '')
12367     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12368 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12369 do
12370   IFS=$as_save_IFS
12371   test -z "$as_dir" && as_dir=.
12372   for as_base in sh bash ksh sh5; do
12373          case $as_dir in
12374          /*)
12375            if ("$as_dir/$as_base" -c '
12376   as_lineno_1=$LINENO
12377   as_lineno_2=$LINENO
12378   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12379   test "x$as_lineno_1" != "x$as_lineno_2" &&
12380   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12381              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12382              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12383              CONFIG_SHELL=$as_dir/$as_base
12384              export CONFIG_SHELL
12385              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12386            fi;;
12387          esac
12388        done
12389 done
12390 ;;
12391   esac
12392
12393   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12394   # uniformly replaced by the line number.  The first 'sed' inserts a
12395   # line-number line before each line; the second 'sed' does the real
12396   # work.  The second script uses 'N' to pair each line-number line
12397   # with the numbered line, and appends trailing '-' during
12398   # substitution so that $LINENO is not a special case at line end.
12399   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12400   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12401   sed '=' <$as_myself |
12402     sed '
12403       N
12404       s,$,-,
12405       : loop
12406       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12407       t loop
12408       s,-$,,
12409       s,^['$as_cr_digits']*\n,,
12410     ' >$as_me.lineno &&
12411   chmod +x $as_me.lineno ||
12412     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12413 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12414    { (exit 1); exit 1; }; }
12415
12416   # Don't try to exec as it changes $[0], causing all sort of problems
12417   # (the dirname of $[0] is not the place where we might find the
12418   # original and so on.  Autoconf is especially sensible to this).
12419   . ./$as_me.lineno
12420   # Exit status is that of the last command.
12421   exit
12422 }
12423
12424
12425 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12426   *c*,-n*) ECHO_N= ECHO_C='
12427 ' ECHO_T='      ' ;;
12428   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12429   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12430 esac
12431
12432 if expr a : '\(a\)' >/dev/null 2>&1; then
12433   as_expr=expr
12434 else
12435   as_expr=false
12436 fi
12437
12438 rm -f conf$$ conf$$.exe conf$$.file
12439 echo >conf$$.file
12440 if ln -s conf$$.file conf$$ 2>/dev/null; then
12441   # We could just check for DJGPP; but this test a) works b) is more generic
12442   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12443   if test -f conf$$.exe; then
12444     # Don't use ln at all; we don't have any links
12445     as_ln_s='cp -p'
12446   else
12447     as_ln_s='ln -s'
12448   fi
12449 elif ln conf$$.file conf$$ 2>/dev/null; then
12450   as_ln_s=ln
12451 else
12452   as_ln_s='cp -p'
12453 fi
12454 rm -f conf$$ conf$$.exe conf$$.file
12455
12456 if mkdir -p . 2>/dev/null; then
12457   as_mkdir_p=:
12458 else
12459   test -d ./-p && rmdir ./-p
12460   as_mkdir_p=false
12461 fi
12462
12463 as_executable_p="test -f"
12464
12465 # Sed expression to map a string onto a valid CPP name.
12466 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12467
12468 # Sed expression to map a string onto a valid variable name.
12469 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12470
12471
12472 # IFS
12473 # We need space, tab and new line, in precisely that order.
12474 as_nl='
12475 '
12476 IFS="   $as_nl"
12477
12478 # CDPATH.
12479 $as_unset CDPATH
12480
12481 exec 6>&1
12482
12483 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12484 # report actual input values of CONFIG_FILES etc. instead of their
12485 # values after options handling.  Logging --version etc. is OK.
12486 exec 5>>config.log
12487 {
12488   echo
12489   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12490 ## Running $as_me. ##
12491 _ASBOX
12492 } >&5
12493 cat >&5 <<_CSEOF
12494
12495 This file was extended by $as_me, which was
12496 generated by GNU Autoconf 2.59.  Invocation command line was
12497
12498   CONFIG_FILES    = $CONFIG_FILES
12499   CONFIG_HEADERS  = $CONFIG_HEADERS
12500   CONFIG_LINKS    = $CONFIG_LINKS
12501   CONFIG_COMMANDS = $CONFIG_COMMANDS
12502   $ $0 $@
12503
12504 _CSEOF
12505 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12506 echo >&5
12507 _ACEOF
12508
12509 # Files that config.status was made for.
12510 if test -n "$ac_config_files"; then
12511   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12512 fi
12513
12514 if test -n "$ac_config_headers"; then
12515   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12516 fi
12517
12518 if test -n "$ac_config_links"; then
12519   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12520 fi
12521
12522 if test -n "$ac_config_commands"; then
12523   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12524 fi
12525
12526 cat >>$CONFIG_STATUS <<\_ACEOF
12527
12528 ac_cs_usage="\
12529 \`$as_me' instantiates files from templates according to the
12530 current configuration.
12531
12532 Usage: $0 [OPTIONS] [FILE]...
12533
12534   -h, --help       print this help, then exit
12535   -V, --version    print version number, then exit
12536   -q, --quiet      do not print progress messages
12537   -d, --debug      don't remove temporary files
12538       --recheck    update $as_me by reconfiguring in the same conditions
12539   --file=FILE[:TEMPLATE]
12540                    instantiate the configuration file FILE
12541
12542 Configuration files:
12543 $config_files
12544
12545 Report bugs to <bug-autoconf@gnu.org>."
12546 _ACEOF
12547
12548 cat >>$CONFIG_STATUS <<_ACEOF
12549 ac_cs_version="\\
12550 config.status
12551 configured by $0, generated by GNU Autoconf 2.59,
12552   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12553
12554 Copyright (C) 2003 Free Software Foundation, Inc.
12555 This config.status script is free software; the Free Software Foundation
12556 gives unlimited permission to copy, distribute and modify it."
12557 srcdir=$srcdir
12558 INSTALL="$INSTALL"
12559 _ACEOF
12560
12561 cat >>$CONFIG_STATUS <<\_ACEOF
12562 # If no file are specified by the user, then we need to provide default
12563 # value.  By we need to know if files were specified by the user.
12564 ac_need_defaults=:
12565 while test $# != 0
12566 do
12567   case $1 in
12568   --*=*)
12569     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12570     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12571     ac_shift=:
12572     ;;
12573   -*)
12574     ac_option=$1
12575     ac_optarg=$2
12576     ac_shift=shift
12577     ;;
12578   *) # This is not an option, so the user has probably given explicit
12579      # arguments.
12580      ac_option=$1
12581      ac_need_defaults=false;;
12582   esac
12583
12584   case $ac_option in
12585   # Handling of the options.
12586 _ACEOF
12587 cat >>$CONFIG_STATUS <<\_ACEOF
12588   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12589     ac_cs_recheck=: ;;
12590   --version | --vers* | -V )
12591     echo "$ac_cs_version"; exit 0 ;;
12592   --he | --h)
12593     # Conflict between --help and --header
12594     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12595 Try \`$0 --help' for more information." >&5
12596 echo "$as_me: error: ambiguous option: $1
12597 Try \`$0 --help' for more information." >&2;}
12598    { (exit 1); exit 1; }; };;
12599   --help | --hel | -h )
12600     echo "$ac_cs_usage"; exit 0 ;;
12601   --debug | --d* | -d )
12602     debug=: ;;
12603   --file | --fil | --fi | --f )
12604     $ac_shift
12605     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12606     ac_need_defaults=false;;
12607   --header | --heade | --head | --hea )
12608     $ac_shift
12609     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12610     ac_need_defaults=false;;
12611   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12612   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12613     ac_cs_silent=: ;;
12614
12615   # This is an error.
12616   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12617 Try \`$0 --help' for more information." >&5
12618 echo "$as_me: error: unrecognized option: $1
12619 Try \`$0 --help' for more information." >&2;}
12620    { (exit 1); exit 1; }; } ;;
12621
12622   *) ac_config_targets="$ac_config_targets $1" ;;
12623
12624   esac
12625   shift
12626 done
12627
12628 ac_configure_extra_args=
12629
12630 if $ac_cs_silent; then
12631   exec 6>/dev/null
12632   ac_configure_extra_args="$ac_configure_extra_args --silent"
12633 fi
12634
12635 _ACEOF
12636 cat >>$CONFIG_STATUS <<_ACEOF
12637 if \$ac_cs_recheck; then
12638   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12639   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12640 fi
12641
12642 _ACEOF
12643
12644
12645
12646
12647
12648 cat >>$CONFIG_STATUS <<\_ACEOF
12649 for ac_config_target in $ac_config_targets
12650 do
12651   case "$ac_config_target" in
12652   # Handling of arguments.
12653   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12654   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12655 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12656    { (exit 1); exit 1; }; };;
12657   esac
12658 done
12659
12660 # If the user did not use the arguments to specify the items to instantiate,
12661 # then the envvar interface is used.  Set only those that are not.
12662 # We use the long form for the default assignment because of an extremely
12663 # bizarre bug on SunOS 4.1.3.
12664 if $ac_need_defaults; then
12665   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12666 fi
12667
12668 # Have a temporary directory for convenience.  Make it in the build tree
12669 # simply because there is no reason to put it here, and in addition,
12670 # creating and moving files from /tmp can sometimes cause problems.
12671 # Create a temporary directory, and hook for its removal unless debugging.
12672 $debug ||
12673 {
12674   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12675   trap '{ (exit 1); exit 1; }' 1 2 13 15
12676 }
12677
12678 # Create a (secure) tmp directory for tmp files.
12679
12680 {
12681   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12682   test -n "$tmp" && test -d "$tmp"
12683 }  ||
12684 {
12685   tmp=./confstat$$-$RANDOM
12686   (umask 077 && mkdir $tmp)
12687 } ||
12688 {
12689    echo "$me: cannot create a temporary directory in ." >&2
12690    { (exit 1); exit 1; }
12691 }
12692
12693 _ACEOF
12694
12695 cat >>$CONFIG_STATUS <<_ACEOF
12696
12697 #
12698 # CONFIG_FILES section.
12699 #
12700
12701 # No need to generate the scripts if there are no CONFIG_FILES.
12702 # This happens for instance when ./config.status config.h
12703 if test -n "\$CONFIG_FILES"; then
12704   # Protect against being on the right side of a sed subst in config.status.
12705   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12706    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12707 s,@SHELL@,$SHELL,;t t
12708 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12709 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12710 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12711 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12712 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12713 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12714 s,@exec_prefix@,$exec_prefix,;t t
12715 s,@prefix@,$prefix,;t t
12716 s,@program_transform_name@,$program_transform_name,;t t
12717 s,@bindir@,$bindir,;t t
12718 s,@sbindir@,$sbindir,;t t
12719 s,@libexecdir@,$libexecdir,;t t
12720 s,@datadir@,$datadir,;t t
12721 s,@sysconfdir@,$sysconfdir,;t t
12722 s,@sharedstatedir@,$sharedstatedir,;t t
12723 s,@localstatedir@,$localstatedir,;t t
12724 s,@libdir@,$libdir,;t t
12725 s,@includedir@,$includedir,;t t
12726 s,@oldincludedir@,$oldincludedir,;t t
12727 s,@infodir@,$infodir,;t t
12728 s,@mandir@,$mandir,;t t
12729 s,@build_alias@,$build_alias,;t t
12730 s,@host_alias@,$host_alias,;t t
12731 s,@target_alias@,$target_alias,;t t
12732 s,@DEFS@,$DEFS,;t t
12733 s,@ECHO_C@,$ECHO_C,;t t
12734 s,@ECHO_N@,$ECHO_N,;t t
12735 s,@ECHO_T@,$ECHO_T,;t t
12736 s,@LIBS@,$LIBS,;t t
12737 s,@build@,$build,;t t
12738 s,@build_cpu@,$build_cpu,;t t
12739 s,@build_vendor@,$build_vendor,;t t
12740 s,@build_os@,$build_os,;t t
12741 s,@build_noncanonical@,$build_noncanonical,;t t
12742 s,@host_noncanonical@,$host_noncanonical,;t t
12743 s,@target_noncanonical@,$target_noncanonical,;t t
12744 s,@host@,$host,;t t
12745 s,@host_cpu@,$host_cpu,;t t
12746 s,@host_vendor@,$host_vendor,;t t
12747 s,@host_os@,$host_os,;t t
12748 s,@target@,$target,;t t
12749 s,@target_cpu@,$target_cpu,;t t
12750 s,@target_vendor@,$target_vendor,;t t
12751 s,@target_os@,$target_os,;t t
12752 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12753 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12754 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12755 s,@LN@,$LN,;t t
12756 s,@LN_S@,$LN_S,;t t
12757 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12758 s,@build_libsubdir@,$build_libsubdir,;t t
12759 s,@build_subdir@,$build_subdir,;t t
12760 s,@host_subdir@,$host_subdir,;t t
12761 s,@target_subdir@,$target_subdir,;t t
12762 s,@CC@,$CC,;t t
12763 s,@CFLAGS@,$CFLAGS,;t t
12764 s,@LDFLAGS@,$LDFLAGS,;t t
12765 s,@CPPFLAGS@,$CPPFLAGS,;t t
12766 s,@ac_ct_CC@,$ac_ct_CC,;t t
12767 s,@EXEEXT@,$EXEEXT,;t t
12768 s,@OBJEXT@,$OBJEXT,;t t
12769 s,@CXX@,$CXX,;t t
12770 s,@CXXFLAGS@,$CXXFLAGS,;t t
12771 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12772 s,@GNATBIND@,$GNATBIND,;t t
12773 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12774 s,@GNATMAKE@,$GNATMAKE,;t t
12775 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12776 s,@do_compare@,$do_compare,;t t
12777 s,@gmplibs@,$gmplibs,;t t
12778 s,@gmpinc@,$gmpinc,;t t
12779 s,@stage1_languages@,$stage1_languages,;t t
12780 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12781 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12782 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12783 s,@tooldir@,$tooldir,;t t
12784 s,@build_tooldir@,$build_tooldir,;t t
12785 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12786 s,@GDB_TK@,$GDB_TK,;t t
12787 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12788 s,@build_configargs@,$build_configargs,;t t
12789 s,@build_configdirs@,$build_configdirs,;t t
12790 s,@host_configargs@,$host_configargs,;t t
12791 s,@configdirs@,$configdirs,;t t
12792 s,@target_configargs@,$target_configargs,;t t
12793 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12794 s,@config_shell@,$config_shell,;t t
12795 s,@YACC@,$YACC,;t t
12796 s,@BISON@,$BISON,;t t
12797 s,@M4@,$M4,;t t
12798 s,@LEX@,$LEX,;t t
12799 s,@FLEX@,$FLEX,;t t
12800 s,@MAKEINFO@,$MAKEINFO,;t t
12801 s,@EXPECT@,$EXPECT,;t t
12802 s,@RUNTEST@,$RUNTEST,;t t
12803 s,@AR@,$AR,;t t
12804 s,@AS@,$AS,;t t
12805 s,@DLLTOOL@,$DLLTOOL,;t t
12806 s,@LD@,$LD,;t t
12807 s,@LIPO@,$LIPO,;t t
12808 s,@NM@,$NM,;t t
12809 s,@RANLIB@,$RANLIB,;t t
12810 s,@STRIP@,$STRIP,;t t
12811 s,@WINDRES@,$WINDRES,;t t
12812 s,@WINDMC@,$WINDMC,;t t
12813 s,@OBJCOPY@,$OBJCOPY,;t t
12814 s,@OBJDUMP@,$OBJDUMP,;t t
12815 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12816 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12817 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12818 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12819 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12820 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12821 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12822 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12823 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12824 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12825 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12826 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12827 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12828 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12829 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12830 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12831 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
12832 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12833 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12834 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12835 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12836 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12837 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12838 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12839 s,@MAINT@,$MAINT,;t t
12840 s,@stage1_cflags@,$stage1_cflags,;t t
12841 s,@stage1_checking@,$stage1_checking,;t t
12842 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12843 s,@datarootdir@,$datarootdir,;t t
12844 s,@docdir@,$docdir,;t t
12845 s,@pdfdir@,$pdfdir,;t t
12846 s,@htmldir@,$htmldir,;t t
12847 s,@LIBOBJS@,$LIBOBJS,;t t
12848 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12849 /@serialization_dependencies@/r $serialization_dependencies
12850 s,@serialization_dependencies@,,;t t
12851 /@host_makefile_frag@/r $host_makefile_frag
12852 s,@host_makefile_frag@,,;t t
12853 /@target_makefile_frag@/r $target_makefile_frag
12854 s,@target_makefile_frag@,,;t t
12855 /@alphaieee_frag@/r $alphaieee_frag
12856 s,@alphaieee_frag@,,;t t
12857 /@ospace_frag@/r $ospace_frag
12858 s,@ospace_frag@,,;t t
12859 CEOF
12860
12861 _ACEOF
12862
12863   cat >>$CONFIG_STATUS <<\_ACEOF
12864   # Split the substitutions into bite-sized pieces for seds with
12865   # small command number limits, like on Digital OSF/1 and HP-UX.
12866   ac_max_sed_lines=48
12867   ac_sed_frag=1 # Number of current file.
12868   ac_beg=1 # First line for current file.
12869   ac_end=$ac_max_sed_lines # Line after last line for current file.
12870   ac_more_lines=:
12871   ac_sed_cmds=
12872   while $ac_more_lines; do
12873     if test $ac_beg -gt 1; then
12874       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12875     else
12876       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12877     fi
12878     if test ! -s $tmp/subs.frag; then
12879       ac_more_lines=false
12880     else
12881       # The purpose of the label and of the branching condition is to
12882       # speed up the sed processing (if there are no `@' at all, there
12883       # is no need to browse any of the substitutions).
12884       # These are the two extra sed commands mentioned above.
12885       (echo ':t
12886   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12887       if test -z "$ac_sed_cmds"; then
12888         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12889       else
12890         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12891       fi
12892       ac_sed_frag=`expr $ac_sed_frag + 1`
12893       ac_beg=$ac_end
12894       ac_end=`expr $ac_end + $ac_max_sed_lines`
12895     fi
12896   done
12897   if test -z "$ac_sed_cmds"; then
12898     ac_sed_cmds=cat
12899   fi
12900 fi # test -n "$CONFIG_FILES"
12901
12902 _ACEOF
12903 cat >>$CONFIG_STATUS <<\_ACEOF
12904 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12905   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12906   case $ac_file in
12907   - | *:- | *:-:* ) # input from stdin
12908         cat >$tmp/stdin
12909         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12910         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12911   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12912         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12913   * )   ac_file_in=$ac_file.in ;;
12914   esac
12915
12916   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
12917   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
12918 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12919          X"$ac_file" : 'X\(//\)[^/]' \| \
12920          X"$ac_file" : 'X\(//\)$' \| \
12921          X"$ac_file" : 'X\(/\)' \| \
12922          .     : '\(.\)' 2>/dev/null ||
12923 echo X"$ac_file" |
12924     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12925           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12926           /^X\(\/\/\)$/{ s//\1/; q; }
12927           /^X\(\/\).*/{ s//\1/; q; }
12928           s/.*/./; q'`
12929   { if $as_mkdir_p; then
12930     mkdir -p "$ac_dir"
12931   else
12932     as_dir="$ac_dir"
12933     as_dirs=
12934     while test ! -d "$as_dir"; do
12935       as_dirs="$as_dir $as_dirs"
12936       as_dir=`(dirname "$as_dir") 2>/dev/null ||
12937 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12938          X"$as_dir" : 'X\(//\)[^/]' \| \
12939          X"$as_dir" : 'X\(//\)$' \| \
12940          X"$as_dir" : 'X\(/\)' \| \
12941          .     : '\(.\)' 2>/dev/null ||
12942 echo X"$as_dir" |
12943     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12944           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12945           /^X\(\/\/\)$/{ s//\1/; q; }
12946           /^X\(\/\).*/{ s//\1/; q; }
12947           s/.*/./; q'`
12948     done
12949     test ! -n "$as_dirs" || mkdir $as_dirs
12950   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
12951 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
12952    { (exit 1); exit 1; }; }; }
12953
12954   ac_builddir=.
12955
12956 if test "$ac_dir" != .; then
12957   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
12958   # A "../" for each directory in $ac_dir_suffix.
12959   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
12960 else
12961   ac_dir_suffix= ac_top_builddir=
12962 fi
12963
12964 case $srcdir in
12965   .)  # No --srcdir option.  We are building in place.
12966     ac_srcdir=.
12967     if test -z "$ac_top_builddir"; then
12968        ac_top_srcdir=.
12969     else
12970        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
12971     fi ;;
12972   [\\/]* | ?:[\\/]* )  # Absolute path.
12973     ac_srcdir=$srcdir$ac_dir_suffix;
12974     ac_top_srcdir=$srcdir ;;
12975   *) # Relative path.
12976     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
12977     ac_top_srcdir=$ac_top_builddir$srcdir ;;
12978 esac
12979
12980 # Do not use `cd foo && pwd` to compute absolute paths, because
12981 # the directories may not exist.
12982 case `pwd` in
12983 .) ac_abs_builddir="$ac_dir";;
12984 *)
12985   case "$ac_dir" in
12986   .) ac_abs_builddir=`pwd`;;
12987   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
12988   *) ac_abs_builddir=`pwd`/"$ac_dir";;
12989   esac;;
12990 esac
12991 case $ac_abs_builddir in
12992 .) ac_abs_top_builddir=${ac_top_builddir}.;;
12993 *)
12994   case ${ac_top_builddir}. in
12995   .) ac_abs_top_builddir=$ac_abs_builddir;;
12996   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
12997   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
12998   esac;;
12999 esac
13000 case $ac_abs_builddir in
13001 .) ac_abs_srcdir=$ac_srcdir;;
13002 *)
13003   case $ac_srcdir in
13004   .) ac_abs_srcdir=$ac_abs_builddir;;
13005   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13006   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13007   esac;;
13008 esac
13009 case $ac_abs_builddir in
13010 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13011 *)
13012   case $ac_top_srcdir in
13013   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13014   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13015   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13016   esac;;
13017 esac
13018
13019
13020   case $INSTALL in
13021   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13022   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13023   esac
13024
13025   if test x"$ac_file" != x-; then
13026     { echo "$as_me:$LINENO: creating $ac_file" >&5
13027 echo "$as_me: creating $ac_file" >&6;}
13028     rm -f "$ac_file"
13029   fi
13030   # Let's still pretend it is `configure' which instantiates (i.e., don't
13031   # use $as_me), people would be surprised to read:
13032   #    /* config.h.  Generated by config.status.  */
13033   if test x"$ac_file" = x-; then
13034     configure_input=
13035   else
13036     configure_input="$ac_file.  "
13037   fi
13038   configure_input=$configure_input"Generated from `echo $ac_file_in |
13039                                      sed 's,.*/,,'` by configure."
13040
13041   # First look for the input files in the build tree, otherwise in the
13042   # src tree.
13043   ac_file_inputs=`IFS=:
13044     for f in $ac_file_in; do
13045       case $f in
13046       -) echo $tmp/stdin ;;
13047       [\\/$]*)
13048          # Absolute (can't be DOS-style, as IFS=:)
13049          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13050 echo "$as_me: error: cannot find input file: $f" >&2;}
13051    { (exit 1); exit 1; }; }
13052          echo "$f";;
13053       *) # Relative
13054          if test -f "$f"; then
13055            # Build tree
13056            echo "$f"
13057          elif test -f "$srcdir/$f"; then
13058            # Source tree
13059            echo "$srcdir/$f"
13060          else
13061            # /dev/null tree
13062            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13063 echo "$as_me: error: cannot find input file: $f" >&2;}
13064    { (exit 1); exit 1; }; }
13065          fi;;
13066       esac
13067     done` || { (exit 1); exit 1; }
13068 _ACEOF
13069 cat >>$CONFIG_STATUS <<_ACEOF
13070   sed "$ac_vpsub
13071 $extrasub
13072 _ACEOF
13073 cat >>$CONFIG_STATUS <<\_ACEOF
13074 :t
13075 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13076 s,@configure_input@,$configure_input,;t t
13077 s,@srcdir@,$ac_srcdir,;t t
13078 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13079 s,@top_srcdir@,$ac_top_srcdir,;t t
13080 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13081 s,@builddir@,$ac_builddir,;t t
13082 s,@abs_builddir@,$ac_abs_builddir,;t t
13083 s,@top_builddir@,$ac_top_builddir,;t t
13084 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13085 s,@INSTALL@,$ac_INSTALL,;t t
13086 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13087   rm -f $tmp/stdin
13088   if test x"$ac_file" != x-; then
13089     mv $tmp/out $ac_file
13090   else
13091     cat $tmp/out
13092     rm -f $tmp/out
13093   fi
13094
13095 done
13096 _ACEOF
13097
13098 cat >>$CONFIG_STATUS <<\_ACEOF
13099
13100 { (exit 0); exit 0; }
13101 _ACEOF
13102 chmod +x $CONFIG_STATUS
13103 ac_clean_files=$ac_clean_files_save
13104
13105
13106 # configure is writing to config.log, and then calls config.status.
13107 # config.status does its own redirection, appending to config.log.
13108 # Unfortunately, on DOS this fails, as config.log is still kept open
13109 # by configure, so config.status won't be able to write to it; its
13110 # output is simply discarded.  So we exec the FD to /dev/null,
13111 # effectively closing config.log, so it can be properly (re)opened and
13112 # appended to by config.status.  When coming back to configure, we
13113 # need to make the FD available again.
13114 if test "$no_create" != yes; then
13115   ac_cs_success=:
13116   ac_config_status_args=
13117   test "$silent" = yes &&
13118     ac_config_status_args="$ac_config_status_args --quiet"
13119   exec 5>/dev/null
13120   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13121   exec 5>>config.log
13122   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13123   # would make configure fail if this is the last instruction.
13124   $ac_cs_success || { (exit 1); exit 1; }
13125 fi
13126