configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S TOPLEVEL_CONFIGURE_ARGUMENTS build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277
 278 # Initialize some variables set by options.
 279 ac_init_help=
 280 ac_init_version=false
 281 # The variables have the same names as the options, with
 282 # dashes changed to underlines.
 283 cache_file=/dev/null
 284 exec_prefix=NONE
 285 no_create=
 286 no_recursion=
 287 prefix=NONE
 288 program_prefix=NONE
 289 program_suffix=NONE
 290 program_transform_name=s,x,x,
 291 silent=
 292 site=
 293 srcdir=
 294 verbose=
 295 x_includes=NONE
 296 x_libraries=NONE
 297
 298 # Installation directory options.
 299 # These are left unexpanded so users can "make install exec_prefix=/foo"
 300 # and all the variables that are supposed to be based on exec_prefix
 301 # by default will actually change.
 302 # Use braces instead of parens because sh, perl, etc. also accept them.
 303 bindir='${exec_prefix}/bin'
 304 sbindir='${exec_prefix}/sbin'
 305 libexecdir='${exec_prefix}/libexec'
 306 datadir='${prefix}/share'
 307 sysconfdir='${prefix}/etc'
 308 sharedstatedir='${prefix}/com'
 309 localstatedir='${prefix}/var'
 310 libdir='${exec_prefix}/lib'
 311 includedir='${prefix}/include'
 312 oldincludedir='/usr/include'
 313 infodir='${prefix}/info'
 314 mandir='${prefix}/man'
 315
 316 ac_prev=
 317 for ac_option
 318 do
 319   # If the previous option needs an argument, assign it.
 320   if test -n "$ac_prev"; then
 321     eval "$ac_prev=\$ac_option"
 322     ac_prev=
 323     continue
 324   fi
 325
 326   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 327
 328   # Accept the important Cygnus configure options, so we can diagnose typos.
 329
 330   case $ac_option in
 331
 332   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 333     ac_prev=bindir ;;
 334   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 335     bindir=$ac_optarg ;;
 336
 337   -build | --build | --buil | --bui | --bu)
 338     ac_prev=build_alias ;;
 339   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 340     build_alias=$ac_optarg ;;
 341
 342   -cache-file | --cache-file | --cache-fil | --cache-fi \
 343   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 344     ac_prev=cache_file ;;
 345   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 346   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 347     cache_file=$ac_optarg ;;
 348
 349   --config-cache | -C)
 350     cache_file=config.cache ;;
 351
 352   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 353     ac_prev=datadir ;;
 354   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 355   | --da=*)
 356     datadir=$ac_optarg ;;
 357
 358   -disable-* | --disable-*)
 359     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 360     # Reject names that are not valid shell variable names.
 361     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 362       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 363    { (exit 1); exit 1; }; }
 364     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 365     eval "enable_$ac_feature=no" ;;
 366
 367   -enable-* | --enable-*)
 368     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 369     # Reject names that are not valid shell variable names.
 370     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 371       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 372    { (exit 1); exit 1; }; }
 373     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 374     case $ac_option in
 375       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 376       *) ac_optarg=yes ;;
 377     esac
 378     eval "enable_$ac_feature='$ac_optarg'" ;;
 379
 380   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 381   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 382   | --exec | --exe | --ex)
 383     ac_prev=exec_prefix ;;
 384   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 385   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 386   | --exec=* | --exe=* | --ex=*)
 387     exec_prefix=$ac_optarg ;;
 388
 389   -gas | --gas | --ga | --g)
 390     # Obsolete; use --with-gas.
 391     with_gas=yes ;;
 392
 393   -help | --help | --hel | --he | -h)
 394     ac_init_help=long ;;
 395   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 396     ac_init_help=recursive ;;
 397   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 398     ac_init_help=short ;;
 399
 400   -host | --host | --hos | --ho)
 401     ac_prev=host_alias ;;
 402   -host=* | --host=* | --hos=* | --ho=*)
 403     host_alias=$ac_optarg ;;
 404
 405   -includedir | --includedir | --includedi | --included | --include \
 406   | --includ | --inclu | --incl | --inc)
 407     ac_prev=includedir ;;
 408   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 409   | --includ=* | --inclu=* | --incl=* | --inc=*)
 410     includedir=$ac_optarg ;;
 411
 412   -infodir | --infodir | --infodi | --infod | --info | --inf)
 413     ac_prev=infodir ;;
 414   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 415     infodir=$ac_optarg ;;
 416
 417   -libdir | --libdir | --libdi | --libd)
 418     ac_prev=libdir ;;
 419   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 420     libdir=$ac_optarg ;;
 421
 422   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 423   | --libexe | --libex | --libe)
 424     ac_prev=libexecdir ;;
 425   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 426   | --libexe=* | --libex=* | --libe=*)
 427     libexecdir=$ac_optarg ;;
 428
 429   -localstatedir | --localstatedir | --localstatedi | --localstated \
 430   | --localstate | --localstat | --localsta | --localst \
 431   | --locals | --local | --loca | --loc | --lo)
 432     ac_prev=localstatedir ;;
 433   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 434   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 435   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 436     localstatedir=$ac_optarg ;;
 437
 438   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 439     ac_prev=mandir ;;
 440   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 441     mandir=$ac_optarg ;;
 442
 443   -nfp | --nfp | --nf)
 444     # Obsolete; use --without-fp.
 445     with_fp=no ;;
 446
 447   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 448   | --no-cr | --no-c | -n)
 449     no_create=yes ;;
 450
 451   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 452   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 453     no_recursion=yes ;;
 454
 455   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 456   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 457   | --oldin | --oldi | --old | --ol | --o)
 458     ac_prev=oldincludedir ;;
 459   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 460   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 461   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 462     oldincludedir=$ac_optarg ;;
 463
 464   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 465     ac_prev=prefix ;;
 466   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 467     prefix=$ac_optarg ;;
 468
 469   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 470   | --program-pre | --program-pr | --program-p)
 471     ac_prev=program_prefix ;;
 472   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 473   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 474     program_prefix=$ac_optarg ;;
 475
 476   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 477   | --program-suf | --program-su | --program-s)
 478     ac_prev=program_suffix ;;
 479   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 480   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 481     program_suffix=$ac_optarg ;;
 482
 483   -program-transform-name | --program-transform-name \
 484   | --program-transform-nam | --program-transform-na \
 485   | --program-transform-n | --program-transform- \
 486   | --program-transform | --program-transfor \
 487   | --program-transfo | --program-transf \
 488   | --program-trans | --program-tran \
 489   | --progr-tra | --program-tr | --program-t)
 490     ac_prev=program_transform_name ;;
 491   -program-transform-name=* | --program-transform-name=* \
 492   | --program-transform-nam=* | --program-transform-na=* \
 493   | --program-transform-n=* | --program-transform-=* \
 494   | --program-transform=* | --program-transfor=* \
 495   | --program-transfo=* | --program-transf=* \
 496   | --program-trans=* | --program-tran=* \
 497   | --progr-tra=* | --program-tr=* | --program-t=*)
 498     program_transform_name=$ac_optarg ;;
 499
 500   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 501   | -silent | --silent | --silen | --sile | --sil)
 502     silent=yes ;;
 503
 504   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 505     ac_prev=sbindir ;;
 506   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 507   | --sbi=* | --sb=*)
 508     sbindir=$ac_optarg ;;
 509
 510   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 511   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 512   | --sharedst | --shareds | --shared | --share | --shar \
 513   | --sha | --sh)
 514     ac_prev=sharedstatedir ;;
 515   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 516   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 517   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 518   | --sha=* | --sh=*)
 519     sharedstatedir=$ac_optarg ;;
 520
 521   -site | --site | --sit)
 522     ac_prev=site ;;
 523   -site=* | --site=* | --sit=*)
 524     site=$ac_optarg ;;
 525
 526   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 527     ac_prev=srcdir ;;
 528   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 529     srcdir=$ac_optarg ;;
 530
 531   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 532   | --syscon | --sysco | --sysc | --sys | --sy)
 533     ac_prev=sysconfdir ;;
 534   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 535   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 536     sysconfdir=$ac_optarg ;;
 537
 538   -target | --target | --targe | --targ | --tar | --ta | --t)
 539     ac_prev=target_alias ;;
 540   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 541     target_alias=$ac_optarg ;;
 542
 543   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 544     verbose=yes ;;
 545
 546   -version | --version | --versio | --versi | --vers | -V)
 547     ac_init_version=: ;;
 548
 549   -with-* | --with-*)
 550     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 551     # Reject names that are not valid shell variable names.
 552     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 553       { echo "$as_me: error: invalid package name: $ac_package" >&2
 554    { (exit 1); exit 1; }; }
 555     ac_package=`echo $ac_package| sed 's/-/_/g'`
 556     case $ac_option in
 557       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 558       *) ac_optarg=yes ;;
 559     esac
 560     eval "with_$ac_package='$ac_optarg'" ;;
 561
 562   -without-* | --without-*)
 563     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 564     # Reject names that are not valid shell variable names.
 565     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 566       { echo "$as_me: error: invalid package name: $ac_package" >&2
 567    { (exit 1); exit 1; }; }
 568     ac_package=`echo $ac_package | sed 's/-/_/g'`
 569     eval "with_$ac_package=no" ;;
 570
 571   --x)
 572     # Obsolete; use --with-x.
 573     with_x=yes ;;
 574
 575   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 576   | --x-incl | --x-inc | --x-in | --x-i)
 577     ac_prev=x_includes ;;
 578   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 579   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 580     x_includes=$ac_optarg ;;
 581
 582   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 583   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 584     ac_prev=x_libraries ;;
 585   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 586   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 587     x_libraries=$ac_optarg ;;
 588
 589   -*) { echo "$as_me: error: unrecognized option: $ac_option
 590 Try \`$0 --help' for more information." >&2
 591    { (exit 1); exit 1; }; }
 592     ;;
 593
 594   *=*)
 595     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 596     # Reject names that are not valid shell variable names.
 597     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 598       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 599    { (exit 1); exit 1; }; }
 600     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 601     eval "$ac_envvar='$ac_optarg'"
 602     export $ac_envvar ;;
 603
 604   *)
 605     # FIXME: should be removed in autoconf 3.0.
 606     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 607     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 608       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 609     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 610     ;;
 611
 612   esac
 613 done
 614
 615 if test -n "$ac_prev"; then
 616   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 617   { echo "$as_me: error: missing argument to $ac_option" >&2
 618    { (exit 1); exit 1; }; }
 619 fi
 620
 621 # Be sure to have absolute paths.
 622 for ac_var in exec_prefix prefix
 623 do
 624   eval ac_val=$`echo $ac_var`
 625   case $ac_val in
 626     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 627     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 628    { (exit 1); exit 1; }; };;
 629   esac
 630 done
 631
 632 # Be sure to have absolute paths.
 633 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 634               localstatedir libdir includedir oldincludedir infodir mandir
 635 do
 636   eval ac_val=$`echo $ac_var`
 637   case $ac_val in
 638     [\\/$]* | ?:[\\/]* ) ;;
 639     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 640    { (exit 1); exit 1; }; };;
 641   esac
 642 done
 643
 644 # There might be people who depend on the old broken behavior: `$host'
 645 # used to hold the argument of --host etc.
 646 # FIXME: To remove some day.
 647 build=$build_alias
 648 host=$host_alias
 649 target=$target_alias
 650
 651 # FIXME: To remove some day.
 652 if test "x$host_alias" != x; then
 653   if test "x$build_alias" = x; then
 654     cross_compiling=maybe
 655     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 656     If a cross compiler is detected then cross compile mode will be used." >&2
 657   elif test "x$build_alias" != "x$host_alias"; then
 658     cross_compiling=yes
 659   fi
 660 fi
 661
 662 ac_tool_prefix=
 663 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 664
 665 test "$silent" = yes && exec 6>/dev/null
 666
 667
 668 # Find the source files, if location was not specified.
 669 if test -z "$srcdir"; then
 670   ac_srcdir_defaulted=yes
 671   # Try the directory containing this script, then its parent.
 672   ac_confdir=`(dirname "$0") 2>/dev/null ||
 673 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 674          X"$0" : 'X\(//\)[^/]' \| \
 675          X"$0" : 'X\(//\)$' \| \
 676          X"$0" : 'X\(/\)' \| \
 677          .     : '\(.\)' 2>/dev/null ||
 678 echo X"$0" |
 679     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 680           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 681           /^X\(\/\/\)$/{ s//\1/; q; }
 682           /^X\(\/\).*/{ s//\1/; q; }
 683           s/.*/./; q'`
 684   srcdir=$ac_confdir
 685   if test ! -r $srcdir/$ac_unique_file; then
 686     srcdir=..
 687   fi
 688 else
 689   ac_srcdir_defaulted=no
 690 fi
 691 if test ! -r $srcdir/$ac_unique_file; then
 692   if test "$ac_srcdir_defaulted" = yes; then
 693     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 694    { (exit 1); exit 1; }; }
 695   else
 696     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 697    { (exit 1); exit 1; }; }
 698   fi
 699 fi
 700 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 701   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 702    { (exit 1); exit 1; }; }
 703 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 704 ac_env_build_alias_set=${build_alias+set}
 705 ac_env_build_alias_value=$build_alias
 706 ac_cv_env_build_alias_set=${build_alias+set}
 707 ac_cv_env_build_alias_value=$build_alias
 708 ac_env_host_alias_set=${host_alias+set}
 709 ac_env_host_alias_value=$host_alias
 710 ac_cv_env_host_alias_set=${host_alias+set}
 711 ac_cv_env_host_alias_value=$host_alias
 712 ac_env_target_alias_set=${target_alias+set}
 713 ac_env_target_alias_value=$target_alias
 714 ac_cv_env_target_alias_set=${target_alias+set}
 715 ac_cv_env_target_alias_value=$target_alias
 716 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 717
 718 ac_env_CC_set=${CC+set}
 719 ac_env_CC_value=$CC
 720 ac_cv_env_CC_set=${CC+set}
 721 ac_cv_env_CC_value=$CC
 722 ac_env_CFLAGS_set=${CFLAGS+set}
 723 ac_env_CFLAGS_value=$CFLAGS
 724 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 725 ac_cv_env_CFLAGS_value=$CFLAGS
 726 ac_env_LDFLAGS_set=${LDFLAGS+set}
 727 ac_env_LDFLAGS_value=$LDFLAGS
 728 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 729 ac_cv_env_LDFLAGS_value=$LDFLAGS
 730 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 731 ac_env_CPPFLAGS_value=$CPPFLAGS
 732 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 733 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 734 ac_env_CXX_set=${CXX+set}
 735 ac_env_CXX_value=$CXX
 736 ac_cv_env_CXX_set=${CXX+set}
 737 ac_cv_env_CXX_value=$CXX
 738 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 739 ac_env_CXXFLAGS_value=$CXXFLAGS
 740 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 741 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 742 ac_env_AR_set=${AR+set}
 743 ac_env_AR_value=$AR
 744 ac_cv_env_AR_set=${AR+set}
 745 ac_cv_env_AR_value=$AR
 746 ac_env_AS_set=${AS+set}
 747 ac_env_AS_value=$AS
 748 ac_cv_env_AS_set=${AS+set}
 749 ac_cv_env_AS_value=$AS
 750 ac_env_DLLTOOL_set=${DLLTOOL+set}
 751 ac_env_DLLTOOL_value=$DLLTOOL
 752 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 753 ac_cv_env_DLLTOOL_value=$DLLTOOL
 754 ac_env_LD_set=${LD+set}
 755 ac_env_LD_value=$LD
 756 ac_cv_env_LD_set=${LD+set}
 757 ac_cv_env_LD_value=$LD
 758 ac_env_LIPO_set=${LIPO+set}
 759 ac_env_LIPO_value=$LIPO
 760 ac_cv_env_LIPO_set=${LIPO+set}
 761 ac_cv_env_LIPO_value=$LIPO
 762 ac_env_NM_set=${NM+set}
 763 ac_env_NM_value=$NM
 764 ac_cv_env_NM_set=${NM+set}
 765 ac_cv_env_NM_value=$NM
 766 ac_env_RANLIB_set=${RANLIB+set}
 767 ac_env_RANLIB_value=$RANLIB
 768 ac_cv_env_RANLIB_set=${RANLIB+set}
 769 ac_cv_env_RANLIB_value=$RANLIB
 770 ac_env_STRIP_set=${STRIP+set}
 771 ac_env_STRIP_value=$STRIP
 772 ac_cv_env_STRIP_set=${STRIP+set}
 773 ac_cv_env_STRIP_value=$STRIP
 774 ac_env_WINDRES_set=${WINDRES+set}
 775 ac_env_WINDRES_value=$WINDRES
 776 ac_cv_env_WINDRES_set=${WINDRES+set}
 777 ac_cv_env_WINDRES_value=$WINDRES
 778 ac_env_WINDMC_set=${WINDMC+set}
 779 ac_env_WINDMC_value=$WINDMC
 780 ac_cv_env_WINDMC_set=${WINDMC+set}
 781 ac_cv_env_WINDMC_value=$WINDMC
 782 ac_env_OBJCOPY_set=${OBJCOPY+set}
 783 ac_env_OBJCOPY_value=$OBJCOPY
 784 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 785 ac_cv_env_OBJCOPY_value=$OBJCOPY
 786 ac_env_OBJDUMP_set=${OBJDUMP+set}
 787 ac_env_OBJDUMP_value=$OBJDUMP
 788 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 789 ac_cv_env_OBJDUMP_value=$OBJDUMP
 790 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 791 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 792 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 793 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 794 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 795 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 796 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 797 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 798 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 799 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 800 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 801 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 802 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 803 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 804 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 805 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 806 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 807 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 808 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 809 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 810 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 811 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 812 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 813 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 814 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 815 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 816 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 817 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 818 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 819 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 820 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 821 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 822 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 823 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 824 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 825 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 826 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 827 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 828 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 829 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 830 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 831 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 832 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 833 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 834 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 835 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 836 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 837 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 838 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 839 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 840 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 841 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 842 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 843 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 844 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 845 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 846 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 847 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 848 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 849 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 850 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 851 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 852 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 853 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 854
 855 #
 856 # Report the --help message.
 857 #
 858 if test "$ac_init_help" = "long"; then
 859   # Omit some internal or obsolete options to make the list less imposing.
 860   # This message is too long to be a string in the A/UX 3.1 sh.
 861   cat <<_ACEOF
 862 \`configure' configures this package to adapt to many kinds of systems.
 863
 864 Usage: $0 [OPTION]... [VAR=VALUE]...
 865
 866 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 867 VAR=VALUE.  See below for descriptions of some of the useful variables.
 868
 869 Defaults for the options are specified in brackets.
 870
 871 Configuration:
 872   -h, --help              display this help and exit
 873       --help=short        display options specific to this package
 874       --help=recursive    display the short help of all the included packages
 875   -V, --version           display version information and exit
 876   -q, --quiet, --silent   do not print \`checking...' messages
 877       --cache-file=FILE   cache test results in FILE [disabled]
 878   -C, --config-cache      alias for \`--cache-file=config.cache'
 879   -n, --no-create         do not create output files
 880       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 881
 882 _ACEOF
 883
 884   cat <<_ACEOF
 885 Installation directories:
 886   --prefix=PREFIX         install architecture-independent files in PREFIX
 887                           [$ac_default_prefix]
 888   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 889                           [PREFIX]
 890
 891 By default, \`make install' will install all the files in
 892 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 893 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 894 for instance \`--prefix=\$HOME'.
 895
 896 For better control, use the options below.
 897
 898 Fine tuning of the installation directories:
 899   --bindir=DIR           user executables [EPREFIX/bin]
 900   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 901   --libexecdir=DIR       program executables [EPREFIX/libexec]
 902   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 903   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 904   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 905   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 906   --libdir=DIR           object code libraries [EPREFIX/lib]
 907   --includedir=DIR       C header files [PREFIX/include]
 908   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 909   --infodir=DIR          info documentation [PREFIX/info]
 910   --mandir=DIR           man documentation [PREFIX/man]
 911 _ACEOF
 912
 913   cat <<\_ACEOF
 914
 915 Program names:
 916   --program-prefix=PREFIX            prepend PREFIX to installed program names
 917   --program-suffix=SUFFIX            append SUFFIX to installed program names
 918   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 919
 920 System types:
 921   --build=BUILD     configure for building on BUILD [guessed]
 922   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 923   --target=TARGET   configure for building compilers for TARGET [HOST]
 924 _ACEOF
 925 fi
 926
 927 if test -n "$ac_init_help"; then
 928
 929   cat <<\_ACEOF
 930
 931 Optional Features:
 932   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 933   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 934   --enable-libada         build libada directory
 935   --enable-libssp         build libssp directory
 936   --enable-stage1-languages[=all]   choose additional languages to build during
 937                           stage1.  Mostly useful for compiler development.
 938   --enable-objc-gc        enable use of Boehm's garbage collector with the
 939                           GNU Objective-C runtime
 940   --enable-bootstrap      enable bootstrapping [yes if native build]
 941   --enable-serial-[{host,target,build}-]configure
 942                           force sequential configuration of
 943                           sub-packages for the host, target or build
 944                           machine, or all sub-packages
 945   --enable-maintainer-mode enable make rules and dependencies not useful
 946                           (and sometimes confusing) to the casual installer
 947   --enable-stage1-checking[=all]   choose additional checking for stage1
 948                           of the compiler
 949   --enable-werror         enable -Werror in bootstrap stage2 and later
 950
 951 Optional Packages:
 952   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 953   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 954   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 955   --with-mpfr-dir=PATH    this option has been REMOVED
 956   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 957                           Equivalent to --with-mpfr-include=PATH/include
 958                           plus --with-mpfr-lib=PATH/lib
 959   --with-mpfr-include=PATH
 960                           specify directory for installed MPFR include files
 961   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 962   --with-gmp-dir=PATH     this option has been REMOVED
 963   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 964                           Equivalent to --with-gmp-include=PATH/include
 965                           plus --with-gmp-lib=PATH/lib
 966   --with-gmp-include=PATH specify directory for installed GMP include files
 967   --with-gmp-lib=PATH     specify directory for the installed GMP library
 968   --with-build-sysroot=SYSROOT
 969                           use sysroot as the system root during the build
 970   --with-debug-prefix-map='A=B C=D ...'
 971                              map A to B, C to D ... in debug information
 972   --with-build-time-tools=PATH
 973                           use given path to find target tools during the build
 974   --with-datarootdir      use datarootdir as the data root directory.
 975   --with-docdir           install documentation in this directory.
 976   --with-pdfdir           install pdf in this directory.
 977   --with-htmldir          install html in this directory.
 978
 979 Some influential environment variables:
 980   CC          C compiler command
 981   CFLAGS      C compiler flags
 982   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 983               nonstandard directory <lib dir>
 984   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 985               headers in a nonstandard directory <include dir>
 986   CXX         C++ compiler command
 987   CXXFLAGS    C++ compiler flags
 988   AR          AR for the host
 989   AS          AS for the host
 990   DLLTOOL     DLLTOOL for the host
 991   LD          LD for the host
 992   LIPO        LIPO for the host
 993   NM          NM for the host
 994   RANLIB      RANLIB for the host
 995   STRIP       STRIP for the host
 996   WINDRES     WINDRES for the host
 997   WINDMC      WINDMC for the host
 998   OBJCOPY     OBJCOPY for the host
 999   OBJDUMP     OBJDUMP for the host
1000   CC_FOR_TARGET
1001               CC for the target
1002   CXX_FOR_TARGET
1003               CXX for the target
1004   GCC_FOR_TARGET
1005               GCC for the target
1006   GCJ_FOR_TARGET
1007               GCJ for the target
1008   GFORTRAN_FOR_TARGET
1009               GFORTRAN for the target
1010   AR_FOR_TARGET
1011               AR for the target
1012   AS_FOR_TARGET
1013               AS for the target
1014   DLLTOOL_FOR_TARGET
1015               DLLTOOL for the target
1016   LD_FOR_TARGET
1017               LD for the target
1018   LIPO_FOR_TARGET
1019               LIPO for the target
1020   NM_FOR_TARGET
1021               NM for the target
1022   OBJDUMP_FOR_TARGET
1023               OBJDUMP for the target
1024   RANLIB_FOR_TARGET
1025               RANLIB for the target
1026   STRIP_FOR_TARGET
1027               STRIP for the target
1028   WINDRES_FOR_TARGET
1029               WINDRES for the target
1030   WINDMC_FOR_TARGET
1031               WINDMC for the target
1032
1033 Use these variables to override the choices made by `configure' or to help
1034 it to find libraries and programs with nonstandard names/locations.
1035
1036 _ACEOF
1037 fi
1038
1039 if test "$ac_init_help" = "recursive"; then
1040   # If there are subdirs, report their specific --help.
1041   ac_popdir=`pwd`
1042   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1043     test -d $ac_dir || continue
1044     ac_builddir=.
1045
1046 if test "$ac_dir" != .; then
1047   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1048   # A "../" for each directory in $ac_dir_suffix.
1049   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1050 else
1051   ac_dir_suffix= ac_top_builddir=
1052 fi
1053
1054 case $srcdir in
1055   .)  # No --srcdir option.  We are building in place.
1056     ac_srcdir=.
1057     if test -z "$ac_top_builddir"; then
1058        ac_top_srcdir=.
1059     else
1060        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1061     fi ;;
1062   [\\/]* | ?:[\\/]* )  # Absolute path.
1063     ac_srcdir=$srcdir$ac_dir_suffix;
1064     ac_top_srcdir=$srcdir ;;
1065   *) # Relative path.
1066     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1067     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1068 esac
1069
1070 # Do not use `cd foo && pwd` to compute absolute paths, because
1071 # the directories may not exist.
1072 case `pwd` in
1073 .) ac_abs_builddir="$ac_dir";;
1074 *)
1075   case "$ac_dir" in
1076   .) ac_abs_builddir=`pwd`;;
1077   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1078   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1079   esac;;
1080 esac
1081 case $ac_abs_builddir in
1082 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1083 *)
1084   case ${ac_top_builddir}. in
1085   .) ac_abs_top_builddir=$ac_abs_builddir;;
1086   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1087   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1088   esac;;
1089 esac
1090 case $ac_abs_builddir in
1091 .) ac_abs_srcdir=$ac_srcdir;;
1092 *)
1093   case $ac_srcdir in
1094   .) ac_abs_srcdir=$ac_abs_builddir;;
1095   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1096   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1097   esac;;
1098 esac
1099 case $ac_abs_builddir in
1100 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1101 *)
1102   case $ac_top_srcdir in
1103   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1104   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1105   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1106   esac;;
1107 esac
1108
1109     cd $ac_dir
1110     # Check for guested configure; otherwise get Cygnus style configure.
1111     if test -f $ac_srcdir/configure.gnu; then
1112       echo
1113       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1114     elif test -f $ac_srcdir/configure; then
1115       echo
1116       $SHELL $ac_srcdir/configure  --help=recursive
1117     elif test -f $ac_srcdir/configure.ac ||
1118            test -f $ac_srcdir/configure.in; then
1119       echo
1120       $ac_configure --help
1121     else
1122       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1123     fi
1124     cd $ac_popdir
1125   done
1126 fi
1127
1128 test -n "$ac_init_help" && exit 0
1129 if $ac_init_version; then
1130   cat <<\_ACEOF
1131
1132 Copyright (C) 2003 Free Software Foundation, Inc.
1133 This configure script is free software; the Free Software Foundation
1134 gives unlimited permission to copy, distribute and modify it.
1135 _ACEOF
1136   exit 0
1137 fi
1138 exec 5>config.log
1139 cat >&5 <<_ACEOF
1140 This file contains any messages produced by compilers while
1141 running configure, to aid debugging if configure makes a mistake.
1142
1143 It was created by $as_me, which was
1144 generated by GNU Autoconf 2.59.  Invocation command line was
1145
1146   $ $0 $@
1147
1148 _ACEOF
1149 {
1150 cat <<_ASUNAME
1151 ## --------- ##
1152 ## Platform. ##
1153 ## --------- ##
1154
1155 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1156 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1157 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1158 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1159 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1160
1161 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1162 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1163
1164 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1165 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1166 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1167 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1168 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1169 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1170 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1171
1172 _ASUNAME
1173
1174 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1175 for as_dir in $PATH
1176 do
1177   IFS=$as_save_IFS
1178   test -z "$as_dir" && as_dir=.
1179   echo "PATH: $as_dir"
1180 done
1181
1182 } >&5
1183
1184 cat >&5 <<_ACEOF
1185
1186
1187 ## ----------- ##
1188 ## Core tests. ##
1189 ## ----------- ##
1190
1191 _ACEOF
1192
1193
1194 # Keep a trace of the command line.
1195 # Strip out --no-create and --no-recursion so they do not pile up.
1196 # Strip out --silent because we don't want to record it for future runs.
1197 # Also quote any args containing shell meta-characters.
1198 # Make two passes to allow for proper duplicate-argument suppression.
1199 ac_configure_args=
1200 ac_configure_args0=
1201 ac_configure_args1=
1202 ac_sep=
1203 ac_must_keep_next=false
1204 for ac_pass in 1 2
1205 do
1206   for ac_arg
1207   do
1208     case $ac_arg in
1209     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1210     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1211     | -silent | --silent | --silen | --sile | --sil)
1212       continue ;;
1213     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1214       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1215     esac
1216     case $ac_pass in
1217     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1218     2)
1219       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1220       if test $ac_must_keep_next = true; then
1221         ac_must_keep_next=false # Got value, back to normal.
1222       else
1223         case $ac_arg in
1224           *=* | --config-cache | -C | -disable-* | --disable-* \
1225           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1226           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1227           | -with-* | --with-* | -without-* | --without-* | --x)
1228             case "$ac_configure_args0 " in
1229               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1230             esac
1231             ;;
1232           -* ) ac_must_keep_next=true ;;
1233         esac
1234       fi
1235       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1236       # Get rid of the leading space.
1237       ac_sep=" "
1238       ;;
1239     esac
1240   done
1241 done
1242 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1243 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1244
1245 # When interrupted or exit'd, cleanup temporary files, and complete
1246 # config.log.  We remove comments because anyway the quotes in there
1247 # would cause problems or look ugly.
1248 # WARNING: Be sure not to use single quotes in there, as some shells,
1249 # such as our DU 5.0 friend, will then `close' the trap.
1250 trap 'exit_status=$?
1251   # Save into config.log some information that might help in debugging.
1252   {
1253     echo
1254
1255     cat <<\_ASBOX
1256 ## ---------------- ##
1257 ## Cache variables. ##
1258 ## ---------------- ##
1259 _ASBOX
1260     echo
1261     # The following way of writing the cache mishandles newlines in values,
1262 {
1263   (set) 2>&1 |
1264     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1265     *ac_space=\ *)
1266       sed -n \
1267         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1268           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1269       ;;
1270     *)
1271       sed -n \
1272         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1273       ;;
1274     esac;
1275 }
1276     echo
1277
1278     cat <<\_ASBOX
1279 ## ----------------- ##
1280 ## Output variables. ##
1281 ## ----------------- ##
1282 _ASBOX
1283     echo
1284     for ac_var in $ac_subst_vars
1285     do
1286       eval ac_val=$`echo $ac_var`
1287       echo "$ac_var='"'"'$ac_val'"'"'"
1288     done | sort
1289     echo
1290
1291     if test -n "$ac_subst_files"; then
1292       cat <<\_ASBOX
1293 ## ------------- ##
1294 ## Output files. ##
1295 ## ------------- ##
1296 _ASBOX
1297       echo
1298       for ac_var in $ac_subst_files
1299       do
1300         eval ac_val=$`echo $ac_var`
1301         echo "$ac_var='"'"'$ac_val'"'"'"
1302       done | sort
1303       echo
1304     fi
1305
1306     if test -s confdefs.h; then
1307       cat <<\_ASBOX
1308 ## ----------- ##
1309 ## confdefs.h. ##
1310 ## ----------- ##
1311 _ASBOX
1312       echo
1313       sed "/^$/d" confdefs.h | sort
1314       echo
1315     fi
1316     test "$ac_signal" != 0 &&
1317       echo "$as_me: caught signal $ac_signal"
1318     echo "$as_me: exit $exit_status"
1319   } >&5
1320   rm -f core *.core &&
1321   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1322     exit $exit_status
1323      ' 0
1324 for ac_signal in 1 2 13 15; do
1325   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1326 done
1327 ac_signal=0
1328
1329 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1330 rm -rf conftest* confdefs.h
1331 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1332 echo >confdefs.h
1333
1334 # Predefined preprocessor variables.
1335
1336 cat >>confdefs.h <<_ACEOF
1337 #define PACKAGE_NAME "$PACKAGE_NAME"
1338 _ACEOF
1339
1340
1341 cat >>confdefs.h <<_ACEOF
1342 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1343 _ACEOF
1344
1345
1346 cat >>confdefs.h <<_ACEOF
1347 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1348 _ACEOF
1349
1350
1351 cat >>confdefs.h <<_ACEOF
1352 #define PACKAGE_STRING "$PACKAGE_STRING"
1353 _ACEOF
1354
1355
1356 cat >>confdefs.h <<_ACEOF
1357 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1358 _ACEOF
1359
1360
1361 # Let the site file select an alternate cache file if it wants to.
1362 # Prefer explicitly selected file to automatically selected ones.
1363 if test -z "$CONFIG_SITE"; then
1364   if test "x$prefix" != xNONE; then
1365     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1366   else
1367     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1368   fi
1369 fi
1370 for ac_site_file in $CONFIG_SITE; do
1371   if test -r "$ac_site_file"; then
1372     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1373 echo "$as_me: loading site script $ac_site_file" >&6;}
1374     sed 's/^/| /' "$ac_site_file" >&5
1375     . "$ac_site_file"
1376   fi
1377 done
1378
1379 if test -r "$cache_file"; then
1380   # Some versions of bash will fail to source /dev/null (special
1381   # files actually), so we avoid doing that.
1382   if test -f "$cache_file"; then
1383     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1384 echo "$as_me: loading cache $cache_file" >&6;}
1385     case $cache_file in
1386       [\\/]* | ?:[\\/]* ) . $cache_file;;
1387       *)                      . ./$cache_file;;
1388     esac
1389   fi
1390 else
1391   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1392 echo "$as_me: creating cache $cache_file" >&6;}
1393   >$cache_file
1394 fi
1395
1396 # Check that the precious variables saved in the cache have kept the same
1397 # value.
1398 ac_cache_corrupted=false
1399 for ac_var in `(set) 2>&1 |
1400                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1401   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1402   eval ac_new_set=\$ac_env_${ac_var}_set
1403   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1404   eval ac_new_val="\$ac_env_${ac_var}_value"
1405   case $ac_old_set,$ac_new_set in
1406     set,)
1407       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1408 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1409       ac_cache_corrupted=: ;;
1410     ,set)
1411       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1412 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1413       ac_cache_corrupted=: ;;
1414     ,);;
1415     *)
1416       if test "x$ac_old_val" != "x$ac_new_val"; then
1417         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1418 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1419         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1420 echo "$as_me:   former value:  $ac_old_val" >&2;}
1421         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1422 echo "$as_me:   current value: $ac_new_val" >&2;}
1423         ac_cache_corrupted=:
1424       fi;;
1425   esac
1426   # Pass precious variables to config.status.
1427   if test "$ac_new_set" = set; then
1428     case $ac_new_val in
1429     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1430       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1431     *) ac_arg=$ac_var=$ac_new_val ;;
1432     esac
1433     case " $ac_configure_args " in
1434       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1435       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1436     esac
1437   fi
1438 done
1439 if $ac_cache_corrupted; then
1440   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1441 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1442   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1443 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1444    { (exit 1); exit 1; }; }
1445 fi
1446
1447 ac_ext=c
1448 ac_cpp='$CPP $CPPFLAGS'
1449 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1450 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1451 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473 # Find the build, host, and target systems.
1474 ac_aux_dir=
1475 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1476   if test -f $ac_dir/install-sh; then
1477     ac_aux_dir=$ac_dir
1478     ac_install_sh="$ac_aux_dir/install-sh -c"
1479     break
1480   elif test -f $ac_dir/install.sh; then
1481     ac_aux_dir=$ac_dir
1482     ac_install_sh="$ac_aux_dir/install.sh -c"
1483     break
1484   elif test -f $ac_dir/shtool; then
1485     ac_aux_dir=$ac_dir
1486     ac_install_sh="$ac_aux_dir/shtool install -c"
1487     break
1488   fi
1489 done
1490 if test -z "$ac_aux_dir"; then
1491   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1492 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1493    { (exit 1); exit 1; }; }
1494 fi
1495 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1496 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1497 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1498
1499 # Make sure we can run config.sub.
1500 $ac_config_sub sun4 >/dev/null 2>&1 ||
1501   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1502 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1503    { (exit 1); exit 1; }; }
1504
1505 echo "$as_me:$LINENO: checking build system type" >&5
1506 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1507 if test "${ac_cv_build+set}" = set; then
1508   echo $ECHO_N "(cached) $ECHO_C" >&6
1509 else
1510   ac_cv_build_alias=$build_alias
1511 test -z "$ac_cv_build_alias" &&
1512   ac_cv_build_alias=`$ac_config_guess`
1513 test -z "$ac_cv_build_alias" &&
1514   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1515 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1516    { (exit 1); exit 1; }; }
1517 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1518   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1519 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1520    { (exit 1); exit 1; }; }
1521
1522 fi
1523 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1524 echo "${ECHO_T}$ac_cv_build" >&6
1525 build=$ac_cv_build
1526 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1527 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1528 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1529
1530
1531  case ${build_alias} in
1532   "") build_noncanonical=${build} ;;
1533   *) build_noncanonical=${build_alias} ;;
1534 esac
1535
1536
1537
1538  case ${host_alias} in
1539   "") host_noncanonical=${build_noncanonical} ;;
1540   *) host_noncanonical=${host_alias} ;;
1541 esac
1542
1543
1544
1545  case ${target_alias} in
1546   "") target_noncanonical=${host_noncanonical} ;;
1547   *) target_noncanonical=${target_alias} ;;
1548 esac
1549
1550
1551
1552
1553 test "$host_noncanonical" = "$target_noncanonical" &&
1554   test "$program_prefix$program_suffix$program_transform_name" = \
1555     NONENONEs,x,x, &&
1556   program_transform_name=s,y,y,
1557
1558 echo "$as_me:$LINENO: checking host system type" >&5
1559 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1560 if test "${ac_cv_host+set}" = set; then
1561   echo $ECHO_N "(cached) $ECHO_C" >&6
1562 else
1563   ac_cv_host_alias=$host_alias
1564 test -z "$ac_cv_host_alias" &&
1565   ac_cv_host_alias=$ac_cv_build_alias
1566 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1567   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1568 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1569    { (exit 1); exit 1; }; }
1570
1571 fi
1572 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1573 echo "${ECHO_T}$ac_cv_host" >&6
1574 host=$ac_cv_host
1575 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1576 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1577 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1578
1579
1580 echo "$as_me:$LINENO: checking target system type" >&5
1581 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1582 if test "${ac_cv_target+set}" = set; then
1583   echo $ECHO_N "(cached) $ECHO_C" >&6
1584 else
1585   ac_cv_target_alias=$target_alias
1586 test "x$ac_cv_target_alias" = "x" &&
1587   ac_cv_target_alias=$ac_cv_host_alias
1588 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1589   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1590 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1591    { (exit 1); exit 1; }; }
1592
1593 fi
1594 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1595 echo "${ECHO_T}$ac_cv_target" >&6
1596 target=$ac_cv_target
1597 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1598 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1599 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1600
1601
1602 # The aliases save the names the user supplied, while $host etc.
1603 # will get canonicalized.
1604 test -n "$target_alias" &&
1605   test "$program_prefix$program_suffix$program_transform_name" = \
1606     NONENONEs,x,x, &&
1607   program_prefix=${target_alias}-
1608 test "$program_prefix" != NONE &&
1609   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1610 # Use a double $ so make ignores it.
1611 test "$program_suffix" != NONE &&
1612   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1613 # Double any \ or $.  echo might interpret backslashes.
1614 # By default was `s,x,x', remove it if useless.
1615 cat <<\_ACEOF >conftest.sed
1616 s/[\\$]/&&/g;s/;s,x,x,$//
1617 _ACEOF
1618 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1619 rm conftest.sed
1620
1621
1622
1623 # Get 'install' or 'install-sh' and its variants.
1624 # Find a good install program.  We prefer a C program (faster),
1625 # so one script is as good as another.  But avoid the broken or
1626 # incompatible versions:
1627 # SysV /etc/install, /usr/sbin/install
1628 # SunOS /usr/etc/install
1629 # IRIX /sbin/install
1630 # AIX /bin/install
1631 # AmigaOS /C/install, which installs bootblocks on floppy discs
1632 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1633 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1634 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1635 # OS/2's system install, which has a completely different semantic
1636 # ./install, which can be erroneously created by make from ./install.sh.
1637 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1638 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1639 if test -z "$INSTALL"; then
1640 if test "${ac_cv_path_install+set}" = set; then
1641   echo $ECHO_N "(cached) $ECHO_C" >&6
1642 else
1643   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1644 for as_dir in $PATH
1645 do
1646   IFS=$as_save_IFS
1647   test -z "$as_dir" && as_dir=.
1648   # Account for people who put trailing slashes in PATH elements.
1649 case $as_dir/ in
1650   ./ | .// | /cC/* | \
1651   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1652   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1653   /usr/ucb/* ) ;;
1654   *)
1655     # OSF1 and SCO ODT 3.0 have their own names for install.
1656     # Don't use installbsd from OSF since it installs stuff as root
1657     # by default.
1658     for ac_prog in ginstall scoinst install; do
1659       for ac_exec_ext in '' $ac_executable_extensions; do
1660         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1661           if test $ac_prog = install &&
1662             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1663             # AIX install.  It has an incompatible calling convention.
1664             :
1665           elif test $ac_prog = install &&
1666             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1667             # program-specific install script used by HP pwplus--don't use.
1668             :
1669           else
1670             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1671             break 3
1672           fi
1673         fi
1674       done
1675     done
1676     ;;
1677 esac
1678 done
1679
1680
1681 fi
1682   if test "${ac_cv_path_install+set}" = set; then
1683     INSTALL=$ac_cv_path_install
1684   else
1685     # As a last resort, use the slow shell script.  We don't cache a
1686     # path for INSTALL within a source directory, because that will
1687     # break other packages using the cache if that directory is
1688     # removed, or if the path is relative.
1689     INSTALL=$ac_install_sh
1690   fi
1691 fi
1692 echo "$as_me:$LINENO: result: $INSTALL" >&5
1693 echo "${ECHO_T}$INSTALL" >&6
1694
1695 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1696 # It thinks the first close brace ends the variable substitution.
1697 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1698
1699 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1700
1701 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1702
1703 echo "$as_me:$LINENO: checking whether ln works" >&5
1704 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1705 if test "${acx_cv_prog_LN+set}" = set; then
1706   echo $ECHO_N "(cached) $ECHO_C" >&6
1707 else
1708   rm -f conftestdata_t
1709 echo >conftestdata_f
1710 if ln conftestdata_f conftestdata_t 2>/dev/null
1711 then
1712   acx_cv_prog_LN=ln
1713 else
1714   acx_cv_prog_LN=no
1715 fi
1716 rm -f conftestdata_f conftestdata_t
1717
1718 fi
1719 if test $acx_cv_prog_LN = no; then
1720   LN="cp"
1721   echo "$as_me:$LINENO: result: no, using $LN" >&5
1722 echo "${ECHO_T}no, using $LN" >&6
1723 else
1724   LN="$acx_cv_prog_LN"
1725   echo "$as_me:$LINENO: result: yes" >&5
1726 echo "${ECHO_T}yes" >&6
1727 fi
1728
1729 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1730 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1731 LN_S=$as_ln_s
1732 if test "$LN_S" = "ln -s"; then
1733   echo "$as_me:$LINENO: result: yes" >&5
1734 echo "${ECHO_T}yes" >&6
1735 else
1736   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1737 echo "${ECHO_T}no, using $LN_S" >&6
1738 fi
1739
1740
1741 ### we might need to use some other shell than /bin/sh for running subshells
1742 ### If we are on Windows, search for the shell.  This will permit people
1743 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1744 ### without also having to set CONFIG_SHELL.  This code will work when
1745 ### using bash, which sets OSTYPE.
1746 case "${OSTYPE}" in
1747 *win32*)
1748   if test x${CONFIG_SHELL} = x ; then
1749     if test ! -f /bin/sh ; then
1750       if test x${SHELL} != x && test -f ${SHELL} ; then
1751         CONFIG_SHELL=${SHELL}
1752         export CONFIG_SHELL
1753       else
1754         for prog in sh sh.exe bash bash.exe; do
1755           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1756           for dir in $PATH; do
1757             test -z "$dir" && dir=.
1758             if test -f $dir/$prog; then
1759               CONFIG_SHELL=$dir/$prog
1760               export CONFIG_SHELL
1761               break
1762             fi
1763           done
1764           IFS="$save_ifs"
1765           test -n "${CONFIG_SHELL}" && break
1766         done
1767       fi
1768     fi
1769   fi
1770   ;;
1771 esac
1772
1773 config_shell=${CONFIG_SHELL-/bin/sh}
1774
1775 progname=$0
1776 # if PWD already has a value, it is probably wrong.
1777 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1778
1779 # Export original configure arguments for use by sub-configures.
1780 # Quote arguments with shell meta charatcers.
1781 TOPLEVEL_CONFIGURE_ARGUMENTS=
1782 set -- "$progname" "$@"
1783 for ac_arg
1784 do
1785   case "$ac_arg" in
1786   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1787     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1788     # if the argument is of the form -foo=baz, quote the baz part only
1789     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1790   *) ;;
1791   esac
1792   # Add the quoted argument to the list.
1793   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1794 done
1795 if test "$silent" = yes; then
1796   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1797 fi
1798 # Remove the initial space we just introduced and, as these will be
1799 # expanded by make, quote '$'.
1800 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1801
1802
1803 moveifchange=${srcdir}/move-if-change
1804
1805 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1806
1807 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1808 # a relative path.
1809 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1810   INSTALL="${srcpwd}/install-sh -c"
1811 fi
1812
1813 # Set srcdir to "." if that's what it is.
1814 # This is important for multilib support.
1815 pwd=`${PWDCMD-pwd}`
1816 if test "${pwd}" = "${srcpwd}" ; then
1817   srcdir=.
1818 fi
1819
1820 topsrcdir=$srcpwd
1821
1822 extra_host_args=
1823
1824 ### To add a new directory to the tree, first choose whether it is a target
1825 ### or a host dependent tool.  Then put it into the appropriate list
1826 ### (library or tools, host or target), doing a dependency sort.
1827
1828 # Subdirs will be configured in the order listed in build_configdirs,
1829 # configdirs, or target_configdirs; see the serialization section below.
1830
1831 # Dependency sorting is only needed when *configuration* must be done in
1832 # a particular order.  In all cases a dependency should be specified in
1833 # the Makefile, whether or not it's implicitly specified here.
1834
1835 # Double entries in build_configdirs, configdirs, or target_configdirs may
1836 # cause circular dependencies and break everything horribly.
1837
1838 # these library is used by various programs built for the build
1839 # environment
1840 #
1841 build_libs="build-libiberty"
1842
1843 # these tools are built for the build environment
1844 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1845
1846 # these libraries are used by various programs built for the host environment
1847 #
1848 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1849
1850 # these tools are built for the host environment
1851 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1852 # know that we are building the simulator.
1853 # binutils, gas and ld appear in that order because it makes sense to run
1854 # "make check" in that particular order.
1855 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"
1856
1857 # libgcj represents the runtime libraries only used by gcj.
1858 libgcj="target-libffi \
1859         target-zlib \
1860         target-qthreads \
1861         target-libjava"
1862
1863 # these libraries are built for the target environment, and are built after
1864 # the host libraries and the host tools (which may be a cross compiler)
1865 #
1866 target_libraries="target-libgcc \
1867                 target-libiberty \
1868                 target-libgloss \
1869                 target-newlib \
1870                 target-libgomp \
1871                 target-libstdc++-v3 \
1872                 target-libmudflap \
1873                 target-libssp \
1874                 target-libgfortran \
1875                 target-boehm-gc \
1876                 ${libgcj} \
1877                 target-libobjc \
1878                 target-libada"
1879
1880 # these tools are built using the target libraries, and are intended to
1881 # run only in the target environment
1882 #
1883 # note: any program that *uses* libraries that are in the "target_libraries"
1884 # list belongs in this list.  those programs are also very likely
1885 # candidates for the "native_only" list which follows
1886 #
1887 target_tools="target-examples target-groff target-gperf target-rda"
1888
1889 ################################################################################
1890
1891 ## All tools belong in one of the four categories, and are assigned above
1892 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1893 ## is important because configure will choke if they ever get through.
1894 ## ${configdirs} is directories we build using the host tools.
1895 ## ${target_configdirs} is directories we build using the target tools.
1896 configdirs=`echo ${host_libs} ${host_tools}`
1897 target_configdirs=`echo ${target_libraries} ${target_tools}`
1898 build_configdirs=`echo ${build_libs} ${build_tools}`
1899
1900
1901
1902 ################################################################################
1903
1904 srcname="gnu development package"
1905
1906 # This gets set non-empty for some net releases of packages.
1907 appdirs=""
1908
1909 # Define is_cross_compiler to save on calls to 'test'.
1910 is_cross_compiler=
1911 if test x"${host}" = x"${target}" ; then
1912   is_cross_compiler=no
1913 else
1914   is_cross_compiler=yes
1915 fi
1916
1917 # Find the build and target subdir names.
1918
1919 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1920 # have matching libraries, they should use host libraries: Makefile.tpl
1921 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1922 # However, they still use the build modules, because the corresponding
1923 # host modules (e.g. bison) are only built for the host when bootstrap
1924 # finishes. So:
1925 # - build_subdir is where we find build modules, and never changes.
1926 # - build_libsubdir is where we find build libraries, and can be overridden.
1927
1928 # Prefix 'build-' so this never conflicts with target_subdir.
1929 build_subdir="build-${build_noncanonical}"
1930
1931 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1932 if test "${with_build_libsubdir+set}" = set; then
1933   withval="$with_build_libsubdir"
1934   build_libsubdir="$withval"
1935 else
1936   build_libsubdir="$build_subdir"
1937 fi;
1938 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1939 if ( test $srcdir = . && test -d gcc ) \
1940    || test -d $srcdir/../host-${host_noncanonical}; then
1941   host_subdir="host-${host_noncanonical}"
1942 else
1943   host_subdir=.
1944 fi
1945 # No prefix.
1946 target_subdir=${target_noncanonical}
1947
1948
1949 # Skipdirs are removed silently.
1950 skipdirs=
1951 # Noconfigdirs are removed loudly.
1952 noconfigdirs=""
1953
1954 use_gnu_ld=
1955 # Make sure we don't let GNU ld be added if we didn't want it.
1956 if test x$with_gnu_ld = xno ; then
1957   use_gnu_ld=no
1958   noconfigdirs="$noconfigdirs ld"
1959 fi
1960
1961 use_gnu_as=
1962 # Make sure we don't let GNU as be added if we didn't want it.
1963 if test x$with_gnu_as = xno ; then
1964   use_gnu_as=no
1965   noconfigdirs="$noconfigdirs gas"
1966 fi
1967
1968 # some tools are so dependent upon X11 that if we're not building with X,
1969 # it's not even worth trying to configure, much less build, that tool.
1970
1971 case ${with_x} in
1972   yes | "") ;; # the default value for this tree is that X11 is available
1973   no)
1974     skipdirs="${skipdirs} tk itcl libgui"
1975     # We won't be able to build gdbtk without X.
1976     enable_gdbtk=no
1977     ;;
1978   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1979 esac
1980
1981 # Some tools are only suitable for building in a "native" situation.
1982 # Remove these if host!=target.
1983 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"
1984
1985 # Similarly, some are only suitable for cross toolchains.
1986 # Remove these if host=target.
1987 cross_only="target-libgloss target-newlib target-opcodes"
1988
1989 case $is_cross_compiler in
1990   no) skipdirs="${skipdirs} ${cross_only}" ;;
1991   yes) skipdirs="${skipdirs} ${native_only}" ;;
1992 esac
1993
1994 # If both --with-headers and --with-libs are specified, default to
1995 # --without-newlib.
1996 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
1997    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
1998   if test x"${with_newlib}" = x ; then
1999     with_newlib=no
2000   fi
2001 fi
2002
2003 # Recognize --with-newlib/--without-newlib.
2004 case ${with_newlib} in
2005   no) skipdirs="${skipdirs} target-newlib" ;;
2006   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2007 esac
2008
2009 # Configure extra directories which are host specific
2010
2011 case "${host}" in
2012   *-cygwin*)
2013     configdirs="$configdirs libtermcap" ;;
2014 esac
2015
2016 # A target can indicate whether a language isn't supported for some reason.
2017 # Only spaces may be used in this macro; not newlines or tabs.
2018 unsupported_languages=
2019
2020 # Remove more programs from consideration, based on the host or
2021 # target this usually means that a port of the program doesn't
2022 # exist yet.
2023
2024 case "${host}" in
2025   hppa*64*-*-*)
2026     noconfigdirs="$noconfigdirs byacc"
2027     ;;
2028   i[3456789]86-*-vsta)
2029     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2030     ;;
2031   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2032     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2033     ;;
2034   x86_64-*-mingw*)
2035     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2036     ;;
2037   i[3456789]86-*-mingw32*)
2038     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2039     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2040     ;;
2041   i[3456789]86-*-beos*)
2042     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2043     ;;
2044   *-*-cygwin*)
2045     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2046     ;;
2047   *-*-netbsd*)
2048     noconfigdirs="$noconfigdirs rcs"
2049     ;;
2050   ppc*-*-pe)
2051     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2052     ;;
2053   powerpc-*-beos*)
2054     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2055     ;;
2056 esac
2057
2058
2059 # Check whether --enable-libada or --disable-libada was given.
2060 if test "${enable_libada+set}" = set; then
2061   enableval="$enable_libada"
2062   ENABLE_LIBADA=$enableval
2063 else
2064   ENABLE_LIBADA=yes
2065 fi;
2066 if test "${ENABLE_LIBADA}" != "yes" ; then
2067   noconfigdirs="$noconfigdirs gnattools"
2068 fi
2069
2070 # Check whether --enable-libssp or --disable-libssp was given.
2071 if test "${enable_libssp+set}" = set; then
2072   enableval="$enable_libssp"
2073   ENABLE_LIBSSP=$enableval
2074 else
2075   ENABLE_LIBSSP=yes
2076 fi;
2077
2078 # Save it here so that, even in case of --enable-libgcj, if the Java
2079 # front-end isn't enabled, we still get libgcj disabled.
2080 libgcj_saved=$libgcj
2081 case $enable_libgcj in
2082 yes)
2083   # If we reset it here, it won't get added to noconfigdirs in the
2084   # target-specific build rules, so it will be forcibly enabled
2085   # (unless the Java language itself isn't enabled).
2086   libgcj=
2087   ;;
2088 no)
2089   # Make sure we get it printed in the list of not supported target libs.
2090   noconfigdirs="$noconfigdirs ${libgcj}"
2091   ;;
2092 esac
2093
2094
2095 # Disable libmudflap on some systems.
2096 if test x$enable_libmudflap = x ; then
2097     case "${target}" in
2098     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2099         # Enable libmudflap by default in GNU and friends.
2100         ;;
2101     *-*-freebsd*)
2102         # Enable libmudflap by default in FreeBSD.
2103         ;;
2104     *)
2105         # Disable it by default everywhere else.
2106         noconfigdirs="$noconfigdirs target-libmudflap"
2107         ;;
2108     esac
2109 fi
2110
2111 # Disable libgomp on non POSIX hosted systems.
2112 if test x$enable_libgomp = x ; then
2113     # Enable libgomp by default on hosted POSIX systems.
2114     case "${target}" in
2115     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2116         ;;
2117     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2118         ;;
2119     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2120         ;;
2121     *-*-darwin* | *-*-aix*)
2122         ;;
2123     *)
2124         noconfigdirs="$noconfigdirs target-libgomp"
2125         ;;
2126     esac
2127 fi
2128
2129 # Default libgloss CPU subdirectory.
2130 libgloss_dir="$target_cpu"
2131
2132 case "${target}" in
2133   *-*-chorusos)
2134     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2135     ;;
2136   powerpc-*-darwin* | i[3456789]86-*-darwin* | x86_64-*-darwin9*)
2137     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2138     noconfigdirs="$noconfigdirs sim target-rda"
2139     ;;
2140   *-*-darwin*)
2141     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2142     noconfigdirs="$noconfigdirs sim target-rda"
2143     noconfigdirs="$noconfigdirs ${libgcj}"
2144     ;;
2145   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2146     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2147     ;;
2148   *-*-freebsd*)
2149     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2150     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2151         && test -f /usr/local/include/gmp.h; then
2152       with_gmp=/usr/local
2153     fi
2154
2155     # Skip some stuff that's unsupported on some FreeBSD configurations.
2156     case "${target}" in
2157       i*86-*-*) ;;
2158       alpha*-*-*) ;;
2159       *)
2160         noconfigdirs="$noconfigdirs ${libgcj}"
2161         ;;
2162     esac
2163     ;;
2164   *-*-kaos*)
2165     # Remove unsupported stuff on all kaOS configurations.
2166     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2167     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2168     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2169     noconfigdirs="$noconfigdirs target-libgloss"
2170     ;;
2171   *-*-netbsd*)
2172     # Skip some stuff on all NetBSD configurations.
2173     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2174
2175     # Skip some stuff that's unsupported on some NetBSD configurations.
2176     case "${target}" in
2177       i*86-*-netbsdelf*) ;;
2178       arm*-*-netbsdelf*) ;;
2179       *)
2180         noconfigdirs="$noconfigdirs ${libgcj}"
2181         ;;
2182     esac
2183     ;;
2184   *-*-netware*)
2185     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2186     ;;
2187   *-*-rtems*)
2188     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2189     ;;
2190     # The tpf target doesn't support gdb yet.
2191   *-*-tpf*)
2192     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2193     ;;
2194   *-*-uclinux*)
2195     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2196     ;;
2197   *-*-vxworks*)
2198     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2199     ;;
2200   alpha*-dec-osf*)
2201     # ld works, but does not support shared libraries.
2202     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2203     # gas doesn't generate exception information.
2204     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2205     ;;
2206   alpha*-*-*vms*)
2207     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2208     ;;
2209   alpha*-*-linux*)
2210     # newlib is not 64 bit ready
2211     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2212     ;;
2213   alpha*-*-*)
2214     # newlib is not 64 bit ready
2215     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2216     ;;
2217   am33_2.0-*-linux*)
2218     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2219     ;;
2220   sh-*-linux*)
2221     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2222     ;;
2223   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2224     noconfigdirs="$noconfigdirs ${libgcj}"
2225     noconfigdirs="$noconfigdirs target-examples"
2226     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2227     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2228     noconfigdirs="$noconfigdirs expect dejagnu"
2229     # the C++ libraries don't build on top of CE's C libraries
2230     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2231     noconfigdirs="$noconfigdirs target-newlib"
2232     case "${host}" in
2233       *-*-cygwin*) ;; # keep gdb and readline
2234       *) noconfigdirs="$noconfigdirs gdb readline"
2235          ;;
2236     esac
2237     libgloss_dir=wince
2238     ;;
2239   arc-*-*)
2240     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2241     ;;
2242   arm-semi-aof )
2243     ;;
2244   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2245     noconfigdirs="$noconfigdirs ${libgcj}"
2246     libgloss_dir=arm
2247     ;;
2248   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2249     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2250     libgloss_dir=arm
2251     ;;
2252   arm*-*-linux-gnueabi)
2253     noconfigdirs="$noconfigdirs target-qthreads"
2254     noconfigdirs="$noconfigdirs target-libobjc"
2255     case ${with_newlib} in
2256       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2257     esac
2258     libgloss_dir=arm
2259     ;;
2260   arm*-*-symbianelf*)
2261     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2262     libgloss_dir=arm
2263     ;;
2264   arm-*-pe*)
2265     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2266     ;;
2267   thumb-*-coff)
2268     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2269     ;;
2270   thumb-*-elf)
2271     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2272     ;;
2273   thumb-*-pe)
2274     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2275     ;;
2276   arm-*-riscix*)
2277     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2278     ;;
2279   avr-*-*)
2280     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2281     ;;
2282   bfin-*-*)
2283     noconfigdirs="$noconfigdirs gdb"
2284     if test x${is_cross_compiler} != xno ; then
2285       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2286     fi
2287     ;;
2288   c4x-*-* | tic4x-*-*)
2289     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2290     ;;
2291   c54x*-*-* | tic54x-*-*)
2292     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2293     ;;
2294   cris-*-* | crisv32-*-*)
2295     unsupported_languages="$unsupported_languages java"
2296     case "${target}" in
2297       *-*-aout)
2298         unsupported_languages="$unsupported_languages fortran"
2299         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2300       *-*-elf)
2301         noconfigdirs="$noconfigdirs target-boehm-gc";;
2302       *-*-linux*)
2303         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2304       *)
2305         unsupported_languages="$unsupported_languages fortran"
2306         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2307     esac
2308     libgloss_dir=cris
2309     ;;
2310   crx-*-*)
2311     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2312     ;;
2313   d10v-*-*)
2314     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2315     ;;
2316   d30v-*-*)
2317     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2318     ;;
2319   ep9312-*-elf | ep9312-*-coff)
2320     libgloss_dir=arm
2321     ;;
2322   fr30-*-elf*)
2323     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2324     ;;
2325   frv-*-*)
2326     noconfigdirs="$noconfigdirs ${libgcj}"
2327     ;;
2328   h8300*-*-*)
2329     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2330     ;;
2331   h8500-*-*)
2332     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2333     ;;
2334   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2335     ;;
2336   hppa*64*-*-linux* | parisc*64*-*-linux*)
2337     # In this case, it's because the hppa64-linux target is for
2338     # the kernel only at this point and has no libc, and thus no
2339     # headers, crt*.o, etc., all of which are needed by these.
2340     noconfigdirs="$noconfigdirs target-zlib"
2341     ;;
2342   parisc*-*-linux* | hppa*-*-linux*)
2343     ;;
2344   hppa*-*-*elf* | \
2345   hppa*-*-lites* | \
2346   hppa*-*-openbsd* | \
2347   hppa*64*-*-*)
2348     noconfigdirs="$noconfigdirs ${libgcj}"
2349     ;;
2350   hppa*-hp-hpux11*)
2351     noconfigdirs="$noconfigdirs ld shellutils"
2352     ;;
2353   hppa*-*-pro*)
2354     libgloss_dir=pa
2355     ;;
2356   hppa*-*-*)
2357     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2358     # build on HP-UX 10.20.
2359     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2360     ;;
2361   i960-*-*)
2362     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2363     ;;
2364   ia64*-*-elf*)
2365     # No gdb support yet.
2366     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2367     ;;
2368   ia64*-**-hpux*)
2369     # No gdb or ld support yet.
2370     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2371     ;;
2372   i370-*-opened*)
2373     ;;
2374   i[3456789]86-*-coff | i[3456789]86-*-elf)
2375     noconfigdirs="$noconfigdirs ${libgcj}"
2376     libgloss_dir=i386
2377     ;;
2378   i[3456789]86-*-linux*)
2379     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2380     # not build java stuff by default.
2381     case "${target}" in
2382       *-*-*libc1*)
2383         noconfigdirs="$noconfigdirs ${libgcj}";;
2384     esac
2385
2386     # This section makes it possible to build newlib natively on linux.
2387     # If we are using a cross compiler then don't configure newlib.
2388     if test x${is_cross_compiler} != xno ; then
2389       noconfigdirs="$noconfigdirs target-newlib"
2390     fi
2391     noconfigdirs="$noconfigdirs target-libgloss"
2392     # If we are not using a cross compiler, do configure newlib.
2393     # Note however, that newlib will only be configured in this situation
2394     # if the --with-newlib option has been given, because otherwise
2395     # 'target-newlib' will appear in skipdirs.
2396     ;;
2397   i[3456789]86-*-mingw32*)
2398     target_configdirs="$target_configdirs target-winsup"
2399     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2400     ;;
2401   x86_64-*-mingw*)
2402     target_configdirs="$target_configdirs target-winsup"
2403     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2404     ;;
2405   *-*-cygwin*)
2406     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2407     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2408     # always build newlib if winsup directory is present.
2409     if test -d "$srcdir/winsup/cygwin"; then
2410       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2411     elif test -d "$srcdir/newlib"; then
2412       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2413     fi
2414     ;;
2415   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2416   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2417     ;;
2418   i[3456789]86-*-pe)
2419     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2420     ;;
2421   i[3456789]86-*-sco3.2v5*)
2422     # The linker does not yet know about weak symbols in COFF,
2423     # and is not configured to handle mixed ELF and COFF.
2424     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2425     ;;
2426   i[3456789]86-*-sco*)
2427     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2428     ;;
2429   i[3456789]86-*-solaris2*)
2430     noconfigdirs="$noconfigdirs target-libgloss"
2431     ;;
2432   i[3456789]86-*-sysv4*)
2433     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2434     ;;
2435   i[3456789]86-*-beos*)
2436     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2437     ;;
2438   i[3456789]86-*-rdos*)
2439     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2440     ;;
2441   m32r-*-*)
2442     noconfigdirs="$noconfigdirs ${libgcj}"
2443     ;;
2444   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2445     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2446     libgloss_dir=m68hc11
2447     ;;
2448   m68k-*-elf*)
2449     noconfigdirs="$noconfigdirs ${libgcj}"
2450     ;;
2451   m68k-*-coff*)
2452     noconfigdirs="$noconfigdirs ${libgcj}"
2453     ;;
2454   m68*-*-* | fido-*-*)
2455     libgloss_dir=m68k
2456     ;;
2457   mcore-*-pe*)
2458   # The EPOC C++ environment does not support exceptions or rtti,
2459   # and so building libstdc++-v3 tends not to always work.
2460     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2461     ;;
2462   mmix-*-*)
2463     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2464     unsupported_languages="$unsupported_languages fortran java"
2465     ;;
2466   mn10200-*-*)
2467     noconfigdirs="$noconfigdirs ${libgcj}"
2468     ;;
2469   mn10300-*-*)
2470     noconfigdirs="$noconfigdirs ${libgcj}"
2471     ;;
2472   mt-*-*)
2473     noconfigdirs="$noconfigdirs sim"
2474     ;;
2475   powerpc-*-aix*)
2476     # copied from rs6000-*-* entry
2477     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2478     ;;
2479   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2480     target_configdirs="$target_configdirs target-winsup"
2481     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2482     # always build newlib.
2483     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2484     ;;
2485     # This is temporary until we can link against shared libraries
2486   powerpcle-*-solaris*)
2487     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2488     libgloss_dir=rs6000
2489     ;;
2490   powerpc-*-beos*)
2491     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2492     ;;
2493   powerpc-*-eabi)
2494     noconfigdirs="$noconfigdirs ${libgcj}"
2495     libgloss_dir=rs6000
2496     ;;
2497   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2498     libgloss_dir=rs6000
2499     ;;
2500   rs6000-*-lynxos*)
2501     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2502     ;;
2503   rs6000-*-aix*)
2504     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2505     ;;
2506   rs6000-*-*)
2507     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2508     ;;
2509   m68k-apollo-*)
2510     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2511     ;;
2512   mips*-sde-elf*)
2513     skipdirs="$skipdirs target-libiberty"
2514     noconfigdirs="$noconfigdirs ${libgcj}"
2515     if test x$with_newlib = xyes; then
2516       noconfigdirs="$noconfigdirs gprof"
2517     fi
2518     libgloss_dir=mips
2519     ;;
2520   mips*-*-irix5*)
2521     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2522     ;;
2523   mips*-*-irix6*)
2524     # Linking libjava exceeds command-line length limits on at least
2525     # IRIX 6.2, but not on IRIX 6.5.
2526     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2527     # <oldham@codesourcery.com>
2528     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2529     ;;
2530   mips*-*-bsd*)
2531     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2532     ;;
2533   mips*-*-linux*)
2534     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2535     ;;
2536   mips*-*-*)
2537     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2538     libgloss_dir=mips
2539     ;;
2540   romp-*-*)
2541     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2542     ;;
2543   sh-*-* | sh64-*-*)
2544     case "${host}" in
2545       i[3456789]86-*-vsta) ;; # don't add gprof back in
2546       i[3456789]86-*-go32*) ;; # don't add gprof back in
2547       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2548       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2549     esac
2550     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2551     ;;
2552   sparclet-*-aout* | sparc86x-*-*)
2553     libgloss_dir=sparc
2554     ;;
2555   sparc-*-elf*)
2556     noconfigdirs="$noconfigdirs ${libgcj}"
2557     ;;
2558   sparc64-*-elf*)
2559     noconfigdirs="$noconfigdirs ${libgcj}"
2560     libgloss_dir=sparc
2561     ;;
2562   sparclite-*-*)
2563     noconfigdirs="$noconfigdirs ${libgcj}"
2564     libgloss_dir=sparc
2565     ;;
2566   sparc-*-sunos4*)
2567     noconfigdirs="$noconfigdirs ${libgcj}"
2568     if test x${is_cross_compiler} != xno ; then
2569            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2570     else
2571            use_gnu_ld=no
2572     fi
2573     ;;
2574   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2575     noconfigdirs="$noconfigdirs ${libgcj}"
2576     ;;
2577   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2578     ;;
2579   spu-*-*)
2580     skipdirs="target-libssp"
2581     ;;
2582   v810-*-*)
2583     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2584     ;;
2585   v850-*-*)
2586     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2587     ;;
2588   v850e-*-*)
2589     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2590     ;;
2591   v850ea-*-*)
2592     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2593     ;;
2594   vax-*-vms)
2595     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2596     ;;
2597   vax-*-*)
2598     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2599     ;;
2600   xtensa*-*-*)
2601     noconfigdirs="$noconfigdirs ${libgcj}"
2602     ;;
2603   ip2k-*-*)
2604     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2605     ;;
2606   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2607     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2608     ;;
2609   *-*-lynxos*)
2610     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2611     ;;
2612   *-*-*)
2613     noconfigdirs="$noconfigdirs ${libgcj}"
2614     ;;
2615 esac
2616
2617 # If we aren't building newlib, then don't build libgloss, since libgloss
2618 # depends upon some newlib header files.
2619 case "${noconfigdirs}" in
2620   *target-libgloss*) ;;
2621   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2622 esac
2623
2624 # Work in distributions that contain no compiler tools, like Autoconf.
2625 tentative_cc=""
2626 host_makefile_frag=/dev/null
2627 if test -d ${srcdir}/config ; then
2628 case "${host}" in
2629   m68k-hp-hpux*)
2630     # Avoid "too much defining" errors from HPUX compiler.
2631     tentative_cc="cc -Wp,-H256000"
2632     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2633     # If it's HP/UX ar, this should be harmless.
2634     RANLIB="ar ts"
2635     ;;
2636   m68k-apollo-sysv*)
2637     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2638     ;;
2639   m68k-apollo-bsd*)
2640     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2641     # chokes on bfd, the compiler won't let you assign integers to enums, and
2642     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2643     # the apollo compiler" (the preferred version of GCC could be called cc,
2644     # or whatever), but I'm not sure leaving CC as cc is any better...
2645     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2646     # Used to have BISON=yacc.
2647     tentative_cc=gcc
2648     ;;
2649   m88k-dg-dgux*)
2650     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2651     ;;
2652   m88k-harris-cxux*)
2653     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2654     tentative_cc="cc -Xa"
2655     host_makefile_frag="config/mh-cxux"
2656     ;;
2657   m88k-motorola-sysv*)
2658     ;;
2659   mips*-dec-ultrix*)
2660     tentative_cc="cc -Wf,-XNg1000"
2661     host_makefile_frag="config/mh-decstation"
2662     ;;
2663   mips*-nec-sysv4*)
2664     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2665     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2666     host_makefile_frag="config/mh-necv4"
2667     ;;
2668   mips*-sgi-irix4*)
2669     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2670     # environment.  Also bump switch table size so that cp-parse will
2671     # compile.  Bump string length limit so linker builds.
2672     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2673     ;;
2674   mips*-*-sysv4*)
2675     host_makefile_frag="config/mh-sysv4"
2676     ;;
2677   mips*-*-sysv*)
2678     # This is for a MIPS running RISC/os 4.52C.
2679
2680     # This is needed for GDB, but needs to be in the top-level make because
2681     # if a library is compiled with the bsd headers and gets linked with the
2682     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2683     # a different size).
2684     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2685     # known except to select the sysv environment.  Could we use /proc instead?
2686     # These "sysv environments" and "bsd environments" often end up being a pain.
2687     #
2688     # This is not part of CFLAGS because perhaps not all C compilers have this
2689     # option.
2690     tentative_cc="cc -systype sysv"
2691     ;;
2692   i370-ibm-opened*)
2693     tentative_cc="c89"
2694     ;;
2695   i[3456789]86-*-sysv5*)
2696     host_makefile_frag="config/mh-sysv5"
2697     ;;
2698   i[3456789]86-*-dgux*)
2699     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2700     host_makefile_frag="config/mh-dgux386"
2701     ;;
2702   i[3456789]86-ncr-sysv4.3*)
2703     # The MetaWare compiler will generate a copyright message unless you
2704     # turn it off by adding the -Hnocopyr flag.
2705     tentative_cc="cc -Hnocopyr"
2706     ;;
2707   i[3456789]86-ncr-sysv4*)
2708     # for an NCR 3000 (i486/SVR4) system.
2709     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2710     # This compiler not only emits obnoxious copyright messages every time
2711     # you run it, but it chokes and dies on a whole bunch of GNU source
2712     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2713     tentative_cc="/usr/ccs/ATT/cc"
2714     host_makefile_frag="config/mh-ncr3000"
2715     ;;
2716   i[3456789]86-*-sco3.2v5*)
2717     ;;
2718   i[3456789]86-*-sco*)
2719     # The native C compiler botches some simple uses of const.  Unfortunately,
2720     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2721     tentative_cc="cc -Dconst="
2722     host_makefile_frag="config/mh-sco"
2723     ;;
2724   i[3456789]86-*-udk*)
2725     host_makefile_frag="config/mh-sysv5"
2726     ;;
2727   i[3456789]86-*-solaris2*)
2728     host_makefile_frag="config/mh-sysv4"
2729     ;;
2730   i[3456789]86-*-msdosdjgpp*)
2731     host_makefile_frag="config/mh-djgpp"
2732     ;;
2733   *-cygwin*)
2734     host_makefile_frag="config/mh-cygwin"
2735     ;;
2736   *-mingw32*)
2737     host_makefile_frag="config/mh-mingw"
2738     ;;
2739   *-mingw64*)
2740     host_makefile_frag="config/mh-mingw"
2741     ;;
2742   *-interix*)
2743     host_makefile_frag="config/mh-interix"
2744     ;;
2745   vax-*-ultrix2*)
2746     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2747     tentative_cc=gcc
2748     ;;
2749   *-*-solaris2*)
2750     host_makefile_frag="config/mh-solaris"
2751     ;;
2752   m68k-sun-sunos*)
2753     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2754     # without overflowing the jump tables (-J says to use a 32 bit table)
2755     tentative_cc="cc -J"
2756     ;;
2757   *-hp-hpux*)
2758     tentative_cc="cc -Wp,-H256000"
2759     ;;
2760   *-*-hiux*)
2761     tentative_cc="cc -Wp,-H256000"
2762     ;;
2763   rs6000-*-lynxos*)
2764     # /bin/cc is less than useful for our purposes.  Always use GCC
2765     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2766     host_makefile_frag="config/mh-lynxrs6k"
2767     ;;
2768   powerpc-*-darwin*)
2769     host_makefile_frag="config/mh-ppc-darwin"
2770     ;;
2771   powerpc-*-aix*)
2772     host_makefile_frag="config/mh-ppc-aix"
2773     ;;
2774   rs6000-*-aix*)
2775     host_makefile_frag="config/mh-ppc-aix"
2776     ;;
2777   *-*-lynxos*)
2778     # /bin/cc is less than useful for our purposes.  Always use GCC
2779     tentative_cc="/bin/gcc"
2780     ;;
2781   *-*-sysv4*)
2782     host_makefile_frag="config/mh-sysv4"
2783     ;;
2784   # This is placed last to prevent interfering with the cases above.
2785   i[3456789]86-*-*)
2786     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2787     host_makefile_frag="config/mh-x86omitfp"
2788     ;;
2789 esac
2790 fi
2791
2792 # If we aren't going to be using gcc, see if we can extract a definition
2793 # of CC from the fragment.
2794 # Actually, use the 'pre-extracted' version above.
2795 if test -z "${CC}" && test "${build}" = "${host}" ; then
2796   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2797   found=
2798   for dir in $PATH; do
2799     test -z "$dir" && dir=.
2800     if test -f $dir/gcc; then
2801       found=yes
2802       break
2803     fi
2804   done
2805   IFS="$save_ifs"
2806   if test -z "${found}" && test -n "${tentative_cc}" ; then
2807     CC=$tentative_cc
2808   fi
2809 fi
2810
2811 if test "${build}" != "${host}" ; then
2812   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2813   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2814   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2815   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2816   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2817   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2818   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2819   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2820   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2821   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2822   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2823   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2824 else
2825   AR_FOR_BUILD="\$(AR)"
2826   AS_FOR_BUILD="\$(AS)"
2827   CC_FOR_BUILD="\$(CC)"
2828   CXX_FOR_BUILD="\$(CXX)"
2829   GCJ_FOR_BUILD="\$(GCJ)"
2830   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2831   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2832   LD_FOR_BUILD="\$(LD)"
2833   NM_FOR_BUILD="\$(NM)"
2834   RANLIB_FOR_BUILD="\$(RANLIB)"
2835   WINDRES_FOR_BUILD="\$(WINDRES)"
2836   WINDMC_FOR_BUILD="\$(WINDMC)"
2837 fi
2838
2839 ac_ext=c
2840 ac_cpp='$CPP $CPPFLAGS'
2841 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2842 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2843 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2844 if test -n "$ac_tool_prefix"; then
2845   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2846 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2847 echo "$as_me:$LINENO: checking for $ac_word" >&5
2848 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2849 if test "${ac_cv_prog_CC+set}" = set; then
2850   echo $ECHO_N "(cached) $ECHO_C" >&6
2851 else
2852   if test -n "$CC"; then
2853   ac_cv_prog_CC="$CC" # Let the user override the test.
2854 else
2855 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2856 for as_dir in $PATH
2857 do
2858   IFS=$as_save_IFS
2859   test -z "$as_dir" && as_dir=.
2860   for ac_exec_ext in '' $ac_executable_extensions; do
2861   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2862     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2863     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2864     break 2
2865   fi
2866 done
2867 done
2868
2869 fi
2870 fi
2871 CC=$ac_cv_prog_CC
2872 if test -n "$CC"; then
2873   echo "$as_me:$LINENO: result: $CC" >&5
2874 echo "${ECHO_T}$CC" >&6
2875 else
2876   echo "$as_me:$LINENO: result: no" >&5
2877 echo "${ECHO_T}no" >&6
2878 fi
2879
2880 fi
2881 if test -z "$ac_cv_prog_CC"; then
2882   ac_ct_CC=$CC
2883   # Extract the first word of "gcc", so it can be a program name with args.
2884 set dummy gcc; ac_word=$2
2885 echo "$as_me:$LINENO: checking for $ac_word" >&5
2886 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2887 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2888   echo $ECHO_N "(cached) $ECHO_C" >&6
2889 else
2890   if test -n "$ac_ct_CC"; then
2891   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2892 else
2893 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2894 for as_dir in $PATH
2895 do
2896   IFS=$as_save_IFS
2897   test -z "$as_dir" && as_dir=.
2898   for ac_exec_ext in '' $ac_executable_extensions; do
2899   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2900     ac_cv_prog_ac_ct_CC="gcc"
2901     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2902     break 2
2903   fi
2904 done
2905 done
2906
2907 fi
2908 fi
2909 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2910 if test -n "$ac_ct_CC"; then
2911   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2912 echo "${ECHO_T}$ac_ct_CC" >&6
2913 else
2914   echo "$as_me:$LINENO: result: no" >&5
2915 echo "${ECHO_T}no" >&6
2916 fi
2917
2918   CC=$ac_ct_CC
2919 else
2920   CC="$ac_cv_prog_CC"
2921 fi
2922
2923 if test -z "$CC"; then
2924   if test -n "$ac_tool_prefix"; then
2925   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2926 set dummy ${ac_tool_prefix}cc; ac_word=$2
2927 echo "$as_me:$LINENO: checking for $ac_word" >&5
2928 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2929 if test "${ac_cv_prog_CC+set}" = set; then
2930   echo $ECHO_N "(cached) $ECHO_C" >&6
2931 else
2932   if test -n "$CC"; then
2933   ac_cv_prog_CC="$CC" # Let the user override the test.
2934 else
2935 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2936 for as_dir in $PATH
2937 do
2938   IFS=$as_save_IFS
2939   test -z "$as_dir" && as_dir=.
2940   for ac_exec_ext in '' $ac_executable_extensions; do
2941   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2942     ac_cv_prog_CC="${ac_tool_prefix}cc"
2943     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2944     break 2
2945   fi
2946 done
2947 done
2948
2949 fi
2950 fi
2951 CC=$ac_cv_prog_CC
2952 if test -n "$CC"; then
2953   echo "$as_me:$LINENO: result: $CC" >&5
2954 echo "${ECHO_T}$CC" >&6
2955 else
2956   echo "$as_me:$LINENO: result: no" >&5
2957 echo "${ECHO_T}no" >&6
2958 fi
2959
2960 fi
2961 if test -z "$ac_cv_prog_CC"; then
2962   ac_ct_CC=$CC
2963   # Extract the first word of "cc", so it can be a program name with args.
2964 set dummy cc; ac_word=$2
2965 echo "$as_me:$LINENO: checking for $ac_word" >&5
2966 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2967 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2968   echo $ECHO_N "(cached) $ECHO_C" >&6
2969 else
2970   if test -n "$ac_ct_CC"; then
2971   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2972 else
2973 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2974 for as_dir in $PATH
2975 do
2976   IFS=$as_save_IFS
2977   test -z "$as_dir" && as_dir=.
2978   for ac_exec_ext in '' $ac_executable_extensions; do
2979   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2980     ac_cv_prog_ac_ct_CC="cc"
2981     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2982     break 2
2983   fi
2984 done
2985 done
2986
2987 fi
2988 fi
2989 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2990 if test -n "$ac_ct_CC"; then
2991   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2992 echo "${ECHO_T}$ac_ct_CC" >&6
2993 else
2994   echo "$as_me:$LINENO: result: no" >&5
2995 echo "${ECHO_T}no" >&6
2996 fi
2997
2998   CC=$ac_ct_CC
2999 else
3000   CC="$ac_cv_prog_CC"
3001 fi
3002
3003 fi
3004 if test -z "$CC"; then
3005   # Extract the first word of "cc", so it can be a program name with args.
3006 set dummy cc; ac_word=$2
3007 echo "$as_me:$LINENO: checking for $ac_word" >&5
3008 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3009 if test "${ac_cv_prog_CC+set}" = set; then
3010   echo $ECHO_N "(cached) $ECHO_C" >&6
3011 else
3012   if test -n "$CC"; then
3013   ac_cv_prog_CC="$CC" # Let the user override the test.
3014 else
3015   ac_prog_rejected=no
3016 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3017 for as_dir in $PATH
3018 do
3019   IFS=$as_save_IFS
3020   test -z "$as_dir" && as_dir=.
3021   for ac_exec_ext in '' $ac_executable_extensions; do
3022   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3023     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3024        ac_prog_rejected=yes
3025        continue
3026      fi
3027     ac_cv_prog_CC="cc"
3028     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3029     break 2
3030   fi
3031 done
3032 done
3033
3034 if test $ac_prog_rejected = yes; then
3035   # We found a bogon in the path, so make sure we never use it.
3036   set dummy $ac_cv_prog_CC
3037   shift
3038   if test $# != 0; then
3039     # We chose a different compiler from the bogus one.
3040     # However, it has the same basename, so the bogon will be chosen
3041     # first if we set CC to just the basename; use the full file name.
3042     shift
3043     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3044   fi
3045 fi
3046 fi
3047 fi
3048 CC=$ac_cv_prog_CC
3049 if test -n "$CC"; then
3050   echo "$as_me:$LINENO: result: $CC" >&5
3051 echo "${ECHO_T}$CC" >&6
3052 else
3053   echo "$as_me:$LINENO: result: no" >&5
3054 echo "${ECHO_T}no" >&6
3055 fi
3056
3057 fi
3058 if test -z "$CC"; then
3059   if test -n "$ac_tool_prefix"; then
3060   for ac_prog in cl
3061   do
3062     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3063 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3064 echo "$as_me:$LINENO: checking for $ac_word" >&5
3065 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3066 if test "${ac_cv_prog_CC+set}" = set; then
3067   echo $ECHO_N "(cached) $ECHO_C" >&6
3068 else
3069   if test -n "$CC"; then
3070   ac_cv_prog_CC="$CC" # Let the user override the test.
3071 else
3072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3073 for as_dir in $PATH
3074 do
3075   IFS=$as_save_IFS
3076   test -z "$as_dir" && as_dir=.
3077   for ac_exec_ext in '' $ac_executable_extensions; do
3078   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3079     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3080     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3081     break 2
3082   fi
3083 done
3084 done
3085
3086 fi
3087 fi
3088 CC=$ac_cv_prog_CC
3089 if test -n "$CC"; then
3090   echo "$as_me:$LINENO: result: $CC" >&5
3091 echo "${ECHO_T}$CC" >&6
3092 else
3093   echo "$as_me:$LINENO: result: no" >&5
3094 echo "${ECHO_T}no" >&6
3095 fi
3096
3097     test -n "$CC" && break
3098   done
3099 fi
3100 if test -z "$CC"; then
3101   ac_ct_CC=$CC
3102   for ac_prog in cl
3103 do
3104   # Extract the first word of "$ac_prog", so it can be a program name with args.
3105 set dummy $ac_prog; ac_word=$2
3106 echo "$as_me:$LINENO: checking for $ac_word" >&5
3107 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3108 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3109   echo $ECHO_N "(cached) $ECHO_C" >&6
3110 else
3111   if test -n "$ac_ct_CC"; then
3112   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3113 else
3114 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3115 for as_dir in $PATH
3116 do
3117   IFS=$as_save_IFS
3118   test -z "$as_dir" && as_dir=.
3119   for ac_exec_ext in '' $ac_executable_extensions; do
3120   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3121     ac_cv_prog_ac_ct_CC="$ac_prog"
3122     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3123     break 2
3124   fi
3125 done
3126 done
3127
3128 fi
3129 fi
3130 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3131 if test -n "$ac_ct_CC"; then
3132   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3133 echo "${ECHO_T}$ac_ct_CC" >&6
3134 else
3135   echo "$as_me:$LINENO: result: no" >&5
3136 echo "${ECHO_T}no" >&6
3137 fi
3138
3139   test -n "$ac_ct_CC" && break
3140 done
3141
3142   CC=$ac_ct_CC
3143 fi
3144
3145 fi
3146
3147
3148 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3149 See \`config.log' for more details." >&5
3150 echo "$as_me: error: no acceptable C compiler found in \$PATH
3151 See \`config.log' for more details." >&2;}
3152    { (exit 1); exit 1; }; }
3153
3154 # Provide some information about the compiler.
3155 echo "$as_me:$LINENO:" \
3156      "checking for C compiler version" >&5
3157 ac_compiler=`set X $ac_compile; echo $2`
3158 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3159   (eval $ac_compiler --version </dev/null >&5) 2>&5
3160   ac_status=$?
3161   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3162   (exit $ac_status); }
3163 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3164   (eval $ac_compiler -v </dev/null >&5) 2>&5
3165   ac_status=$?
3166   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3167   (exit $ac_status); }
3168 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3169   (eval $ac_compiler -V </dev/null >&5) 2>&5
3170   ac_status=$?
3171   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3172   (exit $ac_status); }
3173
3174 cat >conftest.$ac_ext <<_ACEOF
3175 /* confdefs.h.  */
3176 _ACEOF
3177 cat confdefs.h >>conftest.$ac_ext
3178 cat >>conftest.$ac_ext <<_ACEOF
3179 /* end confdefs.h.  */
3180
3181 int
3182 main ()
3183 {
3184
3185   ;
3186   return 0;
3187 }
3188 _ACEOF
3189 ac_clean_files_save=$ac_clean_files
3190 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3191 # Try to create an executable without -o first, disregard a.out.
3192 # It will help us diagnose broken compilers, and finding out an intuition
3193 # of exeext.
3194 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3195 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3196 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3197 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3198   (eval $ac_link_default) 2>&5
3199   ac_status=$?
3200   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3201   (exit $ac_status); }; then
3202   # Find the output, starting from the most likely.  This scheme is
3203 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3204 # resort.
3205
3206 # Be careful to initialize this variable, since it used to be cached.
3207 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3208 ac_cv_exeext=
3209 # b.out is created by i960 compilers.
3210 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3211 do
3212   test -f "$ac_file" || continue
3213   case $ac_file in
3214     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3215         ;;
3216     conftest.$ac_ext )
3217         # This is the source file.
3218         ;;
3219     [ab].out )
3220         # We found the default executable, but exeext='' is most
3221         # certainly right.
3222         break;;
3223     *.* )
3224         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3225         # FIXME: I believe we export ac_cv_exeext for Libtool,
3226         # but it would be cool to find out if it's true.  Does anybody
3227         # maintain Libtool? --akim.
3228         export ac_cv_exeext
3229         break;;
3230     * )
3231         break;;
3232   esac
3233 done
3234 else
3235   echo "$as_me: failed program was:" >&5
3236 sed 's/^/| /' conftest.$ac_ext >&5
3237
3238 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3239 See \`config.log' for more details." >&5
3240 echo "$as_me: error: C compiler cannot create executables
3241 See \`config.log' for more details." >&2;}
3242    { (exit 77); exit 77; }; }
3243 fi
3244
3245 ac_exeext=$ac_cv_exeext
3246 echo "$as_me:$LINENO: result: $ac_file" >&5
3247 echo "${ECHO_T}$ac_file" >&6
3248
3249 # Check the compiler produces executables we can run.  If not, either
3250 # the compiler is broken, or we cross compile.
3251 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3252 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3253 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3254 # If not cross compiling, check that we can run a simple program.
3255 if test "$cross_compiling" != yes; then
3256   if { ac_try='./$ac_file'
3257   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3258   (eval $ac_try) 2>&5
3259   ac_status=$?
3260   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3261   (exit $ac_status); }; }; then
3262     cross_compiling=no
3263   else
3264     if test "$cross_compiling" = maybe; then
3265         cross_compiling=yes
3266     else
3267         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3268 If you meant to cross compile, use \`--host'.
3269 See \`config.log' for more details." >&5
3270 echo "$as_me: error: cannot run C compiled programs.
3271 If you meant to cross compile, use \`--host'.
3272 See \`config.log' for more details." >&2;}
3273    { (exit 1); exit 1; }; }
3274     fi
3275   fi
3276 fi
3277 echo "$as_me:$LINENO: result: yes" >&5
3278 echo "${ECHO_T}yes" >&6
3279
3280 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3281 ac_clean_files=$ac_clean_files_save
3282 # Check the compiler produces executables we can run.  If not, either
3283 # the compiler is broken, or we cross compile.
3284 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3285 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3286 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3287 echo "${ECHO_T}$cross_compiling" >&6
3288
3289 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3290 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3291 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3292   (eval $ac_link) 2>&5
3293   ac_status=$?
3294   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3295   (exit $ac_status); }; then
3296   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3297 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3298 # work properly (i.e., refer to `conftest.exe'), while it won't with
3299 # `rm'.
3300 for ac_file in conftest.exe conftest conftest.*; do
3301   test -f "$ac_file" || continue
3302   case $ac_file in
3303     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3304     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3305           export ac_cv_exeext
3306           break;;
3307     * ) break;;
3308   esac
3309 done
3310 else
3311   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3312 See \`config.log' for more details." >&5
3313 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3314 See \`config.log' for more details." >&2;}
3315    { (exit 1); exit 1; }; }
3316 fi
3317
3318 rm -f conftest$ac_cv_exeext
3319 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3320 echo "${ECHO_T}$ac_cv_exeext" >&6
3321
3322 rm -f conftest.$ac_ext
3323 EXEEXT=$ac_cv_exeext
3324 ac_exeext=$EXEEXT
3325 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3326 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3327 if test "${ac_cv_objext+set}" = set; then
3328   echo $ECHO_N "(cached) $ECHO_C" >&6
3329 else
3330   cat >conftest.$ac_ext <<_ACEOF
3331 /* confdefs.h.  */
3332 _ACEOF
3333 cat confdefs.h >>conftest.$ac_ext
3334 cat >>conftest.$ac_ext <<_ACEOF
3335 /* end confdefs.h.  */
3336
3337 int
3338 main ()
3339 {
3340
3341   ;
3342   return 0;
3343 }
3344 _ACEOF
3345 rm -f conftest.o conftest.obj
3346 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3347   (eval $ac_compile) 2>&5
3348   ac_status=$?
3349   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3350   (exit $ac_status); }; then
3351   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3352   case $ac_file in
3353     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3354     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3355        break;;
3356   esac
3357 done
3358 else
3359   echo "$as_me: failed program was:" >&5
3360 sed 's/^/| /' conftest.$ac_ext >&5
3361
3362 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3363 See \`config.log' for more details." >&5
3364 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3365 See \`config.log' for more details." >&2;}
3366    { (exit 1); exit 1; }; }
3367 fi
3368
3369 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3370 fi
3371 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3372 echo "${ECHO_T}$ac_cv_objext" >&6
3373 OBJEXT=$ac_cv_objext
3374 ac_objext=$OBJEXT
3375 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3376 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3377 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3378   echo $ECHO_N "(cached) $ECHO_C" >&6
3379 else
3380   cat >conftest.$ac_ext <<_ACEOF
3381 /* confdefs.h.  */
3382 _ACEOF
3383 cat confdefs.h >>conftest.$ac_ext
3384 cat >>conftest.$ac_ext <<_ACEOF
3385 /* end confdefs.h.  */
3386
3387 int
3388 main ()
3389 {
3390 #ifndef __GNUC__
3391        choke me
3392 #endif
3393
3394   ;
3395   return 0;
3396 }
3397 _ACEOF
3398 rm -f conftest.$ac_objext
3399 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3400   (eval $ac_compile) 2>conftest.er1
3401   ac_status=$?
3402   grep -v '^ *+' conftest.er1 >conftest.err
3403   rm -f conftest.er1
3404   cat conftest.err >&5
3405   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3406   (exit $ac_status); } &&
3407          { ac_try='test -z "$ac_c_werror_flag"
3408                          || test ! -s conftest.err'
3409   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3410   (eval $ac_try) 2>&5
3411   ac_status=$?
3412   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3413   (exit $ac_status); }; } &&
3414          { ac_try='test -s conftest.$ac_objext'
3415   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3416   (eval $ac_try) 2>&5
3417   ac_status=$?
3418   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3419   (exit $ac_status); }; }; then
3420   ac_compiler_gnu=yes
3421 else
3422   echo "$as_me: failed program was:" >&5
3423 sed 's/^/| /' conftest.$ac_ext >&5
3424
3425 ac_compiler_gnu=no
3426 fi
3427 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3428 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3429
3430 fi
3431 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3432 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3433 GCC=`test $ac_compiler_gnu = yes && echo yes`
3434 ac_test_CFLAGS=${CFLAGS+set}
3435 ac_save_CFLAGS=$CFLAGS
3436 CFLAGS="-g"
3437 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3438 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3439 if test "${ac_cv_prog_cc_g+set}" = set; then
3440   echo $ECHO_N "(cached) $ECHO_C" >&6
3441 else
3442   cat >conftest.$ac_ext <<_ACEOF
3443 /* confdefs.h.  */
3444 _ACEOF
3445 cat confdefs.h >>conftest.$ac_ext
3446 cat >>conftest.$ac_ext <<_ACEOF
3447 /* end confdefs.h.  */
3448
3449 int
3450 main ()
3451 {
3452
3453   ;
3454   return 0;
3455 }
3456 _ACEOF
3457 rm -f conftest.$ac_objext
3458 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3459   (eval $ac_compile) 2>conftest.er1
3460   ac_status=$?
3461   grep -v '^ *+' conftest.er1 >conftest.err
3462   rm -f conftest.er1
3463   cat conftest.err >&5
3464   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3465   (exit $ac_status); } &&
3466          { ac_try='test -z "$ac_c_werror_flag"
3467                          || test ! -s conftest.err'
3468   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3469   (eval $ac_try) 2>&5
3470   ac_status=$?
3471   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3472   (exit $ac_status); }; } &&
3473          { ac_try='test -s conftest.$ac_objext'
3474   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3475   (eval $ac_try) 2>&5
3476   ac_status=$?
3477   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3478   (exit $ac_status); }; }; then
3479   ac_cv_prog_cc_g=yes
3480 else
3481   echo "$as_me: failed program was:" >&5
3482 sed 's/^/| /' conftest.$ac_ext >&5
3483
3484 ac_cv_prog_cc_g=no
3485 fi
3486 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3487 fi
3488 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3489 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3490 if test "$ac_test_CFLAGS" = set; then
3491   CFLAGS=$ac_save_CFLAGS
3492 elif test $ac_cv_prog_cc_g = yes; then
3493   if test "$GCC" = yes; then
3494     CFLAGS="-g -O2"
3495   else
3496     CFLAGS="-g"
3497   fi
3498 else
3499   if test "$GCC" = yes; then
3500     CFLAGS="-O2"
3501   else
3502     CFLAGS=
3503   fi
3504 fi
3505 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3506 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3507 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3508   echo $ECHO_N "(cached) $ECHO_C" >&6
3509 else
3510   ac_cv_prog_cc_stdc=no
3511 ac_save_CC=$CC
3512 cat >conftest.$ac_ext <<_ACEOF
3513 /* confdefs.h.  */
3514 _ACEOF
3515 cat confdefs.h >>conftest.$ac_ext
3516 cat >>conftest.$ac_ext <<_ACEOF
3517 /* end confdefs.h.  */
3518 #include <stdarg.h>
3519 #include <stdio.h>
3520 #include <sys/types.h>
3521 #include <sys/stat.h>
3522 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3523 struct buf { int x; };
3524 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3525 static char *e (p, i)
3526      char **p;
3527      int i;
3528 {
3529   return p[i];
3530 }
3531 static char *f (char * (*g) (char **, int), char **p, ...)
3532 {
3533   char *s;
3534   va_list v;
3535   va_start (v,p);
3536   s = g (p, va_arg (v,int));
3537   va_end (v);
3538   return s;
3539 }
3540
3541 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3542    function prototypes and stuff, but not '\xHH' hex character constants.
3543    These don't provoke an error unfortunately, instead are silently treated
3544    as 'x'.  The following induces an error, until -std1 is added to get
3545    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3546    array size at least.  It's necessary to write '\x00'==0 to get something
3547    that's true only with -std1.  */
3548 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3549
3550 int test (int i, double x);
3551 struct s1 {int (*f) (int a);};
3552 struct s2 {int (*f) (double a);};
3553 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3554 int argc;
3555 char **argv;
3556 int
3557 main ()
3558 {
3559 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3560   ;
3561   return 0;
3562 }
3563 _ACEOF
3564 # Don't try gcc -ansi; that turns off useful extensions and
3565 # breaks some systems' header files.
3566 # AIX                   -qlanglvl=ansi
3567 # Ultrix and OSF/1      -std1
3568 # HP-UX 10.20 and later -Ae
3569 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3570 # SVR4                  -Xc -D__EXTENSIONS__
3571 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3572 do
3573   CC="$ac_save_CC $ac_arg"
3574   rm -f conftest.$ac_objext
3575 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3576   (eval $ac_compile) 2>conftest.er1
3577   ac_status=$?
3578   grep -v '^ *+' conftest.er1 >conftest.err
3579   rm -f conftest.er1
3580   cat conftest.err >&5
3581   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3582   (exit $ac_status); } &&
3583          { ac_try='test -z "$ac_c_werror_flag"
3584                          || test ! -s conftest.err'
3585   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3586   (eval $ac_try) 2>&5
3587   ac_status=$?
3588   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3589   (exit $ac_status); }; } &&
3590          { ac_try='test -s conftest.$ac_objext'
3591   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3592   (eval $ac_try) 2>&5
3593   ac_status=$?
3594   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3595   (exit $ac_status); }; }; then
3596   ac_cv_prog_cc_stdc=$ac_arg
3597 break
3598 else
3599   echo "$as_me: failed program was:" >&5
3600 sed 's/^/| /' conftest.$ac_ext >&5
3601
3602 fi
3603 rm -f conftest.err conftest.$ac_objext
3604 done
3605 rm -f conftest.$ac_ext conftest.$ac_objext
3606 CC=$ac_save_CC
3607
3608 fi
3609
3610 case "x$ac_cv_prog_cc_stdc" in
3611   x|xno)
3612     echo "$as_me:$LINENO: result: none needed" >&5
3613 echo "${ECHO_T}none needed" >&6 ;;
3614   *)
3615     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3616 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3617     CC="$CC $ac_cv_prog_cc_stdc" ;;
3618 esac
3619
3620 # Some people use a C++ compiler to compile C.  Since we use `exit',
3621 # in C++ we need to declare it.  In case someone uses the same compiler
3622 # for both compiling C and C++ we need to have the C++ compiler decide
3623 # the declaration of exit, since it's the most demanding environment.
3624 cat >conftest.$ac_ext <<_ACEOF
3625 #ifndef __cplusplus
3626   choke me
3627 #endif
3628 _ACEOF
3629 rm -f conftest.$ac_objext
3630 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3631   (eval $ac_compile) 2>conftest.er1
3632   ac_status=$?
3633   grep -v '^ *+' conftest.er1 >conftest.err
3634   rm -f conftest.er1
3635   cat conftest.err >&5
3636   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3637   (exit $ac_status); } &&
3638          { ac_try='test -z "$ac_c_werror_flag"
3639                          || test ! -s conftest.err'
3640   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3641   (eval $ac_try) 2>&5
3642   ac_status=$?
3643   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3644   (exit $ac_status); }; } &&
3645          { ac_try='test -s conftest.$ac_objext'
3646   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3647   (eval $ac_try) 2>&5
3648   ac_status=$?
3649   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3650   (exit $ac_status); }; }; then
3651   for ac_declaration in \
3652    '' \
3653    'extern "C" void std::exit (int) throw (); using std::exit;' \
3654    'extern "C" void std::exit (int); using std::exit;' \
3655    'extern "C" void exit (int) throw ();' \
3656    'extern "C" void exit (int);' \
3657    'void exit (int);'
3658 do
3659   cat >conftest.$ac_ext <<_ACEOF
3660 /* confdefs.h.  */
3661 _ACEOF
3662 cat confdefs.h >>conftest.$ac_ext
3663 cat >>conftest.$ac_ext <<_ACEOF
3664 /* end confdefs.h.  */
3665 $ac_declaration
3666 #include <stdlib.h>
3667 int
3668 main ()
3669 {
3670 exit (42);
3671   ;
3672   return 0;
3673 }
3674 _ACEOF
3675 rm -f conftest.$ac_objext
3676 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3677   (eval $ac_compile) 2>conftest.er1
3678   ac_status=$?
3679   grep -v '^ *+' conftest.er1 >conftest.err
3680   rm -f conftest.er1
3681   cat conftest.err >&5
3682   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3683   (exit $ac_status); } &&
3684          { ac_try='test -z "$ac_c_werror_flag"
3685                          || test ! -s conftest.err'
3686   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3687   (eval $ac_try) 2>&5
3688   ac_status=$?
3689   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3690   (exit $ac_status); }; } &&
3691          { ac_try='test -s conftest.$ac_objext'
3692   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3693   (eval $ac_try) 2>&5
3694   ac_status=$?
3695   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3696   (exit $ac_status); }; }; then
3697   :
3698 else
3699   echo "$as_me: failed program was:" >&5
3700 sed 's/^/| /' conftest.$ac_ext >&5
3701
3702 continue
3703 fi
3704 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3705   cat >conftest.$ac_ext <<_ACEOF
3706 /* confdefs.h.  */
3707 _ACEOF
3708 cat confdefs.h >>conftest.$ac_ext
3709 cat >>conftest.$ac_ext <<_ACEOF
3710 /* end confdefs.h.  */
3711 $ac_declaration
3712 int
3713 main ()
3714 {
3715 exit (42);
3716   ;
3717   return 0;
3718 }
3719 _ACEOF
3720 rm -f conftest.$ac_objext
3721 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3722   (eval $ac_compile) 2>conftest.er1
3723   ac_status=$?
3724   grep -v '^ *+' conftest.er1 >conftest.err
3725   rm -f conftest.er1
3726   cat conftest.err >&5
3727   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3728   (exit $ac_status); } &&
3729          { ac_try='test -z "$ac_c_werror_flag"
3730                          || test ! -s conftest.err'
3731   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3732   (eval $ac_try) 2>&5
3733   ac_status=$?
3734   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3735   (exit $ac_status); }; } &&
3736          { ac_try='test -s conftest.$ac_objext'
3737   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3738   (eval $ac_try) 2>&5
3739   ac_status=$?
3740   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3741   (exit $ac_status); }; }; then
3742   break
3743 else
3744   echo "$as_me: failed program was:" >&5
3745 sed 's/^/| /' conftest.$ac_ext >&5
3746
3747 fi
3748 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3749 done
3750 rm -f conftest*
3751 if test -n "$ac_declaration"; then
3752   echo '#ifdef __cplusplus' >>confdefs.h
3753   echo $ac_declaration      >>confdefs.h
3754   echo '#endif'             >>confdefs.h
3755 fi
3756
3757 else
3758   echo "$as_me: failed program was:" >&5
3759 sed 's/^/| /' conftest.$ac_ext >&5
3760
3761 fi
3762 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3763 ac_ext=c
3764 ac_cpp='$CPP $CPPFLAGS'
3765 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3766 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3767 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3768
3769 ac_ext=cc
3770 ac_cpp='$CXXCPP $CPPFLAGS'
3771 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3772 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3773 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3774 if test -n "$ac_tool_prefix"; then
3775   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3776   do
3777     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3778 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3779 echo "$as_me:$LINENO: checking for $ac_word" >&5
3780 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3781 if test "${ac_cv_prog_CXX+set}" = set; then
3782   echo $ECHO_N "(cached) $ECHO_C" >&6
3783 else
3784   if test -n "$CXX"; then
3785   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3786 else
3787 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3788 for as_dir in $PATH
3789 do
3790   IFS=$as_save_IFS
3791   test -z "$as_dir" && as_dir=.
3792   for ac_exec_ext in '' $ac_executable_extensions; do
3793   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3794     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3795     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3796     break 2
3797   fi
3798 done
3799 done
3800
3801 fi
3802 fi
3803 CXX=$ac_cv_prog_CXX
3804 if test -n "$CXX"; then
3805   echo "$as_me:$LINENO: result: $CXX" >&5
3806 echo "${ECHO_T}$CXX" >&6
3807 else
3808   echo "$as_me:$LINENO: result: no" >&5
3809 echo "${ECHO_T}no" >&6
3810 fi
3811
3812     test -n "$CXX" && break
3813   done
3814 fi
3815 if test -z "$CXX"; then
3816   ac_ct_CXX=$CXX
3817   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3818 do
3819   # Extract the first word of "$ac_prog", so it can be a program name with args.
3820 set dummy $ac_prog; ac_word=$2
3821 echo "$as_me:$LINENO: checking for $ac_word" >&5
3822 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3823 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3824   echo $ECHO_N "(cached) $ECHO_C" >&6
3825 else
3826   if test -n "$ac_ct_CXX"; then
3827   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3828 else
3829 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3830 for as_dir in $PATH
3831 do
3832   IFS=$as_save_IFS
3833   test -z "$as_dir" && as_dir=.
3834   for ac_exec_ext in '' $ac_executable_extensions; do
3835   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3836     ac_cv_prog_ac_ct_CXX="$ac_prog"
3837     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3838     break 2
3839   fi
3840 done
3841 done
3842
3843 fi
3844 fi
3845 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3846 if test -n "$ac_ct_CXX"; then
3847   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3848 echo "${ECHO_T}$ac_ct_CXX" >&6
3849 else
3850   echo "$as_me:$LINENO: result: no" >&5
3851 echo "${ECHO_T}no" >&6
3852 fi
3853
3854   test -n "$ac_ct_CXX" && break
3855 done
3856 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3857
3858   CXX=$ac_ct_CXX
3859 fi
3860
3861
3862 # Provide some information about the compiler.
3863 echo "$as_me:$LINENO:" \
3864      "checking for C++ compiler version" >&5
3865 ac_compiler=`set X $ac_compile; echo $2`
3866 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3867   (eval $ac_compiler --version </dev/null >&5) 2>&5
3868   ac_status=$?
3869   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3870   (exit $ac_status); }
3871 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3872   (eval $ac_compiler -v </dev/null >&5) 2>&5
3873   ac_status=$?
3874   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3875   (exit $ac_status); }
3876 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3877   (eval $ac_compiler -V </dev/null >&5) 2>&5
3878   ac_status=$?
3879   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3880   (exit $ac_status); }
3881
3882 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3883 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3884 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3885   echo $ECHO_N "(cached) $ECHO_C" >&6
3886 else
3887   cat >conftest.$ac_ext <<_ACEOF
3888 /* confdefs.h.  */
3889 _ACEOF
3890 cat confdefs.h >>conftest.$ac_ext
3891 cat >>conftest.$ac_ext <<_ACEOF
3892 /* end confdefs.h.  */
3893
3894 int
3895 main ()
3896 {
3897 #ifndef __GNUC__
3898        choke me
3899 #endif
3900
3901   ;
3902   return 0;
3903 }
3904 _ACEOF
3905 rm -f conftest.$ac_objext
3906 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3907   (eval $ac_compile) 2>conftest.er1
3908   ac_status=$?
3909   grep -v '^ *+' conftest.er1 >conftest.err
3910   rm -f conftest.er1
3911   cat conftest.err >&5
3912   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3913   (exit $ac_status); } &&
3914          { ac_try='test -z "$ac_cxx_werror_flag"
3915                          || test ! -s conftest.err'
3916   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3917   (eval $ac_try) 2>&5
3918   ac_status=$?
3919   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3920   (exit $ac_status); }; } &&
3921          { ac_try='test -s conftest.$ac_objext'
3922   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3923   (eval $ac_try) 2>&5
3924   ac_status=$?
3925   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3926   (exit $ac_status); }; }; then
3927   ac_compiler_gnu=yes
3928 else
3929   echo "$as_me: failed program was:" >&5
3930 sed 's/^/| /' conftest.$ac_ext >&5
3931
3932 ac_compiler_gnu=no
3933 fi
3934 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3935 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3936
3937 fi
3938 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3939 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3940 GXX=`test $ac_compiler_gnu = yes && echo yes`
3941 ac_test_CXXFLAGS=${CXXFLAGS+set}
3942 ac_save_CXXFLAGS=$CXXFLAGS
3943 CXXFLAGS="-g"
3944 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3945 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3946 if test "${ac_cv_prog_cxx_g+set}" = set; then
3947   echo $ECHO_N "(cached) $ECHO_C" >&6
3948 else
3949   cat >conftest.$ac_ext <<_ACEOF
3950 /* confdefs.h.  */
3951 _ACEOF
3952 cat confdefs.h >>conftest.$ac_ext
3953 cat >>conftest.$ac_ext <<_ACEOF
3954 /* end confdefs.h.  */
3955
3956 int
3957 main ()
3958 {
3959
3960   ;
3961   return 0;
3962 }
3963 _ACEOF
3964 rm -f conftest.$ac_objext
3965 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3966   (eval $ac_compile) 2>conftest.er1
3967   ac_status=$?
3968   grep -v '^ *+' conftest.er1 >conftest.err
3969   rm -f conftest.er1
3970   cat conftest.err >&5
3971   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3972   (exit $ac_status); } &&
3973          { ac_try='test -z "$ac_cxx_werror_flag"
3974                          || test ! -s conftest.err'
3975   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3976   (eval $ac_try) 2>&5
3977   ac_status=$?
3978   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3979   (exit $ac_status); }; } &&
3980          { ac_try='test -s conftest.$ac_objext'
3981   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3982   (eval $ac_try) 2>&5
3983   ac_status=$?
3984   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3985   (exit $ac_status); }; }; then
3986   ac_cv_prog_cxx_g=yes
3987 else
3988   echo "$as_me: failed program was:" >&5
3989 sed 's/^/| /' conftest.$ac_ext >&5
3990
3991 ac_cv_prog_cxx_g=no
3992 fi
3993 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3994 fi
3995 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3996 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
3997 if test "$ac_test_CXXFLAGS" = set; then
3998   CXXFLAGS=$ac_save_CXXFLAGS
3999 elif test $ac_cv_prog_cxx_g = yes; then
4000   if test "$GXX" = yes; then
4001     CXXFLAGS="-g -O2"
4002   else
4003     CXXFLAGS="-g"
4004   fi
4005 else
4006   if test "$GXX" = yes; then
4007     CXXFLAGS="-O2"
4008   else
4009     CXXFLAGS=
4010   fi
4011 fi
4012 for ac_declaration in \
4013    '' \
4014    'extern "C" void std::exit (int) throw (); using std::exit;' \
4015    'extern "C" void std::exit (int); using std::exit;' \
4016    'extern "C" void exit (int) throw ();' \
4017    'extern "C" void exit (int);' \
4018    'void exit (int);'
4019 do
4020   cat >conftest.$ac_ext <<_ACEOF
4021 /* confdefs.h.  */
4022 _ACEOF
4023 cat confdefs.h >>conftest.$ac_ext
4024 cat >>conftest.$ac_ext <<_ACEOF
4025 /* end confdefs.h.  */
4026 $ac_declaration
4027 #include <stdlib.h>
4028 int
4029 main ()
4030 {
4031 exit (42);
4032   ;
4033   return 0;
4034 }
4035 _ACEOF
4036 rm -f conftest.$ac_objext
4037 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4038   (eval $ac_compile) 2>conftest.er1
4039   ac_status=$?
4040   grep -v '^ *+' conftest.er1 >conftest.err
4041   rm -f conftest.er1
4042   cat conftest.err >&5
4043   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4044   (exit $ac_status); } &&
4045          { ac_try='test -z "$ac_cxx_werror_flag"
4046                          || test ! -s conftest.err'
4047   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4048   (eval $ac_try) 2>&5
4049   ac_status=$?
4050   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4051   (exit $ac_status); }; } &&
4052          { ac_try='test -s conftest.$ac_objext'
4053   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4054   (eval $ac_try) 2>&5
4055   ac_status=$?
4056   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4057   (exit $ac_status); }; }; then
4058   :
4059 else
4060   echo "$as_me: failed program was:" >&5
4061 sed 's/^/| /' conftest.$ac_ext >&5
4062
4063 continue
4064 fi
4065 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4066   cat >conftest.$ac_ext <<_ACEOF
4067 /* confdefs.h.  */
4068 _ACEOF
4069 cat confdefs.h >>conftest.$ac_ext
4070 cat >>conftest.$ac_ext <<_ACEOF
4071 /* end confdefs.h.  */
4072 $ac_declaration
4073 int
4074 main ()
4075 {
4076 exit (42);
4077   ;
4078   return 0;
4079 }
4080 _ACEOF
4081 rm -f conftest.$ac_objext
4082 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4083   (eval $ac_compile) 2>conftest.er1
4084   ac_status=$?
4085   grep -v '^ *+' conftest.er1 >conftest.err
4086   rm -f conftest.er1
4087   cat conftest.err >&5
4088   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4089   (exit $ac_status); } &&
4090          { ac_try='test -z "$ac_cxx_werror_flag"
4091                          || test ! -s conftest.err'
4092   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4093   (eval $ac_try) 2>&5
4094   ac_status=$?
4095   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4096   (exit $ac_status); }; } &&
4097          { ac_try='test -s conftest.$ac_objext'
4098   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4099   (eval $ac_try) 2>&5
4100   ac_status=$?
4101   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4102   (exit $ac_status); }; }; then
4103   break
4104 else
4105   echo "$as_me: failed program was:" >&5
4106 sed 's/^/| /' conftest.$ac_ext >&5
4107
4108 fi
4109 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4110 done
4111 rm -f conftest*
4112 if test -n "$ac_declaration"; then
4113   echo '#ifdef __cplusplus' >>confdefs.h
4114   echo $ac_declaration      >>confdefs.h
4115   echo '#endif'             >>confdefs.h
4116 fi
4117
4118 ac_ext=c
4119 ac_cpp='$CPP $CPPFLAGS'
4120 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4121 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4122 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4123
4124
4125 # We must set the default linker to the linker used by gcc for the correct
4126 # operation of libtool.  If LD is not defined and we are using gcc, try to
4127 # set the LD default to the ld used by gcc.
4128 if test -z "$LD"; then
4129   if test "$GCC" = yes; then
4130     case $build in
4131     *-*-mingw*)
4132       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4133     *)
4134       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4135     esac
4136     case $gcc_prog_ld in
4137     # Accept absolute paths.
4138     [\\/]* | [A-Za-z]:[\\/]*)
4139       LD="$gcc_prog_ld" ;;
4140     esac
4141   fi
4142 fi
4143
4144
4145
4146
4147 if test -n "$ac_tool_prefix"; then
4148   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4149 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4150 echo "$as_me:$LINENO: checking for $ac_word" >&5
4151 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4152 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4153   echo $ECHO_N "(cached) $ECHO_C" >&6
4154 else
4155   if test -n "$GNATBIND"; then
4156   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4157 else
4158 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4159 for as_dir in $PATH
4160 do
4161   IFS=$as_save_IFS
4162   test -z "$as_dir" && as_dir=.
4163   for ac_exec_ext in '' $ac_executable_extensions; do
4164   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4165     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4166     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4167     break 2
4168   fi
4169 done
4170 done
4171
4172 fi
4173 fi
4174 GNATBIND=$ac_cv_prog_GNATBIND
4175 if test -n "$GNATBIND"; then
4176   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4177 echo "${ECHO_T}$GNATBIND" >&6
4178 else
4179   echo "$as_me:$LINENO: result: no" >&5
4180 echo "${ECHO_T}no" >&6
4181 fi
4182
4183 fi
4184 if test -z "$ac_cv_prog_GNATBIND"; then
4185   ac_ct_GNATBIND=$GNATBIND
4186   # Extract the first word of "gnatbind", so it can be a program name with args.
4187 set dummy gnatbind; ac_word=$2
4188 echo "$as_me:$LINENO: checking for $ac_word" >&5
4189 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4190 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4191   echo $ECHO_N "(cached) $ECHO_C" >&6
4192 else
4193   if test -n "$ac_ct_GNATBIND"; then
4194   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4195 else
4196 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4197 for as_dir in $PATH
4198 do
4199   IFS=$as_save_IFS
4200   test -z "$as_dir" && as_dir=.
4201   for ac_exec_ext in '' $ac_executable_extensions; do
4202   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4203     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4204     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4205     break 2
4206   fi
4207 done
4208 done
4209
4210   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4211 fi
4212 fi
4213 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4214 if test -n "$ac_ct_GNATBIND"; then
4215   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4216 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4217 else
4218   echo "$as_me:$LINENO: result: no" >&5
4219 echo "${ECHO_T}no" >&6
4220 fi
4221
4222   GNATBIND=$ac_ct_GNATBIND
4223 else
4224   GNATBIND="$ac_cv_prog_GNATBIND"
4225 fi
4226
4227 if test -n "$ac_tool_prefix"; then
4228   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4229 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4230 echo "$as_me:$LINENO: checking for $ac_word" >&5
4231 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4232 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4233   echo $ECHO_N "(cached) $ECHO_C" >&6
4234 else
4235   if test -n "$GNATMAKE"; then
4236   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4237 else
4238 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4239 for as_dir in $PATH
4240 do
4241   IFS=$as_save_IFS
4242   test -z "$as_dir" && as_dir=.
4243   for ac_exec_ext in '' $ac_executable_extensions; do
4244   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4245     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4246     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4247     break 2
4248   fi
4249 done
4250 done
4251
4252 fi
4253 fi
4254 GNATMAKE=$ac_cv_prog_GNATMAKE
4255 if test -n "$GNATMAKE"; then
4256   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4257 echo "${ECHO_T}$GNATMAKE" >&6
4258 else
4259   echo "$as_me:$LINENO: result: no" >&5
4260 echo "${ECHO_T}no" >&6
4261 fi
4262
4263 fi
4264 if test -z "$ac_cv_prog_GNATMAKE"; then
4265   ac_ct_GNATMAKE=$GNATMAKE
4266   # Extract the first word of "gnatmake", so it can be a program name with args.
4267 set dummy gnatmake; ac_word=$2
4268 echo "$as_me:$LINENO: checking for $ac_word" >&5
4269 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4270 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4271   echo $ECHO_N "(cached) $ECHO_C" >&6
4272 else
4273   if test -n "$ac_ct_GNATMAKE"; then
4274   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4275 else
4276 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4277 for as_dir in $PATH
4278 do
4279   IFS=$as_save_IFS
4280   test -z "$as_dir" && as_dir=.
4281   for ac_exec_ext in '' $ac_executable_extensions; do
4282   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4283     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4284     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4285     break 2
4286   fi
4287 done
4288 done
4289
4290   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4291 fi
4292 fi
4293 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4294 if test -n "$ac_ct_GNATMAKE"; then
4295   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4296 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4297 else
4298   echo "$as_me:$LINENO: result: no" >&5
4299 echo "${ECHO_T}no" >&6
4300 fi
4301
4302   GNATMAKE=$ac_ct_GNATMAKE
4303 else
4304   GNATMAKE="$ac_cv_prog_GNATMAKE"
4305 fi
4306
4307 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4308 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4309 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4310   echo $ECHO_N "(cached) $ECHO_C" >&6
4311 else
4312   cat >conftest.adb <<EOF
4313 procedure conftest is begin null; end conftest;
4314 EOF
4315 acx_cv_cc_gcc_supports_ada=no
4316 # There is a bug in old released versions of GCC which causes the
4317 # driver to exit successfully when the appropriate language module
4318 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4319 # Therefore we must check for the error message as well as an
4320 # unsuccessful exit.
4321 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4322 # given a .adb file, but produce no object file.  So we must check
4323 # if an object file was really produced to guard against this.
4324 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4325 if test x"$errors" = x && test -f conftest.$ac_objext; then
4326   acx_cv_cc_gcc_supports_ada=yes
4327 fi
4328 rm -f conftest.*
4329 fi
4330 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4331 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4332
4333 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4334   have_gnat=yes
4335 else
4336   have_gnat=no
4337 fi
4338
4339 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4340 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4341 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4342   echo $ECHO_N "(cached) $ECHO_C" >&6
4343 else
4344    echo abfoo >t1
4345   echo cdfoo >t2
4346   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4347   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4348     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4349       :
4350     else
4351       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4352     fi
4353   fi
4354   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4355     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4356       :
4357     else
4358       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4359     fi
4360   fi
4361   rm t1 t2
4362
4363 fi
4364 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4365 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4366 do_compare="$gcc_cv_prog_cmp_skip"
4367
4368
4369
4370 # Check for GMP and MPFR
4371 gmplibs="-lmpfr -lgmp"
4372 gmpinc=
4373 have_gmp=no
4374
4375 # Specify a location for mpfr
4376 # check for this first so it ends up on the link line before gmp.
4377
4378 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4379 if test "${with_mpfr_dir+set}" = set; then
4380   withval="$with_mpfr_dir"
4381   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4382 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4383 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4384 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4385    { (exit 1); exit 1; }; }
4386 fi;
4387
4388
4389 # Check whether --with-mpfr or --without-mpfr was given.
4390 if test "${with_mpfr+set}" = set; then
4391   withval="$with_mpfr"
4392
4393 fi;
4394
4395 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4396 if test "${with_mpfr_include+set}" = set; then
4397   withval="$with_mpfr_include"
4398
4399 fi;
4400
4401 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4402 if test "${with_mpfr_lib+set}" = set; then
4403   withval="$with_mpfr_lib"
4404
4405 fi;
4406
4407 if test "x$with_mpfr" != x; then
4408   gmplibs="-L$with_mpfr/lib $gmplibs"
4409   gmpinc="-I$with_mpfr/include"
4410 fi
4411 if test "x$with_mpfr_include" != x; then
4412   gmpinc="-I$with_mpfr_include"
4413 fi
4414 if test "x$with_mpfr_lib" != x; then
4415   gmplibs="-L$with_mpfr_lib $gmplibs"
4416 fi
4417 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4418   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4419   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4420   # Do not test the mpfr version.  Assume that it is sufficient, since
4421   # it is in the source tree, and the library has not been built yet
4422   # but it would be included on the link line in the version check below
4423   # hence making the test fail.
4424   have_gmp=yes
4425 fi
4426
4427 # Specify a location for gmp
4428
4429 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4430 if test "${with_gmp_dir+set}" = set; then
4431   withval="$with_gmp_dir"
4432   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4433 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4434 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4435 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4436    { (exit 1); exit 1; }; }
4437 fi;
4438
4439
4440 # Check whether --with-gmp or --without-gmp was given.
4441 if test "${with_gmp+set}" = set; then
4442   withval="$with_gmp"
4443
4444 fi;
4445
4446 # Check whether --with-gmp_include or --without-gmp_include was given.
4447 if test "${with_gmp_include+set}" = set; then
4448   withval="$with_gmp_include"
4449
4450 fi;
4451
4452 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4453 if test "${with_gmp_lib+set}" = set; then
4454   withval="$with_gmp_lib"
4455
4456 fi;
4457
4458
4459 if test "x$with_gmp" != x; then
4460   gmplibs="-L$with_gmp/lib $gmplibs"
4461   gmpinc="-I$with_gmp/include $gmpinc"
4462 fi
4463 if test "x$with_gmp_include" != x; then
4464   gmpinc="-I$with_gmp_include $gmpinc"
4465 fi
4466 if test "x$with_gmp_lib" != x; then
4467   gmplibs="-L$with_gmp_lib $gmplibs"
4468 fi
4469 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4470   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4471   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4472   # Do not test the gmp version.  Assume that it is sufficient, since
4473   # it is in the source tree, and the library has not been built yet
4474   # but it would be included on the link line in the version check below
4475   # hence making the test fail.
4476   have_gmp=yes
4477 fi
4478
4479 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4480   have_gmp=yes
4481   saved_CFLAGS="$CFLAGS"
4482   CFLAGS="$CFLAGS $gmpinc"
4483   # Check GMP actually works
4484   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4485 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4486
4487 cat >conftest.$ac_ext <<_ACEOF
4488 /* confdefs.h.  */
4489 _ACEOF
4490 cat confdefs.h >>conftest.$ac_ext
4491 cat >>conftest.$ac_ext <<_ACEOF
4492 /* end confdefs.h.  */
4493 #include "gmp.h"
4494 int
4495 main ()
4496 {
4497
4498   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4499   choke me
4500   #endif
4501
4502   ;
4503   return 0;
4504 }
4505 _ACEOF
4506 rm -f conftest.$ac_objext
4507 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4508   (eval $ac_compile) 2>conftest.er1
4509   ac_status=$?
4510   grep -v '^ *+' conftest.er1 >conftest.err
4511   rm -f conftest.er1
4512   cat conftest.err >&5
4513   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4514   (exit $ac_status); } &&
4515          { ac_try='test -z "$ac_c_werror_flag"
4516                          || test ! -s conftest.err'
4517   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4518   (eval $ac_try) 2>&5
4519   ac_status=$?
4520   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4521   (exit $ac_status); }; } &&
4522          { ac_try='test -s conftest.$ac_objext'
4523   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4524   (eval $ac_try) 2>&5
4525   ac_status=$?
4526   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4527   (exit $ac_status); }; }; then
4528   echo "$as_me:$LINENO: result: yes" >&5
4529 echo "${ECHO_T}yes" >&6
4530 else
4531   echo "$as_me: failed program was:" >&5
4532 sed 's/^/| /' conftest.$ac_ext >&5
4533
4534 echo "$as_me:$LINENO: result: no" >&5
4535 echo "${ECHO_T}no" >&6; have_gmp=no
4536 fi
4537 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4538
4539   if test x"$have_gmp" = xyes; then
4540     saved_LIBS="$LIBS"
4541     LIBS="$LIBS $gmplibs"
4542         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4543 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4544     cat >conftest.$ac_ext <<_ACEOF
4545 /* confdefs.h.  */
4546 _ACEOF
4547 cat confdefs.h >>conftest.$ac_ext
4548 cat >>conftest.$ac_ext <<_ACEOF
4549 /* end confdefs.h.  */
4550 #include <gmp.h>
4551     #include <mpfr.h>
4552 int
4553 main ()
4554 {
4555
4556     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4557     choke me
4558     #endif
4559     mpfr_t n;
4560     mpfr_t x;
4561     int t;
4562     mpfr_init (n);
4563     mpfr_init (x);
4564     mpfr_atan2 (n, n, x, GMP_RNDN);
4565     mpfr_erfc (n, x, GMP_RNDN);
4566     mpfr_subnormalize (x, t, GMP_RNDN);
4567
4568   ;
4569   return 0;
4570 }
4571 _ACEOF
4572 rm -f conftest.$ac_objext conftest$ac_exeext
4573 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4574   (eval $ac_link) 2>conftest.er1
4575   ac_status=$?
4576   grep -v '^ *+' conftest.er1 >conftest.err
4577   rm -f conftest.er1
4578   cat conftest.err >&5
4579   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4580   (exit $ac_status); } &&
4581          { ac_try='test -z "$ac_c_werror_flag"
4582                          || test ! -s conftest.err'
4583   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4584   (eval $ac_try) 2>&5
4585   ac_status=$?
4586   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4587   (exit $ac_status); }; } &&
4588          { ac_try='test -s conftest$ac_exeext'
4589   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4590   (eval $ac_try) 2>&5
4591   ac_status=$?
4592   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4593   (exit $ac_status); }; }; then
4594   cat >conftest.$ac_ext <<_ACEOF
4595 /* confdefs.h.  */
4596 _ACEOF
4597 cat confdefs.h >>conftest.$ac_ext
4598 cat >>conftest.$ac_ext <<_ACEOF
4599 /* end confdefs.h.  */
4600 #include <gmp.h>
4601     #include <mpfr.h>
4602 int
4603 main ()
4604 {
4605
4606     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4607     choke me
4608     #endif
4609     mpfr_t n; mpfr_init(n);
4610
4611   ;
4612   return 0;
4613 }
4614 _ACEOF
4615 rm -f conftest.$ac_objext conftest$ac_exeext
4616 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4617   (eval $ac_link) 2>conftest.er1
4618   ac_status=$?
4619   grep -v '^ *+' conftest.er1 >conftest.err
4620   rm -f conftest.er1
4621   cat conftest.err >&5
4622   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4623   (exit $ac_status); } &&
4624          { ac_try='test -z "$ac_c_werror_flag"
4625                          || test ! -s conftest.err'
4626   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4627   (eval $ac_try) 2>&5
4628   ac_status=$?
4629   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4630   (exit $ac_status); }; } &&
4631          { ac_try='test -s conftest$ac_exeext'
4632   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4633   (eval $ac_try) 2>&5
4634   ac_status=$?
4635   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4636   (exit $ac_status); }; }; then
4637   echo "$as_me:$LINENO: result: yes" >&5
4638 echo "${ECHO_T}yes" >&6
4639 else
4640   echo "$as_me: failed program was:" >&5
4641 sed 's/^/| /' conftest.$ac_ext >&5
4642
4643 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4644 echo "${ECHO_T}buggy but acceptable" >&6
4645 fi
4646 rm -f conftest.err conftest.$ac_objext \
4647       conftest$ac_exeext conftest.$ac_ext
4648 else
4649   echo "$as_me: failed program was:" >&5
4650 sed 's/^/| /' conftest.$ac_ext >&5
4651
4652 echo "$as_me:$LINENO: result: no" >&5
4653 echo "${ECHO_T}no" >&6; have_gmp=no
4654 fi
4655 rm -f conftest.err conftest.$ac_objext \
4656       conftest$ac_exeext conftest.$ac_ext
4657       LIBS="$saved_LIBS"
4658   fi
4659   CFLAGS="$saved_CFLAGS"
4660
4661   if test x$have_gmp != xyes; then
4662     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4663 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4664 Copies of these libraries' source code can be found at their respective
4665 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4666 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4667 If you obtained GMP and/or MPFR from a vendor distribution package, make
4668 sure that you have installed both the libraries and the header files.
4669 They may be located in separate packages." >&5
4670 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4671 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4672 Copies of these libraries' source code can be found at their respective
4673 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4674 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4675 If you obtained GMP and/or MPFR from a vendor distribution package, make
4676 sure that you have installed both the libraries and the header files.
4677 They may be located in separate packages." >&2;}
4678    { (exit 1); exit 1; }; }
4679   fi
4680 fi
4681
4682 # Flags needed for both GMP and/or MPFR
4683
4684
4685
4686 # By default, C is the only stage 1 language.
4687 stage1_languages=,c,
4688
4689 # Figure out what language subdirectories are present.
4690 # Look if the user specified --enable-languages="..."; if not, use
4691 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4692 # go away some day.
4693 # NB:  embedded tabs in this IF block -- do not untabify
4694 if test -d ${srcdir}/gcc; then
4695   if test x"${enable_languages+set}" != xset; then
4696     if test x"${LANGUAGES+set}" = xset; then
4697       enable_languages="${LANGUAGES}"
4698         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4699     else
4700       enable_languages=all
4701     fi
4702   else
4703     if test x"${enable_languages}" = x ||
4704        test x"${enable_languages}" = xyes;
4705        then
4706       echo configure.in: --enable-languages needs at least one language argument 1>&2
4707       exit 1
4708     fi
4709   fi
4710   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4711
4712   # 'f95' is the old name for the 'fortran' language. We issue a warning
4713   # and make the substitution.
4714   case ,${enable_languages}, in
4715     *,f95,*)
4716       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4717       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4718       ;;
4719   esac
4720
4721   # First scan to see if an enabled language requires some other language.
4722   # We assume that a given config-lang.in will list all the language
4723   # front ends it requires, even if some are required indirectly.
4724   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4725     case ${lang_frag} in
4726       ..) ;;
4727       # The odd quoting in the next line works around
4728       # an apparent bug in bash 1.12 on linux.
4729       ${srcdir}/gcc/[*]/config-lang.in) ;;
4730       *)
4731         # From the config-lang.in, get $language, $lang_requires
4732         language=
4733         lang_requires=
4734         . ${lang_frag}
4735         for other in ${lang_requires} ; do
4736           case ,${enable_languages}, in
4737             *,$other,*) ;;
4738             *,all,*) ;;
4739             *,$language,*)
4740               echo " \`$other' language required by \`$language'; enabling" 1>&2
4741               enable_languages="${enable_languages},${other}"
4742               ;;
4743           esac
4744         done
4745         ;;
4746     esac
4747   done
4748
4749   new_enable_languages=,c,
4750   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4751   potential_languages=,c,
4752
4753   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4754     case ${lang_frag} in
4755       ..) ;;
4756       # The odd quoting in the next line works around
4757       # an apparent bug in bash 1.12 on linux.
4758       ${srcdir}/gcc/[*]/config-lang.in) ;;
4759       *)
4760         # From the config-lang.in, get $language, $target_libs,
4761         # $lang_dirs, $boot_language, and $build_by_default
4762         language=
4763         target_libs=
4764         lang_dirs=
4765         subdir_requires=
4766         boot_language=no
4767         build_by_default=yes
4768         . ${lang_frag}
4769         if test x${language} = x; then
4770           echo "${lang_frag} doesn't set \$language." 1>&2
4771           exit 1
4772         fi
4773
4774         case ,${enable_languages}, in
4775           *,${language},*)
4776             # Language was explicitly selected; include it.
4777             add_this_lang=yes
4778             ;;
4779           *,all,*)
4780             # 'all' was selected, select it if it is a default language
4781             add_this_lang=${build_by_default}
4782             ;;
4783           *)
4784             add_this_lang=no
4785             ;;
4786         esac
4787
4788         # Disable languages that need other directories if these aren't available.
4789         for i in $subdir_requires; do
4790           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4791           case ,${enable_languages}, in
4792             *,${language},*)
4793               # Specifically requested language; tell them.
4794               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4795 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4796    { (exit 1); exit 1; }; }
4797               ;;
4798             *)
4799               # Silently disable.
4800               add_this_lang=unsupported
4801               ;;
4802           esac
4803         done
4804
4805         # Disable Ada if no preexisting GNAT is available.
4806         case ,${enable_languages},:${language}:${have_gnat} in
4807           *,${language},*:ada:no)
4808             # Specifically requested language; tell them.
4809             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4810 echo "$as_me: error: GNAT is required to build $language" >&2;}
4811    { (exit 1); exit 1; }; }
4812             ;;
4813           *:ada:no)
4814             # Silently disable.
4815             add_this_lang=unsupported
4816             ;;
4817         esac
4818
4819         # Disable a language that is unsupported by the target.
4820         case " $unsupported_languages " in
4821           *" $language "*)
4822             add_this_lang=unsupported
4823             ;;
4824         esac
4825
4826         case $add_this_lang in
4827           unsupported)
4828             # Remove language-dependent dirs.
4829             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4830             ;;
4831           no)
4832             # Remove language-dependent dirs; still show language as supported.
4833             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4834             potential_languages="${potential_languages}${language},"
4835             ;;
4836           yes)
4837             new_enable_languages="${new_enable_languages}${language},"
4838             potential_languages="${potential_languages}${language},"
4839             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4840             case ${boot_language} in
4841               yes)
4842                 # Add to (comma-separated) list of stage 1 languages.
4843                 stage1_languages="${stage1_languages}${language},"
4844                 ;;
4845             esac
4846             ;;
4847         esac
4848         ;;
4849     esac
4850   done
4851
4852   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4853 if test "${enable_stage1_languages+set}" = set; then
4854   enableval="$enable_stage1_languages"
4855   case ,${enable_stage1_languages}, in
4856     ,no,|,,)
4857       # Set it to something that will have no effect in the loop below
4858       enable_stage1_languages=c ;;
4859     ,yes,)
4860       enable_stage1_languages=`echo $new_enable_languages | \
4861         sed -e "s/^,//" -e "s/,$//" ` ;;
4862     *,all,*)
4863       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4864         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4865   esac
4866
4867   # Add "good" languages from enable_stage1_languages to stage1_languages,
4868   # while "bad" languages go in missing_languages.  Leave no duplicates.
4869   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4870     case $potential_languages in
4871       *,$i,*)
4872         case $stage1_languages in
4873           *,$i,*) ;;
4874           *) stage1_languages="$stage1_languages$i," ;;
4875         esac ;;
4876       *)
4877         case $missing_languages in
4878           *,$i,*) ;;
4879           *) missing_languages="$missing_languages$i," ;;
4880         esac ;;
4881      esac
4882   done
4883 fi;
4884
4885   # Remove leading/trailing commas that were added for simplicity
4886   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4887   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4888   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4889   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4890
4891   if test "x$missing_languages" != x; then
4892     { { echo "$as_me:$LINENO: error:
4893 The following requested languages could not be built: ${missing_languages}
4894 Supported languages are: ${potential_languages}" >&5
4895 echo "$as_me: error:
4896 The following requested languages could not be built: ${missing_languages}
4897 Supported languages are: ${potential_languages}" >&2;}
4898    { (exit 1); exit 1; }; }
4899   fi
4900   if test "x$new_enable_languages" != "x$enable_languages"; then
4901     echo The following languages will be built: ${new_enable_languages}
4902     enable_languages="$new_enable_languages"
4903   fi
4904
4905
4906   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4907 fi
4908
4909 # Handle --disable-<component> generically.
4910 for dir in $configdirs $build_configdirs $target_configdirs ; do
4911   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4912   varname=`echo $dirname | sed -e s/+/_/g`
4913   if eval test x\${enable_${varname}} "=" xno ; then
4914     noconfigdirs="$noconfigdirs $dir"
4915   fi
4916 done
4917
4918 # Check for Boehm's garbage collector
4919 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4920 if test "${enable_objc_gc+set}" = set; then
4921   enableval="$enable_objc_gc"
4922   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4923   *,objc,*:*:yes:*target-boehm-gc*)
4924     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4925 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4926    { (exit 1); exit 1; }; }
4927     ;;
4928 esac
4929 fi;
4930
4931 # Make sure we only build Boehm's garbage collector if required.
4932 case ,${enable_languages},:${enable_objc_gc} in
4933   *,objc,*:yes)
4934     # Keep target-boehm-gc if requested for Objective-C.
4935     ;;
4936   *)
4937     # Otherwise remove target-boehm-gc depending on target-libjava.
4938     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4939       noconfigdirs="$noconfigdirs target-boehm-gc"
4940     fi
4941     ;;
4942 esac
4943
4944 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4945 # $build_configdirs and $target_configdirs.
4946 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4947
4948 notsupp=""
4949 for dir in . $skipdirs $noconfigdirs ; do
4950   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4951   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4952     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4953     if test -r $srcdir/$dirname/configure ; then
4954       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4955         true
4956       else
4957         notsupp="$notsupp $dir"
4958       fi
4959     fi
4960   fi
4961   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4962     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
4963     if test -r $srcdir/$dirname/configure ; then
4964       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4965         true
4966       else
4967         notsupp="$notsupp $dir"
4968       fi
4969     fi
4970   fi
4971   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4972     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
4973     if test -r $srcdir/$dirname/configure ; then
4974       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4975         true
4976       else
4977         notsupp="$notsupp $dir"
4978       fi
4979     fi
4980   fi
4981 done
4982
4983 # Sometimes the tools are distributed with libiberty but with no other
4984 # libraries.  In that case, we don't want to build target-libiberty.
4985 # Don't let libgcc imply libiberty either.
4986 if test -n "${target_configdirs}" ; then
4987   libgcc=
4988   others=
4989   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
4990     if test "$i" = "libgcc"; then
4991       libgcc=target-libgcc
4992     elif test "$i" != "libiberty" ; then
4993       if test -r $srcdir/$i/configure ; then
4994         others=yes;
4995         break;
4996       fi
4997     fi
4998   done
4999   if test -z "${others}" ; then
5000     target_configdirs=$libgcc
5001   fi
5002 fi
5003
5004 # Quietly strip out all directories which aren't configurable in this tree.
5005 # This relies on all configurable subdirectories being autoconfiscated, which
5006 # is now the case.
5007 build_configdirs_all="$build_configdirs"
5008 build_configdirs=
5009 for i in ${build_configdirs_all} ; do
5010   j=`echo $i | sed -e s/build-//g`
5011   if test -f ${srcdir}/$j/configure ; then
5012     build_configdirs="${build_configdirs} $i"
5013   fi
5014 done
5015
5016 configdirs_all="$configdirs"
5017 configdirs=
5018 for i in ${configdirs_all} ; do
5019   if test -f ${srcdir}/$i/configure ; then
5020     configdirs="${configdirs} $i"
5021   fi
5022 done
5023
5024 target_configdirs_all="$target_configdirs"
5025 target_configdirs=
5026 for i in ${target_configdirs_all} ; do
5027   j=`echo $i | sed -e s/target-//g`
5028   if test -f ${srcdir}/$j/configure ; then
5029     target_configdirs="${target_configdirs} $i"
5030   fi
5031 done
5032
5033 # Produce a warning message for the subdirs we can't configure.
5034 # This isn't especially interesting in the Cygnus tree, but in the individual
5035 # FSF releases, it's important to let people know when their machine isn't
5036 # supported by the one or two programs in a package.
5037
5038 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5039   # If $appdirs is non-empty, at least one of those directories must still
5040   # be configured, or we error out.  (E.g., if the gas release supports a
5041   # specified target in some subdirs but not the gas subdir, we shouldn't
5042   # pretend that all is well.)
5043   if test -n "$appdirs" ; then
5044     for dir in $appdirs ; do
5045       if test -r $dir/Makefile.in ; then
5046         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5047           appdirs=""
5048           break
5049         fi
5050         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5051           appdirs=""
5052           break
5053         fi
5054       fi
5055     done
5056     if test -n "$appdirs" ; then
5057       echo "*** This configuration is not supported by this package." 1>&2
5058       exit 1
5059     fi
5060   fi
5061   # Okay, some application will build, or we don't care to check.  Still
5062   # notify of subdirs not getting built.
5063   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5064   echo "    ${notsupp}" 1>&2
5065   echo "    (Any other directories should still work fine.)" 1>&2
5066 fi
5067
5068 case "$host" in
5069   *msdosdjgpp*)
5070     enable_gdbtk=no ;;
5071 esac
5072
5073 # To find our prefix, in gcc_cv_tool_prefix.
5074
5075 # The user is always right.
5076 if test "${PATH_SEPARATOR+set}" != set; then
5077   echo "#! /bin/sh" >conf$$.sh
5078   echo  "exit 0"   >>conf$$.sh
5079   chmod +x conf$$.sh
5080   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5081     PATH_SEPARATOR=';'
5082   else
5083     PATH_SEPARATOR=:
5084   fi
5085   rm -f conf$$.sh
5086 fi
5087
5088
5089
5090 if test "x$exec_prefix" = xNONE; then
5091         if test "x$prefix" = xNONE; then
5092                 gcc_cv_tool_prefix=$ac_default_prefix
5093         else
5094                 gcc_cv_tool_prefix=$prefix
5095         fi
5096 else
5097         gcc_cv_tool_prefix=$exec_prefix
5098 fi
5099
5100 # If there is no compiler in the tree, use the PATH only.  In any
5101 # case, if there is no compiler in the tree nobody should use
5102 # AS_FOR_TARGET and LD_FOR_TARGET.
5103 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5104     gcc_version=`cat $srcdir/gcc/BASE-VER`
5105     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5106     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5107     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5108     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5109     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5110     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5111 else
5112     gcc_cv_tool_dirs=
5113 fi
5114
5115 if test x$build = x$target && test -n "$md_exec_prefix"; then
5116         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5117 fi
5118
5119
5120
5121 copy_dirs=
5122
5123
5124 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5125 if test "${with_build_sysroot+set}" = set; then
5126   withval="$with_build_sysroot"
5127   if test x"$withval" != x ; then
5128      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5129    fi
5130 else
5131   SYSROOT_CFLAGS_FOR_TARGET=
5132 fi;
5133
5134
5135
5136 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5137 if test "${with_debug_prefix_map+set}" = set; then
5138   withval="$with_debug_prefix_map"
5139   if test x"$withval" != x; then
5140      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5141      for debug_map in $withval; do
5142        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5143      done
5144    fi
5145 else
5146   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5147 fi;
5148
5149
5150 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5151 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5152 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5153 # We want to ensure that TARGET libraries (which we know are built with
5154 # gcc) are built with "-O2 -g", so include those options when setting
5155 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5156 if test "x$CFLAGS_FOR_TARGET" = x; then
5157   CFLAGS_FOR_TARGET=$CFLAGS
5158   case " $CFLAGS " in
5159     *" -O2 "*) ;;
5160     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5161   esac
5162   case " $CFLAGS " in
5163     *" -g "* | *" -g3 "*) ;;
5164     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5165   esac
5166 fi
5167
5168
5169 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5170   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5171   case " $CXXFLAGS " in
5172     *" -O2 "*) ;;
5173     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5174   esac
5175   case " $CXXFLAGS " in
5176     *" -g "* | *" -g3 "*) ;;
5177     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5178   esac
5179 fi
5180
5181
5182 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5183 # the named directory are copied to $(tooldir)/sys-include.
5184 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5185   if test x${is_cross_compiler} = xno ; then
5186     echo 1>&2 '***' --with-headers is only supported when cross compiling
5187     exit 1
5188   fi
5189   if test x"${with_headers}" != xyes ; then
5190     x=${gcc_cv_tool_prefix}
5191     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5192   fi
5193 fi
5194
5195 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5196 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5197 # are permitted.
5198 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5199   if test x${is_cross_compiler} = xno ; then
5200     echo 1>&2 '***' --with-libs is only supported when cross compiling
5201     exit 1
5202   fi
5203   if test x"${with_libs}" != xyes ; then
5204     # Copy the libraries in reverse order, so that files in the first named
5205     # library override files in subsequent libraries.
5206     x=${gcc_cv_tool_prefix}
5207     for l in ${with_libs}; do
5208       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5209     done
5210   fi
5211 fi
5212
5213 # Set with_gnu_as and with_gnu_ld as appropriate.
5214 #
5215 # This is done by determining whether or not the appropriate directory
5216 # is available, and by checking whether or not specific configurations
5217 # have requested that this magic not happen.
5218 #
5219 # The command line options always override the explicit settings in
5220 # configure.in, and the settings in configure.in override this magic.
5221 #
5222 # If the default for a toolchain is to use GNU as and ld, and you don't
5223 # want to do that, then you should use the --without-gnu-as and
5224 # --without-gnu-ld options for the configure script.
5225
5226 if test x${use_gnu_as} = x &&
5227    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5228   with_gnu_as=yes
5229   extra_host_args="$extra_host_args --with-gnu-as"
5230 fi
5231
5232 if test x${use_gnu_ld} = x &&
5233    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
5234   with_gnu_ld=yes
5235   extra_host_args="$extra_host_args --with-gnu-ld"
5236 fi
5237
5238 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5239 # can detect this case.
5240
5241 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5242   with_newlib=yes
5243   extra_host_args="$extra_host_args --with-newlib"
5244 fi
5245
5246 # Handle ${copy_dirs}
5247 set fnord ${copy_dirs}
5248 shift
5249 while test $# != 0 ; do
5250   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5251     :
5252   else
5253     echo Copying $1 to $2
5254
5255     # Use the install script to create the directory and all required
5256     # parent directories.
5257     if test -d $2 ; then
5258       :
5259     else
5260       echo >config.temp
5261       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5262     fi
5263
5264     # Copy the directory, assuming we have tar.
5265     # FIXME: Should we use B in the second tar?  Not all systems support it.
5266     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5267
5268     # It is the responsibility of the user to correctly adjust all
5269     # symlinks.  If somebody can figure out how to handle them correctly
5270     # here, feel free to add the code.
5271
5272     echo $1 > $2/COPIED
5273   fi
5274   shift; shift
5275 done
5276
5277 # Determine a target-dependent exec_prefix that the installed
5278 # gcc will search in.  Keep this list sorted by triplet, with
5279 # the *-*-osname triplets last.
5280 md_exec_prefix=
5281 case "${target}" in
5282   alpha*-*-*vms*)
5283     md_exec_prefix=/gnu/lib/gcc-lib
5284     ;;
5285   i[34567]86-pc-msdosdjgpp*)
5286     md_exec_prefix=/dev/env/DJDIR/bin
5287     ;;
5288   i[34567]86-*-sco3.2v5*)
5289     if test $with_gnu_as = yes; then
5290       md_exec_prefix=/usr/gnu/bin
5291     else
5292       md_exec_prefix=/usr/ccs/bin/elf
5293     fi
5294     ;;
5295
5296   mn10300-*-* | \
5297   powerpc-*-chorusos* | \
5298   powerpc*-*-eabi* | \
5299   powerpc*-*-sysv* | \
5300   powerpc*-*-kaos* | \
5301   s390x-ibm-tpf*)
5302     md_exec_prefix=/usr/ccs/bin
5303     ;;
5304   sparc64-*-elf*)
5305     ;;
5306   v850*-*-*)
5307     md_exec_prefix=/usr/ccs/bin
5308     ;;
5309   xtensa*-*-elf*)
5310     ;;
5311
5312   *-*-beos* | \
5313   *-*-elf* | \
5314   *-*-hpux* | \
5315   *-*-netware* | \
5316   *-*-nto-qnx* | \
5317   *-*-rtems* | \
5318   *-*-solaris2* | \
5319   *-*-sysv[45]* | \
5320   *-*-vxworks* | \
5321   *-wrs-windiss)
5322     md_exec_prefix=/usr/ccs/bin
5323     ;;
5324 esac
5325
5326 extra_arflags_for_target=
5327 extra_nmflags_for_target=
5328 extra_ranlibflags_for_target=
5329 target_makefile_frag=/dev/null
5330 case "${target}" in
5331   mep*-*-*)
5332     target_makefile_frag="config/mt-mep"
5333     ;;
5334   spu-*-*)
5335     target_makefile_frag="config/mt-spu"
5336     ;;
5337   mips*-sde-elf*)
5338     target_makefile_frag="config/mt-sde"
5339     ;;
5340   mipsisa*-*-elfoabi*)
5341     target_makefile_frag="config/mt-mips-elfoabi"
5342     ;;
5343   *-*-netware*)
5344     target_makefile_frag="config/mt-netware"
5345     ;;
5346   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5347     target_makefile_frag="config/mt-gnu"
5348     ;;
5349   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5350     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5351     # commands to handle both 32-bit and 64-bit objects.  These flags are
5352     # harmless if we're using GNU nm or ar.
5353     extra_arflags_for_target=" -X32_64"
5354     extra_nmflags_for_target=" -B -X32_64"
5355     ;;
5356   *-*-darwin*)
5357     # ranlib from Darwin requires the -c flag to look at common symbols.
5358     extra_ranlibflags_for_target=" -c"
5359     ;;
5360   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5361     target_makefile_frag="config/mt-wince"
5362     ;;
5363 esac
5364
5365 alphaieee_frag=/dev/null
5366 case $target in
5367   alpha*-*-*)
5368     # This just makes sure to use the -mieee option to build target libs.
5369     # This should probably be set individually by each library.
5370     alphaieee_frag="config/mt-alphaieee"
5371     ;;
5372 esac
5373
5374 # If --enable-target-optspace always use -Os instead of -O2 to build
5375 # the target libraries, similarly if it is not specified, use -Os
5376 # on selected platforms.
5377 ospace_frag=/dev/null
5378 case "${enable_target_optspace}:${target}" in
5379   yes:*)
5380     ospace_frag="config/mt-ospace"
5381     ;;
5382   :d30v-*)
5383     ospace_frag="config/mt-d30v"
5384     ;;
5385   :m32r-* | :d10v-* | :fr30-*)
5386     ospace_frag="config/mt-ospace"
5387     ;;
5388   no:* | :*)
5389     ;;
5390   *)
5391     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5392     ;;
5393 esac
5394
5395 # Default to using --with-stabs for certain targets.
5396 if test x${with_stabs} = x ; then
5397   case "${target}" in
5398   mips*-*-irix[56]*)
5399     ;;
5400   mips*-*-* | alpha*-*-osf*)
5401     with_stabs=yes;
5402     extra_host_args="${extra_host_args} --with-stabs"
5403     ;;
5404   esac
5405 fi
5406
5407 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5408 # them automatically.
5409 case "${host}" in
5410   hppa*64*-*-hpux11*)
5411     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5412     ;;
5413 esac
5414
5415 # Some systems (e.g., one of the i386-aix systems the gas testers are
5416 # using) don't handle "\$" correctly, so don't use it here.
5417 tooldir='${exec_prefix}'/${target_noncanonical}
5418 build_tooldir=${tooldir}
5419
5420 # Create a .gdbinit file which runs the one in srcdir
5421 # and tells GDB to look there for source files.
5422
5423 if test -r ${srcdir}/.gdbinit ; then
5424   case ${srcdir} in
5425     .) ;;
5426     *) cat > ./.gdbinit <<EOF
5427 # ${NO_EDIT}
5428 dir ${srcdir}
5429 dir .
5430 source ${srcdir}/.gdbinit
5431 EOF
5432     ;;
5433   esac
5434 fi
5435
5436 # Make sure that the compiler is able to generate an executable.  If it
5437 # can't, we are probably in trouble.  We don't care whether we can run the
5438 # executable--we might be using a cross compiler--we only care whether it
5439 # can be created.  At this point the main configure script has set CC.
5440 we_are_ok=no
5441 echo "int main () { return 0; }" > conftest.c
5442 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5443 if test $? = 0 ; then
5444   if test -s conftest || test -s conftest.exe ; then
5445     we_are_ok=yes
5446   fi
5447 fi
5448 case $we_are_ok in
5449   no)
5450     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5451     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5452     rm -f conftest*
5453     exit 1
5454     ;;
5455 esac
5456 rm -f conftest*
5457
5458 # The Solaris /usr/ucb/cc compiler does not appear to work.
5459 case "${host}" in
5460   sparc-sun-solaris2*)
5461       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5462       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5463           could_use=
5464           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5465           if test -d /opt/cygnus/bin ; then
5466               if test "$could_use" = "" ; then
5467                   could_use="/opt/cygnus/bin"
5468               else
5469                   could_use="$could_use or /opt/cygnus/bin"
5470               fi
5471           fi
5472         if test "$could_use" = "" ; then
5473             echo "Warning: compilation may fail because you're using"
5474             echo "/usr/ucb/cc.  You should change your PATH or CC "
5475             echo "variable and rerun configure."
5476         else
5477             echo "Warning: compilation may fail because you're using"
5478             echo "/usr/ucb/cc, when you should use the C compiler from"
5479             echo "$could_use.  You should change your"
5480             echo "PATH or CC variable and rerun configure."
5481         fi
5482       fi
5483   ;;
5484 esac
5485
5486 case "${host}" in
5487   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5488   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5489   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5490 esac
5491
5492 # Record target_configdirs and the configure arguments for target and
5493 # build configuration in Makefile.
5494 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5495 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5496
5497 # Determine whether gdb needs tk/tcl or not.
5498 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5499 # and in that case we want gdb to be built without tk.  Ugh!
5500 # In fact I believe gdb is the *only* package directly dependent on tk,
5501 # so we should be able to put the 'maybe's in unconditionally and
5502 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5503 # 100% sure that that's safe though.
5504
5505 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5506 case "$enable_gdbtk" in
5507   no)
5508     GDB_TK="" ;;
5509   yes)
5510     GDB_TK="${gdb_tk}" ;;
5511   *)
5512     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5513     # distro.  Eventually someone will fix this and move Insight, nee
5514     # gdbtk to a separate directory.
5515     if test -d ${srcdir}/gdb/gdbtk ; then
5516       GDB_TK="${gdb_tk}"
5517     else
5518       GDB_TK=""
5519     fi
5520     ;;
5521 esac
5522 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5523 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5524
5525 # Strip out unwanted targets.
5526
5527 # While at that, we remove Makefiles if we were started for recursive
5528 # configuration, so that the top-level Makefile reconfigures them,
5529 # like we used to do when configure itself was recursive.
5530
5531 # Loop over modules.  $extrasub must be used with care, limiting as
5532 # much as possible the usage of range addresses.  That's because autoconf
5533 # splits the sed script to overcome limits in the number of commands,
5534 # and relying on carefully-timed sed passes may turn out to be very hard
5535 # to maintain later.  In this particular case, you just have to be careful
5536 # not to nest @if/@endif pairs, because configure will not warn you at all.
5537
5538 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5539 if test "${enable_bootstrap+set}" = set; then
5540   enableval="$enable_bootstrap"
5541
5542 else
5543   enable_bootstrap=default
5544 fi;
5545
5546 # Issue errors and warnings for invalid/strange bootstrap combinations.
5547 case "$configdirs" in
5548   *gcc*) have_compiler=yes ;;
5549   *) have_compiler=no ;;
5550 esac
5551
5552 case "$have_compiler:$host:$target:$enable_bootstrap" in
5553   *:*:*:no) ;;
5554
5555   # Default behavior.  Enable bootstrap if we have a compiler
5556   # and we are in a native configuration.
5557   yes:$build:$build:default)
5558     enable_bootstrap=yes ;;
5559
5560   *:*:*:default)
5561     enable_bootstrap=no ;;
5562
5563   # We have a compiler and we are in a native configuration, bootstrap is ok
5564   yes:$build:$build:yes)
5565     ;;
5566
5567   # Other configurations, but we have a compiler.  Assume the user knows
5568   # what he's doing.
5569   yes:*:*:yes)
5570     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5571 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5572     ;;
5573
5574   # No compiler: if they passed --enable-bootstrap explicitly, fail
5575   no:*:*:yes)
5576     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5577 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5578    { (exit 1); exit 1; }; } ;;
5579
5580   # Fail if wrong command line
5581   *)
5582     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5583 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5584    { (exit 1); exit 1; }; }
5585     ;;
5586 esac
5587
5588 # Adjust the toplevel makefile according to whether bootstrap was selected.
5589 case "$enable_bootstrap" in
5590   yes)
5591     bootstrap_suffix=bootstrap ;;
5592   no)
5593     bootstrap_suffix=no-bootstrap ;;
5594 esac
5595
5596 for module in ${build_configdirs} ; do
5597   if test -z "${no_recursion}" \
5598      && test -f ${build_subdir}/${module}/Makefile; then
5599     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5600     rm -f ${build_subdir}/${module}/Makefile
5601   fi
5602   extrasub="$extrasub
5603 /^@if build-$module\$/d
5604 /^@endif build-$module\$/d
5605 /^@if build-$module-$bootstrap_suffix\$/d
5606 /^@endif build-$module-$bootstrap_suffix\$/d"
5607 done
5608 for module in ${configdirs} ; do
5609   if test -z "${no_recursion}"; then
5610     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5611       if test -f ${file}; then
5612         echo 1>&2 "*** removing ${file} to force reconfigure"
5613         rm -f ${file}
5614       fi
5615     done
5616   fi
5617   extrasub="$extrasub
5618 /^@if $module\$/d
5619 /^@endif $module\$/d
5620 /^@if $module-$bootstrap_suffix\$/d
5621 /^@endif $module-$bootstrap_suffix\$/d"
5622 done
5623 for module in ${target_configdirs} ; do
5624   if test -z "${no_recursion}" \
5625      && test -f ${target_subdir}/${module}/Makefile; then
5626     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5627     rm -f ${target_subdir}/${module}/Makefile
5628   fi
5629   extrasub="$extrasub
5630 /^@if target-$module\$/d
5631 /^@endif target-$module\$/d
5632 /^@if target-$module-$bootstrap_suffix\$/d
5633 /^@endif target-$module-$bootstrap_suffix\$/d"
5634 done
5635
5636 extrasub="$extrasub
5637 /^@if /,/^@endif /d"
5638
5639 # Create the serialization dependencies.  This uses a temporary file.
5640
5641 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5642 if test "${enable_serial_configure+set}" = set; then
5643   enableval="$enable_serial_configure"
5644
5645 fi;
5646
5647 case ${enable_serial_configure} in
5648   yes)
5649     enable_serial_build_configure=yes
5650     enable_serial_host_configure=yes
5651     enable_serial_target_configure=yes
5652     ;;
5653 esac
5654
5655 # These force 'configure's to be done one at a time, to avoid problems
5656 # with contention over a shared config.cache.
5657 rm -f serdep.tmp
5658 echo '# serdep.tmp' > serdep.tmp
5659 olditem=
5660 test "x${enable_serial_build_configure}" = xyes &&
5661 for item in ${build_configdirs} ; do
5662   case ${olditem} in
5663     "") ;;
5664     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5665   esac
5666   olditem=${item}
5667 done
5668 olditem=
5669 test "x${enable_serial_host_configure}" = xyes &&
5670 for item in ${configdirs} ; do
5671   case ${olditem} in
5672     "") ;;
5673     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5674   esac
5675   olditem=${item}
5676 done
5677 olditem=
5678 test "x${enable_serial_target_configure}" = xyes &&
5679 for item in ${target_configdirs} ; do
5680   case ${olditem} in
5681     "") ;;
5682     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5683   esac
5684   olditem=${item}
5685 done
5686 serialization_dependencies=serdep.tmp
5687
5688
5689 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5690 # target, nonopt, and variable assignments.  These are the ones we
5691 # might not want to pass down to subconfigures.  Also strip
5692 # program-prefix, program-suffix, and program-transform-name, so that
5693 # we can pass down a consistent program-transform-name.
5694 baseargs=
5695 keep_next=no
5696 skip_next=no
5697 eval "set -- $ac_configure_args"
5698 for ac_arg
5699 do
5700   if test X"$skip_next" = X"yes"; then
5701     skip_next=no
5702     continue
5703   fi
5704   if test X"$keep_next" = X"yes"; then
5705     case $ac_arg in
5706       *\'*)
5707         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5708     esac
5709     baseargs="$baseargs '$ac_arg'"
5710     keep_next=no
5711     continue
5712   fi
5713
5714   # Handle separated arguments.  Based on the logic generated by
5715   # autoconf 2.59.
5716   case $ac_arg in
5717     *=* | --config-cache | -C | -disable-* | --disable-* \
5718       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5719       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5720       | -with-* | --with-* | -without-* | --without-* | --x)
5721       separate_arg=no
5722       ;;
5723     -*)
5724       separate_arg=yes
5725       ;;
5726     *)
5727       separate_arg=no
5728       ;;
5729   esac
5730
5731   case "$ac_arg" in
5732     --no*)
5733       continue
5734       ;;
5735     --c* | \
5736     --sr* | \
5737     --ho* | \
5738     --bu* | \
5739     --t* | \
5740     --program-* | \
5741     -cache_file* | \
5742     -srcdir* | \
5743     -host* | \
5744     -build* | \
5745     -target* | \
5746     -program-prefix* | \
5747     -program-suffix* | \
5748     -program-transform-name* )
5749       skip_next=$separate_arg
5750       continue
5751       ;;
5752     -*)
5753       # An option.  Add it.
5754       case $ac_arg in
5755         *\'*)
5756           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5757       esac
5758       baseargs="$baseargs '$ac_arg'"
5759       keep_next=$separate_arg
5760       ;;
5761     *)
5762       # Either a variable assignment, or a nonopt (triplet).  Don't
5763       # pass it down; let the Makefile handle this.
5764       continue
5765       ;;
5766   esac
5767 done
5768 # Remove the initial space we just introduced and, as these will be
5769 # expanded by make, quote '$'.
5770 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5771
5772 # Add in --program-transform-name, after --program-prefix and
5773 # --program-suffix have been applied to it.  Autoconf has already
5774 # doubled dollar signs and backslashes in program_transform_name; we want
5775 # the backslashes un-doubled, and then the entire thing wrapped in single
5776 # quotes, because this will be expanded first by make and then by the shell.
5777 # Also, because we want to override the logic in subdir configure scripts to
5778 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5779 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5780 ${program_transform_name}
5781 EOF_SED
5782 gcc_transform_name=`cat conftestsed.out`
5783 rm -f conftestsed.out
5784 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5785 if test "$silent" = yes; then
5786   baseargs="$baseargs --silent"
5787 fi
5788
5789 # For the build-side libraries, we just need to pretend we're native,
5790 # and not use the same cache file.  Multilibs are neither needed nor
5791 # desired.
5792 build_configargs="--cache-file=../config.cache ${baseargs}"
5793
5794 # For host modules, accept cache file option, or specification as blank.
5795 case "${cache_file}" in
5796 "") # empty
5797   cache_file_option="" ;;
5798 /* | [A-Za-z]:[\\/]* ) # absolute path
5799   cache_file_option="--cache-file=${cache_file}" ;;
5800 *) # relative path
5801   cache_file_option="--cache-file=../${cache_file}" ;;
5802 esac
5803
5804 # Host dirs don't like to share a cache file either, horribly enough.
5805 # This seems to be due to autoconf 2.5x stupidity.
5806 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5807
5808 target_configargs=${baseargs}
5809
5810 # Passing a --with-cross-host argument lets the target libraries know
5811 # whether they are being built with a cross-compiler or being built
5812 # native.  However, it would be better to use other mechanisms to make the
5813 # sorts of decisions they want to make on this basis.  Please consider
5814 # this option to be deprecated.  FIXME.
5815 if test x${is_cross_compiler} = xyes ; then
5816   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5817 fi
5818
5819 # Default to --enable-multilib.
5820 if test x${enable_multilib} = x ; then
5821   target_configargs="--enable-multilib ${target_configargs}"
5822 fi
5823
5824 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5825 # changed from the earlier setting of with_newlib.
5826 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5827   target_configargs="--with-newlib ${target_configargs}"
5828 fi
5829
5830 # Different target subdirs use different values of certain variables
5831 # (notably CXX).  Worse, multilibs use *lots* of different values.
5832 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5833 # it doesn't automatically accept command-line overrides of them.
5834 # This means it's not safe for target subdirs to share a cache file,
5835 # which is disgusting, but there you have it.  Hopefully this can be
5836 # fixed in future.  It's still worthwhile to use a cache file for each
5837 # directory.  I think.
5838
5839 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5840 # We need to pass --target, as newer autoconf's requires consistency
5841 # for target_alias and gcc doesn't manage it consistently.
5842 target_configargs="--cache-file=./config.cache ${target_configargs}"
5843
5844 FLAGS_FOR_TARGET=
5845 case " $target_configdirs " in
5846  *" newlib "*)
5847   case " $target_configargs " in
5848   *" --with-newlib "*)
5849    case "$target" in
5850    *-cygwin*)
5851      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' ;;
5852    esac
5853
5854    # If we're not building GCC, don't discard standard headers.
5855    if test -d ${srcdir}/gcc; then
5856      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5857
5858      if test "${build}" != "${host}"; then
5859        # On Canadian crosses, CC_FOR_TARGET will have already been set
5860        # by `configure', so we won't have an opportunity to add -Bgcc/
5861        # to it.  This is right: we don't want to search that directory
5862        # for binaries, but we want the header files in there, so add
5863        # them explicitly.
5864        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5865
5866        # Someone might think of using the pre-installed headers on
5867        # Canadian crosses, in case the installed compiler is not fully
5868        # compatible with the compiler being built.  In this case, it
5869        # would be better to flag an error than risking having
5870        # incompatible object files being constructed.  We can't
5871        # guarantee that an error will be flagged, but let's hope the
5872        # compiler will do it, when presented with incompatible header
5873        # files.
5874      fi
5875    fi
5876
5877    case "${target}-${is_cross_compiler}" in
5878    i[3456789]86-*-linux*-no)
5879       # Here host == target, so we don't need to build gcc,
5880       # so we don't want to discard standard headers.
5881       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5882       ;;
5883    *)
5884       # If we're building newlib, use its generic headers last, but search
5885       # for any libc-related directories first (so make it the last -B
5886       # switch).
5887       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5888
5889       # If we're building libgloss, find the startup file, simulator library
5890       # and linker script.
5891       case " $target_configdirs " in
5892         *" libgloss "*)
5893         # Look for startup file, simulator library and maybe linker script.
5894         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
5895         # Look for libnosys.a in case the target needs it.
5896         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5897         # Most targets have the linker script in the source directory.
5898         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
5899         ;;
5900       esac
5901       ;;
5902    esac
5903    ;;
5904   esac
5905   ;;
5906 esac
5907 case "$target" in
5908 *-mingw*)
5909   # Can't be handled as Cygwin above since Mingw does not use newlib.
5910   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' ;;
5911 esac
5912
5913 # Allow the user to override the flags for
5914 # our build compiler if desired.
5915 if test x"${build}" = x"${host}" ; then
5916   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5917   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
5918   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
5919 fi
5920
5921 # On Canadian crosses, we'll be searching the right directories for
5922 # the previously-installed cross compiler, so don't bother to add
5923 # flags for directories within the install tree of the compiler
5924 # being built; programs in there won't even run.
5925 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5926   # Search for pre-installed headers if nothing else fits.
5927   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5928 fi
5929
5930 if test "x${use_gnu_ld}" = x &&
5931    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5932   # Arrange for us to find uninstalled linker scripts.
5933   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5934 fi
5935
5936 # Search for other target-specific linker scripts and such.
5937 case "${target}" in
5938   mep*)
5939     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5940     ;;
5941 esac
5942
5943 # Makefile fragments.
5944 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5945 do
5946   eval fragval=\$$frag
5947   if test $fragval != /dev/null; then
5948     eval $frag=${srcdir}/$fragval
5949   fi
5950 done
5951
5952
5953
5954
5955
5956 # Miscellanea: directories, flags, etc.
5957
5958
5959
5960
5961
5962
5963
5964 # Build module lists & subconfigure args.
5965
5966
5967
5968 # Host module lists & subconfigure args.
5969
5970
5971
5972 # Target module lists & subconfigure args.
5973
5974
5975
5976 # Build tools.
5977
5978
5979
5980
5981
5982
5983
5984
5985
5986
5987
5988
5989
5990
5991
5992
5993
5994 # Generate default definitions for YACC, M4, LEX and other programs that run
5995 # on the build machine.  These are used if the Makefile can't locate these
5996 # programs in objdir.
5997 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5998
5999 for ac_prog in 'bison -y' byacc yacc
6000 do
6001   # Extract the first word of "$ac_prog", so it can be a program name with args.
6002 set dummy $ac_prog; ac_word=$2
6003 echo "$as_me:$LINENO: checking for $ac_word" >&5
6004 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6005 if test "${ac_cv_prog_YACC+set}" = set; then
6006   echo $ECHO_N "(cached) $ECHO_C" >&6
6007 else
6008   if test -n "$YACC"; then
6009   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6010 else
6011 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6012 for as_dir in $PATH
6013 do
6014   IFS=$as_save_IFS
6015   test -z "$as_dir" && as_dir=.
6016   for ac_exec_ext in '' $ac_executable_extensions; do
6017   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6018     ac_cv_prog_YACC="$ac_prog"
6019     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6020     break 2
6021   fi
6022 done
6023 done
6024
6025 fi
6026 fi
6027 YACC=$ac_cv_prog_YACC
6028 if test -n "$YACC"; then
6029   echo "$as_me:$LINENO: result: $YACC" >&5
6030 echo "${ECHO_T}$YACC" >&6
6031 else
6032   echo "$as_me:$LINENO: result: no" >&5
6033 echo "${ECHO_T}no" >&6
6034 fi
6035
6036   test -n "$YACC" && break
6037 done
6038 test -n "$YACC" || YACC="$MISSING bison -y"
6039
6040 case " $build_configdirs " in
6041   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6042   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6043 esac
6044
6045 for ac_prog in bison
6046 do
6047   # Extract the first word of "$ac_prog", so it can be a program name with args.
6048 set dummy $ac_prog; ac_word=$2
6049 echo "$as_me:$LINENO: checking for $ac_word" >&5
6050 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6051 if test "${ac_cv_prog_BISON+set}" = set; then
6052   echo $ECHO_N "(cached) $ECHO_C" >&6
6053 else
6054   if test -n "$BISON"; then
6055   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6056 else
6057 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6058 for as_dir in $PATH
6059 do
6060   IFS=$as_save_IFS
6061   test -z "$as_dir" && as_dir=.
6062   for ac_exec_ext in '' $ac_executable_extensions; do
6063   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6064     ac_cv_prog_BISON="$ac_prog"
6065     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6066     break 2
6067   fi
6068 done
6069 done
6070
6071 fi
6072 fi
6073 BISON=$ac_cv_prog_BISON
6074 if test -n "$BISON"; then
6075   echo "$as_me:$LINENO: result: $BISON" >&5
6076 echo "${ECHO_T}$BISON" >&6
6077 else
6078   echo "$as_me:$LINENO: result: no" >&5
6079 echo "${ECHO_T}no" >&6
6080 fi
6081
6082   test -n "$BISON" && break
6083 done
6084 test -n "$BISON" || BISON="$MISSING bison"
6085
6086 case " $build_configdirs " in
6087   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6088 esac
6089
6090 for ac_prog in gm4 gnum4 m4
6091 do
6092   # Extract the first word of "$ac_prog", so it can be a program name with args.
6093 set dummy $ac_prog; ac_word=$2
6094 echo "$as_me:$LINENO: checking for $ac_word" >&5
6095 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6096 if test "${ac_cv_prog_M4+set}" = set; then
6097   echo $ECHO_N "(cached) $ECHO_C" >&6
6098 else
6099   if test -n "$M4"; then
6100   ac_cv_prog_M4="$M4" # Let the user override the test.
6101 else
6102 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6103 for as_dir in $PATH
6104 do
6105   IFS=$as_save_IFS
6106   test -z "$as_dir" && as_dir=.
6107   for ac_exec_ext in '' $ac_executable_extensions; do
6108   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6109     ac_cv_prog_M4="$ac_prog"
6110     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6111     break 2
6112   fi
6113 done
6114 done
6115
6116 fi
6117 fi
6118 M4=$ac_cv_prog_M4
6119 if test -n "$M4"; then
6120   echo "$as_me:$LINENO: result: $M4" >&5
6121 echo "${ECHO_T}$M4" >&6
6122 else
6123   echo "$as_me:$LINENO: result: no" >&5
6124 echo "${ECHO_T}no" >&6
6125 fi
6126
6127   test -n "$M4" && break
6128 done
6129 test -n "$M4" || M4="$MISSING m4"
6130
6131 case " $build_configdirs " in
6132   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6133 esac
6134
6135 for ac_prog in flex lex
6136 do
6137   # Extract the first word of "$ac_prog", so it can be a program name with args.
6138 set dummy $ac_prog; ac_word=$2
6139 echo "$as_me:$LINENO: checking for $ac_word" >&5
6140 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6141 if test "${ac_cv_prog_LEX+set}" = set; then
6142   echo $ECHO_N "(cached) $ECHO_C" >&6
6143 else
6144   if test -n "$LEX"; then
6145   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6146 else
6147 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6148 for as_dir in $PATH
6149 do
6150   IFS=$as_save_IFS
6151   test -z "$as_dir" && as_dir=.
6152   for ac_exec_ext in '' $ac_executable_extensions; do
6153   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6154     ac_cv_prog_LEX="$ac_prog"
6155     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6156     break 2
6157   fi
6158 done
6159 done
6160
6161 fi
6162 fi
6163 LEX=$ac_cv_prog_LEX
6164 if test -n "$LEX"; then
6165   echo "$as_me:$LINENO: result: $LEX" >&5
6166 echo "${ECHO_T}$LEX" >&6
6167 else
6168   echo "$as_me:$LINENO: result: no" >&5
6169 echo "${ECHO_T}no" >&6
6170 fi
6171
6172   test -n "$LEX" && break
6173 done
6174 test -n "$LEX" || LEX="$MISSING flex"
6175
6176 case " $build_configdirs " in
6177   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6178   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6179 esac
6180
6181 for ac_prog in flex
6182 do
6183   # Extract the first word of "$ac_prog", so it can be a program name with args.
6184 set dummy $ac_prog; ac_word=$2
6185 echo "$as_me:$LINENO: checking for $ac_word" >&5
6186 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6187 if test "${ac_cv_prog_FLEX+set}" = set; then
6188   echo $ECHO_N "(cached) $ECHO_C" >&6
6189 else
6190   if test -n "$FLEX"; then
6191   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6192 else
6193 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6194 for as_dir in $PATH
6195 do
6196   IFS=$as_save_IFS
6197   test -z "$as_dir" && as_dir=.
6198   for ac_exec_ext in '' $ac_executable_extensions; do
6199   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6200     ac_cv_prog_FLEX="$ac_prog"
6201     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6202     break 2
6203   fi
6204 done
6205 done
6206
6207 fi
6208 fi
6209 FLEX=$ac_cv_prog_FLEX
6210 if test -n "$FLEX"; then
6211   echo "$as_me:$LINENO: result: $FLEX" >&5
6212 echo "${ECHO_T}$FLEX" >&6
6213 else
6214   echo "$as_me:$LINENO: result: no" >&5
6215 echo "${ECHO_T}no" >&6
6216 fi
6217
6218   test -n "$FLEX" && break
6219 done
6220 test -n "$FLEX" || FLEX="$MISSING flex"
6221
6222 case " $build_configdirs " in
6223   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6224 esac
6225
6226 for ac_prog in makeinfo
6227 do
6228   # Extract the first word of "$ac_prog", so it can be a program name with args.
6229 set dummy $ac_prog; ac_word=$2
6230 echo "$as_me:$LINENO: checking for $ac_word" >&5
6231 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6232 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6233   echo $ECHO_N "(cached) $ECHO_C" >&6
6234 else
6235   if test -n "$MAKEINFO"; then
6236   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6237 else
6238 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6239 for as_dir in $PATH
6240 do
6241   IFS=$as_save_IFS
6242   test -z "$as_dir" && as_dir=.
6243   for ac_exec_ext in '' $ac_executable_extensions; do
6244   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6245     ac_cv_prog_MAKEINFO="$ac_prog"
6246     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6247     break 2
6248   fi
6249 done
6250 done
6251
6252 fi
6253 fi
6254 MAKEINFO=$ac_cv_prog_MAKEINFO
6255 if test -n "$MAKEINFO"; then
6256   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6257 echo "${ECHO_T}$MAKEINFO" >&6
6258 else
6259   echo "$as_me:$LINENO: result: no" >&5
6260 echo "${ECHO_T}no" >&6
6261 fi
6262
6263   test -n "$MAKEINFO" && break
6264 done
6265 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6266
6267 case " $build_configdirs " in
6268   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6269   *)
6270
6271     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6272     # higher, else we use the "missing" dummy.
6273     if ${MAKEINFO} --version \
6274        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6275       :
6276     else
6277       MAKEINFO="$MISSING makeinfo"
6278     fi
6279     ;;
6280
6281 esac
6282
6283 # FIXME: expect and dejagnu may become build tools?
6284
6285 for ac_prog in expect
6286 do
6287   # Extract the first word of "$ac_prog", so it can be a program name with args.
6288 set dummy $ac_prog; ac_word=$2
6289 echo "$as_me:$LINENO: checking for $ac_word" >&5
6290 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6291 if test "${ac_cv_prog_EXPECT+set}" = set; then
6292   echo $ECHO_N "(cached) $ECHO_C" >&6
6293 else
6294   if test -n "$EXPECT"; then
6295   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6296 else
6297 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6298 for as_dir in $PATH
6299 do
6300   IFS=$as_save_IFS
6301   test -z "$as_dir" && as_dir=.
6302   for ac_exec_ext in '' $ac_executable_extensions; do
6303   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6304     ac_cv_prog_EXPECT="$ac_prog"
6305     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6306     break 2
6307   fi
6308 done
6309 done
6310
6311 fi
6312 fi
6313 EXPECT=$ac_cv_prog_EXPECT
6314 if test -n "$EXPECT"; then
6315   echo "$as_me:$LINENO: result: $EXPECT" >&5
6316 echo "${ECHO_T}$EXPECT" >&6
6317 else
6318   echo "$as_me:$LINENO: result: no" >&5
6319 echo "${ECHO_T}no" >&6
6320 fi
6321
6322   test -n "$EXPECT" && break
6323 done
6324 test -n "$EXPECT" || EXPECT="expect"
6325
6326 case " $configdirs " in
6327   *" expect "*)
6328     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6329     ;;
6330 esac
6331
6332 for ac_prog in runtest
6333 do
6334   # Extract the first word of "$ac_prog", so it can be a program name with args.
6335 set dummy $ac_prog; ac_word=$2
6336 echo "$as_me:$LINENO: checking for $ac_word" >&5
6337 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6338 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6339   echo $ECHO_N "(cached) $ECHO_C" >&6
6340 else
6341   if test -n "$RUNTEST"; then
6342   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6343 else
6344 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6345 for as_dir in $PATH
6346 do
6347   IFS=$as_save_IFS
6348   test -z "$as_dir" && as_dir=.
6349   for ac_exec_ext in '' $ac_executable_extensions; do
6350   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6351     ac_cv_prog_RUNTEST="$ac_prog"
6352     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6353     break 2
6354   fi
6355 done
6356 done
6357
6358 fi
6359 fi
6360 RUNTEST=$ac_cv_prog_RUNTEST
6361 if test -n "$RUNTEST"; then
6362   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6363 echo "${ECHO_T}$RUNTEST" >&6
6364 else
6365   echo "$as_me:$LINENO: result: no" >&5
6366 echo "${ECHO_T}no" >&6
6367 fi
6368
6369   test -n "$RUNTEST" && break
6370 done
6371 test -n "$RUNTEST" || RUNTEST="runtest"
6372
6373 case " $configdirs " in
6374   *" dejagnu "*)
6375     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6376     ;;
6377 esac
6378
6379
6380 # Host tools.
6381 ncn_tool_prefix=
6382 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6383 ncn_target_tool_prefix=
6384 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6385
6386
6387
6388 if test -n "$AR"; then
6389   ac_cv_prog_AR=$AR
6390 elif test -n "$ac_cv_prog_AR"; then
6391   AR=$ac_cv_prog_AR
6392 fi
6393
6394 if test -n "$ac_cv_prog_AR"; then
6395   for ncn_progname in ar; do
6396     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6397 set dummy ${ncn_progname}; ac_word=$2
6398 echo "$as_me:$LINENO: checking for $ac_word" >&5
6399 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6400 if test "${ac_cv_prog_AR+set}" = set; then
6401   echo $ECHO_N "(cached) $ECHO_C" >&6
6402 else
6403   if test -n "$AR"; then
6404   ac_cv_prog_AR="$AR" # Let the user override the test.
6405 else
6406 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6407 for as_dir in $PATH
6408 do
6409   IFS=$as_save_IFS
6410   test -z "$as_dir" && as_dir=.
6411   for ac_exec_ext in '' $ac_executable_extensions; do
6412   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6413     ac_cv_prog_AR="${ncn_progname}"
6414     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6415     break 2
6416   fi
6417 done
6418 done
6419
6420 fi
6421 fi
6422 AR=$ac_cv_prog_AR
6423 if test -n "$AR"; then
6424   echo "$as_me:$LINENO: result: $AR" >&5
6425 echo "${ECHO_T}$AR" >&6
6426 else
6427   echo "$as_me:$LINENO: result: no" >&5
6428 echo "${ECHO_T}no" >&6
6429 fi
6430
6431   done
6432 fi
6433
6434 for ncn_progname in ar; do
6435   if test -n "$ncn_tool_prefix"; then
6436     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6437 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6438 echo "$as_me:$LINENO: checking for $ac_word" >&5
6439 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6440 if test "${ac_cv_prog_AR+set}" = set; then
6441   echo $ECHO_N "(cached) $ECHO_C" >&6
6442 else
6443   if test -n "$AR"; then
6444   ac_cv_prog_AR="$AR" # Let the user override the test.
6445 else
6446 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6447 for as_dir in $PATH
6448 do
6449   IFS=$as_save_IFS
6450   test -z "$as_dir" && as_dir=.
6451   for ac_exec_ext in '' $ac_executable_extensions; do
6452   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6453     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6454     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6455     break 2
6456   fi
6457 done
6458 done
6459
6460 fi
6461 fi
6462 AR=$ac_cv_prog_AR
6463 if test -n "$AR"; then
6464   echo "$as_me:$LINENO: result: $AR" >&5
6465 echo "${ECHO_T}$AR" >&6
6466 else
6467   echo "$as_me:$LINENO: result: no" >&5
6468 echo "${ECHO_T}no" >&6
6469 fi
6470
6471   fi
6472   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6473     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6474 set dummy ${ncn_progname}; ac_word=$2
6475 echo "$as_me:$LINENO: checking for $ac_word" >&5
6476 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6477 if test "${ac_cv_prog_AR+set}" = set; then
6478   echo $ECHO_N "(cached) $ECHO_C" >&6
6479 else
6480   if test -n "$AR"; then
6481   ac_cv_prog_AR="$AR" # Let the user override the test.
6482 else
6483 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6484 for as_dir in $PATH
6485 do
6486   IFS=$as_save_IFS
6487   test -z "$as_dir" && as_dir=.
6488   for ac_exec_ext in '' $ac_executable_extensions; do
6489   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6490     ac_cv_prog_AR="${ncn_progname}"
6491     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6492     break 2
6493   fi
6494 done
6495 done
6496
6497 fi
6498 fi
6499 AR=$ac_cv_prog_AR
6500 if test -n "$AR"; then
6501   echo "$as_me:$LINENO: result: $AR" >&5
6502 echo "${ECHO_T}$AR" >&6
6503 else
6504   echo "$as_me:$LINENO: result: no" >&5
6505 echo "${ECHO_T}no" >&6
6506 fi
6507
6508   fi
6509   test -n "$ac_cv_prog_AR" && break
6510 done
6511
6512 if test -z "$ac_cv_prog_AR" ; then
6513   set dummy ar
6514   if test $build = $host ; then
6515     AR="$2"
6516   else
6517     AR="${ncn_tool_prefix}$2"
6518   fi
6519 fi
6520
6521
6522
6523 if test -n "$AS"; then
6524   ac_cv_prog_AS=$AS
6525 elif test -n "$ac_cv_prog_AS"; then
6526   AS=$ac_cv_prog_AS
6527 fi
6528
6529 if test -n "$ac_cv_prog_AS"; then
6530   for ncn_progname in as; do
6531     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6532 set dummy ${ncn_progname}; ac_word=$2
6533 echo "$as_me:$LINENO: checking for $ac_word" >&5
6534 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6535 if test "${ac_cv_prog_AS+set}" = set; then
6536   echo $ECHO_N "(cached) $ECHO_C" >&6
6537 else
6538   if test -n "$AS"; then
6539   ac_cv_prog_AS="$AS" # Let the user override the test.
6540 else
6541 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6542 for as_dir in $PATH
6543 do
6544   IFS=$as_save_IFS
6545   test -z "$as_dir" && as_dir=.
6546   for ac_exec_ext in '' $ac_executable_extensions; do
6547   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6548     ac_cv_prog_AS="${ncn_progname}"
6549     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6550     break 2
6551   fi
6552 done
6553 done
6554
6555 fi
6556 fi
6557 AS=$ac_cv_prog_AS
6558 if test -n "$AS"; then
6559   echo "$as_me:$LINENO: result: $AS" >&5
6560 echo "${ECHO_T}$AS" >&6
6561 else
6562   echo "$as_me:$LINENO: result: no" >&5
6563 echo "${ECHO_T}no" >&6
6564 fi
6565
6566   done
6567 fi
6568
6569 for ncn_progname in as; do
6570   if test -n "$ncn_tool_prefix"; then
6571     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6572 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6573 echo "$as_me:$LINENO: checking for $ac_word" >&5
6574 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6575 if test "${ac_cv_prog_AS+set}" = set; then
6576   echo $ECHO_N "(cached) $ECHO_C" >&6
6577 else
6578   if test -n "$AS"; then
6579   ac_cv_prog_AS="$AS" # Let the user override the test.
6580 else
6581 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6582 for as_dir in $PATH
6583 do
6584   IFS=$as_save_IFS
6585   test -z "$as_dir" && as_dir=.
6586   for ac_exec_ext in '' $ac_executable_extensions; do
6587   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6588     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6589     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6590     break 2
6591   fi
6592 done
6593 done
6594
6595 fi
6596 fi
6597 AS=$ac_cv_prog_AS
6598 if test -n "$AS"; then
6599   echo "$as_me:$LINENO: result: $AS" >&5
6600 echo "${ECHO_T}$AS" >&6
6601 else
6602   echo "$as_me:$LINENO: result: no" >&5
6603 echo "${ECHO_T}no" >&6
6604 fi
6605
6606   fi
6607   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6608     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6609 set dummy ${ncn_progname}; ac_word=$2
6610 echo "$as_me:$LINENO: checking for $ac_word" >&5
6611 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6612 if test "${ac_cv_prog_AS+set}" = set; then
6613   echo $ECHO_N "(cached) $ECHO_C" >&6
6614 else
6615   if test -n "$AS"; then
6616   ac_cv_prog_AS="$AS" # Let the user override the test.
6617 else
6618 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6619 for as_dir in $PATH
6620 do
6621   IFS=$as_save_IFS
6622   test -z "$as_dir" && as_dir=.
6623   for ac_exec_ext in '' $ac_executable_extensions; do
6624   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6625     ac_cv_prog_AS="${ncn_progname}"
6626     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6627     break 2
6628   fi
6629 done
6630 done
6631
6632 fi
6633 fi
6634 AS=$ac_cv_prog_AS
6635 if test -n "$AS"; then
6636   echo "$as_me:$LINENO: result: $AS" >&5
6637 echo "${ECHO_T}$AS" >&6
6638 else
6639   echo "$as_me:$LINENO: result: no" >&5
6640 echo "${ECHO_T}no" >&6
6641 fi
6642
6643   fi
6644   test -n "$ac_cv_prog_AS" && break
6645 done
6646
6647 if test -z "$ac_cv_prog_AS" ; then
6648   set dummy as
6649   if test $build = $host ; then
6650     AS="$2"
6651   else
6652     AS="${ncn_tool_prefix}$2"
6653   fi
6654 fi
6655
6656
6657
6658 if test -n "$DLLTOOL"; then
6659   ac_cv_prog_DLLTOOL=$DLLTOOL
6660 elif test -n "$ac_cv_prog_DLLTOOL"; then
6661   DLLTOOL=$ac_cv_prog_DLLTOOL
6662 fi
6663
6664 if test -n "$ac_cv_prog_DLLTOOL"; then
6665   for ncn_progname in dlltool; do
6666     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6667 set dummy ${ncn_progname}; ac_word=$2
6668 echo "$as_me:$LINENO: checking for $ac_word" >&5
6669 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6670 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6671   echo $ECHO_N "(cached) $ECHO_C" >&6
6672 else
6673   if test -n "$DLLTOOL"; then
6674   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6675 else
6676 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6677 for as_dir in $PATH
6678 do
6679   IFS=$as_save_IFS
6680   test -z "$as_dir" && as_dir=.
6681   for ac_exec_ext in '' $ac_executable_extensions; do
6682   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6683     ac_cv_prog_DLLTOOL="${ncn_progname}"
6684     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6685     break 2
6686   fi
6687 done
6688 done
6689
6690 fi
6691 fi
6692 DLLTOOL=$ac_cv_prog_DLLTOOL
6693 if test -n "$DLLTOOL"; then
6694   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6695 echo "${ECHO_T}$DLLTOOL" >&6
6696 else
6697   echo "$as_me:$LINENO: result: no" >&5
6698 echo "${ECHO_T}no" >&6
6699 fi
6700
6701   done
6702 fi
6703
6704 for ncn_progname in dlltool; do
6705   if test -n "$ncn_tool_prefix"; then
6706     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6707 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6708 echo "$as_me:$LINENO: checking for $ac_word" >&5
6709 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6710 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6711   echo $ECHO_N "(cached) $ECHO_C" >&6
6712 else
6713   if test -n "$DLLTOOL"; then
6714   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6715 else
6716 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6717 for as_dir in $PATH
6718 do
6719   IFS=$as_save_IFS
6720   test -z "$as_dir" && as_dir=.
6721   for ac_exec_ext in '' $ac_executable_extensions; do
6722   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6723     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6724     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6725     break 2
6726   fi
6727 done
6728 done
6729
6730 fi
6731 fi
6732 DLLTOOL=$ac_cv_prog_DLLTOOL
6733 if test -n "$DLLTOOL"; then
6734   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6735 echo "${ECHO_T}$DLLTOOL" >&6
6736 else
6737   echo "$as_me:$LINENO: result: no" >&5
6738 echo "${ECHO_T}no" >&6
6739 fi
6740
6741   fi
6742   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6743     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6744 set dummy ${ncn_progname}; ac_word=$2
6745 echo "$as_me:$LINENO: checking for $ac_word" >&5
6746 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6747 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6748   echo $ECHO_N "(cached) $ECHO_C" >&6
6749 else
6750   if test -n "$DLLTOOL"; then
6751   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6752 else
6753 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6754 for as_dir in $PATH
6755 do
6756   IFS=$as_save_IFS
6757   test -z "$as_dir" && as_dir=.
6758   for ac_exec_ext in '' $ac_executable_extensions; do
6759   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6760     ac_cv_prog_DLLTOOL="${ncn_progname}"
6761     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6762     break 2
6763   fi
6764 done
6765 done
6766
6767 fi
6768 fi
6769 DLLTOOL=$ac_cv_prog_DLLTOOL
6770 if test -n "$DLLTOOL"; then
6771   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6772 echo "${ECHO_T}$DLLTOOL" >&6
6773 else
6774   echo "$as_me:$LINENO: result: no" >&5
6775 echo "${ECHO_T}no" >&6
6776 fi
6777
6778   fi
6779   test -n "$ac_cv_prog_DLLTOOL" && break
6780 done
6781
6782 if test -z "$ac_cv_prog_DLLTOOL" ; then
6783   set dummy dlltool
6784   if test $build = $host ; then
6785     DLLTOOL="$2"
6786   else
6787     DLLTOOL="${ncn_tool_prefix}$2"
6788   fi
6789 fi
6790
6791
6792
6793 if test -n "$LD"; then
6794   ac_cv_prog_LD=$LD
6795 elif test -n "$ac_cv_prog_LD"; then
6796   LD=$ac_cv_prog_LD
6797 fi
6798
6799 if test -n "$ac_cv_prog_LD"; then
6800   for ncn_progname in ld; do
6801     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6802 set dummy ${ncn_progname}; ac_word=$2
6803 echo "$as_me:$LINENO: checking for $ac_word" >&5
6804 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6805 if test "${ac_cv_prog_LD+set}" = set; then
6806   echo $ECHO_N "(cached) $ECHO_C" >&6
6807 else
6808   if test -n "$LD"; then
6809   ac_cv_prog_LD="$LD" # Let the user override the test.
6810 else
6811 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6812 for as_dir in $PATH
6813 do
6814   IFS=$as_save_IFS
6815   test -z "$as_dir" && as_dir=.
6816   for ac_exec_ext in '' $ac_executable_extensions; do
6817   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6818     ac_cv_prog_LD="${ncn_progname}"
6819     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6820     break 2
6821   fi
6822 done
6823 done
6824
6825 fi
6826 fi
6827 LD=$ac_cv_prog_LD
6828 if test -n "$LD"; then
6829   echo "$as_me:$LINENO: result: $LD" >&5
6830 echo "${ECHO_T}$LD" >&6
6831 else
6832   echo "$as_me:$LINENO: result: no" >&5
6833 echo "${ECHO_T}no" >&6
6834 fi
6835
6836   done
6837 fi
6838
6839 for ncn_progname in ld; do
6840   if test -n "$ncn_tool_prefix"; then
6841     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6842 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6843 echo "$as_me:$LINENO: checking for $ac_word" >&5
6844 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6845 if test "${ac_cv_prog_LD+set}" = set; then
6846   echo $ECHO_N "(cached) $ECHO_C" >&6
6847 else
6848   if test -n "$LD"; then
6849   ac_cv_prog_LD="$LD" # Let the user override the test.
6850 else
6851 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6852 for as_dir in $PATH
6853 do
6854   IFS=$as_save_IFS
6855   test -z "$as_dir" && as_dir=.
6856   for ac_exec_ext in '' $ac_executable_extensions; do
6857   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6858     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6859     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6860     break 2
6861   fi
6862 done
6863 done
6864
6865 fi
6866 fi
6867 LD=$ac_cv_prog_LD
6868 if test -n "$LD"; then
6869   echo "$as_me:$LINENO: result: $LD" >&5
6870 echo "${ECHO_T}$LD" >&6
6871 else
6872   echo "$as_me:$LINENO: result: no" >&5
6873 echo "${ECHO_T}no" >&6
6874 fi
6875
6876   fi
6877   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6878     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6879 set dummy ${ncn_progname}; ac_word=$2
6880 echo "$as_me:$LINENO: checking for $ac_word" >&5
6881 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6882 if test "${ac_cv_prog_LD+set}" = set; then
6883   echo $ECHO_N "(cached) $ECHO_C" >&6
6884 else
6885   if test -n "$LD"; then
6886   ac_cv_prog_LD="$LD" # Let the user override the test.
6887 else
6888 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6889 for as_dir in $PATH
6890 do
6891   IFS=$as_save_IFS
6892   test -z "$as_dir" && as_dir=.
6893   for ac_exec_ext in '' $ac_executable_extensions; do
6894   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6895     ac_cv_prog_LD="${ncn_progname}"
6896     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6897     break 2
6898   fi
6899 done
6900 done
6901
6902 fi
6903 fi
6904 LD=$ac_cv_prog_LD
6905 if test -n "$LD"; then
6906   echo "$as_me:$LINENO: result: $LD" >&5
6907 echo "${ECHO_T}$LD" >&6
6908 else
6909   echo "$as_me:$LINENO: result: no" >&5
6910 echo "${ECHO_T}no" >&6
6911 fi
6912
6913   fi
6914   test -n "$ac_cv_prog_LD" && break
6915 done
6916
6917 if test -z "$ac_cv_prog_LD" ; then
6918   set dummy ld
6919   if test $build = $host ; then
6920     LD="$2"
6921   else
6922     LD="${ncn_tool_prefix}$2"
6923   fi
6924 fi
6925
6926
6927
6928 if test -n "$LIPO"; then
6929   ac_cv_prog_LIPO=$LIPO
6930 elif test -n "$ac_cv_prog_LIPO"; then
6931   LIPO=$ac_cv_prog_LIPO
6932 fi
6933
6934 if test -n "$ac_cv_prog_LIPO"; then
6935   for ncn_progname in lipo; do
6936     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6937 set dummy ${ncn_progname}; ac_word=$2
6938 echo "$as_me:$LINENO: checking for $ac_word" >&5
6939 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6940 if test "${ac_cv_prog_LIPO+set}" = set; then
6941   echo $ECHO_N "(cached) $ECHO_C" >&6
6942 else
6943   if test -n "$LIPO"; then
6944   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6945 else
6946 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6947 for as_dir in $PATH
6948 do
6949   IFS=$as_save_IFS
6950   test -z "$as_dir" && as_dir=.
6951   for ac_exec_ext in '' $ac_executable_extensions; do
6952   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6953     ac_cv_prog_LIPO="${ncn_progname}"
6954     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6955     break 2
6956   fi
6957 done
6958 done
6959
6960 fi
6961 fi
6962 LIPO=$ac_cv_prog_LIPO
6963 if test -n "$LIPO"; then
6964   echo "$as_me:$LINENO: result: $LIPO" >&5
6965 echo "${ECHO_T}$LIPO" >&6
6966 else
6967   echo "$as_me:$LINENO: result: no" >&5
6968 echo "${ECHO_T}no" >&6
6969 fi
6970
6971   done
6972 fi
6973
6974 for ncn_progname in lipo; do
6975   if test -n "$ncn_tool_prefix"; then
6976     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6977 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6978 echo "$as_me:$LINENO: checking for $ac_word" >&5
6979 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6980 if test "${ac_cv_prog_LIPO+set}" = set; then
6981   echo $ECHO_N "(cached) $ECHO_C" >&6
6982 else
6983   if test -n "$LIPO"; then
6984   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6985 else
6986 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6987 for as_dir in $PATH
6988 do
6989   IFS=$as_save_IFS
6990   test -z "$as_dir" && as_dir=.
6991   for ac_exec_ext in '' $ac_executable_extensions; do
6992   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6993     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6994     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6995     break 2
6996   fi
6997 done
6998 done
6999
7000 fi
7001 fi
7002 LIPO=$ac_cv_prog_LIPO
7003 if test -n "$LIPO"; then
7004   echo "$as_me:$LINENO: result: $LIPO" >&5
7005 echo "${ECHO_T}$LIPO" >&6
7006 else
7007   echo "$as_me:$LINENO: result: no" >&5
7008 echo "${ECHO_T}no" >&6
7009 fi
7010
7011   fi
7012   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7013     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7014 set dummy ${ncn_progname}; ac_word=$2
7015 echo "$as_me:$LINENO: checking for $ac_word" >&5
7016 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7017 if test "${ac_cv_prog_LIPO+set}" = set; then
7018   echo $ECHO_N "(cached) $ECHO_C" >&6
7019 else
7020   if test -n "$LIPO"; then
7021   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7022 else
7023 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7024 for as_dir in $PATH
7025 do
7026   IFS=$as_save_IFS
7027   test -z "$as_dir" && as_dir=.
7028   for ac_exec_ext in '' $ac_executable_extensions; do
7029   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7030     ac_cv_prog_LIPO="${ncn_progname}"
7031     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7032     break 2
7033   fi
7034 done
7035 done
7036
7037 fi
7038 fi
7039 LIPO=$ac_cv_prog_LIPO
7040 if test -n "$LIPO"; then
7041   echo "$as_me:$LINENO: result: $LIPO" >&5
7042 echo "${ECHO_T}$LIPO" >&6
7043 else
7044   echo "$as_me:$LINENO: result: no" >&5
7045 echo "${ECHO_T}no" >&6
7046 fi
7047
7048   fi
7049   test -n "$ac_cv_prog_LIPO" && break
7050 done
7051
7052 if test -z "$ac_cv_prog_LIPO" ; then
7053   set dummy lipo
7054   if test $build = $host ; then
7055     LIPO="$2"
7056   else
7057     LIPO="${ncn_tool_prefix}$2"
7058   fi
7059 fi
7060
7061
7062
7063 if test -n "$NM"; then
7064   ac_cv_prog_NM=$NM
7065 elif test -n "$ac_cv_prog_NM"; then
7066   NM=$ac_cv_prog_NM
7067 fi
7068
7069 if test -n "$ac_cv_prog_NM"; then
7070   for ncn_progname in nm; do
7071     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7072 set dummy ${ncn_progname}; ac_word=$2
7073 echo "$as_me:$LINENO: checking for $ac_word" >&5
7074 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7075 if test "${ac_cv_prog_NM+set}" = set; then
7076   echo $ECHO_N "(cached) $ECHO_C" >&6
7077 else
7078   if test -n "$NM"; then
7079   ac_cv_prog_NM="$NM" # Let the user override the test.
7080 else
7081 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7082 for as_dir in $PATH
7083 do
7084   IFS=$as_save_IFS
7085   test -z "$as_dir" && as_dir=.
7086   for ac_exec_ext in '' $ac_executable_extensions; do
7087   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7088     ac_cv_prog_NM="${ncn_progname}"
7089     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7090     break 2
7091   fi
7092 done
7093 done
7094
7095 fi
7096 fi
7097 NM=$ac_cv_prog_NM
7098 if test -n "$NM"; then
7099   echo "$as_me:$LINENO: result: $NM" >&5
7100 echo "${ECHO_T}$NM" >&6
7101 else
7102   echo "$as_me:$LINENO: result: no" >&5
7103 echo "${ECHO_T}no" >&6
7104 fi
7105
7106   done
7107 fi
7108
7109 for ncn_progname in nm; do
7110   if test -n "$ncn_tool_prefix"; then
7111     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7112 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7113 echo "$as_me:$LINENO: checking for $ac_word" >&5
7114 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7115 if test "${ac_cv_prog_NM+set}" = set; then
7116   echo $ECHO_N "(cached) $ECHO_C" >&6
7117 else
7118   if test -n "$NM"; then
7119   ac_cv_prog_NM="$NM" # Let the user override the test.
7120 else
7121 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7122 for as_dir in $PATH
7123 do
7124   IFS=$as_save_IFS
7125   test -z "$as_dir" && as_dir=.
7126   for ac_exec_ext in '' $ac_executable_extensions; do
7127   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7128     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7129     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7130     break 2
7131   fi
7132 done
7133 done
7134
7135 fi
7136 fi
7137 NM=$ac_cv_prog_NM
7138 if test -n "$NM"; then
7139   echo "$as_me:$LINENO: result: $NM" >&5
7140 echo "${ECHO_T}$NM" >&6
7141 else
7142   echo "$as_me:$LINENO: result: no" >&5
7143 echo "${ECHO_T}no" >&6
7144 fi
7145
7146   fi
7147   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7148     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7149 set dummy ${ncn_progname}; ac_word=$2
7150 echo "$as_me:$LINENO: checking for $ac_word" >&5
7151 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7152 if test "${ac_cv_prog_NM+set}" = set; then
7153   echo $ECHO_N "(cached) $ECHO_C" >&6
7154 else
7155   if test -n "$NM"; then
7156   ac_cv_prog_NM="$NM" # Let the user override the test.
7157 else
7158 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7159 for as_dir in $PATH
7160 do
7161   IFS=$as_save_IFS
7162   test -z "$as_dir" && as_dir=.
7163   for ac_exec_ext in '' $ac_executable_extensions; do
7164   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7165     ac_cv_prog_NM="${ncn_progname}"
7166     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7167     break 2
7168   fi
7169 done
7170 done
7171
7172 fi
7173 fi
7174 NM=$ac_cv_prog_NM
7175 if test -n "$NM"; then
7176   echo "$as_me:$LINENO: result: $NM" >&5
7177 echo "${ECHO_T}$NM" >&6
7178 else
7179   echo "$as_me:$LINENO: result: no" >&5
7180 echo "${ECHO_T}no" >&6
7181 fi
7182
7183   fi
7184   test -n "$ac_cv_prog_NM" && break
7185 done
7186
7187 if test -z "$ac_cv_prog_NM" ; then
7188   set dummy nm
7189   if test $build = $host ; then
7190     NM="$2"
7191   else
7192     NM="${ncn_tool_prefix}$2"
7193   fi
7194 fi
7195
7196
7197
7198 if test -n "$RANLIB"; then
7199   ac_cv_prog_RANLIB=$RANLIB
7200 elif test -n "$ac_cv_prog_RANLIB"; then
7201   RANLIB=$ac_cv_prog_RANLIB
7202 fi
7203
7204 if test -n "$ac_cv_prog_RANLIB"; then
7205   for ncn_progname in ranlib; do
7206     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7207 set dummy ${ncn_progname}; ac_word=$2
7208 echo "$as_me:$LINENO: checking for $ac_word" >&5
7209 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7210 if test "${ac_cv_prog_RANLIB+set}" = set; then
7211   echo $ECHO_N "(cached) $ECHO_C" >&6
7212 else
7213   if test -n "$RANLIB"; then
7214   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7215 else
7216 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7217 for as_dir in $PATH
7218 do
7219   IFS=$as_save_IFS
7220   test -z "$as_dir" && as_dir=.
7221   for ac_exec_ext in '' $ac_executable_extensions; do
7222   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7223     ac_cv_prog_RANLIB="${ncn_progname}"
7224     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7225     break 2
7226   fi
7227 done
7228 done
7229
7230 fi
7231 fi
7232 RANLIB=$ac_cv_prog_RANLIB
7233 if test -n "$RANLIB"; then
7234   echo "$as_me:$LINENO: result: $RANLIB" >&5
7235 echo "${ECHO_T}$RANLIB" >&6
7236 else
7237   echo "$as_me:$LINENO: result: no" >&5
7238 echo "${ECHO_T}no" >&6
7239 fi
7240
7241   done
7242 fi
7243
7244 for ncn_progname in ranlib; do
7245   if test -n "$ncn_tool_prefix"; then
7246     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7247 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7248 echo "$as_me:$LINENO: checking for $ac_word" >&5
7249 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7250 if test "${ac_cv_prog_RANLIB+set}" = set; then
7251   echo $ECHO_N "(cached) $ECHO_C" >&6
7252 else
7253   if test -n "$RANLIB"; then
7254   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7255 else
7256 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7257 for as_dir in $PATH
7258 do
7259   IFS=$as_save_IFS
7260   test -z "$as_dir" && as_dir=.
7261   for ac_exec_ext in '' $ac_executable_extensions; do
7262   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7263     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7264     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7265     break 2
7266   fi
7267 done
7268 done
7269
7270 fi
7271 fi
7272 RANLIB=$ac_cv_prog_RANLIB
7273 if test -n "$RANLIB"; then
7274   echo "$as_me:$LINENO: result: $RANLIB" >&5
7275 echo "${ECHO_T}$RANLIB" >&6
7276 else
7277   echo "$as_me:$LINENO: result: no" >&5
7278 echo "${ECHO_T}no" >&6
7279 fi
7280
7281   fi
7282   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7283     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7284 set dummy ${ncn_progname}; ac_word=$2
7285 echo "$as_me:$LINENO: checking for $ac_word" >&5
7286 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7287 if test "${ac_cv_prog_RANLIB+set}" = set; then
7288   echo $ECHO_N "(cached) $ECHO_C" >&6
7289 else
7290   if test -n "$RANLIB"; then
7291   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7292 else
7293 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7294 for as_dir in $PATH
7295 do
7296   IFS=$as_save_IFS
7297   test -z "$as_dir" && as_dir=.
7298   for ac_exec_ext in '' $ac_executable_extensions; do
7299   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7300     ac_cv_prog_RANLIB="${ncn_progname}"
7301     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7302     break 2
7303   fi
7304 done
7305 done
7306
7307 fi
7308 fi
7309 RANLIB=$ac_cv_prog_RANLIB
7310 if test -n "$RANLIB"; then
7311   echo "$as_me:$LINENO: result: $RANLIB" >&5
7312 echo "${ECHO_T}$RANLIB" >&6
7313 else
7314   echo "$as_me:$LINENO: result: no" >&5
7315 echo "${ECHO_T}no" >&6
7316 fi
7317
7318   fi
7319   test -n "$ac_cv_prog_RANLIB" && break
7320 done
7321
7322 if test -z "$ac_cv_prog_RANLIB" ; then
7323   RANLIB=":"
7324 fi
7325
7326
7327
7328 if test -n "$STRIP"; then
7329   ac_cv_prog_STRIP=$STRIP
7330 elif test -n "$ac_cv_prog_STRIP"; then
7331   STRIP=$ac_cv_prog_STRIP
7332 fi
7333
7334 if test -n "$ac_cv_prog_STRIP"; then
7335   for ncn_progname in strip; do
7336     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7337 set dummy ${ncn_progname}; ac_word=$2
7338 echo "$as_me:$LINENO: checking for $ac_word" >&5
7339 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7340 if test "${ac_cv_prog_STRIP+set}" = set; then
7341   echo $ECHO_N "(cached) $ECHO_C" >&6
7342 else
7343   if test -n "$STRIP"; then
7344   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7345 else
7346 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7347 for as_dir in $PATH
7348 do
7349   IFS=$as_save_IFS
7350   test -z "$as_dir" && as_dir=.
7351   for ac_exec_ext in '' $ac_executable_extensions; do
7352   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7353     ac_cv_prog_STRIP="${ncn_progname}"
7354     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7355     break 2
7356   fi
7357 done
7358 done
7359
7360 fi
7361 fi
7362 STRIP=$ac_cv_prog_STRIP
7363 if test -n "$STRIP"; then
7364   echo "$as_me:$LINENO: result: $STRIP" >&5
7365 echo "${ECHO_T}$STRIP" >&6
7366 else
7367   echo "$as_me:$LINENO: result: no" >&5
7368 echo "${ECHO_T}no" >&6
7369 fi
7370
7371   done
7372 fi
7373
7374 for ncn_progname in strip; do
7375   if test -n "$ncn_tool_prefix"; then
7376     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7377 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7378 echo "$as_me:$LINENO: checking for $ac_word" >&5
7379 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7380 if test "${ac_cv_prog_STRIP+set}" = set; then
7381   echo $ECHO_N "(cached) $ECHO_C" >&6
7382 else
7383   if test -n "$STRIP"; then
7384   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7385 else
7386 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7387 for as_dir in $PATH
7388 do
7389   IFS=$as_save_IFS
7390   test -z "$as_dir" && as_dir=.
7391   for ac_exec_ext in '' $ac_executable_extensions; do
7392   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7393     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7394     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7395     break 2
7396   fi
7397 done
7398 done
7399
7400 fi
7401 fi
7402 STRIP=$ac_cv_prog_STRIP
7403 if test -n "$STRIP"; then
7404   echo "$as_me:$LINENO: result: $STRIP" >&5
7405 echo "${ECHO_T}$STRIP" >&6
7406 else
7407   echo "$as_me:$LINENO: result: no" >&5
7408 echo "${ECHO_T}no" >&6
7409 fi
7410
7411   fi
7412   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7413     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7414 set dummy ${ncn_progname}; ac_word=$2
7415 echo "$as_me:$LINENO: checking for $ac_word" >&5
7416 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7417 if test "${ac_cv_prog_STRIP+set}" = set; then
7418   echo $ECHO_N "(cached) $ECHO_C" >&6
7419 else
7420   if test -n "$STRIP"; then
7421   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7422 else
7423 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7424 for as_dir in $PATH
7425 do
7426   IFS=$as_save_IFS
7427   test -z "$as_dir" && as_dir=.
7428   for ac_exec_ext in '' $ac_executable_extensions; do
7429   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7430     ac_cv_prog_STRIP="${ncn_progname}"
7431     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7432     break 2
7433   fi
7434 done
7435 done
7436
7437 fi
7438 fi
7439 STRIP=$ac_cv_prog_STRIP
7440 if test -n "$STRIP"; then
7441   echo "$as_me:$LINENO: result: $STRIP" >&5
7442 echo "${ECHO_T}$STRIP" >&6
7443 else
7444   echo "$as_me:$LINENO: result: no" >&5
7445 echo "${ECHO_T}no" >&6
7446 fi
7447
7448   fi
7449   test -n "$ac_cv_prog_STRIP" && break
7450 done
7451
7452 if test -z "$ac_cv_prog_STRIP" ; then
7453   STRIP=":"
7454 fi
7455
7456
7457
7458 if test -n "$WINDRES"; then
7459   ac_cv_prog_WINDRES=$WINDRES
7460 elif test -n "$ac_cv_prog_WINDRES"; then
7461   WINDRES=$ac_cv_prog_WINDRES
7462 fi
7463
7464 if test -n "$ac_cv_prog_WINDRES"; then
7465   for ncn_progname in windres; do
7466     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7467 set dummy ${ncn_progname}; ac_word=$2
7468 echo "$as_me:$LINENO: checking for $ac_word" >&5
7469 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7470 if test "${ac_cv_prog_WINDRES+set}" = set; then
7471   echo $ECHO_N "(cached) $ECHO_C" >&6
7472 else
7473   if test -n "$WINDRES"; then
7474   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7475 else
7476 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7477 for as_dir in $PATH
7478 do
7479   IFS=$as_save_IFS
7480   test -z "$as_dir" && as_dir=.
7481   for ac_exec_ext in '' $ac_executable_extensions; do
7482   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7483     ac_cv_prog_WINDRES="${ncn_progname}"
7484     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7485     break 2
7486   fi
7487 done
7488 done
7489
7490 fi
7491 fi
7492 WINDRES=$ac_cv_prog_WINDRES
7493 if test -n "$WINDRES"; then
7494   echo "$as_me:$LINENO: result: $WINDRES" >&5
7495 echo "${ECHO_T}$WINDRES" >&6
7496 else
7497   echo "$as_me:$LINENO: result: no" >&5
7498 echo "${ECHO_T}no" >&6
7499 fi
7500
7501   done
7502 fi
7503
7504 for ncn_progname in windres; do
7505   if test -n "$ncn_tool_prefix"; then
7506     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7507 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7508 echo "$as_me:$LINENO: checking for $ac_word" >&5
7509 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7510 if test "${ac_cv_prog_WINDRES+set}" = set; then
7511   echo $ECHO_N "(cached) $ECHO_C" >&6
7512 else
7513   if test -n "$WINDRES"; then
7514   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7515 else
7516 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7517 for as_dir in $PATH
7518 do
7519   IFS=$as_save_IFS
7520   test -z "$as_dir" && as_dir=.
7521   for ac_exec_ext in '' $ac_executable_extensions; do
7522   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7523     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7524     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7525     break 2
7526   fi
7527 done
7528 done
7529
7530 fi
7531 fi
7532 WINDRES=$ac_cv_prog_WINDRES
7533 if test -n "$WINDRES"; then
7534   echo "$as_me:$LINENO: result: $WINDRES" >&5
7535 echo "${ECHO_T}$WINDRES" >&6
7536 else
7537   echo "$as_me:$LINENO: result: no" >&5
7538 echo "${ECHO_T}no" >&6
7539 fi
7540
7541   fi
7542   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7543     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7544 set dummy ${ncn_progname}; ac_word=$2
7545 echo "$as_me:$LINENO: checking for $ac_word" >&5
7546 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7547 if test "${ac_cv_prog_WINDRES+set}" = set; then
7548   echo $ECHO_N "(cached) $ECHO_C" >&6
7549 else
7550   if test -n "$WINDRES"; then
7551   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7552 else
7553 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7554 for as_dir in $PATH
7555 do
7556   IFS=$as_save_IFS
7557   test -z "$as_dir" && as_dir=.
7558   for ac_exec_ext in '' $ac_executable_extensions; do
7559   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7560     ac_cv_prog_WINDRES="${ncn_progname}"
7561     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7562     break 2
7563   fi
7564 done
7565 done
7566
7567 fi
7568 fi
7569 WINDRES=$ac_cv_prog_WINDRES
7570 if test -n "$WINDRES"; then
7571   echo "$as_me:$LINENO: result: $WINDRES" >&5
7572 echo "${ECHO_T}$WINDRES" >&6
7573 else
7574   echo "$as_me:$LINENO: result: no" >&5
7575 echo "${ECHO_T}no" >&6
7576 fi
7577
7578   fi
7579   test -n "$ac_cv_prog_WINDRES" && break
7580 done
7581
7582 if test -z "$ac_cv_prog_WINDRES" ; then
7583   set dummy windres
7584   if test $build = $host ; then
7585     WINDRES="$2"
7586   else
7587     WINDRES="${ncn_tool_prefix}$2"
7588   fi
7589 fi
7590
7591
7592
7593 if test -n "$WINDMC"; then
7594   ac_cv_prog_WINDMC=$WINDMC
7595 elif test -n "$ac_cv_prog_WINDMC"; then
7596   WINDMC=$ac_cv_prog_WINDMC
7597 fi
7598
7599 if test -n "$ac_cv_prog_WINDMC"; then
7600   for ncn_progname in windmc; do
7601     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7602 set dummy ${ncn_progname}; ac_word=$2
7603 echo "$as_me:$LINENO: checking for $ac_word" >&5
7604 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7605 if test "${ac_cv_prog_WINDMC+set}" = set; then
7606   echo $ECHO_N "(cached) $ECHO_C" >&6
7607 else
7608   if test -n "$WINDMC"; then
7609   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7610 else
7611 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7612 for as_dir in $PATH
7613 do
7614   IFS=$as_save_IFS
7615   test -z "$as_dir" && as_dir=.
7616   for ac_exec_ext in '' $ac_executable_extensions; do
7617   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7618     ac_cv_prog_WINDMC="${ncn_progname}"
7619     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7620     break 2
7621   fi
7622 done
7623 done
7624
7625 fi
7626 fi
7627 WINDMC=$ac_cv_prog_WINDMC
7628 if test -n "$WINDMC"; then
7629   echo "$as_me:$LINENO: result: $WINDMC" >&5
7630 echo "${ECHO_T}$WINDMC" >&6
7631 else
7632   echo "$as_me:$LINENO: result: no" >&5
7633 echo "${ECHO_T}no" >&6
7634 fi
7635
7636   done
7637 fi
7638
7639 for ncn_progname in windmc; do
7640   if test -n "$ncn_tool_prefix"; then
7641     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7642 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7643 echo "$as_me:$LINENO: checking for $ac_word" >&5
7644 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7645 if test "${ac_cv_prog_WINDMC+set}" = set; then
7646   echo $ECHO_N "(cached) $ECHO_C" >&6
7647 else
7648   if test -n "$WINDMC"; then
7649   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7650 else
7651 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7652 for as_dir in $PATH
7653 do
7654   IFS=$as_save_IFS
7655   test -z "$as_dir" && as_dir=.
7656   for ac_exec_ext in '' $ac_executable_extensions; do
7657   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7658     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7659     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7660     break 2
7661   fi
7662 done
7663 done
7664
7665 fi
7666 fi
7667 WINDMC=$ac_cv_prog_WINDMC
7668 if test -n "$WINDMC"; then
7669   echo "$as_me:$LINENO: result: $WINDMC" >&5
7670 echo "${ECHO_T}$WINDMC" >&6
7671 else
7672   echo "$as_me:$LINENO: result: no" >&5
7673 echo "${ECHO_T}no" >&6
7674 fi
7675
7676   fi
7677   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7678     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7679 set dummy ${ncn_progname}; ac_word=$2
7680 echo "$as_me:$LINENO: checking for $ac_word" >&5
7681 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7682 if test "${ac_cv_prog_WINDMC+set}" = set; then
7683   echo $ECHO_N "(cached) $ECHO_C" >&6
7684 else
7685   if test -n "$WINDMC"; then
7686   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7687 else
7688 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7689 for as_dir in $PATH
7690 do
7691   IFS=$as_save_IFS
7692   test -z "$as_dir" && as_dir=.
7693   for ac_exec_ext in '' $ac_executable_extensions; do
7694   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7695     ac_cv_prog_WINDMC="${ncn_progname}"
7696     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7697     break 2
7698   fi
7699 done
7700 done
7701
7702 fi
7703 fi
7704 WINDMC=$ac_cv_prog_WINDMC
7705 if test -n "$WINDMC"; then
7706   echo "$as_me:$LINENO: result: $WINDMC" >&5
7707 echo "${ECHO_T}$WINDMC" >&6
7708 else
7709   echo "$as_me:$LINENO: result: no" >&5
7710 echo "${ECHO_T}no" >&6
7711 fi
7712
7713   fi
7714   test -n "$ac_cv_prog_WINDMC" && break
7715 done
7716
7717 if test -z "$ac_cv_prog_WINDMC" ; then
7718   set dummy windmc
7719   if test $build = $host ; then
7720     WINDMC="$2"
7721   else
7722     WINDMC="${ncn_tool_prefix}$2"
7723   fi
7724 fi
7725
7726
7727
7728 if test -n "$OBJCOPY"; then
7729   ac_cv_prog_OBJCOPY=$OBJCOPY
7730 elif test -n "$ac_cv_prog_OBJCOPY"; then
7731   OBJCOPY=$ac_cv_prog_OBJCOPY
7732 fi
7733
7734 if test -n "$ac_cv_prog_OBJCOPY"; then
7735   for ncn_progname in objcopy; do
7736     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7737 set dummy ${ncn_progname}; ac_word=$2
7738 echo "$as_me:$LINENO: checking for $ac_word" >&5
7739 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7740 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7741   echo $ECHO_N "(cached) $ECHO_C" >&6
7742 else
7743   if test -n "$OBJCOPY"; then
7744   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7745 else
7746 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7747 for as_dir in $PATH
7748 do
7749   IFS=$as_save_IFS
7750   test -z "$as_dir" && as_dir=.
7751   for ac_exec_ext in '' $ac_executable_extensions; do
7752   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7753     ac_cv_prog_OBJCOPY="${ncn_progname}"
7754     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7755     break 2
7756   fi
7757 done
7758 done
7759
7760 fi
7761 fi
7762 OBJCOPY=$ac_cv_prog_OBJCOPY
7763 if test -n "$OBJCOPY"; then
7764   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7765 echo "${ECHO_T}$OBJCOPY" >&6
7766 else
7767   echo "$as_me:$LINENO: result: no" >&5
7768 echo "${ECHO_T}no" >&6
7769 fi
7770
7771   done
7772 fi
7773
7774 for ncn_progname in objcopy; do
7775   if test -n "$ncn_tool_prefix"; then
7776     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7777 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7778 echo "$as_me:$LINENO: checking for $ac_word" >&5
7779 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7780 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7781   echo $ECHO_N "(cached) $ECHO_C" >&6
7782 else
7783   if test -n "$OBJCOPY"; then
7784   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7785 else
7786 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7787 for as_dir in $PATH
7788 do
7789   IFS=$as_save_IFS
7790   test -z "$as_dir" && as_dir=.
7791   for ac_exec_ext in '' $ac_executable_extensions; do
7792   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7793     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7794     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7795     break 2
7796   fi
7797 done
7798 done
7799
7800 fi
7801 fi
7802 OBJCOPY=$ac_cv_prog_OBJCOPY
7803 if test -n "$OBJCOPY"; then
7804   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7805 echo "${ECHO_T}$OBJCOPY" >&6
7806 else
7807   echo "$as_me:$LINENO: result: no" >&5
7808 echo "${ECHO_T}no" >&6
7809 fi
7810
7811   fi
7812   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7813     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7814 set dummy ${ncn_progname}; ac_word=$2
7815 echo "$as_me:$LINENO: checking for $ac_word" >&5
7816 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7817 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7818   echo $ECHO_N "(cached) $ECHO_C" >&6
7819 else
7820   if test -n "$OBJCOPY"; then
7821   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7822 else
7823 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7824 for as_dir in $PATH
7825 do
7826   IFS=$as_save_IFS
7827   test -z "$as_dir" && as_dir=.
7828   for ac_exec_ext in '' $ac_executable_extensions; do
7829   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7830     ac_cv_prog_OBJCOPY="${ncn_progname}"
7831     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7832     break 2
7833   fi
7834 done
7835 done
7836
7837 fi
7838 fi
7839 OBJCOPY=$ac_cv_prog_OBJCOPY
7840 if test -n "$OBJCOPY"; then
7841   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7842 echo "${ECHO_T}$OBJCOPY" >&6
7843 else
7844   echo "$as_me:$LINENO: result: no" >&5
7845 echo "${ECHO_T}no" >&6
7846 fi
7847
7848   fi
7849   test -n "$ac_cv_prog_OBJCOPY" && break
7850 done
7851
7852 if test -z "$ac_cv_prog_OBJCOPY" ; then
7853   set dummy objcopy
7854   if test $build = $host ; then
7855     OBJCOPY="$2"
7856   else
7857     OBJCOPY="${ncn_tool_prefix}$2"
7858   fi
7859 fi
7860
7861
7862
7863 if test -n "$OBJDUMP"; then
7864   ac_cv_prog_OBJDUMP=$OBJDUMP
7865 elif test -n "$ac_cv_prog_OBJDUMP"; then
7866   OBJDUMP=$ac_cv_prog_OBJDUMP
7867 fi
7868
7869 if test -n "$ac_cv_prog_OBJDUMP"; then
7870   for ncn_progname in objdump; do
7871     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7872 set dummy ${ncn_progname}; ac_word=$2
7873 echo "$as_me:$LINENO: checking for $ac_word" >&5
7874 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7875 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7876   echo $ECHO_N "(cached) $ECHO_C" >&6
7877 else
7878   if test -n "$OBJDUMP"; then
7879   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7880 else
7881 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7882 for as_dir in $PATH
7883 do
7884   IFS=$as_save_IFS
7885   test -z "$as_dir" && as_dir=.
7886   for ac_exec_ext in '' $ac_executable_extensions; do
7887   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7888     ac_cv_prog_OBJDUMP="${ncn_progname}"
7889     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7890     break 2
7891   fi
7892 done
7893 done
7894
7895 fi
7896 fi
7897 OBJDUMP=$ac_cv_prog_OBJDUMP
7898 if test -n "$OBJDUMP"; then
7899   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7900 echo "${ECHO_T}$OBJDUMP" >&6
7901 else
7902   echo "$as_me:$LINENO: result: no" >&5
7903 echo "${ECHO_T}no" >&6
7904 fi
7905
7906   done
7907 fi
7908
7909 for ncn_progname in objdump; do
7910   if test -n "$ncn_tool_prefix"; then
7911     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7912 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7913 echo "$as_me:$LINENO: checking for $ac_word" >&5
7914 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7915 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7916   echo $ECHO_N "(cached) $ECHO_C" >&6
7917 else
7918   if test -n "$OBJDUMP"; then
7919   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7920 else
7921 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7922 for as_dir in $PATH
7923 do
7924   IFS=$as_save_IFS
7925   test -z "$as_dir" && as_dir=.
7926   for ac_exec_ext in '' $ac_executable_extensions; do
7927   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7928     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7929     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7930     break 2
7931   fi
7932 done
7933 done
7934
7935 fi
7936 fi
7937 OBJDUMP=$ac_cv_prog_OBJDUMP
7938 if test -n "$OBJDUMP"; then
7939   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7940 echo "${ECHO_T}$OBJDUMP" >&6
7941 else
7942   echo "$as_me:$LINENO: result: no" >&5
7943 echo "${ECHO_T}no" >&6
7944 fi
7945
7946   fi
7947   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7948     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7949 set dummy ${ncn_progname}; ac_word=$2
7950 echo "$as_me:$LINENO: checking for $ac_word" >&5
7951 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7952 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7953   echo $ECHO_N "(cached) $ECHO_C" >&6
7954 else
7955   if test -n "$OBJDUMP"; then
7956   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7957 else
7958 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7959 for as_dir in $PATH
7960 do
7961   IFS=$as_save_IFS
7962   test -z "$as_dir" && as_dir=.
7963   for ac_exec_ext in '' $ac_executable_extensions; do
7964   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7965     ac_cv_prog_OBJDUMP="${ncn_progname}"
7966     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7967     break 2
7968   fi
7969 done
7970 done
7971
7972 fi
7973 fi
7974 OBJDUMP=$ac_cv_prog_OBJDUMP
7975 if test -n "$OBJDUMP"; then
7976   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7977 echo "${ECHO_T}$OBJDUMP" >&6
7978 else
7979   echo "$as_me:$LINENO: result: no" >&5
7980 echo "${ECHO_T}no" >&6
7981 fi
7982
7983   fi
7984   test -n "$ac_cv_prog_OBJDUMP" && break
7985 done
7986
7987 if test -z "$ac_cv_prog_OBJDUMP" ; then
7988   set dummy objdump
7989   if test $build = $host ; then
7990     OBJDUMP="$2"
7991   else
7992     OBJDUMP="${ncn_tool_prefix}$2"
7993   fi
7994 fi
7995
7996
7997
7998
7999
8000
8001 # Target tools.
8002
8003 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8004 if test "${with_build_time_tools+set}" = set; then
8005   withval="$with_build_time_tools"
8006   case x"$withval" in
8007      x/*) ;;
8008      *)
8009        with_build_time_tools=
8010        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8011 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8012        ;;
8013    esac
8014 else
8015   with_build_time_tools=
8016 fi;
8017
8018
8019
8020 if test -n "$CC_FOR_TARGET"; then
8021   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8022 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8023   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8024 fi
8025
8026 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8027   for ncn_progname in cc gcc; do
8028     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8029 set dummy ${ncn_progname}; ac_word=$2
8030 echo "$as_me:$LINENO: checking for $ac_word" >&5
8031 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8032 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8033   echo $ECHO_N "(cached) $ECHO_C" >&6
8034 else
8035   if test -n "$CC_FOR_TARGET"; then
8036   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8037 else
8038 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8039 for as_dir in $PATH
8040 do
8041   IFS=$as_save_IFS
8042   test -z "$as_dir" && as_dir=.
8043   for ac_exec_ext in '' $ac_executable_extensions; do
8044   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8045     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8046     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8047     break 2
8048   fi
8049 done
8050 done
8051
8052 fi
8053 fi
8054 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8055 if test -n "$CC_FOR_TARGET"; then
8056   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8057 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8058 else
8059   echo "$as_me:$LINENO: result: no" >&5
8060 echo "${ECHO_T}no" >&6
8061 fi
8062
8063   done
8064 fi
8065
8066 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8067   for ncn_progname in cc gcc; do
8068     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8069 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8070     if test -x $with_build_time_tools/${ncn_progname}; then
8071       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8072       echo "$as_me:$LINENO: result: yes" >&5
8073 echo "${ECHO_T}yes" >&6
8074       break
8075     else
8076       echo "$as_me:$LINENO: result: no" >&5
8077 echo "${ECHO_T}no" >&6
8078     fi
8079   done
8080 fi
8081
8082 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8083   for ncn_progname in cc gcc; do
8084     if test -n "$ncn_target_tool_prefix"; then
8085       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8086 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8087 echo "$as_me:$LINENO: checking for $ac_word" >&5
8088 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8089 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8090   echo $ECHO_N "(cached) $ECHO_C" >&6
8091 else
8092   if test -n "$CC_FOR_TARGET"; then
8093   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8094 else
8095 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8096 for as_dir in $PATH
8097 do
8098   IFS=$as_save_IFS
8099   test -z "$as_dir" && as_dir=.
8100   for ac_exec_ext in '' $ac_executable_extensions; do
8101   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8102     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8103     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8104     break 2
8105   fi
8106 done
8107 done
8108
8109 fi
8110 fi
8111 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8112 if test -n "$CC_FOR_TARGET"; then
8113   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8114 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8115 else
8116   echo "$as_me:$LINENO: result: no" >&5
8117 echo "${ECHO_T}no" >&6
8118 fi
8119
8120     fi
8121     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8122       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8123 set dummy ${ncn_progname}; ac_word=$2
8124 echo "$as_me:$LINENO: checking for $ac_word" >&5
8125 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8126 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8127   echo $ECHO_N "(cached) $ECHO_C" >&6
8128 else
8129   if test -n "$CC_FOR_TARGET"; then
8130   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8131 else
8132 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8133 for as_dir in $PATH
8134 do
8135   IFS=$as_save_IFS
8136   test -z "$as_dir" && as_dir=.
8137   for ac_exec_ext in '' $ac_executable_extensions; do
8138   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8139     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8140     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8141     break 2
8142   fi
8143 done
8144 done
8145
8146 fi
8147 fi
8148 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8149 if test -n "$CC_FOR_TARGET"; then
8150   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8151 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8152 else
8153   echo "$as_me:$LINENO: result: no" >&5
8154 echo "${ECHO_T}no" >&6
8155 fi
8156
8157     fi
8158     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8159   done
8160 fi
8161
8162 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8163   set dummy cc gcc
8164   if test $build = $target ; then
8165     CC_FOR_TARGET="$2"
8166   else
8167     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8168   fi
8169 else
8170   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8171 fi
8172
8173
8174
8175 if test -n "$CXX_FOR_TARGET"; then
8176   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8177 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8178   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8179 fi
8180
8181 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8182   for ncn_progname in c++ g++ cxx gxx; do
8183     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8184 set dummy ${ncn_progname}; ac_word=$2
8185 echo "$as_me:$LINENO: checking for $ac_word" >&5
8186 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8187 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8188   echo $ECHO_N "(cached) $ECHO_C" >&6
8189 else
8190   if test -n "$CXX_FOR_TARGET"; then
8191   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8192 else
8193 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8194 for as_dir in $PATH
8195 do
8196   IFS=$as_save_IFS
8197   test -z "$as_dir" && as_dir=.
8198   for ac_exec_ext in '' $ac_executable_extensions; do
8199   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8200     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8201     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8202     break 2
8203   fi
8204 done
8205 done
8206
8207 fi
8208 fi
8209 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8210 if test -n "$CXX_FOR_TARGET"; then
8211   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8212 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8213 else
8214   echo "$as_me:$LINENO: result: no" >&5
8215 echo "${ECHO_T}no" >&6
8216 fi
8217
8218   done
8219 fi
8220
8221 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8222   for ncn_progname in c++ g++ cxx gxx; do
8223     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8224 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8225     if test -x $with_build_time_tools/${ncn_progname}; then
8226       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8227       echo "$as_me:$LINENO: result: yes" >&5
8228 echo "${ECHO_T}yes" >&6
8229       break
8230     else
8231       echo "$as_me:$LINENO: result: no" >&5
8232 echo "${ECHO_T}no" >&6
8233     fi
8234   done
8235 fi
8236
8237 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8238   for ncn_progname in c++ g++ cxx gxx; do
8239     if test -n "$ncn_target_tool_prefix"; then
8240       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8241 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8242 echo "$as_me:$LINENO: checking for $ac_word" >&5
8243 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8244 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8245   echo $ECHO_N "(cached) $ECHO_C" >&6
8246 else
8247   if test -n "$CXX_FOR_TARGET"; then
8248   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8249 else
8250 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8251 for as_dir in $PATH
8252 do
8253   IFS=$as_save_IFS
8254   test -z "$as_dir" && as_dir=.
8255   for ac_exec_ext in '' $ac_executable_extensions; do
8256   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8257     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8258     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8259     break 2
8260   fi
8261 done
8262 done
8263
8264 fi
8265 fi
8266 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8267 if test -n "$CXX_FOR_TARGET"; then
8268   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8269 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8270 else
8271   echo "$as_me:$LINENO: result: no" >&5
8272 echo "${ECHO_T}no" >&6
8273 fi
8274
8275     fi
8276     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8277       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8278 set dummy ${ncn_progname}; ac_word=$2
8279 echo "$as_me:$LINENO: checking for $ac_word" >&5
8280 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8281 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8282   echo $ECHO_N "(cached) $ECHO_C" >&6
8283 else
8284   if test -n "$CXX_FOR_TARGET"; then
8285   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8286 else
8287 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8288 for as_dir in $PATH
8289 do
8290   IFS=$as_save_IFS
8291   test -z "$as_dir" && as_dir=.
8292   for ac_exec_ext in '' $ac_executable_extensions; do
8293   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8294     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8295     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8296     break 2
8297   fi
8298 done
8299 done
8300
8301 fi
8302 fi
8303 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8304 if test -n "$CXX_FOR_TARGET"; then
8305   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8306 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8307 else
8308   echo "$as_me:$LINENO: result: no" >&5
8309 echo "${ECHO_T}no" >&6
8310 fi
8311
8312     fi
8313     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8314   done
8315 fi
8316
8317 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8318   set dummy c++ g++ cxx gxx
8319   if test $build = $target ; then
8320     CXX_FOR_TARGET="$2"
8321   else
8322     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8323   fi
8324 else
8325   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8326 fi
8327
8328
8329
8330 if test -n "$GCC_FOR_TARGET"; then
8331   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8332 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8333   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8334 fi
8335
8336 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8337   for ncn_progname in gcc; do
8338     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8339 set dummy ${ncn_progname}; ac_word=$2
8340 echo "$as_me:$LINENO: checking for $ac_word" >&5
8341 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8342 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8343   echo $ECHO_N "(cached) $ECHO_C" >&6
8344 else
8345   if test -n "$GCC_FOR_TARGET"; then
8346   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8347 else
8348 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8349 for as_dir in $PATH
8350 do
8351   IFS=$as_save_IFS
8352   test -z "$as_dir" && as_dir=.
8353   for ac_exec_ext in '' $ac_executable_extensions; do
8354   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8355     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8356     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8357     break 2
8358   fi
8359 done
8360 done
8361
8362 fi
8363 fi
8364 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8365 if test -n "$GCC_FOR_TARGET"; then
8366   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8367 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8368 else
8369   echo "$as_me:$LINENO: result: no" >&5
8370 echo "${ECHO_T}no" >&6
8371 fi
8372
8373   done
8374 fi
8375
8376 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8377   for ncn_progname in gcc; do
8378     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8379 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8380     if test -x $with_build_time_tools/${ncn_progname}; then
8381       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8382       echo "$as_me:$LINENO: result: yes" >&5
8383 echo "${ECHO_T}yes" >&6
8384       break
8385     else
8386       echo "$as_me:$LINENO: result: no" >&5
8387 echo "${ECHO_T}no" >&6
8388     fi
8389   done
8390 fi
8391
8392 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8393   for ncn_progname in gcc; do
8394     if test -n "$ncn_target_tool_prefix"; then
8395       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8396 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8397 echo "$as_me:$LINENO: checking for $ac_word" >&5
8398 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8399 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8400   echo $ECHO_N "(cached) $ECHO_C" >&6
8401 else
8402   if test -n "$GCC_FOR_TARGET"; then
8403   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8404 else
8405 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8406 for as_dir in $PATH
8407 do
8408   IFS=$as_save_IFS
8409   test -z "$as_dir" && as_dir=.
8410   for ac_exec_ext in '' $ac_executable_extensions; do
8411   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8412     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8413     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8414     break 2
8415   fi
8416 done
8417 done
8418
8419 fi
8420 fi
8421 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8422 if test -n "$GCC_FOR_TARGET"; then
8423   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8424 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8425 else
8426   echo "$as_me:$LINENO: result: no" >&5
8427 echo "${ECHO_T}no" >&6
8428 fi
8429
8430     fi
8431     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8432       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8433 set dummy ${ncn_progname}; ac_word=$2
8434 echo "$as_me:$LINENO: checking for $ac_word" >&5
8435 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8436 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8437   echo $ECHO_N "(cached) $ECHO_C" >&6
8438 else
8439   if test -n "$GCC_FOR_TARGET"; then
8440   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8441 else
8442 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8443 for as_dir in $PATH
8444 do
8445   IFS=$as_save_IFS
8446   test -z "$as_dir" && as_dir=.
8447   for ac_exec_ext in '' $ac_executable_extensions; do
8448   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8449     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8450     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8451     break 2
8452   fi
8453 done
8454 done
8455
8456 fi
8457 fi
8458 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8459 if test -n "$GCC_FOR_TARGET"; then
8460   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8461 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8462 else
8463   echo "$as_me:$LINENO: result: no" >&5
8464 echo "${ECHO_T}no" >&6
8465 fi
8466
8467     fi
8468     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8469   done
8470 fi
8471
8472 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8473   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8474 else
8475   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8476 fi
8477
8478
8479
8480 if test -n "$GCJ_FOR_TARGET"; then
8481   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8482 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8483   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8484 fi
8485
8486 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8487   for ncn_progname in gcj; do
8488     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8489 set dummy ${ncn_progname}; ac_word=$2
8490 echo "$as_me:$LINENO: checking for $ac_word" >&5
8491 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8492 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8493   echo $ECHO_N "(cached) $ECHO_C" >&6
8494 else
8495   if test -n "$GCJ_FOR_TARGET"; then
8496   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8497 else
8498 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8499 for as_dir in $PATH
8500 do
8501   IFS=$as_save_IFS
8502   test -z "$as_dir" && as_dir=.
8503   for ac_exec_ext in '' $ac_executable_extensions; do
8504   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8505     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8506     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8507     break 2
8508   fi
8509 done
8510 done
8511
8512 fi
8513 fi
8514 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8515 if test -n "$GCJ_FOR_TARGET"; then
8516   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8517 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8518 else
8519   echo "$as_me:$LINENO: result: no" >&5
8520 echo "${ECHO_T}no" >&6
8521 fi
8522
8523   done
8524 fi
8525
8526 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8527   for ncn_progname in gcj; do
8528     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8529 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8530     if test -x $with_build_time_tools/${ncn_progname}; then
8531       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8532       echo "$as_me:$LINENO: result: yes" >&5
8533 echo "${ECHO_T}yes" >&6
8534       break
8535     else
8536       echo "$as_me:$LINENO: result: no" >&5
8537 echo "${ECHO_T}no" >&6
8538     fi
8539   done
8540 fi
8541
8542 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8543   for ncn_progname in gcj; do
8544     if test -n "$ncn_target_tool_prefix"; then
8545       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8546 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8547 echo "$as_me:$LINENO: checking for $ac_word" >&5
8548 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8549 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8550   echo $ECHO_N "(cached) $ECHO_C" >&6
8551 else
8552   if test -n "$GCJ_FOR_TARGET"; then
8553   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8554 else
8555 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8556 for as_dir in $PATH
8557 do
8558   IFS=$as_save_IFS
8559   test -z "$as_dir" && as_dir=.
8560   for ac_exec_ext in '' $ac_executable_extensions; do
8561   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8562     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8563     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8564     break 2
8565   fi
8566 done
8567 done
8568
8569 fi
8570 fi
8571 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8572 if test -n "$GCJ_FOR_TARGET"; then
8573   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8574 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8575 else
8576   echo "$as_me:$LINENO: result: no" >&5
8577 echo "${ECHO_T}no" >&6
8578 fi
8579
8580     fi
8581     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8582       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8583 set dummy ${ncn_progname}; ac_word=$2
8584 echo "$as_me:$LINENO: checking for $ac_word" >&5
8585 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8586 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8587   echo $ECHO_N "(cached) $ECHO_C" >&6
8588 else
8589   if test -n "$GCJ_FOR_TARGET"; then
8590   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8591 else
8592 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8593 for as_dir in $PATH
8594 do
8595   IFS=$as_save_IFS
8596   test -z "$as_dir" && as_dir=.
8597   for ac_exec_ext in '' $ac_executable_extensions; do
8598   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8599     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8600     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8601     break 2
8602   fi
8603 done
8604 done
8605
8606 fi
8607 fi
8608 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8609 if test -n "$GCJ_FOR_TARGET"; then
8610   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8611 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8612 else
8613   echo "$as_me:$LINENO: result: no" >&5
8614 echo "${ECHO_T}no" >&6
8615 fi
8616
8617     fi
8618     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8619   done
8620 fi
8621
8622 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8623   set dummy gcj
8624   if test $build = $target ; then
8625     GCJ_FOR_TARGET="$2"
8626   else
8627     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8628   fi
8629 else
8630   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8631 fi
8632
8633
8634
8635 if test -n "$GFORTRAN_FOR_TARGET"; then
8636   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8637 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8638   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8639 fi
8640
8641 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8642   for ncn_progname in gfortran; do
8643     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8644 set dummy ${ncn_progname}; ac_word=$2
8645 echo "$as_me:$LINENO: checking for $ac_word" >&5
8646 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8647 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8648   echo $ECHO_N "(cached) $ECHO_C" >&6
8649 else
8650   if test -n "$GFORTRAN_FOR_TARGET"; then
8651   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8652 else
8653 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8654 for as_dir in $PATH
8655 do
8656   IFS=$as_save_IFS
8657   test -z "$as_dir" && as_dir=.
8658   for ac_exec_ext in '' $ac_executable_extensions; do
8659   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8660     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8661     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8662     break 2
8663   fi
8664 done
8665 done
8666
8667 fi
8668 fi
8669 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8670 if test -n "$GFORTRAN_FOR_TARGET"; then
8671   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8672 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8673 else
8674   echo "$as_me:$LINENO: result: no" >&5
8675 echo "${ECHO_T}no" >&6
8676 fi
8677
8678   done
8679 fi
8680
8681 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8682   for ncn_progname in gfortran; do
8683     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8684 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8685     if test -x $with_build_time_tools/${ncn_progname}; then
8686       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8687       echo "$as_me:$LINENO: result: yes" >&5
8688 echo "${ECHO_T}yes" >&6
8689       break
8690     else
8691       echo "$as_me:$LINENO: result: no" >&5
8692 echo "${ECHO_T}no" >&6
8693     fi
8694   done
8695 fi
8696
8697 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8698   for ncn_progname in gfortran; do
8699     if test -n "$ncn_target_tool_prefix"; then
8700       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8701 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8702 echo "$as_me:$LINENO: checking for $ac_word" >&5
8703 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8704 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8705   echo $ECHO_N "(cached) $ECHO_C" >&6
8706 else
8707   if test -n "$GFORTRAN_FOR_TARGET"; then
8708   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8709 else
8710 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8711 for as_dir in $PATH
8712 do
8713   IFS=$as_save_IFS
8714   test -z "$as_dir" && as_dir=.
8715   for ac_exec_ext in '' $ac_executable_extensions; do
8716   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8717     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8718     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8719     break 2
8720   fi
8721 done
8722 done
8723
8724 fi
8725 fi
8726 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8727 if test -n "$GFORTRAN_FOR_TARGET"; then
8728   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8729 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8730 else
8731   echo "$as_me:$LINENO: result: no" >&5
8732 echo "${ECHO_T}no" >&6
8733 fi
8734
8735     fi
8736     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8737       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8738 set dummy ${ncn_progname}; ac_word=$2
8739 echo "$as_me:$LINENO: checking for $ac_word" >&5
8740 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8741 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8742   echo $ECHO_N "(cached) $ECHO_C" >&6
8743 else
8744   if test -n "$GFORTRAN_FOR_TARGET"; then
8745   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8746 else
8747 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8748 for as_dir in $PATH
8749 do
8750   IFS=$as_save_IFS
8751   test -z "$as_dir" && as_dir=.
8752   for ac_exec_ext in '' $ac_executable_extensions; do
8753   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8754     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8755     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8756     break 2
8757   fi
8758 done
8759 done
8760
8761 fi
8762 fi
8763 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8764 if test -n "$GFORTRAN_FOR_TARGET"; then
8765   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8766 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8767 else
8768   echo "$as_me:$LINENO: result: no" >&5
8769 echo "${ECHO_T}no" >&6
8770 fi
8771
8772     fi
8773     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8774   done
8775 fi
8776
8777 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8778   set dummy gfortran
8779   if test $build = $target ; then
8780     GFORTRAN_FOR_TARGET="$2"
8781   else
8782     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8783   fi
8784 else
8785   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8786 fi
8787
8788
8789
8790 cat > conftest.c << \EOF
8791 #ifdef __GNUC__
8792   gcc_yay;
8793 #endif
8794 EOF
8795 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8796   have_gcc_for_target=yes
8797 else
8798   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8799   have_gcc_for_target=no
8800 fi
8801 rm conftest.c
8802
8803
8804
8805
8806 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8807   if test -n "$with_build_time_tools"; then
8808     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8809 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8810     if test -x $with_build_time_tools/ar; then
8811       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8812       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8813       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8814 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8815     else
8816       echo "$as_me:$LINENO: result: no" >&5
8817 echo "${ECHO_T}no" >&6
8818     fi
8819   elif test $build != $host && test $have_gcc_for_target = yes; then
8820     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8821     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8822     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8823   fi
8824 fi
8825 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8826   # Extract the first word of "ar", so it can be a program name with args.
8827 set dummy ar; ac_word=$2
8828 echo "$as_me:$LINENO: checking for $ac_word" >&5
8829 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8830 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8831   echo $ECHO_N "(cached) $ECHO_C" >&6
8832 else
8833   case $AR_FOR_TARGET in
8834   [\\/]* | ?:[\\/]*)
8835   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8836   ;;
8837   *)
8838   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8839 for as_dir in $gcc_cv_tool_dirs
8840 do
8841   IFS=$as_save_IFS
8842   test -z "$as_dir" && as_dir=.
8843   for ac_exec_ext in '' $ac_executable_extensions; do
8844   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8845     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8846     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8847     break 2
8848   fi
8849 done
8850 done
8851
8852   ;;
8853 esac
8854 fi
8855 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8856
8857 if test -n "$AR_FOR_TARGET"; then
8858   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8859 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8860 else
8861   echo "$as_me:$LINENO: result: no" >&5
8862 echo "${ECHO_T}no" >&6
8863 fi
8864
8865 fi
8866 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8867
8868
8869 if test -n "$AR_FOR_TARGET"; then
8870   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8871 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8872   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8873 fi
8874
8875 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8876   for ncn_progname in ar; do
8877     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8878 set dummy ${ncn_progname}; ac_word=$2
8879 echo "$as_me:$LINENO: checking for $ac_word" >&5
8880 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8881 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8882   echo $ECHO_N "(cached) $ECHO_C" >&6
8883 else
8884   if test -n "$AR_FOR_TARGET"; then
8885   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8886 else
8887 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8888 for as_dir in $PATH
8889 do
8890   IFS=$as_save_IFS
8891   test -z "$as_dir" && as_dir=.
8892   for ac_exec_ext in '' $ac_executable_extensions; do
8893   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8894     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8895     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8896     break 2
8897   fi
8898 done
8899 done
8900
8901 fi
8902 fi
8903 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8904 if test -n "$AR_FOR_TARGET"; then
8905   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8906 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8907 else
8908   echo "$as_me:$LINENO: result: no" >&5
8909 echo "${ECHO_T}no" >&6
8910 fi
8911
8912   done
8913 fi
8914
8915 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8916   for ncn_progname in ar; do
8917     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8918 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8919     if test -x $with_build_time_tools/${ncn_progname}; then
8920       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8921       echo "$as_me:$LINENO: result: yes" >&5
8922 echo "${ECHO_T}yes" >&6
8923       break
8924     else
8925       echo "$as_me:$LINENO: result: no" >&5
8926 echo "${ECHO_T}no" >&6
8927     fi
8928   done
8929 fi
8930
8931 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8932   for ncn_progname in ar; do
8933     if test -n "$ncn_target_tool_prefix"; then
8934       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8935 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8936 echo "$as_me:$LINENO: checking for $ac_word" >&5
8937 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8938 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8939   echo $ECHO_N "(cached) $ECHO_C" >&6
8940 else
8941   if test -n "$AR_FOR_TARGET"; then
8942   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8943 else
8944 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8945 for as_dir in $PATH
8946 do
8947   IFS=$as_save_IFS
8948   test -z "$as_dir" && as_dir=.
8949   for ac_exec_ext in '' $ac_executable_extensions; do
8950   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8951     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8952     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8953     break 2
8954   fi
8955 done
8956 done
8957
8958 fi
8959 fi
8960 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8961 if test -n "$AR_FOR_TARGET"; then
8962   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8963 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8964 else
8965   echo "$as_me:$LINENO: result: no" >&5
8966 echo "${ECHO_T}no" >&6
8967 fi
8968
8969     fi
8970     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8971       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8972 set dummy ${ncn_progname}; 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_prog_AR_FOR_TARGET+set}" = set; then
8976   echo $ECHO_N "(cached) $ECHO_C" >&6
8977 else
8978   if test -n "$AR_FOR_TARGET"; then
8979   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8980 else
8981 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8982 for as_dir in $PATH
8983 do
8984   IFS=$as_save_IFS
8985   test -z "$as_dir" && as_dir=.
8986   for ac_exec_ext in '' $ac_executable_extensions; do
8987   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8988     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8989     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8990     break 2
8991   fi
8992 done
8993 done
8994
8995 fi
8996 fi
8997 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8998 if test -n "$AR_FOR_TARGET"; then
8999   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9000 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9001 else
9002   echo "$as_me:$LINENO: result: no" >&5
9003 echo "${ECHO_T}no" >&6
9004 fi
9005
9006     fi
9007     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9008   done
9009 fi
9010
9011 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9012   set dummy ar
9013   if test $build = $target ; then
9014     AR_FOR_TARGET="$2"
9015   else
9016     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9017   fi
9018 else
9019   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9020 fi
9021
9022 else
9023   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9024 fi
9025
9026
9027
9028
9029 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9030   if test -n "$with_build_time_tools"; then
9031     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9032 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9033     if test -x $with_build_time_tools/as; then
9034       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9035       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9036       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9037 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9038     else
9039       echo "$as_me:$LINENO: result: no" >&5
9040 echo "${ECHO_T}no" >&6
9041     fi
9042   elif test $build != $host && test $have_gcc_for_target = yes; then
9043     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9044     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9045     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9046   fi
9047 fi
9048 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9049   # Extract the first word of "as", so it can be a program name with args.
9050 set dummy as; ac_word=$2
9051 echo "$as_me:$LINENO: checking for $ac_word" >&5
9052 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9053 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9054   echo $ECHO_N "(cached) $ECHO_C" >&6
9055 else
9056   case $AS_FOR_TARGET in
9057   [\\/]* | ?:[\\/]*)
9058   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9059   ;;
9060   *)
9061   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9062 for as_dir in $gcc_cv_tool_dirs
9063 do
9064   IFS=$as_save_IFS
9065   test -z "$as_dir" && as_dir=.
9066   for ac_exec_ext in '' $ac_executable_extensions; do
9067   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9068     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9069     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9070     break 2
9071   fi
9072 done
9073 done
9074
9075   ;;
9076 esac
9077 fi
9078 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9079
9080 if test -n "$AS_FOR_TARGET"; then
9081   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9082 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9083 else
9084   echo "$as_me:$LINENO: result: no" >&5
9085 echo "${ECHO_T}no" >&6
9086 fi
9087
9088 fi
9089 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9090
9091
9092 if test -n "$AS_FOR_TARGET"; then
9093   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9094 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9095   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9096 fi
9097
9098 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9099   for ncn_progname in as; do
9100     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9101 set dummy ${ncn_progname}; ac_word=$2
9102 echo "$as_me:$LINENO: checking for $ac_word" >&5
9103 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9104 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9105   echo $ECHO_N "(cached) $ECHO_C" >&6
9106 else
9107   if test -n "$AS_FOR_TARGET"; then
9108   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9109 else
9110 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9111 for as_dir in $PATH
9112 do
9113   IFS=$as_save_IFS
9114   test -z "$as_dir" && as_dir=.
9115   for ac_exec_ext in '' $ac_executable_extensions; do
9116   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9117     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9118     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9119     break 2
9120   fi
9121 done
9122 done
9123
9124 fi
9125 fi
9126 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9127 if test -n "$AS_FOR_TARGET"; then
9128   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9129 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9130 else
9131   echo "$as_me:$LINENO: result: no" >&5
9132 echo "${ECHO_T}no" >&6
9133 fi
9134
9135   done
9136 fi
9137
9138 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9139   for ncn_progname in as; do
9140     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9141 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9142     if test -x $with_build_time_tools/${ncn_progname}; then
9143       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9144       echo "$as_me:$LINENO: result: yes" >&5
9145 echo "${ECHO_T}yes" >&6
9146       break
9147     else
9148       echo "$as_me:$LINENO: result: no" >&5
9149 echo "${ECHO_T}no" >&6
9150     fi
9151   done
9152 fi
9153
9154 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9155   for ncn_progname in as; do
9156     if test -n "$ncn_target_tool_prefix"; then
9157       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9158 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9159 echo "$as_me:$LINENO: checking for $ac_word" >&5
9160 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9161 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9162   echo $ECHO_N "(cached) $ECHO_C" >&6
9163 else
9164   if test -n "$AS_FOR_TARGET"; then
9165   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9166 else
9167 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9168 for as_dir in $PATH
9169 do
9170   IFS=$as_save_IFS
9171   test -z "$as_dir" && as_dir=.
9172   for ac_exec_ext in '' $ac_executable_extensions; do
9173   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9174     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9175     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9176     break 2
9177   fi
9178 done
9179 done
9180
9181 fi
9182 fi
9183 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9184 if test -n "$AS_FOR_TARGET"; then
9185   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9186 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9187 else
9188   echo "$as_me:$LINENO: result: no" >&5
9189 echo "${ECHO_T}no" >&6
9190 fi
9191
9192     fi
9193     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9194       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9195 set dummy ${ncn_progname}; 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_prog_AS_FOR_TARGET+set}" = set; then
9199   echo $ECHO_N "(cached) $ECHO_C" >&6
9200 else
9201   if test -n "$AS_FOR_TARGET"; then
9202   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9203 else
9204 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9205 for as_dir in $PATH
9206 do
9207   IFS=$as_save_IFS
9208   test -z "$as_dir" && as_dir=.
9209   for ac_exec_ext in '' $ac_executable_extensions; do
9210   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9211     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9212     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9213     break 2
9214   fi
9215 done
9216 done
9217
9218 fi
9219 fi
9220 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9221 if test -n "$AS_FOR_TARGET"; then
9222   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9223 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9224 else
9225   echo "$as_me:$LINENO: result: no" >&5
9226 echo "${ECHO_T}no" >&6
9227 fi
9228
9229     fi
9230     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9231   done
9232 fi
9233
9234 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9235   set dummy as
9236   if test $build = $target ; then
9237     AS_FOR_TARGET="$2"
9238   else
9239     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9240   fi
9241 else
9242   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9243 fi
9244
9245 else
9246   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9247 fi
9248
9249
9250
9251
9252 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9253   if test -n "$with_build_time_tools"; then
9254     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9255 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9256     if test -x $with_build_time_tools/dlltool; then
9257       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9258       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9259       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9260 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9261     else
9262       echo "$as_me:$LINENO: result: no" >&5
9263 echo "${ECHO_T}no" >&6
9264     fi
9265   elif test $build != $host && test $have_gcc_for_target = yes; then
9266     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9267     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9268     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9269   fi
9270 fi
9271 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9272   # Extract the first word of "dlltool", so it can be a program name with args.
9273 set dummy dlltool; ac_word=$2
9274 echo "$as_me:$LINENO: checking for $ac_word" >&5
9275 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9276 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9277   echo $ECHO_N "(cached) $ECHO_C" >&6
9278 else
9279   case $DLLTOOL_FOR_TARGET in
9280   [\\/]* | ?:[\\/]*)
9281   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9282   ;;
9283   *)
9284   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9285 for as_dir in $gcc_cv_tool_dirs
9286 do
9287   IFS=$as_save_IFS
9288   test -z "$as_dir" && as_dir=.
9289   for ac_exec_ext in '' $ac_executable_extensions; do
9290   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9291     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9292     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9293     break 2
9294   fi
9295 done
9296 done
9297
9298   ;;
9299 esac
9300 fi
9301 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9302
9303 if test -n "$DLLTOOL_FOR_TARGET"; then
9304   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9305 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9306 else
9307   echo "$as_me:$LINENO: result: no" >&5
9308 echo "${ECHO_T}no" >&6
9309 fi
9310
9311 fi
9312 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9313
9314
9315 if test -n "$DLLTOOL_FOR_TARGET"; then
9316   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9317 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9318   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9319 fi
9320
9321 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9322   for ncn_progname in dlltool; do
9323     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9324 set dummy ${ncn_progname}; ac_word=$2
9325 echo "$as_me:$LINENO: checking for $ac_word" >&5
9326 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9327 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9328   echo $ECHO_N "(cached) $ECHO_C" >&6
9329 else
9330   if test -n "$DLLTOOL_FOR_TARGET"; then
9331   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9332 else
9333 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9334 for as_dir in $PATH
9335 do
9336   IFS=$as_save_IFS
9337   test -z "$as_dir" && as_dir=.
9338   for ac_exec_ext in '' $ac_executable_extensions; do
9339   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9340     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9341     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9342     break 2
9343   fi
9344 done
9345 done
9346
9347 fi
9348 fi
9349 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9350 if test -n "$DLLTOOL_FOR_TARGET"; then
9351   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9352 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9353 else
9354   echo "$as_me:$LINENO: result: no" >&5
9355 echo "${ECHO_T}no" >&6
9356 fi
9357
9358   done
9359 fi
9360
9361 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9362   for ncn_progname in dlltool; do
9363     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9364 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9365     if test -x $with_build_time_tools/${ncn_progname}; then
9366       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9367       echo "$as_me:$LINENO: result: yes" >&5
9368 echo "${ECHO_T}yes" >&6
9369       break
9370     else
9371       echo "$as_me:$LINENO: result: no" >&5
9372 echo "${ECHO_T}no" >&6
9373     fi
9374   done
9375 fi
9376
9377 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9378   for ncn_progname in dlltool; do
9379     if test -n "$ncn_target_tool_prefix"; then
9380       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9381 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9382 echo "$as_me:$LINENO: checking for $ac_word" >&5
9383 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9384 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9385   echo $ECHO_N "(cached) $ECHO_C" >&6
9386 else
9387   if test -n "$DLLTOOL_FOR_TARGET"; then
9388   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9389 else
9390 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9391 for as_dir in $PATH
9392 do
9393   IFS=$as_save_IFS
9394   test -z "$as_dir" && as_dir=.
9395   for ac_exec_ext in '' $ac_executable_extensions; do
9396   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9397     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9398     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9399     break 2
9400   fi
9401 done
9402 done
9403
9404 fi
9405 fi
9406 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9407 if test -n "$DLLTOOL_FOR_TARGET"; then
9408   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9409 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9410 else
9411   echo "$as_me:$LINENO: result: no" >&5
9412 echo "${ECHO_T}no" >&6
9413 fi
9414
9415     fi
9416     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9417       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9418 set dummy ${ncn_progname}; 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_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9422   echo $ECHO_N "(cached) $ECHO_C" >&6
9423 else
9424   if test -n "$DLLTOOL_FOR_TARGET"; then
9425   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9426 else
9427 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9428 for as_dir in $PATH
9429 do
9430   IFS=$as_save_IFS
9431   test -z "$as_dir" && as_dir=.
9432   for ac_exec_ext in '' $ac_executable_extensions; do
9433   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9434     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9435     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9436     break 2
9437   fi
9438 done
9439 done
9440
9441 fi
9442 fi
9443 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9444 if test -n "$DLLTOOL_FOR_TARGET"; then
9445   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9446 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9447 else
9448   echo "$as_me:$LINENO: result: no" >&5
9449 echo "${ECHO_T}no" >&6
9450 fi
9451
9452     fi
9453     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9454   done
9455 fi
9456
9457 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9458   set dummy dlltool
9459   if test $build = $target ; then
9460     DLLTOOL_FOR_TARGET="$2"
9461   else
9462     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9463   fi
9464 else
9465   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9466 fi
9467
9468 else
9469   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9470 fi
9471
9472
9473
9474
9475 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9476   if test -n "$with_build_time_tools"; then
9477     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9478 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9479     if test -x $with_build_time_tools/ld; then
9480       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9481       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9482       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9483 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9484     else
9485       echo "$as_me:$LINENO: result: no" >&5
9486 echo "${ECHO_T}no" >&6
9487     fi
9488   elif test $build != $host && test $have_gcc_for_target = yes; then
9489     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9490     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9491     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9492   fi
9493 fi
9494 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9495   # Extract the first word of "ld", so it can be a program name with args.
9496 set dummy ld; ac_word=$2
9497 echo "$as_me:$LINENO: checking for $ac_word" >&5
9498 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9499 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9500   echo $ECHO_N "(cached) $ECHO_C" >&6
9501 else
9502   case $LD_FOR_TARGET in
9503   [\\/]* | ?:[\\/]*)
9504   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9505   ;;
9506   *)
9507   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9508 for as_dir in $gcc_cv_tool_dirs
9509 do
9510   IFS=$as_save_IFS
9511   test -z "$as_dir" && as_dir=.
9512   for ac_exec_ext in '' $ac_executable_extensions; do
9513   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9514     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9515     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9516     break 2
9517   fi
9518 done
9519 done
9520
9521   ;;
9522 esac
9523 fi
9524 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9525
9526 if test -n "$LD_FOR_TARGET"; then
9527   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9528 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9529 else
9530   echo "$as_me:$LINENO: result: no" >&5
9531 echo "${ECHO_T}no" >&6
9532 fi
9533
9534 fi
9535 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9536
9537
9538 if test -n "$LD_FOR_TARGET"; then
9539   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9540 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9541   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9542 fi
9543
9544 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9545   for ncn_progname in ld; do
9546     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9547 set dummy ${ncn_progname}; ac_word=$2
9548 echo "$as_me:$LINENO: checking for $ac_word" >&5
9549 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9550 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9551   echo $ECHO_N "(cached) $ECHO_C" >&6
9552 else
9553   if test -n "$LD_FOR_TARGET"; then
9554   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9555 else
9556 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9557 for as_dir in $PATH
9558 do
9559   IFS=$as_save_IFS
9560   test -z "$as_dir" && as_dir=.
9561   for ac_exec_ext in '' $ac_executable_extensions; do
9562   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9563     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9564     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9565     break 2
9566   fi
9567 done
9568 done
9569
9570 fi
9571 fi
9572 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9573 if test -n "$LD_FOR_TARGET"; then
9574   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9575 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9576 else
9577   echo "$as_me:$LINENO: result: no" >&5
9578 echo "${ECHO_T}no" >&6
9579 fi
9580
9581   done
9582 fi
9583
9584 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9585   for ncn_progname in ld; do
9586     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9587 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9588     if test -x $with_build_time_tools/${ncn_progname}; then
9589       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9590       echo "$as_me:$LINENO: result: yes" >&5
9591 echo "${ECHO_T}yes" >&6
9592       break
9593     else
9594       echo "$as_me:$LINENO: result: no" >&5
9595 echo "${ECHO_T}no" >&6
9596     fi
9597   done
9598 fi
9599
9600 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9601   for ncn_progname in ld; do
9602     if test -n "$ncn_target_tool_prefix"; then
9603       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9604 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9605 echo "$as_me:$LINENO: checking for $ac_word" >&5
9606 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9607 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9608   echo $ECHO_N "(cached) $ECHO_C" >&6
9609 else
9610   if test -n "$LD_FOR_TARGET"; then
9611   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9612 else
9613 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9614 for as_dir in $PATH
9615 do
9616   IFS=$as_save_IFS
9617   test -z "$as_dir" && as_dir=.
9618   for ac_exec_ext in '' $ac_executable_extensions; do
9619   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9620     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9621     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9622     break 2
9623   fi
9624 done
9625 done
9626
9627 fi
9628 fi
9629 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9630 if test -n "$LD_FOR_TARGET"; then
9631   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9632 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9633 else
9634   echo "$as_me:$LINENO: result: no" >&5
9635 echo "${ECHO_T}no" >&6
9636 fi
9637
9638     fi
9639     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9640       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9641 set dummy ${ncn_progname}; 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_prog_LD_FOR_TARGET+set}" = set; then
9645   echo $ECHO_N "(cached) $ECHO_C" >&6
9646 else
9647   if test -n "$LD_FOR_TARGET"; then
9648   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9649 else
9650 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9651 for as_dir in $PATH
9652 do
9653   IFS=$as_save_IFS
9654   test -z "$as_dir" && as_dir=.
9655   for ac_exec_ext in '' $ac_executable_extensions; do
9656   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9657     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9658     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9659     break 2
9660   fi
9661 done
9662 done
9663
9664 fi
9665 fi
9666 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9667 if test -n "$LD_FOR_TARGET"; then
9668   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9669 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9670 else
9671   echo "$as_me:$LINENO: result: no" >&5
9672 echo "${ECHO_T}no" >&6
9673 fi
9674
9675     fi
9676     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9677   done
9678 fi
9679
9680 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9681   set dummy ld
9682   if test $build = $target ; then
9683     LD_FOR_TARGET="$2"
9684   else
9685     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9686   fi
9687 else
9688   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9689 fi
9690
9691 else
9692   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9693 fi
9694
9695
9696
9697
9698 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9699   if test -n "$with_build_time_tools"; then
9700     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9701 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9702     if test -x $with_build_time_tools/lipo; then
9703       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9704       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9705       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9706 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9707     else
9708       echo "$as_me:$LINENO: result: no" >&5
9709 echo "${ECHO_T}no" >&6
9710     fi
9711   elif test $build != $host && test $have_gcc_for_target = yes; then
9712     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9713     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9714     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9715   fi
9716 fi
9717 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9718   # Extract the first word of "lipo", so it can be a program name with args.
9719 set dummy lipo; ac_word=$2
9720 echo "$as_me:$LINENO: checking for $ac_word" >&5
9721 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9722 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9723   echo $ECHO_N "(cached) $ECHO_C" >&6
9724 else
9725   case $LIPO_FOR_TARGET in
9726   [\\/]* | ?:[\\/]*)
9727   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9728   ;;
9729   *)
9730   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9731 for as_dir in $gcc_cv_tool_dirs
9732 do
9733   IFS=$as_save_IFS
9734   test -z "$as_dir" && as_dir=.
9735   for ac_exec_ext in '' $ac_executable_extensions; do
9736   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9737     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9738     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9739     break 2
9740   fi
9741 done
9742 done
9743
9744   ;;
9745 esac
9746 fi
9747 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9748
9749 if test -n "$LIPO_FOR_TARGET"; then
9750   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9751 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9752 else
9753   echo "$as_me:$LINENO: result: no" >&5
9754 echo "${ECHO_T}no" >&6
9755 fi
9756
9757 fi
9758 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9759
9760
9761 if test -n "$LIPO_FOR_TARGET"; then
9762   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9763 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9764   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9765 fi
9766
9767 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9768   for ncn_progname in lipo; do
9769     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9770 set dummy ${ncn_progname}; ac_word=$2
9771 echo "$as_me:$LINENO: checking for $ac_word" >&5
9772 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9773 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9774   echo $ECHO_N "(cached) $ECHO_C" >&6
9775 else
9776   if test -n "$LIPO_FOR_TARGET"; then
9777   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9778 else
9779 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9780 for as_dir in $PATH
9781 do
9782   IFS=$as_save_IFS
9783   test -z "$as_dir" && as_dir=.
9784   for ac_exec_ext in '' $ac_executable_extensions; do
9785   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9786     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9787     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9788     break 2
9789   fi
9790 done
9791 done
9792
9793 fi
9794 fi
9795 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9796 if test -n "$LIPO_FOR_TARGET"; then
9797   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9798 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9799 else
9800   echo "$as_me:$LINENO: result: no" >&5
9801 echo "${ECHO_T}no" >&6
9802 fi
9803
9804   done
9805 fi
9806
9807 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9808   for ncn_progname in lipo; do
9809     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9810 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9811     if test -x $with_build_time_tools/${ncn_progname}; then
9812       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9813       echo "$as_me:$LINENO: result: yes" >&5
9814 echo "${ECHO_T}yes" >&6
9815       break
9816     else
9817       echo "$as_me:$LINENO: result: no" >&5
9818 echo "${ECHO_T}no" >&6
9819     fi
9820   done
9821 fi
9822
9823 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9824   for ncn_progname in lipo; do
9825     if test -n "$ncn_target_tool_prefix"; then
9826       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9827 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9828 echo "$as_me:$LINENO: checking for $ac_word" >&5
9829 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9830 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9831   echo $ECHO_N "(cached) $ECHO_C" >&6
9832 else
9833   if test -n "$LIPO_FOR_TARGET"; then
9834   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9835 else
9836 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9837 for as_dir in $PATH
9838 do
9839   IFS=$as_save_IFS
9840   test -z "$as_dir" && as_dir=.
9841   for ac_exec_ext in '' $ac_executable_extensions; do
9842   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9843     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9844     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9845     break 2
9846   fi
9847 done
9848 done
9849
9850 fi
9851 fi
9852 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9853 if test -n "$LIPO_FOR_TARGET"; then
9854   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9855 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9856 else
9857   echo "$as_me:$LINENO: result: no" >&5
9858 echo "${ECHO_T}no" >&6
9859 fi
9860
9861     fi
9862     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9863       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9864 set dummy ${ncn_progname}; 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_prog_LIPO_FOR_TARGET+set}" = set; then
9868   echo $ECHO_N "(cached) $ECHO_C" >&6
9869 else
9870   if test -n "$LIPO_FOR_TARGET"; then
9871   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9872 else
9873 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9874 for as_dir in $PATH
9875 do
9876   IFS=$as_save_IFS
9877   test -z "$as_dir" && as_dir=.
9878   for ac_exec_ext in '' $ac_executable_extensions; do
9879   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9880     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9881     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9882     break 2
9883   fi
9884 done
9885 done
9886
9887 fi
9888 fi
9889 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9890 if test -n "$LIPO_FOR_TARGET"; then
9891   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9892 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9893 else
9894   echo "$as_me:$LINENO: result: no" >&5
9895 echo "${ECHO_T}no" >&6
9896 fi
9897
9898     fi
9899     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9900   done
9901 fi
9902
9903 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9904   set dummy lipo
9905   if test $build = $target ; then
9906     LIPO_FOR_TARGET="$2"
9907   else
9908     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9909   fi
9910 else
9911   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9912 fi
9913
9914 else
9915   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9916 fi
9917
9918
9919
9920
9921 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9922   if test -n "$with_build_time_tools"; then
9923     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9924 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9925     if test -x $with_build_time_tools/nm; then
9926       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9927       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9928       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9929 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9930     else
9931       echo "$as_me:$LINENO: result: no" >&5
9932 echo "${ECHO_T}no" >&6
9933     fi
9934   elif test $build != $host && test $have_gcc_for_target = yes; then
9935     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9936     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
9937     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9938   fi
9939 fi
9940 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9941   # Extract the first word of "nm", so it can be a program name with args.
9942 set dummy nm; ac_word=$2
9943 echo "$as_me:$LINENO: checking for $ac_word" >&5
9944 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9945 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9946   echo $ECHO_N "(cached) $ECHO_C" >&6
9947 else
9948   case $NM_FOR_TARGET in
9949   [\\/]* | ?:[\\/]*)
9950   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9951   ;;
9952   *)
9953   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9954 for as_dir in $gcc_cv_tool_dirs
9955 do
9956   IFS=$as_save_IFS
9957   test -z "$as_dir" && as_dir=.
9958   for ac_exec_ext in '' $ac_executable_extensions; do
9959   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9960     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9961     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9962     break 2
9963   fi
9964 done
9965 done
9966
9967   ;;
9968 esac
9969 fi
9970 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9971
9972 if test -n "$NM_FOR_TARGET"; then
9973   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9974 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9975 else
9976   echo "$as_me:$LINENO: result: no" >&5
9977 echo "${ECHO_T}no" >&6
9978 fi
9979
9980 fi
9981 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9982
9983
9984 if test -n "$NM_FOR_TARGET"; then
9985   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9986 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9987   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9988 fi
9989
9990 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9991   for ncn_progname in nm; do
9992     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9993 set dummy ${ncn_progname}; ac_word=$2
9994 echo "$as_me:$LINENO: checking for $ac_word" >&5
9995 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9996 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9997   echo $ECHO_N "(cached) $ECHO_C" >&6
9998 else
9999   if test -n "$NM_FOR_TARGET"; then
10000   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10001 else
10002 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10003 for as_dir in $PATH
10004 do
10005   IFS=$as_save_IFS
10006   test -z "$as_dir" && as_dir=.
10007   for ac_exec_ext in '' $ac_executable_extensions; do
10008   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10009     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10010     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10011     break 2
10012   fi
10013 done
10014 done
10015
10016 fi
10017 fi
10018 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10019 if test -n "$NM_FOR_TARGET"; then
10020   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10021 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10022 else
10023   echo "$as_me:$LINENO: result: no" >&5
10024 echo "${ECHO_T}no" >&6
10025 fi
10026
10027   done
10028 fi
10029
10030 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10031   for ncn_progname in nm; do
10032     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10033 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10034     if test -x $with_build_time_tools/${ncn_progname}; then
10035       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10036       echo "$as_me:$LINENO: result: yes" >&5
10037 echo "${ECHO_T}yes" >&6
10038       break
10039     else
10040       echo "$as_me:$LINENO: result: no" >&5
10041 echo "${ECHO_T}no" >&6
10042     fi
10043   done
10044 fi
10045
10046 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10047   for ncn_progname in nm; do
10048     if test -n "$ncn_target_tool_prefix"; then
10049       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10050 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10051 echo "$as_me:$LINENO: checking for $ac_word" >&5
10052 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10053 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10054   echo $ECHO_N "(cached) $ECHO_C" >&6
10055 else
10056   if test -n "$NM_FOR_TARGET"; then
10057   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10058 else
10059 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10060 for as_dir in $PATH
10061 do
10062   IFS=$as_save_IFS
10063   test -z "$as_dir" && as_dir=.
10064   for ac_exec_ext in '' $ac_executable_extensions; do
10065   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10066     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10067     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10068     break 2
10069   fi
10070 done
10071 done
10072
10073 fi
10074 fi
10075 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10076 if test -n "$NM_FOR_TARGET"; then
10077   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10078 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10079 else
10080   echo "$as_me:$LINENO: result: no" >&5
10081 echo "${ECHO_T}no" >&6
10082 fi
10083
10084     fi
10085     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10086       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10087 set dummy ${ncn_progname}; 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_prog_NM_FOR_TARGET+set}" = set; then
10091   echo $ECHO_N "(cached) $ECHO_C" >&6
10092 else
10093   if test -n "$NM_FOR_TARGET"; then
10094   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10095 else
10096 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10097 for as_dir in $PATH
10098 do
10099   IFS=$as_save_IFS
10100   test -z "$as_dir" && as_dir=.
10101   for ac_exec_ext in '' $ac_executable_extensions; do
10102   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10103     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10104     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10105     break 2
10106   fi
10107 done
10108 done
10109
10110 fi
10111 fi
10112 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10113 if test -n "$NM_FOR_TARGET"; then
10114   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10115 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10116 else
10117   echo "$as_me:$LINENO: result: no" >&5
10118 echo "${ECHO_T}no" >&6
10119 fi
10120
10121     fi
10122     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10123   done
10124 fi
10125
10126 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10127   set dummy nm
10128   if test $build = $target ; then
10129     NM_FOR_TARGET="$2"
10130   else
10131     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10132   fi
10133 else
10134   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10135 fi
10136
10137 else
10138   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10139 fi
10140
10141
10142
10143
10144 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10145   if test -n "$with_build_time_tools"; then
10146     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10147 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10148     if test -x $with_build_time_tools/objdump; then
10149       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10150       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10151       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10152 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10153     else
10154       echo "$as_me:$LINENO: result: no" >&5
10155 echo "${ECHO_T}no" >&6
10156     fi
10157   elif test $build != $host && test $have_gcc_for_target = yes; then
10158     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10159     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10160     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10161   fi
10162 fi
10163 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10164   # Extract the first word of "objdump", so it can be a program name with args.
10165 set dummy objdump; ac_word=$2
10166 echo "$as_me:$LINENO: checking for $ac_word" >&5
10167 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10168 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10169   echo $ECHO_N "(cached) $ECHO_C" >&6
10170 else
10171   case $OBJDUMP_FOR_TARGET in
10172   [\\/]* | ?:[\\/]*)
10173   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10174   ;;
10175   *)
10176   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10177 for as_dir in $gcc_cv_tool_dirs
10178 do
10179   IFS=$as_save_IFS
10180   test -z "$as_dir" && as_dir=.
10181   for ac_exec_ext in '' $ac_executable_extensions; do
10182   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10183     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10184     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10185     break 2
10186   fi
10187 done
10188 done
10189
10190   ;;
10191 esac
10192 fi
10193 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10194
10195 if test -n "$OBJDUMP_FOR_TARGET"; then
10196   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10197 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10198 else
10199   echo "$as_me:$LINENO: result: no" >&5
10200 echo "${ECHO_T}no" >&6
10201 fi
10202
10203 fi
10204 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10205
10206
10207 if test -n "$OBJDUMP_FOR_TARGET"; then
10208   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10209 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10210   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10211 fi
10212
10213 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10214   for ncn_progname in objdump; do
10215     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10216 set dummy ${ncn_progname}; ac_word=$2
10217 echo "$as_me:$LINENO: checking for $ac_word" >&5
10218 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10219 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10220   echo $ECHO_N "(cached) $ECHO_C" >&6
10221 else
10222   if test -n "$OBJDUMP_FOR_TARGET"; then
10223   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10224 else
10225 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10226 for as_dir in $PATH
10227 do
10228   IFS=$as_save_IFS
10229   test -z "$as_dir" && as_dir=.
10230   for ac_exec_ext in '' $ac_executable_extensions; do
10231   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10232     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10233     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10234     break 2
10235   fi
10236 done
10237 done
10238
10239 fi
10240 fi
10241 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10242 if test -n "$OBJDUMP_FOR_TARGET"; then
10243   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10244 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10245 else
10246   echo "$as_me:$LINENO: result: no" >&5
10247 echo "${ECHO_T}no" >&6
10248 fi
10249
10250   done
10251 fi
10252
10253 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10254   for ncn_progname in objdump; do
10255     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10256 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10257     if test -x $with_build_time_tools/${ncn_progname}; then
10258       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10259       echo "$as_me:$LINENO: result: yes" >&5
10260 echo "${ECHO_T}yes" >&6
10261       break
10262     else
10263       echo "$as_me:$LINENO: result: no" >&5
10264 echo "${ECHO_T}no" >&6
10265     fi
10266   done
10267 fi
10268
10269 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10270   for ncn_progname in objdump; do
10271     if test -n "$ncn_target_tool_prefix"; then
10272       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10273 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10274 echo "$as_me:$LINENO: checking for $ac_word" >&5
10275 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10276 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10277   echo $ECHO_N "(cached) $ECHO_C" >&6
10278 else
10279   if test -n "$OBJDUMP_FOR_TARGET"; then
10280   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10281 else
10282 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10283 for as_dir in $PATH
10284 do
10285   IFS=$as_save_IFS
10286   test -z "$as_dir" && as_dir=.
10287   for ac_exec_ext in '' $ac_executable_extensions; do
10288   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10289     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10290     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10291     break 2
10292   fi
10293 done
10294 done
10295
10296 fi
10297 fi
10298 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10299 if test -n "$OBJDUMP_FOR_TARGET"; then
10300   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10301 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10302 else
10303   echo "$as_me:$LINENO: result: no" >&5
10304 echo "${ECHO_T}no" >&6
10305 fi
10306
10307     fi
10308     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10309       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10310 set dummy ${ncn_progname}; 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_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10314   echo $ECHO_N "(cached) $ECHO_C" >&6
10315 else
10316   if test -n "$OBJDUMP_FOR_TARGET"; then
10317   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10318 else
10319 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10320 for as_dir in $PATH
10321 do
10322   IFS=$as_save_IFS
10323   test -z "$as_dir" && as_dir=.
10324   for ac_exec_ext in '' $ac_executable_extensions; do
10325   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10326     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10327     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10328     break 2
10329   fi
10330 done
10331 done
10332
10333 fi
10334 fi
10335 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10336 if test -n "$OBJDUMP_FOR_TARGET"; then
10337   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10338 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10339 else
10340   echo "$as_me:$LINENO: result: no" >&5
10341 echo "${ECHO_T}no" >&6
10342 fi
10343
10344     fi
10345     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10346   done
10347 fi
10348
10349 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10350   set dummy objdump
10351   if test $build = $target ; then
10352     OBJDUMP_FOR_TARGET="$2"
10353   else
10354     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10355   fi
10356 else
10357   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10358 fi
10359
10360 else
10361   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10362 fi
10363
10364
10365
10366
10367 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10368   if test -n "$with_build_time_tools"; then
10369     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10370 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10371     if test -x $with_build_time_tools/ranlib; then
10372       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10373       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10374       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10375 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10376     else
10377       echo "$as_me:$LINENO: result: no" >&5
10378 echo "${ECHO_T}no" >&6
10379     fi
10380   elif test $build != $host && test $have_gcc_for_target = yes; then
10381     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10382     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10383     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10384   fi
10385 fi
10386 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10387   # Extract the first word of "ranlib", so it can be a program name with args.
10388 set dummy ranlib; ac_word=$2
10389 echo "$as_me:$LINENO: checking for $ac_word" >&5
10390 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10391 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10392   echo $ECHO_N "(cached) $ECHO_C" >&6
10393 else
10394   case $RANLIB_FOR_TARGET in
10395   [\\/]* | ?:[\\/]*)
10396   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10397   ;;
10398   *)
10399   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10400 for as_dir in $gcc_cv_tool_dirs
10401 do
10402   IFS=$as_save_IFS
10403   test -z "$as_dir" && as_dir=.
10404   for ac_exec_ext in '' $ac_executable_extensions; do
10405   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10406     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10407     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10408     break 2
10409   fi
10410 done
10411 done
10412
10413   ;;
10414 esac
10415 fi
10416 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10417
10418 if test -n "$RANLIB_FOR_TARGET"; then
10419   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10420 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10421 else
10422   echo "$as_me:$LINENO: result: no" >&5
10423 echo "${ECHO_T}no" >&6
10424 fi
10425
10426 fi
10427 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10428
10429
10430 if test -n "$RANLIB_FOR_TARGET"; then
10431   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10432 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10433   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10434 fi
10435
10436 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10437   for ncn_progname in ranlib; do
10438     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10439 set dummy ${ncn_progname}; ac_word=$2
10440 echo "$as_me:$LINENO: checking for $ac_word" >&5
10441 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10442 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10443   echo $ECHO_N "(cached) $ECHO_C" >&6
10444 else
10445   if test -n "$RANLIB_FOR_TARGET"; then
10446   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10447 else
10448 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10449 for as_dir in $PATH
10450 do
10451   IFS=$as_save_IFS
10452   test -z "$as_dir" && as_dir=.
10453   for ac_exec_ext in '' $ac_executable_extensions; do
10454   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10455     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10456     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10457     break 2
10458   fi
10459 done
10460 done
10461
10462 fi
10463 fi
10464 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10465 if test -n "$RANLIB_FOR_TARGET"; then
10466   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10467 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10468 else
10469   echo "$as_me:$LINENO: result: no" >&5
10470 echo "${ECHO_T}no" >&6
10471 fi
10472
10473   done
10474 fi
10475
10476 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10477   for ncn_progname in ranlib; do
10478     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10479 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10480     if test -x $with_build_time_tools/${ncn_progname}; then
10481       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10482       echo "$as_me:$LINENO: result: yes" >&5
10483 echo "${ECHO_T}yes" >&6
10484       break
10485     else
10486       echo "$as_me:$LINENO: result: no" >&5
10487 echo "${ECHO_T}no" >&6
10488     fi
10489   done
10490 fi
10491
10492 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10493   for ncn_progname in ranlib; do
10494     if test -n "$ncn_target_tool_prefix"; then
10495       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10496 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10497 echo "$as_me:$LINENO: checking for $ac_word" >&5
10498 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10499 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10500   echo $ECHO_N "(cached) $ECHO_C" >&6
10501 else
10502   if test -n "$RANLIB_FOR_TARGET"; then
10503   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10504 else
10505 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10506 for as_dir in $PATH
10507 do
10508   IFS=$as_save_IFS
10509   test -z "$as_dir" && as_dir=.
10510   for ac_exec_ext in '' $ac_executable_extensions; do
10511   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10512     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10513     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10514     break 2
10515   fi
10516 done
10517 done
10518
10519 fi
10520 fi
10521 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10522 if test -n "$RANLIB_FOR_TARGET"; then
10523   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10524 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10525 else
10526   echo "$as_me:$LINENO: result: no" >&5
10527 echo "${ECHO_T}no" >&6
10528 fi
10529
10530     fi
10531     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10532       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10533 set dummy ${ncn_progname}; 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_prog_RANLIB_FOR_TARGET+set}" = set; then
10537   echo $ECHO_N "(cached) $ECHO_C" >&6
10538 else
10539   if test -n "$RANLIB_FOR_TARGET"; then
10540   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10541 else
10542 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10543 for as_dir in $PATH
10544 do
10545   IFS=$as_save_IFS
10546   test -z "$as_dir" && as_dir=.
10547   for ac_exec_ext in '' $ac_executable_extensions; do
10548   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10549     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10550     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10551     break 2
10552   fi
10553 done
10554 done
10555
10556 fi
10557 fi
10558 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10559 if test -n "$RANLIB_FOR_TARGET"; then
10560   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10561 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10562 else
10563   echo "$as_me:$LINENO: result: no" >&5
10564 echo "${ECHO_T}no" >&6
10565 fi
10566
10567     fi
10568     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10569   done
10570 fi
10571
10572 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10573   set dummy ranlib
10574   if test $build = $target ; then
10575     RANLIB_FOR_TARGET="$2"
10576   else
10577     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10578   fi
10579 else
10580   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10581 fi
10582
10583 else
10584   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10585 fi
10586
10587
10588
10589
10590 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10591   if test -n "$with_build_time_tools"; then
10592     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10593 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10594     if test -x $with_build_time_tools/strip; then
10595       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10596       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10597       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10598 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10599     else
10600       echo "$as_me:$LINENO: result: no" >&5
10601 echo "${ECHO_T}no" >&6
10602     fi
10603   elif test $build != $host && test $have_gcc_for_target = yes; then
10604     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10605     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10606     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10607   fi
10608 fi
10609 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10610   # Extract the first word of "strip", so it can be a program name with args.
10611 set dummy strip; ac_word=$2
10612 echo "$as_me:$LINENO: checking for $ac_word" >&5
10613 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10614 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10615   echo $ECHO_N "(cached) $ECHO_C" >&6
10616 else
10617   case $STRIP_FOR_TARGET in
10618   [\\/]* | ?:[\\/]*)
10619   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10620   ;;
10621   *)
10622   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10623 for as_dir in $gcc_cv_tool_dirs
10624 do
10625   IFS=$as_save_IFS
10626   test -z "$as_dir" && as_dir=.
10627   for ac_exec_ext in '' $ac_executable_extensions; do
10628   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10629     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10630     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10631     break 2
10632   fi
10633 done
10634 done
10635
10636   ;;
10637 esac
10638 fi
10639 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10640
10641 if test -n "$STRIP_FOR_TARGET"; then
10642   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10643 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10644 else
10645   echo "$as_me:$LINENO: result: no" >&5
10646 echo "${ECHO_T}no" >&6
10647 fi
10648
10649 fi
10650 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10651
10652
10653 if test -n "$STRIP_FOR_TARGET"; then
10654   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10655 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10656   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10657 fi
10658
10659 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10660   for ncn_progname in strip; do
10661     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10662 set dummy ${ncn_progname}; ac_word=$2
10663 echo "$as_me:$LINENO: checking for $ac_word" >&5
10664 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10665 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10666   echo $ECHO_N "(cached) $ECHO_C" >&6
10667 else
10668   if test -n "$STRIP_FOR_TARGET"; then
10669   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10670 else
10671 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10672 for as_dir in $PATH
10673 do
10674   IFS=$as_save_IFS
10675   test -z "$as_dir" && as_dir=.
10676   for ac_exec_ext in '' $ac_executable_extensions; do
10677   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10678     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10679     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10680     break 2
10681   fi
10682 done
10683 done
10684
10685 fi
10686 fi
10687 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10688 if test -n "$STRIP_FOR_TARGET"; then
10689   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10690 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10691 else
10692   echo "$as_me:$LINENO: result: no" >&5
10693 echo "${ECHO_T}no" >&6
10694 fi
10695
10696   done
10697 fi
10698
10699 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10700   for ncn_progname in strip; do
10701     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10702 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10703     if test -x $with_build_time_tools/${ncn_progname}; then
10704       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10705       echo "$as_me:$LINENO: result: yes" >&5
10706 echo "${ECHO_T}yes" >&6
10707       break
10708     else
10709       echo "$as_me:$LINENO: result: no" >&5
10710 echo "${ECHO_T}no" >&6
10711     fi
10712   done
10713 fi
10714
10715 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10716   for ncn_progname in strip; do
10717     if test -n "$ncn_target_tool_prefix"; then
10718       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10719 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10720 echo "$as_me:$LINENO: checking for $ac_word" >&5
10721 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10722 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10723   echo $ECHO_N "(cached) $ECHO_C" >&6
10724 else
10725   if test -n "$STRIP_FOR_TARGET"; then
10726   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10727 else
10728 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10729 for as_dir in $PATH
10730 do
10731   IFS=$as_save_IFS
10732   test -z "$as_dir" && as_dir=.
10733   for ac_exec_ext in '' $ac_executable_extensions; do
10734   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10735     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10736     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10737     break 2
10738   fi
10739 done
10740 done
10741
10742 fi
10743 fi
10744 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10745 if test -n "$STRIP_FOR_TARGET"; then
10746   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10747 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10748 else
10749   echo "$as_me:$LINENO: result: no" >&5
10750 echo "${ECHO_T}no" >&6
10751 fi
10752
10753     fi
10754     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10755       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10756 set dummy ${ncn_progname}; 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_prog_STRIP_FOR_TARGET+set}" = set; then
10760   echo $ECHO_N "(cached) $ECHO_C" >&6
10761 else
10762   if test -n "$STRIP_FOR_TARGET"; then
10763   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10764 else
10765 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10766 for as_dir in $PATH
10767 do
10768   IFS=$as_save_IFS
10769   test -z "$as_dir" && as_dir=.
10770   for ac_exec_ext in '' $ac_executable_extensions; do
10771   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10772     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10773     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10774     break 2
10775   fi
10776 done
10777 done
10778
10779 fi
10780 fi
10781 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10782 if test -n "$STRIP_FOR_TARGET"; then
10783   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10784 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10785 else
10786   echo "$as_me:$LINENO: result: no" >&5
10787 echo "${ECHO_T}no" >&6
10788 fi
10789
10790     fi
10791     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10792   done
10793 fi
10794
10795 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10796   set dummy strip
10797   if test $build = $target ; then
10798     STRIP_FOR_TARGET="$2"
10799   else
10800     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10801   fi
10802 else
10803   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10804 fi
10805
10806 else
10807   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10808 fi
10809
10810
10811
10812
10813 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10814   if test -n "$with_build_time_tools"; then
10815     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10816 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10817     if test -x $with_build_time_tools/windres; then
10818       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10819       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10820       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10821 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10822     else
10823       echo "$as_me:$LINENO: result: no" >&5
10824 echo "${ECHO_T}no" >&6
10825     fi
10826   elif test $build != $host && test $have_gcc_for_target = yes; then
10827     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10828     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10829     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10830   fi
10831 fi
10832 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10833   # Extract the first word of "windres", so it can be a program name with args.
10834 set dummy windres; ac_word=$2
10835 echo "$as_me:$LINENO: checking for $ac_word" >&5
10836 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10837 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10838   echo $ECHO_N "(cached) $ECHO_C" >&6
10839 else
10840   case $WINDRES_FOR_TARGET in
10841   [\\/]* | ?:[\\/]*)
10842   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10843   ;;
10844   *)
10845   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10846 for as_dir in $gcc_cv_tool_dirs
10847 do
10848   IFS=$as_save_IFS
10849   test -z "$as_dir" && as_dir=.
10850   for ac_exec_ext in '' $ac_executable_extensions; do
10851   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10852     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10853     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10854     break 2
10855   fi
10856 done
10857 done
10858
10859   ;;
10860 esac
10861 fi
10862 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10863
10864 if test -n "$WINDRES_FOR_TARGET"; then
10865   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10866 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10867 else
10868   echo "$as_me:$LINENO: result: no" >&5
10869 echo "${ECHO_T}no" >&6
10870 fi
10871
10872 fi
10873 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10874
10875
10876 if test -n "$WINDRES_FOR_TARGET"; then
10877   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10878 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10879   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10880 fi
10881
10882 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10883   for ncn_progname in windres; do
10884     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10885 set dummy ${ncn_progname}; ac_word=$2
10886 echo "$as_me:$LINENO: checking for $ac_word" >&5
10887 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10888 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10889   echo $ECHO_N "(cached) $ECHO_C" >&6
10890 else
10891   if test -n "$WINDRES_FOR_TARGET"; then
10892   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10893 else
10894 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10895 for as_dir in $PATH
10896 do
10897   IFS=$as_save_IFS
10898   test -z "$as_dir" && as_dir=.
10899   for ac_exec_ext in '' $ac_executable_extensions; do
10900   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10901     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10902     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10903     break 2
10904   fi
10905 done
10906 done
10907
10908 fi
10909 fi
10910 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10911 if test -n "$WINDRES_FOR_TARGET"; then
10912   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10913 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10914 else
10915   echo "$as_me:$LINENO: result: no" >&5
10916 echo "${ECHO_T}no" >&6
10917 fi
10918
10919   done
10920 fi
10921
10922 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10923   for ncn_progname in windres; do
10924     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10925 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10926     if test -x $with_build_time_tools/${ncn_progname}; then
10927       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10928       echo "$as_me:$LINENO: result: yes" >&5
10929 echo "${ECHO_T}yes" >&6
10930       break
10931     else
10932       echo "$as_me:$LINENO: result: no" >&5
10933 echo "${ECHO_T}no" >&6
10934     fi
10935   done
10936 fi
10937
10938 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10939   for ncn_progname in windres; do
10940     if test -n "$ncn_target_tool_prefix"; then
10941       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10942 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10943 echo "$as_me:$LINENO: checking for $ac_word" >&5
10944 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10945 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10946   echo $ECHO_N "(cached) $ECHO_C" >&6
10947 else
10948   if test -n "$WINDRES_FOR_TARGET"; then
10949   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10950 else
10951 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10952 for as_dir in $PATH
10953 do
10954   IFS=$as_save_IFS
10955   test -z "$as_dir" && as_dir=.
10956   for ac_exec_ext in '' $ac_executable_extensions; do
10957   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10958     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10959     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10960     break 2
10961   fi
10962 done
10963 done
10964
10965 fi
10966 fi
10967 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10968 if test -n "$WINDRES_FOR_TARGET"; then
10969   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10970 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10971 else
10972   echo "$as_me:$LINENO: result: no" >&5
10973 echo "${ECHO_T}no" >&6
10974 fi
10975
10976     fi
10977     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10978       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10979 set dummy ${ncn_progname}; 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_prog_WINDRES_FOR_TARGET+set}" = set; then
10983   echo $ECHO_N "(cached) $ECHO_C" >&6
10984 else
10985   if test -n "$WINDRES_FOR_TARGET"; then
10986   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10987 else
10988 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10989 for as_dir in $PATH
10990 do
10991   IFS=$as_save_IFS
10992   test -z "$as_dir" && as_dir=.
10993   for ac_exec_ext in '' $ac_executable_extensions; do
10994   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10995     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10996     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10997     break 2
10998   fi
10999 done
11000 done
11001
11002 fi
11003 fi
11004 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11005 if test -n "$WINDRES_FOR_TARGET"; then
11006   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11007 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11008 else
11009   echo "$as_me:$LINENO: result: no" >&5
11010 echo "${ECHO_T}no" >&6
11011 fi
11012
11013     fi
11014     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11015   done
11016 fi
11017
11018 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11019   set dummy windres
11020   if test $build = $target ; then
11021     WINDRES_FOR_TARGET="$2"
11022   else
11023     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11024   fi
11025 else
11026   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11027 fi
11028
11029 else
11030   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11031 fi
11032
11033
11034
11035
11036 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11037   if test -n "$with_build_time_tools"; then
11038     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11039 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11040     if test -x $with_build_time_tools/windmc; then
11041       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11042       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11043       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11044 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11045     else
11046       echo "$as_me:$LINENO: result: no" >&5
11047 echo "${ECHO_T}no" >&6
11048     fi
11049   elif test $build != $host && test $have_gcc_for_target = yes; then
11050     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11051     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11052     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11053   fi
11054 fi
11055 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11056   # Extract the first word of "windmc", so it can be a program name with args.
11057 set dummy windmc; ac_word=$2
11058 echo "$as_me:$LINENO: checking for $ac_word" >&5
11059 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11060 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11061   echo $ECHO_N "(cached) $ECHO_C" >&6
11062 else
11063   case $WINDMC_FOR_TARGET in
11064   [\\/]* | ?:[\\/]*)
11065   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11066   ;;
11067   *)
11068   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11069 for as_dir in $gcc_cv_tool_dirs
11070 do
11071   IFS=$as_save_IFS
11072   test -z "$as_dir" && as_dir=.
11073   for ac_exec_ext in '' $ac_executable_extensions; do
11074   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11075     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11076     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11077     break 2
11078   fi
11079 done
11080 done
11081
11082   ;;
11083 esac
11084 fi
11085 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11086
11087 if test -n "$WINDMC_FOR_TARGET"; then
11088   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11089 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11090 else
11091   echo "$as_me:$LINENO: result: no" >&5
11092 echo "${ECHO_T}no" >&6
11093 fi
11094
11095 fi
11096 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11097
11098
11099 if test -n "$WINDMC_FOR_TARGET"; then
11100   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11101 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11102   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11103 fi
11104
11105 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11106   for ncn_progname in windmc; do
11107     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11108 set dummy ${ncn_progname}; ac_word=$2
11109 echo "$as_me:$LINENO: checking for $ac_word" >&5
11110 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11111 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11112   echo $ECHO_N "(cached) $ECHO_C" >&6
11113 else
11114   if test -n "$WINDMC_FOR_TARGET"; then
11115   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11116 else
11117 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11118 for as_dir in $PATH
11119 do
11120   IFS=$as_save_IFS
11121   test -z "$as_dir" && as_dir=.
11122   for ac_exec_ext in '' $ac_executable_extensions; do
11123   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11124     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11125     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11126     break 2
11127   fi
11128 done
11129 done
11130
11131 fi
11132 fi
11133 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11134 if test -n "$WINDMC_FOR_TARGET"; then
11135   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11136 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11137 else
11138   echo "$as_me:$LINENO: result: no" >&5
11139 echo "${ECHO_T}no" >&6
11140 fi
11141
11142   done
11143 fi
11144
11145 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11146   for ncn_progname in windmc; do
11147     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11148 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11149     if test -x $with_build_time_tools/${ncn_progname}; then
11150       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11151       echo "$as_me:$LINENO: result: yes" >&5
11152 echo "${ECHO_T}yes" >&6
11153       break
11154     else
11155       echo "$as_me:$LINENO: result: no" >&5
11156 echo "${ECHO_T}no" >&6
11157     fi
11158   done
11159 fi
11160
11161 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11162   for ncn_progname in windmc; do
11163     if test -n "$ncn_target_tool_prefix"; then
11164       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11165 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11166 echo "$as_me:$LINENO: checking for $ac_word" >&5
11167 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11168 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11169   echo $ECHO_N "(cached) $ECHO_C" >&6
11170 else
11171   if test -n "$WINDMC_FOR_TARGET"; then
11172   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11173 else
11174 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11175 for as_dir in $PATH
11176 do
11177   IFS=$as_save_IFS
11178   test -z "$as_dir" && as_dir=.
11179   for ac_exec_ext in '' $ac_executable_extensions; do
11180   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11181     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11182     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11183     break 2
11184   fi
11185 done
11186 done
11187
11188 fi
11189 fi
11190 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11191 if test -n "$WINDMC_FOR_TARGET"; then
11192   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11193 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11194 else
11195   echo "$as_me:$LINENO: result: no" >&5
11196 echo "${ECHO_T}no" >&6
11197 fi
11198
11199     fi
11200     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11201       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11202 set dummy ${ncn_progname}; ac_word=$2
11203 echo "$as_me:$LINENO: checking for $ac_word" >&5
11204 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11205 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11206   echo $ECHO_N "(cached) $ECHO_C" >&6
11207 else
11208   if test -n "$WINDMC_FOR_TARGET"; then
11209   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11210 else
11211 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11212 for as_dir in $PATH
11213 do
11214   IFS=$as_save_IFS
11215   test -z "$as_dir" && as_dir=.
11216   for ac_exec_ext in '' $ac_executable_extensions; do
11217   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11218     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11219     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11220     break 2
11221   fi
11222 done
11223 done
11224
11225 fi
11226 fi
11227 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11228 if test -n "$WINDMC_FOR_TARGET"; then
11229   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11230 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11231 else
11232   echo "$as_me:$LINENO: result: no" >&5
11233 echo "${ECHO_T}no" >&6
11234 fi
11235
11236     fi
11237     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11238   done
11239 fi
11240
11241 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11242   set dummy windmc
11243   if test $build = $target ; then
11244     WINDMC_FOR_TARGET="$2"
11245   else
11246     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11247   fi
11248 else
11249   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11250 fi
11251
11252 else
11253   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11254 fi
11255
11256
11257 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11258
11259 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11260 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11261 if test "x${build}" != "x${host}" ; then
11262   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11263     # We already found the complete path
11264     ac_dir=`dirname $AR_FOR_TARGET`
11265     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11266 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11267   else
11268     # Canadian cross, just use what we found
11269     echo "$as_me:$LINENO: result: pre-installed" >&5
11270 echo "${ECHO_T}pre-installed" >&6
11271   fi
11272 else
11273   ok=yes
11274   case " ${configdirs} " in
11275     *" binutils "*) ;;
11276     *) ok=no ;;
11277   esac
11278
11279   if test $ok = yes; then
11280     # An in-tree tool is available and we can use it
11281     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11282     echo "$as_me:$LINENO: result: just compiled" >&5
11283 echo "${ECHO_T}just compiled" >&6
11284   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11285     # We already found the complete path
11286     ac_dir=`dirname $AR_FOR_TARGET`
11287     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11288 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11289   elif test "x$target" = "x$host"; then
11290     # We can use an host tool
11291     AR_FOR_TARGET='$(AR)'
11292     echo "$as_me:$LINENO: result: host tool" >&5
11293 echo "${ECHO_T}host tool" >&6
11294   else
11295     # We need a cross tool
11296     echo "$as_me:$LINENO: result: pre-installed" >&5
11297 echo "${ECHO_T}pre-installed" >&6
11298   fi
11299 fi
11300
11301 echo "$as_me:$LINENO: checking where to find the target as" >&5
11302 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11303 if test "x${build}" != "x${host}" ; then
11304   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11305     # We already found the complete path
11306     ac_dir=`dirname $AS_FOR_TARGET`
11307     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11308 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11309   else
11310     # Canadian cross, just use what we found
11311     echo "$as_me:$LINENO: result: pre-installed" >&5
11312 echo "${ECHO_T}pre-installed" >&6
11313   fi
11314 else
11315   ok=yes
11316   case " ${configdirs} " in
11317     *" gas "*) ;;
11318     *) ok=no ;;
11319   esac
11320
11321   if test $ok = yes; then
11322     # An in-tree tool is available and we can use it
11323     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11324     echo "$as_me:$LINENO: result: just compiled" >&5
11325 echo "${ECHO_T}just compiled" >&6
11326   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11327     # We already found the complete path
11328     ac_dir=`dirname $AS_FOR_TARGET`
11329     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11330 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11331   elif test "x$target" = "x$host"; then
11332     # We can use an host tool
11333     AS_FOR_TARGET='$(AS)'
11334     echo "$as_me:$LINENO: result: host tool" >&5
11335 echo "${ECHO_T}host tool" >&6
11336   else
11337     # We need a cross tool
11338     echo "$as_me:$LINENO: result: pre-installed" >&5
11339 echo "${ECHO_T}pre-installed" >&6
11340   fi
11341 fi
11342
11343 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11344 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11345 if test "x${build}" != "x${host}" ; then
11346   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11347     # We already found the complete path
11348     ac_dir=`dirname $CC_FOR_TARGET`
11349     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11350 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11351   else
11352     # Canadian cross, just use what we found
11353     echo "$as_me:$LINENO: result: pre-installed" >&5
11354 echo "${ECHO_T}pre-installed" >&6
11355   fi
11356 else
11357   ok=yes
11358   case " ${configdirs} " in
11359     *" gcc "*) ;;
11360     *) ok=no ;;
11361   esac
11362
11363   if test $ok = yes; then
11364     # An in-tree tool is available and we can use it
11365     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11366     echo "$as_me:$LINENO: result: just compiled" >&5
11367 echo "${ECHO_T}just compiled" >&6
11368   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11369     # We already found the complete path
11370     ac_dir=`dirname $CC_FOR_TARGET`
11371     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11372 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11373   elif test "x$target" = "x$host"; then
11374     # We can use an host tool
11375     CC_FOR_TARGET='$(CC)'
11376     echo "$as_me:$LINENO: result: host tool" >&5
11377 echo "${ECHO_T}host tool" >&6
11378   else
11379     # We need a cross tool
11380     echo "$as_me:$LINENO: result: pre-installed" >&5
11381 echo "${ECHO_T}pre-installed" >&6
11382   fi
11383 fi
11384
11385 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11386 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11387 if test "x${build}" != "x${host}" ; then
11388   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11389     # We already found the complete path
11390     ac_dir=`dirname $CXX_FOR_TARGET`
11391     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11392 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11393   else
11394     # Canadian cross, just use what we found
11395     echo "$as_me:$LINENO: result: pre-installed" >&5
11396 echo "${ECHO_T}pre-installed" >&6
11397   fi
11398 else
11399   ok=yes
11400   case " ${configdirs} " in
11401     *" gcc "*) ;;
11402     *) ok=no ;;
11403   esac
11404   case ,${enable_languages}, in
11405     *,c++,*) ;;
11406     *) ok=no ;;
11407   esac
11408   if test $ok = yes; then
11409     # An in-tree tool is available and we can use it
11410     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'
11411     echo "$as_me:$LINENO: result: just compiled" >&5
11412 echo "${ECHO_T}just compiled" >&6
11413   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11414     # We already found the complete path
11415     ac_dir=`dirname $CXX_FOR_TARGET`
11416     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11417 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11418   elif test "x$target" = "x$host"; then
11419     # We can use an host tool
11420     CXX_FOR_TARGET='$(CXX)'
11421     echo "$as_me:$LINENO: result: host tool" >&5
11422 echo "${ECHO_T}host tool" >&6
11423   else
11424     # We need a cross tool
11425     echo "$as_me:$LINENO: result: pre-installed" >&5
11426 echo "${ECHO_T}pre-installed" >&6
11427   fi
11428 fi
11429
11430 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11431 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11432 if test "x${build}" != "x${host}" ; then
11433   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11434     # We already found the complete path
11435     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11436     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11437 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11438   else
11439     # Canadian cross, just use what we found
11440     echo "$as_me:$LINENO: result: pre-installed" >&5
11441 echo "${ECHO_T}pre-installed" >&6
11442   fi
11443 else
11444   ok=yes
11445   case " ${configdirs} " in
11446     *" gcc "*) ;;
11447     *) ok=no ;;
11448   esac
11449   case ,${enable_languages}, in
11450     *,c++,*) ;;
11451     *) ok=no ;;
11452   esac
11453   if test $ok = yes; then
11454     # An in-tree tool is available and we can use it
11455     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'
11456     echo "$as_me:$LINENO: result: just compiled" >&5
11457 echo "${ECHO_T}just compiled" >&6
11458   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11459     # We already found the complete path
11460     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11461     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11462 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11463   elif test "x$target" = "x$host"; then
11464     # We can use an host tool
11465     RAW_CXX_FOR_TARGET='$(CXX)'
11466     echo "$as_me:$LINENO: result: host tool" >&5
11467 echo "${ECHO_T}host tool" >&6
11468   else
11469     # We need a cross tool
11470     echo "$as_me:$LINENO: result: pre-installed" >&5
11471 echo "${ECHO_T}pre-installed" >&6
11472   fi
11473 fi
11474
11475 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11476 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11477 if test "x${build}" != "x${host}" ; then
11478   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11479     # We already found the complete path
11480     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11481     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11482 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11483   else
11484     # Canadian cross, just use what we found
11485     echo "$as_me:$LINENO: result: pre-installed" >&5
11486 echo "${ECHO_T}pre-installed" >&6
11487   fi
11488 else
11489   ok=yes
11490   case " ${configdirs} " in
11491     *" binutils "*) ;;
11492     *) ok=no ;;
11493   esac
11494
11495   if test $ok = yes; then
11496     # An in-tree tool is available and we can use it
11497     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11498     echo "$as_me:$LINENO: result: just compiled" >&5
11499 echo "${ECHO_T}just compiled" >&6
11500   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11501     # We already found the complete path
11502     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11503     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11504 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11505   elif test "x$target" = "x$host"; then
11506     # We can use an host tool
11507     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11508     echo "$as_me:$LINENO: result: host tool" >&5
11509 echo "${ECHO_T}host tool" >&6
11510   else
11511     # We need a cross tool
11512     echo "$as_me:$LINENO: result: pre-installed" >&5
11513 echo "${ECHO_T}pre-installed" >&6
11514   fi
11515 fi
11516
11517 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11518 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11519 if test "x${build}" != "x${host}" ; then
11520   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11521     # We already found the complete path
11522     ac_dir=`dirname $GCC_FOR_TARGET`
11523     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11524 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11525   else
11526     # Canadian cross, just use what we found
11527     echo "$as_me:$LINENO: result: pre-installed" >&5
11528 echo "${ECHO_T}pre-installed" >&6
11529   fi
11530 else
11531   ok=yes
11532   case " ${configdirs} " in
11533     *" gcc "*) ;;
11534     *) ok=no ;;
11535   esac
11536
11537   if test $ok = yes; then
11538     # An in-tree tool is available and we can use it
11539     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11540     echo "$as_me:$LINENO: result: just compiled" >&5
11541 echo "${ECHO_T}just compiled" >&6
11542   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11543     # We already found the complete path
11544     ac_dir=`dirname $GCC_FOR_TARGET`
11545     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11546 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11547   elif test "x$target" = "x$host"; then
11548     # We can use an host tool
11549     GCC_FOR_TARGET='$()'
11550     echo "$as_me:$LINENO: result: host tool" >&5
11551 echo "${ECHO_T}host tool" >&6
11552   else
11553     # We need a cross tool
11554     echo "$as_me:$LINENO: result: pre-installed" >&5
11555 echo "${ECHO_T}pre-installed" >&6
11556   fi
11557 fi
11558
11559 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11560 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11561 if test "x${build}" != "x${host}" ; then
11562   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11563     # We already found the complete path
11564     ac_dir=`dirname $GCJ_FOR_TARGET`
11565     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11566 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11567   else
11568     # Canadian cross, just use what we found
11569     echo "$as_me:$LINENO: result: pre-installed" >&5
11570 echo "${ECHO_T}pre-installed" >&6
11571   fi
11572 else
11573   ok=yes
11574   case " ${configdirs} " in
11575     *" gcc "*) ;;
11576     *) ok=no ;;
11577   esac
11578   case ,${enable_languages}, in
11579     *,java,*) ;;
11580     *) ok=no ;;
11581   esac
11582   if test $ok = yes; then
11583     # An in-tree tool is available and we can use it
11584     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11585     echo "$as_me:$LINENO: result: just compiled" >&5
11586 echo "${ECHO_T}just compiled" >&6
11587   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11588     # We already found the complete path
11589     ac_dir=`dirname $GCJ_FOR_TARGET`
11590     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11591 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11592   elif test "x$target" = "x$host"; then
11593     # We can use an host tool
11594     GCJ_FOR_TARGET='$(GCJ)'
11595     echo "$as_me:$LINENO: result: host tool" >&5
11596 echo "${ECHO_T}host tool" >&6
11597   else
11598     # We need a cross tool
11599     echo "$as_me:$LINENO: result: pre-installed" >&5
11600 echo "${ECHO_T}pre-installed" >&6
11601   fi
11602 fi
11603
11604 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11605 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11606 if test "x${build}" != "x${host}" ; then
11607   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11608     # We already found the complete path
11609     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11610     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11611 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11612   else
11613     # Canadian cross, just use what we found
11614     echo "$as_me:$LINENO: result: pre-installed" >&5
11615 echo "${ECHO_T}pre-installed" >&6
11616   fi
11617 else
11618   ok=yes
11619   case " ${configdirs} " in
11620     *" gcc "*) ;;
11621     *) ok=no ;;
11622   esac
11623   case ,${enable_languages}, in
11624     *,fortran,*) ;;
11625     *) ok=no ;;
11626   esac
11627   if test $ok = yes; then
11628     # An in-tree tool is available and we can use it
11629     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11630     echo "$as_me:$LINENO: result: just compiled" >&5
11631 echo "${ECHO_T}just compiled" >&6
11632   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11633     # We already found the complete path
11634     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11635     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11636 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11637   elif test "x$target" = "x$host"; then
11638     # We can use an host tool
11639     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11640     echo "$as_me:$LINENO: result: host tool" >&5
11641 echo "${ECHO_T}host tool" >&6
11642   else
11643     # We need a cross tool
11644     echo "$as_me:$LINENO: result: pre-installed" >&5
11645 echo "${ECHO_T}pre-installed" >&6
11646   fi
11647 fi
11648
11649 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11650 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11651 if test "x${build}" != "x${host}" ; then
11652   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11653     # We already found the complete path
11654     ac_dir=`dirname $LD_FOR_TARGET`
11655     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11656 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11657   else
11658     # Canadian cross, just use what we found
11659     echo "$as_me:$LINENO: result: pre-installed" >&5
11660 echo "${ECHO_T}pre-installed" >&6
11661   fi
11662 else
11663   ok=yes
11664   case " ${configdirs} " in
11665     *" ld "*) ;;
11666     *) ok=no ;;
11667   esac
11668
11669   if test $ok = yes; then
11670     # An in-tree tool is available and we can use it
11671     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11672     echo "$as_me:$LINENO: result: just compiled" >&5
11673 echo "${ECHO_T}just compiled" >&6
11674   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11675     # We already found the complete path
11676     ac_dir=`dirname $LD_FOR_TARGET`
11677     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11678 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11679   elif test "x$target" = "x$host"; then
11680     # We can use an host tool
11681     LD_FOR_TARGET='$(LD)'
11682     echo "$as_me:$LINENO: result: host tool" >&5
11683 echo "${ECHO_T}host tool" >&6
11684   else
11685     # We need a cross tool
11686     echo "$as_me:$LINENO: result: pre-installed" >&5
11687 echo "${ECHO_T}pre-installed" >&6
11688   fi
11689 fi
11690
11691 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11692 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11693 if test "x${build}" != "x${host}" ; then
11694   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11695     # We already found the complete path
11696     ac_dir=`dirname $LIPO_FOR_TARGET`
11697     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11698 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11699   else
11700     # Canadian cross, just use what we found
11701     echo "$as_me:$LINENO: result: pre-installed" >&5
11702 echo "${ECHO_T}pre-installed" >&6
11703   fi
11704 else
11705   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11706     # We already found the complete path
11707     ac_dir=`dirname $LIPO_FOR_TARGET`
11708     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11709 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11710   elif test "x$target" = "x$host"; then
11711     # We can use an host tool
11712     LIPO_FOR_TARGET='$(LIPO)'
11713     echo "$as_me:$LINENO: result: host tool" >&5
11714 echo "${ECHO_T}host tool" >&6
11715   else
11716     # We need a cross tool
11717     echo "$as_me:$LINENO: result: pre-installed" >&5
11718 echo "${ECHO_T}pre-installed" >&6
11719   fi
11720 fi
11721
11722 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11723 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11724 if test "x${build}" != "x${host}" ; then
11725   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11726     # We already found the complete path
11727     ac_dir=`dirname $NM_FOR_TARGET`
11728     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11729 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11730   else
11731     # Canadian cross, just use what we found
11732     echo "$as_me:$LINENO: result: pre-installed" >&5
11733 echo "${ECHO_T}pre-installed" >&6
11734   fi
11735 else
11736   ok=yes
11737   case " ${configdirs} " in
11738     *" binutils "*) ;;
11739     *) ok=no ;;
11740   esac
11741
11742   if test $ok = yes; then
11743     # An in-tree tool is available and we can use it
11744     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11745     echo "$as_me:$LINENO: result: just compiled" >&5
11746 echo "${ECHO_T}just compiled" >&6
11747   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11748     # We already found the complete path
11749     ac_dir=`dirname $NM_FOR_TARGET`
11750     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11751 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11752   elif test "x$target" = "x$host"; then
11753     # We can use an host tool
11754     NM_FOR_TARGET='$(NM)'
11755     echo "$as_me:$LINENO: result: host tool" >&5
11756 echo "${ECHO_T}host tool" >&6
11757   else
11758     # We need a cross tool
11759     echo "$as_me:$LINENO: result: pre-installed" >&5
11760 echo "${ECHO_T}pre-installed" >&6
11761   fi
11762 fi
11763
11764 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11765 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11766 if test "x${build}" != "x${host}" ; then
11767   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11768     # We already found the complete path
11769     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11770     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11771 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11772   else
11773     # Canadian cross, just use what we found
11774     echo "$as_me:$LINENO: result: pre-installed" >&5
11775 echo "${ECHO_T}pre-installed" >&6
11776   fi
11777 else
11778   ok=yes
11779   case " ${configdirs} " in
11780     *" binutils "*) ;;
11781     *) ok=no ;;
11782   esac
11783
11784   if test $ok = yes; then
11785     # An in-tree tool is available and we can use it
11786     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11787     echo "$as_me:$LINENO: result: just compiled" >&5
11788 echo "${ECHO_T}just compiled" >&6
11789   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11790     # We already found the complete path
11791     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11792     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11793 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11794   elif test "x$target" = "x$host"; then
11795     # We can use an host tool
11796     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11797     echo "$as_me:$LINENO: result: host tool" >&5
11798 echo "${ECHO_T}host tool" >&6
11799   else
11800     # We need a cross tool
11801     echo "$as_me:$LINENO: result: pre-installed" >&5
11802 echo "${ECHO_T}pre-installed" >&6
11803   fi
11804 fi
11805
11806 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11807 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11808 if test "x${build}" != "x${host}" ; then
11809   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11810     # We already found the complete path
11811     ac_dir=`dirname $RANLIB_FOR_TARGET`
11812     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11813 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11814   else
11815     # Canadian cross, just use what we found
11816     echo "$as_me:$LINENO: result: pre-installed" >&5
11817 echo "${ECHO_T}pre-installed" >&6
11818   fi
11819 else
11820   ok=yes
11821   case " ${configdirs} " in
11822     *" binutils "*) ;;
11823     *) ok=no ;;
11824   esac
11825
11826   if test $ok = yes; then
11827     # An in-tree tool is available and we can use it
11828     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11829     echo "$as_me:$LINENO: result: just compiled" >&5
11830 echo "${ECHO_T}just compiled" >&6
11831   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11832     # We already found the complete path
11833     ac_dir=`dirname $RANLIB_FOR_TARGET`
11834     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11835 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11836   elif test "x$target" = "x$host"; then
11837     # We can use an host tool
11838     RANLIB_FOR_TARGET='$(RANLIB)'
11839     echo "$as_me:$LINENO: result: host tool" >&5
11840 echo "${ECHO_T}host tool" >&6
11841   else
11842     # We need a cross tool
11843     echo "$as_me:$LINENO: result: pre-installed" >&5
11844 echo "${ECHO_T}pre-installed" >&6
11845   fi
11846 fi
11847
11848 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11849 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11850 if test "x${build}" != "x${host}" ; then
11851   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11852     # We already found the complete path
11853     ac_dir=`dirname $STRIP_FOR_TARGET`
11854     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11855 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11856   else
11857     # Canadian cross, just use what we found
11858     echo "$as_me:$LINENO: result: pre-installed" >&5
11859 echo "${ECHO_T}pre-installed" >&6
11860   fi
11861 else
11862   ok=yes
11863   case " ${configdirs} " in
11864     *" binutils "*) ;;
11865     *) ok=no ;;
11866   esac
11867
11868   if test $ok = yes; then
11869     # An in-tree tool is available and we can use it
11870     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11871     echo "$as_me:$LINENO: result: just compiled" >&5
11872 echo "${ECHO_T}just compiled" >&6
11873   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11874     # We already found the complete path
11875     ac_dir=`dirname $STRIP_FOR_TARGET`
11876     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11877 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11878   elif test "x$target" = "x$host"; then
11879     # We can use an host tool
11880     STRIP_FOR_TARGET='$(STRIP)'
11881     echo "$as_me:$LINENO: result: host tool" >&5
11882 echo "${ECHO_T}host tool" >&6
11883   else
11884     # We need a cross tool
11885     echo "$as_me:$LINENO: result: pre-installed" >&5
11886 echo "${ECHO_T}pre-installed" >&6
11887   fi
11888 fi
11889
11890 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11891 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11892 if test "x${build}" != "x${host}" ; then
11893   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11894     # We already found the complete path
11895     ac_dir=`dirname $WINDRES_FOR_TARGET`
11896     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11897 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11898   else
11899     # Canadian cross, just use what we found
11900     echo "$as_me:$LINENO: result: pre-installed" >&5
11901 echo "${ECHO_T}pre-installed" >&6
11902   fi
11903 else
11904   ok=yes
11905   case " ${configdirs} " in
11906     *" binutils "*) ;;
11907     *) ok=no ;;
11908   esac
11909
11910   if test $ok = yes; then
11911     # An in-tree tool is available and we can use it
11912     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11913     echo "$as_me:$LINENO: result: just compiled" >&5
11914 echo "${ECHO_T}just compiled" >&6
11915   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11916     # We already found the complete path
11917     ac_dir=`dirname $WINDRES_FOR_TARGET`
11918     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11919 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11920   elif test "x$target" = "x$host"; then
11921     # We can use an host tool
11922     WINDRES_FOR_TARGET='$(WINDRES)'
11923     echo "$as_me:$LINENO: result: host tool" >&5
11924 echo "${ECHO_T}host tool" >&6
11925   else
11926     # We need a cross tool
11927     echo "$as_me:$LINENO: result: pre-installed" >&5
11928 echo "${ECHO_T}pre-installed" >&6
11929   fi
11930 fi
11931
11932 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
11933 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
11934 if test "x${build}" != "x${host}" ; then
11935   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11936     # We already found the complete path
11937     ac_dir=`dirname $WINDMC_FOR_TARGET`
11938     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11939 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11940   else
11941     # Canadian cross, just use what we found
11942     echo "$as_me:$LINENO: result: pre-installed" >&5
11943 echo "${ECHO_T}pre-installed" >&6
11944   fi
11945 else
11946   ok=yes
11947   case " ${configdirs} " in
11948     *" binutils "*) ;;
11949     *) ok=no ;;
11950   esac
11951
11952   if test $ok = yes; then
11953     # An in-tree tool is available and we can use it
11954     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
11955     echo "$as_me:$LINENO: result: just compiled" >&5
11956 echo "${ECHO_T}just compiled" >&6
11957   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11958     # We already found the complete path
11959     ac_dir=`dirname $WINDMC_FOR_TARGET`
11960     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11961 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11962   elif test "x$target" = "x$host"; then
11963     # We can use an host tool
11964     WINDMC_FOR_TARGET='$(WINDMC)'
11965     echo "$as_me:$LINENO: result: host tool" >&5
11966 echo "${ECHO_T}host tool" >&6
11967   else
11968     # We need a cross tool
11969     echo "$as_me:$LINENO: result: pre-installed" >&5
11970 echo "${ECHO_T}pre-installed" >&6
11971   fi
11972 fi
11973
11974
11975
11976
11977
11978 # Certain tools may need extra flags.
11979 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11980 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11981 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11982
11983 # When building target libraries, except in a Canadian cross, we use
11984 # the same toolchain as the compiler we just built.
11985 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11986 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11987 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11988 if test $host = $build; then
11989   case " $configdirs " in
11990     *" gcc "*)
11991       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11992       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11993       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11994       ;;
11995   esac
11996 fi
11997
11998
11999
12000
12001
12002 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12003 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12004 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12005 if test "${enable_maintainer_mode+set}" = set; then
12006   enableval="$enable_maintainer_mode"
12007   USE_MAINTAINER_MODE=$enableval
12008 else
12009   USE_MAINTAINER_MODE=no
12010 fi;
12011 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12012 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12013
12014
12015 if test "$USE_MAINTAINER_MODE" = yes; then
12016   MAINTAINER_MODE_TRUE=
12017   MAINTAINER_MODE_FALSE='#'
12018 else
12019   MAINTAINER_MODE_TRUE='#'
12020   MAINTAINER_MODE_FALSE=
12021 fi
12022 MAINT=$MAINTAINER_MODE_TRUE
12023
12024 # ---------------------
12025 # GCC bootstrap support
12026 # ---------------------
12027
12028 # Stage specific cflags for build.
12029 stage1_cflags="-g"
12030 case $build in
12031   vax-*-*)
12032     case ${GCC} in
12033       yes) stage1_cflags="-g -Wa,-J" ;;
12034       *) stage1_cflags="-g -J" ;;
12035     esac ;;
12036 esac
12037
12038 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12039 if test "$GCC" = yes; then
12040   saved_CFLAGS="$CFLAGS"
12041
12042   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12043   CFLAGS="$CFLAGS -fkeep-inline-functions"
12044   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12045 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12046   cat >conftest.$ac_ext <<_ACEOF
12047 /* confdefs.h.  */
12048 _ACEOF
12049 cat confdefs.h >>conftest.$ac_ext
12050 cat >>conftest.$ac_ext <<_ACEOF
12051 /* end confdefs.h.  */
12052
12053 #if (__GNUC__ < 3) \
12054     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12055                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12056 #error http://gcc.gnu.org/PR29382
12057 #endif
12058
12059 int
12060 main ()
12061 {
12062
12063   ;
12064   return 0;
12065 }
12066 _ACEOF
12067 rm -f conftest.$ac_objext
12068 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12069   (eval $ac_compile) 2>conftest.er1
12070   ac_status=$?
12071   grep -v '^ *+' conftest.er1 >conftest.err
12072   rm -f conftest.er1
12073   cat conftest.err >&5
12074   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12075   (exit $ac_status); } &&
12076          { ac_try='test -z "$ac_c_werror_flag"
12077                          || test ! -s conftest.err'
12078   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12079   (eval $ac_try) 2>&5
12080   ac_status=$?
12081   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12082   (exit $ac_status); }; } &&
12083          { ac_try='test -s conftest.$ac_objext'
12084   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12085   (eval $ac_try) 2>&5
12086   ac_status=$?
12087   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12088   (exit $ac_status); }; }; then
12089   echo "$as_me:$LINENO: result: yes" >&5
12090 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12091 else
12092   echo "$as_me: failed program was:" >&5
12093 sed 's/^/| /' conftest.$ac_ext >&5
12094
12095 echo "$as_me:$LINENO: result: no" >&5
12096 echo "${ECHO_T}no" >&6
12097 fi
12098 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12099
12100   CFLAGS="$saved_CFLAGS"
12101 fi
12102
12103
12104
12105 # Enable --enable-checking in stage1 of the compiler.
12106 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12107 if test "${enable_stage1_checking+set}" = set; then
12108   enableval="$enable_stage1_checking"
12109   stage1_checking=--enable-checking=${enable_stage1_checking}
12110 else
12111   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12112   stage1_checking=--enable-checking=yes,types
12113 else
12114   stage1_checking=--enable-checking=$enable_checking,types
12115 fi
12116 fi;
12117
12118
12119 # Enable -Werror in bootstrap stage2 and later.
12120 # Check whether --enable-werror or --disable-werror was given.
12121 if test "${enable_werror+set}" = set; then
12122   enableval="$enable_werror"
12123
12124 else
12125   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12126   enable_werror=yes
12127 else
12128   enable_werror=no
12129 fi
12130 fi;
12131 case ${enable_werror} in
12132   yes) stage2_werror_flag="--enable-werror-always" ;;
12133   *) stage2_werror_flag="" ;;
12134 esac
12135
12136
12137 # Flags needed to enable html installing and building
12138
12139 # Check whether --with-datarootdir or --without-datarootdir was given.
12140 if test "${with_datarootdir+set}" = set; then
12141   withval="$with_datarootdir"
12142   datarootdir="\${prefix}/${withval}"
12143 else
12144   datarootdir="\${prefix}/share"
12145 fi;
12146
12147
12148 # Check whether --with-docdir or --without-docdir was given.
12149 if test "${with_docdir+set}" = set; then
12150   withval="$with_docdir"
12151   docdir="\${prefix}/${withval}"
12152 else
12153   docdir="\${datarootdir}/doc"
12154 fi;
12155
12156
12157 # Check whether --with-pdfdir or --without-pdfdir was given.
12158 if test "${with_pdfdir+set}" = set; then
12159   withval="$with_pdfdir"
12160   pdfdir="\${prefix}/${withval}"
12161 else
12162   pdfdir="\${docdir}"
12163 fi;
12164
12165
12166 # Check whether --with-htmldir or --without-htmldir was given.
12167 if test "${with_htmldir+set}" = set; then
12168   withval="$with_htmldir"
12169   htmldir="\${prefix}/${withval}"
12170 else
12171   htmldir="\${docdir}"
12172 fi;
12173
12174
12175
12176
12177
12178
12179           ac_config_files="$ac_config_files Makefile"
12180 cat >confcache <<\_ACEOF
12181 # This file is a shell script that caches the results of configure
12182 # tests run on this system so they can be shared between configure
12183 # scripts and configure runs, see configure's option --config-cache.
12184 # It is not useful on other systems.  If it contains results you don't
12185 # want to keep, you may remove or edit it.
12186 #
12187 # config.status only pays attention to the cache file if you give it
12188 # the --recheck option to rerun configure.
12189 #
12190 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12191 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12192 # following values.
12193
12194 _ACEOF
12195
12196 # The following way of writing the cache mishandles newlines in values,
12197 # but we know of no workaround that is simple, portable, and efficient.
12198 # So, don't put newlines in cache variables' values.
12199 # Ultrix sh set writes to stderr and can't be redirected directly,
12200 # and sets the high bit in the cache file unless we assign to the vars.
12201 {
12202   (set) 2>&1 |
12203     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12204     *ac_space=\ *)
12205       # `set' does not quote correctly, so add quotes (double-quote
12206       # substitution turns \\\\ into \\, and sed turns \\ into \).
12207       sed -n \
12208         "s/'/'\\\\''/g;
12209           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12210       ;;
12211     *)
12212       # `set' quotes correctly as required by POSIX, so do not add quotes.
12213       sed -n \
12214         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12215       ;;
12216     esac;
12217 } |
12218   sed '
12219      t clear
12220      : clear
12221      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12222      t end
12223      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12224      : end' >>confcache
12225 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12226   if test -w $cache_file; then
12227     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12228     cat confcache >$cache_file
12229   else
12230     echo "not updating unwritable cache $cache_file"
12231   fi
12232 fi
12233 rm -f confcache
12234
12235 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12236 # Let make expand exec_prefix.
12237 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12238
12239 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12240 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12241 # trailing colons and then remove the whole line if VPATH becomes empty
12242 # (actually we leave an empty line to preserve line numbers).
12243 if test "x$srcdir" = x.; then
12244   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12245 s/:*\$(srcdir):*/:/;
12246 s/:*\${srcdir}:*/:/;
12247 s/:*@srcdir@:*/:/;
12248 s/^\([^=]*=[     ]*\):*/\1/;
12249 s/:*$//;
12250 s/^[^=]*=[       ]*$//;
12251 }'
12252 fi
12253
12254 # Transform confdefs.h into DEFS.
12255 # Protect against shell expansion while executing Makefile rules.
12256 # Protect against Makefile macro expansion.
12257 #
12258 # If the first sed substitution is executed (which looks for macros that
12259 # take arguments), then we branch to the quote section.  Otherwise,
12260 # look for a macro that doesn't take arguments.
12261 cat >confdef2opt.sed <<\_ACEOF
12262 t clear
12263 : clear
12264 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12265 t quote
12266 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12267 t quote
12268 d
12269 : quote
12270 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12271 s,\[,\\&,g
12272 s,\],\\&,g
12273 s,\$,$$,g
12274 p
12275 _ACEOF
12276 # We use echo to avoid assuming a particular line-breaking character.
12277 # The extra dot is to prevent the shell from consuming trailing
12278 # line-breaks from the sub-command output.  A line-break within
12279 # single-quotes doesn't work because, if this script is created in a
12280 # platform that uses two characters for line-breaks (e.g., DOS), tr
12281 # would break.
12282 ac_LF_and_DOT=`echo; echo .`
12283 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12284 rm -f confdef2opt.sed
12285
12286
12287 ac_libobjs=
12288 ac_ltlibobjs=
12289 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12290   # 1. Remove the extension, and $U if already installed.
12291   ac_i=`echo "$ac_i" |
12292          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12293   # 2. Add them.
12294   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12295   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12296 done
12297 LIBOBJS=$ac_libobjs
12298
12299 LTLIBOBJS=$ac_ltlibobjs
12300
12301
12302
12303 : ${CONFIG_STATUS=./config.status}
12304 ac_clean_files_save=$ac_clean_files
12305 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12306 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12307 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12308 cat >$CONFIG_STATUS <<_ACEOF
12309 #! $SHELL
12310 # Generated by $as_me.
12311 # Run this file to recreate the current configuration.
12312 # Compiler output produced by configure, useful for debugging
12313 # configure, is in config.log if it exists.
12314
12315 debug=false
12316 ac_cs_recheck=false
12317 ac_cs_silent=false
12318 SHELL=\${CONFIG_SHELL-$SHELL}
12319 _ACEOF
12320
12321 cat >>$CONFIG_STATUS <<\_ACEOF
12322 ## --------------------- ##
12323 ## M4sh Initialization.  ##
12324 ## --------------------- ##
12325
12326 # Be Bourne compatible
12327 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12328   emulate sh
12329   NULLCMD=:
12330   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12331   # is contrary to our usage.  Disable this feature.
12332   alias -g '${1+"$@"}'='"$@"'
12333 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12334   set -o posix
12335 fi
12336 DUALCASE=1; export DUALCASE # for MKS sh
12337
12338 # Support unset when possible.
12339 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12340   as_unset=unset
12341 else
12342   as_unset=false
12343 fi
12344
12345
12346 # Work around bugs in pre-3.0 UWIN ksh.
12347 $as_unset ENV MAIL MAILPATH
12348 PS1='$ '
12349 PS2='> '
12350 PS4='+ '
12351
12352 # NLS nuisances.
12353 for as_var in \
12354   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12355   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12356   LC_TELEPHONE LC_TIME
12357 do
12358   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12359     eval $as_var=C; export $as_var
12360   else
12361     $as_unset $as_var
12362   fi
12363 done
12364
12365 # Required to use basename.
12366 if expr a : '\(a\)' >/dev/null 2>&1; then
12367   as_expr=expr
12368 else
12369   as_expr=false
12370 fi
12371
12372 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12373   as_basename=basename
12374 else
12375   as_basename=false
12376 fi
12377
12378
12379 # Name of the executable.
12380 as_me=`$as_basename "$0" ||
12381 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12382          X"$0" : 'X\(//\)$' \| \
12383          X"$0" : 'X\(/\)$' \| \
12384          .     : '\(.\)' 2>/dev/null ||
12385 echo X/"$0" |
12386     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12387           /^X\/\(\/\/\)$/{ s//\1/; q; }
12388           /^X\/\(\/\).*/{ s//\1/; q; }
12389           s/.*/./; q'`
12390
12391
12392 # PATH needs CR, and LINENO needs CR and PATH.
12393 # Avoid depending upon Character Ranges.
12394 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12395 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12396 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12397 as_cr_digits='0123456789'
12398 as_cr_alnum=$as_cr_Letters$as_cr_digits
12399
12400 # The user is always right.
12401 if test "${PATH_SEPARATOR+set}" != set; then
12402   echo "#! /bin/sh" >conf$$.sh
12403   echo  "exit 0"   >>conf$$.sh
12404   chmod +x conf$$.sh
12405   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12406     PATH_SEPARATOR=';'
12407   else
12408     PATH_SEPARATOR=:
12409   fi
12410   rm -f conf$$.sh
12411 fi
12412
12413
12414   as_lineno_1=$LINENO
12415   as_lineno_2=$LINENO
12416   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12417   test "x$as_lineno_1" != "x$as_lineno_2" &&
12418   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12419   # Find who we are.  Look in the path if we contain no path at all
12420   # relative or not.
12421   case $0 in
12422     *[\\/]* ) as_myself=$0 ;;
12423     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12424 for as_dir in $PATH
12425 do
12426   IFS=$as_save_IFS
12427   test -z "$as_dir" && as_dir=.
12428   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12429 done
12430
12431        ;;
12432   esac
12433   # We did not find ourselves, most probably we were run as `sh COMMAND'
12434   # in which case we are not to be found in the path.
12435   if test "x$as_myself" = x; then
12436     as_myself=$0
12437   fi
12438   if test ! -f "$as_myself"; then
12439     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12440 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12441    { (exit 1); exit 1; }; }
12442   fi
12443   case $CONFIG_SHELL in
12444   '')
12445     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12446 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12447 do
12448   IFS=$as_save_IFS
12449   test -z "$as_dir" && as_dir=.
12450   for as_base in sh bash ksh sh5; do
12451          case $as_dir in
12452          /*)
12453            if ("$as_dir/$as_base" -c '
12454   as_lineno_1=$LINENO
12455   as_lineno_2=$LINENO
12456   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12457   test "x$as_lineno_1" != "x$as_lineno_2" &&
12458   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12459              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12460              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12461              CONFIG_SHELL=$as_dir/$as_base
12462              export CONFIG_SHELL
12463              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12464            fi;;
12465          esac
12466        done
12467 done
12468 ;;
12469   esac
12470
12471   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12472   # uniformly replaced by the line number.  The first 'sed' inserts a
12473   # line-number line before each line; the second 'sed' does the real
12474   # work.  The second script uses 'N' to pair each line-number line
12475   # with the numbered line, and appends trailing '-' during
12476   # substitution so that $LINENO is not a special case at line end.
12477   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12478   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12479   sed '=' <$as_myself |
12480     sed '
12481       N
12482       s,$,-,
12483       : loop
12484       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12485       t loop
12486       s,-$,,
12487       s,^['$as_cr_digits']*\n,,
12488     ' >$as_me.lineno &&
12489   chmod +x $as_me.lineno ||
12490     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12491 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12492    { (exit 1); exit 1; }; }
12493
12494   # Don't try to exec as it changes $[0], causing all sort of problems
12495   # (the dirname of $[0] is not the place where we might find the
12496   # original and so on.  Autoconf is especially sensible to this).
12497   . ./$as_me.lineno
12498   # Exit status is that of the last command.
12499   exit
12500 }
12501
12502
12503 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12504   *c*,-n*) ECHO_N= ECHO_C='
12505 ' ECHO_T='      ' ;;
12506   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12507   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12508 esac
12509
12510 if expr a : '\(a\)' >/dev/null 2>&1; then
12511   as_expr=expr
12512 else
12513   as_expr=false
12514 fi
12515
12516 rm -f conf$$ conf$$.exe conf$$.file
12517 echo >conf$$.file
12518 if ln -s conf$$.file conf$$ 2>/dev/null; then
12519   # We could just check for DJGPP; but this test a) works b) is more generic
12520   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12521   if test -f conf$$.exe; then
12522     # Don't use ln at all; we don't have any links
12523     as_ln_s='cp -p'
12524   else
12525     as_ln_s='ln -s'
12526   fi
12527 elif ln conf$$.file conf$$ 2>/dev/null; then
12528   as_ln_s=ln
12529 else
12530   as_ln_s='cp -p'
12531 fi
12532 rm -f conf$$ conf$$.exe conf$$.file
12533
12534 if mkdir -p . 2>/dev/null; then
12535   as_mkdir_p=:
12536 else
12537   test -d ./-p && rmdir ./-p
12538   as_mkdir_p=false
12539 fi
12540
12541 as_executable_p="test -f"
12542
12543 # Sed expression to map a string onto a valid CPP name.
12544 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12545
12546 # Sed expression to map a string onto a valid variable name.
12547 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12548
12549
12550 # IFS
12551 # We need space, tab and new line, in precisely that order.
12552 as_nl='
12553 '
12554 IFS="   $as_nl"
12555
12556 # CDPATH.
12557 $as_unset CDPATH
12558
12559 exec 6>&1
12560
12561 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12562 # report actual input values of CONFIG_FILES etc. instead of their
12563 # values after options handling.  Logging --version etc. is OK.
12564 exec 5>>config.log
12565 {
12566   echo
12567   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12568 ## Running $as_me. ##
12569 _ASBOX
12570 } >&5
12571 cat >&5 <<_CSEOF
12572
12573 This file was extended by $as_me, which was
12574 generated by GNU Autoconf 2.59.  Invocation command line was
12575
12576   CONFIG_FILES    = $CONFIG_FILES
12577   CONFIG_HEADERS  = $CONFIG_HEADERS
12578   CONFIG_LINKS    = $CONFIG_LINKS
12579   CONFIG_COMMANDS = $CONFIG_COMMANDS
12580   $ $0 $@
12581
12582 _CSEOF
12583 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12584 echo >&5
12585 _ACEOF
12586
12587 # Files that config.status was made for.
12588 if test -n "$ac_config_files"; then
12589   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12590 fi
12591
12592 if test -n "$ac_config_headers"; then
12593   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12594 fi
12595
12596 if test -n "$ac_config_links"; then
12597   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12598 fi
12599
12600 if test -n "$ac_config_commands"; then
12601   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12602 fi
12603
12604 cat >>$CONFIG_STATUS <<\_ACEOF
12605
12606 ac_cs_usage="\
12607 \`$as_me' instantiates files from templates according to the
12608 current configuration.
12609
12610 Usage: $0 [OPTIONS] [FILE]...
12611
12612   -h, --help       print this help, then exit
12613   -V, --version    print version number, then exit
12614   -q, --quiet      do not print progress messages
12615   -d, --debug      don't remove temporary files
12616       --recheck    update $as_me by reconfiguring in the same conditions
12617   --file=FILE[:TEMPLATE]
12618                    instantiate the configuration file FILE
12619
12620 Configuration files:
12621 $config_files
12622
12623 Report bugs to <bug-autoconf@gnu.org>."
12624 _ACEOF
12625
12626 cat >>$CONFIG_STATUS <<_ACEOF
12627 ac_cs_version="\\
12628 config.status
12629 configured by $0, generated by GNU Autoconf 2.59,
12630   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12631
12632 Copyright (C) 2003 Free Software Foundation, Inc.
12633 This config.status script is free software; the Free Software Foundation
12634 gives unlimited permission to copy, distribute and modify it."
12635 srcdir=$srcdir
12636 INSTALL="$INSTALL"
12637 _ACEOF
12638
12639 cat >>$CONFIG_STATUS <<\_ACEOF
12640 # If no file are specified by the user, then we need to provide default
12641 # value.  By we need to know if files were specified by the user.
12642 ac_need_defaults=:
12643 while test $# != 0
12644 do
12645   case $1 in
12646   --*=*)
12647     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12648     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12649     ac_shift=:
12650     ;;
12651   -*)
12652     ac_option=$1
12653     ac_optarg=$2
12654     ac_shift=shift
12655     ;;
12656   *) # This is not an option, so the user has probably given explicit
12657      # arguments.
12658      ac_option=$1
12659      ac_need_defaults=false;;
12660   esac
12661
12662   case $ac_option in
12663   # Handling of the options.
12664 _ACEOF
12665 cat >>$CONFIG_STATUS <<\_ACEOF
12666   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12667     ac_cs_recheck=: ;;
12668   --version | --vers* | -V )
12669     echo "$ac_cs_version"; exit 0 ;;
12670   --he | --h)
12671     # Conflict between --help and --header
12672     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12673 Try \`$0 --help' for more information." >&5
12674 echo "$as_me: error: ambiguous option: $1
12675 Try \`$0 --help' for more information." >&2;}
12676    { (exit 1); exit 1; }; };;
12677   --help | --hel | -h )
12678     echo "$ac_cs_usage"; exit 0 ;;
12679   --debug | --d* | -d )
12680     debug=: ;;
12681   --file | --fil | --fi | --f )
12682     $ac_shift
12683     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12684     ac_need_defaults=false;;
12685   --header | --heade | --head | --hea )
12686     $ac_shift
12687     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12688     ac_need_defaults=false;;
12689   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12690   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12691     ac_cs_silent=: ;;
12692
12693   # This is an error.
12694   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12695 Try \`$0 --help' for more information." >&5
12696 echo "$as_me: error: unrecognized option: $1
12697 Try \`$0 --help' for more information." >&2;}
12698    { (exit 1); exit 1; }; } ;;
12699
12700   *) ac_config_targets="$ac_config_targets $1" ;;
12701
12702   esac
12703   shift
12704 done
12705
12706 ac_configure_extra_args=
12707
12708 if $ac_cs_silent; then
12709   exec 6>/dev/null
12710   ac_configure_extra_args="$ac_configure_extra_args --silent"
12711 fi
12712
12713 _ACEOF
12714 cat >>$CONFIG_STATUS <<_ACEOF
12715 if \$ac_cs_recheck; then
12716   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12717   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12718 fi
12719
12720 _ACEOF
12721
12722
12723
12724
12725
12726 cat >>$CONFIG_STATUS <<\_ACEOF
12727 for ac_config_target in $ac_config_targets
12728 do
12729   case "$ac_config_target" in
12730   # Handling of arguments.
12731   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12732   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12733 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12734    { (exit 1); exit 1; }; };;
12735   esac
12736 done
12737
12738 # If the user did not use the arguments to specify the items to instantiate,
12739 # then the envvar interface is used.  Set only those that are not.
12740 # We use the long form for the default assignment because of an extremely
12741 # bizarre bug on SunOS 4.1.3.
12742 if $ac_need_defaults; then
12743   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12744 fi
12745
12746 # Have a temporary directory for convenience.  Make it in the build tree
12747 # simply because there is no reason to put it here, and in addition,
12748 # creating and moving files from /tmp can sometimes cause problems.
12749 # Create a temporary directory, and hook for its removal unless debugging.
12750 $debug ||
12751 {
12752   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12753   trap '{ (exit 1); exit 1; }' 1 2 13 15
12754 }
12755
12756 # Create a (secure) tmp directory for tmp files.
12757
12758 {
12759   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12760   test -n "$tmp" && test -d "$tmp"
12761 }  ||
12762 {
12763   tmp=./confstat$$-$RANDOM
12764   (umask 077 && mkdir $tmp)
12765 } ||
12766 {
12767    echo "$me: cannot create a temporary directory in ." >&2
12768    { (exit 1); exit 1; }
12769 }
12770
12771 _ACEOF
12772
12773 cat >>$CONFIG_STATUS <<_ACEOF
12774
12775 #
12776 # CONFIG_FILES section.
12777 #
12778
12779 # No need to generate the scripts if there are no CONFIG_FILES.
12780 # This happens for instance when ./config.status config.h
12781 if test -n "\$CONFIG_FILES"; then
12782   # Protect against being on the right side of a sed subst in config.status.
12783   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12784    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12785 s,@SHELL@,$SHELL,;t t
12786 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12787 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12788 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12789 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12790 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12791 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12792 s,@exec_prefix@,$exec_prefix,;t t
12793 s,@prefix@,$prefix,;t t
12794 s,@program_transform_name@,$program_transform_name,;t t
12795 s,@bindir@,$bindir,;t t
12796 s,@sbindir@,$sbindir,;t t
12797 s,@libexecdir@,$libexecdir,;t t
12798 s,@datadir@,$datadir,;t t
12799 s,@sysconfdir@,$sysconfdir,;t t
12800 s,@sharedstatedir@,$sharedstatedir,;t t
12801 s,@localstatedir@,$localstatedir,;t t
12802 s,@libdir@,$libdir,;t t
12803 s,@includedir@,$includedir,;t t
12804 s,@oldincludedir@,$oldincludedir,;t t
12805 s,@infodir@,$infodir,;t t
12806 s,@mandir@,$mandir,;t t
12807 s,@build_alias@,$build_alias,;t t
12808 s,@host_alias@,$host_alias,;t t
12809 s,@target_alias@,$target_alias,;t t
12810 s,@DEFS@,$DEFS,;t t
12811 s,@ECHO_C@,$ECHO_C,;t t
12812 s,@ECHO_N@,$ECHO_N,;t t
12813 s,@ECHO_T@,$ECHO_T,;t t
12814 s,@LIBS@,$LIBS,;t t
12815 s,@build@,$build,;t t
12816 s,@build_cpu@,$build_cpu,;t t
12817 s,@build_vendor@,$build_vendor,;t t
12818 s,@build_os@,$build_os,;t t
12819 s,@build_noncanonical@,$build_noncanonical,;t t
12820 s,@host_noncanonical@,$host_noncanonical,;t t
12821 s,@target_noncanonical@,$target_noncanonical,;t t
12822 s,@host@,$host,;t t
12823 s,@host_cpu@,$host_cpu,;t t
12824 s,@host_vendor@,$host_vendor,;t t
12825 s,@host_os@,$host_os,;t t
12826 s,@target@,$target,;t t
12827 s,@target_cpu@,$target_cpu,;t t
12828 s,@target_vendor@,$target_vendor,;t t
12829 s,@target_os@,$target_os,;t t
12830 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12831 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12832 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12833 s,@LN@,$LN,;t t
12834 s,@LN_S@,$LN_S,;t t
12835 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12836 s,@build_libsubdir@,$build_libsubdir,;t t
12837 s,@build_subdir@,$build_subdir,;t t
12838 s,@host_subdir@,$host_subdir,;t t
12839 s,@target_subdir@,$target_subdir,;t t
12840 s,@CC@,$CC,;t t
12841 s,@CFLAGS@,$CFLAGS,;t t
12842 s,@LDFLAGS@,$LDFLAGS,;t t
12843 s,@CPPFLAGS@,$CPPFLAGS,;t t
12844 s,@ac_ct_CC@,$ac_ct_CC,;t t
12845 s,@EXEEXT@,$EXEEXT,;t t
12846 s,@OBJEXT@,$OBJEXT,;t t
12847 s,@CXX@,$CXX,;t t
12848 s,@CXXFLAGS@,$CXXFLAGS,;t t
12849 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12850 s,@GNATBIND@,$GNATBIND,;t t
12851 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12852 s,@GNATMAKE@,$GNATMAKE,;t t
12853 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12854 s,@do_compare@,$do_compare,;t t
12855 s,@gmplibs@,$gmplibs,;t t
12856 s,@gmpinc@,$gmpinc,;t t
12857 s,@stage1_languages@,$stage1_languages,;t t
12858 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12859 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12860 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
12861 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
12862 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12863 s,@tooldir@,$tooldir,;t t
12864 s,@build_tooldir@,$build_tooldir,;t t
12865 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12866 s,@GDB_TK@,$GDB_TK,;t t
12867 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12868 s,@build_configargs@,$build_configargs,;t t
12869 s,@build_configdirs@,$build_configdirs,;t t
12870 s,@host_configargs@,$host_configargs,;t t
12871 s,@configdirs@,$configdirs,;t t
12872 s,@target_configargs@,$target_configargs,;t t
12873 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
12874 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
12875 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12876 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12877 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
12878 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
12879 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
12880 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
12881 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
12882 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
12883 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
12884 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
12885 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
12886 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
12887 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
12888 s,@config_shell@,$config_shell,;t t
12889 s,@YACC@,$YACC,;t t
12890 s,@BISON@,$BISON,;t t
12891 s,@M4@,$M4,;t t
12892 s,@LEX@,$LEX,;t t
12893 s,@FLEX@,$FLEX,;t t
12894 s,@MAKEINFO@,$MAKEINFO,;t t
12895 s,@EXPECT@,$EXPECT,;t t
12896 s,@RUNTEST@,$RUNTEST,;t t
12897 s,@AR@,$AR,;t t
12898 s,@AS@,$AS,;t t
12899 s,@DLLTOOL@,$DLLTOOL,;t t
12900 s,@LD@,$LD,;t t
12901 s,@LIPO@,$LIPO,;t t
12902 s,@NM@,$NM,;t t
12903 s,@RANLIB@,$RANLIB,;t t
12904 s,@STRIP@,$STRIP,;t t
12905 s,@WINDRES@,$WINDRES,;t t
12906 s,@WINDMC@,$WINDMC,;t t
12907 s,@OBJCOPY@,$OBJCOPY,;t t
12908 s,@OBJDUMP@,$OBJDUMP,;t t
12909 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12910 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12911 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12912 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12913 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12914 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12915 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12916 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12917 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12918 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12919 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12920 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12921 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12922 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12923 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12924 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
12925 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12926 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12927 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12928 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12929 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12930 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12931 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12932 s,@MAINT@,$MAINT,;t t
12933 s,@stage1_cflags@,$stage1_cflags,;t t
12934 s,@stage1_checking@,$stage1_checking,;t t
12935 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12936 s,@datarootdir@,$datarootdir,;t t
12937 s,@docdir@,$docdir,;t t
12938 s,@pdfdir@,$pdfdir,;t t
12939 s,@htmldir@,$htmldir,;t t
12940 s,@LIBOBJS@,$LIBOBJS,;t t
12941 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12942 /@serialization_dependencies@/r $serialization_dependencies
12943 s,@serialization_dependencies@,,;t t
12944 /@host_makefile_frag@/r $host_makefile_frag
12945 s,@host_makefile_frag@,,;t t
12946 /@target_makefile_frag@/r $target_makefile_frag
12947 s,@target_makefile_frag@,,;t t
12948 /@alphaieee_frag@/r $alphaieee_frag
12949 s,@alphaieee_frag@,,;t t
12950 /@ospace_frag@/r $ospace_frag
12951 s,@ospace_frag@,,;t t
12952 CEOF
12953
12954 _ACEOF
12955
12956   cat >>$CONFIG_STATUS <<\_ACEOF
12957   # Split the substitutions into bite-sized pieces for seds with
12958   # small command number limits, like on Digital OSF/1 and HP-UX.
12959   ac_max_sed_lines=48
12960   ac_sed_frag=1 # Number of current file.
12961   ac_beg=1 # First line for current file.
12962   ac_end=$ac_max_sed_lines # Line after last line for current file.
12963   ac_more_lines=:
12964   ac_sed_cmds=
12965   while $ac_more_lines; do
12966     if test $ac_beg -gt 1; then
12967       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12968     else
12969       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12970     fi
12971     if test ! -s $tmp/subs.frag; then
12972       ac_more_lines=false
12973     else
12974       # The purpose of the label and of the branching condition is to
12975       # speed up the sed processing (if there are no `@' at all, there
12976       # is no need to browse any of the substitutions).
12977       # These are the two extra sed commands mentioned above.
12978       (echo ':t
12979   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12980       if test -z "$ac_sed_cmds"; then
12981         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12982       else
12983         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12984       fi
12985       ac_sed_frag=`expr $ac_sed_frag + 1`
12986       ac_beg=$ac_end
12987       ac_end=`expr $ac_end + $ac_max_sed_lines`
12988     fi
12989   done
12990   if test -z "$ac_sed_cmds"; then
12991     ac_sed_cmds=cat
12992   fi
12993 fi # test -n "$CONFIG_FILES"
12994
12995 _ACEOF
12996 cat >>$CONFIG_STATUS <<\_ACEOF
12997 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12998   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12999   case $ac_file in
13000   - | *:- | *:-:* ) # input from stdin
13001         cat >$tmp/stdin
13002         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13003         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13004   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13005         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13006   * )   ac_file_in=$ac_file.in ;;
13007   esac
13008
13009   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13010   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13011 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13012          X"$ac_file" : 'X\(//\)[^/]' \| \
13013          X"$ac_file" : 'X\(//\)$' \| \
13014          X"$ac_file" : 'X\(/\)' \| \
13015          .     : '\(.\)' 2>/dev/null ||
13016 echo X"$ac_file" |
13017     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13018           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13019           /^X\(\/\/\)$/{ s//\1/; q; }
13020           /^X\(\/\).*/{ s//\1/; q; }
13021           s/.*/./; q'`
13022   { if $as_mkdir_p; then
13023     mkdir -p "$ac_dir"
13024   else
13025     as_dir="$ac_dir"
13026     as_dirs=
13027     while test ! -d "$as_dir"; do
13028       as_dirs="$as_dir $as_dirs"
13029       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13030 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13031          X"$as_dir" : 'X\(//\)[^/]' \| \
13032          X"$as_dir" : 'X\(//\)$' \| \
13033          X"$as_dir" : 'X\(/\)' \| \
13034          .     : '\(.\)' 2>/dev/null ||
13035 echo X"$as_dir" |
13036     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13037           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13038           /^X\(\/\/\)$/{ s//\1/; q; }
13039           /^X\(\/\).*/{ s//\1/; q; }
13040           s/.*/./; q'`
13041     done
13042     test ! -n "$as_dirs" || mkdir $as_dirs
13043   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13044 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13045    { (exit 1); exit 1; }; }; }
13046
13047   ac_builddir=.
13048
13049 if test "$ac_dir" != .; then
13050   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13051   # A "../" for each directory in $ac_dir_suffix.
13052   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13053 else
13054   ac_dir_suffix= ac_top_builddir=
13055 fi
13056
13057 case $srcdir in
13058   .)  # No --srcdir option.  We are building in place.
13059     ac_srcdir=.
13060     if test -z "$ac_top_builddir"; then
13061        ac_top_srcdir=.
13062     else
13063        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13064     fi ;;
13065   [\\/]* | ?:[\\/]* )  # Absolute path.
13066     ac_srcdir=$srcdir$ac_dir_suffix;
13067     ac_top_srcdir=$srcdir ;;
13068   *) # Relative path.
13069     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13070     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13071 esac
13072
13073 # Do not use `cd foo && pwd` to compute absolute paths, because
13074 # the directories may not exist.
13075 case `pwd` in
13076 .) ac_abs_builddir="$ac_dir";;
13077 *)
13078   case "$ac_dir" in
13079   .) ac_abs_builddir=`pwd`;;
13080   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13081   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13082   esac;;
13083 esac
13084 case $ac_abs_builddir in
13085 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13086 *)
13087   case ${ac_top_builddir}. in
13088   .) ac_abs_top_builddir=$ac_abs_builddir;;
13089   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13090   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13091   esac;;
13092 esac
13093 case $ac_abs_builddir in
13094 .) ac_abs_srcdir=$ac_srcdir;;
13095 *)
13096   case $ac_srcdir in
13097   .) ac_abs_srcdir=$ac_abs_builddir;;
13098   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13099   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13100   esac;;
13101 esac
13102 case $ac_abs_builddir in
13103 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13104 *)
13105   case $ac_top_srcdir in
13106   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13107   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13108   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13109   esac;;
13110 esac
13111
13112
13113   case $INSTALL in
13114   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13115   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13116   esac
13117
13118   if test x"$ac_file" != x-; then
13119     { echo "$as_me:$LINENO: creating $ac_file" >&5
13120 echo "$as_me: creating $ac_file" >&6;}
13121     rm -f "$ac_file"
13122   fi
13123   # Let's still pretend it is `configure' which instantiates (i.e., don't
13124   # use $as_me), people would be surprised to read:
13125   #    /* config.h.  Generated by config.status.  */
13126   if test x"$ac_file" = x-; then
13127     configure_input=
13128   else
13129     configure_input="$ac_file.  "
13130   fi
13131   configure_input=$configure_input"Generated from `echo $ac_file_in |
13132                                      sed 's,.*/,,'` by configure."
13133
13134   # First look for the input files in the build tree, otherwise in the
13135   # src tree.
13136   ac_file_inputs=`IFS=:
13137     for f in $ac_file_in; do
13138       case $f in
13139       -) echo $tmp/stdin ;;
13140       [\\/$]*)
13141          # Absolute (can't be DOS-style, as IFS=:)
13142          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13143 echo "$as_me: error: cannot find input file: $f" >&2;}
13144    { (exit 1); exit 1; }; }
13145          echo "$f";;
13146       *) # Relative
13147          if test -f "$f"; then
13148            # Build tree
13149            echo "$f"
13150          elif test -f "$srcdir/$f"; then
13151            # Source tree
13152            echo "$srcdir/$f"
13153          else
13154            # /dev/null tree
13155            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13156 echo "$as_me: error: cannot find input file: $f" >&2;}
13157    { (exit 1); exit 1; }; }
13158          fi;;
13159       esac
13160     done` || { (exit 1); exit 1; }
13161 _ACEOF
13162 cat >>$CONFIG_STATUS <<_ACEOF
13163   sed "$ac_vpsub
13164 $extrasub
13165 _ACEOF
13166 cat >>$CONFIG_STATUS <<\_ACEOF
13167 :t
13168 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13169 s,@configure_input@,$configure_input,;t t
13170 s,@srcdir@,$ac_srcdir,;t t
13171 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13172 s,@top_srcdir@,$ac_top_srcdir,;t t
13173 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13174 s,@builddir@,$ac_builddir,;t t
13175 s,@abs_builddir@,$ac_abs_builddir,;t t
13176 s,@top_builddir@,$ac_top_builddir,;t t
13177 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13178 s,@INSTALL@,$ac_INSTALL,;t t
13179 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13180   rm -f $tmp/stdin
13181   if test x"$ac_file" != x-; then
13182     mv $tmp/out $ac_file
13183   else
13184     cat $tmp/out
13185     rm -f $tmp/out
13186   fi
13187
13188 done
13189 _ACEOF
13190
13191 cat >>$CONFIG_STATUS <<\_ACEOF
13192
13193 { (exit 0); exit 0; }
13194 _ACEOF
13195 chmod +x $CONFIG_STATUS
13196 ac_clean_files=$ac_clean_files_save
13197
13198
13199 # configure is writing to config.log, and then calls config.status.
13200 # config.status does its own redirection, appending to config.log.
13201 # Unfortunately, on DOS this fails, as config.log is still kept open
13202 # by configure, so config.status won't be able to write to it; its
13203 # output is simply discarded.  So we exec the FD to /dev/null,
13204 # effectively closing config.log, so it can be properly (re)opened and
13205 # appended to by config.status.  When coming back to configure, we
13206 # need to make the FD available again.
13207 if test "$no_create" != yes; then
13208   ac_cs_success=:
13209   ac_config_status_args=
13210   test "$silent" = yes &&
13211     ac_config_status_args="$ac_config_status_args --quiet"
13212   exec 5>/dev/null
13213   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13214   exec 5>>config.log
13215   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13216   # would make configure fail if this is the last instruction.
13217   $ac_cs_success || { (exit 1); exit 1; }
13218 fi
13219