configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S TOPLEVEL_CONFIGURE_ARGUMENTS build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET RPATH_ENVVAR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs 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_env_CC_set=${CC+set}
 717 ac_env_CC_value=$CC
 718 ac_cv_env_CC_set=${CC+set}
 719 ac_cv_env_CC_value=$CC
 720 ac_env_CFLAGS_set=${CFLAGS+set}
 721 ac_env_CFLAGS_value=$CFLAGS
 722 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 723 ac_cv_env_CFLAGS_value=$CFLAGS
 724 ac_env_LDFLAGS_set=${LDFLAGS+set}
 725 ac_env_LDFLAGS_value=$LDFLAGS
 726 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 727 ac_cv_env_LDFLAGS_value=$LDFLAGS
 728 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 729 ac_env_CPPFLAGS_value=$CPPFLAGS
 730 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 731 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 732 ac_env_CXX_set=${CXX+set}
 733 ac_env_CXX_value=$CXX
 734 ac_cv_env_CXX_set=${CXX+set}
 735 ac_cv_env_CXX_value=$CXX
 736 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 737 ac_env_CXXFLAGS_value=$CXXFLAGS
 738 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 739 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 740 ac_env_AR_set=${AR+set}
 741 ac_env_AR_value=$AR
 742 ac_cv_env_AR_set=${AR+set}
 743 ac_cv_env_AR_value=$AR
 744 ac_env_AS_set=${AS+set}
 745 ac_env_AS_value=$AS
 746 ac_cv_env_AS_set=${AS+set}
 747 ac_cv_env_AS_value=$AS
 748 ac_env_DLLTOOL_set=${DLLTOOL+set}
 749 ac_env_DLLTOOL_value=$DLLTOOL
 750 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 751 ac_cv_env_DLLTOOL_value=$DLLTOOL
 752 ac_env_LD_set=${LD+set}
 753 ac_env_LD_value=$LD
 754 ac_cv_env_LD_set=${LD+set}
 755 ac_cv_env_LD_value=$LD
 756 ac_env_LIPO_set=${LIPO+set}
 757 ac_env_LIPO_value=$LIPO
 758 ac_cv_env_LIPO_set=${LIPO+set}
 759 ac_cv_env_LIPO_value=$LIPO
 760 ac_env_NM_set=${NM+set}
 761 ac_env_NM_value=$NM
 762 ac_cv_env_NM_set=${NM+set}
 763 ac_cv_env_NM_value=$NM
 764 ac_env_RANLIB_set=${RANLIB+set}
 765 ac_env_RANLIB_value=$RANLIB
 766 ac_cv_env_RANLIB_set=${RANLIB+set}
 767 ac_cv_env_RANLIB_value=$RANLIB
 768 ac_env_STRIP_set=${STRIP+set}
 769 ac_env_STRIP_value=$STRIP
 770 ac_cv_env_STRIP_set=${STRIP+set}
 771 ac_cv_env_STRIP_value=$STRIP
 772 ac_env_WINDRES_set=${WINDRES+set}
 773 ac_env_WINDRES_value=$WINDRES
 774 ac_cv_env_WINDRES_set=${WINDRES+set}
 775 ac_cv_env_WINDRES_value=$WINDRES
 776 ac_env_WINDMC_set=${WINDMC+set}
 777 ac_env_WINDMC_value=$WINDMC
 778 ac_cv_env_WINDMC_set=${WINDMC+set}
 779 ac_cv_env_WINDMC_value=$WINDMC
 780 ac_env_OBJCOPY_set=${OBJCOPY+set}
 781 ac_env_OBJCOPY_value=$OBJCOPY
 782 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 783 ac_cv_env_OBJCOPY_value=$OBJCOPY
 784 ac_env_OBJDUMP_set=${OBJDUMP+set}
 785 ac_env_OBJDUMP_value=$OBJDUMP
 786 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 787 ac_cv_env_OBJDUMP_value=$OBJDUMP
 788 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 789 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 790 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 791 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 792 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 793 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 794 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 795 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 796 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 797 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 798 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 799 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 800 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 801 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 802 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 803 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 804 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 805 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 806 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 807 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 808 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 809 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 810 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 811 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 812 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 813 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 814 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 815 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 816 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 817 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 818 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 819 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 820 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 821 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 822 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 823 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 824 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 825 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 826 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 827 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 828 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 829 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 830 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 831 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 832 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 833 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 834 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 835 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 836 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 837 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 838 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 839 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 840 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 841 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 842 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 843 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 844 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 845 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 846 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 847 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 848 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 849 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 850 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 851 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 852
 853 #
 854 # Report the --help message.
 855 #
 856 if test "$ac_init_help" = "long"; then
 857   # Omit some internal or obsolete options to make the list less imposing.
 858   # This message is too long to be a string in the A/UX 3.1 sh.
 859   cat <<_ACEOF
 860 \`configure' configures this package to adapt to many kinds of systems.
 861
 862 Usage: $0 [OPTION]... [VAR=VALUE]...
 863
 864 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 865 VAR=VALUE.  See below for descriptions of some of the useful variables.
 866
 867 Defaults for the options are specified in brackets.
 868
 869 Configuration:
 870   -h, --help              display this help and exit
 871       --help=short        display options specific to this package
 872       --help=recursive    display the short help of all the included packages
 873   -V, --version           display version information and exit
 874   -q, --quiet, --silent   do not print \`checking...' messages
 875       --cache-file=FILE   cache test results in FILE [disabled]
 876   -C, --config-cache      alias for \`--cache-file=config.cache'
 877   -n, --no-create         do not create output files
 878       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 879
 880 _ACEOF
 881
 882   cat <<_ACEOF
 883 Installation directories:
 884   --prefix=PREFIX         install architecture-independent files in PREFIX
 885                           [$ac_default_prefix]
 886   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 887                           [PREFIX]
 888
 889 By default, \`make install' will install all the files in
 890 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 891 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 892 for instance \`--prefix=\$HOME'.
 893
 894 For better control, use the options below.
 895
 896 Fine tuning of the installation directories:
 897   --bindir=DIR           user executables [EPREFIX/bin]
 898   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 899   --libexecdir=DIR       program executables [EPREFIX/libexec]
 900   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 901   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 902   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 903   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 904   --libdir=DIR           object code libraries [EPREFIX/lib]
 905   --includedir=DIR       C header files [PREFIX/include]
 906   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 907   --infodir=DIR          info documentation [PREFIX/info]
 908   --mandir=DIR           man documentation [PREFIX/man]
 909 _ACEOF
 910
 911   cat <<\_ACEOF
 912
 913 Program names:
 914   --program-prefix=PREFIX            prepend PREFIX to installed program names
 915   --program-suffix=SUFFIX            append SUFFIX to installed program names
 916   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 917
 918 System types:
 919   --build=BUILD     configure for building on BUILD [guessed]
 920   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 921   --target=TARGET   configure for building compilers for TARGET [HOST]
 922 _ACEOF
 923 fi
 924
 925 if test -n "$ac_init_help"; then
 926
 927   cat <<\_ACEOF
 928
 929 Optional Features:
 930   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 931   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 932   --enable-libada         build libada directory
 933   --enable-libssp         build libssp directory
 934   --enable-stage1-languages[=all]   choose additional languages to build during
 935                           stage1.  Mostly useful for compiler development.
 936   --enable-objc-gc        enable use of Boehm's garbage collector with the
 937                           GNU Objective-C runtime
 938   --enable-bootstrap      enable bootstrapping [yes if native build]
 939   --enable-serial-[{host,target,build}-]configure
 940                           force sequential configuration of
 941                           sub-packages for the host, target or build
 942                           machine, or all sub-packages
 943   --enable-maintainer-mode enable make rules and dependencies not useful
 944                           (and sometimes confusing) to the casual installer
 945   --enable-stage1-checking[=all]   choose additional checking for stage1
 946                           of the compiler
 947   --enable-werror         enable -Werror in bootstrap stage2 and later
 948
 949 Optional Packages:
 950   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 951   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 952   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 953   --with-mpfr-dir=PATH    this option has been REMOVED
 954   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 955                           Equivalent to --with-mpfr-include=PATH/include
 956                           plus --with-mpfr-lib=PATH/lib
 957   --with-mpfr-include=PATH
 958                           specify directory for installed MPFR include files
 959   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 960   --with-gmp-dir=PATH     this option has been REMOVED
 961   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 962                           Equivalent to --with-gmp-include=PATH/include
 963                           plus --with-gmp-lib=PATH/lib
 964   --with-gmp-include=PATH specify directory for installed GMP include files
 965   --with-gmp-lib=PATH     specify directory for the installed GMP library
 966   --with-build-sysroot=SYSROOT
 967                           use sysroot as the system root during the build
 968   --with-debug-prefix-map='A=B C=D ...'
 969                              map A to B, C to D ... in debug information
 970   --with-build-time-tools=PATH
 971                           use given path to find target tools during the build
 972   --with-datarootdir      use datarootdir as the data root directory.
 973   --with-docdir           install documentation in this directory.
 974   --with-pdfdir           install pdf in this directory.
 975   --with-htmldir          install html in this directory.
 976
 977 Some influential environment variables:
 978   CC          C compiler command
 979   CFLAGS      C compiler flags
 980   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 981               nonstandard directory <lib dir>
 982   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 983               headers in a nonstandard directory <include dir>
 984   CXX         C++ compiler command
 985   CXXFLAGS    C++ compiler flags
 986   AR          AR for the host
 987   AS          AS for the host
 988   DLLTOOL     DLLTOOL for the host
 989   LD          LD for the host
 990   LIPO        LIPO for the host
 991   NM          NM for the host
 992   RANLIB      RANLIB for the host
 993   STRIP       STRIP for the host
 994   WINDRES     WINDRES for the host
 995   WINDMC      WINDMC for the host
 996   OBJCOPY     OBJCOPY for the host
 997   OBJDUMP     OBJDUMP for the host
 998   CC_FOR_TARGET
 999               CC for the target
1000   CXX_FOR_TARGET
1001               CXX for the target
1002   GCC_FOR_TARGET
1003               GCC for the target
1004   GCJ_FOR_TARGET
1005               GCJ for the target
1006   GFORTRAN_FOR_TARGET
1007               GFORTRAN for the target
1008   AR_FOR_TARGET
1009               AR for the target
1010   AS_FOR_TARGET
1011               AS for the target
1012   DLLTOOL_FOR_TARGET
1013               DLLTOOL for the target
1014   LD_FOR_TARGET
1015               LD for the target
1016   LIPO_FOR_TARGET
1017               LIPO for the target
1018   NM_FOR_TARGET
1019               NM for the target
1020   OBJDUMP_FOR_TARGET
1021               OBJDUMP for the target
1022   RANLIB_FOR_TARGET
1023               RANLIB for the target
1024   STRIP_FOR_TARGET
1025               STRIP for the target
1026   WINDRES_FOR_TARGET
1027               WINDRES for the target
1028   WINDMC_FOR_TARGET
1029               WINDMC for the target
1030
1031 Use these variables to override the choices made by `configure' or to help
1032 it to find libraries and programs with nonstandard names/locations.
1033
1034 _ACEOF
1035 fi
1036
1037 if test "$ac_init_help" = "recursive"; then
1038   # If there are subdirs, report their specific --help.
1039   ac_popdir=`pwd`
1040   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1041     test -d $ac_dir || continue
1042     ac_builddir=.
1043
1044 if test "$ac_dir" != .; then
1045   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1046   # A "../" for each directory in $ac_dir_suffix.
1047   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1048 else
1049   ac_dir_suffix= ac_top_builddir=
1050 fi
1051
1052 case $srcdir in
1053   .)  # No --srcdir option.  We are building in place.
1054     ac_srcdir=.
1055     if test -z "$ac_top_builddir"; then
1056        ac_top_srcdir=.
1057     else
1058        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1059     fi ;;
1060   [\\/]* | ?:[\\/]* )  # Absolute path.
1061     ac_srcdir=$srcdir$ac_dir_suffix;
1062     ac_top_srcdir=$srcdir ;;
1063   *) # Relative path.
1064     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1065     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1066 esac
1067
1068 # Do not use `cd foo && pwd` to compute absolute paths, because
1069 # the directories may not exist.
1070 case `pwd` in
1071 .) ac_abs_builddir="$ac_dir";;
1072 *)
1073   case "$ac_dir" in
1074   .) ac_abs_builddir=`pwd`;;
1075   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1076   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1077   esac;;
1078 esac
1079 case $ac_abs_builddir in
1080 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1081 *)
1082   case ${ac_top_builddir}. in
1083   .) ac_abs_top_builddir=$ac_abs_builddir;;
1084   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1085   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1086   esac;;
1087 esac
1088 case $ac_abs_builddir in
1089 .) ac_abs_srcdir=$ac_srcdir;;
1090 *)
1091   case $ac_srcdir in
1092   .) ac_abs_srcdir=$ac_abs_builddir;;
1093   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1094   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1095   esac;;
1096 esac
1097 case $ac_abs_builddir in
1098 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1099 *)
1100   case $ac_top_srcdir in
1101   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1102   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1103   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1104   esac;;
1105 esac
1106
1107     cd $ac_dir
1108     # Check for guested configure; otherwise get Cygnus style configure.
1109     if test -f $ac_srcdir/configure.gnu; then
1110       echo
1111       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1112     elif test -f $ac_srcdir/configure; then
1113       echo
1114       $SHELL $ac_srcdir/configure  --help=recursive
1115     elif test -f $ac_srcdir/configure.ac ||
1116            test -f $ac_srcdir/configure.in; then
1117       echo
1118       $ac_configure --help
1119     else
1120       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1121     fi
1122     cd $ac_popdir
1123   done
1124 fi
1125
1126 test -n "$ac_init_help" && exit 0
1127 if $ac_init_version; then
1128   cat <<\_ACEOF
1129
1130 Copyright (C) 2003 Free Software Foundation, Inc.
1131 This configure script is free software; the Free Software Foundation
1132 gives unlimited permission to copy, distribute and modify it.
1133 _ACEOF
1134   exit 0
1135 fi
1136 exec 5>config.log
1137 cat >&5 <<_ACEOF
1138 This file contains any messages produced by compilers while
1139 running configure, to aid debugging if configure makes a mistake.
1140
1141 It was created by $as_me, which was
1142 generated by GNU Autoconf 2.59.  Invocation command line was
1143
1144   $ $0 $@
1145
1146 _ACEOF
1147 {
1148 cat <<_ASUNAME
1149 ## --------- ##
1150 ## Platform. ##
1151 ## --------- ##
1152
1153 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1154 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1155 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1156 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1157 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1158
1159 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1160 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1161
1162 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1163 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1164 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1165 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1166 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1167 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1168 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1169
1170 _ASUNAME
1171
1172 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1173 for as_dir in $PATH
1174 do
1175   IFS=$as_save_IFS
1176   test -z "$as_dir" && as_dir=.
1177   echo "PATH: $as_dir"
1178 done
1179
1180 } >&5
1181
1182 cat >&5 <<_ACEOF
1183
1184
1185 ## ----------- ##
1186 ## Core tests. ##
1187 ## ----------- ##
1188
1189 _ACEOF
1190
1191
1192 # Keep a trace of the command line.
1193 # Strip out --no-create and --no-recursion so they do not pile up.
1194 # Strip out --silent because we don't want to record it for future runs.
1195 # Also quote any args containing shell meta-characters.
1196 # Make two passes to allow for proper duplicate-argument suppression.
1197 ac_configure_args=
1198 ac_configure_args0=
1199 ac_configure_args1=
1200 ac_sep=
1201 ac_must_keep_next=false
1202 for ac_pass in 1 2
1203 do
1204   for ac_arg
1205   do
1206     case $ac_arg in
1207     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1208     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1209     | -silent | --silent | --silen | --sile | --sil)
1210       continue ;;
1211     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1212       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1213     esac
1214     case $ac_pass in
1215     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1216     2)
1217       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1218       if test $ac_must_keep_next = true; then
1219         ac_must_keep_next=false # Got value, back to normal.
1220       else
1221         case $ac_arg in
1222           *=* | --config-cache | -C | -disable-* | --disable-* \
1223           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1224           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1225           | -with-* | --with-* | -without-* | --without-* | --x)
1226             case "$ac_configure_args0 " in
1227               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1228             esac
1229             ;;
1230           -* ) ac_must_keep_next=true ;;
1231         esac
1232       fi
1233       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1234       # Get rid of the leading space.
1235       ac_sep=" "
1236       ;;
1237     esac
1238   done
1239 done
1240 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1241 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1242
1243 # When interrupted or exit'd, cleanup temporary files, and complete
1244 # config.log.  We remove comments because anyway the quotes in there
1245 # would cause problems or look ugly.
1246 # WARNING: Be sure not to use single quotes in there, as some shells,
1247 # such as our DU 5.0 friend, will then `close' the trap.
1248 trap 'exit_status=$?
1249   # Save into config.log some information that might help in debugging.
1250   {
1251     echo
1252
1253     cat <<\_ASBOX
1254 ## ---------------- ##
1255 ## Cache variables. ##
1256 ## ---------------- ##
1257 _ASBOX
1258     echo
1259     # The following way of writing the cache mishandles newlines in values,
1260 {
1261   (set) 2>&1 |
1262     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1263     *ac_space=\ *)
1264       sed -n \
1265         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1266           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1267       ;;
1268     *)
1269       sed -n \
1270         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1271       ;;
1272     esac;
1273 }
1274     echo
1275
1276     cat <<\_ASBOX
1277 ## ----------------- ##
1278 ## Output variables. ##
1279 ## ----------------- ##
1280 _ASBOX
1281     echo
1282     for ac_var in $ac_subst_vars
1283     do
1284       eval ac_val=$`echo $ac_var`
1285       echo "$ac_var='"'"'$ac_val'"'"'"
1286     done | sort
1287     echo
1288
1289     if test -n "$ac_subst_files"; then
1290       cat <<\_ASBOX
1291 ## ------------- ##
1292 ## Output files. ##
1293 ## ------------- ##
1294 _ASBOX
1295       echo
1296       for ac_var in $ac_subst_files
1297       do
1298         eval ac_val=$`echo $ac_var`
1299         echo "$ac_var='"'"'$ac_val'"'"'"
1300       done | sort
1301       echo
1302     fi
1303
1304     if test -s confdefs.h; then
1305       cat <<\_ASBOX
1306 ## ----------- ##
1307 ## confdefs.h. ##
1308 ## ----------- ##
1309 _ASBOX
1310       echo
1311       sed "/^$/d" confdefs.h | sort
1312       echo
1313     fi
1314     test "$ac_signal" != 0 &&
1315       echo "$as_me: caught signal $ac_signal"
1316     echo "$as_me: exit $exit_status"
1317   } >&5
1318   rm -f core *.core &&
1319   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1320     exit $exit_status
1321      ' 0
1322 for ac_signal in 1 2 13 15; do
1323   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1324 done
1325 ac_signal=0
1326
1327 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1328 rm -rf conftest* confdefs.h
1329 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1330 echo >confdefs.h
1331
1332 # Predefined preprocessor variables.
1333
1334 cat >>confdefs.h <<_ACEOF
1335 #define PACKAGE_NAME "$PACKAGE_NAME"
1336 _ACEOF
1337
1338
1339 cat >>confdefs.h <<_ACEOF
1340 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1341 _ACEOF
1342
1343
1344 cat >>confdefs.h <<_ACEOF
1345 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1346 _ACEOF
1347
1348
1349 cat >>confdefs.h <<_ACEOF
1350 #define PACKAGE_STRING "$PACKAGE_STRING"
1351 _ACEOF
1352
1353
1354 cat >>confdefs.h <<_ACEOF
1355 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1356 _ACEOF
1357
1358
1359 # Let the site file select an alternate cache file if it wants to.
1360 # Prefer explicitly selected file to automatically selected ones.
1361 if test -z "$CONFIG_SITE"; then
1362   if test "x$prefix" != xNONE; then
1363     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1364   else
1365     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1366   fi
1367 fi
1368 for ac_site_file in $CONFIG_SITE; do
1369   if test -r "$ac_site_file"; then
1370     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1371 echo "$as_me: loading site script $ac_site_file" >&6;}
1372     sed 's/^/| /' "$ac_site_file" >&5
1373     . "$ac_site_file"
1374   fi
1375 done
1376
1377 if test -r "$cache_file"; then
1378   # Some versions of bash will fail to source /dev/null (special
1379   # files actually), so we avoid doing that.
1380   if test -f "$cache_file"; then
1381     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1382 echo "$as_me: loading cache $cache_file" >&6;}
1383     case $cache_file in
1384       [\\/]* | ?:[\\/]* ) . $cache_file;;
1385       *)                      . ./$cache_file;;
1386     esac
1387   fi
1388 else
1389   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1390 echo "$as_me: creating cache $cache_file" >&6;}
1391   >$cache_file
1392 fi
1393
1394 # Check that the precious variables saved in the cache have kept the same
1395 # value.
1396 ac_cache_corrupted=false
1397 for ac_var in `(set) 2>&1 |
1398                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1399   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1400   eval ac_new_set=\$ac_env_${ac_var}_set
1401   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1402   eval ac_new_val="\$ac_env_${ac_var}_value"
1403   case $ac_old_set,$ac_new_set in
1404     set,)
1405       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1406 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1407       ac_cache_corrupted=: ;;
1408     ,set)
1409       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1410 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1411       ac_cache_corrupted=: ;;
1412     ,);;
1413     *)
1414       if test "x$ac_old_val" != "x$ac_new_val"; then
1415         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1416 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1417         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1418 echo "$as_me:   former value:  $ac_old_val" >&2;}
1419         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1420 echo "$as_me:   current value: $ac_new_val" >&2;}
1421         ac_cache_corrupted=:
1422       fi;;
1423   esac
1424   # Pass precious variables to config.status.
1425   if test "$ac_new_set" = set; then
1426     case $ac_new_val in
1427     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1428       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1429     *) ac_arg=$ac_var=$ac_new_val ;;
1430     esac
1431     case " $ac_configure_args " in
1432       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1433       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1434     esac
1435   fi
1436 done
1437 if $ac_cache_corrupted; then
1438   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1439 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1440   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1441 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1442    { (exit 1); exit 1; }; }
1443 fi
1444
1445 ac_ext=c
1446 ac_cpp='$CPP $CPPFLAGS'
1447 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1448 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1449 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471 # Find the build, host, and target systems.
1472 ac_aux_dir=
1473 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1474   if test -f $ac_dir/install-sh; then
1475     ac_aux_dir=$ac_dir
1476     ac_install_sh="$ac_aux_dir/install-sh -c"
1477     break
1478   elif test -f $ac_dir/install.sh; then
1479     ac_aux_dir=$ac_dir
1480     ac_install_sh="$ac_aux_dir/install.sh -c"
1481     break
1482   elif test -f $ac_dir/shtool; then
1483     ac_aux_dir=$ac_dir
1484     ac_install_sh="$ac_aux_dir/shtool install -c"
1485     break
1486   fi
1487 done
1488 if test -z "$ac_aux_dir"; then
1489   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1490 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1491    { (exit 1); exit 1; }; }
1492 fi
1493 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1494 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1495 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1496
1497 # Make sure we can run config.sub.
1498 $ac_config_sub sun4 >/dev/null 2>&1 ||
1499   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1500 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1501    { (exit 1); exit 1; }; }
1502
1503 echo "$as_me:$LINENO: checking build system type" >&5
1504 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1505 if test "${ac_cv_build+set}" = set; then
1506   echo $ECHO_N "(cached) $ECHO_C" >&6
1507 else
1508   ac_cv_build_alias=$build_alias
1509 test -z "$ac_cv_build_alias" &&
1510   ac_cv_build_alias=`$ac_config_guess`
1511 test -z "$ac_cv_build_alias" &&
1512   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1513 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1514    { (exit 1); exit 1; }; }
1515 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1516   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1517 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1518    { (exit 1); exit 1; }; }
1519
1520 fi
1521 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1522 echo "${ECHO_T}$ac_cv_build" >&6
1523 build=$ac_cv_build
1524 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1525 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1526 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1527
1528
1529  case ${build_alias} in
1530   "") build_noncanonical=${build} ;;
1531   *) build_noncanonical=${build_alias} ;;
1532 esac
1533
1534
1535
1536  case ${host_alias} in
1537   "") host_noncanonical=${build_noncanonical} ;;
1538   *) host_noncanonical=${host_alias} ;;
1539 esac
1540
1541
1542
1543  case ${target_alias} in
1544   "") target_noncanonical=${host_noncanonical} ;;
1545   *) target_noncanonical=${target_alias} ;;
1546 esac
1547
1548
1549
1550
1551 test "$host_noncanonical" = "$target_noncanonical" &&
1552   test "$program_prefix$program_suffix$program_transform_name" = \
1553     NONENONEs,x,x, &&
1554   program_transform_name=s,y,y,
1555
1556 echo "$as_me:$LINENO: checking host system type" >&5
1557 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1558 if test "${ac_cv_host+set}" = set; then
1559   echo $ECHO_N "(cached) $ECHO_C" >&6
1560 else
1561   ac_cv_host_alias=$host_alias
1562 test -z "$ac_cv_host_alias" &&
1563   ac_cv_host_alias=$ac_cv_build_alias
1564 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1565   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1566 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1567    { (exit 1); exit 1; }; }
1568
1569 fi
1570 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1571 echo "${ECHO_T}$ac_cv_host" >&6
1572 host=$ac_cv_host
1573 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1574 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1575 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1576
1577
1578 echo "$as_me:$LINENO: checking target system type" >&5
1579 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1580 if test "${ac_cv_target+set}" = set; then
1581   echo $ECHO_N "(cached) $ECHO_C" >&6
1582 else
1583   ac_cv_target_alias=$target_alias
1584 test "x$ac_cv_target_alias" = "x" &&
1585   ac_cv_target_alias=$ac_cv_host_alias
1586 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1587   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1588 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1589    { (exit 1); exit 1; }; }
1590
1591 fi
1592 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1593 echo "${ECHO_T}$ac_cv_target" >&6
1594 target=$ac_cv_target
1595 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1596 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1597 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1598
1599
1600 # The aliases save the names the user supplied, while $host etc.
1601 # will get canonicalized.
1602 test -n "$target_alias" &&
1603   test "$program_prefix$program_suffix$program_transform_name" = \
1604     NONENONEs,x,x, &&
1605   program_prefix=${target_alias}-
1606 test "$program_prefix" != NONE &&
1607   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1608 # Use a double $ so make ignores it.
1609 test "$program_suffix" != NONE &&
1610   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1611 # Double any \ or $.  echo might interpret backslashes.
1612 # By default was `s,x,x', remove it if useless.
1613 cat <<\_ACEOF >conftest.sed
1614 s/[\\$]/&&/g;s/;s,x,x,$//
1615 _ACEOF
1616 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1617 rm conftest.sed
1618
1619
1620
1621 # Get 'install' or 'install-sh' and its variants.
1622 # Find a good install program.  We prefer a C program (faster),
1623 # so one script is as good as another.  But avoid the broken or
1624 # incompatible versions:
1625 # SysV /etc/install, /usr/sbin/install
1626 # SunOS /usr/etc/install
1627 # IRIX /sbin/install
1628 # AIX /bin/install
1629 # AmigaOS /C/install, which installs bootblocks on floppy discs
1630 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1631 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1632 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1633 # OS/2's system install, which has a completely different semantic
1634 # ./install, which can be erroneously created by make from ./install.sh.
1635 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1636 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1637 if test -z "$INSTALL"; then
1638 if test "${ac_cv_path_install+set}" = set; then
1639   echo $ECHO_N "(cached) $ECHO_C" >&6
1640 else
1641   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1642 for as_dir in $PATH
1643 do
1644   IFS=$as_save_IFS
1645   test -z "$as_dir" && as_dir=.
1646   # Account for people who put trailing slashes in PATH elements.
1647 case $as_dir/ in
1648   ./ | .// | /cC/* | \
1649   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1650   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1651   /usr/ucb/* ) ;;
1652   *)
1653     # OSF1 and SCO ODT 3.0 have their own names for install.
1654     # Don't use installbsd from OSF since it installs stuff as root
1655     # by default.
1656     for ac_prog in ginstall scoinst install; do
1657       for ac_exec_ext in '' $ac_executable_extensions; do
1658         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1659           if test $ac_prog = install &&
1660             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1661             # AIX install.  It has an incompatible calling convention.
1662             :
1663           elif test $ac_prog = install &&
1664             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1665             # program-specific install script used by HP pwplus--don't use.
1666             :
1667           else
1668             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1669             break 3
1670           fi
1671         fi
1672       done
1673     done
1674     ;;
1675 esac
1676 done
1677
1678
1679 fi
1680   if test "${ac_cv_path_install+set}" = set; then
1681     INSTALL=$ac_cv_path_install
1682   else
1683     # As a last resort, use the slow shell script.  We don't cache a
1684     # path for INSTALL within a source directory, because that will
1685     # break other packages using the cache if that directory is
1686     # removed, or if the path is relative.
1687     INSTALL=$ac_install_sh
1688   fi
1689 fi
1690 echo "$as_me:$LINENO: result: $INSTALL" >&5
1691 echo "${ECHO_T}$INSTALL" >&6
1692
1693 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1694 # It thinks the first close brace ends the variable substitution.
1695 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1696
1697 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1698
1699 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1700
1701 echo "$as_me:$LINENO: checking whether ln works" >&5
1702 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1703 if test "${acx_cv_prog_LN+set}" = set; then
1704   echo $ECHO_N "(cached) $ECHO_C" >&6
1705 else
1706   rm -f conftestdata_t
1707 echo >conftestdata_f
1708 if ln conftestdata_f conftestdata_t 2>/dev/null
1709 then
1710   acx_cv_prog_LN=ln
1711 else
1712   acx_cv_prog_LN=no
1713 fi
1714 rm -f conftestdata_f conftestdata_t
1715
1716 fi
1717 if test $acx_cv_prog_LN = no; then
1718   LN="cp"
1719   echo "$as_me:$LINENO: result: no, using $LN" >&5
1720 echo "${ECHO_T}no, using $LN" >&6
1721 else
1722   LN="$acx_cv_prog_LN"
1723   echo "$as_me:$LINENO: result: yes" >&5
1724 echo "${ECHO_T}yes" >&6
1725 fi
1726
1727 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1728 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1729 LN_S=$as_ln_s
1730 if test "$LN_S" = "ln -s"; then
1731   echo "$as_me:$LINENO: result: yes" >&5
1732 echo "${ECHO_T}yes" >&6
1733 else
1734   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1735 echo "${ECHO_T}no, using $LN_S" >&6
1736 fi
1737
1738
1739 ### we might need to use some other shell than /bin/sh for running subshells
1740 ### If we are on Windows, search for the shell.  This will permit people
1741 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1742 ### without also having to set CONFIG_SHELL.  This code will work when
1743 ### using bash, which sets OSTYPE.
1744 case "${OSTYPE}" in
1745 *win32*)
1746   if test x${CONFIG_SHELL} = x ; then
1747     if test ! -f /bin/sh ; then
1748       if test x${SHELL} != x && test -f ${SHELL} ; then
1749         CONFIG_SHELL=${SHELL}
1750         export CONFIG_SHELL
1751       else
1752         for prog in sh sh.exe bash bash.exe; do
1753           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1754           for dir in $PATH; do
1755             test -z "$dir" && dir=.
1756             if test -f $dir/$prog; then
1757               CONFIG_SHELL=$dir/$prog
1758               export CONFIG_SHELL
1759               break
1760             fi
1761           done
1762           IFS="$save_ifs"
1763           test -n "${CONFIG_SHELL}" && break
1764         done
1765       fi
1766     fi
1767   fi
1768   ;;
1769 esac
1770
1771 config_shell=${CONFIG_SHELL-/bin/sh}
1772
1773 progname=$0
1774 # if PWD already has a value, it is probably wrong.
1775 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1776
1777 # Export original configure arguments for use by sub-configures.
1778 # Quote arguments with shell meta charatcers.
1779 TOPLEVEL_CONFIGURE_ARGUMENTS=
1780 set -- "$progname" "$@"
1781 for ac_arg
1782 do
1783   case "$ac_arg" in
1784   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1785     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1786     # if the argument is of the form -foo=baz, quote the baz part only
1787     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1788   *) ;;
1789   esac
1790   # Add the quoted argument to the list.
1791   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1792 done
1793 if test "$silent" = yes; then
1794   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1795 fi
1796 # Remove the initial space we just introduced and, as these will be
1797 # expanded by make, quote '$'.
1798 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1799
1800
1801 moveifchange=${srcdir}/move-if-change
1802
1803 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1804
1805 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1806 # a relative path.
1807 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1808   INSTALL="${srcpwd}/install-sh -c"
1809 fi
1810
1811 # Set srcdir to "." if that's what it is.
1812 # This is important for multilib support.
1813 pwd=`${PWDCMD-pwd}`
1814 if test "${pwd}" = "${srcpwd}" ; then
1815   srcdir=.
1816 fi
1817
1818 topsrcdir=$srcpwd
1819
1820 extra_host_args=
1821
1822 ### To add a new directory to the tree, first choose whether it is a target
1823 ### or a host dependent tool.  Then put it into the appropriate list
1824 ### (library or tools, host or target), doing a dependency sort.
1825
1826 # Subdirs will be configured in the order listed in build_configdirs,
1827 # configdirs, or target_configdirs; see the serialization section below.
1828
1829 # Dependency sorting is only needed when *configuration* must be done in
1830 # a particular order.  In all cases a dependency should be specified in
1831 # the Makefile, whether or not it's implicitly specified here.
1832
1833 # Double entries in build_configdirs, configdirs, or target_configdirs may
1834 # cause circular dependencies and break everything horribly.
1835
1836 # these library is used by various programs built for the build
1837 # environment
1838 #
1839 build_libs="build-libiberty"
1840
1841 # these tools are built for the build environment
1842 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1843
1844 # these libraries are used by various programs built for the host environment
1845 #
1846 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1847
1848 # these tools are built for the host environment
1849 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1850 # know that we are building the simulator.
1851 # binutils, gas and ld appear in that order because it makes sense to run
1852 # "make check" in that particular order.
1853 host_tools="texinfo byacc flex bison binutils gas ld fixincludes gcc sid sim gdb make patch prms send-pr gprof etc expect dejagnu ash bash bzip2 m4 autoconf automake libtool diff rcs fileutils shellutils time textutils wdiff find uudecode hello tar gzip indent recode release sed utils guile perl gawk findutils gettext zip fastjar gnattools"
1854
1855 # libgcj represents the runtime libraries only used by gcj.
1856 libgcj="target-libffi \
1857         target-zlib \
1858         target-qthreads \
1859         target-libjava"
1860
1861 # these libraries are built for the target environment, and are built after
1862 # the host libraries and the host tools (which may be a cross compiler)
1863 #
1864 target_libraries="target-libgcc \
1865                 target-libiberty \
1866                 target-libgloss \
1867                 target-newlib \
1868                 target-libgomp \
1869                 target-libstdc++-v3 \
1870                 target-libmudflap \
1871                 target-libssp \
1872                 target-libgfortran \
1873                 target-boehm-gc \
1874                 ${libgcj} \
1875                 target-libobjc \
1876                 target-libada"
1877
1878 # these tools are built using the target libraries, and are intended to
1879 # run only in the target environment
1880 #
1881 # note: any program that *uses* libraries that are in the "target_libraries"
1882 # list belongs in this list.  those programs are also very likely
1883 # candidates for the "native_only" list which follows
1884 #
1885 target_tools="target-examples target-groff target-gperf target-rda"
1886
1887 ################################################################################
1888
1889 ## All tools belong in one of the four categories, and are assigned above
1890 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1891 ## is important because configure will choke if they ever get through.
1892 ## ${configdirs} is directories we build using the host tools.
1893 ## ${target_configdirs} is directories we build using the target tools.
1894 configdirs=`echo ${host_libs} ${host_tools}`
1895 target_configdirs=`echo ${target_libraries} ${target_tools}`
1896 build_configdirs=`echo ${build_libs} ${build_tools}`
1897
1898 ################################################################################
1899
1900 srcname="gnu development package"
1901
1902 # This gets set non-empty for some net releases of packages.
1903 appdirs=""
1904
1905 # Define is_cross_compiler to save on calls to 'test'.
1906 is_cross_compiler=
1907 if test x"${host}" = x"${target}" ; then
1908   is_cross_compiler=no
1909 else
1910   is_cross_compiler=yes
1911 fi
1912
1913 # Find the build and target subdir names.
1914
1915 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1916 # have matching libraries, they should use host libraries: Makefile.tpl
1917 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1918 # However, they still use the build modules, because the corresponding
1919 # host modules (e.g. bison) are only built for the host when bootstrap
1920 # finishes. So:
1921 # - build_subdir is where we find build modules, and never changes.
1922 # - build_libsubdir is where we find build libraries, and can be overridden.
1923
1924 # Prefix 'build-' so this never conflicts with target_subdir.
1925 build_subdir="build-${build_noncanonical}"
1926
1927 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1928 if test "${with_build_libsubdir+set}" = set; then
1929   withval="$with_build_libsubdir"
1930   build_libsubdir="$withval"
1931 else
1932   build_libsubdir="$build_subdir"
1933 fi;
1934 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1935 if ( test $srcdir = . && test -d gcc ) \
1936    || test -d $srcdir/../host-${host_noncanonical}; then
1937   host_subdir="host-${host_noncanonical}"
1938 else
1939   host_subdir=.
1940 fi
1941 # No prefix.
1942 target_subdir=${target_noncanonical}
1943
1944
1945 # Skipdirs are removed silently.
1946 skipdirs=
1947 # Noconfigdirs are removed loudly.
1948 noconfigdirs=""
1949
1950 use_gnu_ld=
1951 # Make sure we don't let GNU ld be added if we didn't want it.
1952 if test x$with_gnu_ld = xno ; then
1953   use_gnu_ld=no
1954   noconfigdirs="$noconfigdirs ld"
1955 fi
1956
1957 use_gnu_as=
1958 # Make sure we don't let GNU as be added if we didn't want it.
1959 if test x$with_gnu_as = xno ; then
1960   use_gnu_as=no
1961   noconfigdirs="$noconfigdirs gas"
1962 fi
1963
1964 # some tools are so dependent upon X11 that if we're not building with X,
1965 # it's not even worth trying to configure, much less build, that tool.
1966
1967 case ${with_x} in
1968   yes | "") ;; # the default value for this tree is that X11 is available
1969   no)
1970     skipdirs="${skipdirs} tk itcl libgui"
1971     # We won't be able to build gdbtk without X.
1972     enable_gdbtk=no
1973     ;;
1974   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1975 esac
1976
1977 # Some tools are only suitable for building in a "native" situation.
1978 # Remove these if host!=target.
1979 native_only="autoconf automake libtool fileutils find gawk gettext gzip hello indent m4 rcs recode sed shellutils tar textutils uudecode wdiff target-groff guile perl time ash bash bzip2 prms gnuserv target-gperf"
1980
1981 # Similarly, some are only suitable for cross toolchains.
1982 # Remove these if host=target.
1983 cross_only="target-libgloss target-newlib target-opcodes"
1984
1985 case $is_cross_compiler in
1986   no) skipdirs="${skipdirs} ${cross_only}" ;;
1987   yes) skipdirs="${skipdirs} ${native_only}" ;;
1988 esac
1989
1990 # If both --with-headers and --with-libs are specified, default to
1991 # --without-newlib.
1992 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
1993    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
1994   if test x"${with_newlib}" = x ; then
1995     with_newlib=no
1996   fi
1997 fi
1998
1999 # Recognize --with-newlib/--without-newlib.
2000 case ${with_newlib} in
2001   no) skipdirs="${skipdirs} target-newlib" ;;
2002   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2003 esac
2004
2005 # Configure extra directories which are host specific
2006
2007 case "${host}" in
2008   *-cygwin*)
2009     configdirs="$configdirs libtermcap" ;;
2010 esac
2011
2012 # A target can indicate whether a language isn't supported for some reason.
2013 # Only spaces may be used in this macro; not newlines or tabs.
2014 unsupported_languages=
2015
2016 # Remove more programs from consideration, based on the host or
2017 # target this usually means that a port of the program doesn't
2018 # exist yet.
2019
2020 case "${host}" in
2021   hppa*64*-*-*)
2022     noconfigdirs="$noconfigdirs byacc"
2023     ;;
2024   i[3456789]86-*-vsta)
2025     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2026     ;;
2027   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2028     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2029     ;;
2030   x86_64-*-mingw*)
2031     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2032     ;;
2033   i[3456789]86-*-mingw32*)
2034     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2035     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2036     ;;
2037   i[3456789]86-*-beos*)
2038     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2039     ;;
2040   *-*-cygwin*)
2041     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2042     ;;
2043   *-*-netbsd*)
2044     noconfigdirs="$noconfigdirs rcs"
2045     ;;
2046   ppc*-*-pe)
2047     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2048     ;;
2049   powerpc-*-beos*)
2050     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2051     ;;
2052 esac
2053
2054
2055 # Check whether --enable-libada or --disable-libada was given.
2056 if test "${enable_libada+set}" = set; then
2057   enableval="$enable_libada"
2058   ENABLE_LIBADA=$enableval
2059 else
2060   ENABLE_LIBADA=yes
2061 fi;
2062 if test "${ENABLE_LIBADA}" != "yes" ; then
2063   noconfigdirs="$noconfigdirs gnattools"
2064 fi
2065
2066 # Check whether --enable-libssp or --disable-libssp was given.
2067 if test "${enable_libssp+set}" = set; then
2068   enableval="$enable_libssp"
2069   ENABLE_LIBSSP=$enableval
2070 else
2071   ENABLE_LIBSSP=yes
2072 fi;
2073
2074 # Save it here so that, even in case of --enable-libgcj, if the Java
2075 # front-end isn't enabled, we still get libgcj disabled.
2076 libgcj_saved=$libgcj
2077 case $enable_libgcj in
2078 yes)
2079   # If we reset it here, it won't get added to noconfigdirs in the
2080   # target-specific build rules, so it will be forcibly enabled
2081   # (unless the Java language itself isn't enabled).
2082   libgcj=
2083   ;;
2084 no)
2085   # Make sure we get it printed in the list of not supported target libs.
2086   noconfigdirs="$noconfigdirs ${libgcj}"
2087   ;;
2088 esac
2089
2090
2091 # Disable libmudflap on some systems.
2092 if test x$enable_libmudflap = x ; then
2093     case "${target}" in
2094     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2095         # Enable libmudflap by default in GNU and friends.
2096         ;;
2097     *-*-freebsd*)
2098         # Enable libmudflap by default in FreeBSD.
2099         ;;
2100     *)
2101         # Disable it by default everywhere else.
2102         noconfigdirs="$noconfigdirs target-libmudflap"
2103         ;;
2104     esac
2105 fi
2106
2107 # Disable libgomp on non POSIX hosted systems.
2108 if test x$enable_libgomp = x ; then
2109     # Enable libgomp by default on hosted POSIX systems.
2110     case "${target}" in
2111     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2112         ;;
2113     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2114         ;;
2115     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2116         ;;
2117     *-*-darwin* | *-*-aix*)
2118         ;;
2119     *)
2120         noconfigdirs="$noconfigdirs target-libgomp"
2121         ;;
2122     esac
2123 fi
2124
2125 # Default libgloss CPU subdirectory.
2126 libgloss_dir="$target_cpu"
2127
2128 case "${target}" in
2129   *-*-chorusos)
2130     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2131     ;;
2132   powerpc-*-darwin* | i[3456789]86-*-darwin*)
2133     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2134     noconfigdirs="$noconfigdirs sim target-rda"
2135     ;;
2136   *-*-darwin*)
2137     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2138     noconfigdirs="$noconfigdirs sim target-rda"
2139     noconfigdirs="$noconfigdirs ${libgcj}"
2140     ;;
2141   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2142     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2143     ;;
2144   *-*-freebsd*)
2145     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2146     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2147         && test -f /usr/local/include/gmp.h; then
2148       with_gmp=/usr/local
2149     fi
2150
2151     # Skip some stuff that's unsupported on some FreeBSD configurations.
2152     case "${target}" in
2153       i*86-*-*) ;;
2154       alpha*-*-*) ;;
2155       *)
2156         noconfigdirs="$noconfigdirs ${libgcj}"
2157         ;;
2158     esac
2159     ;;
2160   *-*-kaos*)
2161     # Remove unsupported stuff on all kaOS configurations.
2162     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2163     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2164     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2165     noconfigdirs="$noconfigdirs target-libgloss"
2166     ;;
2167   *-*-netbsd*)
2168     # Skip some stuff on all NetBSD configurations.
2169     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2170
2171     # Skip some stuff that's unsupported on some NetBSD configurations.
2172     case "${target}" in
2173       i*86-*-netbsdelf*) ;;
2174       arm*-*-netbsdelf*) ;;
2175       *)
2176         noconfigdirs="$noconfigdirs ${libgcj}"
2177         ;;
2178     esac
2179     ;;
2180   *-*-netware*)
2181     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2182     ;;
2183   *-*-rtems*)
2184     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2185     ;;
2186     # The tpf target doesn't support gdb yet.
2187   *-*-tpf*)
2188     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2189     ;;
2190   *-*-uclinux*)
2191     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2192     ;;
2193   *-*-vxworks*)
2194     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2195     ;;
2196   alpha*-dec-osf*)
2197     # ld works, but does not support shared libraries.
2198     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2199     # gas doesn't generate exception information.
2200     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2201     ;;
2202   alpha*-*-*vms*)
2203     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2204     ;;
2205   alpha*-*-linux*)
2206     # newlib is not 64 bit ready
2207     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2208     ;;
2209   alpha*-*-*)
2210     # newlib is not 64 bit ready
2211     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2212     ;;
2213   am33_2.0-*-linux*)
2214     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2215     ;;
2216   sh-*-linux*)
2217     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2218     ;;
2219   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2220     noconfigdirs="$noconfigdirs ${libgcj}"
2221     noconfigdirs="$noconfigdirs target-examples"
2222     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2223     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2224     noconfigdirs="$noconfigdirs expect dejagnu"
2225     # the C++ libraries don't build on top of CE's C libraries
2226     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2227     noconfigdirs="$noconfigdirs target-newlib"
2228     case "${host}" in
2229       *-*-cygwin*) ;; # keep gdb and readline
2230       *) noconfigdirs="$noconfigdirs gdb readline"
2231          ;;
2232     esac
2233     libgloss_dir=wince
2234     ;;
2235   arc-*-*)
2236     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2237     ;;
2238   arm-semi-aof )
2239     ;;
2240   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2241     noconfigdirs="$noconfigdirs ${libgcj}"
2242     libgloss_dir=arm
2243     ;;
2244   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2245     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2246     libgloss_dir=arm
2247     ;;
2248   arm*-*-linux-gnueabi)
2249     noconfigdirs="$noconfigdirs target-qthreads"
2250     noconfigdirs="$noconfigdirs target-libobjc"
2251     case ${with_newlib} in
2252       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2253     esac
2254     libgloss_dir=arm
2255     ;;
2256   arm*-*-symbianelf*)
2257     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2258     libgloss_dir=arm
2259     ;;
2260   arm-*-pe*)
2261     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2262     ;;
2263   thumb-*-coff)
2264     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2265     ;;
2266   thumb-*-elf)
2267     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2268     ;;
2269   thumb-*-pe)
2270     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2271     ;;
2272   arm-*-riscix*)
2273     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2274     ;;
2275   avr-*-*)
2276     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2277     ;;
2278   bfin-*-*)
2279     noconfigdirs="$noconfigdirs gdb"
2280     if test x${is_cross_compiler} != xno ; then
2281       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2282     fi
2283     ;;
2284   c4x-*-* | tic4x-*-*)
2285     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2286     ;;
2287   c54x*-*-* | tic54x-*-*)
2288     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2289     ;;
2290   cris-*-* | crisv32-*-*)
2291     unsupported_languages="$unsupported_languages java"
2292     case "${target}" in
2293       *-*-aout)
2294         unsupported_languages="$unsupported_languages fortran"
2295         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2296       *-*-elf)
2297         unsupported_languages="$unsupported_languages fortran"
2298         noconfigdirs="$noconfigdirs target-boehm-gc";;
2299       *-*-linux*)
2300         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2301       *)
2302         unsupported_languages="$unsupported_languages fortran"
2303         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2304     esac
2305     libgloss_dir=cris
2306     ;;
2307   crx-*-*)
2308     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2309     ;;
2310   d10v-*-*)
2311     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2312     ;;
2313   d30v-*-*)
2314     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2315     ;;
2316   ep9312-*-elf | ep9312-*-coff)
2317     libgloss_dir=arm
2318     ;;
2319   fr30-*-elf*)
2320     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2321     ;;
2322   frv-*-*)
2323     noconfigdirs="$noconfigdirs ${libgcj}"
2324     ;;
2325   h8300*-*-*)
2326     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2327     ;;
2328   h8500-*-*)
2329     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2330     ;;
2331   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2332     ;;
2333   hppa*64*-*-linux* | parisc*64*-*-linux*)
2334     # In this case, it's because the hppa64-linux target is for
2335     # the kernel only at this point and has no libc, and thus no
2336     # headers, crt*.o, etc., all of which are needed by these.
2337     noconfigdirs="$noconfigdirs target-zlib"
2338     ;;
2339   parisc*-*-linux* | hppa*-*-linux*)
2340     ;;
2341   hppa*-*-*elf* | \
2342   hppa*-*-lites* | \
2343   hppa*-*-openbsd* | \
2344   hppa*64*-*-*)
2345     noconfigdirs="$noconfigdirs ${libgcj}"
2346     ;;
2347   hppa*-hp-hpux11*)
2348     noconfigdirs="$noconfigdirs ld shellutils"
2349     ;;
2350   hppa*-*-pro*)
2351     libgloss_dir=pa
2352     ;;
2353   hppa*-*-*)
2354     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2355     # build on HP-UX 10.20.
2356     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2357     ;;
2358   i960-*-*)
2359     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2360     ;;
2361   ia64*-*-elf*)
2362     # No gdb support yet.
2363     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2364     ;;
2365   ia64*-**-hpux*)
2366     # No gdb or ld support yet.
2367     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2368     ;;
2369   i370-*-opened*)
2370     ;;
2371   i[3456789]86-*-coff | i[3456789]86-*-elf)
2372     noconfigdirs="$noconfigdirs ${libgcj}"
2373     libgloss_dir=i386
2374     ;;
2375   i[3456789]86-*-linux*)
2376     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2377     # not build java stuff by default.
2378     case "${target}" in
2379       *-*-*libc1*)
2380         noconfigdirs="$noconfigdirs ${libgcj}";;
2381     esac
2382
2383     # This section makes it possible to build newlib natively on linux.
2384     # If we are using a cross compiler then don't configure newlib.
2385     if test x${is_cross_compiler} != xno ; then
2386       noconfigdirs="$noconfigdirs target-newlib"
2387     fi
2388     noconfigdirs="$noconfigdirs target-libgloss"
2389     # If we are not using a cross compiler, do configure newlib.
2390     # Note however, that newlib will only be configured in this situation
2391     # if the --with-newlib option has been given, because otherwise
2392     # 'target-newlib' will appear in skipdirs.
2393     ;;
2394   i[3456789]86-*-mingw32*)
2395     target_configdirs="$target_configdirs target-winsup"
2396     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2397     ;;
2398   x86_64-*-mingw*)
2399     target_configdirs="$target_configdirs target-winsup"
2400     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2401     ;;
2402   *-*-cygwin*)
2403     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2404     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2405     # always build newlib if winsup directory is present.
2406     if test -d "$srcdir/winsup/cygwin"; then
2407       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2408     elif test -d "$srcdir/newlib"; then
2409       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2410     fi
2411     ;;
2412   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2413   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2414     ;;
2415   i[3456789]86-*-pe)
2416     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2417     ;;
2418   i[3456789]86-*-sco3.2v5*)
2419     # The linker does not yet know about weak symbols in COFF,
2420     # and is not configured to handle mixed ELF and COFF.
2421     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2422     ;;
2423   i[3456789]86-*-sco*)
2424     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2425     ;;
2426   i[3456789]86-*-solaris2*)
2427     noconfigdirs="$noconfigdirs target-libgloss"
2428     ;;
2429   i[3456789]86-*-sysv4*)
2430     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2431     ;;
2432   i[3456789]86-*-beos*)
2433     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2434     ;;
2435   i[3456789]86-*-rdos*)
2436     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2437     ;;
2438   m32r-*-*)
2439     noconfigdirs="$noconfigdirs ${libgcj}"
2440     ;;
2441   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2442     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2443     libgloss_dir=m68hc11
2444     ;;
2445   m68k-*-elf*)
2446     noconfigdirs="$noconfigdirs ${libgcj}"
2447     ;;
2448   m68k-*-coff*)
2449     noconfigdirs="$noconfigdirs ${libgcj}"
2450     ;;
2451   m68*-*-* | fido-*-*)
2452     libgloss_dir=m68k
2453     ;;
2454   mcore-*-pe*)
2455   # The EPOC C++ environment does not support exceptions or rtti,
2456   # and so building libstdc++-v3 tends not to always work.
2457     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2458     ;;
2459   mmix-*-*)
2460     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2461     unsupported_languages="$unsupported_languages fortran java"
2462     ;;
2463   mn10200-*-*)
2464     noconfigdirs="$noconfigdirs ${libgcj}"
2465     ;;
2466   mn10300-*-*)
2467     noconfigdirs="$noconfigdirs ${libgcj}"
2468     ;;
2469   mt-*-*)
2470     noconfigdirs="$noconfigdirs sim"
2471     ;;
2472   powerpc-*-aix*)
2473     # copied from rs6000-*-* entry
2474     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2475     ;;
2476   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2477     target_configdirs="$target_configdirs target-winsup"
2478     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2479     # always build newlib.
2480     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2481     ;;
2482     # This is temporary until we can link against shared libraries
2483   powerpcle-*-solaris*)
2484     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2485     libgloss_dir=rs6000
2486     ;;
2487   powerpc-*-beos*)
2488     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2489     ;;
2490   powerpc-*-eabi)
2491     noconfigdirs="$noconfigdirs ${libgcj}"
2492     libgloss_dir=rs6000
2493     ;;
2494   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2495     libgloss_dir=rs6000
2496     ;;
2497   rs6000-*-lynxos*)
2498     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2499     ;;
2500   rs6000-*-aix*)
2501     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2502     ;;
2503   rs6000-*-*)
2504     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2505     ;;
2506   m68k-apollo-*)
2507     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2508     ;;
2509   mips*-sde-elf*)
2510     skipdirs="$skipdirs target-libiberty"
2511     noconfigdirs="$noconfigdirs ${libgcj}"
2512     if test x$with_newlib = xyes; then
2513       noconfigdirs="$noconfigdirs gprof"
2514     fi
2515     libgloss_dir=mips
2516     ;;
2517   mips*-*-irix5*)
2518     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2519     ;;
2520   mips*-*-irix6*)
2521     # Linking libjava exceeds command-line length limits on at least
2522     # IRIX 6.2, but not on IRIX 6.5.
2523     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2524     # <oldham@codesourcery.com>
2525     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2526     ;;
2527   mips*-*-bsd*)
2528     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2529     ;;
2530   mips*-*-linux*)
2531     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2532     ;;
2533   mips*-*-*)
2534     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2535     libgloss_dir=mips
2536     ;;
2537   romp-*-*)
2538     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2539     ;;
2540   sh-*-* | sh64-*-*)
2541     case "${host}" in
2542       i[3456789]86-*-vsta) ;; # don't add gprof back in
2543       i[3456789]86-*-go32*) ;; # don't add gprof back in
2544       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2545       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2546     esac
2547     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2548     ;;
2549   sparclet-*-aout* | sparc86x-*-*)
2550     libgloss_dir=sparc
2551     ;;
2552   sparc-*-elf*)
2553     noconfigdirs="$noconfigdirs ${libgcj}"
2554     ;;
2555   sparc64-*-elf*)
2556     noconfigdirs="$noconfigdirs ${libgcj}"
2557     libgloss_dir=sparc
2558     ;;
2559   sparclite-*-*)
2560     noconfigdirs="$noconfigdirs ${libgcj}"
2561     libgloss_dir=sparc
2562     ;;
2563   sparc-*-sunos4*)
2564     noconfigdirs="$noconfigdirs ${libgcj}"
2565     if test x${is_cross_compiler} != xno ; then
2566            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2567     else
2568            use_gnu_ld=no
2569     fi
2570     ;;
2571   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2572     noconfigdirs="$noconfigdirs ${libgcj}"
2573     ;;
2574   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2575     ;;
2576   spu-*-*)
2577     skipdirs="target-libssp"
2578     ;;
2579   v810-*-*)
2580     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2581     ;;
2582   v850-*-*)
2583     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2584     ;;
2585   v850e-*-*)
2586     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2587     ;;
2588   v850ea-*-*)
2589     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2590     ;;
2591   vax-*-vms)
2592     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2593     ;;
2594   vax-*-*)
2595     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2596     ;;
2597   xtensa-*-*)
2598     noconfigdirs="$noconfigdirs ${libgcj}"
2599     ;;
2600   ip2k-*-*)
2601     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2602     ;;
2603   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2604     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2605     ;;
2606   *-*-lynxos*)
2607     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2608     ;;
2609   *-*-*)
2610     noconfigdirs="$noconfigdirs ${libgcj}"
2611     ;;
2612 esac
2613
2614 # If we aren't building newlib, then don't build libgloss, since libgloss
2615 # depends upon some newlib header files.
2616 case "${noconfigdirs}" in
2617   *target-libgloss*) ;;
2618   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2619 esac
2620
2621 # Work in distributions that contain no compiler tools, like Autoconf.
2622 tentative_cc=""
2623 host_makefile_frag=/dev/null
2624 if test -d ${srcdir}/config ; then
2625 case "${host}" in
2626   m68k-hp-hpux*)
2627     # Avoid "too much defining" errors from HPUX compiler.
2628     tentative_cc="cc -Wp,-H256000"
2629     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2630     # If it's HP/UX ar, this should be harmless.
2631     RANLIB="ar ts"
2632     ;;
2633   m68k-apollo-sysv*)
2634     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2635     ;;
2636   m68k-apollo-bsd*)
2637     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2638     # chokes on bfd, the compiler won't let you assign integers to enums, and
2639     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2640     # the apollo compiler" (the preferred version of GCC could be called cc,
2641     # or whatever), but I'm not sure leaving CC as cc is any better...
2642     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2643     # Used to have BISON=yacc.
2644     tentative_cc=gcc
2645     ;;
2646   m88k-dg-dgux*)
2647     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2648     ;;
2649   m88k-harris-cxux*)
2650     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2651     tentative_cc="cc -Xa"
2652     host_makefile_frag="config/mh-cxux"
2653     ;;
2654   m88k-motorola-sysv*)
2655     ;;
2656   mips*-dec-ultrix*)
2657     tentative_cc="cc -Wf,-XNg1000"
2658     host_makefile_frag="config/mh-decstation"
2659     ;;
2660   mips*-nec-sysv4*)
2661     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2662     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2663     host_makefile_frag="config/mh-necv4"
2664     ;;
2665   mips*-sgi-irix4*)
2666     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2667     # environment.  Also bump switch table size so that cp-parse will
2668     # compile.  Bump string length limit so linker builds.
2669     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2670     ;;
2671   mips*-*-sysv4*)
2672     host_makefile_frag="config/mh-sysv4"
2673     ;;
2674   mips*-*-sysv*)
2675     # This is for a MIPS running RISC/os 4.52C.
2676
2677     # This is needed for GDB, but needs to be in the top-level make because
2678     # if a library is compiled with the bsd headers and gets linked with the
2679     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2680     # a different size).
2681     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2682     # known except to select the sysv environment.  Could we use /proc instead?
2683     # These "sysv environments" and "bsd environments" often end up being a pain.
2684     #
2685     # This is not part of CFLAGS because perhaps not all C compilers have this
2686     # option.
2687     tentative_cc="cc -systype sysv"
2688     ;;
2689   i370-ibm-opened*)
2690     tentative_cc="c89"
2691     ;;
2692   i[3456789]86-*-sysv5*)
2693     host_makefile_frag="config/mh-sysv5"
2694     ;;
2695   i[3456789]86-*-dgux*)
2696     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2697     host_makefile_frag="config/mh-dgux386"
2698     ;;
2699   i[3456789]86-ncr-sysv4.3*)
2700     # The MetaWare compiler will generate a copyright message unless you
2701     # turn it off by adding the -Hnocopyr flag.
2702     tentative_cc="cc -Hnocopyr"
2703     ;;
2704   i[3456789]86-ncr-sysv4*)
2705     # for an NCR 3000 (i486/SVR4) system.
2706     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2707     # This compiler not only emits obnoxious copyright messages every time
2708     # you run it, but it chokes and dies on a whole bunch of GNU source
2709     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2710     tentative_cc="/usr/ccs/ATT/cc"
2711     host_makefile_frag="config/mh-ncr3000"
2712     ;;
2713   i[3456789]86-*-sco3.2v5*)
2714     ;;
2715   i[3456789]86-*-sco*)
2716     # The native C compiler botches some simple uses of const.  Unfortunately,
2717     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2718     tentative_cc="cc -Dconst="
2719     host_makefile_frag="config/mh-sco"
2720     ;;
2721   i[3456789]86-*-udk*)
2722     host_makefile_frag="config/mh-sysv5"
2723     ;;
2724   i[3456789]86-*-solaris2*)
2725     host_makefile_frag="config/mh-sysv4"
2726     ;;
2727   i[3456789]86-*-msdosdjgpp*)
2728     host_makefile_frag="config/mh-djgpp"
2729     ;;
2730   *-cygwin*)
2731     host_makefile_frag="config/mh-cygwin"
2732     ;;
2733   *-mingw32*)
2734     host_makefile_frag="config/mh-mingw"
2735     ;;
2736   *-mingw64*)
2737     host_makefile_frag="config/mh-mingw"
2738     ;;
2739   *-interix*)
2740     host_makefile_frag="config/mh-interix"
2741     ;;
2742   vax-*-ultrix2*)
2743     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2744     tentative_cc=gcc
2745     ;;
2746   *-*-solaris2*)
2747     host_makefile_frag="config/mh-solaris"
2748     ;;
2749   m68k-sun-sunos*)
2750     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2751     # without overflowing the jump tables (-J says to use a 32 bit table)
2752     tentative_cc="cc -J"
2753     ;;
2754   *-hp-hpux*)
2755     tentative_cc="cc -Wp,-H256000"
2756     ;;
2757   *-*-hiux*)
2758     tentative_cc="cc -Wp,-H256000"
2759     ;;
2760   rs6000-*-lynxos*)
2761     # /bin/cc is less than useful for our purposes.  Always use GCC
2762     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2763     host_makefile_frag="config/mh-lynxrs6k"
2764     ;;
2765   powerpc-*-darwin*)
2766     host_makefile_frag="config/mh-ppc-darwin"
2767     ;;
2768   powerpc-*-aix*)
2769     host_makefile_frag="config/mh-ppc-aix"
2770     ;;
2771   rs6000-*-aix*)
2772     host_makefile_frag="config/mh-ppc-aix"
2773     ;;
2774   *-*-lynxos*)
2775     # /bin/cc is less than useful for our purposes.  Always use GCC
2776     tentative_cc="/bin/gcc"
2777     ;;
2778   *-*-sysv4*)
2779     host_makefile_frag="config/mh-sysv4"
2780     ;;
2781   # This is placed last to prevent interfering with the cases above.
2782   i[3456789]86-*-*)
2783     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2784     host_makefile_frag="config/mh-x86omitfp"
2785     ;;
2786 esac
2787 fi
2788
2789 # If we aren't going to be using gcc, see if we can extract a definition
2790 # of CC from the fragment.
2791 # Actually, use the 'pre-extracted' version above.
2792 if test -z "${CC}" && test "${build}" = "${host}" ; then
2793   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2794   found=
2795   for dir in $PATH; do
2796     test -z "$dir" && dir=.
2797     if test -f $dir/gcc; then
2798       found=yes
2799       break
2800     fi
2801   done
2802   IFS="$save_ifs"
2803   if test -z "${found}" && test -n "${tentative_cc}" ; then
2804     CC=$tentative_cc
2805   fi
2806 fi
2807
2808 if test "${build}" != "${host}" ; then
2809   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2810   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2811   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2812   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2813   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2814   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2815   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2816   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2817   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2818   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2819   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2820   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2821 else
2822   AR_FOR_BUILD="\$(AR)"
2823   AS_FOR_BUILD="\$(AS)"
2824   CC_FOR_BUILD="\$(CC)"
2825   CXX_FOR_BUILD="\$(CXX)"
2826   GCJ_FOR_BUILD="\$(GCJ)"
2827   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2828   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2829   LD_FOR_BUILD="\$(LD)"
2830   NM_FOR_BUILD="\$(NM)"
2831   RANLIB_FOR_BUILD="\$(RANLIB)"
2832   WINDRES_FOR_BUILD="\$(WINDRES)"
2833   WINDMC_FOR_BUILD="\$(WINDMC)"
2834 fi
2835
2836 ac_ext=c
2837 ac_cpp='$CPP $CPPFLAGS'
2838 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2839 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2840 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2841 if test -n "$ac_tool_prefix"; then
2842   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2843 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2844 echo "$as_me:$LINENO: checking for $ac_word" >&5
2845 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2846 if test "${ac_cv_prog_CC+set}" = set; then
2847   echo $ECHO_N "(cached) $ECHO_C" >&6
2848 else
2849   if test -n "$CC"; then
2850   ac_cv_prog_CC="$CC" # Let the user override the test.
2851 else
2852 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2853 for as_dir in $PATH
2854 do
2855   IFS=$as_save_IFS
2856   test -z "$as_dir" && as_dir=.
2857   for ac_exec_ext in '' $ac_executable_extensions; do
2858   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2859     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2860     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2861     break 2
2862   fi
2863 done
2864 done
2865
2866 fi
2867 fi
2868 CC=$ac_cv_prog_CC
2869 if test -n "$CC"; then
2870   echo "$as_me:$LINENO: result: $CC" >&5
2871 echo "${ECHO_T}$CC" >&6
2872 else
2873   echo "$as_me:$LINENO: result: no" >&5
2874 echo "${ECHO_T}no" >&6
2875 fi
2876
2877 fi
2878 if test -z "$ac_cv_prog_CC"; then
2879   ac_ct_CC=$CC
2880   # Extract the first word of "gcc", so it can be a program name with args.
2881 set dummy gcc; ac_word=$2
2882 echo "$as_me:$LINENO: checking for $ac_word" >&5
2883 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2884 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2885   echo $ECHO_N "(cached) $ECHO_C" >&6
2886 else
2887   if test -n "$ac_ct_CC"; then
2888   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2889 else
2890 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2891 for as_dir in $PATH
2892 do
2893   IFS=$as_save_IFS
2894   test -z "$as_dir" && as_dir=.
2895   for ac_exec_ext in '' $ac_executable_extensions; do
2896   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2897     ac_cv_prog_ac_ct_CC="gcc"
2898     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2899     break 2
2900   fi
2901 done
2902 done
2903
2904 fi
2905 fi
2906 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2907 if test -n "$ac_ct_CC"; then
2908   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2909 echo "${ECHO_T}$ac_ct_CC" >&6
2910 else
2911   echo "$as_me:$LINENO: result: no" >&5
2912 echo "${ECHO_T}no" >&6
2913 fi
2914
2915   CC=$ac_ct_CC
2916 else
2917   CC="$ac_cv_prog_CC"
2918 fi
2919
2920 if test -z "$CC"; then
2921   if test -n "$ac_tool_prefix"; then
2922   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2923 set dummy ${ac_tool_prefix}cc; ac_word=$2
2924 echo "$as_me:$LINENO: checking for $ac_word" >&5
2925 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2926 if test "${ac_cv_prog_CC+set}" = set; then
2927   echo $ECHO_N "(cached) $ECHO_C" >&6
2928 else
2929   if test -n "$CC"; then
2930   ac_cv_prog_CC="$CC" # Let the user override the test.
2931 else
2932 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2933 for as_dir in $PATH
2934 do
2935   IFS=$as_save_IFS
2936   test -z "$as_dir" && as_dir=.
2937   for ac_exec_ext in '' $ac_executable_extensions; do
2938   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2939     ac_cv_prog_CC="${ac_tool_prefix}cc"
2940     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2941     break 2
2942   fi
2943 done
2944 done
2945
2946 fi
2947 fi
2948 CC=$ac_cv_prog_CC
2949 if test -n "$CC"; then
2950   echo "$as_me:$LINENO: result: $CC" >&5
2951 echo "${ECHO_T}$CC" >&6
2952 else
2953   echo "$as_me:$LINENO: result: no" >&5
2954 echo "${ECHO_T}no" >&6
2955 fi
2956
2957 fi
2958 if test -z "$ac_cv_prog_CC"; then
2959   ac_ct_CC=$CC
2960   # Extract the first word of "cc", so it can be a program name with args.
2961 set dummy cc; ac_word=$2
2962 echo "$as_me:$LINENO: checking for $ac_word" >&5
2963 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2964 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2965   echo $ECHO_N "(cached) $ECHO_C" >&6
2966 else
2967   if test -n "$ac_ct_CC"; then
2968   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2969 else
2970 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2971 for as_dir in $PATH
2972 do
2973   IFS=$as_save_IFS
2974   test -z "$as_dir" && as_dir=.
2975   for ac_exec_ext in '' $ac_executable_extensions; do
2976   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2977     ac_cv_prog_ac_ct_CC="cc"
2978     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2979     break 2
2980   fi
2981 done
2982 done
2983
2984 fi
2985 fi
2986 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2987 if test -n "$ac_ct_CC"; then
2988   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2989 echo "${ECHO_T}$ac_ct_CC" >&6
2990 else
2991   echo "$as_me:$LINENO: result: no" >&5
2992 echo "${ECHO_T}no" >&6
2993 fi
2994
2995   CC=$ac_ct_CC
2996 else
2997   CC="$ac_cv_prog_CC"
2998 fi
2999
3000 fi
3001 if test -z "$CC"; then
3002   # Extract the first word of "cc", so it can be a program name with args.
3003 set dummy cc; ac_word=$2
3004 echo "$as_me:$LINENO: checking for $ac_word" >&5
3005 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3006 if test "${ac_cv_prog_CC+set}" = set; then
3007   echo $ECHO_N "(cached) $ECHO_C" >&6
3008 else
3009   if test -n "$CC"; then
3010   ac_cv_prog_CC="$CC" # Let the user override the test.
3011 else
3012   ac_prog_rejected=no
3013 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3014 for as_dir in $PATH
3015 do
3016   IFS=$as_save_IFS
3017   test -z "$as_dir" && as_dir=.
3018   for ac_exec_ext in '' $ac_executable_extensions; do
3019   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3020     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3021        ac_prog_rejected=yes
3022        continue
3023      fi
3024     ac_cv_prog_CC="cc"
3025     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3026     break 2
3027   fi
3028 done
3029 done
3030
3031 if test $ac_prog_rejected = yes; then
3032   # We found a bogon in the path, so make sure we never use it.
3033   set dummy $ac_cv_prog_CC
3034   shift
3035   if test $# != 0; then
3036     # We chose a different compiler from the bogus one.
3037     # However, it has the same basename, so the bogon will be chosen
3038     # first if we set CC to just the basename; use the full file name.
3039     shift
3040     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3041   fi
3042 fi
3043 fi
3044 fi
3045 CC=$ac_cv_prog_CC
3046 if test -n "$CC"; then
3047   echo "$as_me:$LINENO: result: $CC" >&5
3048 echo "${ECHO_T}$CC" >&6
3049 else
3050   echo "$as_me:$LINENO: result: no" >&5
3051 echo "${ECHO_T}no" >&6
3052 fi
3053
3054 fi
3055 if test -z "$CC"; then
3056   if test -n "$ac_tool_prefix"; then
3057   for ac_prog in cl
3058   do
3059     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3060 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3061 echo "$as_me:$LINENO: checking for $ac_word" >&5
3062 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3063 if test "${ac_cv_prog_CC+set}" = set; then
3064   echo $ECHO_N "(cached) $ECHO_C" >&6
3065 else
3066   if test -n "$CC"; then
3067   ac_cv_prog_CC="$CC" # Let the user override the test.
3068 else
3069 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3070 for as_dir in $PATH
3071 do
3072   IFS=$as_save_IFS
3073   test -z "$as_dir" && as_dir=.
3074   for ac_exec_ext in '' $ac_executable_extensions; do
3075   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3076     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3077     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3078     break 2
3079   fi
3080 done
3081 done
3082
3083 fi
3084 fi
3085 CC=$ac_cv_prog_CC
3086 if test -n "$CC"; then
3087   echo "$as_me:$LINENO: result: $CC" >&5
3088 echo "${ECHO_T}$CC" >&6
3089 else
3090   echo "$as_me:$LINENO: result: no" >&5
3091 echo "${ECHO_T}no" >&6
3092 fi
3093
3094     test -n "$CC" && break
3095   done
3096 fi
3097 if test -z "$CC"; then
3098   ac_ct_CC=$CC
3099   for ac_prog in cl
3100 do
3101   # Extract the first word of "$ac_prog", so it can be a program name with args.
3102 set dummy $ac_prog; ac_word=$2
3103 echo "$as_me:$LINENO: checking for $ac_word" >&5
3104 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3105 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3106   echo $ECHO_N "(cached) $ECHO_C" >&6
3107 else
3108   if test -n "$ac_ct_CC"; then
3109   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3110 else
3111 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3112 for as_dir in $PATH
3113 do
3114   IFS=$as_save_IFS
3115   test -z "$as_dir" && as_dir=.
3116   for ac_exec_ext in '' $ac_executable_extensions; do
3117   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3118     ac_cv_prog_ac_ct_CC="$ac_prog"
3119     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3120     break 2
3121   fi
3122 done
3123 done
3124
3125 fi
3126 fi
3127 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3128 if test -n "$ac_ct_CC"; then
3129   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3130 echo "${ECHO_T}$ac_ct_CC" >&6
3131 else
3132   echo "$as_me:$LINENO: result: no" >&5
3133 echo "${ECHO_T}no" >&6
3134 fi
3135
3136   test -n "$ac_ct_CC" && break
3137 done
3138
3139   CC=$ac_ct_CC
3140 fi
3141
3142 fi
3143
3144
3145 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3146 See \`config.log' for more details." >&5
3147 echo "$as_me: error: no acceptable C compiler found in \$PATH
3148 See \`config.log' for more details." >&2;}
3149    { (exit 1); exit 1; }; }
3150
3151 # Provide some information about the compiler.
3152 echo "$as_me:$LINENO:" \
3153      "checking for C compiler version" >&5
3154 ac_compiler=`set X $ac_compile; echo $2`
3155 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3156   (eval $ac_compiler --version </dev/null >&5) 2>&5
3157   ac_status=$?
3158   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3159   (exit $ac_status); }
3160 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3161   (eval $ac_compiler -v </dev/null >&5) 2>&5
3162   ac_status=$?
3163   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3164   (exit $ac_status); }
3165 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3166   (eval $ac_compiler -V </dev/null >&5) 2>&5
3167   ac_status=$?
3168   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3169   (exit $ac_status); }
3170
3171 cat >conftest.$ac_ext <<_ACEOF
3172 /* confdefs.h.  */
3173 _ACEOF
3174 cat confdefs.h >>conftest.$ac_ext
3175 cat >>conftest.$ac_ext <<_ACEOF
3176 /* end confdefs.h.  */
3177
3178 int
3179 main ()
3180 {
3181
3182   ;
3183   return 0;
3184 }
3185 _ACEOF
3186 ac_clean_files_save=$ac_clean_files
3187 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3188 # Try to create an executable without -o first, disregard a.out.
3189 # It will help us diagnose broken compilers, and finding out an intuition
3190 # of exeext.
3191 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3192 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3193 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3194 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3195   (eval $ac_link_default) 2>&5
3196   ac_status=$?
3197   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3198   (exit $ac_status); }; then
3199   # Find the output, starting from the most likely.  This scheme is
3200 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3201 # resort.
3202
3203 # Be careful to initialize this variable, since it used to be cached.
3204 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3205 ac_cv_exeext=
3206 # b.out is created by i960 compilers.
3207 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3208 do
3209   test -f "$ac_file" || continue
3210   case $ac_file in
3211     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3212         ;;
3213     conftest.$ac_ext )
3214         # This is the source file.
3215         ;;
3216     [ab].out )
3217         # We found the default executable, but exeext='' is most
3218         # certainly right.
3219         break;;
3220     *.* )
3221         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3222         # FIXME: I believe we export ac_cv_exeext for Libtool,
3223         # but it would be cool to find out if it's true.  Does anybody
3224         # maintain Libtool? --akim.
3225         export ac_cv_exeext
3226         break;;
3227     * )
3228         break;;
3229   esac
3230 done
3231 else
3232   echo "$as_me: failed program was:" >&5
3233 sed 's/^/| /' conftest.$ac_ext >&5
3234
3235 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3236 See \`config.log' for more details." >&5
3237 echo "$as_me: error: C compiler cannot create executables
3238 See \`config.log' for more details." >&2;}
3239    { (exit 77); exit 77; }; }
3240 fi
3241
3242 ac_exeext=$ac_cv_exeext
3243 echo "$as_me:$LINENO: result: $ac_file" >&5
3244 echo "${ECHO_T}$ac_file" >&6
3245
3246 # Check the compiler produces executables we can run.  If not, either
3247 # the compiler is broken, or we cross compile.
3248 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3249 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3250 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3251 # If not cross compiling, check that we can run a simple program.
3252 if test "$cross_compiling" != yes; then
3253   if { ac_try='./$ac_file'
3254   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3255   (eval $ac_try) 2>&5
3256   ac_status=$?
3257   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3258   (exit $ac_status); }; }; then
3259     cross_compiling=no
3260   else
3261     if test "$cross_compiling" = maybe; then
3262         cross_compiling=yes
3263     else
3264         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3265 If you meant to cross compile, use \`--host'.
3266 See \`config.log' for more details." >&5
3267 echo "$as_me: error: cannot run C compiled programs.
3268 If you meant to cross compile, use \`--host'.
3269 See \`config.log' for more details." >&2;}
3270    { (exit 1); exit 1; }; }
3271     fi
3272   fi
3273 fi
3274 echo "$as_me:$LINENO: result: yes" >&5
3275 echo "${ECHO_T}yes" >&6
3276
3277 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3278 ac_clean_files=$ac_clean_files_save
3279 # Check the compiler produces executables we can run.  If not, either
3280 # the compiler is broken, or we cross compile.
3281 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3282 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3283 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3284 echo "${ECHO_T}$cross_compiling" >&6
3285
3286 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3287 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3288 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3289   (eval $ac_link) 2>&5
3290   ac_status=$?
3291   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3292   (exit $ac_status); }; then
3293   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3294 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3295 # work properly (i.e., refer to `conftest.exe'), while it won't with
3296 # `rm'.
3297 for ac_file in conftest.exe conftest conftest.*; do
3298   test -f "$ac_file" || continue
3299   case $ac_file in
3300     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3301     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3302           export ac_cv_exeext
3303           break;;
3304     * ) break;;
3305   esac
3306 done
3307 else
3308   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3309 See \`config.log' for more details." >&5
3310 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3311 See \`config.log' for more details." >&2;}
3312    { (exit 1); exit 1; }; }
3313 fi
3314
3315 rm -f conftest$ac_cv_exeext
3316 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3317 echo "${ECHO_T}$ac_cv_exeext" >&6
3318
3319 rm -f conftest.$ac_ext
3320 EXEEXT=$ac_cv_exeext
3321 ac_exeext=$EXEEXT
3322 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3323 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3324 if test "${ac_cv_objext+set}" = set; then
3325   echo $ECHO_N "(cached) $ECHO_C" >&6
3326 else
3327   cat >conftest.$ac_ext <<_ACEOF
3328 /* confdefs.h.  */
3329 _ACEOF
3330 cat confdefs.h >>conftest.$ac_ext
3331 cat >>conftest.$ac_ext <<_ACEOF
3332 /* end confdefs.h.  */
3333
3334 int
3335 main ()
3336 {
3337
3338   ;
3339   return 0;
3340 }
3341 _ACEOF
3342 rm -f conftest.o conftest.obj
3343 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3344   (eval $ac_compile) 2>&5
3345   ac_status=$?
3346   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3347   (exit $ac_status); }; then
3348   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3349   case $ac_file in
3350     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3351     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3352        break;;
3353   esac
3354 done
3355 else
3356   echo "$as_me: failed program was:" >&5
3357 sed 's/^/| /' conftest.$ac_ext >&5
3358
3359 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3360 See \`config.log' for more details." >&5
3361 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3362 See \`config.log' for more details." >&2;}
3363    { (exit 1); exit 1; }; }
3364 fi
3365
3366 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3367 fi
3368 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3369 echo "${ECHO_T}$ac_cv_objext" >&6
3370 OBJEXT=$ac_cv_objext
3371 ac_objext=$OBJEXT
3372 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3373 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3374 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3375   echo $ECHO_N "(cached) $ECHO_C" >&6
3376 else
3377   cat >conftest.$ac_ext <<_ACEOF
3378 /* confdefs.h.  */
3379 _ACEOF
3380 cat confdefs.h >>conftest.$ac_ext
3381 cat >>conftest.$ac_ext <<_ACEOF
3382 /* end confdefs.h.  */
3383
3384 int
3385 main ()
3386 {
3387 #ifndef __GNUC__
3388        choke me
3389 #endif
3390
3391   ;
3392   return 0;
3393 }
3394 _ACEOF
3395 rm -f conftest.$ac_objext
3396 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3397   (eval $ac_compile) 2>conftest.er1
3398   ac_status=$?
3399   grep -v '^ *+' conftest.er1 >conftest.err
3400   rm -f conftest.er1
3401   cat conftest.err >&5
3402   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3403   (exit $ac_status); } &&
3404          { ac_try='test -z "$ac_c_werror_flag"
3405                          || test ! -s conftest.err'
3406   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3407   (eval $ac_try) 2>&5
3408   ac_status=$?
3409   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3410   (exit $ac_status); }; } &&
3411          { ac_try='test -s conftest.$ac_objext'
3412   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3413   (eval $ac_try) 2>&5
3414   ac_status=$?
3415   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3416   (exit $ac_status); }; }; then
3417   ac_compiler_gnu=yes
3418 else
3419   echo "$as_me: failed program was:" >&5
3420 sed 's/^/| /' conftest.$ac_ext >&5
3421
3422 ac_compiler_gnu=no
3423 fi
3424 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3425 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3426
3427 fi
3428 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3429 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3430 GCC=`test $ac_compiler_gnu = yes && echo yes`
3431 ac_test_CFLAGS=${CFLAGS+set}
3432 ac_save_CFLAGS=$CFLAGS
3433 CFLAGS="-g"
3434 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3435 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3436 if test "${ac_cv_prog_cc_g+set}" = set; then
3437   echo $ECHO_N "(cached) $ECHO_C" >&6
3438 else
3439   cat >conftest.$ac_ext <<_ACEOF
3440 /* confdefs.h.  */
3441 _ACEOF
3442 cat confdefs.h >>conftest.$ac_ext
3443 cat >>conftest.$ac_ext <<_ACEOF
3444 /* end confdefs.h.  */
3445
3446 int
3447 main ()
3448 {
3449
3450   ;
3451   return 0;
3452 }
3453 _ACEOF
3454 rm -f conftest.$ac_objext
3455 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3456   (eval $ac_compile) 2>conftest.er1
3457   ac_status=$?
3458   grep -v '^ *+' conftest.er1 >conftest.err
3459   rm -f conftest.er1
3460   cat conftest.err >&5
3461   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3462   (exit $ac_status); } &&
3463          { ac_try='test -z "$ac_c_werror_flag"
3464                          || test ! -s conftest.err'
3465   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3466   (eval $ac_try) 2>&5
3467   ac_status=$?
3468   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3469   (exit $ac_status); }; } &&
3470          { ac_try='test -s conftest.$ac_objext'
3471   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3472   (eval $ac_try) 2>&5
3473   ac_status=$?
3474   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3475   (exit $ac_status); }; }; then
3476   ac_cv_prog_cc_g=yes
3477 else
3478   echo "$as_me: failed program was:" >&5
3479 sed 's/^/| /' conftest.$ac_ext >&5
3480
3481 ac_cv_prog_cc_g=no
3482 fi
3483 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3484 fi
3485 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3486 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3487 if test "$ac_test_CFLAGS" = set; then
3488   CFLAGS=$ac_save_CFLAGS
3489 elif test $ac_cv_prog_cc_g = yes; then
3490   if test "$GCC" = yes; then
3491     CFLAGS="-g -O2"
3492   else
3493     CFLAGS="-g"
3494   fi
3495 else
3496   if test "$GCC" = yes; then
3497     CFLAGS="-O2"
3498   else
3499     CFLAGS=
3500   fi
3501 fi
3502 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3503 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3504 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3505   echo $ECHO_N "(cached) $ECHO_C" >&6
3506 else
3507   ac_cv_prog_cc_stdc=no
3508 ac_save_CC=$CC
3509 cat >conftest.$ac_ext <<_ACEOF
3510 /* confdefs.h.  */
3511 _ACEOF
3512 cat confdefs.h >>conftest.$ac_ext
3513 cat >>conftest.$ac_ext <<_ACEOF
3514 /* end confdefs.h.  */
3515 #include <stdarg.h>
3516 #include <stdio.h>
3517 #include <sys/types.h>
3518 #include <sys/stat.h>
3519 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3520 struct buf { int x; };
3521 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3522 static char *e (p, i)
3523      char **p;
3524      int i;
3525 {
3526   return p[i];
3527 }
3528 static char *f (char * (*g) (char **, int), char **p, ...)
3529 {
3530   char *s;
3531   va_list v;
3532   va_start (v,p);
3533   s = g (p, va_arg (v,int));
3534   va_end (v);
3535   return s;
3536 }
3537
3538 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3539    function prototypes and stuff, but not '\xHH' hex character constants.
3540    These don't provoke an error unfortunately, instead are silently treated
3541    as 'x'.  The following induces an error, until -std1 is added to get
3542    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3543    array size at least.  It's necessary to write '\x00'==0 to get something
3544    that's true only with -std1.  */
3545 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3546
3547 int test (int i, double x);
3548 struct s1 {int (*f) (int a);};
3549 struct s2 {int (*f) (double a);};
3550 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3551 int argc;
3552 char **argv;
3553 int
3554 main ()
3555 {
3556 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3557   ;
3558   return 0;
3559 }
3560 _ACEOF
3561 # Don't try gcc -ansi; that turns off useful extensions and
3562 # breaks some systems' header files.
3563 # AIX                   -qlanglvl=ansi
3564 # Ultrix and OSF/1      -std1
3565 # HP-UX 10.20 and later -Ae
3566 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3567 # SVR4                  -Xc -D__EXTENSIONS__
3568 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3569 do
3570   CC="$ac_save_CC $ac_arg"
3571   rm -f conftest.$ac_objext
3572 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3573   (eval $ac_compile) 2>conftest.er1
3574   ac_status=$?
3575   grep -v '^ *+' conftest.er1 >conftest.err
3576   rm -f conftest.er1
3577   cat conftest.err >&5
3578   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3579   (exit $ac_status); } &&
3580          { ac_try='test -z "$ac_c_werror_flag"
3581                          || test ! -s conftest.err'
3582   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3583   (eval $ac_try) 2>&5
3584   ac_status=$?
3585   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3586   (exit $ac_status); }; } &&
3587          { ac_try='test -s conftest.$ac_objext'
3588   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3589   (eval $ac_try) 2>&5
3590   ac_status=$?
3591   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3592   (exit $ac_status); }; }; then
3593   ac_cv_prog_cc_stdc=$ac_arg
3594 break
3595 else
3596   echo "$as_me: failed program was:" >&5
3597 sed 's/^/| /' conftest.$ac_ext >&5
3598
3599 fi
3600 rm -f conftest.err conftest.$ac_objext
3601 done
3602 rm -f conftest.$ac_ext conftest.$ac_objext
3603 CC=$ac_save_CC
3604
3605 fi
3606
3607 case "x$ac_cv_prog_cc_stdc" in
3608   x|xno)
3609     echo "$as_me:$LINENO: result: none needed" >&5
3610 echo "${ECHO_T}none needed" >&6 ;;
3611   *)
3612     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3613 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3614     CC="$CC $ac_cv_prog_cc_stdc" ;;
3615 esac
3616
3617 # Some people use a C++ compiler to compile C.  Since we use `exit',
3618 # in C++ we need to declare it.  In case someone uses the same compiler
3619 # for both compiling C and C++ we need to have the C++ compiler decide
3620 # the declaration of exit, since it's the most demanding environment.
3621 cat >conftest.$ac_ext <<_ACEOF
3622 #ifndef __cplusplus
3623   choke me
3624 #endif
3625 _ACEOF
3626 rm -f conftest.$ac_objext
3627 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3628   (eval $ac_compile) 2>conftest.er1
3629   ac_status=$?
3630   grep -v '^ *+' conftest.er1 >conftest.err
3631   rm -f conftest.er1
3632   cat conftest.err >&5
3633   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3634   (exit $ac_status); } &&
3635          { ac_try='test -z "$ac_c_werror_flag"
3636                          || test ! -s conftest.err'
3637   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3638   (eval $ac_try) 2>&5
3639   ac_status=$?
3640   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3641   (exit $ac_status); }; } &&
3642          { ac_try='test -s conftest.$ac_objext'
3643   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3644   (eval $ac_try) 2>&5
3645   ac_status=$?
3646   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3647   (exit $ac_status); }; }; then
3648   for ac_declaration in \
3649    '' \
3650    'extern "C" void std::exit (int) throw (); using std::exit;' \
3651    'extern "C" void std::exit (int); using std::exit;' \
3652    'extern "C" void exit (int) throw ();' \
3653    'extern "C" void exit (int);' \
3654    'void exit (int);'
3655 do
3656   cat >conftest.$ac_ext <<_ACEOF
3657 /* confdefs.h.  */
3658 _ACEOF
3659 cat confdefs.h >>conftest.$ac_ext
3660 cat >>conftest.$ac_ext <<_ACEOF
3661 /* end confdefs.h.  */
3662 $ac_declaration
3663 #include <stdlib.h>
3664 int
3665 main ()
3666 {
3667 exit (42);
3668   ;
3669   return 0;
3670 }
3671 _ACEOF
3672 rm -f conftest.$ac_objext
3673 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3674   (eval $ac_compile) 2>conftest.er1
3675   ac_status=$?
3676   grep -v '^ *+' conftest.er1 >conftest.err
3677   rm -f conftest.er1
3678   cat conftest.err >&5
3679   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3680   (exit $ac_status); } &&
3681          { ac_try='test -z "$ac_c_werror_flag"
3682                          || test ! -s conftest.err'
3683   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3684   (eval $ac_try) 2>&5
3685   ac_status=$?
3686   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3687   (exit $ac_status); }; } &&
3688          { ac_try='test -s conftest.$ac_objext'
3689   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3690   (eval $ac_try) 2>&5
3691   ac_status=$?
3692   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3693   (exit $ac_status); }; }; then
3694   :
3695 else
3696   echo "$as_me: failed program was:" >&5
3697 sed 's/^/| /' conftest.$ac_ext >&5
3698
3699 continue
3700 fi
3701 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3702   cat >conftest.$ac_ext <<_ACEOF
3703 /* confdefs.h.  */
3704 _ACEOF
3705 cat confdefs.h >>conftest.$ac_ext
3706 cat >>conftest.$ac_ext <<_ACEOF
3707 /* end confdefs.h.  */
3708 $ac_declaration
3709 int
3710 main ()
3711 {
3712 exit (42);
3713   ;
3714   return 0;
3715 }
3716 _ACEOF
3717 rm -f conftest.$ac_objext
3718 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3719   (eval $ac_compile) 2>conftest.er1
3720   ac_status=$?
3721   grep -v '^ *+' conftest.er1 >conftest.err
3722   rm -f conftest.er1
3723   cat conftest.err >&5
3724   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3725   (exit $ac_status); } &&
3726          { ac_try='test -z "$ac_c_werror_flag"
3727                          || test ! -s conftest.err'
3728   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3729   (eval $ac_try) 2>&5
3730   ac_status=$?
3731   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3732   (exit $ac_status); }; } &&
3733          { ac_try='test -s conftest.$ac_objext'
3734   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3735   (eval $ac_try) 2>&5
3736   ac_status=$?
3737   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3738   (exit $ac_status); }; }; then
3739   break
3740 else
3741   echo "$as_me: failed program was:" >&5
3742 sed 's/^/| /' conftest.$ac_ext >&5
3743
3744 fi
3745 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3746 done
3747 rm -f conftest*
3748 if test -n "$ac_declaration"; then
3749   echo '#ifdef __cplusplus' >>confdefs.h
3750   echo $ac_declaration      >>confdefs.h
3751   echo '#endif'             >>confdefs.h
3752 fi
3753
3754 else
3755   echo "$as_me: failed program was:" >&5
3756 sed 's/^/| /' conftest.$ac_ext >&5
3757
3758 fi
3759 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3760 ac_ext=c
3761 ac_cpp='$CPP $CPPFLAGS'
3762 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3763 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3764 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3765
3766 ac_ext=cc
3767 ac_cpp='$CXXCPP $CPPFLAGS'
3768 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3769 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3770 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3771 if test -n "$ac_tool_prefix"; then
3772   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3773   do
3774     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3775 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3776 echo "$as_me:$LINENO: checking for $ac_word" >&5
3777 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3778 if test "${ac_cv_prog_CXX+set}" = set; then
3779   echo $ECHO_N "(cached) $ECHO_C" >&6
3780 else
3781   if test -n "$CXX"; then
3782   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3783 else
3784 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3785 for as_dir in $PATH
3786 do
3787   IFS=$as_save_IFS
3788   test -z "$as_dir" && as_dir=.
3789   for ac_exec_ext in '' $ac_executable_extensions; do
3790   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3791     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3792     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3793     break 2
3794   fi
3795 done
3796 done
3797
3798 fi
3799 fi
3800 CXX=$ac_cv_prog_CXX
3801 if test -n "$CXX"; then
3802   echo "$as_me:$LINENO: result: $CXX" >&5
3803 echo "${ECHO_T}$CXX" >&6
3804 else
3805   echo "$as_me:$LINENO: result: no" >&5
3806 echo "${ECHO_T}no" >&6
3807 fi
3808
3809     test -n "$CXX" && break
3810   done
3811 fi
3812 if test -z "$CXX"; then
3813   ac_ct_CXX=$CXX
3814   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3815 do
3816   # Extract the first word of "$ac_prog", so it can be a program name with args.
3817 set dummy $ac_prog; ac_word=$2
3818 echo "$as_me:$LINENO: checking for $ac_word" >&5
3819 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3820 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3821   echo $ECHO_N "(cached) $ECHO_C" >&6
3822 else
3823   if test -n "$ac_ct_CXX"; then
3824   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3825 else
3826 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3827 for as_dir in $PATH
3828 do
3829   IFS=$as_save_IFS
3830   test -z "$as_dir" && as_dir=.
3831   for ac_exec_ext in '' $ac_executable_extensions; do
3832   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3833     ac_cv_prog_ac_ct_CXX="$ac_prog"
3834     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3835     break 2
3836   fi
3837 done
3838 done
3839
3840 fi
3841 fi
3842 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3843 if test -n "$ac_ct_CXX"; then
3844   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3845 echo "${ECHO_T}$ac_ct_CXX" >&6
3846 else
3847   echo "$as_me:$LINENO: result: no" >&5
3848 echo "${ECHO_T}no" >&6
3849 fi
3850
3851   test -n "$ac_ct_CXX" && break
3852 done
3853 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3854
3855   CXX=$ac_ct_CXX
3856 fi
3857
3858
3859 # Provide some information about the compiler.
3860 echo "$as_me:$LINENO:" \
3861      "checking for C++ compiler version" >&5
3862 ac_compiler=`set X $ac_compile; echo $2`
3863 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3864   (eval $ac_compiler --version </dev/null >&5) 2>&5
3865   ac_status=$?
3866   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3867   (exit $ac_status); }
3868 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3869   (eval $ac_compiler -v </dev/null >&5) 2>&5
3870   ac_status=$?
3871   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3872   (exit $ac_status); }
3873 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3874   (eval $ac_compiler -V </dev/null >&5) 2>&5
3875   ac_status=$?
3876   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3877   (exit $ac_status); }
3878
3879 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3880 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3881 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3882   echo $ECHO_N "(cached) $ECHO_C" >&6
3883 else
3884   cat >conftest.$ac_ext <<_ACEOF
3885 /* confdefs.h.  */
3886 _ACEOF
3887 cat confdefs.h >>conftest.$ac_ext
3888 cat >>conftest.$ac_ext <<_ACEOF
3889 /* end confdefs.h.  */
3890
3891 int
3892 main ()
3893 {
3894 #ifndef __GNUC__
3895        choke me
3896 #endif
3897
3898   ;
3899   return 0;
3900 }
3901 _ACEOF
3902 rm -f conftest.$ac_objext
3903 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3904   (eval $ac_compile) 2>conftest.er1
3905   ac_status=$?
3906   grep -v '^ *+' conftest.er1 >conftest.err
3907   rm -f conftest.er1
3908   cat conftest.err >&5
3909   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3910   (exit $ac_status); } &&
3911          { ac_try='test -z "$ac_cxx_werror_flag"
3912                          || test ! -s conftest.err'
3913   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3914   (eval $ac_try) 2>&5
3915   ac_status=$?
3916   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3917   (exit $ac_status); }; } &&
3918          { ac_try='test -s conftest.$ac_objext'
3919   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3920   (eval $ac_try) 2>&5
3921   ac_status=$?
3922   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3923   (exit $ac_status); }; }; then
3924   ac_compiler_gnu=yes
3925 else
3926   echo "$as_me: failed program was:" >&5
3927 sed 's/^/| /' conftest.$ac_ext >&5
3928
3929 ac_compiler_gnu=no
3930 fi
3931 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3932 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3933
3934 fi
3935 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3936 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3937 GXX=`test $ac_compiler_gnu = yes && echo yes`
3938 ac_test_CXXFLAGS=${CXXFLAGS+set}
3939 ac_save_CXXFLAGS=$CXXFLAGS
3940 CXXFLAGS="-g"
3941 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3942 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3943 if test "${ac_cv_prog_cxx_g+set}" = set; then
3944   echo $ECHO_N "(cached) $ECHO_C" >&6
3945 else
3946   cat >conftest.$ac_ext <<_ACEOF
3947 /* confdefs.h.  */
3948 _ACEOF
3949 cat confdefs.h >>conftest.$ac_ext
3950 cat >>conftest.$ac_ext <<_ACEOF
3951 /* end confdefs.h.  */
3952
3953 int
3954 main ()
3955 {
3956
3957   ;
3958   return 0;
3959 }
3960 _ACEOF
3961 rm -f conftest.$ac_objext
3962 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3963   (eval $ac_compile) 2>conftest.er1
3964   ac_status=$?
3965   grep -v '^ *+' conftest.er1 >conftest.err
3966   rm -f conftest.er1
3967   cat conftest.err >&5
3968   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3969   (exit $ac_status); } &&
3970          { ac_try='test -z "$ac_cxx_werror_flag"
3971                          || test ! -s conftest.err'
3972   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3973   (eval $ac_try) 2>&5
3974   ac_status=$?
3975   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3976   (exit $ac_status); }; } &&
3977          { ac_try='test -s conftest.$ac_objext'
3978   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3979   (eval $ac_try) 2>&5
3980   ac_status=$?
3981   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3982   (exit $ac_status); }; }; then
3983   ac_cv_prog_cxx_g=yes
3984 else
3985   echo "$as_me: failed program was:" >&5
3986 sed 's/^/| /' conftest.$ac_ext >&5
3987
3988 ac_cv_prog_cxx_g=no
3989 fi
3990 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3991 fi
3992 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3993 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
3994 if test "$ac_test_CXXFLAGS" = set; then
3995   CXXFLAGS=$ac_save_CXXFLAGS
3996 elif test $ac_cv_prog_cxx_g = yes; then
3997   if test "$GXX" = yes; then
3998     CXXFLAGS="-g -O2"
3999   else
4000     CXXFLAGS="-g"
4001   fi
4002 else
4003   if test "$GXX" = yes; then
4004     CXXFLAGS="-O2"
4005   else
4006     CXXFLAGS=
4007   fi
4008 fi
4009 for ac_declaration in \
4010    '' \
4011    'extern "C" void std::exit (int) throw (); using std::exit;' \
4012    'extern "C" void std::exit (int); using std::exit;' \
4013    'extern "C" void exit (int) throw ();' \
4014    'extern "C" void exit (int);' \
4015    'void exit (int);'
4016 do
4017   cat >conftest.$ac_ext <<_ACEOF
4018 /* confdefs.h.  */
4019 _ACEOF
4020 cat confdefs.h >>conftest.$ac_ext
4021 cat >>conftest.$ac_ext <<_ACEOF
4022 /* end confdefs.h.  */
4023 $ac_declaration
4024 #include <stdlib.h>
4025 int
4026 main ()
4027 {
4028 exit (42);
4029   ;
4030   return 0;
4031 }
4032 _ACEOF
4033 rm -f conftest.$ac_objext
4034 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4035   (eval $ac_compile) 2>conftest.er1
4036   ac_status=$?
4037   grep -v '^ *+' conftest.er1 >conftest.err
4038   rm -f conftest.er1
4039   cat conftest.err >&5
4040   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4041   (exit $ac_status); } &&
4042          { ac_try='test -z "$ac_cxx_werror_flag"
4043                          || test ! -s conftest.err'
4044   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4045   (eval $ac_try) 2>&5
4046   ac_status=$?
4047   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4048   (exit $ac_status); }; } &&
4049          { ac_try='test -s conftest.$ac_objext'
4050   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4051   (eval $ac_try) 2>&5
4052   ac_status=$?
4053   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4054   (exit $ac_status); }; }; then
4055   :
4056 else
4057   echo "$as_me: failed program was:" >&5
4058 sed 's/^/| /' conftest.$ac_ext >&5
4059
4060 continue
4061 fi
4062 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4063   cat >conftest.$ac_ext <<_ACEOF
4064 /* confdefs.h.  */
4065 _ACEOF
4066 cat confdefs.h >>conftest.$ac_ext
4067 cat >>conftest.$ac_ext <<_ACEOF
4068 /* end confdefs.h.  */
4069 $ac_declaration
4070 int
4071 main ()
4072 {
4073 exit (42);
4074   ;
4075   return 0;
4076 }
4077 _ACEOF
4078 rm -f conftest.$ac_objext
4079 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4080   (eval $ac_compile) 2>conftest.er1
4081   ac_status=$?
4082   grep -v '^ *+' conftest.er1 >conftest.err
4083   rm -f conftest.er1
4084   cat conftest.err >&5
4085   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4086   (exit $ac_status); } &&
4087          { ac_try='test -z "$ac_cxx_werror_flag"
4088                          || test ! -s conftest.err'
4089   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4090   (eval $ac_try) 2>&5
4091   ac_status=$?
4092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4093   (exit $ac_status); }; } &&
4094          { ac_try='test -s conftest.$ac_objext'
4095   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4096   (eval $ac_try) 2>&5
4097   ac_status=$?
4098   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4099   (exit $ac_status); }; }; then
4100   break
4101 else
4102   echo "$as_me: failed program was:" >&5
4103 sed 's/^/| /' conftest.$ac_ext >&5
4104
4105 fi
4106 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4107 done
4108 rm -f conftest*
4109 if test -n "$ac_declaration"; then
4110   echo '#ifdef __cplusplus' >>confdefs.h
4111   echo $ac_declaration      >>confdefs.h
4112   echo '#endif'             >>confdefs.h
4113 fi
4114
4115 ac_ext=c
4116 ac_cpp='$CPP $CPPFLAGS'
4117 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4118 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4119 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4120
4121
4122 # We must set the default linker to the linker used by gcc for the correct
4123 # operation of libtool.  If LD is not defined and we are using gcc, try to
4124 # set the LD default to the ld used by gcc.
4125 if test -z "$LD"; then
4126   if test "$GCC" = yes; then
4127     case $build in
4128     *-*-mingw*)
4129       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4130     *)
4131       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4132     esac
4133     case $gcc_prog_ld in
4134     # Accept absolute paths.
4135     [\\/]* | [A-Za-z]:[\\/]*)
4136       LD="$gcc_prog_ld" ;;
4137     esac
4138   fi
4139 fi
4140
4141
4142
4143
4144 if test -n "$ac_tool_prefix"; then
4145   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4146 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4147 echo "$as_me:$LINENO: checking for $ac_word" >&5
4148 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4149 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4150   echo $ECHO_N "(cached) $ECHO_C" >&6
4151 else
4152   if test -n "$GNATBIND"; then
4153   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4154 else
4155 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4156 for as_dir in $PATH
4157 do
4158   IFS=$as_save_IFS
4159   test -z "$as_dir" && as_dir=.
4160   for ac_exec_ext in '' $ac_executable_extensions; do
4161   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4162     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4163     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4164     break 2
4165   fi
4166 done
4167 done
4168
4169 fi
4170 fi
4171 GNATBIND=$ac_cv_prog_GNATBIND
4172 if test -n "$GNATBIND"; then
4173   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4174 echo "${ECHO_T}$GNATBIND" >&6
4175 else
4176   echo "$as_me:$LINENO: result: no" >&5
4177 echo "${ECHO_T}no" >&6
4178 fi
4179
4180 fi
4181 if test -z "$ac_cv_prog_GNATBIND"; then
4182   ac_ct_GNATBIND=$GNATBIND
4183   # Extract the first word of "gnatbind", so it can be a program name with args.
4184 set dummy gnatbind; ac_word=$2
4185 echo "$as_me:$LINENO: checking for $ac_word" >&5
4186 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4187 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4188   echo $ECHO_N "(cached) $ECHO_C" >&6
4189 else
4190   if test -n "$ac_ct_GNATBIND"; then
4191   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4192 else
4193 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4194 for as_dir in $PATH
4195 do
4196   IFS=$as_save_IFS
4197   test -z "$as_dir" && as_dir=.
4198   for ac_exec_ext in '' $ac_executable_extensions; do
4199   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4200     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4201     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4202     break 2
4203   fi
4204 done
4205 done
4206
4207   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4208 fi
4209 fi
4210 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4211 if test -n "$ac_ct_GNATBIND"; then
4212   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4213 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4214 else
4215   echo "$as_me:$LINENO: result: no" >&5
4216 echo "${ECHO_T}no" >&6
4217 fi
4218
4219   GNATBIND=$ac_ct_GNATBIND
4220 else
4221   GNATBIND="$ac_cv_prog_GNATBIND"
4222 fi
4223
4224 if test -n "$ac_tool_prefix"; then
4225   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4226 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4227 echo "$as_me:$LINENO: checking for $ac_word" >&5
4228 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4229 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4230   echo $ECHO_N "(cached) $ECHO_C" >&6
4231 else
4232   if test -n "$GNATMAKE"; then
4233   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4234 else
4235 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4236 for as_dir in $PATH
4237 do
4238   IFS=$as_save_IFS
4239   test -z "$as_dir" && as_dir=.
4240   for ac_exec_ext in '' $ac_executable_extensions; do
4241   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4242     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4243     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4244     break 2
4245   fi
4246 done
4247 done
4248
4249 fi
4250 fi
4251 GNATMAKE=$ac_cv_prog_GNATMAKE
4252 if test -n "$GNATMAKE"; then
4253   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4254 echo "${ECHO_T}$GNATMAKE" >&6
4255 else
4256   echo "$as_me:$LINENO: result: no" >&5
4257 echo "${ECHO_T}no" >&6
4258 fi
4259
4260 fi
4261 if test -z "$ac_cv_prog_GNATMAKE"; then
4262   ac_ct_GNATMAKE=$GNATMAKE
4263   # Extract the first word of "gnatmake", so it can be a program name with args.
4264 set dummy gnatmake; ac_word=$2
4265 echo "$as_me:$LINENO: checking for $ac_word" >&5
4266 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4267 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4268   echo $ECHO_N "(cached) $ECHO_C" >&6
4269 else
4270   if test -n "$ac_ct_GNATMAKE"; then
4271   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4272 else
4273 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4274 for as_dir in $PATH
4275 do
4276   IFS=$as_save_IFS
4277   test -z "$as_dir" && as_dir=.
4278   for ac_exec_ext in '' $ac_executable_extensions; do
4279   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4280     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4281     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4282     break 2
4283   fi
4284 done
4285 done
4286
4287   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4288 fi
4289 fi
4290 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4291 if test -n "$ac_ct_GNATMAKE"; then
4292   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4293 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4294 else
4295   echo "$as_me:$LINENO: result: no" >&5
4296 echo "${ECHO_T}no" >&6
4297 fi
4298
4299   GNATMAKE=$ac_ct_GNATMAKE
4300 else
4301   GNATMAKE="$ac_cv_prog_GNATMAKE"
4302 fi
4303
4304 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4305 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4306 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4307   echo $ECHO_N "(cached) $ECHO_C" >&6
4308 else
4309   cat >conftest.adb <<EOF
4310 procedure conftest is begin null; end conftest;
4311 EOF
4312 acx_cv_cc_gcc_supports_ada=no
4313 # There is a bug in old released versions of GCC which causes the
4314 # driver to exit successfully when the appropriate language module
4315 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4316 # Therefore we must check for the error message as well as an
4317 # unsuccessful exit.
4318 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4319 # given a .adb file, but produce no object file.  So we must check
4320 # if an object file was really produced to guard against this.
4321 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4322 if test x"$errors" = x && test -f conftest.$ac_objext; then
4323   acx_cv_cc_gcc_supports_ada=yes
4324 fi
4325 rm -f conftest.*
4326 fi
4327 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4328 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4329
4330 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4331   have_gnat=yes
4332 else
4333   have_gnat=no
4334 fi
4335
4336 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4337 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4338 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4339   echo $ECHO_N "(cached) $ECHO_C" >&6
4340 else
4341    echo abfoo >t1
4342   echo cdfoo >t2
4343   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4344   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4345     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4346       :
4347     else
4348       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4349     fi
4350   fi
4351   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4352     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4353       :
4354     else
4355       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4356     fi
4357   fi
4358   rm t1 t2
4359
4360 fi
4361 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4362 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4363 do_compare="$gcc_cv_prog_cmp_skip"
4364
4365
4366
4367 # Check for GMP and MPFR
4368 gmplibs="-lmpfr -lgmp"
4369 gmpinc=
4370 have_gmp=no
4371
4372 # Specify a location for mpfr
4373 # check for this first so it ends up on the link line before gmp.
4374
4375 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4376 if test "${with_mpfr_dir+set}" = set; then
4377   withval="$with_mpfr_dir"
4378   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4379 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4380 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4381 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4382    { (exit 1); exit 1; }; }
4383 fi;
4384
4385
4386 # Check whether --with-mpfr or --without-mpfr was given.
4387 if test "${with_mpfr+set}" = set; then
4388   withval="$with_mpfr"
4389
4390 fi;
4391
4392 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4393 if test "${with_mpfr_include+set}" = set; then
4394   withval="$with_mpfr_include"
4395
4396 fi;
4397
4398 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4399 if test "${with_mpfr_lib+set}" = set; then
4400   withval="$with_mpfr_lib"
4401
4402 fi;
4403
4404 if test "x$with_mpfr" != x; then
4405   gmplibs="-L$with_mpfr/lib $gmplibs"
4406   gmpinc="-I$with_mpfr/include"
4407 fi
4408 if test "x$with_mpfr_include" != x; then
4409   gmpinc="-I$with_mpfr_include"
4410 fi
4411 if test "x$with_mpfr_lib" != x; then
4412   gmplibs="-L$with_mpfr_lib $gmplibs"
4413 fi
4414 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4415   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4416   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4417   # Do not test the mpfr version.  Assume that it is sufficient, since
4418   # it is in the source tree, and the library has not been built yet
4419   # but it would be included on the link line in the version check below
4420   # hence making the test fail.
4421   have_gmp=yes
4422 fi
4423
4424 # Specify a location for gmp
4425
4426 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4427 if test "${with_gmp_dir+set}" = set; then
4428   withval="$with_gmp_dir"
4429   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4430 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4431 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4432 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4433    { (exit 1); exit 1; }; }
4434 fi;
4435
4436
4437 # Check whether --with-gmp or --without-gmp was given.
4438 if test "${with_gmp+set}" = set; then
4439   withval="$with_gmp"
4440
4441 fi;
4442
4443 # Check whether --with-gmp_include or --without-gmp_include was given.
4444 if test "${with_gmp_include+set}" = set; then
4445   withval="$with_gmp_include"
4446
4447 fi;
4448
4449 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4450 if test "${with_gmp_lib+set}" = set; then
4451   withval="$with_gmp_lib"
4452
4453 fi;
4454
4455
4456 if test "x$with_gmp" != x; then
4457   gmplibs="-L$with_gmp/lib $gmplibs"
4458   gmpinc="-I$with_gmp/include $gmpinc"
4459 fi
4460 if test "x$with_gmp_include" != x; then
4461   gmpinc="-I$with_gmp_include $gmpinc"
4462 fi
4463 if test "x$with_gmp_lib" != x; then
4464   gmplibs="-L$with_gmp_lib $gmplibs"
4465 fi
4466 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4467   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4468   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4469   # Do not test the gmp version.  Assume that it is sufficient, since
4470   # it is in the source tree, and the library has not been built yet
4471   # but it would be included on the link line in the version check below
4472   # hence making the test fail.
4473   have_gmp=yes
4474 fi
4475
4476 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4477   have_gmp=yes
4478   saved_CFLAGS="$CFLAGS"
4479   CFLAGS="$CFLAGS $gmpinc"
4480   # Check GMP actually works
4481   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4482 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4483
4484 cat >conftest.$ac_ext <<_ACEOF
4485 /* confdefs.h.  */
4486 _ACEOF
4487 cat confdefs.h >>conftest.$ac_ext
4488 cat >>conftest.$ac_ext <<_ACEOF
4489 /* end confdefs.h.  */
4490 #include "gmp.h"
4491 int
4492 main ()
4493 {
4494
4495   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4496   choke me
4497   #endif
4498
4499   ;
4500   return 0;
4501 }
4502 _ACEOF
4503 rm -f conftest.$ac_objext
4504 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4505   (eval $ac_compile) 2>conftest.er1
4506   ac_status=$?
4507   grep -v '^ *+' conftest.er1 >conftest.err
4508   rm -f conftest.er1
4509   cat conftest.err >&5
4510   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4511   (exit $ac_status); } &&
4512          { ac_try='test -z "$ac_c_werror_flag"
4513                          || test ! -s conftest.err'
4514   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4515   (eval $ac_try) 2>&5
4516   ac_status=$?
4517   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4518   (exit $ac_status); }; } &&
4519          { ac_try='test -s conftest.$ac_objext'
4520   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4521   (eval $ac_try) 2>&5
4522   ac_status=$?
4523   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4524   (exit $ac_status); }; }; then
4525   echo "$as_me:$LINENO: result: yes" >&5
4526 echo "${ECHO_T}yes" >&6
4527 else
4528   echo "$as_me: failed program was:" >&5
4529 sed 's/^/| /' conftest.$ac_ext >&5
4530
4531 echo "$as_me:$LINENO: result: no" >&5
4532 echo "${ECHO_T}no" >&6; have_gmp=no
4533 fi
4534 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4535
4536   if test x"$have_gmp" = xyes; then
4537     saved_LIBS="$LIBS"
4538     LIBS="$LIBS $gmplibs"
4539         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4540 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4541     cat >conftest.$ac_ext <<_ACEOF
4542 /* confdefs.h.  */
4543 _ACEOF
4544 cat confdefs.h >>conftest.$ac_ext
4545 cat >>conftest.$ac_ext <<_ACEOF
4546 /* end confdefs.h.  */
4547 #include <gmp.h>
4548     #include <mpfr.h>
4549 int
4550 main ()
4551 {
4552
4553     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,0)
4554     choke me
4555     #endif
4556     mpfr_t n;
4557     mpfr_t x;
4558     int t;
4559     mpfr_init (n);
4560     mpfr_init (x);
4561     mpfr_atan2 (n, n, x, GMP_RNDN);
4562     mpfr_erfc (n, x, GMP_RNDN);
4563     mpfr_subnormalize (x, t, GMP_RNDN);
4564
4565   ;
4566   return 0;
4567 }
4568 _ACEOF
4569 rm -f conftest.$ac_objext conftest$ac_exeext
4570 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4571   (eval $ac_link) 2>conftest.er1
4572   ac_status=$?
4573   grep -v '^ *+' conftest.er1 >conftest.err
4574   rm -f conftest.er1
4575   cat conftest.err >&5
4576   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4577   (exit $ac_status); } &&
4578          { ac_try='test -z "$ac_c_werror_flag"
4579                          || test ! -s conftest.err'
4580   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4581   (eval $ac_try) 2>&5
4582   ac_status=$?
4583   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4584   (exit $ac_status); }; } &&
4585          { ac_try='test -s conftest$ac_exeext'
4586   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4587   (eval $ac_try) 2>&5
4588   ac_status=$?
4589   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4590   (exit $ac_status); }; }; then
4591   cat >conftest.$ac_ext <<_ACEOF
4592 /* confdefs.h.  */
4593 _ACEOF
4594 cat confdefs.h >>conftest.$ac_ext
4595 cat >>conftest.$ac_ext <<_ACEOF
4596 /* end confdefs.h.  */
4597 #include <gmp.h>
4598     #include <mpfr.h>
4599 int
4600 main ()
4601 {
4602
4603     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4604     choke me
4605     #endif
4606     mpfr_t n; mpfr_init(n);
4607
4608   ;
4609   return 0;
4610 }
4611 _ACEOF
4612 rm -f conftest.$ac_objext conftest$ac_exeext
4613 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4614   (eval $ac_link) 2>conftest.er1
4615   ac_status=$?
4616   grep -v '^ *+' conftest.er1 >conftest.err
4617   rm -f conftest.er1
4618   cat conftest.err >&5
4619   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4620   (exit $ac_status); } &&
4621          { ac_try='test -z "$ac_c_werror_flag"
4622                          || test ! -s conftest.err'
4623   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4624   (eval $ac_try) 2>&5
4625   ac_status=$?
4626   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4627   (exit $ac_status); }; } &&
4628          { ac_try='test -s conftest$ac_exeext'
4629   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4630   (eval $ac_try) 2>&5
4631   ac_status=$?
4632   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4633   (exit $ac_status); }; }; then
4634   echo "$as_me:$LINENO: result: yes" >&5
4635 echo "${ECHO_T}yes" >&6
4636 else
4637   echo "$as_me: failed program was:" >&5
4638 sed 's/^/| /' conftest.$ac_ext >&5
4639
4640 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4641 echo "${ECHO_T}buggy but acceptable" >&6
4642 fi
4643 rm -f conftest.err conftest.$ac_objext \
4644       conftest$ac_exeext conftest.$ac_ext
4645 else
4646   echo "$as_me: failed program was:" >&5
4647 sed 's/^/| /' conftest.$ac_ext >&5
4648
4649 echo "$as_me:$LINENO: result: no" >&5
4650 echo "${ECHO_T}no" >&6; have_gmp=no
4651 fi
4652 rm -f conftest.err conftest.$ac_objext \
4653       conftest$ac_exeext conftest.$ac_ext
4654       LIBS="$saved_LIBS"
4655   fi
4656   CFLAGS="$saved_CFLAGS"
4657
4658   if test x$have_gmp != xyes; then
4659     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4660 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4661 Copies of these libraries' source code can be found at their respective
4662 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4663 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4664 If you obtained GMP and/or MPFR from a vendor distribution package, make
4665 sure that you have installed both the libraries and the header files.
4666 They may be located in separate packages." >&5
4667 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4668 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4669 Copies of these libraries' source code can be found at their respective
4670 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4671 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4672 If you obtained GMP and/or MPFR from a vendor distribution package, make
4673 sure that you have installed both the libraries and the header files.
4674 They may be located in separate packages." >&2;}
4675    { (exit 1); exit 1; }; }
4676   fi
4677 fi
4678
4679 # Flags needed for both GMP and/or MPFR
4680
4681
4682
4683 # By default, C is the only stage 1 language.
4684 stage1_languages=,c,
4685
4686 # Figure out what language subdirectories are present.
4687 # Look if the user specified --enable-languages="..."; if not, use
4688 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4689 # go away some day.
4690 # NB:  embedded tabs in this IF block -- do not untabify
4691 if test -d ${srcdir}/gcc; then
4692   if test x"${enable_languages+set}" != xset; then
4693     if test x"${LANGUAGES+set}" = xset; then
4694       enable_languages="${LANGUAGES}"
4695         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4696     else
4697       enable_languages=all
4698     fi
4699   else
4700     if test x"${enable_languages}" = x ||
4701        test x"${enable_languages}" = xyes;
4702        then
4703       echo configure.in: --enable-languages needs at least one language argument 1>&2
4704       exit 1
4705     fi
4706   fi
4707   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4708
4709   # 'f95' is the old name for the 'fortran' language. We issue a warning
4710   # and make the substitution.
4711   case ,${enable_languages}, in
4712     *,f95,*)
4713       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4714       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4715       ;;
4716   esac
4717
4718   # First scan to see if an enabled language requires some other language.
4719   # We assume that a given config-lang.in will list all the language
4720   # front ends it requires, even if some are required indirectly.
4721   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4722     case ${lang_frag} in
4723       ..) ;;
4724       # The odd quoting in the next line works around
4725       # an apparent bug in bash 1.12 on linux.
4726       ${srcdir}/gcc/[*]/config-lang.in) ;;
4727       *)
4728         # From the config-lang.in, get $language, $lang_requires
4729         language=
4730         lang_requires=
4731         . ${lang_frag}
4732         for other in ${lang_requires} ; do
4733           case ,${enable_languages}, in
4734             *,$other,*) ;;
4735             *,all,*) ;;
4736             *,$language,*)
4737               echo " \`$other' language required by \`$language'; enabling" 1>&2
4738               enable_languages="${enable_languages},${other}"
4739               ;;
4740           esac
4741         done
4742         ;;
4743     esac
4744   done
4745
4746   new_enable_languages=,c,
4747   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4748   potential_languages=,c,
4749
4750   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4751     case ${lang_frag} in
4752       ..) ;;
4753       # The odd quoting in the next line works around
4754       # an apparent bug in bash 1.12 on linux.
4755       ${srcdir}/gcc/[*]/config-lang.in) ;;
4756       *)
4757         # From the config-lang.in, get $language, $target_libs,
4758         # $lang_dirs, $boot_language, and $build_by_default
4759         language=
4760         target_libs=
4761         lang_dirs=
4762         subdir_requires=
4763         boot_language=no
4764         build_by_default=yes
4765         . ${lang_frag}
4766         if test x${language} = x; then
4767           echo "${lang_frag} doesn't set \$language." 1>&2
4768           exit 1
4769         fi
4770
4771         case ,${enable_languages}, in
4772           *,${language},*)
4773             # Language was explicitly selected; include it.
4774             add_this_lang=yes
4775             ;;
4776           *,all,*)
4777             # 'all' was selected, select it if it is a default language
4778             add_this_lang=${build_by_default}
4779             ;;
4780           *)
4781             add_this_lang=no
4782             ;;
4783         esac
4784
4785         # Disable languages that need other directories if these aren't available.
4786         for i in $subdir_requires; do
4787           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4788           case ,${enable_languages}, in
4789             *,${language},*)
4790               # Specifically requested language; tell them.
4791               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4792 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4793    { (exit 1); exit 1; }; }
4794               ;;
4795             *)
4796               # Silently disable.
4797               add_this_lang=unsupported
4798               ;;
4799           esac
4800         done
4801
4802         # Disable Ada if no preexisting GNAT is available.
4803         case ,${enable_languages},:${language}:${have_gnat} in
4804           *,${language},*:ada:no)
4805             # Specifically requested language; tell them.
4806             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4807 echo "$as_me: error: GNAT is required to build $language" >&2;}
4808    { (exit 1); exit 1; }; }
4809             ;;
4810           *:ada:no)
4811             # Silently disable.
4812             add_this_lang=unsupported
4813             ;;
4814         esac
4815
4816         # Disable a language that is unsupported by the target.
4817         case " $unsupported_languages " in
4818           *" $language "*)
4819             add_this_lang=unsupported
4820             ;;
4821         esac
4822
4823         case $add_this_lang in
4824           unsupported)
4825             # Remove language-dependent dirs.
4826             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4827             ;;
4828           no)
4829             # Remove language-dependent dirs; still show language as supported.
4830             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4831             potential_languages="${potential_languages}${language},"
4832             ;;
4833           yes)
4834             new_enable_languages="${new_enable_languages}${language},"
4835             potential_languages="${potential_languages}${language},"
4836             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4837             case ${boot_language} in
4838               yes)
4839                 # Add to (comma-separated) list of stage 1 languages.
4840                 stage1_languages="${stage1_languages}${language},"
4841                 ;;
4842             esac
4843             ;;
4844         esac
4845         ;;
4846     esac
4847   done
4848
4849   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4850 if test "${enable_stage1_languages+set}" = set; then
4851   enableval="$enable_stage1_languages"
4852   case ,${enable_stage1_languages}, in
4853     ,no,|,,)
4854       # Set it to something that will have no effect in the loop below
4855       enable_stage1_languages=c ;;
4856     ,yes,)
4857       enable_stage1_languages=`echo $new_enable_languages | \
4858         sed -e "s/^,//" -e "s/,$//" ` ;;
4859     *,all,*)
4860       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4861         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4862   esac
4863
4864   # Add "good" languages from enable_stage1_languages to stage1_languages,
4865   # while "bad" languages go in missing_languages.  Leave no duplicates.
4866   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4867     case $potential_languages in
4868       *,$i,*)
4869         case $stage1_languages in
4870           *,$i,*) ;;
4871           *) stage1_languages="$stage1_languages$i," ;;
4872         esac ;;
4873       *)
4874         case $missing_languages in
4875           *,$i,*) ;;
4876           *) missing_languages="$missing_languages$i," ;;
4877         esac ;;
4878      esac
4879   done
4880 fi;
4881
4882   # Remove leading/trailing commas that were added for simplicity
4883   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4884   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4885   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4886   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4887
4888   if test "x$missing_languages" != x; then
4889     { { echo "$as_me:$LINENO: error:
4890 The following requested languages could not be built: ${missing_languages}
4891 Supported languages are: ${potential_languages}" >&5
4892 echo "$as_me: error:
4893 The following requested languages could not be built: ${missing_languages}
4894 Supported languages are: ${potential_languages}" >&2;}
4895    { (exit 1); exit 1; }; }
4896   fi
4897   if test "x$new_enable_languages" != "x$enable_languages"; then
4898     echo The following languages will be built: ${new_enable_languages}
4899     enable_languages="$new_enable_languages"
4900   fi
4901
4902
4903   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4904 fi
4905
4906 # Handle --disable-<component> generically.
4907 for dir in $configdirs $build_configdirs $target_configdirs ; do
4908   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4909   if eval test x\${enable_${dirname}} "=" xno ; then
4910     noconfigdirs="$noconfigdirs $dir"
4911   fi
4912 done
4913
4914 # Check for Boehm's garbage collector
4915 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4916 if test "${enable_objc_gc+set}" = set; then
4917   enableval="$enable_objc_gc"
4918   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4919   *,objc,*:*:yes:*target-boehm-gc*)
4920     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4921 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4922    { (exit 1); exit 1; }; }
4923     ;;
4924 esac
4925 fi;
4926
4927 # Make sure we only build Boehm's garbage collector if required.
4928 case ,${enable_languages},:${enable_objc_gc} in
4929   *,objc,*:yes)
4930     # Keep target-boehm-gc if requested for Objective-C.
4931     ;;
4932   *)
4933     # Otherwise remove target-boehm-gc depending on target-libjava.
4934     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4935       noconfigdirs="$noconfigdirs target-boehm-gc"
4936     fi
4937     ;;
4938 esac
4939
4940 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4941 # $build_configdirs and $target_configdirs.
4942 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4943
4944 notsupp=""
4945 for dir in . $skipdirs $noconfigdirs ; do
4946   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4947   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4948     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4949     if test -r $srcdir/$dirname/configure ; then
4950       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4951         true
4952       else
4953         notsupp="$notsupp $dir"
4954       fi
4955     fi
4956   fi
4957   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4958     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
4959     if test -r $srcdir/$dirname/configure ; then
4960       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4961         true
4962       else
4963         notsupp="$notsupp $dir"
4964       fi
4965     fi
4966   fi
4967   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4968     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
4969     if test -r $srcdir/$dirname/configure ; then
4970       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4971         true
4972       else
4973         notsupp="$notsupp $dir"
4974       fi
4975     fi
4976   fi
4977 done
4978
4979 # Sometimes the tools are distributed with libiberty but with no other
4980 # libraries.  In that case, we don't want to build target-libiberty.
4981 # Don't let libgcc imply libiberty either.
4982 if test -n "${target_configdirs}" ; then
4983   libgcc=
4984   others=
4985   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
4986     if test "$i" = "libgcc"; then
4987       libgcc=target-libgcc
4988     elif test "$i" != "libiberty" ; then
4989       if test -r $srcdir/$i/configure ; then
4990         others=yes;
4991         break;
4992       fi
4993     fi
4994   done
4995   if test -z "${others}" ; then
4996     target_configdirs=$libgcc
4997   fi
4998 fi
4999
5000 # Quietly strip out all directories which aren't configurable in this tree.
5001 # This relies on all configurable subdirectories being autoconfiscated, which
5002 # is now the case.
5003 build_configdirs_all="$build_configdirs"
5004 build_configdirs=
5005 for i in ${build_configdirs_all} ; do
5006   j=`echo $i | sed -e s/build-//g`
5007   if test -f ${srcdir}/$j/configure ; then
5008     build_configdirs="${build_configdirs} $i"
5009   fi
5010 done
5011
5012 configdirs_all="$configdirs"
5013 configdirs=
5014 for i in ${configdirs_all} ; do
5015   if test -f ${srcdir}/$i/configure ; then
5016     configdirs="${configdirs} $i"
5017   fi
5018 done
5019
5020 target_configdirs_all="$target_configdirs"
5021 target_configdirs=
5022 for i in ${target_configdirs_all} ; do
5023   j=`echo $i | sed -e s/target-//g`
5024   if test -f ${srcdir}/$j/configure ; then
5025     target_configdirs="${target_configdirs} $i"
5026   fi
5027 done
5028
5029 # Produce a warning message for the subdirs we can't configure.
5030 # This isn't especially interesting in the Cygnus tree, but in the individual
5031 # FSF releases, it's important to let people know when their machine isn't
5032 # supported by the one or two programs in a package.
5033
5034 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5035   # If $appdirs is non-empty, at least one of those directories must still
5036   # be configured, or we error out.  (E.g., if the gas release supports a
5037   # specified target in some subdirs but not the gas subdir, we shouldn't
5038   # pretend that all is well.)
5039   if test -n "$appdirs" ; then
5040     for dir in $appdirs ; do
5041       if test -r $dir/Makefile.in ; then
5042         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5043           appdirs=""
5044           break
5045         fi
5046         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5047           appdirs=""
5048           break
5049         fi
5050       fi
5051     done
5052     if test -n "$appdirs" ; then
5053       echo "*** This configuration is not supported by this package." 1>&2
5054       exit 1
5055     fi
5056   fi
5057   # Okay, some application will build, or we don't care to check.  Still
5058   # notify of subdirs not getting built.
5059   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5060   echo "    ${notsupp}" 1>&2
5061   echo "    (Any other directories should still work fine.)" 1>&2
5062 fi
5063
5064 case "$host" in
5065   *msdosdjgpp*)
5066     enable_gdbtk=no ;;
5067 esac
5068
5069 # To find our prefix, in gcc_cv_tool_prefix.
5070
5071 # The user is always right.
5072 if test "${PATH_SEPARATOR+set}" != set; then
5073   echo "#! /bin/sh" >conf$$.sh
5074   echo  "exit 0"   >>conf$$.sh
5075   chmod +x conf$$.sh
5076   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5077     PATH_SEPARATOR=';'
5078   else
5079     PATH_SEPARATOR=:
5080   fi
5081   rm -f conf$$.sh
5082 fi
5083
5084
5085
5086 if test "x$exec_prefix" = xNONE; then
5087         if test "x$prefix" = xNONE; then
5088                 gcc_cv_tool_prefix=$ac_default_prefix
5089         else
5090                 gcc_cv_tool_prefix=$prefix
5091         fi
5092 else
5093         gcc_cv_tool_prefix=$exec_prefix
5094 fi
5095
5096 # If there is no compiler in the tree, use the PATH only.  In any
5097 # case, if there is no compiler in the tree nobody should use
5098 # AS_FOR_TARGET and LD_FOR_TARGET.
5099 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5100     gcc_version=`cat $srcdir/gcc/BASE-VER`
5101     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5102     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5103     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5104     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5105     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5106     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5107 else
5108     gcc_cv_tool_dirs=
5109 fi
5110
5111 if test x$build = x$target && test -n "$md_exec_prefix"; then
5112         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5113 fi
5114
5115
5116
5117 copy_dirs=
5118
5119
5120 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5121 if test "${with_build_sysroot+set}" = set; then
5122   withval="$with_build_sysroot"
5123   if test x"$withval" != x ; then
5124      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5125    fi
5126 else
5127   SYSROOT_CFLAGS_FOR_TARGET=
5128 fi;
5129
5130
5131
5132 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5133 if test "${with_debug_prefix_map+set}" = set; then
5134   withval="$with_debug_prefix_map"
5135   if test x"$withval" != x; then
5136      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5137      for debug_map in $withval; do
5138        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5139      done
5140    fi
5141 else
5142   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5143 fi;
5144
5145
5146 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5147 # the named directory are copied to $(tooldir)/sys-include.
5148 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5149   if test x${is_cross_compiler} = xno ; then
5150     echo 1>&2 '***' --with-headers is only supported when cross compiling
5151     exit 1
5152   fi
5153   if test x"${with_headers}" != xyes ; then
5154     x=${gcc_cv_tool_prefix}
5155     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5156   fi
5157 fi
5158
5159 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5160 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5161 # are permitted.
5162 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5163   if test x${is_cross_compiler} = xno ; then
5164     echo 1>&2 '***' --with-libs is only supported when cross compiling
5165     exit 1
5166   fi
5167   if test x"${with_libs}" != xyes ; then
5168     # Copy the libraries in reverse order, so that files in the first named
5169     # library override files in subsequent libraries.
5170     x=${gcc_cv_tool_prefix}
5171     for l in ${with_libs}; do
5172       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5173     done
5174   fi
5175 fi
5176
5177 # Set with_gnu_as and with_gnu_ld as appropriate.
5178 #
5179 # This is done by determining whether or not the appropriate directory
5180 # is available, and by checking whether or not specific configurations
5181 # have requested that this magic not happen.
5182 #
5183 # The command line options always override the explicit settings in
5184 # configure.in, and the settings in configure.in override this magic.
5185 #
5186 # If the default for a toolchain is to use GNU as and ld, and you don't
5187 # want to do that, then you should use the --without-gnu-as and
5188 # --without-gnu-ld options for the configure script.
5189
5190 if test x${use_gnu_as} = x &&
5191    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5192   with_gnu_as=yes
5193   extra_host_args="$extra_host_args --with-gnu-as"
5194 fi
5195
5196 if test x${use_gnu_ld} = x &&
5197    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
5198   with_gnu_ld=yes
5199   extra_host_args="$extra_host_args --with-gnu-ld"
5200 fi
5201
5202 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5203 # can detect this case.
5204
5205 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5206   with_newlib=yes
5207   extra_host_args="$extra_host_args --with-newlib"
5208 fi
5209
5210 # Handle ${copy_dirs}
5211 set fnord ${copy_dirs}
5212 shift
5213 while test $# != 0 ; do
5214   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5215     :
5216   else
5217     echo Copying $1 to $2
5218
5219     # Use the install script to create the directory and all required
5220     # parent directories.
5221     if test -d $2 ; then
5222       :
5223     else
5224       echo >config.temp
5225       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5226     fi
5227
5228     # Copy the directory, assuming we have tar.
5229     # FIXME: Should we use B in the second tar?  Not all systems support it.
5230     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5231
5232     # It is the responsibility of the user to correctly adjust all
5233     # symlinks.  If somebody can figure out how to handle them correctly
5234     # here, feel free to add the code.
5235
5236     echo $1 > $2/COPIED
5237   fi
5238   shift; shift
5239 done
5240
5241 # Determine a target-dependent exec_prefix that the installed
5242 # gcc will search in.  Keep this list sorted by triplet, with
5243 # the *-*-osname triplets last.
5244 md_exec_prefix=
5245 case "${target}" in
5246   alpha*-*-*vms*)
5247     md_exec_prefix=/gnu/lib/gcc-lib
5248     ;;
5249   i[34567]86-pc-msdosdjgpp*)
5250     md_exec_prefix=/dev/env/DJDIR/bin
5251     ;;
5252   i[34567]86-*-sco3.2v5*)
5253     if test $with_gnu_as = yes; then
5254       md_exec_prefix=/usr/gnu/bin
5255     else
5256       md_exec_prefix=/usr/ccs/bin/elf
5257     fi
5258     ;;
5259
5260   mn10300-*-* | \
5261   powerpc-*-chorusos* | \
5262   powerpc*-*-eabi* | \
5263   powerpc*-*-sysv* | \
5264   powerpc*-*-kaos* | \
5265   s390x-ibm-tpf*)
5266     md_exec_prefix=/usr/ccs/bin
5267     ;;
5268   sparc64-*-elf*)
5269     ;;
5270   v850*-*-*)
5271     md_exec_prefix=/usr/ccs/bin
5272     ;;
5273   xtensa-*-elf*)
5274     ;;
5275
5276   *-*-beos* | \
5277   *-*-elf* | \
5278   *-*-hpux* | \
5279   *-*-netware* | \
5280   *-*-nto-qnx* | \
5281   *-*-rtems* | \
5282   *-*-solaris2* | \
5283   *-*-sysv[45]* | \
5284   *-*-vxworks* | \
5285   *-wrs-windiss)
5286     md_exec_prefix=/usr/ccs/bin
5287     ;;
5288 esac
5289
5290 extra_arflags_for_target=
5291 extra_nmflags_for_target=
5292 extra_ranlibflags_for_target=
5293 target_makefile_frag=/dev/null
5294 case "${target}" in
5295   mep*-*-*)
5296     target_makefile_frag="config/mt-mep"
5297     ;;
5298   spu-*-*)
5299     target_makefile_frag="config/mt-spu"
5300     ;;
5301   mips*-sde-elf*)
5302     target_makefile_frag="config/mt-sde"
5303     ;;
5304   mipsisa*-*-elfoabi*)
5305     target_makefile_frag="config/mt-mips-elfoabi"
5306     ;;
5307   *-*-netware*)
5308     target_makefile_frag="config/mt-netware"
5309     ;;
5310   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5311     target_makefile_frag="config/mt-gnu"
5312     ;;
5313   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5314     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5315     # commands to handle both 32-bit and 64-bit objects.  These flags are
5316     # harmless if we're using GNU nm or ar.
5317     extra_arflags_for_target=" -X32_64"
5318     extra_nmflags_for_target=" -B -X32_64"
5319     ;;
5320   *-*-darwin*)
5321     # ranlib from Darwin requires the -c flag to look at common symbols.
5322     extra_ranlibflags_for_target=" -c"
5323     ;;
5324   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5325     target_makefile_frag="config/mt-wince"
5326     ;;
5327 esac
5328
5329 alphaieee_frag=/dev/null
5330 case $target in
5331   alpha*-*-*)
5332     # This just makes sure to use the -mieee option to build target libs.
5333     # This should probably be set individually by each library.
5334     alphaieee_frag="config/mt-alphaieee"
5335     ;;
5336 esac
5337
5338 # If --enable-target-optspace always use -Os instead of -O2 to build
5339 # the target libraries, similarly if it is not specified, use -Os
5340 # on selected platforms.
5341 ospace_frag=/dev/null
5342 case "${enable_target_optspace}:${target}" in
5343   yes:*)
5344     ospace_frag="config/mt-ospace"
5345     ;;
5346   :d30v-*)
5347     ospace_frag="config/mt-d30v"
5348     ;;
5349   :m32r-* | :d10v-* | :fr30-*)
5350     ospace_frag="config/mt-ospace"
5351     ;;
5352   no:* | :*)
5353     ;;
5354   *)
5355     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5356     ;;
5357 esac
5358
5359 # Default to using --with-stabs for certain targets.
5360 if test x${with_stabs} = x ; then
5361   case "${target}" in
5362   mips*-*-irix[56]*)
5363     ;;
5364   mips*-*-* | alpha*-*-osf*)
5365     with_stabs=yes;
5366     extra_host_args="${extra_host_args} --with-stabs"
5367     ;;
5368   esac
5369 fi
5370
5371 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5372 # them automatically.
5373 case "${host}" in
5374   hppa*64*-*-hpux11*)
5375     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5376     ;;
5377 esac
5378
5379 # Some systems (e.g., one of the i386-aix systems the gas testers are
5380 # using) don't handle "\$" correctly, so don't use it here.
5381 tooldir='${exec_prefix}'/${target_noncanonical}
5382 build_tooldir=${tooldir}
5383
5384 # Create a .gdbinit file which runs the one in srcdir
5385 # and tells GDB to look there for source files.
5386
5387 if test -r ${srcdir}/.gdbinit ; then
5388   case ${srcdir} in
5389     .) ;;
5390     *) cat > ./.gdbinit <<EOF
5391 # ${NO_EDIT}
5392 dir ${srcdir}
5393 dir .
5394 source ${srcdir}/.gdbinit
5395 EOF
5396     ;;
5397   esac
5398 fi
5399
5400 # Make sure that the compiler is able to generate an executable.  If it
5401 # can't, we are probably in trouble.  We don't care whether we can run the
5402 # executable--we might be using a cross compiler--we only care whether it
5403 # can be created.  At this point the main configure script has set CC.
5404 we_are_ok=no
5405 echo "int main () { return 0; }" > conftest.c
5406 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5407 if test $? = 0 ; then
5408   if test -s conftest || test -s conftest.exe ; then
5409     we_are_ok=yes
5410   fi
5411 fi
5412 case $we_are_ok in
5413   no)
5414     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5415     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5416     rm -f conftest*
5417     exit 1
5418     ;;
5419 esac
5420 rm -f conftest*
5421
5422 # The Solaris /usr/ucb/cc compiler does not appear to work.
5423 case "${host}" in
5424   sparc-sun-solaris2*)
5425       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5426       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5427           could_use=
5428           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5429           if test -d /opt/cygnus/bin ; then
5430               if test "$could_use" = "" ; then
5431                   could_use="/opt/cygnus/bin"
5432               else
5433                   could_use="$could_use or /opt/cygnus/bin"
5434               fi
5435           fi
5436         if test "$could_use" = "" ; then
5437             echo "Warning: compilation may fail because you're using"
5438             echo "/usr/ucb/cc.  You should change your PATH or CC "
5439             echo "variable and rerun configure."
5440         else
5441             echo "Warning: compilation may fail because you're using"
5442             echo "/usr/ucb/cc, when you should use the C compiler from"
5443             echo "$could_use.  You should change your"
5444             echo "PATH or CC variable and rerun configure."
5445         fi
5446       fi
5447   ;;
5448 esac
5449
5450 case "${host}" in
5451   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5452   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5453   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5454 esac
5455
5456 # Record target_configdirs and the configure arguments for target and
5457 # build configuration in Makefile.
5458 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5459 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5460
5461 # Determine whether gdb needs tk/tcl or not.
5462 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5463 # and in that case we want gdb to be built without tk.  Ugh!
5464 # In fact I believe gdb is the *only* package directly dependent on tk,
5465 # so we should be able to put the 'maybe's in unconditionally and
5466 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5467 # 100% sure that that's safe though.
5468
5469 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5470 case "$enable_gdbtk" in
5471   no)
5472     GDB_TK="" ;;
5473   yes)
5474     GDB_TK="${gdb_tk}" ;;
5475   *)
5476     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5477     # distro.  Eventually someone will fix this and move Insight, nee
5478     # gdbtk to a separate directory.
5479     if test -d ${srcdir}/gdb/gdbtk ; then
5480       GDB_TK="${gdb_tk}"
5481     else
5482       GDB_TK=""
5483     fi
5484     ;;
5485 esac
5486 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5487 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5488
5489 # Strip out unwanted targets.
5490
5491 # While at that, we remove Makefiles if we were started for recursive
5492 # configuration, so that the top-level Makefile reconfigures them,
5493 # like we used to do when configure itself was recursive.
5494
5495 # Loop over modules.  $extrasub must be used with care, limiting as
5496 # much as possible the usage of range addresses.  That's because autoconf
5497 # splits the sed script to overcome limits in the number of commands,
5498 # and relying on carefully-timed sed passes may turn out to be very hard
5499 # to maintain later.  In this particular case, you just have to be careful
5500 # not to nest @if/@endif pairs, because configure will not warn you at all.
5501
5502 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5503 if test "${enable_bootstrap+set}" = set; then
5504   enableval="$enable_bootstrap"
5505
5506 else
5507   enable_bootstrap=default
5508 fi;
5509
5510 # Issue errors and warnings for invalid/strange bootstrap combinations.
5511 case "$configdirs" in
5512   *gcc*) have_compiler=yes ;;
5513   *) have_compiler=no ;;
5514 esac
5515
5516 case "$have_compiler:$host:$target:$enable_bootstrap" in
5517   *:*:*:no) ;;
5518
5519   # Default behavior.  Enable bootstrap if we have a compiler
5520   # and we are in a native configuration.
5521   yes:$build:$build:default)
5522     enable_bootstrap=yes ;;
5523
5524   *:*:*:default)
5525     enable_bootstrap=no ;;
5526
5527   # We have a compiler and we are in a native configuration, bootstrap is ok
5528   yes:$build:$build:yes)
5529     ;;
5530
5531   # Other configurations, but we have a compiler.  Assume the user knows
5532   # what he's doing.
5533   yes:*:*:yes)
5534     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5535 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5536     ;;
5537
5538   # No compiler: if they passed --enable-bootstrap explicitly, fail
5539   no:*:*:yes)
5540     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5541 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5542    { (exit 1); exit 1; }; } ;;
5543
5544   # Fail if wrong command line
5545   *)
5546     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5547 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5548    { (exit 1); exit 1; }; }
5549     ;;
5550 esac
5551
5552 # Adjust the toplevel makefile according to whether bootstrap was selected.
5553 case "$enable_bootstrap" in
5554   yes)
5555     bootstrap_suffix=bootstrap ;;
5556   no)
5557     bootstrap_suffix=no-bootstrap ;;
5558 esac
5559
5560 for module in ${build_configdirs} ; do
5561   if test -z "${no_recursion}" \
5562      && test -f ${build_subdir}/${module}/Makefile; then
5563     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5564     rm -f ${build_subdir}/${module}/Makefile
5565   fi
5566   extrasub="$extrasub
5567 /^@if build-$module\$/d
5568 /^@endif build-$module\$/d
5569 /^@if build-$module-$bootstrap_suffix\$/d
5570 /^@endif build-$module-$bootstrap_suffix\$/d"
5571 done
5572 for module in ${configdirs} ; do
5573   if test -z "${no_recursion}"; then
5574     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5575       if test -f ${file}; then
5576         echo 1>&2 "*** removing ${file} to force reconfigure"
5577         rm -f ${file}
5578       fi
5579     done
5580   fi
5581   extrasub="$extrasub
5582 /^@if $module\$/d
5583 /^@endif $module\$/d
5584 /^@if $module-$bootstrap_suffix\$/d
5585 /^@endif $module-$bootstrap_suffix\$/d"
5586 done
5587 for module in ${target_configdirs} ; do
5588   if test -z "${no_recursion}" \
5589      && test -f ${target_subdir}/${module}/Makefile; then
5590     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5591     rm -f ${target_subdir}/${module}/Makefile
5592   fi
5593   extrasub="$extrasub
5594 /^@if target-$module\$/d
5595 /^@endif target-$module\$/d
5596 /^@if target-$module-$bootstrap_suffix\$/d
5597 /^@endif target-$module-$bootstrap_suffix\$/d"
5598 done
5599
5600 extrasub="$extrasub
5601 /^@if /,/^@endif /d"
5602
5603 # Create the serialization dependencies.  This uses a temporary file.
5604
5605 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5606 if test "${enable_serial_configure+set}" = set; then
5607   enableval="$enable_serial_configure"
5608
5609 fi;
5610
5611 case ${enable_serial_configure} in
5612   yes)
5613     enable_serial_build_configure=yes
5614     enable_serial_host_configure=yes
5615     enable_serial_target_configure=yes
5616     ;;
5617 esac
5618
5619 # These force 'configure's to be done one at a time, to avoid problems
5620 # with contention over a shared config.cache.
5621 rm -f serdep.tmp
5622 echo '# serdep.tmp' > serdep.tmp
5623 olditem=
5624 test "x${enable_serial_build_configure}" = xyes &&
5625 for item in ${build_configdirs} ; do
5626   case ${olditem} in
5627     "") ;;
5628     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5629   esac
5630   olditem=${item}
5631 done
5632 olditem=
5633 test "x${enable_serial_host_configure}" = xyes &&
5634 for item in ${configdirs} ; do
5635   case ${olditem} in
5636     "") ;;
5637     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5638   esac
5639   olditem=${item}
5640 done
5641 olditem=
5642 test "x${enable_serial_target_configure}" = xyes &&
5643 for item in ${target_configdirs} ; do
5644   case ${olditem} in
5645     "") ;;
5646     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5647   esac
5648   olditem=${item}
5649 done
5650 serialization_dependencies=serdep.tmp
5651
5652
5653 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5654 # target, nonopt, and variable assignments.  These are the ones we
5655 # might not want to pass down to subconfigures.  Also strip
5656 # program-prefix, program-suffix, and program-transform-name, so that
5657 # we can pass down a consistent program-transform-name.
5658 baseargs=
5659 keep_next=no
5660 skip_next=no
5661 eval "set -- $ac_configure_args"
5662 for ac_arg
5663 do
5664   if test X"$skip_next" = X"yes"; then
5665     skip_next=no
5666     continue
5667   fi
5668   if test X"$keep_next" = X"yes"; then
5669     case $ac_arg in
5670       *\'*)
5671         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5672     esac
5673     baseargs="$baseargs '$ac_arg'"
5674     keep_next=no
5675     continue
5676   fi
5677
5678   # Handle separated arguments.  Based on the logic generated by
5679   # autoconf 2.59.
5680   case $ac_arg in
5681     *=* | --config-cache | -C | -disable-* | --disable-* \
5682       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5683       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5684       | -with-* | --with-* | -without-* | --without-* | --x)
5685       separate_arg=no
5686       ;;
5687     -*)
5688       separate_arg=yes
5689       ;;
5690     *)
5691       separate_arg=no
5692       ;;
5693   esac
5694
5695   case "$ac_arg" in
5696     --no*)
5697       continue
5698       ;;
5699     --c* | \
5700     --sr* | \
5701     --ho* | \
5702     --bu* | \
5703     --t* | \
5704     --program-* | \
5705     -cache_file* | \
5706     -srcdir* | \
5707     -host* | \
5708     -build* | \
5709     -target* | \
5710     -program-prefix* | \
5711     -program-suffix* | \
5712     -program-transform-name* )
5713       skip_next=$separate_arg
5714       continue
5715       ;;
5716     -*)
5717       # An option.  Add it.
5718       case $ac_arg in
5719         *\'*)
5720           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5721       esac
5722       baseargs="$baseargs '$ac_arg'"
5723       keep_next=$separate_arg
5724       ;;
5725     *)
5726       # Either a variable assignment, or a nonopt (triplet).  Don't
5727       # pass it down; let the Makefile handle this.
5728       continue
5729       ;;
5730   esac
5731 done
5732 # Remove the initial space we just introduced and, as these will be
5733 # expanded by make, quote '$'.
5734 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5735
5736 # Add in --program-transform-name, after --program-prefix and
5737 # --program-suffix have been applied to it.  Autoconf has already
5738 # doubled dollar signs and backslashes in program_transform_name; we want
5739 # the backslashes un-doubled, and then the entire thing wrapped in single
5740 # quotes, because this will be expanded first by make and then by the shell.
5741 # Also, because we want to override the logic in subdir configure scripts to
5742 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5743 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5744 ${program_transform_name}
5745 EOF_SED
5746 gcc_transform_name=`cat conftestsed.out`
5747 rm -f conftestsed.out
5748 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5749 if test "$silent" = yes; then
5750   baseargs="$baseargs --silent"
5751 fi
5752
5753 # For the build-side libraries, we just need to pretend we're native,
5754 # and not use the same cache file.  Multilibs are neither needed nor
5755 # desired.
5756 build_configargs="--cache-file=../config.cache ${baseargs}"
5757
5758 # For host modules, accept cache file option, or specification as blank.
5759 case "${cache_file}" in
5760 "") # empty
5761   cache_file_option="" ;;
5762 /* | [A-Za-z]:[\\/]* ) # absolute path
5763   cache_file_option="--cache-file=${cache_file}" ;;
5764 *) # relative path
5765   cache_file_option="--cache-file=../${cache_file}" ;;
5766 esac
5767
5768 # Host dirs don't like to share a cache file either, horribly enough.
5769 # This seems to be due to autoconf 2.5x stupidity.
5770 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5771
5772 target_configargs=${baseargs}
5773
5774 # Passing a --with-cross-host argument lets the target libraries know
5775 # whether they are being built with a cross-compiler or being built
5776 # native.  However, it would be better to use other mechanisms to make the
5777 # sorts of decisions they want to make on this basis.  Please consider
5778 # this option to be deprecated.  FIXME.
5779 if test x${is_cross_compiler} = xyes ; then
5780   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5781 fi
5782
5783 # Default to --enable-multilib.
5784 if test x${enable_multilib} = x ; then
5785   target_configargs="--enable-multilib ${target_configargs}"
5786 fi
5787
5788 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5789 # changed from the earlier setting of with_newlib.
5790 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5791   target_configargs="--with-newlib ${target_configargs}"
5792 fi
5793
5794 # Different target subdirs use different values of certain variables
5795 # (notably CXX).  Worse, multilibs use *lots* of different values.
5796 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5797 # it doesn't automatically accept command-line overrides of them.
5798 # This means it's not safe for target subdirs to share a cache file,
5799 # which is disgusting, but there you have it.  Hopefully this can be
5800 # fixed in future.  It's still worthwhile to use a cache file for each
5801 # directory.  I think.
5802
5803 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5804 # We need to pass --target, as newer autoconf's requires consistency
5805 # for target_alias and gcc doesn't manage it consistently.
5806 target_configargs="--cache-file=./config.cache ${target_configargs}"
5807
5808 FLAGS_FOR_TARGET=
5809 case " $target_configdirs " in
5810  *" newlib "*)
5811   case " $target_configargs " in
5812   *" --with-newlib "*)
5813    case "$target" in
5814    *-cygwin*)
5815      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' ;;
5816    esac
5817
5818    # If we're not building GCC, don't discard standard headers.
5819    if test -d ${srcdir}/gcc; then
5820      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5821
5822      if test "${build}" != "${host}"; then
5823        # On Canadian crosses, CC_FOR_TARGET will have already been set
5824        # by `configure', so we won't have an opportunity to add -Bgcc/
5825        # to it.  This is right: we don't want to search that directory
5826        # for binaries, but we want the header files in there, so add
5827        # them explicitly.
5828        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5829
5830        # Someone might think of using the pre-installed headers on
5831        # Canadian crosses, in case the installed compiler is not fully
5832        # compatible with the compiler being built.  In this case, it
5833        # would be better to flag an error than risking having
5834        # incompatible object files being constructed.  We can't
5835        # guarantee that an error will be flagged, but let's hope the
5836        # compiler will do it, when presented with incompatible header
5837        # files.
5838      fi
5839    fi
5840
5841    case "${target}-${is_cross_compiler}" in
5842    i[3456789]86-*-linux*-no)
5843       # Here host == target, so we don't need to build gcc,
5844       # so we don't want to discard standard headers.
5845       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5846       ;;
5847    *)
5848       # If we're building newlib, use its generic headers last, but search
5849       # for any libc-related directories first (so make it the last -B
5850       # switch).
5851       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5852
5853       # If we're building libgloss, find the startup file, simulator library
5854       # and linker script.
5855       case " $target_configdirs " in
5856         *" libgloss "*)
5857         # Look for startup file, simulator library and maybe linker script.
5858         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
5859         # Look for libnosys.a in case the target needs it.
5860         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5861         # Most targets have the linker script in the source directory.
5862         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
5863         ;;
5864       esac
5865       ;;
5866    esac
5867    ;;
5868   esac
5869   ;;
5870 esac
5871 case "$target" in
5872 *-mingw*)
5873   # Can't be handled as Cygwin above since Mingw does not use newlib.
5874   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' ;;
5875 esac
5876
5877 # Allow the user to override the flags for
5878 # our build compiler if desired.
5879 if test x"${build}" = x"${host}" ; then
5880   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5881   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
5882   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
5883 fi
5884
5885 # On Canadian crosses, we'll be searching the right directories for
5886 # the previously-installed cross compiler, so don't bother to add
5887 # flags for directories within the install tree of the compiler
5888 # being built; programs in there won't even run.
5889 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5890   # Search for pre-installed headers if nothing else fits.
5891   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5892 fi
5893
5894 if test "x${use_gnu_ld}" = x &&
5895    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5896   # Arrange for us to find uninstalled linker scripts.
5897   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5898 fi
5899
5900 # Search for other target-specific linker scripts and such.
5901 case "${target}" in
5902   mep*)
5903     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5904     ;;
5905 esac
5906
5907 # Makefile fragments.
5908 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5909 do
5910   eval fragval=\$$frag
5911   if test $fragval != /dev/null; then
5912     eval $frag=${srcdir}/$fragval
5913   fi
5914 done
5915
5916
5917
5918
5919
5920 # Miscellanea: directories, flags, etc.
5921
5922
5923
5924
5925
5926
5927
5928 # Build module lists & subconfigure args.
5929
5930
5931
5932 # Host module lists & subconfigure args.
5933
5934
5935
5936 # Target module lists & subconfigure args.
5937
5938
5939
5940 # Build tools.
5941
5942
5943
5944
5945
5946
5947
5948
5949
5950
5951
5952
5953
5954
5955
5956
5957
5958 # Generate default definitions for YACC, M4, LEX and other programs that run
5959 # on the build machine.  These are used if the Makefile can't locate these
5960 # programs in objdir.
5961 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5962
5963 for ac_prog in 'bison -y' byacc yacc
5964 do
5965   # Extract the first word of "$ac_prog", so it can be a program name with args.
5966 set dummy $ac_prog; ac_word=$2
5967 echo "$as_me:$LINENO: checking for $ac_word" >&5
5968 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5969 if test "${ac_cv_prog_YACC+set}" = set; then
5970   echo $ECHO_N "(cached) $ECHO_C" >&6
5971 else
5972   if test -n "$YACC"; then
5973   ac_cv_prog_YACC="$YACC" # Let the user override the test.
5974 else
5975 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5976 for as_dir in $PATH
5977 do
5978   IFS=$as_save_IFS
5979   test -z "$as_dir" && as_dir=.
5980   for ac_exec_ext in '' $ac_executable_extensions; do
5981   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5982     ac_cv_prog_YACC="$ac_prog"
5983     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5984     break 2
5985   fi
5986 done
5987 done
5988
5989 fi
5990 fi
5991 YACC=$ac_cv_prog_YACC
5992 if test -n "$YACC"; then
5993   echo "$as_me:$LINENO: result: $YACC" >&5
5994 echo "${ECHO_T}$YACC" >&6
5995 else
5996   echo "$as_me:$LINENO: result: no" >&5
5997 echo "${ECHO_T}no" >&6
5998 fi
5999
6000   test -n "$YACC" && break
6001 done
6002 test -n "$YACC" || YACC="$MISSING bison -y"
6003
6004 case " $build_configdirs " in
6005   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6006   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6007 esac
6008
6009 for ac_prog in bison
6010 do
6011   # Extract the first word of "$ac_prog", so it can be a program name with args.
6012 set dummy $ac_prog; ac_word=$2
6013 echo "$as_me:$LINENO: checking for $ac_word" >&5
6014 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6015 if test "${ac_cv_prog_BISON+set}" = set; then
6016   echo $ECHO_N "(cached) $ECHO_C" >&6
6017 else
6018   if test -n "$BISON"; then
6019   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6020 else
6021 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6022 for as_dir in $PATH
6023 do
6024   IFS=$as_save_IFS
6025   test -z "$as_dir" && as_dir=.
6026   for ac_exec_ext in '' $ac_executable_extensions; do
6027   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6028     ac_cv_prog_BISON="$ac_prog"
6029     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6030     break 2
6031   fi
6032 done
6033 done
6034
6035 fi
6036 fi
6037 BISON=$ac_cv_prog_BISON
6038 if test -n "$BISON"; then
6039   echo "$as_me:$LINENO: result: $BISON" >&5
6040 echo "${ECHO_T}$BISON" >&6
6041 else
6042   echo "$as_me:$LINENO: result: no" >&5
6043 echo "${ECHO_T}no" >&6
6044 fi
6045
6046   test -n "$BISON" && break
6047 done
6048 test -n "$BISON" || BISON="$MISSING bison"
6049
6050 case " $build_configdirs " in
6051   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6052 esac
6053
6054 for ac_prog in gm4 gnum4 m4
6055 do
6056   # Extract the first word of "$ac_prog", so it can be a program name with args.
6057 set dummy $ac_prog; ac_word=$2
6058 echo "$as_me:$LINENO: checking for $ac_word" >&5
6059 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6060 if test "${ac_cv_prog_M4+set}" = set; then
6061   echo $ECHO_N "(cached) $ECHO_C" >&6
6062 else
6063   if test -n "$M4"; then
6064   ac_cv_prog_M4="$M4" # Let the user override the test.
6065 else
6066 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6067 for as_dir in $PATH
6068 do
6069   IFS=$as_save_IFS
6070   test -z "$as_dir" && as_dir=.
6071   for ac_exec_ext in '' $ac_executable_extensions; do
6072   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6073     ac_cv_prog_M4="$ac_prog"
6074     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6075     break 2
6076   fi
6077 done
6078 done
6079
6080 fi
6081 fi
6082 M4=$ac_cv_prog_M4
6083 if test -n "$M4"; then
6084   echo "$as_me:$LINENO: result: $M4" >&5
6085 echo "${ECHO_T}$M4" >&6
6086 else
6087   echo "$as_me:$LINENO: result: no" >&5
6088 echo "${ECHO_T}no" >&6
6089 fi
6090
6091   test -n "$M4" && break
6092 done
6093 test -n "$M4" || M4="$MISSING m4"
6094
6095 case " $build_configdirs " in
6096   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6097 esac
6098
6099 for ac_prog in flex lex
6100 do
6101   # Extract the first word of "$ac_prog", so it can be a program name with args.
6102 set dummy $ac_prog; ac_word=$2
6103 echo "$as_me:$LINENO: checking for $ac_word" >&5
6104 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6105 if test "${ac_cv_prog_LEX+set}" = set; then
6106   echo $ECHO_N "(cached) $ECHO_C" >&6
6107 else
6108   if test -n "$LEX"; then
6109   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6110 else
6111 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6112 for as_dir in $PATH
6113 do
6114   IFS=$as_save_IFS
6115   test -z "$as_dir" && as_dir=.
6116   for ac_exec_ext in '' $ac_executable_extensions; do
6117   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6118     ac_cv_prog_LEX="$ac_prog"
6119     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6120     break 2
6121   fi
6122 done
6123 done
6124
6125 fi
6126 fi
6127 LEX=$ac_cv_prog_LEX
6128 if test -n "$LEX"; then
6129   echo "$as_me:$LINENO: result: $LEX" >&5
6130 echo "${ECHO_T}$LEX" >&6
6131 else
6132   echo "$as_me:$LINENO: result: no" >&5
6133 echo "${ECHO_T}no" >&6
6134 fi
6135
6136   test -n "$LEX" && break
6137 done
6138 test -n "$LEX" || LEX="$MISSING flex"
6139
6140 case " $build_configdirs " in
6141   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6142   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6143 esac
6144
6145 for ac_prog in flex
6146 do
6147   # Extract the first word of "$ac_prog", so it can be a program name with args.
6148 set dummy $ac_prog; ac_word=$2
6149 echo "$as_me:$LINENO: checking for $ac_word" >&5
6150 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6151 if test "${ac_cv_prog_FLEX+set}" = set; then
6152   echo $ECHO_N "(cached) $ECHO_C" >&6
6153 else
6154   if test -n "$FLEX"; then
6155   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6156 else
6157 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6158 for as_dir in $PATH
6159 do
6160   IFS=$as_save_IFS
6161   test -z "$as_dir" && as_dir=.
6162   for ac_exec_ext in '' $ac_executable_extensions; do
6163   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6164     ac_cv_prog_FLEX="$ac_prog"
6165     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6166     break 2
6167   fi
6168 done
6169 done
6170
6171 fi
6172 fi
6173 FLEX=$ac_cv_prog_FLEX
6174 if test -n "$FLEX"; then
6175   echo "$as_me:$LINENO: result: $FLEX" >&5
6176 echo "${ECHO_T}$FLEX" >&6
6177 else
6178   echo "$as_me:$LINENO: result: no" >&5
6179 echo "${ECHO_T}no" >&6
6180 fi
6181
6182   test -n "$FLEX" && break
6183 done
6184 test -n "$FLEX" || FLEX="$MISSING flex"
6185
6186 case " $build_configdirs " in
6187   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6188 esac
6189
6190 for ac_prog in makeinfo
6191 do
6192   # Extract the first word of "$ac_prog", so it can be a program name with args.
6193 set dummy $ac_prog; ac_word=$2
6194 echo "$as_me:$LINENO: checking for $ac_word" >&5
6195 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6196 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6197   echo $ECHO_N "(cached) $ECHO_C" >&6
6198 else
6199   if test -n "$MAKEINFO"; then
6200   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6201 else
6202 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6203 for as_dir in $PATH
6204 do
6205   IFS=$as_save_IFS
6206   test -z "$as_dir" && as_dir=.
6207   for ac_exec_ext in '' $ac_executable_extensions; do
6208   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6209     ac_cv_prog_MAKEINFO="$ac_prog"
6210     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6211     break 2
6212   fi
6213 done
6214 done
6215
6216 fi
6217 fi
6218 MAKEINFO=$ac_cv_prog_MAKEINFO
6219 if test -n "$MAKEINFO"; then
6220   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6221 echo "${ECHO_T}$MAKEINFO" >&6
6222 else
6223   echo "$as_me:$LINENO: result: no" >&5
6224 echo "${ECHO_T}no" >&6
6225 fi
6226
6227   test -n "$MAKEINFO" && break
6228 done
6229 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6230
6231 case " $build_configdirs " in
6232   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6233   *)
6234
6235     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6236     # higher, else we use the "missing" dummy.
6237     if ${MAKEINFO} --version \
6238        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6239       :
6240     else
6241       MAKEINFO="$MISSING makeinfo"
6242     fi
6243     ;;
6244
6245 esac
6246
6247 # FIXME: expect and dejagnu may become build tools?
6248
6249 for ac_prog in expect
6250 do
6251   # Extract the first word of "$ac_prog", so it can be a program name with args.
6252 set dummy $ac_prog; ac_word=$2
6253 echo "$as_me:$LINENO: checking for $ac_word" >&5
6254 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6255 if test "${ac_cv_prog_EXPECT+set}" = set; then
6256   echo $ECHO_N "(cached) $ECHO_C" >&6
6257 else
6258   if test -n "$EXPECT"; then
6259   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6260 else
6261 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6262 for as_dir in $PATH
6263 do
6264   IFS=$as_save_IFS
6265   test -z "$as_dir" && as_dir=.
6266   for ac_exec_ext in '' $ac_executable_extensions; do
6267   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6268     ac_cv_prog_EXPECT="$ac_prog"
6269     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6270     break 2
6271   fi
6272 done
6273 done
6274
6275 fi
6276 fi
6277 EXPECT=$ac_cv_prog_EXPECT
6278 if test -n "$EXPECT"; then
6279   echo "$as_me:$LINENO: result: $EXPECT" >&5
6280 echo "${ECHO_T}$EXPECT" >&6
6281 else
6282   echo "$as_me:$LINENO: result: no" >&5
6283 echo "${ECHO_T}no" >&6
6284 fi
6285
6286   test -n "$EXPECT" && break
6287 done
6288 test -n "$EXPECT" || EXPECT="expect"
6289
6290 case " $configdirs " in
6291   *" expect "*)
6292     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6293     ;;
6294 esac
6295
6296 for ac_prog in runtest
6297 do
6298   # Extract the first word of "$ac_prog", so it can be a program name with args.
6299 set dummy $ac_prog; ac_word=$2
6300 echo "$as_me:$LINENO: checking for $ac_word" >&5
6301 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6302 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6303   echo $ECHO_N "(cached) $ECHO_C" >&6
6304 else
6305   if test -n "$RUNTEST"; then
6306   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6307 else
6308 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6309 for as_dir in $PATH
6310 do
6311   IFS=$as_save_IFS
6312   test -z "$as_dir" && as_dir=.
6313   for ac_exec_ext in '' $ac_executable_extensions; do
6314   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6315     ac_cv_prog_RUNTEST="$ac_prog"
6316     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6317     break 2
6318   fi
6319 done
6320 done
6321
6322 fi
6323 fi
6324 RUNTEST=$ac_cv_prog_RUNTEST
6325 if test -n "$RUNTEST"; then
6326   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6327 echo "${ECHO_T}$RUNTEST" >&6
6328 else
6329   echo "$as_me:$LINENO: result: no" >&5
6330 echo "${ECHO_T}no" >&6
6331 fi
6332
6333   test -n "$RUNTEST" && break
6334 done
6335 test -n "$RUNTEST" || RUNTEST="runtest"
6336
6337 case " $configdirs " in
6338   *" dejagnu "*)
6339     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6340     ;;
6341 esac
6342
6343
6344 # Host tools.
6345 ncn_tool_prefix=
6346 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6347 ncn_target_tool_prefix=
6348 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6349
6350
6351
6352 if test -n "$AR"; then
6353   ac_cv_prog_AR=$AR
6354 elif test -n "$ac_cv_prog_AR"; then
6355   AR=$ac_cv_prog_AR
6356 fi
6357
6358 if test -n "$ac_cv_prog_AR"; then
6359   for ncn_progname in ar; do
6360     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6361 set dummy ${ncn_progname}; ac_word=$2
6362 echo "$as_me:$LINENO: checking for $ac_word" >&5
6363 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6364 if test "${ac_cv_prog_AR+set}" = set; then
6365   echo $ECHO_N "(cached) $ECHO_C" >&6
6366 else
6367   if test -n "$AR"; then
6368   ac_cv_prog_AR="$AR" # Let the user override the test.
6369 else
6370 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6371 for as_dir in $PATH
6372 do
6373   IFS=$as_save_IFS
6374   test -z "$as_dir" && as_dir=.
6375   for ac_exec_ext in '' $ac_executable_extensions; do
6376   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6377     ac_cv_prog_AR="${ncn_progname}"
6378     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6379     break 2
6380   fi
6381 done
6382 done
6383
6384 fi
6385 fi
6386 AR=$ac_cv_prog_AR
6387 if test -n "$AR"; then
6388   echo "$as_me:$LINENO: result: $AR" >&5
6389 echo "${ECHO_T}$AR" >&6
6390 else
6391   echo "$as_me:$LINENO: result: no" >&5
6392 echo "${ECHO_T}no" >&6
6393 fi
6394
6395   done
6396 fi
6397
6398 for ncn_progname in ar; do
6399   if test -n "$ncn_tool_prefix"; then
6400     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6401 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6402 echo "$as_me:$LINENO: checking for $ac_word" >&5
6403 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6404 if test "${ac_cv_prog_AR+set}" = set; then
6405   echo $ECHO_N "(cached) $ECHO_C" >&6
6406 else
6407   if test -n "$AR"; then
6408   ac_cv_prog_AR="$AR" # Let the user override the test.
6409 else
6410 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6411 for as_dir in $PATH
6412 do
6413   IFS=$as_save_IFS
6414   test -z "$as_dir" && as_dir=.
6415   for ac_exec_ext in '' $ac_executable_extensions; do
6416   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6417     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6418     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6419     break 2
6420   fi
6421 done
6422 done
6423
6424 fi
6425 fi
6426 AR=$ac_cv_prog_AR
6427 if test -n "$AR"; then
6428   echo "$as_me:$LINENO: result: $AR" >&5
6429 echo "${ECHO_T}$AR" >&6
6430 else
6431   echo "$as_me:$LINENO: result: no" >&5
6432 echo "${ECHO_T}no" >&6
6433 fi
6434
6435   fi
6436   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6437     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6438 set dummy ${ncn_progname}; ac_word=$2
6439 echo "$as_me:$LINENO: checking for $ac_word" >&5
6440 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6441 if test "${ac_cv_prog_AR+set}" = set; then
6442   echo $ECHO_N "(cached) $ECHO_C" >&6
6443 else
6444   if test -n "$AR"; then
6445   ac_cv_prog_AR="$AR" # Let the user override the test.
6446 else
6447 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6448 for as_dir in $PATH
6449 do
6450   IFS=$as_save_IFS
6451   test -z "$as_dir" && as_dir=.
6452   for ac_exec_ext in '' $ac_executable_extensions; do
6453   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6454     ac_cv_prog_AR="${ncn_progname}"
6455     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6456     break 2
6457   fi
6458 done
6459 done
6460
6461 fi
6462 fi
6463 AR=$ac_cv_prog_AR
6464 if test -n "$AR"; then
6465   echo "$as_me:$LINENO: result: $AR" >&5
6466 echo "${ECHO_T}$AR" >&6
6467 else
6468   echo "$as_me:$LINENO: result: no" >&5
6469 echo "${ECHO_T}no" >&6
6470 fi
6471
6472   fi
6473   test -n "$ac_cv_prog_AR" && break
6474 done
6475
6476 if test -z "$ac_cv_prog_AR" ; then
6477   set dummy ar
6478   if test $build = $host ; then
6479     AR="$2"
6480   else
6481     AR="${ncn_tool_prefix}$2"
6482   fi
6483 fi
6484
6485
6486
6487 if test -n "$AS"; then
6488   ac_cv_prog_AS=$AS
6489 elif test -n "$ac_cv_prog_AS"; then
6490   AS=$ac_cv_prog_AS
6491 fi
6492
6493 if test -n "$ac_cv_prog_AS"; then
6494   for ncn_progname in as; do
6495     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6496 set dummy ${ncn_progname}; ac_word=$2
6497 echo "$as_me:$LINENO: checking for $ac_word" >&5
6498 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6499 if test "${ac_cv_prog_AS+set}" = set; then
6500   echo $ECHO_N "(cached) $ECHO_C" >&6
6501 else
6502   if test -n "$AS"; then
6503   ac_cv_prog_AS="$AS" # Let the user override the test.
6504 else
6505 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6506 for as_dir in $PATH
6507 do
6508   IFS=$as_save_IFS
6509   test -z "$as_dir" && as_dir=.
6510   for ac_exec_ext in '' $ac_executable_extensions; do
6511   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6512     ac_cv_prog_AS="${ncn_progname}"
6513     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6514     break 2
6515   fi
6516 done
6517 done
6518
6519 fi
6520 fi
6521 AS=$ac_cv_prog_AS
6522 if test -n "$AS"; then
6523   echo "$as_me:$LINENO: result: $AS" >&5
6524 echo "${ECHO_T}$AS" >&6
6525 else
6526   echo "$as_me:$LINENO: result: no" >&5
6527 echo "${ECHO_T}no" >&6
6528 fi
6529
6530   done
6531 fi
6532
6533 for ncn_progname in as; do
6534   if test -n "$ncn_tool_prefix"; then
6535     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6536 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6537 echo "$as_me:$LINENO: checking for $ac_word" >&5
6538 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6539 if test "${ac_cv_prog_AS+set}" = set; then
6540   echo $ECHO_N "(cached) $ECHO_C" >&6
6541 else
6542   if test -n "$AS"; then
6543   ac_cv_prog_AS="$AS" # Let the user override the test.
6544 else
6545 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6546 for as_dir in $PATH
6547 do
6548   IFS=$as_save_IFS
6549   test -z "$as_dir" && as_dir=.
6550   for ac_exec_ext in '' $ac_executable_extensions; do
6551   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6552     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6553     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6554     break 2
6555   fi
6556 done
6557 done
6558
6559 fi
6560 fi
6561 AS=$ac_cv_prog_AS
6562 if test -n "$AS"; then
6563   echo "$as_me:$LINENO: result: $AS" >&5
6564 echo "${ECHO_T}$AS" >&6
6565 else
6566   echo "$as_me:$LINENO: result: no" >&5
6567 echo "${ECHO_T}no" >&6
6568 fi
6569
6570   fi
6571   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6572     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6573 set dummy ${ncn_progname}; ac_word=$2
6574 echo "$as_me:$LINENO: checking for $ac_word" >&5
6575 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6576 if test "${ac_cv_prog_AS+set}" = set; then
6577   echo $ECHO_N "(cached) $ECHO_C" >&6
6578 else
6579   if test -n "$AS"; then
6580   ac_cv_prog_AS="$AS" # Let the user override the test.
6581 else
6582 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6583 for as_dir in $PATH
6584 do
6585   IFS=$as_save_IFS
6586   test -z "$as_dir" && as_dir=.
6587   for ac_exec_ext in '' $ac_executable_extensions; do
6588   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6589     ac_cv_prog_AS="${ncn_progname}"
6590     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6591     break 2
6592   fi
6593 done
6594 done
6595
6596 fi
6597 fi
6598 AS=$ac_cv_prog_AS
6599 if test -n "$AS"; then
6600   echo "$as_me:$LINENO: result: $AS" >&5
6601 echo "${ECHO_T}$AS" >&6
6602 else
6603   echo "$as_me:$LINENO: result: no" >&5
6604 echo "${ECHO_T}no" >&6
6605 fi
6606
6607   fi
6608   test -n "$ac_cv_prog_AS" && break
6609 done
6610
6611 if test -z "$ac_cv_prog_AS" ; then
6612   set dummy as
6613   if test $build = $host ; then
6614     AS="$2"
6615   else
6616     AS="${ncn_tool_prefix}$2"
6617   fi
6618 fi
6619
6620
6621
6622 if test -n "$DLLTOOL"; then
6623   ac_cv_prog_DLLTOOL=$DLLTOOL
6624 elif test -n "$ac_cv_prog_DLLTOOL"; then
6625   DLLTOOL=$ac_cv_prog_DLLTOOL
6626 fi
6627
6628 if test -n "$ac_cv_prog_DLLTOOL"; then
6629   for ncn_progname in dlltool; do
6630     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6631 set dummy ${ncn_progname}; ac_word=$2
6632 echo "$as_me:$LINENO: checking for $ac_word" >&5
6633 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6634 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6635   echo $ECHO_N "(cached) $ECHO_C" >&6
6636 else
6637   if test -n "$DLLTOOL"; then
6638   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6639 else
6640 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6641 for as_dir in $PATH
6642 do
6643   IFS=$as_save_IFS
6644   test -z "$as_dir" && as_dir=.
6645   for ac_exec_ext in '' $ac_executable_extensions; do
6646   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6647     ac_cv_prog_DLLTOOL="${ncn_progname}"
6648     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6649     break 2
6650   fi
6651 done
6652 done
6653
6654 fi
6655 fi
6656 DLLTOOL=$ac_cv_prog_DLLTOOL
6657 if test -n "$DLLTOOL"; then
6658   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6659 echo "${ECHO_T}$DLLTOOL" >&6
6660 else
6661   echo "$as_me:$LINENO: result: no" >&5
6662 echo "${ECHO_T}no" >&6
6663 fi
6664
6665   done
6666 fi
6667
6668 for ncn_progname in dlltool; do
6669   if test -n "$ncn_tool_prefix"; then
6670     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6671 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6672 echo "$as_me:$LINENO: checking for $ac_word" >&5
6673 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6674 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6675   echo $ECHO_N "(cached) $ECHO_C" >&6
6676 else
6677   if test -n "$DLLTOOL"; then
6678   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6679 else
6680 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6681 for as_dir in $PATH
6682 do
6683   IFS=$as_save_IFS
6684   test -z "$as_dir" && as_dir=.
6685   for ac_exec_ext in '' $ac_executable_extensions; do
6686   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6687     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6688     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6689     break 2
6690   fi
6691 done
6692 done
6693
6694 fi
6695 fi
6696 DLLTOOL=$ac_cv_prog_DLLTOOL
6697 if test -n "$DLLTOOL"; then
6698   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6699 echo "${ECHO_T}$DLLTOOL" >&6
6700 else
6701   echo "$as_me:$LINENO: result: no" >&5
6702 echo "${ECHO_T}no" >&6
6703 fi
6704
6705   fi
6706   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6707     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6708 set dummy ${ncn_progname}; ac_word=$2
6709 echo "$as_me:$LINENO: checking for $ac_word" >&5
6710 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6711 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6712   echo $ECHO_N "(cached) $ECHO_C" >&6
6713 else
6714   if test -n "$DLLTOOL"; then
6715   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6716 else
6717 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6718 for as_dir in $PATH
6719 do
6720   IFS=$as_save_IFS
6721   test -z "$as_dir" && as_dir=.
6722   for ac_exec_ext in '' $ac_executable_extensions; do
6723   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6724     ac_cv_prog_DLLTOOL="${ncn_progname}"
6725     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6726     break 2
6727   fi
6728 done
6729 done
6730
6731 fi
6732 fi
6733 DLLTOOL=$ac_cv_prog_DLLTOOL
6734 if test -n "$DLLTOOL"; then
6735   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6736 echo "${ECHO_T}$DLLTOOL" >&6
6737 else
6738   echo "$as_me:$LINENO: result: no" >&5
6739 echo "${ECHO_T}no" >&6
6740 fi
6741
6742   fi
6743   test -n "$ac_cv_prog_DLLTOOL" && break
6744 done
6745
6746 if test -z "$ac_cv_prog_DLLTOOL" ; then
6747   set dummy dlltool
6748   if test $build = $host ; then
6749     DLLTOOL="$2"
6750   else
6751     DLLTOOL="${ncn_tool_prefix}$2"
6752   fi
6753 fi
6754
6755
6756
6757 if test -n "$LD"; then
6758   ac_cv_prog_LD=$LD
6759 elif test -n "$ac_cv_prog_LD"; then
6760   LD=$ac_cv_prog_LD
6761 fi
6762
6763 if test -n "$ac_cv_prog_LD"; then
6764   for ncn_progname in ld; do
6765     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6766 set dummy ${ncn_progname}; ac_word=$2
6767 echo "$as_me:$LINENO: checking for $ac_word" >&5
6768 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6769 if test "${ac_cv_prog_LD+set}" = set; then
6770   echo $ECHO_N "(cached) $ECHO_C" >&6
6771 else
6772   if test -n "$LD"; then
6773   ac_cv_prog_LD="$LD" # Let the user override the test.
6774 else
6775 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6776 for as_dir in $PATH
6777 do
6778   IFS=$as_save_IFS
6779   test -z "$as_dir" && as_dir=.
6780   for ac_exec_ext in '' $ac_executable_extensions; do
6781   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6782     ac_cv_prog_LD="${ncn_progname}"
6783     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6784     break 2
6785   fi
6786 done
6787 done
6788
6789 fi
6790 fi
6791 LD=$ac_cv_prog_LD
6792 if test -n "$LD"; then
6793   echo "$as_me:$LINENO: result: $LD" >&5
6794 echo "${ECHO_T}$LD" >&6
6795 else
6796   echo "$as_me:$LINENO: result: no" >&5
6797 echo "${ECHO_T}no" >&6
6798 fi
6799
6800   done
6801 fi
6802
6803 for ncn_progname in ld; do
6804   if test -n "$ncn_tool_prefix"; then
6805     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6806 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6807 echo "$as_me:$LINENO: checking for $ac_word" >&5
6808 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6809 if test "${ac_cv_prog_LD+set}" = set; then
6810   echo $ECHO_N "(cached) $ECHO_C" >&6
6811 else
6812   if test -n "$LD"; then
6813   ac_cv_prog_LD="$LD" # Let the user override the test.
6814 else
6815 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6816 for as_dir in $PATH
6817 do
6818   IFS=$as_save_IFS
6819   test -z "$as_dir" && as_dir=.
6820   for ac_exec_ext in '' $ac_executable_extensions; do
6821   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6822     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6823     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6824     break 2
6825   fi
6826 done
6827 done
6828
6829 fi
6830 fi
6831 LD=$ac_cv_prog_LD
6832 if test -n "$LD"; then
6833   echo "$as_me:$LINENO: result: $LD" >&5
6834 echo "${ECHO_T}$LD" >&6
6835 else
6836   echo "$as_me:$LINENO: result: no" >&5
6837 echo "${ECHO_T}no" >&6
6838 fi
6839
6840   fi
6841   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6842     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6843 set dummy ${ncn_progname}; ac_word=$2
6844 echo "$as_me:$LINENO: checking for $ac_word" >&5
6845 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6846 if test "${ac_cv_prog_LD+set}" = set; then
6847   echo $ECHO_N "(cached) $ECHO_C" >&6
6848 else
6849   if test -n "$LD"; then
6850   ac_cv_prog_LD="$LD" # Let the user override the test.
6851 else
6852 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6853 for as_dir in $PATH
6854 do
6855   IFS=$as_save_IFS
6856   test -z "$as_dir" && as_dir=.
6857   for ac_exec_ext in '' $ac_executable_extensions; do
6858   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6859     ac_cv_prog_LD="${ncn_progname}"
6860     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6861     break 2
6862   fi
6863 done
6864 done
6865
6866 fi
6867 fi
6868 LD=$ac_cv_prog_LD
6869 if test -n "$LD"; then
6870   echo "$as_me:$LINENO: result: $LD" >&5
6871 echo "${ECHO_T}$LD" >&6
6872 else
6873   echo "$as_me:$LINENO: result: no" >&5
6874 echo "${ECHO_T}no" >&6
6875 fi
6876
6877   fi
6878   test -n "$ac_cv_prog_LD" && break
6879 done
6880
6881 if test -z "$ac_cv_prog_LD" ; then
6882   set dummy ld
6883   if test $build = $host ; then
6884     LD="$2"
6885   else
6886     LD="${ncn_tool_prefix}$2"
6887   fi
6888 fi
6889
6890
6891
6892 if test -n "$LIPO"; then
6893   ac_cv_prog_LIPO=$LIPO
6894 elif test -n "$ac_cv_prog_LIPO"; then
6895   LIPO=$ac_cv_prog_LIPO
6896 fi
6897
6898 if test -n "$ac_cv_prog_LIPO"; then
6899   for ncn_progname in lipo; do
6900     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6901 set dummy ${ncn_progname}; ac_word=$2
6902 echo "$as_me:$LINENO: checking for $ac_word" >&5
6903 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6904 if test "${ac_cv_prog_LIPO+set}" = set; then
6905   echo $ECHO_N "(cached) $ECHO_C" >&6
6906 else
6907   if test -n "$LIPO"; then
6908   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6909 else
6910 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6911 for as_dir in $PATH
6912 do
6913   IFS=$as_save_IFS
6914   test -z "$as_dir" && as_dir=.
6915   for ac_exec_ext in '' $ac_executable_extensions; do
6916   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6917     ac_cv_prog_LIPO="${ncn_progname}"
6918     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6919     break 2
6920   fi
6921 done
6922 done
6923
6924 fi
6925 fi
6926 LIPO=$ac_cv_prog_LIPO
6927 if test -n "$LIPO"; then
6928   echo "$as_me:$LINENO: result: $LIPO" >&5
6929 echo "${ECHO_T}$LIPO" >&6
6930 else
6931   echo "$as_me:$LINENO: result: no" >&5
6932 echo "${ECHO_T}no" >&6
6933 fi
6934
6935   done
6936 fi
6937
6938 for ncn_progname in lipo; do
6939   if test -n "$ncn_tool_prefix"; then
6940     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6941 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6942 echo "$as_me:$LINENO: checking for $ac_word" >&5
6943 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6944 if test "${ac_cv_prog_LIPO+set}" = set; then
6945   echo $ECHO_N "(cached) $ECHO_C" >&6
6946 else
6947   if test -n "$LIPO"; then
6948   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6949 else
6950 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6951 for as_dir in $PATH
6952 do
6953   IFS=$as_save_IFS
6954   test -z "$as_dir" && as_dir=.
6955   for ac_exec_ext in '' $ac_executable_extensions; do
6956   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6957     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6958     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6959     break 2
6960   fi
6961 done
6962 done
6963
6964 fi
6965 fi
6966 LIPO=$ac_cv_prog_LIPO
6967 if test -n "$LIPO"; then
6968   echo "$as_me:$LINENO: result: $LIPO" >&5
6969 echo "${ECHO_T}$LIPO" >&6
6970 else
6971   echo "$as_me:$LINENO: result: no" >&5
6972 echo "${ECHO_T}no" >&6
6973 fi
6974
6975   fi
6976   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
6977     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6978 set dummy ${ncn_progname}; ac_word=$2
6979 echo "$as_me:$LINENO: checking for $ac_word" >&5
6980 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6981 if test "${ac_cv_prog_LIPO+set}" = set; then
6982   echo $ECHO_N "(cached) $ECHO_C" >&6
6983 else
6984   if test -n "$LIPO"; then
6985   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6986 else
6987 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6988 for as_dir in $PATH
6989 do
6990   IFS=$as_save_IFS
6991   test -z "$as_dir" && as_dir=.
6992   for ac_exec_ext in '' $ac_executable_extensions; do
6993   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6994     ac_cv_prog_LIPO="${ncn_progname}"
6995     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6996     break 2
6997   fi
6998 done
6999 done
7000
7001 fi
7002 fi
7003 LIPO=$ac_cv_prog_LIPO
7004 if test -n "$LIPO"; then
7005   echo "$as_me:$LINENO: result: $LIPO" >&5
7006 echo "${ECHO_T}$LIPO" >&6
7007 else
7008   echo "$as_me:$LINENO: result: no" >&5
7009 echo "${ECHO_T}no" >&6
7010 fi
7011
7012   fi
7013   test -n "$ac_cv_prog_LIPO" && break
7014 done
7015
7016 if test -z "$ac_cv_prog_LIPO" ; then
7017   set dummy lipo
7018   if test $build = $host ; then
7019     LIPO="$2"
7020   else
7021     LIPO="${ncn_tool_prefix}$2"
7022   fi
7023 fi
7024
7025
7026
7027 if test -n "$NM"; then
7028   ac_cv_prog_NM=$NM
7029 elif test -n "$ac_cv_prog_NM"; then
7030   NM=$ac_cv_prog_NM
7031 fi
7032
7033 if test -n "$ac_cv_prog_NM"; then
7034   for ncn_progname in nm; do
7035     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7036 set dummy ${ncn_progname}; ac_word=$2
7037 echo "$as_me:$LINENO: checking for $ac_word" >&5
7038 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7039 if test "${ac_cv_prog_NM+set}" = set; then
7040   echo $ECHO_N "(cached) $ECHO_C" >&6
7041 else
7042   if test -n "$NM"; then
7043   ac_cv_prog_NM="$NM" # Let the user override the test.
7044 else
7045 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7046 for as_dir in $PATH
7047 do
7048   IFS=$as_save_IFS
7049   test -z "$as_dir" && as_dir=.
7050   for ac_exec_ext in '' $ac_executable_extensions; do
7051   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7052     ac_cv_prog_NM="${ncn_progname}"
7053     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7054     break 2
7055   fi
7056 done
7057 done
7058
7059 fi
7060 fi
7061 NM=$ac_cv_prog_NM
7062 if test -n "$NM"; then
7063   echo "$as_me:$LINENO: result: $NM" >&5
7064 echo "${ECHO_T}$NM" >&6
7065 else
7066   echo "$as_me:$LINENO: result: no" >&5
7067 echo "${ECHO_T}no" >&6
7068 fi
7069
7070   done
7071 fi
7072
7073 for ncn_progname in nm; do
7074   if test -n "$ncn_tool_prefix"; then
7075     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7076 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7077 echo "$as_me:$LINENO: checking for $ac_word" >&5
7078 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7079 if test "${ac_cv_prog_NM+set}" = set; then
7080   echo $ECHO_N "(cached) $ECHO_C" >&6
7081 else
7082   if test -n "$NM"; then
7083   ac_cv_prog_NM="$NM" # Let the user override the test.
7084 else
7085 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7086 for as_dir in $PATH
7087 do
7088   IFS=$as_save_IFS
7089   test -z "$as_dir" && as_dir=.
7090   for ac_exec_ext in '' $ac_executable_extensions; do
7091   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7092     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7093     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7094     break 2
7095   fi
7096 done
7097 done
7098
7099 fi
7100 fi
7101 NM=$ac_cv_prog_NM
7102 if test -n "$NM"; then
7103   echo "$as_me:$LINENO: result: $NM" >&5
7104 echo "${ECHO_T}$NM" >&6
7105 else
7106   echo "$as_me:$LINENO: result: no" >&5
7107 echo "${ECHO_T}no" >&6
7108 fi
7109
7110   fi
7111   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7112     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7113 set dummy ${ncn_progname}; ac_word=$2
7114 echo "$as_me:$LINENO: checking for $ac_word" >&5
7115 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7116 if test "${ac_cv_prog_NM+set}" = set; then
7117   echo $ECHO_N "(cached) $ECHO_C" >&6
7118 else
7119   if test -n "$NM"; then
7120   ac_cv_prog_NM="$NM" # Let the user override the test.
7121 else
7122 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7123 for as_dir in $PATH
7124 do
7125   IFS=$as_save_IFS
7126   test -z "$as_dir" && as_dir=.
7127   for ac_exec_ext in '' $ac_executable_extensions; do
7128   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7129     ac_cv_prog_NM="${ncn_progname}"
7130     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7131     break 2
7132   fi
7133 done
7134 done
7135
7136 fi
7137 fi
7138 NM=$ac_cv_prog_NM
7139 if test -n "$NM"; then
7140   echo "$as_me:$LINENO: result: $NM" >&5
7141 echo "${ECHO_T}$NM" >&6
7142 else
7143   echo "$as_me:$LINENO: result: no" >&5
7144 echo "${ECHO_T}no" >&6
7145 fi
7146
7147   fi
7148   test -n "$ac_cv_prog_NM" && break
7149 done
7150
7151 if test -z "$ac_cv_prog_NM" ; then
7152   set dummy nm
7153   if test $build = $host ; then
7154     NM="$2"
7155   else
7156     NM="${ncn_tool_prefix}$2"
7157   fi
7158 fi
7159
7160
7161
7162 if test -n "$RANLIB"; then
7163   ac_cv_prog_RANLIB=$RANLIB
7164 elif test -n "$ac_cv_prog_RANLIB"; then
7165   RANLIB=$ac_cv_prog_RANLIB
7166 fi
7167
7168 if test -n "$ac_cv_prog_RANLIB"; then
7169   for ncn_progname in ranlib; do
7170     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7171 set dummy ${ncn_progname}; ac_word=$2
7172 echo "$as_me:$LINENO: checking for $ac_word" >&5
7173 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7174 if test "${ac_cv_prog_RANLIB+set}" = set; then
7175   echo $ECHO_N "(cached) $ECHO_C" >&6
7176 else
7177   if test -n "$RANLIB"; then
7178   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7179 else
7180 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7181 for as_dir in $PATH
7182 do
7183   IFS=$as_save_IFS
7184   test -z "$as_dir" && as_dir=.
7185   for ac_exec_ext in '' $ac_executable_extensions; do
7186   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7187     ac_cv_prog_RANLIB="${ncn_progname}"
7188     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7189     break 2
7190   fi
7191 done
7192 done
7193
7194 fi
7195 fi
7196 RANLIB=$ac_cv_prog_RANLIB
7197 if test -n "$RANLIB"; then
7198   echo "$as_me:$LINENO: result: $RANLIB" >&5
7199 echo "${ECHO_T}$RANLIB" >&6
7200 else
7201   echo "$as_me:$LINENO: result: no" >&5
7202 echo "${ECHO_T}no" >&6
7203 fi
7204
7205   done
7206 fi
7207
7208 for ncn_progname in ranlib; do
7209   if test -n "$ncn_tool_prefix"; then
7210     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7211 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7212 echo "$as_me:$LINENO: checking for $ac_word" >&5
7213 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7214 if test "${ac_cv_prog_RANLIB+set}" = set; then
7215   echo $ECHO_N "(cached) $ECHO_C" >&6
7216 else
7217   if test -n "$RANLIB"; then
7218   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7219 else
7220 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7221 for as_dir in $PATH
7222 do
7223   IFS=$as_save_IFS
7224   test -z "$as_dir" && as_dir=.
7225   for ac_exec_ext in '' $ac_executable_extensions; do
7226   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7227     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7228     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7229     break 2
7230   fi
7231 done
7232 done
7233
7234 fi
7235 fi
7236 RANLIB=$ac_cv_prog_RANLIB
7237 if test -n "$RANLIB"; then
7238   echo "$as_me:$LINENO: result: $RANLIB" >&5
7239 echo "${ECHO_T}$RANLIB" >&6
7240 else
7241   echo "$as_me:$LINENO: result: no" >&5
7242 echo "${ECHO_T}no" >&6
7243 fi
7244
7245   fi
7246   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7247     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7248 set dummy ${ncn_progname}; ac_word=$2
7249 echo "$as_me:$LINENO: checking for $ac_word" >&5
7250 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7251 if test "${ac_cv_prog_RANLIB+set}" = set; then
7252   echo $ECHO_N "(cached) $ECHO_C" >&6
7253 else
7254   if test -n "$RANLIB"; then
7255   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7256 else
7257 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7258 for as_dir in $PATH
7259 do
7260   IFS=$as_save_IFS
7261   test -z "$as_dir" && as_dir=.
7262   for ac_exec_ext in '' $ac_executable_extensions; do
7263   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7264     ac_cv_prog_RANLIB="${ncn_progname}"
7265     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7266     break 2
7267   fi
7268 done
7269 done
7270
7271 fi
7272 fi
7273 RANLIB=$ac_cv_prog_RANLIB
7274 if test -n "$RANLIB"; then
7275   echo "$as_me:$LINENO: result: $RANLIB" >&5
7276 echo "${ECHO_T}$RANLIB" >&6
7277 else
7278   echo "$as_me:$LINENO: result: no" >&5
7279 echo "${ECHO_T}no" >&6
7280 fi
7281
7282   fi
7283   test -n "$ac_cv_prog_RANLIB" && break
7284 done
7285
7286 if test -z "$ac_cv_prog_RANLIB" ; then
7287   RANLIB=":"
7288 fi
7289
7290
7291
7292 if test -n "$STRIP"; then
7293   ac_cv_prog_STRIP=$STRIP
7294 elif test -n "$ac_cv_prog_STRIP"; then
7295   STRIP=$ac_cv_prog_STRIP
7296 fi
7297
7298 if test -n "$ac_cv_prog_STRIP"; then
7299   for ncn_progname in strip; do
7300     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7301 set dummy ${ncn_progname}; ac_word=$2
7302 echo "$as_me:$LINENO: checking for $ac_word" >&5
7303 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7304 if test "${ac_cv_prog_STRIP+set}" = set; then
7305   echo $ECHO_N "(cached) $ECHO_C" >&6
7306 else
7307   if test -n "$STRIP"; then
7308   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7309 else
7310 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7311 for as_dir in $PATH
7312 do
7313   IFS=$as_save_IFS
7314   test -z "$as_dir" && as_dir=.
7315   for ac_exec_ext in '' $ac_executable_extensions; do
7316   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7317     ac_cv_prog_STRIP="${ncn_progname}"
7318     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7319     break 2
7320   fi
7321 done
7322 done
7323
7324 fi
7325 fi
7326 STRIP=$ac_cv_prog_STRIP
7327 if test -n "$STRIP"; then
7328   echo "$as_me:$LINENO: result: $STRIP" >&5
7329 echo "${ECHO_T}$STRIP" >&6
7330 else
7331   echo "$as_me:$LINENO: result: no" >&5
7332 echo "${ECHO_T}no" >&6
7333 fi
7334
7335   done
7336 fi
7337
7338 for ncn_progname in strip; do
7339   if test -n "$ncn_tool_prefix"; then
7340     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7341 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7342 echo "$as_me:$LINENO: checking for $ac_word" >&5
7343 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7344 if test "${ac_cv_prog_STRIP+set}" = set; then
7345   echo $ECHO_N "(cached) $ECHO_C" >&6
7346 else
7347   if test -n "$STRIP"; then
7348   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7349 else
7350 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7351 for as_dir in $PATH
7352 do
7353   IFS=$as_save_IFS
7354   test -z "$as_dir" && as_dir=.
7355   for ac_exec_ext in '' $ac_executable_extensions; do
7356   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7357     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7358     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7359     break 2
7360   fi
7361 done
7362 done
7363
7364 fi
7365 fi
7366 STRIP=$ac_cv_prog_STRIP
7367 if test -n "$STRIP"; then
7368   echo "$as_me:$LINENO: result: $STRIP" >&5
7369 echo "${ECHO_T}$STRIP" >&6
7370 else
7371   echo "$as_me:$LINENO: result: no" >&5
7372 echo "${ECHO_T}no" >&6
7373 fi
7374
7375   fi
7376   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7377     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7378 set dummy ${ncn_progname}; ac_word=$2
7379 echo "$as_me:$LINENO: checking for $ac_word" >&5
7380 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7381 if test "${ac_cv_prog_STRIP+set}" = set; then
7382   echo $ECHO_N "(cached) $ECHO_C" >&6
7383 else
7384   if test -n "$STRIP"; then
7385   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7386 else
7387 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7388 for as_dir in $PATH
7389 do
7390   IFS=$as_save_IFS
7391   test -z "$as_dir" && as_dir=.
7392   for ac_exec_ext in '' $ac_executable_extensions; do
7393   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7394     ac_cv_prog_STRIP="${ncn_progname}"
7395     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7396     break 2
7397   fi
7398 done
7399 done
7400
7401 fi
7402 fi
7403 STRIP=$ac_cv_prog_STRIP
7404 if test -n "$STRIP"; then
7405   echo "$as_me:$LINENO: result: $STRIP" >&5
7406 echo "${ECHO_T}$STRIP" >&6
7407 else
7408   echo "$as_me:$LINENO: result: no" >&5
7409 echo "${ECHO_T}no" >&6
7410 fi
7411
7412   fi
7413   test -n "$ac_cv_prog_STRIP" && break
7414 done
7415
7416 if test -z "$ac_cv_prog_STRIP" ; then
7417   STRIP=":"
7418 fi
7419
7420
7421
7422 if test -n "$WINDRES"; then
7423   ac_cv_prog_WINDRES=$WINDRES
7424 elif test -n "$ac_cv_prog_WINDRES"; then
7425   WINDRES=$ac_cv_prog_WINDRES
7426 fi
7427
7428 if test -n "$ac_cv_prog_WINDRES"; then
7429   for ncn_progname in windres; do
7430     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7431 set dummy ${ncn_progname}; ac_word=$2
7432 echo "$as_me:$LINENO: checking for $ac_word" >&5
7433 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7434 if test "${ac_cv_prog_WINDRES+set}" = set; then
7435   echo $ECHO_N "(cached) $ECHO_C" >&6
7436 else
7437   if test -n "$WINDRES"; then
7438   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7439 else
7440 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7441 for as_dir in $PATH
7442 do
7443   IFS=$as_save_IFS
7444   test -z "$as_dir" && as_dir=.
7445   for ac_exec_ext in '' $ac_executable_extensions; do
7446   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7447     ac_cv_prog_WINDRES="${ncn_progname}"
7448     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7449     break 2
7450   fi
7451 done
7452 done
7453
7454 fi
7455 fi
7456 WINDRES=$ac_cv_prog_WINDRES
7457 if test -n "$WINDRES"; then
7458   echo "$as_me:$LINENO: result: $WINDRES" >&5
7459 echo "${ECHO_T}$WINDRES" >&6
7460 else
7461   echo "$as_me:$LINENO: result: no" >&5
7462 echo "${ECHO_T}no" >&6
7463 fi
7464
7465   done
7466 fi
7467
7468 for ncn_progname in windres; do
7469   if test -n "$ncn_tool_prefix"; then
7470     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7471 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7472 echo "$as_me:$LINENO: checking for $ac_word" >&5
7473 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7474 if test "${ac_cv_prog_WINDRES+set}" = set; then
7475   echo $ECHO_N "(cached) $ECHO_C" >&6
7476 else
7477   if test -n "$WINDRES"; then
7478   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7479 else
7480 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7481 for as_dir in $PATH
7482 do
7483   IFS=$as_save_IFS
7484   test -z "$as_dir" && as_dir=.
7485   for ac_exec_ext in '' $ac_executable_extensions; do
7486   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7487     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7488     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7489     break 2
7490   fi
7491 done
7492 done
7493
7494 fi
7495 fi
7496 WINDRES=$ac_cv_prog_WINDRES
7497 if test -n "$WINDRES"; then
7498   echo "$as_me:$LINENO: result: $WINDRES" >&5
7499 echo "${ECHO_T}$WINDRES" >&6
7500 else
7501   echo "$as_me:$LINENO: result: no" >&5
7502 echo "${ECHO_T}no" >&6
7503 fi
7504
7505   fi
7506   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7507     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7508 set dummy ${ncn_progname}; ac_word=$2
7509 echo "$as_me:$LINENO: checking for $ac_word" >&5
7510 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7511 if test "${ac_cv_prog_WINDRES+set}" = set; then
7512   echo $ECHO_N "(cached) $ECHO_C" >&6
7513 else
7514   if test -n "$WINDRES"; then
7515   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7516 else
7517 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7518 for as_dir in $PATH
7519 do
7520   IFS=$as_save_IFS
7521   test -z "$as_dir" && as_dir=.
7522   for ac_exec_ext in '' $ac_executable_extensions; do
7523   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7524     ac_cv_prog_WINDRES="${ncn_progname}"
7525     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7526     break 2
7527   fi
7528 done
7529 done
7530
7531 fi
7532 fi
7533 WINDRES=$ac_cv_prog_WINDRES
7534 if test -n "$WINDRES"; then
7535   echo "$as_me:$LINENO: result: $WINDRES" >&5
7536 echo "${ECHO_T}$WINDRES" >&6
7537 else
7538   echo "$as_me:$LINENO: result: no" >&5
7539 echo "${ECHO_T}no" >&6
7540 fi
7541
7542   fi
7543   test -n "$ac_cv_prog_WINDRES" && break
7544 done
7545
7546 if test -z "$ac_cv_prog_WINDRES" ; then
7547   set dummy windres
7548   if test $build = $host ; then
7549     WINDRES="$2"
7550   else
7551     WINDRES="${ncn_tool_prefix}$2"
7552   fi
7553 fi
7554
7555
7556
7557 if test -n "$WINDMC"; then
7558   ac_cv_prog_WINDMC=$WINDMC
7559 elif test -n "$ac_cv_prog_WINDMC"; then
7560   WINDMC=$ac_cv_prog_WINDMC
7561 fi
7562
7563 if test -n "$ac_cv_prog_WINDMC"; then
7564   for ncn_progname in windmc; do
7565     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7566 set dummy ${ncn_progname}; ac_word=$2
7567 echo "$as_me:$LINENO: checking for $ac_word" >&5
7568 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7569 if test "${ac_cv_prog_WINDMC+set}" = set; then
7570   echo $ECHO_N "(cached) $ECHO_C" >&6
7571 else
7572   if test -n "$WINDMC"; then
7573   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7574 else
7575 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7576 for as_dir in $PATH
7577 do
7578   IFS=$as_save_IFS
7579   test -z "$as_dir" && as_dir=.
7580   for ac_exec_ext in '' $ac_executable_extensions; do
7581   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7582     ac_cv_prog_WINDMC="${ncn_progname}"
7583     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7584     break 2
7585   fi
7586 done
7587 done
7588
7589 fi
7590 fi
7591 WINDMC=$ac_cv_prog_WINDMC
7592 if test -n "$WINDMC"; then
7593   echo "$as_me:$LINENO: result: $WINDMC" >&5
7594 echo "${ECHO_T}$WINDMC" >&6
7595 else
7596   echo "$as_me:$LINENO: result: no" >&5
7597 echo "${ECHO_T}no" >&6
7598 fi
7599
7600   done
7601 fi
7602
7603 for ncn_progname in windmc; do
7604   if test -n "$ncn_tool_prefix"; then
7605     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7606 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7607 echo "$as_me:$LINENO: checking for $ac_word" >&5
7608 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7609 if test "${ac_cv_prog_WINDMC+set}" = set; then
7610   echo $ECHO_N "(cached) $ECHO_C" >&6
7611 else
7612   if test -n "$WINDMC"; then
7613   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7614 else
7615 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7616 for as_dir in $PATH
7617 do
7618   IFS=$as_save_IFS
7619   test -z "$as_dir" && as_dir=.
7620   for ac_exec_ext in '' $ac_executable_extensions; do
7621   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7622     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7623     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7624     break 2
7625   fi
7626 done
7627 done
7628
7629 fi
7630 fi
7631 WINDMC=$ac_cv_prog_WINDMC
7632 if test -n "$WINDMC"; then
7633   echo "$as_me:$LINENO: result: $WINDMC" >&5
7634 echo "${ECHO_T}$WINDMC" >&6
7635 else
7636   echo "$as_me:$LINENO: result: no" >&5
7637 echo "${ECHO_T}no" >&6
7638 fi
7639
7640   fi
7641   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7642     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7643 set dummy ${ncn_progname}; ac_word=$2
7644 echo "$as_me:$LINENO: checking for $ac_word" >&5
7645 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7646 if test "${ac_cv_prog_WINDMC+set}" = set; then
7647   echo $ECHO_N "(cached) $ECHO_C" >&6
7648 else
7649   if test -n "$WINDMC"; then
7650   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7651 else
7652 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7653 for as_dir in $PATH
7654 do
7655   IFS=$as_save_IFS
7656   test -z "$as_dir" && as_dir=.
7657   for ac_exec_ext in '' $ac_executable_extensions; do
7658   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7659     ac_cv_prog_WINDMC="${ncn_progname}"
7660     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7661     break 2
7662   fi
7663 done
7664 done
7665
7666 fi
7667 fi
7668 WINDMC=$ac_cv_prog_WINDMC
7669 if test -n "$WINDMC"; then
7670   echo "$as_me:$LINENO: result: $WINDMC" >&5
7671 echo "${ECHO_T}$WINDMC" >&6
7672 else
7673   echo "$as_me:$LINENO: result: no" >&5
7674 echo "${ECHO_T}no" >&6
7675 fi
7676
7677   fi
7678   test -n "$ac_cv_prog_WINDMC" && break
7679 done
7680
7681 if test -z "$ac_cv_prog_WINDMC" ; then
7682   set dummy windmc
7683   if test $build = $host ; then
7684     WINDMC="$2"
7685   else
7686     WINDMC="${ncn_tool_prefix}$2"
7687   fi
7688 fi
7689
7690
7691
7692 if test -n "$OBJCOPY"; then
7693   ac_cv_prog_OBJCOPY=$OBJCOPY
7694 elif test -n "$ac_cv_prog_OBJCOPY"; then
7695   OBJCOPY=$ac_cv_prog_OBJCOPY
7696 fi
7697
7698 if test -n "$ac_cv_prog_OBJCOPY"; then
7699   for ncn_progname in objcopy; do
7700     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7701 set dummy ${ncn_progname}; ac_word=$2
7702 echo "$as_me:$LINENO: checking for $ac_word" >&5
7703 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7704 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7705   echo $ECHO_N "(cached) $ECHO_C" >&6
7706 else
7707   if test -n "$OBJCOPY"; then
7708   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7709 else
7710 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7711 for as_dir in $PATH
7712 do
7713   IFS=$as_save_IFS
7714   test -z "$as_dir" && as_dir=.
7715   for ac_exec_ext in '' $ac_executable_extensions; do
7716   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7717     ac_cv_prog_OBJCOPY="${ncn_progname}"
7718     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7719     break 2
7720   fi
7721 done
7722 done
7723
7724 fi
7725 fi
7726 OBJCOPY=$ac_cv_prog_OBJCOPY
7727 if test -n "$OBJCOPY"; then
7728   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7729 echo "${ECHO_T}$OBJCOPY" >&6
7730 else
7731   echo "$as_me:$LINENO: result: no" >&5
7732 echo "${ECHO_T}no" >&6
7733 fi
7734
7735   done
7736 fi
7737
7738 for ncn_progname in objcopy; do
7739   if test -n "$ncn_tool_prefix"; then
7740     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7741 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7742 echo "$as_me:$LINENO: checking for $ac_word" >&5
7743 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7744 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7745   echo $ECHO_N "(cached) $ECHO_C" >&6
7746 else
7747   if test -n "$OBJCOPY"; then
7748   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7749 else
7750 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7751 for as_dir in $PATH
7752 do
7753   IFS=$as_save_IFS
7754   test -z "$as_dir" && as_dir=.
7755   for ac_exec_ext in '' $ac_executable_extensions; do
7756   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7757     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7758     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7759     break 2
7760   fi
7761 done
7762 done
7763
7764 fi
7765 fi
7766 OBJCOPY=$ac_cv_prog_OBJCOPY
7767 if test -n "$OBJCOPY"; then
7768   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7769 echo "${ECHO_T}$OBJCOPY" >&6
7770 else
7771   echo "$as_me:$LINENO: result: no" >&5
7772 echo "${ECHO_T}no" >&6
7773 fi
7774
7775   fi
7776   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7777     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7778 set dummy ${ncn_progname}; ac_word=$2
7779 echo "$as_me:$LINENO: checking for $ac_word" >&5
7780 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7781 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7782   echo $ECHO_N "(cached) $ECHO_C" >&6
7783 else
7784   if test -n "$OBJCOPY"; then
7785   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7786 else
7787 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7788 for as_dir in $PATH
7789 do
7790   IFS=$as_save_IFS
7791   test -z "$as_dir" && as_dir=.
7792   for ac_exec_ext in '' $ac_executable_extensions; do
7793   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7794     ac_cv_prog_OBJCOPY="${ncn_progname}"
7795     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7796     break 2
7797   fi
7798 done
7799 done
7800
7801 fi
7802 fi
7803 OBJCOPY=$ac_cv_prog_OBJCOPY
7804 if test -n "$OBJCOPY"; then
7805   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7806 echo "${ECHO_T}$OBJCOPY" >&6
7807 else
7808   echo "$as_me:$LINENO: result: no" >&5
7809 echo "${ECHO_T}no" >&6
7810 fi
7811
7812   fi
7813   test -n "$ac_cv_prog_OBJCOPY" && break
7814 done
7815
7816 if test -z "$ac_cv_prog_OBJCOPY" ; then
7817   set dummy objcopy
7818   if test $build = $host ; then
7819     OBJCOPY="$2"
7820   else
7821     OBJCOPY="${ncn_tool_prefix}$2"
7822   fi
7823 fi
7824
7825
7826
7827 if test -n "$OBJDUMP"; then
7828   ac_cv_prog_OBJDUMP=$OBJDUMP
7829 elif test -n "$ac_cv_prog_OBJDUMP"; then
7830   OBJDUMP=$ac_cv_prog_OBJDUMP
7831 fi
7832
7833 if test -n "$ac_cv_prog_OBJDUMP"; then
7834   for ncn_progname in objdump; do
7835     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7836 set dummy ${ncn_progname}; ac_word=$2
7837 echo "$as_me:$LINENO: checking for $ac_word" >&5
7838 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7839 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7840   echo $ECHO_N "(cached) $ECHO_C" >&6
7841 else
7842   if test -n "$OBJDUMP"; then
7843   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7844 else
7845 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7846 for as_dir in $PATH
7847 do
7848   IFS=$as_save_IFS
7849   test -z "$as_dir" && as_dir=.
7850   for ac_exec_ext in '' $ac_executable_extensions; do
7851   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7852     ac_cv_prog_OBJDUMP="${ncn_progname}"
7853     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7854     break 2
7855   fi
7856 done
7857 done
7858
7859 fi
7860 fi
7861 OBJDUMP=$ac_cv_prog_OBJDUMP
7862 if test -n "$OBJDUMP"; then
7863   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7864 echo "${ECHO_T}$OBJDUMP" >&6
7865 else
7866   echo "$as_me:$LINENO: result: no" >&5
7867 echo "${ECHO_T}no" >&6
7868 fi
7869
7870   done
7871 fi
7872
7873 for ncn_progname in objdump; do
7874   if test -n "$ncn_tool_prefix"; then
7875     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7876 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7877 echo "$as_me:$LINENO: checking for $ac_word" >&5
7878 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7879 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7880   echo $ECHO_N "(cached) $ECHO_C" >&6
7881 else
7882   if test -n "$OBJDUMP"; then
7883   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7884 else
7885 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7886 for as_dir in $PATH
7887 do
7888   IFS=$as_save_IFS
7889   test -z "$as_dir" && as_dir=.
7890   for ac_exec_ext in '' $ac_executable_extensions; do
7891   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7892     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7893     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7894     break 2
7895   fi
7896 done
7897 done
7898
7899 fi
7900 fi
7901 OBJDUMP=$ac_cv_prog_OBJDUMP
7902 if test -n "$OBJDUMP"; then
7903   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7904 echo "${ECHO_T}$OBJDUMP" >&6
7905 else
7906   echo "$as_me:$LINENO: result: no" >&5
7907 echo "${ECHO_T}no" >&6
7908 fi
7909
7910   fi
7911   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7912     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7913 set dummy ${ncn_progname}; ac_word=$2
7914 echo "$as_me:$LINENO: checking for $ac_word" >&5
7915 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7916 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7917   echo $ECHO_N "(cached) $ECHO_C" >&6
7918 else
7919   if test -n "$OBJDUMP"; then
7920   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7921 else
7922 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7923 for as_dir in $PATH
7924 do
7925   IFS=$as_save_IFS
7926   test -z "$as_dir" && as_dir=.
7927   for ac_exec_ext in '' $ac_executable_extensions; do
7928   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7929     ac_cv_prog_OBJDUMP="${ncn_progname}"
7930     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7931     break 2
7932   fi
7933 done
7934 done
7935
7936 fi
7937 fi
7938 OBJDUMP=$ac_cv_prog_OBJDUMP
7939 if test -n "$OBJDUMP"; then
7940   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7941 echo "${ECHO_T}$OBJDUMP" >&6
7942 else
7943   echo "$as_me:$LINENO: result: no" >&5
7944 echo "${ECHO_T}no" >&6
7945 fi
7946
7947   fi
7948   test -n "$ac_cv_prog_OBJDUMP" && break
7949 done
7950
7951 if test -z "$ac_cv_prog_OBJDUMP" ; then
7952   set dummy objdump
7953   if test $build = $host ; then
7954     OBJDUMP="$2"
7955   else
7956     OBJDUMP="${ncn_tool_prefix}$2"
7957   fi
7958 fi
7959
7960
7961
7962
7963
7964
7965 # Target tools.
7966
7967 # Check whether --with-build-time-tools or --without-build-time-tools was given.
7968 if test "${with_build_time_tools+set}" = set; then
7969   withval="$with_build_time_tools"
7970   case x"$withval" in
7971      x/*) ;;
7972      *)
7973        with_build_time_tools=
7974        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
7975 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
7976        ;;
7977    esac
7978 else
7979   with_build_time_tools=
7980 fi;
7981
7982
7983
7984 if test -n "$CC_FOR_TARGET"; then
7985   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
7986 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7987   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7988 fi
7989
7990 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7991   for ncn_progname in cc gcc; do
7992     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7993 set dummy ${ncn_progname}; ac_word=$2
7994 echo "$as_me:$LINENO: checking for $ac_word" >&5
7995 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7996 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7997   echo $ECHO_N "(cached) $ECHO_C" >&6
7998 else
7999   if test -n "$CC_FOR_TARGET"; then
8000   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8001 else
8002 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8003 for as_dir in $PATH
8004 do
8005   IFS=$as_save_IFS
8006   test -z "$as_dir" && as_dir=.
8007   for ac_exec_ext in '' $ac_executable_extensions; do
8008   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8009     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8010     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8011     break 2
8012   fi
8013 done
8014 done
8015
8016 fi
8017 fi
8018 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8019 if test -n "$CC_FOR_TARGET"; then
8020   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8021 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8022 else
8023   echo "$as_me:$LINENO: result: no" >&5
8024 echo "${ECHO_T}no" >&6
8025 fi
8026
8027   done
8028 fi
8029
8030 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8031   for ncn_progname in cc gcc; do
8032     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8033 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8034     if test -x $with_build_time_tools/${ncn_progname}; then
8035       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8036       echo "$as_me:$LINENO: result: yes" >&5
8037 echo "${ECHO_T}yes" >&6
8038       break
8039     else
8040       echo "$as_me:$LINENO: result: no" >&5
8041 echo "${ECHO_T}no" >&6
8042     fi
8043   done
8044 fi
8045
8046 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8047   for ncn_progname in cc gcc; do
8048     if test -n "$ncn_target_tool_prefix"; then
8049       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8050 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8051 echo "$as_me:$LINENO: checking for $ac_word" >&5
8052 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8053 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8054   echo $ECHO_N "(cached) $ECHO_C" >&6
8055 else
8056   if test -n "$CC_FOR_TARGET"; then
8057   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8058 else
8059 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8060 for as_dir in $PATH
8061 do
8062   IFS=$as_save_IFS
8063   test -z "$as_dir" && as_dir=.
8064   for ac_exec_ext in '' $ac_executable_extensions; do
8065   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8066     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8067     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8068     break 2
8069   fi
8070 done
8071 done
8072
8073 fi
8074 fi
8075 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8076 if test -n "$CC_FOR_TARGET"; then
8077   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8078 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8079 else
8080   echo "$as_me:$LINENO: result: no" >&5
8081 echo "${ECHO_T}no" >&6
8082 fi
8083
8084     fi
8085     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8086       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8087 set dummy ${ncn_progname}; ac_word=$2
8088 echo "$as_me:$LINENO: checking for $ac_word" >&5
8089 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8090 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8091   echo $ECHO_N "(cached) $ECHO_C" >&6
8092 else
8093   if test -n "$CC_FOR_TARGET"; then
8094   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8095 else
8096 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8097 for as_dir in $PATH
8098 do
8099   IFS=$as_save_IFS
8100   test -z "$as_dir" && as_dir=.
8101   for ac_exec_ext in '' $ac_executable_extensions; do
8102   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8103     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8104     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8105     break 2
8106   fi
8107 done
8108 done
8109
8110 fi
8111 fi
8112 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8113 if test -n "$CC_FOR_TARGET"; then
8114   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8115 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8116 else
8117   echo "$as_me:$LINENO: result: no" >&5
8118 echo "${ECHO_T}no" >&6
8119 fi
8120
8121     fi
8122     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8123   done
8124 fi
8125
8126 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8127   set dummy cc gcc
8128   if test $build = $target ; then
8129     CC_FOR_TARGET="$2"
8130   else
8131     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8132   fi
8133 else
8134   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8135 fi
8136
8137
8138
8139 if test -n "$CXX_FOR_TARGET"; then
8140   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8141 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8142   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8143 fi
8144
8145 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8146   for ncn_progname in c++ g++ cxx gxx; do
8147     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8148 set dummy ${ncn_progname}; ac_word=$2
8149 echo "$as_me:$LINENO: checking for $ac_word" >&5
8150 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8151 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8152   echo $ECHO_N "(cached) $ECHO_C" >&6
8153 else
8154   if test -n "$CXX_FOR_TARGET"; then
8155   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8156 else
8157 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8158 for as_dir in $PATH
8159 do
8160   IFS=$as_save_IFS
8161   test -z "$as_dir" && as_dir=.
8162   for ac_exec_ext in '' $ac_executable_extensions; do
8163   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8164     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8165     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8166     break 2
8167   fi
8168 done
8169 done
8170
8171 fi
8172 fi
8173 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8174 if test -n "$CXX_FOR_TARGET"; then
8175   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8176 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8177 else
8178   echo "$as_me:$LINENO: result: no" >&5
8179 echo "${ECHO_T}no" >&6
8180 fi
8181
8182   done
8183 fi
8184
8185 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8186   for ncn_progname in c++ g++ cxx gxx; do
8187     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8188 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8189     if test -x $with_build_time_tools/${ncn_progname}; then
8190       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8191       echo "$as_me:$LINENO: result: yes" >&5
8192 echo "${ECHO_T}yes" >&6
8193       break
8194     else
8195       echo "$as_me:$LINENO: result: no" >&5
8196 echo "${ECHO_T}no" >&6
8197     fi
8198   done
8199 fi
8200
8201 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8202   for ncn_progname in c++ g++ cxx gxx; do
8203     if test -n "$ncn_target_tool_prefix"; then
8204       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8205 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8206 echo "$as_me:$LINENO: checking for $ac_word" >&5
8207 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8208 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8209   echo $ECHO_N "(cached) $ECHO_C" >&6
8210 else
8211   if test -n "$CXX_FOR_TARGET"; then
8212   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8213 else
8214 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8215 for as_dir in $PATH
8216 do
8217   IFS=$as_save_IFS
8218   test -z "$as_dir" && as_dir=.
8219   for ac_exec_ext in '' $ac_executable_extensions; do
8220   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8221     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8222     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8223     break 2
8224   fi
8225 done
8226 done
8227
8228 fi
8229 fi
8230 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8231 if test -n "$CXX_FOR_TARGET"; then
8232   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8233 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8234 else
8235   echo "$as_me:$LINENO: result: no" >&5
8236 echo "${ECHO_T}no" >&6
8237 fi
8238
8239     fi
8240     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8241       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8242 set dummy ${ncn_progname}; ac_word=$2
8243 echo "$as_me:$LINENO: checking for $ac_word" >&5
8244 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8245 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8246   echo $ECHO_N "(cached) $ECHO_C" >&6
8247 else
8248   if test -n "$CXX_FOR_TARGET"; then
8249   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8250 else
8251 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8252 for as_dir in $PATH
8253 do
8254   IFS=$as_save_IFS
8255   test -z "$as_dir" && as_dir=.
8256   for ac_exec_ext in '' $ac_executable_extensions; do
8257   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8258     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8259     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8260     break 2
8261   fi
8262 done
8263 done
8264
8265 fi
8266 fi
8267 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8268 if test -n "$CXX_FOR_TARGET"; then
8269   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8270 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8271 else
8272   echo "$as_me:$LINENO: result: no" >&5
8273 echo "${ECHO_T}no" >&6
8274 fi
8275
8276     fi
8277     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8278   done
8279 fi
8280
8281 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8282   set dummy c++ g++ cxx gxx
8283   if test $build = $target ; then
8284     CXX_FOR_TARGET="$2"
8285   else
8286     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8287   fi
8288 else
8289   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8290 fi
8291
8292
8293
8294 if test -n "$GCC_FOR_TARGET"; then
8295   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8296 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8297   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8298 fi
8299
8300 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8301   for ncn_progname in gcc; do
8302     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8303 set dummy ${ncn_progname}; ac_word=$2
8304 echo "$as_me:$LINENO: checking for $ac_word" >&5
8305 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8306 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8307   echo $ECHO_N "(cached) $ECHO_C" >&6
8308 else
8309   if test -n "$GCC_FOR_TARGET"; then
8310   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8311 else
8312 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8313 for as_dir in $PATH
8314 do
8315   IFS=$as_save_IFS
8316   test -z "$as_dir" && as_dir=.
8317   for ac_exec_ext in '' $ac_executable_extensions; do
8318   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8319     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8320     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8321     break 2
8322   fi
8323 done
8324 done
8325
8326 fi
8327 fi
8328 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8329 if test -n "$GCC_FOR_TARGET"; then
8330   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8331 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8332 else
8333   echo "$as_me:$LINENO: result: no" >&5
8334 echo "${ECHO_T}no" >&6
8335 fi
8336
8337   done
8338 fi
8339
8340 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8341   for ncn_progname in gcc; do
8342     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8343 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8344     if test -x $with_build_time_tools/${ncn_progname}; then
8345       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8346       echo "$as_me:$LINENO: result: yes" >&5
8347 echo "${ECHO_T}yes" >&6
8348       break
8349     else
8350       echo "$as_me:$LINENO: result: no" >&5
8351 echo "${ECHO_T}no" >&6
8352     fi
8353   done
8354 fi
8355
8356 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8357   for ncn_progname in gcc; do
8358     if test -n "$ncn_target_tool_prefix"; then
8359       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8360 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8361 echo "$as_me:$LINENO: checking for $ac_word" >&5
8362 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8363 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8364   echo $ECHO_N "(cached) $ECHO_C" >&6
8365 else
8366   if test -n "$GCC_FOR_TARGET"; then
8367   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8368 else
8369 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8370 for as_dir in $PATH
8371 do
8372   IFS=$as_save_IFS
8373   test -z "$as_dir" && as_dir=.
8374   for ac_exec_ext in '' $ac_executable_extensions; do
8375   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8376     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8377     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8378     break 2
8379   fi
8380 done
8381 done
8382
8383 fi
8384 fi
8385 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8386 if test -n "$GCC_FOR_TARGET"; then
8387   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8388 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8389 else
8390   echo "$as_me:$LINENO: result: no" >&5
8391 echo "${ECHO_T}no" >&6
8392 fi
8393
8394     fi
8395     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8396       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8397 set dummy ${ncn_progname}; ac_word=$2
8398 echo "$as_me:$LINENO: checking for $ac_word" >&5
8399 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8400 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8401   echo $ECHO_N "(cached) $ECHO_C" >&6
8402 else
8403   if test -n "$GCC_FOR_TARGET"; then
8404   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8405 else
8406 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8407 for as_dir in $PATH
8408 do
8409   IFS=$as_save_IFS
8410   test -z "$as_dir" && as_dir=.
8411   for ac_exec_ext in '' $ac_executable_extensions; do
8412   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8413     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8414     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8415     break 2
8416   fi
8417 done
8418 done
8419
8420 fi
8421 fi
8422 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8423 if test -n "$GCC_FOR_TARGET"; then
8424   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8425 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8426 else
8427   echo "$as_me:$LINENO: result: no" >&5
8428 echo "${ECHO_T}no" >&6
8429 fi
8430
8431     fi
8432     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8433   done
8434 fi
8435
8436 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8437   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8438 else
8439   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8440 fi
8441
8442
8443
8444 if test -n "$GCJ_FOR_TARGET"; then
8445   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8446 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8447   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8448 fi
8449
8450 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8451   for ncn_progname in gcj; do
8452     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8453 set dummy ${ncn_progname}; ac_word=$2
8454 echo "$as_me:$LINENO: checking for $ac_word" >&5
8455 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8456 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8457   echo $ECHO_N "(cached) $ECHO_C" >&6
8458 else
8459   if test -n "$GCJ_FOR_TARGET"; then
8460   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8461 else
8462 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8463 for as_dir in $PATH
8464 do
8465   IFS=$as_save_IFS
8466   test -z "$as_dir" && as_dir=.
8467   for ac_exec_ext in '' $ac_executable_extensions; do
8468   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8469     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8470     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8471     break 2
8472   fi
8473 done
8474 done
8475
8476 fi
8477 fi
8478 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8479 if test -n "$GCJ_FOR_TARGET"; then
8480   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8481 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8482 else
8483   echo "$as_me:$LINENO: result: no" >&5
8484 echo "${ECHO_T}no" >&6
8485 fi
8486
8487   done
8488 fi
8489
8490 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8491   for ncn_progname in gcj; do
8492     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8493 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8494     if test -x $with_build_time_tools/${ncn_progname}; then
8495       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8496       echo "$as_me:$LINENO: result: yes" >&5
8497 echo "${ECHO_T}yes" >&6
8498       break
8499     else
8500       echo "$as_me:$LINENO: result: no" >&5
8501 echo "${ECHO_T}no" >&6
8502     fi
8503   done
8504 fi
8505
8506 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8507   for ncn_progname in gcj; do
8508     if test -n "$ncn_target_tool_prefix"; then
8509       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8510 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8511 echo "$as_me:$LINENO: checking for $ac_word" >&5
8512 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8513 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8514   echo $ECHO_N "(cached) $ECHO_C" >&6
8515 else
8516   if test -n "$GCJ_FOR_TARGET"; then
8517   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8518 else
8519 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8520 for as_dir in $PATH
8521 do
8522   IFS=$as_save_IFS
8523   test -z "$as_dir" && as_dir=.
8524   for ac_exec_ext in '' $ac_executable_extensions; do
8525   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8526     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8527     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8528     break 2
8529   fi
8530 done
8531 done
8532
8533 fi
8534 fi
8535 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8536 if test -n "$GCJ_FOR_TARGET"; then
8537   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8538 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8539 else
8540   echo "$as_me:$LINENO: result: no" >&5
8541 echo "${ECHO_T}no" >&6
8542 fi
8543
8544     fi
8545     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8546       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8547 set dummy ${ncn_progname}; ac_word=$2
8548 echo "$as_me:$LINENO: checking for $ac_word" >&5
8549 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8550 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8551   echo $ECHO_N "(cached) $ECHO_C" >&6
8552 else
8553   if test -n "$GCJ_FOR_TARGET"; then
8554   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8555 else
8556 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8557 for as_dir in $PATH
8558 do
8559   IFS=$as_save_IFS
8560   test -z "$as_dir" && as_dir=.
8561   for ac_exec_ext in '' $ac_executable_extensions; do
8562   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8563     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8564     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8565     break 2
8566   fi
8567 done
8568 done
8569
8570 fi
8571 fi
8572 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8573 if test -n "$GCJ_FOR_TARGET"; then
8574   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8575 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8576 else
8577   echo "$as_me:$LINENO: result: no" >&5
8578 echo "${ECHO_T}no" >&6
8579 fi
8580
8581     fi
8582     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8583   done
8584 fi
8585
8586 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8587   set dummy gcj
8588   if test $build = $target ; then
8589     GCJ_FOR_TARGET="$2"
8590   else
8591     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8592   fi
8593 else
8594   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8595 fi
8596
8597
8598
8599 if test -n "$GFORTRAN_FOR_TARGET"; then
8600   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8601 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8602   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8603 fi
8604
8605 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8606   for ncn_progname in gfortran; do
8607     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8608 set dummy ${ncn_progname}; ac_word=$2
8609 echo "$as_me:$LINENO: checking for $ac_word" >&5
8610 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8611 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8612   echo $ECHO_N "(cached) $ECHO_C" >&6
8613 else
8614   if test -n "$GFORTRAN_FOR_TARGET"; then
8615   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8616 else
8617 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8618 for as_dir in $PATH
8619 do
8620   IFS=$as_save_IFS
8621   test -z "$as_dir" && as_dir=.
8622   for ac_exec_ext in '' $ac_executable_extensions; do
8623   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8624     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8625     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8626     break 2
8627   fi
8628 done
8629 done
8630
8631 fi
8632 fi
8633 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8634 if test -n "$GFORTRAN_FOR_TARGET"; then
8635   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8636 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8637 else
8638   echo "$as_me:$LINENO: result: no" >&5
8639 echo "${ECHO_T}no" >&6
8640 fi
8641
8642   done
8643 fi
8644
8645 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8646   for ncn_progname in gfortran; do
8647     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8648 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8649     if test -x $with_build_time_tools/${ncn_progname}; then
8650       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8651       echo "$as_me:$LINENO: result: yes" >&5
8652 echo "${ECHO_T}yes" >&6
8653       break
8654     else
8655       echo "$as_me:$LINENO: result: no" >&5
8656 echo "${ECHO_T}no" >&6
8657     fi
8658   done
8659 fi
8660
8661 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8662   for ncn_progname in gfortran; do
8663     if test -n "$ncn_target_tool_prefix"; then
8664       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8665 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8666 echo "$as_me:$LINENO: checking for $ac_word" >&5
8667 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8668 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8669   echo $ECHO_N "(cached) $ECHO_C" >&6
8670 else
8671   if test -n "$GFORTRAN_FOR_TARGET"; then
8672   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8673 else
8674 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8675 for as_dir in $PATH
8676 do
8677   IFS=$as_save_IFS
8678   test -z "$as_dir" && as_dir=.
8679   for ac_exec_ext in '' $ac_executable_extensions; do
8680   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8681     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8682     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8683     break 2
8684   fi
8685 done
8686 done
8687
8688 fi
8689 fi
8690 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8691 if test -n "$GFORTRAN_FOR_TARGET"; then
8692   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8693 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8694 else
8695   echo "$as_me:$LINENO: result: no" >&5
8696 echo "${ECHO_T}no" >&6
8697 fi
8698
8699     fi
8700     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8701       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8702 set dummy ${ncn_progname}; ac_word=$2
8703 echo "$as_me:$LINENO: checking for $ac_word" >&5
8704 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8705 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8706   echo $ECHO_N "(cached) $ECHO_C" >&6
8707 else
8708   if test -n "$GFORTRAN_FOR_TARGET"; then
8709   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8710 else
8711 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8712 for as_dir in $PATH
8713 do
8714   IFS=$as_save_IFS
8715   test -z "$as_dir" && as_dir=.
8716   for ac_exec_ext in '' $ac_executable_extensions; do
8717   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8718     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8719     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8720     break 2
8721   fi
8722 done
8723 done
8724
8725 fi
8726 fi
8727 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8728 if test -n "$GFORTRAN_FOR_TARGET"; then
8729   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8730 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8731 else
8732   echo "$as_me:$LINENO: result: no" >&5
8733 echo "${ECHO_T}no" >&6
8734 fi
8735
8736     fi
8737     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8738   done
8739 fi
8740
8741 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8742   set dummy gfortran
8743   if test $build = $target ; then
8744     GFORTRAN_FOR_TARGET="$2"
8745   else
8746     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8747   fi
8748 else
8749   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8750 fi
8751
8752
8753
8754 cat > conftest.c << \EOF
8755 #ifdef __GNUC__
8756   gcc_yay;
8757 #endif
8758 EOF
8759 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8760   have_gcc_for_target=yes
8761 else
8762   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8763   have_gcc_for_target=no
8764 fi
8765 rm conftest.c
8766
8767
8768
8769
8770 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8771   if test -n "$with_build_time_tools"; then
8772     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8773 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8774     if test -x $with_build_time_tools/ar; then
8775       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8776       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8777       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8778 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8779     else
8780       echo "$as_me:$LINENO: result: no" >&5
8781 echo "${ECHO_T}no" >&6
8782     fi
8783   elif test $build != $host && test $have_gcc_for_target = yes; then
8784     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8785     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8786     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8787   fi
8788 fi
8789 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8790   # Extract the first word of "ar", so it can be a program name with args.
8791 set dummy ar; ac_word=$2
8792 echo "$as_me:$LINENO: checking for $ac_word" >&5
8793 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8794 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8795   echo $ECHO_N "(cached) $ECHO_C" >&6
8796 else
8797   case $AR_FOR_TARGET in
8798   [\\/]* | ?:[\\/]*)
8799   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8800   ;;
8801   *)
8802   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8803 for as_dir in $gcc_cv_tool_dirs
8804 do
8805   IFS=$as_save_IFS
8806   test -z "$as_dir" && as_dir=.
8807   for ac_exec_ext in '' $ac_executable_extensions; do
8808   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8809     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8810     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8811     break 2
8812   fi
8813 done
8814 done
8815
8816   ;;
8817 esac
8818 fi
8819 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8820
8821 if test -n "$AR_FOR_TARGET"; then
8822   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8823 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8824 else
8825   echo "$as_me:$LINENO: result: no" >&5
8826 echo "${ECHO_T}no" >&6
8827 fi
8828
8829 fi
8830 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8831
8832
8833 if test -n "$AR_FOR_TARGET"; then
8834   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8835 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8836   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8837 fi
8838
8839 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8840   for ncn_progname in ar; do
8841     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8842 set dummy ${ncn_progname}; ac_word=$2
8843 echo "$as_me:$LINENO: checking for $ac_word" >&5
8844 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8845 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8846   echo $ECHO_N "(cached) $ECHO_C" >&6
8847 else
8848   if test -n "$AR_FOR_TARGET"; then
8849   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8850 else
8851 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8852 for as_dir in $PATH
8853 do
8854   IFS=$as_save_IFS
8855   test -z "$as_dir" && as_dir=.
8856   for ac_exec_ext in '' $ac_executable_extensions; do
8857   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8858     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8859     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8860     break 2
8861   fi
8862 done
8863 done
8864
8865 fi
8866 fi
8867 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8868 if test -n "$AR_FOR_TARGET"; then
8869   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8870 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8871 else
8872   echo "$as_me:$LINENO: result: no" >&5
8873 echo "${ECHO_T}no" >&6
8874 fi
8875
8876   done
8877 fi
8878
8879 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8880   for ncn_progname in ar; do
8881     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8882 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8883     if test -x $with_build_time_tools/${ncn_progname}; then
8884       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8885       echo "$as_me:$LINENO: result: yes" >&5
8886 echo "${ECHO_T}yes" >&6
8887       break
8888     else
8889       echo "$as_me:$LINENO: result: no" >&5
8890 echo "${ECHO_T}no" >&6
8891     fi
8892   done
8893 fi
8894
8895 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8896   for ncn_progname in ar; do
8897     if test -n "$ncn_target_tool_prefix"; then
8898       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8899 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8900 echo "$as_me:$LINENO: checking for $ac_word" >&5
8901 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8902 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8903   echo $ECHO_N "(cached) $ECHO_C" >&6
8904 else
8905   if test -n "$AR_FOR_TARGET"; then
8906   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8907 else
8908 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8909 for as_dir in $PATH
8910 do
8911   IFS=$as_save_IFS
8912   test -z "$as_dir" && as_dir=.
8913   for ac_exec_ext in '' $ac_executable_extensions; do
8914   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8915     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8916     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8917     break 2
8918   fi
8919 done
8920 done
8921
8922 fi
8923 fi
8924 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8925 if test -n "$AR_FOR_TARGET"; then
8926   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8927 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8928 else
8929   echo "$as_me:$LINENO: result: no" >&5
8930 echo "${ECHO_T}no" >&6
8931 fi
8932
8933     fi
8934     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8935       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8936 set dummy ${ncn_progname}; ac_word=$2
8937 echo "$as_me:$LINENO: checking for $ac_word" >&5
8938 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8939 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8940   echo $ECHO_N "(cached) $ECHO_C" >&6
8941 else
8942   if test -n "$AR_FOR_TARGET"; then
8943   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8944 else
8945 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8946 for as_dir in $PATH
8947 do
8948   IFS=$as_save_IFS
8949   test -z "$as_dir" && as_dir=.
8950   for ac_exec_ext in '' $ac_executable_extensions; do
8951   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8952     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8953     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8954     break 2
8955   fi
8956 done
8957 done
8958
8959 fi
8960 fi
8961 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8962 if test -n "$AR_FOR_TARGET"; then
8963   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8964 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8965 else
8966   echo "$as_me:$LINENO: result: no" >&5
8967 echo "${ECHO_T}no" >&6
8968 fi
8969
8970     fi
8971     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
8972   done
8973 fi
8974
8975 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
8976   set dummy ar
8977   if test $build = $target ; then
8978     AR_FOR_TARGET="$2"
8979   else
8980     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
8981   fi
8982 else
8983   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
8984 fi
8985
8986 else
8987   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8988 fi
8989
8990
8991
8992
8993 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8994   if test -n "$with_build_time_tools"; then
8995     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
8996 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
8997     if test -x $with_build_time_tools/as; then
8998       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
8999       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9000       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9001 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9002     else
9003       echo "$as_me:$LINENO: result: no" >&5
9004 echo "${ECHO_T}no" >&6
9005     fi
9006   elif test $build != $host && test $have_gcc_for_target = yes; then
9007     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9008     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9009     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9010   fi
9011 fi
9012 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9013   # Extract the first word of "as", so it can be a program name with args.
9014 set dummy as; ac_word=$2
9015 echo "$as_me:$LINENO: checking for $ac_word" >&5
9016 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9017 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9018   echo $ECHO_N "(cached) $ECHO_C" >&6
9019 else
9020   case $AS_FOR_TARGET in
9021   [\\/]* | ?:[\\/]*)
9022   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9023   ;;
9024   *)
9025   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9026 for as_dir in $gcc_cv_tool_dirs
9027 do
9028   IFS=$as_save_IFS
9029   test -z "$as_dir" && as_dir=.
9030   for ac_exec_ext in '' $ac_executable_extensions; do
9031   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9032     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9033     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9034     break 2
9035   fi
9036 done
9037 done
9038
9039   ;;
9040 esac
9041 fi
9042 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9043
9044 if test -n "$AS_FOR_TARGET"; then
9045   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9046 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9047 else
9048   echo "$as_me:$LINENO: result: no" >&5
9049 echo "${ECHO_T}no" >&6
9050 fi
9051
9052 fi
9053 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9054
9055
9056 if test -n "$AS_FOR_TARGET"; then
9057   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9058 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9059   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9060 fi
9061
9062 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9063   for ncn_progname in as; do
9064     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9065 set dummy ${ncn_progname}; ac_word=$2
9066 echo "$as_me:$LINENO: checking for $ac_word" >&5
9067 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9068 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9069   echo $ECHO_N "(cached) $ECHO_C" >&6
9070 else
9071   if test -n "$AS_FOR_TARGET"; then
9072   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9073 else
9074 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9075 for as_dir in $PATH
9076 do
9077   IFS=$as_save_IFS
9078   test -z "$as_dir" && as_dir=.
9079   for ac_exec_ext in '' $ac_executable_extensions; do
9080   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9081     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9082     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9083     break 2
9084   fi
9085 done
9086 done
9087
9088 fi
9089 fi
9090 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9091 if test -n "$AS_FOR_TARGET"; then
9092   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9093 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9094 else
9095   echo "$as_me:$LINENO: result: no" >&5
9096 echo "${ECHO_T}no" >&6
9097 fi
9098
9099   done
9100 fi
9101
9102 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9103   for ncn_progname in as; do
9104     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9105 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9106     if test -x $with_build_time_tools/${ncn_progname}; then
9107       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9108       echo "$as_me:$LINENO: result: yes" >&5
9109 echo "${ECHO_T}yes" >&6
9110       break
9111     else
9112       echo "$as_me:$LINENO: result: no" >&5
9113 echo "${ECHO_T}no" >&6
9114     fi
9115   done
9116 fi
9117
9118 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9119   for ncn_progname in as; do
9120     if test -n "$ncn_target_tool_prefix"; then
9121       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9122 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9123 echo "$as_me:$LINENO: checking for $ac_word" >&5
9124 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9125 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9126   echo $ECHO_N "(cached) $ECHO_C" >&6
9127 else
9128   if test -n "$AS_FOR_TARGET"; then
9129   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9130 else
9131 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9132 for as_dir in $PATH
9133 do
9134   IFS=$as_save_IFS
9135   test -z "$as_dir" && as_dir=.
9136   for ac_exec_ext in '' $ac_executable_extensions; do
9137   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9138     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9139     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9140     break 2
9141   fi
9142 done
9143 done
9144
9145 fi
9146 fi
9147 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9148 if test -n "$AS_FOR_TARGET"; then
9149   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9150 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9151 else
9152   echo "$as_me:$LINENO: result: no" >&5
9153 echo "${ECHO_T}no" >&6
9154 fi
9155
9156     fi
9157     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9158       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9159 set dummy ${ncn_progname}; ac_word=$2
9160 echo "$as_me:$LINENO: checking for $ac_word" >&5
9161 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9162 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9163   echo $ECHO_N "(cached) $ECHO_C" >&6
9164 else
9165   if test -n "$AS_FOR_TARGET"; then
9166   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9167 else
9168 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9169 for as_dir in $PATH
9170 do
9171   IFS=$as_save_IFS
9172   test -z "$as_dir" && as_dir=.
9173   for ac_exec_ext in '' $ac_executable_extensions; do
9174   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9175     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9176     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9177     break 2
9178   fi
9179 done
9180 done
9181
9182 fi
9183 fi
9184 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9185 if test -n "$AS_FOR_TARGET"; then
9186   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9187 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9188 else
9189   echo "$as_me:$LINENO: result: no" >&5
9190 echo "${ECHO_T}no" >&6
9191 fi
9192
9193     fi
9194     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9195   done
9196 fi
9197
9198 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9199   set dummy as
9200   if test $build = $target ; then
9201     AS_FOR_TARGET="$2"
9202   else
9203     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9204   fi
9205 else
9206   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9207 fi
9208
9209 else
9210   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9211 fi
9212
9213
9214
9215
9216 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9217   if test -n "$with_build_time_tools"; then
9218     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9219 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9220     if test -x $with_build_time_tools/dlltool; then
9221       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9222       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9223       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9224 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9225     else
9226       echo "$as_me:$LINENO: result: no" >&5
9227 echo "${ECHO_T}no" >&6
9228     fi
9229   elif test $build != $host && test $have_gcc_for_target = yes; then
9230     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9231     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9232     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9233   fi
9234 fi
9235 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9236   # Extract the first word of "dlltool", so it can be a program name with args.
9237 set dummy dlltool; ac_word=$2
9238 echo "$as_me:$LINENO: checking for $ac_word" >&5
9239 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9240 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9241   echo $ECHO_N "(cached) $ECHO_C" >&6
9242 else
9243   case $DLLTOOL_FOR_TARGET in
9244   [\\/]* | ?:[\\/]*)
9245   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9246   ;;
9247   *)
9248   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9249 for as_dir in $gcc_cv_tool_dirs
9250 do
9251   IFS=$as_save_IFS
9252   test -z "$as_dir" && as_dir=.
9253   for ac_exec_ext in '' $ac_executable_extensions; do
9254   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9255     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9256     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9257     break 2
9258   fi
9259 done
9260 done
9261
9262   ;;
9263 esac
9264 fi
9265 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9266
9267 if test -n "$DLLTOOL_FOR_TARGET"; then
9268   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9269 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9270 else
9271   echo "$as_me:$LINENO: result: no" >&5
9272 echo "${ECHO_T}no" >&6
9273 fi
9274
9275 fi
9276 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9277
9278
9279 if test -n "$DLLTOOL_FOR_TARGET"; then
9280   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9281 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9282   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9283 fi
9284
9285 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9286   for ncn_progname in dlltool; do
9287     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9288 set dummy ${ncn_progname}; ac_word=$2
9289 echo "$as_me:$LINENO: checking for $ac_word" >&5
9290 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9291 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9292   echo $ECHO_N "(cached) $ECHO_C" >&6
9293 else
9294   if test -n "$DLLTOOL_FOR_TARGET"; then
9295   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9296 else
9297 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9298 for as_dir in $PATH
9299 do
9300   IFS=$as_save_IFS
9301   test -z "$as_dir" && as_dir=.
9302   for ac_exec_ext in '' $ac_executable_extensions; do
9303   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9304     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9305     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9306     break 2
9307   fi
9308 done
9309 done
9310
9311 fi
9312 fi
9313 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9314 if test -n "$DLLTOOL_FOR_TARGET"; then
9315   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9316 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9317 else
9318   echo "$as_me:$LINENO: result: no" >&5
9319 echo "${ECHO_T}no" >&6
9320 fi
9321
9322   done
9323 fi
9324
9325 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9326   for ncn_progname in dlltool; do
9327     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9328 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9329     if test -x $with_build_time_tools/${ncn_progname}; then
9330       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9331       echo "$as_me:$LINENO: result: yes" >&5
9332 echo "${ECHO_T}yes" >&6
9333       break
9334     else
9335       echo "$as_me:$LINENO: result: no" >&5
9336 echo "${ECHO_T}no" >&6
9337     fi
9338   done
9339 fi
9340
9341 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9342   for ncn_progname in dlltool; do
9343     if test -n "$ncn_target_tool_prefix"; then
9344       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9345 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9346 echo "$as_me:$LINENO: checking for $ac_word" >&5
9347 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9348 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9349   echo $ECHO_N "(cached) $ECHO_C" >&6
9350 else
9351   if test -n "$DLLTOOL_FOR_TARGET"; then
9352   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9353 else
9354 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9355 for as_dir in $PATH
9356 do
9357   IFS=$as_save_IFS
9358   test -z "$as_dir" && as_dir=.
9359   for ac_exec_ext in '' $ac_executable_extensions; do
9360   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9361     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9362     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9363     break 2
9364   fi
9365 done
9366 done
9367
9368 fi
9369 fi
9370 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9371 if test -n "$DLLTOOL_FOR_TARGET"; then
9372   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9373 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9374 else
9375   echo "$as_me:$LINENO: result: no" >&5
9376 echo "${ECHO_T}no" >&6
9377 fi
9378
9379     fi
9380     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9381       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9382 set dummy ${ncn_progname}; ac_word=$2
9383 echo "$as_me:$LINENO: checking for $ac_word" >&5
9384 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9385 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9386   echo $ECHO_N "(cached) $ECHO_C" >&6
9387 else
9388   if test -n "$DLLTOOL_FOR_TARGET"; then
9389   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9390 else
9391 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9392 for as_dir in $PATH
9393 do
9394   IFS=$as_save_IFS
9395   test -z "$as_dir" && as_dir=.
9396   for ac_exec_ext in '' $ac_executable_extensions; do
9397   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9398     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9399     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9400     break 2
9401   fi
9402 done
9403 done
9404
9405 fi
9406 fi
9407 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9408 if test -n "$DLLTOOL_FOR_TARGET"; then
9409   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9410 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9411 else
9412   echo "$as_me:$LINENO: result: no" >&5
9413 echo "${ECHO_T}no" >&6
9414 fi
9415
9416     fi
9417     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9418   done
9419 fi
9420
9421 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9422   set dummy dlltool
9423   if test $build = $target ; then
9424     DLLTOOL_FOR_TARGET="$2"
9425   else
9426     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9427   fi
9428 else
9429   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9430 fi
9431
9432 else
9433   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9434 fi
9435
9436
9437
9438
9439 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9440   if test -n "$with_build_time_tools"; then
9441     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9442 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9443     if test -x $with_build_time_tools/ld; then
9444       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9445       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9446       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9447 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9448     else
9449       echo "$as_me:$LINENO: result: no" >&5
9450 echo "${ECHO_T}no" >&6
9451     fi
9452   elif test $build != $host && test $have_gcc_for_target = yes; then
9453     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9454     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9455     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9456   fi
9457 fi
9458 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9459   # Extract the first word of "ld", so it can be a program name with args.
9460 set dummy ld; ac_word=$2
9461 echo "$as_me:$LINENO: checking for $ac_word" >&5
9462 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9463 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9464   echo $ECHO_N "(cached) $ECHO_C" >&6
9465 else
9466   case $LD_FOR_TARGET in
9467   [\\/]* | ?:[\\/]*)
9468   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9469   ;;
9470   *)
9471   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9472 for as_dir in $gcc_cv_tool_dirs
9473 do
9474   IFS=$as_save_IFS
9475   test -z "$as_dir" && as_dir=.
9476   for ac_exec_ext in '' $ac_executable_extensions; do
9477   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9478     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9479     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9480     break 2
9481   fi
9482 done
9483 done
9484
9485   ;;
9486 esac
9487 fi
9488 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9489
9490 if test -n "$LD_FOR_TARGET"; then
9491   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9492 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9493 else
9494   echo "$as_me:$LINENO: result: no" >&5
9495 echo "${ECHO_T}no" >&6
9496 fi
9497
9498 fi
9499 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9500
9501
9502 if test -n "$LD_FOR_TARGET"; then
9503   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9504 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9505   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9506 fi
9507
9508 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9509   for ncn_progname in ld; do
9510     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9511 set dummy ${ncn_progname}; ac_word=$2
9512 echo "$as_me:$LINENO: checking for $ac_word" >&5
9513 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9514 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9515   echo $ECHO_N "(cached) $ECHO_C" >&6
9516 else
9517   if test -n "$LD_FOR_TARGET"; then
9518   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9519 else
9520 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9521 for as_dir in $PATH
9522 do
9523   IFS=$as_save_IFS
9524   test -z "$as_dir" && as_dir=.
9525   for ac_exec_ext in '' $ac_executable_extensions; do
9526   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9527     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9528     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9529     break 2
9530   fi
9531 done
9532 done
9533
9534 fi
9535 fi
9536 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9537 if test -n "$LD_FOR_TARGET"; then
9538   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9539 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9540 else
9541   echo "$as_me:$LINENO: result: no" >&5
9542 echo "${ECHO_T}no" >&6
9543 fi
9544
9545   done
9546 fi
9547
9548 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9549   for ncn_progname in ld; do
9550     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9551 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9552     if test -x $with_build_time_tools/${ncn_progname}; then
9553       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9554       echo "$as_me:$LINENO: result: yes" >&5
9555 echo "${ECHO_T}yes" >&6
9556       break
9557     else
9558       echo "$as_me:$LINENO: result: no" >&5
9559 echo "${ECHO_T}no" >&6
9560     fi
9561   done
9562 fi
9563
9564 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9565   for ncn_progname in ld; do
9566     if test -n "$ncn_target_tool_prefix"; then
9567       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9568 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9569 echo "$as_me:$LINENO: checking for $ac_word" >&5
9570 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9571 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9572   echo $ECHO_N "(cached) $ECHO_C" >&6
9573 else
9574   if test -n "$LD_FOR_TARGET"; then
9575   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9576 else
9577 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9578 for as_dir in $PATH
9579 do
9580   IFS=$as_save_IFS
9581   test -z "$as_dir" && as_dir=.
9582   for ac_exec_ext in '' $ac_executable_extensions; do
9583   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9584     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9585     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9586     break 2
9587   fi
9588 done
9589 done
9590
9591 fi
9592 fi
9593 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9594 if test -n "$LD_FOR_TARGET"; then
9595   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9596 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9597 else
9598   echo "$as_me:$LINENO: result: no" >&5
9599 echo "${ECHO_T}no" >&6
9600 fi
9601
9602     fi
9603     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9604       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9605 set dummy ${ncn_progname}; ac_word=$2
9606 echo "$as_me:$LINENO: checking for $ac_word" >&5
9607 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9608 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9609   echo $ECHO_N "(cached) $ECHO_C" >&6
9610 else
9611   if test -n "$LD_FOR_TARGET"; then
9612   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9613 else
9614 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9615 for as_dir in $PATH
9616 do
9617   IFS=$as_save_IFS
9618   test -z "$as_dir" && as_dir=.
9619   for ac_exec_ext in '' $ac_executable_extensions; do
9620   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9621     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9622     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9623     break 2
9624   fi
9625 done
9626 done
9627
9628 fi
9629 fi
9630 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9631 if test -n "$LD_FOR_TARGET"; then
9632   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9633 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9634 else
9635   echo "$as_me:$LINENO: result: no" >&5
9636 echo "${ECHO_T}no" >&6
9637 fi
9638
9639     fi
9640     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9641   done
9642 fi
9643
9644 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9645   set dummy ld
9646   if test $build = $target ; then
9647     LD_FOR_TARGET="$2"
9648   else
9649     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9650   fi
9651 else
9652   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9653 fi
9654
9655 else
9656   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9657 fi
9658
9659
9660
9661
9662 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9663   if test -n "$with_build_time_tools"; then
9664     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9665 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9666     if test -x $with_build_time_tools/lipo; then
9667       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9668       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9669       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9670 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9671     else
9672       echo "$as_me:$LINENO: result: no" >&5
9673 echo "${ECHO_T}no" >&6
9674     fi
9675   elif test $build != $host && test $have_gcc_for_target = yes; then
9676     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9677     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9678     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9679   fi
9680 fi
9681 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9682   # Extract the first word of "lipo", so it can be a program name with args.
9683 set dummy lipo; ac_word=$2
9684 echo "$as_me:$LINENO: checking for $ac_word" >&5
9685 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9686 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9687   echo $ECHO_N "(cached) $ECHO_C" >&6
9688 else
9689   case $LIPO_FOR_TARGET in
9690   [\\/]* | ?:[\\/]*)
9691   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9692   ;;
9693   *)
9694   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9695 for as_dir in $gcc_cv_tool_dirs
9696 do
9697   IFS=$as_save_IFS
9698   test -z "$as_dir" && as_dir=.
9699   for ac_exec_ext in '' $ac_executable_extensions; do
9700   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9701     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9702     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9703     break 2
9704   fi
9705 done
9706 done
9707
9708   ;;
9709 esac
9710 fi
9711 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9712
9713 if test -n "$LIPO_FOR_TARGET"; then
9714   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9715 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9716 else
9717   echo "$as_me:$LINENO: result: no" >&5
9718 echo "${ECHO_T}no" >&6
9719 fi
9720
9721 fi
9722 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9723
9724
9725 if test -n "$LIPO_FOR_TARGET"; then
9726   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9727 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9728   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9729 fi
9730
9731 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9732   for ncn_progname in lipo; do
9733     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9734 set dummy ${ncn_progname}; ac_word=$2
9735 echo "$as_me:$LINENO: checking for $ac_word" >&5
9736 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9737 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9738   echo $ECHO_N "(cached) $ECHO_C" >&6
9739 else
9740   if test -n "$LIPO_FOR_TARGET"; then
9741   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9742 else
9743 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9744 for as_dir in $PATH
9745 do
9746   IFS=$as_save_IFS
9747   test -z "$as_dir" && as_dir=.
9748   for ac_exec_ext in '' $ac_executable_extensions; do
9749   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9750     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9751     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9752     break 2
9753   fi
9754 done
9755 done
9756
9757 fi
9758 fi
9759 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9760 if test -n "$LIPO_FOR_TARGET"; then
9761   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9762 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9763 else
9764   echo "$as_me:$LINENO: result: no" >&5
9765 echo "${ECHO_T}no" >&6
9766 fi
9767
9768   done
9769 fi
9770
9771 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9772   for ncn_progname in lipo; do
9773     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9774 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9775     if test -x $with_build_time_tools/${ncn_progname}; then
9776       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9777       echo "$as_me:$LINENO: result: yes" >&5
9778 echo "${ECHO_T}yes" >&6
9779       break
9780     else
9781       echo "$as_me:$LINENO: result: no" >&5
9782 echo "${ECHO_T}no" >&6
9783     fi
9784   done
9785 fi
9786
9787 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9788   for ncn_progname in lipo; do
9789     if test -n "$ncn_target_tool_prefix"; then
9790       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9791 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9792 echo "$as_me:$LINENO: checking for $ac_word" >&5
9793 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9794 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9795   echo $ECHO_N "(cached) $ECHO_C" >&6
9796 else
9797   if test -n "$LIPO_FOR_TARGET"; then
9798   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9799 else
9800 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9801 for as_dir in $PATH
9802 do
9803   IFS=$as_save_IFS
9804   test -z "$as_dir" && as_dir=.
9805   for ac_exec_ext in '' $ac_executable_extensions; do
9806   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9807     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9808     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9809     break 2
9810   fi
9811 done
9812 done
9813
9814 fi
9815 fi
9816 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9817 if test -n "$LIPO_FOR_TARGET"; then
9818   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9819 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9820 else
9821   echo "$as_me:$LINENO: result: no" >&5
9822 echo "${ECHO_T}no" >&6
9823 fi
9824
9825     fi
9826     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9827       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9828 set dummy ${ncn_progname}; ac_word=$2
9829 echo "$as_me:$LINENO: checking for $ac_word" >&5
9830 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9831 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9832   echo $ECHO_N "(cached) $ECHO_C" >&6
9833 else
9834   if test -n "$LIPO_FOR_TARGET"; then
9835   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9836 else
9837 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9838 for as_dir in $PATH
9839 do
9840   IFS=$as_save_IFS
9841   test -z "$as_dir" && as_dir=.
9842   for ac_exec_ext in '' $ac_executable_extensions; do
9843   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9844     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9845     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9846     break 2
9847   fi
9848 done
9849 done
9850
9851 fi
9852 fi
9853 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9854 if test -n "$LIPO_FOR_TARGET"; then
9855   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9856 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9857 else
9858   echo "$as_me:$LINENO: result: no" >&5
9859 echo "${ECHO_T}no" >&6
9860 fi
9861
9862     fi
9863     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9864   done
9865 fi
9866
9867 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9868   set dummy lipo
9869   if test $build = $target ; then
9870     LIPO_FOR_TARGET="$2"
9871   else
9872     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9873   fi
9874 else
9875   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9876 fi
9877
9878 else
9879   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9880 fi
9881
9882
9883
9884
9885 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9886   if test -n "$with_build_time_tools"; then
9887     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9888 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9889     if test -x $with_build_time_tools/nm; then
9890       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9891       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9892       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9893 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9894     else
9895       echo "$as_me:$LINENO: result: no" >&5
9896 echo "${ECHO_T}no" >&6
9897     fi
9898   elif test $build != $host && test $have_gcc_for_target = yes; then
9899     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9900     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
9901     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9902   fi
9903 fi
9904 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9905   # Extract the first word of "nm", so it can be a program name with args.
9906 set dummy nm; ac_word=$2
9907 echo "$as_me:$LINENO: checking for $ac_word" >&5
9908 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9909 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9910   echo $ECHO_N "(cached) $ECHO_C" >&6
9911 else
9912   case $NM_FOR_TARGET in
9913   [\\/]* | ?:[\\/]*)
9914   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9915   ;;
9916   *)
9917   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9918 for as_dir in $gcc_cv_tool_dirs
9919 do
9920   IFS=$as_save_IFS
9921   test -z "$as_dir" && as_dir=.
9922   for ac_exec_ext in '' $ac_executable_extensions; do
9923   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9924     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9925     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9926     break 2
9927   fi
9928 done
9929 done
9930
9931   ;;
9932 esac
9933 fi
9934 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9935
9936 if test -n "$NM_FOR_TARGET"; then
9937   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9938 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9939 else
9940   echo "$as_me:$LINENO: result: no" >&5
9941 echo "${ECHO_T}no" >&6
9942 fi
9943
9944 fi
9945 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9946
9947
9948 if test -n "$NM_FOR_TARGET"; then
9949   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9950 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9951   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9952 fi
9953
9954 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9955   for ncn_progname in nm; do
9956     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9957 set dummy ${ncn_progname}; ac_word=$2
9958 echo "$as_me:$LINENO: checking for $ac_word" >&5
9959 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9960 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9961   echo $ECHO_N "(cached) $ECHO_C" >&6
9962 else
9963   if test -n "$NM_FOR_TARGET"; then
9964   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9965 else
9966 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9967 for as_dir in $PATH
9968 do
9969   IFS=$as_save_IFS
9970   test -z "$as_dir" && as_dir=.
9971   for ac_exec_ext in '' $ac_executable_extensions; do
9972   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9973     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9974     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9975     break 2
9976   fi
9977 done
9978 done
9979
9980 fi
9981 fi
9982 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9983 if test -n "$NM_FOR_TARGET"; then
9984   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9985 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9986 else
9987   echo "$as_me:$LINENO: result: no" >&5
9988 echo "${ECHO_T}no" >&6
9989 fi
9990
9991   done
9992 fi
9993
9994 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
9995   for ncn_progname in nm; do
9996     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9997 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9998     if test -x $with_build_time_tools/${ncn_progname}; then
9999       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10000       echo "$as_me:$LINENO: result: yes" >&5
10001 echo "${ECHO_T}yes" >&6
10002       break
10003     else
10004       echo "$as_me:$LINENO: result: no" >&5
10005 echo "${ECHO_T}no" >&6
10006     fi
10007   done
10008 fi
10009
10010 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10011   for ncn_progname in nm; do
10012     if test -n "$ncn_target_tool_prefix"; then
10013       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10014 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10015 echo "$as_me:$LINENO: checking for $ac_word" >&5
10016 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10017 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10018   echo $ECHO_N "(cached) $ECHO_C" >&6
10019 else
10020   if test -n "$NM_FOR_TARGET"; then
10021   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10022 else
10023 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10024 for as_dir in $PATH
10025 do
10026   IFS=$as_save_IFS
10027   test -z "$as_dir" && as_dir=.
10028   for ac_exec_ext in '' $ac_executable_extensions; do
10029   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10030     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10031     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10032     break 2
10033   fi
10034 done
10035 done
10036
10037 fi
10038 fi
10039 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10040 if test -n "$NM_FOR_TARGET"; then
10041   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10042 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10043 else
10044   echo "$as_me:$LINENO: result: no" >&5
10045 echo "${ECHO_T}no" >&6
10046 fi
10047
10048     fi
10049     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10050       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10051 set dummy ${ncn_progname}; ac_word=$2
10052 echo "$as_me:$LINENO: checking for $ac_word" >&5
10053 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10054 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10055   echo $ECHO_N "(cached) $ECHO_C" >&6
10056 else
10057   if test -n "$NM_FOR_TARGET"; then
10058   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10059 else
10060 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10061 for as_dir in $PATH
10062 do
10063   IFS=$as_save_IFS
10064   test -z "$as_dir" && as_dir=.
10065   for ac_exec_ext in '' $ac_executable_extensions; do
10066   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10067     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10068     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10069     break 2
10070   fi
10071 done
10072 done
10073
10074 fi
10075 fi
10076 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10077 if test -n "$NM_FOR_TARGET"; then
10078   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10079 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10080 else
10081   echo "$as_me:$LINENO: result: no" >&5
10082 echo "${ECHO_T}no" >&6
10083 fi
10084
10085     fi
10086     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10087   done
10088 fi
10089
10090 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10091   set dummy nm
10092   if test $build = $target ; then
10093     NM_FOR_TARGET="$2"
10094   else
10095     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10096   fi
10097 else
10098   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10099 fi
10100
10101 else
10102   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10103 fi
10104
10105
10106
10107
10108 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10109   if test -n "$with_build_time_tools"; then
10110     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10111 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10112     if test -x $with_build_time_tools/objdump; then
10113       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10114       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10115       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10116 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10117     else
10118       echo "$as_me:$LINENO: result: no" >&5
10119 echo "${ECHO_T}no" >&6
10120     fi
10121   elif test $build != $host && test $have_gcc_for_target = yes; then
10122     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10123     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10124     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10125   fi
10126 fi
10127 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10128   # Extract the first word of "objdump", so it can be a program name with args.
10129 set dummy objdump; ac_word=$2
10130 echo "$as_me:$LINENO: checking for $ac_word" >&5
10131 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10132 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10133   echo $ECHO_N "(cached) $ECHO_C" >&6
10134 else
10135   case $OBJDUMP_FOR_TARGET in
10136   [\\/]* | ?:[\\/]*)
10137   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10138   ;;
10139   *)
10140   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10141 for as_dir in $gcc_cv_tool_dirs
10142 do
10143   IFS=$as_save_IFS
10144   test -z "$as_dir" && as_dir=.
10145   for ac_exec_ext in '' $ac_executable_extensions; do
10146   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10147     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10148     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10149     break 2
10150   fi
10151 done
10152 done
10153
10154   ;;
10155 esac
10156 fi
10157 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10158
10159 if test -n "$OBJDUMP_FOR_TARGET"; then
10160   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10161 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10162 else
10163   echo "$as_me:$LINENO: result: no" >&5
10164 echo "${ECHO_T}no" >&6
10165 fi
10166
10167 fi
10168 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10169
10170
10171 if test -n "$OBJDUMP_FOR_TARGET"; then
10172   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10173 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10174   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10175 fi
10176
10177 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10178   for ncn_progname in objdump; do
10179     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10180 set dummy ${ncn_progname}; ac_word=$2
10181 echo "$as_me:$LINENO: checking for $ac_word" >&5
10182 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10183 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10184   echo $ECHO_N "(cached) $ECHO_C" >&6
10185 else
10186   if test -n "$OBJDUMP_FOR_TARGET"; then
10187   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10188 else
10189 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10190 for as_dir in $PATH
10191 do
10192   IFS=$as_save_IFS
10193   test -z "$as_dir" && as_dir=.
10194   for ac_exec_ext in '' $ac_executable_extensions; do
10195   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10196     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10197     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10198     break 2
10199   fi
10200 done
10201 done
10202
10203 fi
10204 fi
10205 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10206 if test -n "$OBJDUMP_FOR_TARGET"; then
10207   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10208 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10209 else
10210   echo "$as_me:$LINENO: result: no" >&5
10211 echo "${ECHO_T}no" >&6
10212 fi
10213
10214   done
10215 fi
10216
10217 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10218   for ncn_progname in objdump; do
10219     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10220 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10221     if test -x $with_build_time_tools/${ncn_progname}; then
10222       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10223       echo "$as_me:$LINENO: result: yes" >&5
10224 echo "${ECHO_T}yes" >&6
10225       break
10226     else
10227       echo "$as_me:$LINENO: result: no" >&5
10228 echo "${ECHO_T}no" >&6
10229     fi
10230   done
10231 fi
10232
10233 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10234   for ncn_progname in objdump; do
10235     if test -n "$ncn_target_tool_prefix"; then
10236       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10237 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10238 echo "$as_me:$LINENO: checking for $ac_word" >&5
10239 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10240 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10241   echo $ECHO_N "(cached) $ECHO_C" >&6
10242 else
10243   if test -n "$OBJDUMP_FOR_TARGET"; then
10244   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10245 else
10246 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10247 for as_dir in $PATH
10248 do
10249   IFS=$as_save_IFS
10250   test -z "$as_dir" && as_dir=.
10251   for ac_exec_ext in '' $ac_executable_extensions; do
10252   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10253     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10254     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10255     break 2
10256   fi
10257 done
10258 done
10259
10260 fi
10261 fi
10262 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10263 if test -n "$OBJDUMP_FOR_TARGET"; then
10264   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10265 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10266 else
10267   echo "$as_me:$LINENO: result: no" >&5
10268 echo "${ECHO_T}no" >&6
10269 fi
10270
10271     fi
10272     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10273       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10274 set dummy ${ncn_progname}; ac_word=$2
10275 echo "$as_me:$LINENO: checking for $ac_word" >&5
10276 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10277 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10278   echo $ECHO_N "(cached) $ECHO_C" >&6
10279 else
10280   if test -n "$OBJDUMP_FOR_TARGET"; then
10281   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10282 else
10283 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10284 for as_dir in $PATH
10285 do
10286   IFS=$as_save_IFS
10287   test -z "$as_dir" && as_dir=.
10288   for ac_exec_ext in '' $ac_executable_extensions; do
10289   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10290     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10291     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10292     break 2
10293   fi
10294 done
10295 done
10296
10297 fi
10298 fi
10299 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10300 if test -n "$OBJDUMP_FOR_TARGET"; then
10301   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10302 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10303 else
10304   echo "$as_me:$LINENO: result: no" >&5
10305 echo "${ECHO_T}no" >&6
10306 fi
10307
10308     fi
10309     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10310   done
10311 fi
10312
10313 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10314   set dummy objdump
10315   if test $build = $target ; then
10316     OBJDUMP_FOR_TARGET="$2"
10317   else
10318     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10319   fi
10320 else
10321   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10322 fi
10323
10324 else
10325   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10326 fi
10327
10328
10329
10330
10331 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10332   if test -n "$with_build_time_tools"; then
10333     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10334 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10335     if test -x $with_build_time_tools/ranlib; then
10336       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10337       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10338       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10339 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10340     else
10341       echo "$as_me:$LINENO: result: no" >&5
10342 echo "${ECHO_T}no" >&6
10343     fi
10344   elif test $build != $host && test $have_gcc_for_target = yes; then
10345     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10346     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10347     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10348   fi
10349 fi
10350 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10351   # Extract the first word of "ranlib", so it can be a program name with args.
10352 set dummy ranlib; ac_word=$2
10353 echo "$as_me:$LINENO: checking for $ac_word" >&5
10354 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10355 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10356   echo $ECHO_N "(cached) $ECHO_C" >&6
10357 else
10358   case $RANLIB_FOR_TARGET in
10359   [\\/]* | ?:[\\/]*)
10360   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10361   ;;
10362   *)
10363   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10364 for as_dir in $gcc_cv_tool_dirs
10365 do
10366   IFS=$as_save_IFS
10367   test -z "$as_dir" && as_dir=.
10368   for ac_exec_ext in '' $ac_executable_extensions; do
10369   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10370     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10371     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10372     break 2
10373   fi
10374 done
10375 done
10376
10377   ;;
10378 esac
10379 fi
10380 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10381
10382 if test -n "$RANLIB_FOR_TARGET"; then
10383   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10384 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10385 else
10386   echo "$as_me:$LINENO: result: no" >&5
10387 echo "${ECHO_T}no" >&6
10388 fi
10389
10390 fi
10391 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10392
10393
10394 if test -n "$RANLIB_FOR_TARGET"; then
10395   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10396 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10397   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10398 fi
10399
10400 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10401   for ncn_progname in ranlib; do
10402     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10403 set dummy ${ncn_progname}; ac_word=$2
10404 echo "$as_me:$LINENO: checking for $ac_word" >&5
10405 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10406 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10407   echo $ECHO_N "(cached) $ECHO_C" >&6
10408 else
10409   if test -n "$RANLIB_FOR_TARGET"; then
10410   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10411 else
10412 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10413 for as_dir in $PATH
10414 do
10415   IFS=$as_save_IFS
10416   test -z "$as_dir" && as_dir=.
10417   for ac_exec_ext in '' $ac_executable_extensions; do
10418   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10419     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10420     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10421     break 2
10422   fi
10423 done
10424 done
10425
10426 fi
10427 fi
10428 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10429 if test -n "$RANLIB_FOR_TARGET"; then
10430   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10431 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10432 else
10433   echo "$as_me:$LINENO: result: no" >&5
10434 echo "${ECHO_T}no" >&6
10435 fi
10436
10437   done
10438 fi
10439
10440 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10441   for ncn_progname in ranlib; do
10442     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10443 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10444     if test -x $with_build_time_tools/${ncn_progname}; then
10445       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10446       echo "$as_me:$LINENO: result: yes" >&5
10447 echo "${ECHO_T}yes" >&6
10448       break
10449     else
10450       echo "$as_me:$LINENO: result: no" >&5
10451 echo "${ECHO_T}no" >&6
10452     fi
10453   done
10454 fi
10455
10456 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10457   for ncn_progname in ranlib; do
10458     if test -n "$ncn_target_tool_prefix"; then
10459       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10460 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10461 echo "$as_me:$LINENO: checking for $ac_word" >&5
10462 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10463 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10464   echo $ECHO_N "(cached) $ECHO_C" >&6
10465 else
10466   if test -n "$RANLIB_FOR_TARGET"; then
10467   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10468 else
10469 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10470 for as_dir in $PATH
10471 do
10472   IFS=$as_save_IFS
10473   test -z "$as_dir" && as_dir=.
10474   for ac_exec_ext in '' $ac_executable_extensions; do
10475   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10476     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10477     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10478     break 2
10479   fi
10480 done
10481 done
10482
10483 fi
10484 fi
10485 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10486 if test -n "$RANLIB_FOR_TARGET"; then
10487   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10488 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10489 else
10490   echo "$as_me:$LINENO: result: no" >&5
10491 echo "${ECHO_T}no" >&6
10492 fi
10493
10494     fi
10495     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10496       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10497 set dummy ${ncn_progname}; ac_word=$2
10498 echo "$as_me:$LINENO: checking for $ac_word" >&5
10499 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10500 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10501   echo $ECHO_N "(cached) $ECHO_C" >&6
10502 else
10503   if test -n "$RANLIB_FOR_TARGET"; then
10504   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10505 else
10506 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10507 for as_dir in $PATH
10508 do
10509   IFS=$as_save_IFS
10510   test -z "$as_dir" && as_dir=.
10511   for ac_exec_ext in '' $ac_executable_extensions; do
10512   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10513     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10514     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10515     break 2
10516   fi
10517 done
10518 done
10519
10520 fi
10521 fi
10522 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10523 if test -n "$RANLIB_FOR_TARGET"; then
10524   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10525 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10526 else
10527   echo "$as_me:$LINENO: result: no" >&5
10528 echo "${ECHO_T}no" >&6
10529 fi
10530
10531     fi
10532     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10533   done
10534 fi
10535
10536 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10537   set dummy ranlib
10538   if test $build = $target ; then
10539     RANLIB_FOR_TARGET="$2"
10540   else
10541     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10542   fi
10543 else
10544   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10545 fi
10546
10547 else
10548   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10549 fi
10550
10551
10552
10553
10554 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10555   if test -n "$with_build_time_tools"; then
10556     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10557 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10558     if test -x $with_build_time_tools/strip; then
10559       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10560       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10561       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10562 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10563     else
10564       echo "$as_me:$LINENO: result: no" >&5
10565 echo "${ECHO_T}no" >&6
10566     fi
10567   elif test $build != $host && test $have_gcc_for_target = yes; then
10568     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10569     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10570     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10571   fi
10572 fi
10573 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10574   # Extract the first word of "strip", so it can be a program name with args.
10575 set dummy strip; ac_word=$2
10576 echo "$as_me:$LINENO: checking for $ac_word" >&5
10577 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10578 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10579   echo $ECHO_N "(cached) $ECHO_C" >&6
10580 else
10581   case $STRIP_FOR_TARGET in
10582   [\\/]* | ?:[\\/]*)
10583   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10584   ;;
10585   *)
10586   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10587 for as_dir in $gcc_cv_tool_dirs
10588 do
10589   IFS=$as_save_IFS
10590   test -z "$as_dir" && as_dir=.
10591   for ac_exec_ext in '' $ac_executable_extensions; do
10592   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10593     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10594     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10595     break 2
10596   fi
10597 done
10598 done
10599
10600   ;;
10601 esac
10602 fi
10603 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10604
10605 if test -n "$STRIP_FOR_TARGET"; then
10606   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10607 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10608 else
10609   echo "$as_me:$LINENO: result: no" >&5
10610 echo "${ECHO_T}no" >&6
10611 fi
10612
10613 fi
10614 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10615
10616
10617 if test -n "$STRIP_FOR_TARGET"; then
10618   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10619 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10620   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10621 fi
10622
10623 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10624   for ncn_progname in strip; do
10625     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10626 set dummy ${ncn_progname}; ac_word=$2
10627 echo "$as_me:$LINENO: checking for $ac_word" >&5
10628 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10629 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10630   echo $ECHO_N "(cached) $ECHO_C" >&6
10631 else
10632   if test -n "$STRIP_FOR_TARGET"; then
10633   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10634 else
10635 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10636 for as_dir in $PATH
10637 do
10638   IFS=$as_save_IFS
10639   test -z "$as_dir" && as_dir=.
10640   for ac_exec_ext in '' $ac_executable_extensions; do
10641   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10642     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10643     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10644     break 2
10645   fi
10646 done
10647 done
10648
10649 fi
10650 fi
10651 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10652 if test -n "$STRIP_FOR_TARGET"; then
10653   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10654 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10655 else
10656   echo "$as_me:$LINENO: result: no" >&5
10657 echo "${ECHO_T}no" >&6
10658 fi
10659
10660   done
10661 fi
10662
10663 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10664   for ncn_progname in strip; do
10665     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10666 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10667     if test -x $with_build_time_tools/${ncn_progname}; then
10668       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10669       echo "$as_me:$LINENO: result: yes" >&5
10670 echo "${ECHO_T}yes" >&6
10671       break
10672     else
10673       echo "$as_me:$LINENO: result: no" >&5
10674 echo "${ECHO_T}no" >&6
10675     fi
10676   done
10677 fi
10678
10679 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10680   for ncn_progname in strip; do
10681     if test -n "$ncn_target_tool_prefix"; then
10682       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10683 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10684 echo "$as_me:$LINENO: checking for $ac_word" >&5
10685 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10686 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10687   echo $ECHO_N "(cached) $ECHO_C" >&6
10688 else
10689   if test -n "$STRIP_FOR_TARGET"; then
10690   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10691 else
10692 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10693 for as_dir in $PATH
10694 do
10695   IFS=$as_save_IFS
10696   test -z "$as_dir" && as_dir=.
10697   for ac_exec_ext in '' $ac_executable_extensions; do
10698   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10699     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10700     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10701     break 2
10702   fi
10703 done
10704 done
10705
10706 fi
10707 fi
10708 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10709 if test -n "$STRIP_FOR_TARGET"; then
10710   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10711 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10712 else
10713   echo "$as_me:$LINENO: result: no" >&5
10714 echo "${ECHO_T}no" >&6
10715 fi
10716
10717     fi
10718     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10719       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10720 set dummy ${ncn_progname}; ac_word=$2
10721 echo "$as_me:$LINENO: checking for $ac_word" >&5
10722 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10723 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10724   echo $ECHO_N "(cached) $ECHO_C" >&6
10725 else
10726   if test -n "$STRIP_FOR_TARGET"; then
10727   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10728 else
10729 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10730 for as_dir in $PATH
10731 do
10732   IFS=$as_save_IFS
10733   test -z "$as_dir" && as_dir=.
10734   for ac_exec_ext in '' $ac_executable_extensions; do
10735   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10736     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10737     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10738     break 2
10739   fi
10740 done
10741 done
10742
10743 fi
10744 fi
10745 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10746 if test -n "$STRIP_FOR_TARGET"; then
10747   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10748 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10749 else
10750   echo "$as_me:$LINENO: result: no" >&5
10751 echo "${ECHO_T}no" >&6
10752 fi
10753
10754     fi
10755     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10756   done
10757 fi
10758
10759 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10760   set dummy strip
10761   if test $build = $target ; then
10762     STRIP_FOR_TARGET="$2"
10763   else
10764     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10765   fi
10766 else
10767   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10768 fi
10769
10770 else
10771   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10772 fi
10773
10774
10775
10776
10777 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10778   if test -n "$with_build_time_tools"; then
10779     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10780 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10781     if test -x $with_build_time_tools/windres; then
10782       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10783       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10784       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10785 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10786     else
10787       echo "$as_me:$LINENO: result: no" >&5
10788 echo "${ECHO_T}no" >&6
10789     fi
10790   elif test $build != $host && test $have_gcc_for_target = yes; then
10791     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10792     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10793     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10794   fi
10795 fi
10796 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10797   # Extract the first word of "windres", so it can be a program name with args.
10798 set dummy windres; ac_word=$2
10799 echo "$as_me:$LINENO: checking for $ac_word" >&5
10800 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10801 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10802   echo $ECHO_N "(cached) $ECHO_C" >&6
10803 else
10804   case $WINDRES_FOR_TARGET in
10805   [\\/]* | ?:[\\/]*)
10806   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10807   ;;
10808   *)
10809   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10810 for as_dir in $gcc_cv_tool_dirs
10811 do
10812   IFS=$as_save_IFS
10813   test -z "$as_dir" && as_dir=.
10814   for ac_exec_ext in '' $ac_executable_extensions; do
10815   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10816     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10817     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10818     break 2
10819   fi
10820 done
10821 done
10822
10823   ;;
10824 esac
10825 fi
10826 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10827
10828 if test -n "$WINDRES_FOR_TARGET"; then
10829   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10830 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10831 else
10832   echo "$as_me:$LINENO: result: no" >&5
10833 echo "${ECHO_T}no" >&6
10834 fi
10835
10836 fi
10837 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10838
10839
10840 if test -n "$WINDRES_FOR_TARGET"; then
10841   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10842 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10843   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10844 fi
10845
10846 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10847   for ncn_progname in windres; do
10848     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10849 set dummy ${ncn_progname}; ac_word=$2
10850 echo "$as_me:$LINENO: checking for $ac_word" >&5
10851 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10852 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10853   echo $ECHO_N "(cached) $ECHO_C" >&6
10854 else
10855   if test -n "$WINDRES_FOR_TARGET"; then
10856   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10857 else
10858 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10859 for as_dir in $PATH
10860 do
10861   IFS=$as_save_IFS
10862   test -z "$as_dir" && as_dir=.
10863   for ac_exec_ext in '' $ac_executable_extensions; do
10864   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10865     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10866     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10867     break 2
10868   fi
10869 done
10870 done
10871
10872 fi
10873 fi
10874 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10875 if test -n "$WINDRES_FOR_TARGET"; then
10876   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10877 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10878 else
10879   echo "$as_me:$LINENO: result: no" >&5
10880 echo "${ECHO_T}no" >&6
10881 fi
10882
10883   done
10884 fi
10885
10886 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10887   for ncn_progname in windres; do
10888     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10889 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10890     if test -x $with_build_time_tools/${ncn_progname}; then
10891       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10892       echo "$as_me:$LINENO: result: yes" >&5
10893 echo "${ECHO_T}yes" >&6
10894       break
10895     else
10896       echo "$as_me:$LINENO: result: no" >&5
10897 echo "${ECHO_T}no" >&6
10898     fi
10899   done
10900 fi
10901
10902 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10903   for ncn_progname in windres; do
10904     if test -n "$ncn_target_tool_prefix"; then
10905       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10906 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10907 echo "$as_me:$LINENO: checking for $ac_word" >&5
10908 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10909 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10910   echo $ECHO_N "(cached) $ECHO_C" >&6
10911 else
10912   if test -n "$WINDRES_FOR_TARGET"; then
10913   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10914 else
10915 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10916 for as_dir in $PATH
10917 do
10918   IFS=$as_save_IFS
10919   test -z "$as_dir" && as_dir=.
10920   for ac_exec_ext in '' $ac_executable_extensions; do
10921   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10922     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10923     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10924     break 2
10925   fi
10926 done
10927 done
10928
10929 fi
10930 fi
10931 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10932 if test -n "$WINDRES_FOR_TARGET"; then
10933   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10934 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10935 else
10936   echo "$as_me:$LINENO: result: no" >&5
10937 echo "${ECHO_T}no" >&6
10938 fi
10939
10940     fi
10941     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10942       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10943 set dummy ${ncn_progname}; ac_word=$2
10944 echo "$as_me:$LINENO: checking for $ac_word" >&5
10945 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10946 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10947   echo $ECHO_N "(cached) $ECHO_C" >&6
10948 else
10949   if test -n "$WINDRES_FOR_TARGET"; then
10950   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10951 else
10952 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10953 for as_dir in $PATH
10954 do
10955   IFS=$as_save_IFS
10956   test -z "$as_dir" && as_dir=.
10957   for ac_exec_ext in '' $ac_executable_extensions; do
10958   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10959     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10960     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10961     break 2
10962   fi
10963 done
10964 done
10965
10966 fi
10967 fi
10968 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10969 if test -n "$WINDRES_FOR_TARGET"; then
10970   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10971 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10972 else
10973   echo "$as_me:$LINENO: result: no" >&5
10974 echo "${ECHO_T}no" >&6
10975 fi
10976
10977     fi
10978     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
10979   done
10980 fi
10981
10982 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
10983   set dummy windres
10984   if test $build = $target ; then
10985     WINDRES_FOR_TARGET="$2"
10986   else
10987     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
10988   fi
10989 else
10990   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
10991 fi
10992
10993 else
10994   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10995 fi
10996
10997
10998
10999
11000 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11001   if test -n "$with_build_time_tools"; then
11002     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11003 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11004     if test -x $with_build_time_tools/windmc; then
11005       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11006       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11007       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11008 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11009     else
11010       echo "$as_me:$LINENO: result: no" >&5
11011 echo "${ECHO_T}no" >&6
11012     fi
11013   elif test $build != $host && test $have_gcc_for_target = yes; then
11014     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11015     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11016     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11017   fi
11018 fi
11019 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11020   # Extract the first word of "windmc", so it can be a program name with args.
11021 set dummy windmc; ac_word=$2
11022 echo "$as_me:$LINENO: checking for $ac_word" >&5
11023 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11024 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11025   echo $ECHO_N "(cached) $ECHO_C" >&6
11026 else
11027   case $WINDMC_FOR_TARGET in
11028   [\\/]* | ?:[\\/]*)
11029   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11030   ;;
11031   *)
11032   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11033 for as_dir in $gcc_cv_tool_dirs
11034 do
11035   IFS=$as_save_IFS
11036   test -z "$as_dir" && as_dir=.
11037   for ac_exec_ext in '' $ac_executable_extensions; do
11038   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11039     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11040     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11041     break 2
11042   fi
11043 done
11044 done
11045
11046   ;;
11047 esac
11048 fi
11049 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11050
11051 if test -n "$WINDMC_FOR_TARGET"; then
11052   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11053 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11054 else
11055   echo "$as_me:$LINENO: result: no" >&5
11056 echo "${ECHO_T}no" >&6
11057 fi
11058
11059 fi
11060 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11061
11062
11063 if test -n "$WINDMC_FOR_TARGET"; then
11064   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11065 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11066   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11067 fi
11068
11069 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11070   for ncn_progname in windmc; do
11071     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11072 set dummy ${ncn_progname}; ac_word=$2
11073 echo "$as_me:$LINENO: checking for $ac_word" >&5
11074 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11075 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11076   echo $ECHO_N "(cached) $ECHO_C" >&6
11077 else
11078   if test -n "$WINDMC_FOR_TARGET"; then
11079   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11080 else
11081 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11082 for as_dir in $PATH
11083 do
11084   IFS=$as_save_IFS
11085   test -z "$as_dir" && as_dir=.
11086   for ac_exec_ext in '' $ac_executable_extensions; do
11087   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11088     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11089     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11090     break 2
11091   fi
11092 done
11093 done
11094
11095 fi
11096 fi
11097 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11098 if test -n "$WINDMC_FOR_TARGET"; then
11099   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11100 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11101 else
11102   echo "$as_me:$LINENO: result: no" >&5
11103 echo "${ECHO_T}no" >&6
11104 fi
11105
11106   done
11107 fi
11108
11109 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11110   for ncn_progname in windmc; do
11111     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11112 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11113     if test -x $with_build_time_tools/${ncn_progname}; then
11114       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11115       echo "$as_me:$LINENO: result: yes" >&5
11116 echo "${ECHO_T}yes" >&6
11117       break
11118     else
11119       echo "$as_me:$LINENO: result: no" >&5
11120 echo "${ECHO_T}no" >&6
11121     fi
11122   done
11123 fi
11124
11125 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11126   for ncn_progname in windmc; do
11127     if test -n "$ncn_target_tool_prefix"; then
11128       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11129 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11130 echo "$as_me:$LINENO: checking for $ac_word" >&5
11131 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11132 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11133   echo $ECHO_N "(cached) $ECHO_C" >&6
11134 else
11135   if test -n "$WINDMC_FOR_TARGET"; then
11136   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11137 else
11138 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11139 for as_dir in $PATH
11140 do
11141   IFS=$as_save_IFS
11142   test -z "$as_dir" && as_dir=.
11143   for ac_exec_ext in '' $ac_executable_extensions; do
11144   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11145     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11146     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11147     break 2
11148   fi
11149 done
11150 done
11151
11152 fi
11153 fi
11154 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11155 if test -n "$WINDMC_FOR_TARGET"; then
11156   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11157 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11158 else
11159   echo "$as_me:$LINENO: result: no" >&5
11160 echo "${ECHO_T}no" >&6
11161 fi
11162
11163     fi
11164     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11165       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11166 set dummy ${ncn_progname}; ac_word=$2
11167 echo "$as_me:$LINENO: checking for $ac_word" >&5
11168 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11169 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11170   echo $ECHO_N "(cached) $ECHO_C" >&6
11171 else
11172   if test -n "$WINDMC_FOR_TARGET"; then
11173   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11174 else
11175 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11176 for as_dir in $PATH
11177 do
11178   IFS=$as_save_IFS
11179   test -z "$as_dir" && as_dir=.
11180   for ac_exec_ext in '' $ac_executable_extensions; do
11181   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11182     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11183     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11184     break 2
11185   fi
11186 done
11187 done
11188
11189 fi
11190 fi
11191 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11192 if test -n "$WINDMC_FOR_TARGET"; then
11193   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11194 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11195 else
11196   echo "$as_me:$LINENO: result: no" >&5
11197 echo "${ECHO_T}no" >&6
11198 fi
11199
11200     fi
11201     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11202   done
11203 fi
11204
11205 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11206   set dummy windmc
11207   if test $build = $target ; then
11208     WINDMC_FOR_TARGET="$2"
11209   else
11210     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11211   fi
11212 else
11213   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11214 fi
11215
11216 else
11217   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11218 fi
11219
11220
11221 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11222
11223 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11224 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11225 if test "x${build}" != "x${host}" ; then
11226   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11227     # We already found the complete path
11228     ac_dir=`dirname $AR_FOR_TARGET`
11229     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11230 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11231   else
11232     # Canadian cross, just use what we found
11233     echo "$as_me:$LINENO: result: pre-installed" >&5
11234 echo "${ECHO_T}pre-installed" >&6
11235   fi
11236 else
11237   ok=yes
11238   case " ${configdirs} " in
11239     *" binutils "*) ;;
11240     *) ok=no ;;
11241   esac
11242
11243   if test $ok = yes; then
11244     # An in-tree tool is available and we can use it
11245     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11246     echo "$as_me:$LINENO: result: just compiled" >&5
11247 echo "${ECHO_T}just compiled" >&6
11248   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11249     # We already found the complete path
11250     ac_dir=`dirname $AR_FOR_TARGET`
11251     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11252 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11253   elif test "x$target" = "x$host"; then
11254     # We can use an host tool
11255     AR_FOR_TARGET='$(AR)'
11256     echo "$as_me:$LINENO: result: host tool" >&5
11257 echo "${ECHO_T}host tool" >&6
11258   else
11259     # We need a cross tool
11260     echo "$as_me:$LINENO: result: pre-installed" >&5
11261 echo "${ECHO_T}pre-installed" >&6
11262   fi
11263 fi
11264
11265 echo "$as_me:$LINENO: checking where to find the target as" >&5
11266 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11267 if test "x${build}" != "x${host}" ; then
11268   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11269     # We already found the complete path
11270     ac_dir=`dirname $AS_FOR_TARGET`
11271     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11272 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11273   else
11274     # Canadian cross, just use what we found
11275     echo "$as_me:$LINENO: result: pre-installed" >&5
11276 echo "${ECHO_T}pre-installed" >&6
11277   fi
11278 else
11279   ok=yes
11280   case " ${configdirs} " in
11281     *" gas "*) ;;
11282     *) ok=no ;;
11283   esac
11284
11285   if test $ok = yes; then
11286     # An in-tree tool is available and we can use it
11287     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11288     echo "$as_me:$LINENO: result: just compiled" >&5
11289 echo "${ECHO_T}just compiled" >&6
11290   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11291     # We already found the complete path
11292     ac_dir=`dirname $AS_FOR_TARGET`
11293     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11294 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11295   elif test "x$target" = "x$host"; then
11296     # We can use an host tool
11297     AS_FOR_TARGET='$(AS)'
11298     echo "$as_me:$LINENO: result: host tool" >&5
11299 echo "${ECHO_T}host tool" >&6
11300   else
11301     # We need a cross tool
11302     echo "$as_me:$LINENO: result: pre-installed" >&5
11303 echo "${ECHO_T}pre-installed" >&6
11304   fi
11305 fi
11306
11307 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11308 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11309 if test "x${build}" != "x${host}" ; then
11310   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11311     # We already found the complete path
11312     ac_dir=`dirname $CC_FOR_TARGET`
11313     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11314 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11315   else
11316     # Canadian cross, just use what we found
11317     echo "$as_me:$LINENO: result: pre-installed" >&5
11318 echo "${ECHO_T}pre-installed" >&6
11319   fi
11320 else
11321   ok=yes
11322   case " ${configdirs} " in
11323     *" gcc "*) ;;
11324     *) ok=no ;;
11325   esac
11326
11327   if test $ok = yes; then
11328     # An in-tree tool is available and we can use it
11329     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11330     echo "$as_me:$LINENO: result: just compiled" >&5
11331 echo "${ECHO_T}just compiled" >&6
11332   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11333     # We already found the complete path
11334     ac_dir=`dirname $CC_FOR_TARGET`
11335     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11336 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11337   elif test "x$target" = "x$host"; then
11338     # We can use an host tool
11339     CC_FOR_TARGET='$(CC)'
11340     echo "$as_me:$LINENO: result: host tool" >&5
11341 echo "${ECHO_T}host tool" >&6
11342   else
11343     # We need a cross tool
11344     echo "$as_me:$LINENO: result: pre-installed" >&5
11345 echo "${ECHO_T}pre-installed" >&6
11346   fi
11347 fi
11348
11349 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11350 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11351 if test "x${build}" != "x${host}" ; then
11352   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11353     # We already found the complete path
11354     ac_dir=`dirname $CXX_FOR_TARGET`
11355     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11356 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11357   else
11358     # Canadian cross, just use what we found
11359     echo "$as_me:$LINENO: result: pre-installed" >&5
11360 echo "${ECHO_T}pre-installed" >&6
11361   fi
11362 else
11363   ok=yes
11364   case " ${configdirs} " in
11365     *" gcc "*) ;;
11366     *) ok=no ;;
11367   esac
11368   case ,${enable_languages}, in
11369     *,c++,*) ;;
11370     *) ok=no ;;
11371   esac
11372   if test $ok = yes; then
11373     # An in-tree tool is available and we can use it
11374     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'
11375     echo "$as_me:$LINENO: result: just compiled" >&5
11376 echo "${ECHO_T}just compiled" >&6
11377   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11378     # We already found the complete path
11379     ac_dir=`dirname $CXX_FOR_TARGET`
11380     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11381 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11382   elif test "x$target" = "x$host"; then
11383     # We can use an host tool
11384     CXX_FOR_TARGET='$(CXX)'
11385     echo "$as_me:$LINENO: result: host tool" >&5
11386 echo "${ECHO_T}host tool" >&6
11387   else
11388     # We need a cross tool
11389     echo "$as_me:$LINENO: result: pre-installed" >&5
11390 echo "${ECHO_T}pre-installed" >&6
11391   fi
11392 fi
11393
11394 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11395 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11396 if test "x${build}" != "x${host}" ; then
11397   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11398     # We already found the complete path
11399     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11400     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11401 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11402   else
11403     # Canadian cross, just use what we found
11404     echo "$as_me:$LINENO: result: pre-installed" >&5
11405 echo "${ECHO_T}pre-installed" >&6
11406   fi
11407 else
11408   ok=yes
11409   case " ${configdirs} " in
11410     *" gcc "*) ;;
11411     *) ok=no ;;
11412   esac
11413   case ,${enable_languages}, in
11414     *,c++,*) ;;
11415     *) ok=no ;;
11416   esac
11417   if test $ok = yes; then
11418     # An in-tree tool is available and we can use it
11419     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'
11420     echo "$as_me:$LINENO: result: just compiled" >&5
11421 echo "${ECHO_T}just compiled" >&6
11422   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11423     # We already found the complete path
11424     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11425     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11426 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11427   elif test "x$target" = "x$host"; then
11428     # We can use an host tool
11429     RAW_CXX_FOR_TARGET='$(CXX)'
11430     echo "$as_me:$LINENO: result: host tool" >&5
11431 echo "${ECHO_T}host tool" >&6
11432   else
11433     # We need a cross tool
11434     echo "$as_me:$LINENO: result: pre-installed" >&5
11435 echo "${ECHO_T}pre-installed" >&6
11436   fi
11437 fi
11438
11439 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11440 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11441 if test "x${build}" != "x${host}" ; then
11442   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11443     # We already found the complete path
11444     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11445     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11446 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11447   else
11448     # Canadian cross, just use what we found
11449     echo "$as_me:$LINENO: result: pre-installed" >&5
11450 echo "${ECHO_T}pre-installed" >&6
11451   fi
11452 else
11453   ok=yes
11454   case " ${configdirs} " in
11455     *" binutils "*) ;;
11456     *) ok=no ;;
11457   esac
11458
11459   if test $ok = yes; then
11460     # An in-tree tool is available and we can use it
11461     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11462     echo "$as_me:$LINENO: result: just compiled" >&5
11463 echo "${ECHO_T}just compiled" >&6
11464   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11465     # We already found the complete path
11466     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11467     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11468 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11469   elif test "x$target" = "x$host"; then
11470     # We can use an host tool
11471     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11472     echo "$as_me:$LINENO: result: host tool" >&5
11473 echo "${ECHO_T}host tool" >&6
11474   else
11475     # We need a cross tool
11476     echo "$as_me:$LINENO: result: pre-installed" >&5
11477 echo "${ECHO_T}pre-installed" >&6
11478   fi
11479 fi
11480
11481 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11482 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11483 if test "x${build}" != "x${host}" ; then
11484   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11485     # We already found the complete path
11486     ac_dir=`dirname $GCC_FOR_TARGET`
11487     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11488 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11489   else
11490     # Canadian cross, just use what we found
11491     echo "$as_me:$LINENO: result: pre-installed" >&5
11492 echo "${ECHO_T}pre-installed" >&6
11493   fi
11494 else
11495   ok=yes
11496   case " ${configdirs} " in
11497     *" gcc "*) ;;
11498     *) ok=no ;;
11499   esac
11500
11501   if test $ok = yes; then
11502     # An in-tree tool is available and we can use it
11503     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11504     echo "$as_me:$LINENO: result: just compiled" >&5
11505 echo "${ECHO_T}just compiled" >&6
11506   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11507     # We already found the complete path
11508     ac_dir=`dirname $GCC_FOR_TARGET`
11509     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11510 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11511   elif test "x$target" = "x$host"; then
11512     # We can use an host tool
11513     GCC_FOR_TARGET='$()'
11514     echo "$as_me:$LINENO: result: host tool" >&5
11515 echo "${ECHO_T}host tool" >&6
11516   else
11517     # We need a cross tool
11518     echo "$as_me:$LINENO: result: pre-installed" >&5
11519 echo "${ECHO_T}pre-installed" >&6
11520   fi
11521 fi
11522
11523 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11524 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11525 if test "x${build}" != "x${host}" ; then
11526   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11527     # We already found the complete path
11528     ac_dir=`dirname $GCJ_FOR_TARGET`
11529     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11530 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11531   else
11532     # Canadian cross, just use what we found
11533     echo "$as_me:$LINENO: result: pre-installed" >&5
11534 echo "${ECHO_T}pre-installed" >&6
11535   fi
11536 else
11537   ok=yes
11538   case " ${configdirs} " in
11539     *" gcc "*) ;;
11540     *) ok=no ;;
11541   esac
11542   case ,${enable_languages}, in
11543     *,java,*) ;;
11544     *) ok=no ;;
11545   esac
11546   if test $ok = yes; then
11547     # An in-tree tool is available and we can use it
11548     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11549     echo "$as_me:$LINENO: result: just compiled" >&5
11550 echo "${ECHO_T}just compiled" >&6
11551   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11552     # We already found the complete path
11553     ac_dir=`dirname $GCJ_FOR_TARGET`
11554     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11555 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11556   elif test "x$target" = "x$host"; then
11557     # We can use an host tool
11558     GCJ_FOR_TARGET='$(GCJ)'
11559     echo "$as_me:$LINENO: result: host tool" >&5
11560 echo "${ECHO_T}host tool" >&6
11561   else
11562     # We need a cross tool
11563     echo "$as_me:$LINENO: result: pre-installed" >&5
11564 echo "${ECHO_T}pre-installed" >&6
11565   fi
11566 fi
11567
11568 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11569 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11570 if test "x${build}" != "x${host}" ; then
11571   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11572     # We already found the complete path
11573     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11574     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11575 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11576   else
11577     # Canadian cross, just use what we found
11578     echo "$as_me:$LINENO: result: pre-installed" >&5
11579 echo "${ECHO_T}pre-installed" >&6
11580   fi
11581 else
11582   ok=yes
11583   case " ${configdirs} " in
11584     *" gcc "*) ;;
11585     *) ok=no ;;
11586   esac
11587   case ,${enable_languages}, in
11588     *,fortran,*) ;;
11589     *) ok=no ;;
11590   esac
11591   if test $ok = yes; then
11592     # An in-tree tool is available and we can use it
11593     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11594     echo "$as_me:$LINENO: result: just compiled" >&5
11595 echo "${ECHO_T}just compiled" >&6
11596   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11597     # We already found the complete path
11598     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11599     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11600 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11601   elif test "x$target" = "x$host"; then
11602     # We can use an host tool
11603     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11604     echo "$as_me:$LINENO: result: host tool" >&5
11605 echo "${ECHO_T}host tool" >&6
11606   else
11607     # We need a cross tool
11608     echo "$as_me:$LINENO: result: pre-installed" >&5
11609 echo "${ECHO_T}pre-installed" >&6
11610   fi
11611 fi
11612
11613 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11614 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11615 if test "x${build}" != "x${host}" ; then
11616   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11617     # We already found the complete path
11618     ac_dir=`dirname $LD_FOR_TARGET`
11619     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11620 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11621   else
11622     # Canadian cross, just use what we found
11623     echo "$as_me:$LINENO: result: pre-installed" >&5
11624 echo "${ECHO_T}pre-installed" >&6
11625   fi
11626 else
11627   ok=yes
11628   case " ${configdirs} " in
11629     *" ld "*) ;;
11630     *) ok=no ;;
11631   esac
11632
11633   if test $ok = yes; then
11634     # An in-tree tool is available and we can use it
11635     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11636     echo "$as_me:$LINENO: result: just compiled" >&5
11637 echo "${ECHO_T}just compiled" >&6
11638   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11639     # We already found the complete path
11640     ac_dir=`dirname $LD_FOR_TARGET`
11641     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11642 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11643   elif test "x$target" = "x$host"; then
11644     # We can use an host tool
11645     LD_FOR_TARGET='$(LD)'
11646     echo "$as_me:$LINENO: result: host tool" >&5
11647 echo "${ECHO_T}host tool" >&6
11648   else
11649     # We need a cross tool
11650     echo "$as_me:$LINENO: result: pre-installed" >&5
11651 echo "${ECHO_T}pre-installed" >&6
11652   fi
11653 fi
11654
11655 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11656 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11657 if test "x${build}" != "x${host}" ; then
11658   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11659     # We already found the complete path
11660     ac_dir=`dirname $LIPO_FOR_TARGET`
11661     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11662 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11663   else
11664     # Canadian cross, just use what we found
11665     echo "$as_me:$LINENO: result: pre-installed" >&5
11666 echo "${ECHO_T}pre-installed" >&6
11667   fi
11668 else
11669   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11670     # We already found the complete path
11671     ac_dir=`dirname $LIPO_FOR_TARGET`
11672     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11673 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11674   elif test "x$target" = "x$host"; then
11675     # We can use an host tool
11676     LIPO_FOR_TARGET='$(LIPO)'
11677     echo "$as_me:$LINENO: result: host tool" >&5
11678 echo "${ECHO_T}host tool" >&6
11679   else
11680     # We need a cross tool
11681     echo "$as_me:$LINENO: result: pre-installed" >&5
11682 echo "${ECHO_T}pre-installed" >&6
11683   fi
11684 fi
11685
11686 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11687 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11688 if test "x${build}" != "x${host}" ; then
11689   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11690     # We already found the complete path
11691     ac_dir=`dirname $NM_FOR_TARGET`
11692     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11693 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11694   else
11695     # Canadian cross, just use what we found
11696     echo "$as_me:$LINENO: result: pre-installed" >&5
11697 echo "${ECHO_T}pre-installed" >&6
11698   fi
11699 else
11700   ok=yes
11701   case " ${configdirs} " in
11702     *" binutils "*) ;;
11703     *) ok=no ;;
11704   esac
11705
11706   if test $ok = yes; then
11707     # An in-tree tool is available and we can use it
11708     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11709     echo "$as_me:$LINENO: result: just compiled" >&5
11710 echo "${ECHO_T}just compiled" >&6
11711   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11712     # We already found the complete path
11713     ac_dir=`dirname $NM_FOR_TARGET`
11714     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11715 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11716   elif test "x$target" = "x$host"; then
11717     # We can use an host tool
11718     NM_FOR_TARGET='$(NM)'
11719     echo "$as_me:$LINENO: result: host tool" >&5
11720 echo "${ECHO_T}host tool" >&6
11721   else
11722     # We need a cross tool
11723     echo "$as_me:$LINENO: result: pre-installed" >&5
11724 echo "${ECHO_T}pre-installed" >&6
11725   fi
11726 fi
11727
11728 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11729 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11730 if test "x${build}" != "x${host}" ; then
11731   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11732     # We already found the complete path
11733     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11734     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11735 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11736   else
11737     # Canadian cross, just use what we found
11738     echo "$as_me:$LINENO: result: pre-installed" >&5
11739 echo "${ECHO_T}pre-installed" >&6
11740   fi
11741 else
11742   ok=yes
11743   case " ${configdirs} " in
11744     *" binutils "*) ;;
11745     *) ok=no ;;
11746   esac
11747
11748   if test $ok = yes; then
11749     # An in-tree tool is available and we can use it
11750     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11751     echo "$as_me:$LINENO: result: just compiled" >&5
11752 echo "${ECHO_T}just compiled" >&6
11753   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11754     # We already found the complete path
11755     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11756     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11757 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11758   elif test "x$target" = "x$host"; then
11759     # We can use an host tool
11760     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11761     echo "$as_me:$LINENO: result: host tool" >&5
11762 echo "${ECHO_T}host tool" >&6
11763   else
11764     # We need a cross tool
11765     echo "$as_me:$LINENO: result: pre-installed" >&5
11766 echo "${ECHO_T}pre-installed" >&6
11767   fi
11768 fi
11769
11770 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11771 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11772 if test "x${build}" != "x${host}" ; then
11773   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11774     # We already found the complete path
11775     ac_dir=`dirname $RANLIB_FOR_TARGET`
11776     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11777 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11778   else
11779     # Canadian cross, just use what we found
11780     echo "$as_me:$LINENO: result: pre-installed" >&5
11781 echo "${ECHO_T}pre-installed" >&6
11782   fi
11783 else
11784   ok=yes
11785   case " ${configdirs} " in
11786     *" binutils "*) ;;
11787     *) ok=no ;;
11788   esac
11789
11790   if test $ok = yes; then
11791     # An in-tree tool is available and we can use it
11792     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11793     echo "$as_me:$LINENO: result: just compiled" >&5
11794 echo "${ECHO_T}just compiled" >&6
11795   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11796     # We already found the complete path
11797     ac_dir=`dirname $RANLIB_FOR_TARGET`
11798     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11799 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11800   elif test "x$target" = "x$host"; then
11801     # We can use an host tool
11802     RANLIB_FOR_TARGET='$(RANLIB)'
11803     echo "$as_me:$LINENO: result: host tool" >&5
11804 echo "${ECHO_T}host tool" >&6
11805   else
11806     # We need a cross tool
11807     echo "$as_me:$LINENO: result: pre-installed" >&5
11808 echo "${ECHO_T}pre-installed" >&6
11809   fi
11810 fi
11811
11812 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11813 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11814 if test "x${build}" != "x${host}" ; then
11815   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11816     # We already found the complete path
11817     ac_dir=`dirname $STRIP_FOR_TARGET`
11818     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11819 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11820   else
11821     # Canadian cross, just use what we found
11822     echo "$as_me:$LINENO: result: pre-installed" >&5
11823 echo "${ECHO_T}pre-installed" >&6
11824   fi
11825 else
11826   ok=yes
11827   case " ${configdirs} " in
11828     *" binutils "*) ;;
11829     *) ok=no ;;
11830   esac
11831
11832   if test $ok = yes; then
11833     # An in-tree tool is available and we can use it
11834     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11835     echo "$as_me:$LINENO: result: just compiled" >&5
11836 echo "${ECHO_T}just compiled" >&6
11837   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11838     # We already found the complete path
11839     ac_dir=`dirname $STRIP_FOR_TARGET`
11840     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11841 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11842   elif test "x$target" = "x$host"; then
11843     # We can use an host tool
11844     STRIP_FOR_TARGET='$(STRIP)'
11845     echo "$as_me:$LINENO: result: host tool" >&5
11846 echo "${ECHO_T}host tool" >&6
11847   else
11848     # We need a cross tool
11849     echo "$as_me:$LINENO: result: pre-installed" >&5
11850 echo "${ECHO_T}pre-installed" >&6
11851   fi
11852 fi
11853
11854 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11855 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11856 if test "x${build}" != "x${host}" ; then
11857   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11858     # We already found the complete path
11859     ac_dir=`dirname $WINDRES_FOR_TARGET`
11860     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11861 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11862   else
11863     # Canadian cross, just use what we found
11864     echo "$as_me:$LINENO: result: pre-installed" >&5
11865 echo "${ECHO_T}pre-installed" >&6
11866   fi
11867 else
11868   ok=yes
11869   case " ${configdirs} " in
11870     *" binutils "*) ;;
11871     *) ok=no ;;
11872   esac
11873
11874   if test $ok = yes; then
11875     # An in-tree tool is available and we can use it
11876     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11877     echo "$as_me:$LINENO: result: just compiled" >&5
11878 echo "${ECHO_T}just compiled" >&6
11879   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11880     # We already found the complete path
11881     ac_dir=`dirname $WINDRES_FOR_TARGET`
11882     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11883 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11884   elif test "x$target" = "x$host"; then
11885     # We can use an host tool
11886     WINDRES_FOR_TARGET='$(WINDRES)'
11887     echo "$as_me:$LINENO: result: host tool" >&5
11888 echo "${ECHO_T}host tool" >&6
11889   else
11890     # We need a cross tool
11891     echo "$as_me:$LINENO: result: pre-installed" >&5
11892 echo "${ECHO_T}pre-installed" >&6
11893   fi
11894 fi
11895
11896 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
11897 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
11898 if test "x${build}" != "x${host}" ; then
11899   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11900     # We already found the complete path
11901     ac_dir=`dirname $WINDMC_FOR_TARGET`
11902     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11903 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11904   else
11905     # Canadian cross, just use what we found
11906     echo "$as_me:$LINENO: result: pre-installed" >&5
11907 echo "${ECHO_T}pre-installed" >&6
11908   fi
11909 else
11910   ok=yes
11911   case " ${configdirs} " in
11912     *" binutils "*) ;;
11913     *) ok=no ;;
11914   esac
11915
11916   if test $ok = yes; then
11917     # An in-tree tool is available and we can use it
11918     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
11919     echo "$as_me:$LINENO: result: just compiled" >&5
11920 echo "${ECHO_T}just compiled" >&6
11921   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11922     # We already found the complete path
11923     ac_dir=`dirname $WINDMC_FOR_TARGET`
11924     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11925 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11926   elif test "x$target" = "x$host"; then
11927     # We can use an host tool
11928     WINDMC_FOR_TARGET='$(WINDMC)'
11929     echo "$as_me:$LINENO: result: host tool" >&5
11930 echo "${ECHO_T}host tool" >&6
11931   else
11932     # We need a cross tool
11933     echo "$as_me:$LINENO: result: pre-installed" >&5
11934 echo "${ECHO_T}pre-installed" >&6
11935   fi
11936 fi
11937
11938
11939
11940
11941
11942 # Certain tools may need extra flags.
11943 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11944 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11945 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11946
11947 # When building target libraries, except in a Canadian cross, we use
11948 # the same toolchain as the compiler we just built.
11949 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11950 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11951 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11952 if test $host = $build; then
11953   case " $configdirs " in
11954     *" gcc "*)
11955       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11956       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11957       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11958       ;;
11959   esac
11960 fi
11961
11962
11963
11964
11965
11966 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
11967 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
11968 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
11969 if test "${enable_maintainer_mode+set}" = set; then
11970   enableval="$enable_maintainer_mode"
11971   USE_MAINTAINER_MODE=$enableval
11972 else
11973   USE_MAINTAINER_MODE=no
11974 fi;
11975 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
11976 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
11977
11978
11979 if test "$USE_MAINTAINER_MODE" = yes; then
11980   MAINTAINER_MODE_TRUE=
11981   MAINTAINER_MODE_FALSE='#'
11982 else
11983   MAINTAINER_MODE_TRUE='#'
11984   MAINTAINER_MODE_FALSE=
11985 fi
11986 MAINT=$MAINTAINER_MODE_TRUE
11987
11988 # ---------------------
11989 # GCC bootstrap support
11990 # ---------------------
11991
11992 # Stage specific cflags for build.
11993 stage1_cflags="-g"
11994 case $build in
11995   vax-*-*)
11996     case ${GCC} in
11997       yes) stage1_cflags="-g -Wa,-J" ;;
11998       *) stage1_cflags="-g -J" ;;
11999     esac ;;
12000 esac
12001
12002 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12003 if test "$GCC" = yes; then
12004   saved_CFLAGS="$CFLAGS"
12005
12006   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12007   CFLAGS="$CFLAGS -fkeep-inline-functions"
12008   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12009 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12010   cat >conftest.$ac_ext <<_ACEOF
12011 /* confdefs.h.  */
12012 _ACEOF
12013 cat confdefs.h >>conftest.$ac_ext
12014 cat >>conftest.$ac_ext <<_ACEOF
12015 /* end confdefs.h.  */
12016
12017 #if (__GNUC__ < 3) \
12018     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12019                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12020 #error http://gcc.gnu.org/PR29382
12021 #endif
12022
12023 int
12024 main ()
12025 {
12026
12027   ;
12028   return 0;
12029 }
12030 _ACEOF
12031 rm -f conftest.$ac_objext
12032 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12033   (eval $ac_compile) 2>conftest.er1
12034   ac_status=$?
12035   grep -v '^ *+' conftest.er1 >conftest.err
12036   rm -f conftest.er1
12037   cat conftest.err >&5
12038   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12039   (exit $ac_status); } &&
12040          { ac_try='test -z "$ac_c_werror_flag"
12041                          || test ! -s conftest.err'
12042   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12043   (eval $ac_try) 2>&5
12044   ac_status=$?
12045   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12046   (exit $ac_status); }; } &&
12047          { ac_try='test -s conftest.$ac_objext'
12048   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12049   (eval $ac_try) 2>&5
12050   ac_status=$?
12051   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12052   (exit $ac_status); }; }; then
12053   echo "$as_me:$LINENO: result: yes" >&5
12054 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12055 else
12056   echo "$as_me: failed program was:" >&5
12057 sed 's/^/| /' conftest.$ac_ext >&5
12058
12059 echo "$as_me:$LINENO: result: no" >&5
12060 echo "${ECHO_T}no" >&6
12061 fi
12062 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12063
12064   CFLAGS="$saved_CFLAGS"
12065 fi
12066
12067
12068
12069 # Enable --enable-checking in stage1 of the compiler.
12070 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12071 if test "${enable_stage1_checking+set}" = set; then
12072   enableval="$enable_stage1_checking"
12073   stage1_checking=--enable-checking=${enable_stage1_checking}
12074 else
12075   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12076   stage1_checking=--enable-checking=yes,types
12077 else
12078   stage1_checking=--enable-checking=$enable_checking,types
12079 fi
12080 fi;
12081
12082
12083 # Enable -Werror in bootstrap stage2 and later.
12084 # Check whether --enable-werror or --disable-werror was given.
12085 if test "${enable_werror+set}" = set; then
12086   enableval="$enable_werror"
12087
12088 else
12089   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12090   enable_werror=yes
12091 else
12092   enable_werror=no
12093 fi
12094 fi;
12095 case ${enable_werror} in
12096   yes) stage2_werror_flag="--enable-werror-always" ;;
12097   *) stage2_werror_flag="" ;;
12098 esac
12099
12100
12101 # Flags needed to enable html installing and building
12102
12103 # Check whether --with-datarootdir or --without-datarootdir was given.
12104 if test "${with_datarootdir+set}" = set; then
12105   withval="$with_datarootdir"
12106   datarootdir="\${prefix}/${withval}"
12107 else
12108   datarootdir="\${prefix}/share"
12109 fi;
12110
12111
12112 # Check whether --with-docdir or --without-docdir was given.
12113 if test "${with_docdir+set}" = set; then
12114   withval="$with_docdir"
12115   docdir="\${prefix}/${withval}"
12116 else
12117   docdir="\${datarootdir}/doc"
12118 fi;
12119
12120
12121 # Check whether --with-pdfdir or --without-pdfdir was given.
12122 if test "${with_pdfdir+set}" = set; then
12123   withval="$with_pdfdir"
12124   pdfdir="\${prefix}/${withval}"
12125 else
12126   pdfdir="\${docdir}"
12127 fi;
12128
12129
12130 # Check whether --with-htmldir or --without-htmldir was given.
12131 if test "${with_htmldir+set}" = set; then
12132   withval="$with_htmldir"
12133   htmldir="\${prefix}/${withval}"
12134 else
12135   htmldir="\${docdir}"
12136 fi;
12137
12138
12139
12140
12141
12142
12143           ac_config_files="$ac_config_files Makefile"
12144 cat >confcache <<\_ACEOF
12145 # This file is a shell script that caches the results of configure
12146 # tests run on this system so they can be shared between configure
12147 # scripts and configure runs, see configure's option --config-cache.
12148 # It is not useful on other systems.  If it contains results you don't
12149 # want to keep, you may remove or edit it.
12150 #
12151 # config.status only pays attention to the cache file if you give it
12152 # the --recheck option to rerun configure.
12153 #
12154 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12155 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12156 # following values.
12157
12158 _ACEOF
12159
12160 # The following way of writing the cache mishandles newlines in values,
12161 # but we know of no workaround that is simple, portable, and efficient.
12162 # So, don't put newlines in cache variables' values.
12163 # Ultrix sh set writes to stderr and can't be redirected directly,
12164 # and sets the high bit in the cache file unless we assign to the vars.
12165 {
12166   (set) 2>&1 |
12167     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12168     *ac_space=\ *)
12169       # `set' does not quote correctly, so add quotes (double-quote
12170       # substitution turns \\\\ into \\, and sed turns \\ into \).
12171       sed -n \
12172         "s/'/'\\\\''/g;
12173           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12174       ;;
12175     *)
12176       # `set' quotes correctly as required by POSIX, so do not add quotes.
12177       sed -n \
12178         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12179       ;;
12180     esac;
12181 } |
12182   sed '
12183      t clear
12184      : clear
12185      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12186      t end
12187      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12188      : end' >>confcache
12189 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12190   if test -w $cache_file; then
12191     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12192     cat confcache >$cache_file
12193   else
12194     echo "not updating unwritable cache $cache_file"
12195   fi
12196 fi
12197 rm -f confcache
12198
12199 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12200 # Let make expand exec_prefix.
12201 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12202
12203 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12204 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12205 # trailing colons and then remove the whole line if VPATH becomes empty
12206 # (actually we leave an empty line to preserve line numbers).
12207 if test "x$srcdir" = x.; then
12208   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12209 s/:*\$(srcdir):*/:/;
12210 s/:*\${srcdir}:*/:/;
12211 s/:*@srcdir@:*/:/;
12212 s/^\([^=]*=[     ]*\):*/\1/;
12213 s/:*$//;
12214 s/^[^=]*=[       ]*$//;
12215 }'
12216 fi
12217
12218 # Transform confdefs.h into DEFS.
12219 # Protect against shell expansion while executing Makefile rules.
12220 # Protect against Makefile macro expansion.
12221 #
12222 # If the first sed substitution is executed (which looks for macros that
12223 # take arguments), then we branch to the quote section.  Otherwise,
12224 # look for a macro that doesn't take arguments.
12225 cat >confdef2opt.sed <<\_ACEOF
12226 t clear
12227 : clear
12228 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12229 t quote
12230 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12231 t quote
12232 d
12233 : quote
12234 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12235 s,\[,\\&,g
12236 s,\],\\&,g
12237 s,\$,$$,g
12238 p
12239 _ACEOF
12240 # We use echo to avoid assuming a particular line-breaking character.
12241 # The extra dot is to prevent the shell from consuming trailing
12242 # line-breaks from the sub-command output.  A line-break within
12243 # single-quotes doesn't work because, if this script is created in a
12244 # platform that uses two characters for line-breaks (e.g., DOS), tr
12245 # would break.
12246 ac_LF_and_DOT=`echo; echo .`
12247 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12248 rm -f confdef2opt.sed
12249
12250
12251 ac_libobjs=
12252 ac_ltlibobjs=
12253 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12254   # 1. Remove the extension, and $U if already installed.
12255   ac_i=`echo "$ac_i" |
12256          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12257   # 2. Add them.
12258   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12259   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12260 done
12261 LIBOBJS=$ac_libobjs
12262
12263 LTLIBOBJS=$ac_ltlibobjs
12264
12265
12266
12267 : ${CONFIG_STATUS=./config.status}
12268 ac_clean_files_save=$ac_clean_files
12269 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12270 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12271 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12272 cat >$CONFIG_STATUS <<_ACEOF
12273 #! $SHELL
12274 # Generated by $as_me.
12275 # Run this file to recreate the current configuration.
12276 # Compiler output produced by configure, useful for debugging
12277 # configure, is in config.log if it exists.
12278
12279 debug=false
12280 ac_cs_recheck=false
12281 ac_cs_silent=false
12282 SHELL=\${CONFIG_SHELL-$SHELL}
12283 _ACEOF
12284
12285 cat >>$CONFIG_STATUS <<\_ACEOF
12286 ## --------------------- ##
12287 ## M4sh Initialization.  ##
12288 ## --------------------- ##
12289
12290 # Be Bourne compatible
12291 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12292   emulate sh
12293   NULLCMD=:
12294   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12295   # is contrary to our usage.  Disable this feature.
12296   alias -g '${1+"$@"}'='"$@"'
12297 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12298   set -o posix
12299 fi
12300 DUALCASE=1; export DUALCASE # for MKS sh
12301
12302 # Support unset when possible.
12303 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12304   as_unset=unset
12305 else
12306   as_unset=false
12307 fi
12308
12309
12310 # Work around bugs in pre-3.0 UWIN ksh.
12311 $as_unset ENV MAIL MAILPATH
12312 PS1='$ '
12313 PS2='> '
12314 PS4='+ '
12315
12316 # NLS nuisances.
12317 for as_var in \
12318   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12319   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12320   LC_TELEPHONE LC_TIME
12321 do
12322   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12323     eval $as_var=C; export $as_var
12324   else
12325     $as_unset $as_var
12326   fi
12327 done
12328
12329 # Required to use basename.
12330 if expr a : '\(a\)' >/dev/null 2>&1; then
12331   as_expr=expr
12332 else
12333   as_expr=false
12334 fi
12335
12336 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12337   as_basename=basename
12338 else
12339   as_basename=false
12340 fi
12341
12342
12343 # Name of the executable.
12344 as_me=`$as_basename "$0" ||
12345 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12346          X"$0" : 'X\(//\)$' \| \
12347          X"$0" : 'X\(/\)$' \| \
12348          .     : '\(.\)' 2>/dev/null ||
12349 echo X/"$0" |
12350     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12351           /^X\/\(\/\/\)$/{ s//\1/; q; }
12352           /^X\/\(\/\).*/{ s//\1/; q; }
12353           s/.*/./; q'`
12354
12355
12356 # PATH needs CR, and LINENO needs CR and PATH.
12357 # Avoid depending upon Character Ranges.
12358 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12359 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12360 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12361 as_cr_digits='0123456789'
12362 as_cr_alnum=$as_cr_Letters$as_cr_digits
12363
12364 # The user is always right.
12365 if test "${PATH_SEPARATOR+set}" != set; then
12366   echo "#! /bin/sh" >conf$$.sh
12367   echo  "exit 0"   >>conf$$.sh
12368   chmod +x conf$$.sh
12369   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12370     PATH_SEPARATOR=';'
12371   else
12372     PATH_SEPARATOR=:
12373   fi
12374   rm -f conf$$.sh
12375 fi
12376
12377
12378   as_lineno_1=$LINENO
12379   as_lineno_2=$LINENO
12380   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12381   test "x$as_lineno_1" != "x$as_lineno_2" &&
12382   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12383   # Find who we are.  Look in the path if we contain no path at all
12384   # relative or not.
12385   case $0 in
12386     *[\\/]* ) as_myself=$0 ;;
12387     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12388 for as_dir in $PATH
12389 do
12390   IFS=$as_save_IFS
12391   test -z "$as_dir" && as_dir=.
12392   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12393 done
12394
12395        ;;
12396   esac
12397   # We did not find ourselves, most probably we were run as `sh COMMAND'
12398   # in which case we are not to be found in the path.
12399   if test "x$as_myself" = x; then
12400     as_myself=$0
12401   fi
12402   if test ! -f "$as_myself"; then
12403     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12404 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12405    { (exit 1); exit 1; }; }
12406   fi
12407   case $CONFIG_SHELL in
12408   '')
12409     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12410 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12411 do
12412   IFS=$as_save_IFS
12413   test -z "$as_dir" && as_dir=.
12414   for as_base in sh bash ksh sh5; do
12415          case $as_dir in
12416          /*)
12417            if ("$as_dir/$as_base" -c '
12418   as_lineno_1=$LINENO
12419   as_lineno_2=$LINENO
12420   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12421   test "x$as_lineno_1" != "x$as_lineno_2" &&
12422   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12423              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12424              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12425              CONFIG_SHELL=$as_dir/$as_base
12426              export CONFIG_SHELL
12427              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12428            fi;;
12429          esac
12430        done
12431 done
12432 ;;
12433   esac
12434
12435   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12436   # uniformly replaced by the line number.  The first 'sed' inserts a
12437   # line-number line before each line; the second 'sed' does the real
12438   # work.  The second script uses 'N' to pair each line-number line
12439   # with the numbered line, and appends trailing '-' during
12440   # substitution so that $LINENO is not a special case at line end.
12441   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12442   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12443   sed '=' <$as_myself |
12444     sed '
12445       N
12446       s,$,-,
12447       : loop
12448       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12449       t loop
12450       s,-$,,
12451       s,^['$as_cr_digits']*\n,,
12452     ' >$as_me.lineno &&
12453   chmod +x $as_me.lineno ||
12454     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12455 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12456    { (exit 1); exit 1; }; }
12457
12458   # Don't try to exec as it changes $[0], causing all sort of problems
12459   # (the dirname of $[0] is not the place where we might find the
12460   # original and so on.  Autoconf is especially sensible to this).
12461   . ./$as_me.lineno
12462   # Exit status is that of the last command.
12463   exit
12464 }
12465
12466
12467 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12468   *c*,-n*) ECHO_N= ECHO_C='
12469 ' ECHO_T='      ' ;;
12470   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12471   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12472 esac
12473
12474 if expr a : '\(a\)' >/dev/null 2>&1; then
12475   as_expr=expr
12476 else
12477   as_expr=false
12478 fi
12479
12480 rm -f conf$$ conf$$.exe conf$$.file
12481 echo >conf$$.file
12482 if ln -s conf$$.file conf$$ 2>/dev/null; then
12483   # We could just check for DJGPP; but this test a) works b) is more generic
12484   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12485   if test -f conf$$.exe; then
12486     # Don't use ln at all; we don't have any links
12487     as_ln_s='cp -p'
12488   else
12489     as_ln_s='ln -s'
12490   fi
12491 elif ln conf$$.file conf$$ 2>/dev/null; then
12492   as_ln_s=ln
12493 else
12494   as_ln_s='cp -p'
12495 fi
12496 rm -f conf$$ conf$$.exe conf$$.file
12497
12498 if mkdir -p . 2>/dev/null; then
12499   as_mkdir_p=:
12500 else
12501   test -d ./-p && rmdir ./-p
12502   as_mkdir_p=false
12503 fi
12504
12505 as_executable_p="test -f"
12506
12507 # Sed expression to map a string onto a valid CPP name.
12508 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12509
12510 # Sed expression to map a string onto a valid variable name.
12511 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12512
12513
12514 # IFS
12515 # We need space, tab and new line, in precisely that order.
12516 as_nl='
12517 '
12518 IFS="   $as_nl"
12519
12520 # CDPATH.
12521 $as_unset CDPATH
12522
12523 exec 6>&1
12524
12525 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12526 # report actual input values of CONFIG_FILES etc. instead of their
12527 # values after options handling.  Logging --version etc. is OK.
12528 exec 5>>config.log
12529 {
12530   echo
12531   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12532 ## Running $as_me. ##
12533 _ASBOX
12534 } >&5
12535 cat >&5 <<_CSEOF
12536
12537 This file was extended by $as_me, which was
12538 generated by GNU Autoconf 2.59.  Invocation command line was
12539
12540   CONFIG_FILES    = $CONFIG_FILES
12541   CONFIG_HEADERS  = $CONFIG_HEADERS
12542   CONFIG_LINKS    = $CONFIG_LINKS
12543   CONFIG_COMMANDS = $CONFIG_COMMANDS
12544   $ $0 $@
12545
12546 _CSEOF
12547 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12548 echo >&5
12549 _ACEOF
12550
12551 # Files that config.status was made for.
12552 if test -n "$ac_config_files"; then
12553   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12554 fi
12555
12556 if test -n "$ac_config_headers"; then
12557   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12558 fi
12559
12560 if test -n "$ac_config_links"; then
12561   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12562 fi
12563
12564 if test -n "$ac_config_commands"; then
12565   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12566 fi
12567
12568 cat >>$CONFIG_STATUS <<\_ACEOF
12569
12570 ac_cs_usage="\
12571 \`$as_me' instantiates files from templates according to the
12572 current configuration.
12573
12574 Usage: $0 [OPTIONS] [FILE]...
12575
12576   -h, --help       print this help, then exit
12577   -V, --version    print version number, then exit
12578   -q, --quiet      do not print progress messages
12579   -d, --debug      don't remove temporary files
12580       --recheck    update $as_me by reconfiguring in the same conditions
12581   --file=FILE[:TEMPLATE]
12582                    instantiate the configuration file FILE
12583
12584 Configuration files:
12585 $config_files
12586
12587 Report bugs to <bug-autoconf@gnu.org>."
12588 _ACEOF
12589
12590 cat >>$CONFIG_STATUS <<_ACEOF
12591 ac_cs_version="\\
12592 config.status
12593 configured by $0, generated by GNU Autoconf 2.59,
12594   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12595
12596 Copyright (C) 2003 Free Software Foundation, Inc.
12597 This config.status script is free software; the Free Software Foundation
12598 gives unlimited permission to copy, distribute and modify it."
12599 srcdir=$srcdir
12600 INSTALL="$INSTALL"
12601 _ACEOF
12602
12603 cat >>$CONFIG_STATUS <<\_ACEOF
12604 # If no file are specified by the user, then we need to provide default
12605 # value.  By we need to know if files were specified by the user.
12606 ac_need_defaults=:
12607 while test $# != 0
12608 do
12609   case $1 in
12610   --*=*)
12611     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12612     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12613     ac_shift=:
12614     ;;
12615   -*)
12616     ac_option=$1
12617     ac_optarg=$2
12618     ac_shift=shift
12619     ;;
12620   *) # This is not an option, so the user has probably given explicit
12621      # arguments.
12622      ac_option=$1
12623      ac_need_defaults=false;;
12624   esac
12625
12626   case $ac_option in
12627   # Handling of the options.
12628 _ACEOF
12629 cat >>$CONFIG_STATUS <<\_ACEOF
12630   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12631     ac_cs_recheck=: ;;
12632   --version | --vers* | -V )
12633     echo "$ac_cs_version"; exit 0 ;;
12634   --he | --h)
12635     # Conflict between --help and --header
12636     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12637 Try \`$0 --help' for more information." >&5
12638 echo "$as_me: error: ambiguous option: $1
12639 Try \`$0 --help' for more information." >&2;}
12640    { (exit 1); exit 1; }; };;
12641   --help | --hel | -h )
12642     echo "$ac_cs_usage"; exit 0 ;;
12643   --debug | --d* | -d )
12644     debug=: ;;
12645   --file | --fil | --fi | --f )
12646     $ac_shift
12647     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12648     ac_need_defaults=false;;
12649   --header | --heade | --head | --hea )
12650     $ac_shift
12651     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12652     ac_need_defaults=false;;
12653   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12654   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12655     ac_cs_silent=: ;;
12656
12657   # This is an error.
12658   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12659 Try \`$0 --help' for more information." >&5
12660 echo "$as_me: error: unrecognized option: $1
12661 Try \`$0 --help' for more information." >&2;}
12662    { (exit 1); exit 1; }; } ;;
12663
12664   *) ac_config_targets="$ac_config_targets $1" ;;
12665
12666   esac
12667   shift
12668 done
12669
12670 ac_configure_extra_args=
12671
12672 if $ac_cs_silent; then
12673   exec 6>/dev/null
12674   ac_configure_extra_args="$ac_configure_extra_args --silent"
12675 fi
12676
12677 _ACEOF
12678 cat >>$CONFIG_STATUS <<_ACEOF
12679 if \$ac_cs_recheck; then
12680   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12681   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12682 fi
12683
12684 _ACEOF
12685
12686
12687
12688
12689
12690 cat >>$CONFIG_STATUS <<\_ACEOF
12691 for ac_config_target in $ac_config_targets
12692 do
12693   case "$ac_config_target" in
12694   # Handling of arguments.
12695   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12696   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12697 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12698    { (exit 1); exit 1; }; };;
12699   esac
12700 done
12701
12702 # If the user did not use the arguments to specify the items to instantiate,
12703 # then the envvar interface is used.  Set only those that are not.
12704 # We use the long form for the default assignment because of an extremely
12705 # bizarre bug on SunOS 4.1.3.
12706 if $ac_need_defaults; then
12707   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12708 fi
12709
12710 # Have a temporary directory for convenience.  Make it in the build tree
12711 # simply because there is no reason to put it here, and in addition,
12712 # creating and moving files from /tmp can sometimes cause problems.
12713 # Create a temporary directory, and hook for its removal unless debugging.
12714 $debug ||
12715 {
12716   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12717   trap '{ (exit 1); exit 1; }' 1 2 13 15
12718 }
12719
12720 # Create a (secure) tmp directory for tmp files.
12721
12722 {
12723   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12724   test -n "$tmp" && test -d "$tmp"
12725 }  ||
12726 {
12727   tmp=./confstat$$-$RANDOM
12728   (umask 077 && mkdir $tmp)
12729 } ||
12730 {
12731    echo "$me: cannot create a temporary directory in ." >&2
12732    { (exit 1); exit 1; }
12733 }
12734
12735 _ACEOF
12736
12737 cat >>$CONFIG_STATUS <<_ACEOF
12738
12739 #
12740 # CONFIG_FILES section.
12741 #
12742
12743 # No need to generate the scripts if there are no CONFIG_FILES.
12744 # This happens for instance when ./config.status config.h
12745 if test -n "\$CONFIG_FILES"; then
12746   # Protect against being on the right side of a sed subst in config.status.
12747   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12748    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12749 s,@SHELL@,$SHELL,;t t
12750 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12751 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12752 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12753 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12754 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12755 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12756 s,@exec_prefix@,$exec_prefix,;t t
12757 s,@prefix@,$prefix,;t t
12758 s,@program_transform_name@,$program_transform_name,;t t
12759 s,@bindir@,$bindir,;t t
12760 s,@sbindir@,$sbindir,;t t
12761 s,@libexecdir@,$libexecdir,;t t
12762 s,@datadir@,$datadir,;t t
12763 s,@sysconfdir@,$sysconfdir,;t t
12764 s,@sharedstatedir@,$sharedstatedir,;t t
12765 s,@localstatedir@,$localstatedir,;t t
12766 s,@libdir@,$libdir,;t t
12767 s,@includedir@,$includedir,;t t
12768 s,@oldincludedir@,$oldincludedir,;t t
12769 s,@infodir@,$infodir,;t t
12770 s,@mandir@,$mandir,;t t
12771 s,@build_alias@,$build_alias,;t t
12772 s,@host_alias@,$host_alias,;t t
12773 s,@target_alias@,$target_alias,;t t
12774 s,@DEFS@,$DEFS,;t t
12775 s,@ECHO_C@,$ECHO_C,;t t
12776 s,@ECHO_N@,$ECHO_N,;t t
12777 s,@ECHO_T@,$ECHO_T,;t t
12778 s,@LIBS@,$LIBS,;t t
12779 s,@build@,$build,;t t
12780 s,@build_cpu@,$build_cpu,;t t
12781 s,@build_vendor@,$build_vendor,;t t
12782 s,@build_os@,$build_os,;t t
12783 s,@build_noncanonical@,$build_noncanonical,;t t
12784 s,@host_noncanonical@,$host_noncanonical,;t t
12785 s,@target_noncanonical@,$target_noncanonical,;t t
12786 s,@host@,$host,;t t
12787 s,@host_cpu@,$host_cpu,;t t
12788 s,@host_vendor@,$host_vendor,;t t
12789 s,@host_os@,$host_os,;t t
12790 s,@target@,$target,;t t
12791 s,@target_cpu@,$target_cpu,;t t
12792 s,@target_vendor@,$target_vendor,;t t
12793 s,@target_os@,$target_os,;t t
12794 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12795 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12796 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12797 s,@LN@,$LN,;t t
12798 s,@LN_S@,$LN_S,;t t
12799 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12800 s,@build_libsubdir@,$build_libsubdir,;t t
12801 s,@build_subdir@,$build_subdir,;t t
12802 s,@host_subdir@,$host_subdir,;t t
12803 s,@target_subdir@,$target_subdir,;t t
12804 s,@CC@,$CC,;t t
12805 s,@CFLAGS@,$CFLAGS,;t t
12806 s,@LDFLAGS@,$LDFLAGS,;t t
12807 s,@CPPFLAGS@,$CPPFLAGS,;t t
12808 s,@ac_ct_CC@,$ac_ct_CC,;t t
12809 s,@EXEEXT@,$EXEEXT,;t t
12810 s,@OBJEXT@,$OBJEXT,;t t
12811 s,@CXX@,$CXX,;t t
12812 s,@CXXFLAGS@,$CXXFLAGS,;t t
12813 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12814 s,@GNATBIND@,$GNATBIND,;t t
12815 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12816 s,@GNATMAKE@,$GNATMAKE,;t t
12817 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12818 s,@do_compare@,$do_compare,;t t
12819 s,@gmplibs@,$gmplibs,;t t
12820 s,@gmpinc@,$gmpinc,;t t
12821 s,@stage1_languages@,$stage1_languages,;t t
12822 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12823 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12824 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12825 s,@tooldir@,$tooldir,;t t
12826 s,@build_tooldir@,$build_tooldir,;t t
12827 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12828 s,@GDB_TK@,$GDB_TK,;t t
12829 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12830 s,@build_configargs@,$build_configargs,;t t
12831 s,@build_configdirs@,$build_configdirs,;t t
12832 s,@host_configargs@,$host_configargs,;t t
12833 s,@configdirs@,$configdirs,;t t
12834 s,@target_configargs@,$target_configargs,;t t
12835 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
12836 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
12837 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12838 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12839 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
12840 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
12841 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
12842 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
12843 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
12844 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
12845 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
12846 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
12847 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
12848 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
12849 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
12850 s,@config_shell@,$config_shell,;t t
12851 s,@YACC@,$YACC,;t t
12852 s,@BISON@,$BISON,;t t
12853 s,@M4@,$M4,;t t
12854 s,@LEX@,$LEX,;t t
12855 s,@FLEX@,$FLEX,;t t
12856 s,@MAKEINFO@,$MAKEINFO,;t t
12857 s,@EXPECT@,$EXPECT,;t t
12858 s,@RUNTEST@,$RUNTEST,;t t
12859 s,@AR@,$AR,;t t
12860 s,@AS@,$AS,;t t
12861 s,@DLLTOOL@,$DLLTOOL,;t t
12862 s,@LD@,$LD,;t t
12863 s,@LIPO@,$LIPO,;t t
12864 s,@NM@,$NM,;t t
12865 s,@RANLIB@,$RANLIB,;t t
12866 s,@STRIP@,$STRIP,;t t
12867 s,@WINDRES@,$WINDRES,;t t
12868 s,@WINDMC@,$WINDMC,;t t
12869 s,@OBJCOPY@,$OBJCOPY,;t t
12870 s,@OBJDUMP@,$OBJDUMP,;t t
12871 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12872 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12873 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12874 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12875 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12876 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12877 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12878 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12879 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12880 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12881 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12882 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12883 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12884 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12885 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12886 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
12887 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12888 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12889 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12890 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12891 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12892 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12893 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12894 s,@MAINT@,$MAINT,;t t
12895 s,@stage1_cflags@,$stage1_cflags,;t t
12896 s,@stage1_checking@,$stage1_checking,;t t
12897 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12898 s,@datarootdir@,$datarootdir,;t t
12899 s,@docdir@,$docdir,;t t
12900 s,@pdfdir@,$pdfdir,;t t
12901 s,@htmldir@,$htmldir,;t t
12902 s,@LIBOBJS@,$LIBOBJS,;t t
12903 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12904 /@serialization_dependencies@/r $serialization_dependencies
12905 s,@serialization_dependencies@,,;t t
12906 /@host_makefile_frag@/r $host_makefile_frag
12907 s,@host_makefile_frag@,,;t t
12908 /@target_makefile_frag@/r $target_makefile_frag
12909 s,@target_makefile_frag@,,;t t
12910 /@alphaieee_frag@/r $alphaieee_frag
12911 s,@alphaieee_frag@,,;t t
12912 /@ospace_frag@/r $ospace_frag
12913 s,@ospace_frag@,,;t t
12914 CEOF
12915
12916 _ACEOF
12917
12918   cat >>$CONFIG_STATUS <<\_ACEOF
12919   # Split the substitutions into bite-sized pieces for seds with
12920   # small command number limits, like on Digital OSF/1 and HP-UX.
12921   ac_max_sed_lines=48
12922   ac_sed_frag=1 # Number of current file.
12923   ac_beg=1 # First line for current file.
12924   ac_end=$ac_max_sed_lines # Line after last line for current file.
12925   ac_more_lines=:
12926   ac_sed_cmds=
12927   while $ac_more_lines; do
12928     if test $ac_beg -gt 1; then
12929       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12930     else
12931       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12932     fi
12933     if test ! -s $tmp/subs.frag; then
12934       ac_more_lines=false
12935     else
12936       # The purpose of the label and of the branching condition is to
12937       # speed up the sed processing (if there are no `@' at all, there
12938       # is no need to browse any of the substitutions).
12939       # These are the two extra sed commands mentioned above.
12940       (echo ':t
12941   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12942       if test -z "$ac_sed_cmds"; then
12943         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12944       else
12945         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12946       fi
12947       ac_sed_frag=`expr $ac_sed_frag + 1`
12948       ac_beg=$ac_end
12949       ac_end=`expr $ac_end + $ac_max_sed_lines`
12950     fi
12951   done
12952   if test -z "$ac_sed_cmds"; then
12953     ac_sed_cmds=cat
12954   fi
12955 fi # test -n "$CONFIG_FILES"
12956
12957 _ACEOF
12958 cat >>$CONFIG_STATUS <<\_ACEOF
12959 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12960   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12961   case $ac_file in
12962   - | *:- | *:-:* ) # input from stdin
12963         cat >$tmp/stdin
12964         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12965         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12966   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12967         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12968   * )   ac_file_in=$ac_file.in ;;
12969   esac
12970
12971   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
12972   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
12973 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12974          X"$ac_file" : 'X\(//\)[^/]' \| \
12975          X"$ac_file" : 'X\(//\)$' \| \
12976          X"$ac_file" : 'X\(/\)' \| \
12977          .     : '\(.\)' 2>/dev/null ||
12978 echo X"$ac_file" |
12979     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12980           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12981           /^X\(\/\/\)$/{ s//\1/; q; }
12982           /^X\(\/\).*/{ s//\1/; q; }
12983           s/.*/./; q'`
12984   { if $as_mkdir_p; then
12985     mkdir -p "$ac_dir"
12986   else
12987     as_dir="$ac_dir"
12988     as_dirs=
12989     while test ! -d "$as_dir"; do
12990       as_dirs="$as_dir $as_dirs"
12991       as_dir=`(dirname "$as_dir") 2>/dev/null ||
12992 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12993          X"$as_dir" : 'X\(//\)[^/]' \| \
12994          X"$as_dir" : 'X\(//\)$' \| \
12995          X"$as_dir" : 'X\(/\)' \| \
12996          .     : '\(.\)' 2>/dev/null ||
12997 echo X"$as_dir" |
12998     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12999           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13000           /^X\(\/\/\)$/{ s//\1/; q; }
13001           /^X\(\/\).*/{ s//\1/; q; }
13002           s/.*/./; q'`
13003     done
13004     test ! -n "$as_dirs" || mkdir $as_dirs
13005   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13006 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13007    { (exit 1); exit 1; }; }; }
13008
13009   ac_builddir=.
13010
13011 if test "$ac_dir" != .; then
13012   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13013   # A "../" for each directory in $ac_dir_suffix.
13014   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13015 else
13016   ac_dir_suffix= ac_top_builddir=
13017 fi
13018
13019 case $srcdir in
13020   .)  # No --srcdir option.  We are building in place.
13021     ac_srcdir=.
13022     if test -z "$ac_top_builddir"; then
13023        ac_top_srcdir=.
13024     else
13025        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13026     fi ;;
13027   [\\/]* | ?:[\\/]* )  # Absolute path.
13028     ac_srcdir=$srcdir$ac_dir_suffix;
13029     ac_top_srcdir=$srcdir ;;
13030   *) # Relative path.
13031     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13032     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13033 esac
13034
13035 # Do not use `cd foo && pwd` to compute absolute paths, because
13036 # the directories may not exist.
13037 case `pwd` in
13038 .) ac_abs_builddir="$ac_dir";;
13039 *)
13040   case "$ac_dir" in
13041   .) ac_abs_builddir=`pwd`;;
13042   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13043   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13044   esac;;
13045 esac
13046 case $ac_abs_builddir in
13047 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13048 *)
13049   case ${ac_top_builddir}. in
13050   .) ac_abs_top_builddir=$ac_abs_builddir;;
13051   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13052   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13053   esac;;
13054 esac
13055 case $ac_abs_builddir in
13056 .) ac_abs_srcdir=$ac_srcdir;;
13057 *)
13058   case $ac_srcdir in
13059   .) ac_abs_srcdir=$ac_abs_builddir;;
13060   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13061   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13062   esac;;
13063 esac
13064 case $ac_abs_builddir in
13065 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13066 *)
13067   case $ac_top_srcdir in
13068   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13069   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13070   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13071   esac;;
13072 esac
13073
13074
13075   case $INSTALL in
13076   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13077   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13078   esac
13079
13080   if test x"$ac_file" != x-; then
13081     { echo "$as_me:$LINENO: creating $ac_file" >&5
13082 echo "$as_me: creating $ac_file" >&6;}
13083     rm -f "$ac_file"
13084   fi
13085   # Let's still pretend it is `configure' which instantiates (i.e., don't
13086   # use $as_me), people would be surprised to read:
13087   #    /* config.h.  Generated by config.status.  */
13088   if test x"$ac_file" = x-; then
13089     configure_input=
13090   else
13091     configure_input="$ac_file.  "
13092   fi
13093   configure_input=$configure_input"Generated from `echo $ac_file_in |
13094                                      sed 's,.*/,,'` by configure."
13095
13096   # First look for the input files in the build tree, otherwise in the
13097   # src tree.
13098   ac_file_inputs=`IFS=:
13099     for f in $ac_file_in; do
13100       case $f in
13101       -) echo $tmp/stdin ;;
13102       [\\/$]*)
13103          # Absolute (can't be DOS-style, as IFS=:)
13104          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13105 echo "$as_me: error: cannot find input file: $f" >&2;}
13106    { (exit 1); exit 1; }; }
13107          echo "$f";;
13108       *) # Relative
13109          if test -f "$f"; then
13110            # Build tree
13111            echo "$f"
13112          elif test -f "$srcdir/$f"; then
13113            # Source tree
13114            echo "$srcdir/$f"
13115          else
13116            # /dev/null tree
13117            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13118 echo "$as_me: error: cannot find input file: $f" >&2;}
13119    { (exit 1); exit 1; }; }
13120          fi;;
13121       esac
13122     done` || { (exit 1); exit 1; }
13123 _ACEOF
13124 cat >>$CONFIG_STATUS <<_ACEOF
13125   sed "$ac_vpsub
13126 $extrasub
13127 _ACEOF
13128 cat >>$CONFIG_STATUS <<\_ACEOF
13129 :t
13130 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13131 s,@configure_input@,$configure_input,;t t
13132 s,@srcdir@,$ac_srcdir,;t t
13133 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13134 s,@top_srcdir@,$ac_top_srcdir,;t t
13135 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13136 s,@builddir@,$ac_builddir,;t t
13137 s,@abs_builddir@,$ac_abs_builddir,;t t
13138 s,@top_builddir@,$ac_top_builddir,;t t
13139 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13140 s,@INSTALL@,$ac_INSTALL,;t t
13141 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13142   rm -f $tmp/stdin
13143   if test x"$ac_file" != x-; then
13144     mv $tmp/out $ac_file
13145   else
13146     cat $tmp/out
13147     rm -f $tmp/out
13148   fi
13149
13150 done
13151 _ACEOF
13152
13153 cat >>$CONFIG_STATUS <<\_ACEOF
13154
13155 { (exit 0); exit 0; }
13156 _ACEOF
13157 chmod +x $CONFIG_STATUS
13158 ac_clean_files=$ac_clean_files_save
13159
13160
13161 # configure is writing to config.log, and then calls config.status.
13162 # config.status does its own redirection, appending to config.log.
13163 # Unfortunately, on DOS this fails, as config.log is still kept open
13164 # by configure, so config.status won't be able to write to it; its
13165 # output is simply discarded.  So we exec the FD to /dev/null,
13166 # effectively closing config.log, so it can be properly (re)opened and
13167 # appended to by config.status.  When coming back to configure, we
13168 # need to make the FD available again.
13169 if test "$no_create" != yes; then
13170   ac_cs_success=:
13171   ac_config_status_args=
13172   test "$silent" = yes &&
13173     ac_config_status_args="$ac_config_status_args --quiet"
13174   exec 5>/dev/null
13175   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13176   exec 5>>config.log
13177   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13178   # would make configure fail if this is the last instruction.
13179   $ac_cs_success || { (exit 1); exit 1; }
13180 fi
13181