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 CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5880 CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CFLAGS}}
5881 LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${CFLAGS}}
5882
5883 # On Canadian crosses, we'll be searching the right directories for
5884 # the previously-installed cross compiler, so don't bother to add
5885 # flags for directories within the install tree of the compiler
5886 # being built; programs in there won't even run.
5887 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5888   # Search for pre-installed headers if nothing else fits.
5889   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5890 fi
5891
5892 if test "x${use_gnu_ld}" = x &&
5893    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5894   # Arrange for us to find uninstalled linker scripts.
5895   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5896 fi
5897
5898 # Search for other target-specific linker scripts and such.
5899 case "${target}" in
5900   mep*)
5901     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5902     ;;
5903 esac
5904
5905 # Makefile fragments.
5906 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5907 do
5908   eval fragval=\$$frag
5909   if test $fragval != /dev/null; then
5910     eval $frag=${srcdir}/$fragval
5911   fi
5912 done
5913
5914
5915
5916
5917
5918 # Miscellanea: directories, flags, etc.
5919
5920
5921
5922
5923
5924
5925
5926 # Build module lists & subconfigure args.
5927
5928
5929
5930 # Host module lists & subconfigure args.
5931
5932
5933
5934 # Target module lists & subconfigure args.
5935
5936
5937
5938 # Build tools.
5939
5940
5941
5942
5943
5944
5945
5946
5947
5948
5949
5950
5951
5952
5953
5954
5955
5956 # Generate default definitions for YACC, M4, LEX and other programs that run
5957 # on the build machine.  These are used if the Makefile can't locate these
5958 # programs in objdir.
5959 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5960
5961 for ac_prog in 'bison -y' byacc yacc
5962 do
5963   # Extract the first word of "$ac_prog", so it can be a program name with args.
5964 set dummy $ac_prog; ac_word=$2
5965 echo "$as_me:$LINENO: checking for $ac_word" >&5
5966 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5967 if test "${ac_cv_prog_YACC+set}" = set; then
5968   echo $ECHO_N "(cached) $ECHO_C" >&6
5969 else
5970   if test -n "$YACC"; then
5971   ac_cv_prog_YACC="$YACC" # Let the user override the test.
5972 else
5973 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5974 for as_dir in $PATH
5975 do
5976   IFS=$as_save_IFS
5977   test -z "$as_dir" && as_dir=.
5978   for ac_exec_ext in '' $ac_executable_extensions; do
5979   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5980     ac_cv_prog_YACC="$ac_prog"
5981     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5982     break 2
5983   fi
5984 done
5985 done
5986
5987 fi
5988 fi
5989 YACC=$ac_cv_prog_YACC
5990 if test -n "$YACC"; then
5991   echo "$as_me:$LINENO: result: $YACC" >&5
5992 echo "${ECHO_T}$YACC" >&6
5993 else
5994   echo "$as_me:$LINENO: result: no" >&5
5995 echo "${ECHO_T}no" >&6
5996 fi
5997
5998   test -n "$YACC" && break
5999 done
6000 test -n "$YACC" || YACC="$MISSING bison -y"
6001
6002 case " $build_configdirs " in
6003   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6004   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6005 esac
6006
6007 for ac_prog in bison
6008 do
6009   # Extract the first word of "$ac_prog", so it can be a program name with args.
6010 set dummy $ac_prog; ac_word=$2
6011 echo "$as_me:$LINENO: checking for $ac_word" >&5
6012 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6013 if test "${ac_cv_prog_BISON+set}" = set; then
6014   echo $ECHO_N "(cached) $ECHO_C" >&6
6015 else
6016   if test -n "$BISON"; then
6017   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6018 else
6019 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6020 for as_dir in $PATH
6021 do
6022   IFS=$as_save_IFS
6023   test -z "$as_dir" && as_dir=.
6024   for ac_exec_ext in '' $ac_executable_extensions; do
6025   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6026     ac_cv_prog_BISON="$ac_prog"
6027     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6028     break 2
6029   fi
6030 done
6031 done
6032
6033 fi
6034 fi
6035 BISON=$ac_cv_prog_BISON
6036 if test -n "$BISON"; then
6037   echo "$as_me:$LINENO: result: $BISON" >&5
6038 echo "${ECHO_T}$BISON" >&6
6039 else
6040   echo "$as_me:$LINENO: result: no" >&5
6041 echo "${ECHO_T}no" >&6
6042 fi
6043
6044   test -n "$BISON" && break
6045 done
6046 test -n "$BISON" || BISON="$MISSING bison"
6047
6048 case " $build_configdirs " in
6049   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6050 esac
6051
6052 for ac_prog in gm4 gnum4 m4
6053 do
6054   # Extract the first word of "$ac_prog", so it can be a program name with args.
6055 set dummy $ac_prog; ac_word=$2
6056 echo "$as_me:$LINENO: checking for $ac_word" >&5
6057 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6058 if test "${ac_cv_prog_M4+set}" = set; then
6059   echo $ECHO_N "(cached) $ECHO_C" >&6
6060 else
6061   if test -n "$M4"; then
6062   ac_cv_prog_M4="$M4" # Let the user override the test.
6063 else
6064 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6065 for as_dir in $PATH
6066 do
6067   IFS=$as_save_IFS
6068   test -z "$as_dir" && as_dir=.
6069   for ac_exec_ext in '' $ac_executable_extensions; do
6070   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6071     ac_cv_prog_M4="$ac_prog"
6072     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6073     break 2
6074   fi
6075 done
6076 done
6077
6078 fi
6079 fi
6080 M4=$ac_cv_prog_M4
6081 if test -n "$M4"; then
6082   echo "$as_me:$LINENO: result: $M4" >&5
6083 echo "${ECHO_T}$M4" >&6
6084 else
6085   echo "$as_me:$LINENO: result: no" >&5
6086 echo "${ECHO_T}no" >&6
6087 fi
6088
6089   test -n "$M4" && break
6090 done
6091 test -n "$M4" || M4="$MISSING m4"
6092
6093 case " $build_configdirs " in
6094   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6095 esac
6096
6097 for ac_prog in flex lex
6098 do
6099   # Extract the first word of "$ac_prog", so it can be a program name with args.
6100 set dummy $ac_prog; ac_word=$2
6101 echo "$as_me:$LINENO: checking for $ac_word" >&5
6102 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6103 if test "${ac_cv_prog_LEX+set}" = set; then
6104   echo $ECHO_N "(cached) $ECHO_C" >&6
6105 else
6106   if test -n "$LEX"; then
6107   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6108 else
6109 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6110 for as_dir in $PATH
6111 do
6112   IFS=$as_save_IFS
6113   test -z "$as_dir" && as_dir=.
6114   for ac_exec_ext in '' $ac_executable_extensions; do
6115   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6116     ac_cv_prog_LEX="$ac_prog"
6117     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6118     break 2
6119   fi
6120 done
6121 done
6122
6123 fi
6124 fi
6125 LEX=$ac_cv_prog_LEX
6126 if test -n "$LEX"; then
6127   echo "$as_me:$LINENO: result: $LEX" >&5
6128 echo "${ECHO_T}$LEX" >&6
6129 else
6130   echo "$as_me:$LINENO: result: no" >&5
6131 echo "${ECHO_T}no" >&6
6132 fi
6133
6134   test -n "$LEX" && break
6135 done
6136 test -n "$LEX" || LEX="$MISSING flex"
6137
6138 case " $build_configdirs " in
6139   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6140   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6141 esac
6142
6143 for ac_prog in flex
6144 do
6145   # Extract the first word of "$ac_prog", so it can be a program name with args.
6146 set dummy $ac_prog; ac_word=$2
6147 echo "$as_me:$LINENO: checking for $ac_word" >&5
6148 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6149 if test "${ac_cv_prog_FLEX+set}" = set; then
6150   echo $ECHO_N "(cached) $ECHO_C" >&6
6151 else
6152   if test -n "$FLEX"; then
6153   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6154 else
6155 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6156 for as_dir in $PATH
6157 do
6158   IFS=$as_save_IFS
6159   test -z "$as_dir" && as_dir=.
6160   for ac_exec_ext in '' $ac_executable_extensions; do
6161   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6162     ac_cv_prog_FLEX="$ac_prog"
6163     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6164     break 2
6165   fi
6166 done
6167 done
6168
6169 fi
6170 fi
6171 FLEX=$ac_cv_prog_FLEX
6172 if test -n "$FLEX"; then
6173   echo "$as_me:$LINENO: result: $FLEX" >&5
6174 echo "${ECHO_T}$FLEX" >&6
6175 else
6176   echo "$as_me:$LINENO: result: no" >&5
6177 echo "${ECHO_T}no" >&6
6178 fi
6179
6180   test -n "$FLEX" && break
6181 done
6182 test -n "$FLEX" || FLEX="$MISSING flex"
6183
6184 case " $build_configdirs " in
6185   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6186 esac
6187
6188 for ac_prog in makeinfo
6189 do
6190   # Extract the first word of "$ac_prog", so it can be a program name with args.
6191 set dummy $ac_prog; ac_word=$2
6192 echo "$as_me:$LINENO: checking for $ac_word" >&5
6193 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6194 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6195   echo $ECHO_N "(cached) $ECHO_C" >&6
6196 else
6197   if test -n "$MAKEINFO"; then
6198   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6199 else
6200 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6201 for as_dir in $PATH
6202 do
6203   IFS=$as_save_IFS
6204   test -z "$as_dir" && as_dir=.
6205   for ac_exec_ext in '' $ac_executable_extensions; do
6206   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6207     ac_cv_prog_MAKEINFO="$ac_prog"
6208     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6209     break 2
6210   fi
6211 done
6212 done
6213
6214 fi
6215 fi
6216 MAKEINFO=$ac_cv_prog_MAKEINFO
6217 if test -n "$MAKEINFO"; then
6218   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6219 echo "${ECHO_T}$MAKEINFO" >&6
6220 else
6221   echo "$as_me:$LINENO: result: no" >&5
6222 echo "${ECHO_T}no" >&6
6223 fi
6224
6225   test -n "$MAKEINFO" && break
6226 done
6227 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6228
6229 case " $build_configdirs " in
6230   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6231   *)
6232
6233     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6234     # higher, else we use the "missing" dummy.
6235     if ${MAKEINFO} --version \
6236        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6237       :
6238     else
6239       MAKEINFO="$MISSING makeinfo"
6240     fi
6241     ;;
6242
6243 esac
6244
6245 # FIXME: expect and dejagnu may become build tools?
6246
6247 for ac_prog in expect
6248 do
6249   # Extract the first word of "$ac_prog", so it can be a program name with args.
6250 set dummy $ac_prog; ac_word=$2
6251 echo "$as_me:$LINENO: checking for $ac_word" >&5
6252 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6253 if test "${ac_cv_prog_EXPECT+set}" = set; then
6254   echo $ECHO_N "(cached) $ECHO_C" >&6
6255 else
6256   if test -n "$EXPECT"; then
6257   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6258 else
6259 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6260 for as_dir in $PATH
6261 do
6262   IFS=$as_save_IFS
6263   test -z "$as_dir" && as_dir=.
6264   for ac_exec_ext in '' $ac_executable_extensions; do
6265   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6266     ac_cv_prog_EXPECT="$ac_prog"
6267     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6268     break 2
6269   fi
6270 done
6271 done
6272
6273 fi
6274 fi
6275 EXPECT=$ac_cv_prog_EXPECT
6276 if test -n "$EXPECT"; then
6277   echo "$as_me:$LINENO: result: $EXPECT" >&5
6278 echo "${ECHO_T}$EXPECT" >&6
6279 else
6280   echo "$as_me:$LINENO: result: no" >&5
6281 echo "${ECHO_T}no" >&6
6282 fi
6283
6284   test -n "$EXPECT" && break
6285 done
6286 test -n "$EXPECT" || EXPECT="expect"
6287
6288 case " $configdirs " in
6289   *" expect "*)
6290     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6291     ;;
6292 esac
6293
6294 for ac_prog in runtest
6295 do
6296   # Extract the first word of "$ac_prog", so it can be a program name with args.
6297 set dummy $ac_prog; ac_word=$2
6298 echo "$as_me:$LINENO: checking for $ac_word" >&5
6299 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6300 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6301   echo $ECHO_N "(cached) $ECHO_C" >&6
6302 else
6303   if test -n "$RUNTEST"; then
6304   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6305 else
6306 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6307 for as_dir in $PATH
6308 do
6309   IFS=$as_save_IFS
6310   test -z "$as_dir" && as_dir=.
6311   for ac_exec_ext in '' $ac_executable_extensions; do
6312   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6313     ac_cv_prog_RUNTEST="$ac_prog"
6314     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6315     break 2
6316   fi
6317 done
6318 done
6319
6320 fi
6321 fi
6322 RUNTEST=$ac_cv_prog_RUNTEST
6323 if test -n "$RUNTEST"; then
6324   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6325 echo "${ECHO_T}$RUNTEST" >&6
6326 else
6327   echo "$as_me:$LINENO: result: no" >&5
6328 echo "${ECHO_T}no" >&6
6329 fi
6330
6331   test -n "$RUNTEST" && break
6332 done
6333 test -n "$RUNTEST" || RUNTEST="runtest"
6334
6335 case " $configdirs " in
6336   *" dejagnu "*)
6337     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6338     ;;
6339 esac
6340
6341
6342 # Host tools.
6343 ncn_tool_prefix=
6344 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6345 ncn_target_tool_prefix=
6346 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6347
6348
6349
6350 if test -n "$AR"; then
6351   ac_cv_prog_AR=$AR
6352 elif test -n "$ac_cv_prog_AR"; then
6353   AR=$ac_cv_prog_AR
6354 fi
6355
6356 if test -n "$ac_cv_prog_AR"; then
6357   for ncn_progname in ar; do
6358     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6359 set dummy ${ncn_progname}; ac_word=$2
6360 echo "$as_me:$LINENO: checking for $ac_word" >&5
6361 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6362 if test "${ac_cv_prog_AR+set}" = set; then
6363   echo $ECHO_N "(cached) $ECHO_C" >&6
6364 else
6365   if test -n "$AR"; then
6366   ac_cv_prog_AR="$AR" # Let the user override the test.
6367 else
6368 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6369 for as_dir in $PATH
6370 do
6371   IFS=$as_save_IFS
6372   test -z "$as_dir" && as_dir=.
6373   for ac_exec_ext in '' $ac_executable_extensions; do
6374   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6375     ac_cv_prog_AR="${ncn_progname}"
6376     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6377     break 2
6378   fi
6379 done
6380 done
6381
6382 fi
6383 fi
6384 AR=$ac_cv_prog_AR
6385 if test -n "$AR"; then
6386   echo "$as_me:$LINENO: result: $AR" >&5
6387 echo "${ECHO_T}$AR" >&6
6388 else
6389   echo "$as_me:$LINENO: result: no" >&5
6390 echo "${ECHO_T}no" >&6
6391 fi
6392
6393   done
6394 fi
6395
6396 for ncn_progname in ar; do
6397   if test -n "$ncn_tool_prefix"; then
6398     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6399 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6400 echo "$as_me:$LINENO: checking for $ac_word" >&5
6401 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6402 if test "${ac_cv_prog_AR+set}" = set; then
6403   echo $ECHO_N "(cached) $ECHO_C" >&6
6404 else
6405   if test -n "$AR"; then
6406   ac_cv_prog_AR="$AR" # Let the user override the test.
6407 else
6408 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6409 for as_dir in $PATH
6410 do
6411   IFS=$as_save_IFS
6412   test -z "$as_dir" && as_dir=.
6413   for ac_exec_ext in '' $ac_executable_extensions; do
6414   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6415     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6416     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6417     break 2
6418   fi
6419 done
6420 done
6421
6422 fi
6423 fi
6424 AR=$ac_cv_prog_AR
6425 if test -n "$AR"; then
6426   echo "$as_me:$LINENO: result: $AR" >&5
6427 echo "${ECHO_T}$AR" >&6
6428 else
6429   echo "$as_me:$LINENO: result: no" >&5
6430 echo "${ECHO_T}no" >&6
6431 fi
6432
6433   fi
6434   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6435     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6436 set dummy ${ncn_progname}; ac_word=$2
6437 echo "$as_me:$LINENO: checking for $ac_word" >&5
6438 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6439 if test "${ac_cv_prog_AR+set}" = set; then
6440   echo $ECHO_N "(cached) $ECHO_C" >&6
6441 else
6442   if test -n "$AR"; then
6443   ac_cv_prog_AR="$AR" # Let the user override the test.
6444 else
6445 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6446 for as_dir in $PATH
6447 do
6448   IFS=$as_save_IFS
6449   test -z "$as_dir" && as_dir=.
6450   for ac_exec_ext in '' $ac_executable_extensions; do
6451   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6452     ac_cv_prog_AR="${ncn_progname}"
6453     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6454     break 2
6455   fi
6456 done
6457 done
6458
6459 fi
6460 fi
6461 AR=$ac_cv_prog_AR
6462 if test -n "$AR"; then
6463   echo "$as_me:$LINENO: result: $AR" >&5
6464 echo "${ECHO_T}$AR" >&6
6465 else
6466   echo "$as_me:$LINENO: result: no" >&5
6467 echo "${ECHO_T}no" >&6
6468 fi
6469
6470   fi
6471   test -n "$ac_cv_prog_AR" && break
6472 done
6473
6474 if test -z "$ac_cv_prog_AR" ; then
6475   set dummy ar
6476   if test $build = $host ; then
6477     AR="$2"
6478   else
6479     AR="${ncn_tool_prefix}$2"
6480   fi
6481 fi
6482
6483
6484
6485 if test -n "$AS"; then
6486   ac_cv_prog_AS=$AS
6487 elif test -n "$ac_cv_prog_AS"; then
6488   AS=$ac_cv_prog_AS
6489 fi
6490
6491 if test -n "$ac_cv_prog_AS"; then
6492   for ncn_progname in as; do
6493     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6494 set dummy ${ncn_progname}; ac_word=$2
6495 echo "$as_me:$LINENO: checking for $ac_word" >&5
6496 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6497 if test "${ac_cv_prog_AS+set}" = set; then
6498   echo $ECHO_N "(cached) $ECHO_C" >&6
6499 else
6500   if test -n "$AS"; then
6501   ac_cv_prog_AS="$AS" # Let the user override the test.
6502 else
6503 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6504 for as_dir in $PATH
6505 do
6506   IFS=$as_save_IFS
6507   test -z "$as_dir" && as_dir=.
6508   for ac_exec_ext in '' $ac_executable_extensions; do
6509   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6510     ac_cv_prog_AS="${ncn_progname}"
6511     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6512     break 2
6513   fi
6514 done
6515 done
6516
6517 fi
6518 fi
6519 AS=$ac_cv_prog_AS
6520 if test -n "$AS"; then
6521   echo "$as_me:$LINENO: result: $AS" >&5
6522 echo "${ECHO_T}$AS" >&6
6523 else
6524   echo "$as_me:$LINENO: result: no" >&5
6525 echo "${ECHO_T}no" >&6
6526 fi
6527
6528   done
6529 fi
6530
6531 for ncn_progname in as; do
6532   if test -n "$ncn_tool_prefix"; then
6533     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6534 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6535 echo "$as_me:$LINENO: checking for $ac_word" >&5
6536 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6537 if test "${ac_cv_prog_AS+set}" = set; then
6538   echo $ECHO_N "(cached) $ECHO_C" >&6
6539 else
6540   if test -n "$AS"; then
6541   ac_cv_prog_AS="$AS" # Let the user override the test.
6542 else
6543 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6544 for as_dir in $PATH
6545 do
6546   IFS=$as_save_IFS
6547   test -z "$as_dir" && as_dir=.
6548   for ac_exec_ext in '' $ac_executable_extensions; do
6549   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6550     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6551     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6552     break 2
6553   fi
6554 done
6555 done
6556
6557 fi
6558 fi
6559 AS=$ac_cv_prog_AS
6560 if test -n "$AS"; then
6561   echo "$as_me:$LINENO: result: $AS" >&5
6562 echo "${ECHO_T}$AS" >&6
6563 else
6564   echo "$as_me:$LINENO: result: no" >&5
6565 echo "${ECHO_T}no" >&6
6566 fi
6567
6568   fi
6569   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6570     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6571 set dummy ${ncn_progname}; ac_word=$2
6572 echo "$as_me:$LINENO: checking for $ac_word" >&5
6573 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6574 if test "${ac_cv_prog_AS+set}" = set; then
6575   echo $ECHO_N "(cached) $ECHO_C" >&6
6576 else
6577   if test -n "$AS"; then
6578   ac_cv_prog_AS="$AS" # Let the user override the test.
6579 else
6580 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6581 for as_dir in $PATH
6582 do
6583   IFS=$as_save_IFS
6584   test -z "$as_dir" && as_dir=.
6585   for ac_exec_ext in '' $ac_executable_extensions; do
6586   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6587     ac_cv_prog_AS="${ncn_progname}"
6588     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6589     break 2
6590   fi
6591 done
6592 done
6593
6594 fi
6595 fi
6596 AS=$ac_cv_prog_AS
6597 if test -n "$AS"; then
6598   echo "$as_me:$LINENO: result: $AS" >&5
6599 echo "${ECHO_T}$AS" >&6
6600 else
6601   echo "$as_me:$LINENO: result: no" >&5
6602 echo "${ECHO_T}no" >&6
6603 fi
6604
6605   fi
6606   test -n "$ac_cv_prog_AS" && break
6607 done
6608
6609 if test -z "$ac_cv_prog_AS" ; then
6610   set dummy as
6611   if test $build = $host ; then
6612     AS="$2"
6613   else
6614     AS="${ncn_tool_prefix}$2"
6615   fi
6616 fi
6617
6618
6619
6620 if test -n "$DLLTOOL"; then
6621   ac_cv_prog_DLLTOOL=$DLLTOOL
6622 elif test -n "$ac_cv_prog_DLLTOOL"; then
6623   DLLTOOL=$ac_cv_prog_DLLTOOL
6624 fi
6625
6626 if test -n "$ac_cv_prog_DLLTOOL"; then
6627   for ncn_progname in dlltool; do
6628     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6629 set dummy ${ncn_progname}; ac_word=$2
6630 echo "$as_me:$LINENO: checking for $ac_word" >&5
6631 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6632 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6633   echo $ECHO_N "(cached) $ECHO_C" >&6
6634 else
6635   if test -n "$DLLTOOL"; then
6636   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6637 else
6638 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6639 for as_dir in $PATH
6640 do
6641   IFS=$as_save_IFS
6642   test -z "$as_dir" && as_dir=.
6643   for ac_exec_ext in '' $ac_executable_extensions; do
6644   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6645     ac_cv_prog_DLLTOOL="${ncn_progname}"
6646     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6647     break 2
6648   fi
6649 done
6650 done
6651
6652 fi
6653 fi
6654 DLLTOOL=$ac_cv_prog_DLLTOOL
6655 if test -n "$DLLTOOL"; then
6656   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6657 echo "${ECHO_T}$DLLTOOL" >&6
6658 else
6659   echo "$as_me:$LINENO: result: no" >&5
6660 echo "${ECHO_T}no" >&6
6661 fi
6662
6663   done
6664 fi
6665
6666 for ncn_progname in dlltool; do
6667   if test -n "$ncn_tool_prefix"; then
6668     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6669 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6670 echo "$as_me:$LINENO: checking for $ac_word" >&5
6671 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6672 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6673   echo $ECHO_N "(cached) $ECHO_C" >&6
6674 else
6675   if test -n "$DLLTOOL"; then
6676   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6677 else
6678 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6679 for as_dir in $PATH
6680 do
6681   IFS=$as_save_IFS
6682   test -z "$as_dir" && as_dir=.
6683   for ac_exec_ext in '' $ac_executable_extensions; do
6684   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6685     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6686     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6687     break 2
6688   fi
6689 done
6690 done
6691
6692 fi
6693 fi
6694 DLLTOOL=$ac_cv_prog_DLLTOOL
6695 if test -n "$DLLTOOL"; then
6696   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6697 echo "${ECHO_T}$DLLTOOL" >&6
6698 else
6699   echo "$as_me:$LINENO: result: no" >&5
6700 echo "${ECHO_T}no" >&6
6701 fi
6702
6703   fi
6704   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6705     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6706 set dummy ${ncn_progname}; ac_word=$2
6707 echo "$as_me:$LINENO: checking for $ac_word" >&5
6708 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6709 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6710   echo $ECHO_N "(cached) $ECHO_C" >&6
6711 else
6712   if test -n "$DLLTOOL"; then
6713   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6714 else
6715 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6716 for as_dir in $PATH
6717 do
6718   IFS=$as_save_IFS
6719   test -z "$as_dir" && as_dir=.
6720   for ac_exec_ext in '' $ac_executable_extensions; do
6721   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6722     ac_cv_prog_DLLTOOL="${ncn_progname}"
6723     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6724     break 2
6725   fi
6726 done
6727 done
6728
6729 fi
6730 fi
6731 DLLTOOL=$ac_cv_prog_DLLTOOL
6732 if test -n "$DLLTOOL"; then
6733   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6734 echo "${ECHO_T}$DLLTOOL" >&6
6735 else
6736   echo "$as_me:$LINENO: result: no" >&5
6737 echo "${ECHO_T}no" >&6
6738 fi
6739
6740   fi
6741   test -n "$ac_cv_prog_DLLTOOL" && break
6742 done
6743
6744 if test -z "$ac_cv_prog_DLLTOOL" ; then
6745   set dummy dlltool
6746   if test $build = $host ; then
6747     DLLTOOL="$2"
6748   else
6749     DLLTOOL="${ncn_tool_prefix}$2"
6750   fi
6751 fi
6752
6753
6754
6755 if test -n "$LD"; then
6756   ac_cv_prog_LD=$LD
6757 elif test -n "$ac_cv_prog_LD"; then
6758   LD=$ac_cv_prog_LD
6759 fi
6760
6761 if test -n "$ac_cv_prog_LD"; then
6762   for ncn_progname in ld; do
6763     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6764 set dummy ${ncn_progname}; ac_word=$2
6765 echo "$as_me:$LINENO: checking for $ac_word" >&5
6766 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6767 if test "${ac_cv_prog_LD+set}" = set; then
6768   echo $ECHO_N "(cached) $ECHO_C" >&6
6769 else
6770   if test -n "$LD"; then
6771   ac_cv_prog_LD="$LD" # Let the user override the test.
6772 else
6773 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6774 for as_dir in $PATH
6775 do
6776   IFS=$as_save_IFS
6777   test -z "$as_dir" && as_dir=.
6778   for ac_exec_ext in '' $ac_executable_extensions; do
6779   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6780     ac_cv_prog_LD="${ncn_progname}"
6781     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6782     break 2
6783   fi
6784 done
6785 done
6786
6787 fi
6788 fi
6789 LD=$ac_cv_prog_LD
6790 if test -n "$LD"; then
6791   echo "$as_me:$LINENO: result: $LD" >&5
6792 echo "${ECHO_T}$LD" >&6
6793 else
6794   echo "$as_me:$LINENO: result: no" >&5
6795 echo "${ECHO_T}no" >&6
6796 fi
6797
6798   done
6799 fi
6800
6801 for ncn_progname in ld; do
6802   if test -n "$ncn_tool_prefix"; then
6803     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6804 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6805 echo "$as_me:$LINENO: checking for $ac_word" >&5
6806 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6807 if test "${ac_cv_prog_LD+set}" = set; then
6808   echo $ECHO_N "(cached) $ECHO_C" >&6
6809 else
6810   if test -n "$LD"; then
6811   ac_cv_prog_LD="$LD" # Let the user override the test.
6812 else
6813 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6814 for as_dir in $PATH
6815 do
6816   IFS=$as_save_IFS
6817   test -z "$as_dir" && as_dir=.
6818   for ac_exec_ext in '' $ac_executable_extensions; do
6819   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6820     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6821     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6822     break 2
6823   fi
6824 done
6825 done
6826
6827 fi
6828 fi
6829 LD=$ac_cv_prog_LD
6830 if test -n "$LD"; then
6831   echo "$as_me:$LINENO: result: $LD" >&5
6832 echo "${ECHO_T}$LD" >&6
6833 else
6834   echo "$as_me:$LINENO: result: no" >&5
6835 echo "${ECHO_T}no" >&6
6836 fi
6837
6838   fi
6839   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6840     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6841 set dummy ${ncn_progname}; ac_word=$2
6842 echo "$as_me:$LINENO: checking for $ac_word" >&5
6843 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6844 if test "${ac_cv_prog_LD+set}" = set; then
6845   echo $ECHO_N "(cached) $ECHO_C" >&6
6846 else
6847   if test -n "$LD"; then
6848   ac_cv_prog_LD="$LD" # Let the user override the test.
6849 else
6850 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6851 for as_dir in $PATH
6852 do
6853   IFS=$as_save_IFS
6854   test -z "$as_dir" && as_dir=.
6855   for ac_exec_ext in '' $ac_executable_extensions; do
6856   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6857     ac_cv_prog_LD="${ncn_progname}"
6858     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6859     break 2
6860   fi
6861 done
6862 done
6863
6864 fi
6865 fi
6866 LD=$ac_cv_prog_LD
6867 if test -n "$LD"; then
6868   echo "$as_me:$LINENO: result: $LD" >&5
6869 echo "${ECHO_T}$LD" >&6
6870 else
6871   echo "$as_me:$LINENO: result: no" >&5
6872 echo "${ECHO_T}no" >&6
6873 fi
6874
6875   fi
6876   test -n "$ac_cv_prog_LD" && break
6877 done
6878
6879 if test -z "$ac_cv_prog_LD" ; then
6880   set dummy ld
6881   if test $build = $host ; then
6882     LD="$2"
6883   else
6884     LD="${ncn_tool_prefix}$2"
6885   fi
6886 fi
6887
6888
6889
6890 if test -n "$LIPO"; then
6891   ac_cv_prog_LIPO=$LIPO
6892 elif test -n "$ac_cv_prog_LIPO"; then
6893   LIPO=$ac_cv_prog_LIPO
6894 fi
6895
6896 if test -n "$ac_cv_prog_LIPO"; then
6897   for ncn_progname in lipo; do
6898     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6899 set dummy ${ncn_progname}; ac_word=$2
6900 echo "$as_me:$LINENO: checking for $ac_word" >&5
6901 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6902 if test "${ac_cv_prog_LIPO+set}" = set; then
6903   echo $ECHO_N "(cached) $ECHO_C" >&6
6904 else
6905   if test -n "$LIPO"; then
6906   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6907 else
6908 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6909 for as_dir in $PATH
6910 do
6911   IFS=$as_save_IFS
6912   test -z "$as_dir" && as_dir=.
6913   for ac_exec_ext in '' $ac_executable_extensions; do
6914   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6915     ac_cv_prog_LIPO="${ncn_progname}"
6916     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6917     break 2
6918   fi
6919 done
6920 done
6921
6922 fi
6923 fi
6924 LIPO=$ac_cv_prog_LIPO
6925 if test -n "$LIPO"; then
6926   echo "$as_me:$LINENO: result: $LIPO" >&5
6927 echo "${ECHO_T}$LIPO" >&6
6928 else
6929   echo "$as_me:$LINENO: result: no" >&5
6930 echo "${ECHO_T}no" >&6
6931 fi
6932
6933   done
6934 fi
6935
6936 for ncn_progname in lipo; do
6937   if test -n "$ncn_tool_prefix"; then
6938     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6939 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6940 echo "$as_me:$LINENO: checking for $ac_word" >&5
6941 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6942 if test "${ac_cv_prog_LIPO+set}" = set; then
6943   echo $ECHO_N "(cached) $ECHO_C" >&6
6944 else
6945   if test -n "$LIPO"; then
6946   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6947 else
6948 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6949 for as_dir in $PATH
6950 do
6951   IFS=$as_save_IFS
6952   test -z "$as_dir" && as_dir=.
6953   for ac_exec_ext in '' $ac_executable_extensions; do
6954   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6955     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6956     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6957     break 2
6958   fi
6959 done
6960 done
6961
6962 fi
6963 fi
6964 LIPO=$ac_cv_prog_LIPO
6965 if test -n "$LIPO"; then
6966   echo "$as_me:$LINENO: result: $LIPO" >&5
6967 echo "${ECHO_T}$LIPO" >&6
6968 else
6969   echo "$as_me:$LINENO: result: no" >&5
6970 echo "${ECHO_T}no" >&6
6971 fi
6972
6973   fi
6974   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
6975     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6976 set dummy ${ncn_progname}; ac_word=$2
6977 echo "$as_me:$LINENO: checking for $ac_word" >&5
6978 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6979 if test "${ac_cv_prog_LIPO+set}" = set; then
6980   echo $ECHO_N "(cached) $ECHO_C" >&6
6981 else
6982   if test -n "$LIPO"; then
6983   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6984 else
6985 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6986 for as_dir in $PATH
6987 do
6988   IFS=$as_save_IFS
6989   test -z "$as_dir" && as_dir=.
6990   for ac_exec_ext in '' $ac_executable_extensions; do
6991   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6992     ac_cv_prog_LIPO="${ncn_progname}"
6993     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6994     break 2
6995   fi
6996 done
6997 done
6998
6999 fi
7000 fi
7001 LIPO=$ac_cv_prog_LIPO
7002 if test -n "$LIPO"; then
7003   echo "$as_me:$LINENO: result: $LIPO" >&5
7004 echo "${ECHO_T}$LIPO" >&6
7005 else
7006   echo "$as_me:$LINENO: result: no" >&5
7007 echo "${ECHO_T}no" >&6
7008 fi
7009
7010   fi
7011   test -n "$ac_cv_prog_LIPO" && break
7012 done
7013
7014 if test -z "$ac_cv_prog_LIPO" ; then
7015   set dummy lipo
7016   if test $build = $host ; then
7017     LIPO="$2"
7018   else
7019     LIPO="${ncn_tool_prefix}$2"
7020   fi
7021 fi
7022
7023
7024
7025 if test -n "$NM"; then
7026   ac_cv_prog_NM=$NM
7027 elif test -n "$ac_cv_prog_NM"; then
7028   NM=$ac_cv_prog_NM
7029 fi
7030
7031 if test -n "$ac_cv_prog_NM"; then
7032   for ncn_progname in nm; do
7033     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7034 set dummy ${ncn_progname}; ac_word=$2
7035 echo "$as_me:$LINENO: checking for $ac_word" >&5
7036 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7037 if test "${ac_cv_prog_NM+set}" = set; then
7038   echo $ECHO_N "(cached) $ECHO_C" >&6
7039 else
7040   if test -n "$NM"; then
7041   ac_cv_prog_NM="$NM" # Let the user override the test.
7042 else
7043 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7044 for as_dir in $PATH
7045 do
7046   IFS=$as_save_IFS
7047   test -z "$as_dir" && as_dir=.
7048   for ac_exec_ext in '' $ac_executable_extensions; do
7049   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7050     ac_cv_prog_NM="${ncn_progname}"
7051     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7052     break 2
7053   fi
7054 done
7055 done
7056
7057 fi
7058 fi
7059 NM=$ac_cv_prog_NM
7060 if test -n "$NM"; then
7061   echo "$as_me:$LINENO: result: $NM" >&5
7062 echo "${ECHO_T}$NM" >&6
7063 else
7064   echo "$as_me:$LINENO: result: no" >&5
7065 echo "${ECHO_T}no" >&6
7066 fi
7067
7068   done
7069 fi
7070
7071 for ncn_progname in nm; do
7072   if test -n "$ncn_tool_prefix"; then
7073     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7074 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7075 echo "$as_me:$LINENO: checking for $ac_word" >&5
7076 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7077 if test "${ac_cv_prog_NM+set}" = set; then
7078   echo $ECHO_N "(cached) $ECHO_C" >&6
7079 else
7080   if test -n "$NM"; then
7081   ac_cv_prog_NM="$NM" # Let the user override the test.
7082 else
7083 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7084 for as_dir in $PATH
7085 do
7086   IFS=$as_save_IFS
7087   test -z "$as_dir" && as_dir=.
7088   for ac_exec_ext in '' $ac_executable_extensions; do
7089   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7090     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7091     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7092     break 2
7093   fi
7094 done
7095 done
7096
7097 fi
7098 fi
7099 NM=$ac_cv_prog_NM
7100 if test -n "$NM"; then
7101   echo "$as_me:$LINENO: result: $NM" >&5
7102 echo "${ECHO_T}$NM" >&6
7103 else
7104   echo "$as_me:$LINENO: result: no" >&5
7105 echo "${ECHO_T}no" >&6
7106 fi
7107
7108   fi
7109   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7110     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7111 set dummy ${ncn_progname}; ac_word=$2
7112 echo "$as_me:$LINENO: checking for $ac_word" >&5
7113 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7114 if test "${ac_cv_prog_NM+set}" = set; then
7115   echo $ECHO_N "(cached) $ECHO_C" >&6
7116 else
7117   if test -n "$NM"; then
7118   ac_cv_prog_NM="$NM" # Let the user override the test.
7119 else
7120 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7121 for as_dir in $PATH
7122 do
7123   IFS=$as_save_IFS
7124   test -z "$as_dir" && as_dir=.
7125   for ac_exec_ext in '' $ac_executable_extensions; do
7126   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7127     ac_cv_prog_NM="${ncn_progname}"
7128     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7129     break 2
7130   fi
7131 done
7132 done
7133
7134 fi
7135 fi
7136 NM=$ac_cv_prog_NM
7137 if test -n "$NM"; then
7138   echo "$as_me:$LINENO: result: $NM" >&5
7139 echo "${ECHO_T}$NM" >&6
7140 else
7141   echo "$as_me:$LINENO: result: no" >&5
7142 echo "${ECHO_T}no" >&6
7143 fi
7144
7145   fi
7146   test -n "$ac_cv_prog_NM" && break
7147 done
7148
7149 if test -z "$ac_cv_prog_NM" ; then
7150   set dummy nm
7151   if test $build = $host ; then
7152     NM="$2"
7153   else
7154     NM="${ncn_tool_prefix}$2"
7155   fi
7156 fi
7157
7158
7159
7160 if test -n "$RANLIB"; then
7161   ac_cv_prog_RANLIB=$RANLIB
7162 elif test -n "$ac_cv_prog_RANLIB"; then
7163   RANLIB=$ac_cv_prog_RANLIB
7164 fi
7165
7166 if test -n "$ac_cv_prog_RANLIB"; then
7167   for ncn_progname in ranlib; do
7168     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7169 set dummy ${ncn_progname}; ac_word=$2
7170 echo "$as_me:$LINENO: checking for $ac_word" >&5
7171 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7172 if test "${ac_cv_prog_RANLIB+set}" = set; then
7173   echo $ECHO_N "(cached) $ECHO_C" >&6
7174 else
7175   if test -n "$RANLIB"; then
7176   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7177 else
7178 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7179 for as_dir in $PATH
7180 do
7181   IFS=$as_save_IFS
7182   test -z "$as_dir" && as_dir=.
7183   for ac_exec_ext in '' $ac_executable_extensions; do
7184   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7185     ac_cv_prog_RANLIB="${ncn_progname}"
7186     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7187     break 2
7188   fi
7189 done
7190 done
7191
7192 fi
7193 fi
7194 RANLIB=$ac_cv_prog_RANLIB
7195 if test -n "$RANLIB"; then
7196   echo "$as_me:$LINENO: result: $RANLIB" >&5
7197 echo "${ECHO_T}$RANLIB" >&6
7198 else
7199   echo "$as_me:$LINENO: result: no" >&5
7200 echo "${ECHO_T}no" >&6
7201 fi
7202
7203   done
7204 fi
7205
7206 for ncn_progname in ranlib; do
7207   if test -n "$ncn_tool_prefix"; then
7208     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7209 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7210 echo "$as_me:$LINENO: checking for $ac_word" >&5
7211 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7212 if test "${ac_cv_prog_RANLIB+set}" = set; then
7213   echo $ECHO_N "(cached) $ECHO_C" >&6
7214 else
7215   if test -n "$RANLIB"; then
7216   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7217 else
7218 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7219 for as_dir in $PATH
7220 do
7221   IFS=$as_save_IFS
7222   test -z "$as_dir" && as_dir=.
7223   for ac_exec_ext in '' $ac_executable_extensions; do
7224   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7225     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7226     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7227     break 2
7228   fi
7229 done
7230 done
7231
7232 fi
7233 fi
7234 RANLIB=$ac_cv_prog_RANLIB
7235 if test -n "$RANLIB"; then
7236   echo "$as_me:$LINENO: result: $RANLIB" >&5
7237 echo "${ECHO_T}$RANLIB" >&6
7238 else
7239   echo "$as_me:$LINENO: result: no" >&5
7240 echo "${ECHO_T}no" >&6
7241 fi
7242
7243   fi
7244   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7245     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7246 set dummy ${ncn_progname}; ac_word=$2
7247 echo "$as_me:$LINENO: checking for $ac_word" >&5
7248 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7249 if test "${ac_cv_prog_RANLIB+set}" = set; then
7250   echo $ECHO_N "(cached) $ECHO_C" >&6
7251 else
7252   if test -n "$RANLIB"; then
7253   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7254 else
7255 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7256 for as_dir in $PATH
7257 do
7258   IFS=$as_save_IFS
7259   test -z "$as_dir" && as_dir=.
7260   for ac_exec_ext in '' $ac_executable_extensions; do
7261   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7262     ac_cv_prog_RANLIB="${ncn_progname}"
7263     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7264     break 2
7265   fi
7266 done
7267 done
7268
7269 fi
7270 fi
7271 RANLIB=$ac_cv_prog_RANLIB
7272 if test -n "$RANLIB"; then
7273   echo "$as_me:$LINENO: result: $RANLIB" >&5
7274 echo "${ECHO_T}$RANLIB" >&6
7275 else
7276   echo "$as_me:$LINENO: result: no" >&5
7277 echo "${ECHO_T}no" >&6
7278 fi
7279
7280   fi
7281   test -n "$ac_cv_prog_RANLIB" && break
7282 done
7283
7284 if test -z "$ac_cv_prog_RANLIB" ; then
7285   RANLIB=":"
7286 fi
7287
7288
7289
7290 if test -n "$STRIP"; then
7291   ac_cv_prog_STRIP=$STRIP
7292 elif test -n "$ac_cv_prog_STRIP"; then
7293   STRIP=$ac_cv_prog_STRIP
7294 fi
7295
7296 if test -n "$ac_cv_prog_STRIP"; then
7297   for ncn_progname in strip; do
7298     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7299 set dummy ${ncn_progname}; ac_word=$2
7300 echo "$as_me:$LINENO: checking for $ac_word" >&5
7301 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7302 if test "${ac_cv_prog_STRIP+set}" = set; then
7303   echo $ECHO_N "(cached) $ECHO_C" >&6
7304 else
7305   if test -n "$STRIP"; then
7306   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7307 else
7308 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7309 for as_dir in $PATH
7310 do
7311   IFS=$as_save_IFS
7312   test -z "$as_dir" && as_dir=.
7313   for ac_exec_ext in '' $ac_executable_extensions; do
7314   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7315     ac_cv_prog_STRIP="${ncn_progname}"
7316     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7317     break 2
7318   fi
7319 done
7320 done
7321
7322 fi
7323 fi
7324 STRIP=$ac_cv_prog_STRIP
7325 if test -n "$STRIP"; then
7326   echo "$as_me:$LINENO: result: $STRIP" >&5
7327 echo "${ECHO_T}$STRIP" >&6
7328 else
7329   echo "$as_me:$LINENO: result: no" >&5
7330 echo "${ECHO_T}no" >&6
7331 fi
7332
7333   done
7334 fi
7335
7336 for ncn_progname in strip; do
7337   if test -n "$ncn_tool_prefix"; then
7338     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7339 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7340 echo "$as_me:$LINENO: checking for $ac_word" >&5
7341 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7342 if test "${ac_cv_prog_STRIP+set}" = set; then
7343   echo $ECHO_N "(cached) $ECHO_C" >&6
7344 else
7345   if test -n "$STRIP"; then
7346   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7347 else
7348 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7349 for as_dir in $PATH
7350 do
7351   IFS=$as_save_IFS
7352   test -z "$as_dir" && as_dir=.
7353   for ac_exec_ext in '' $ac_executable_extensions; do
7354   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7355     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7356     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7357     break 2
7358   fi
7359 done
7360 done
7361
7362 fi
7363 fi
7364 STRIP=$ac_cv_prog_STRIP
7365 if test -n "$STRIP"; then
7366   echo "$as_me:$LINENO: result: $STRIP" >&5
7367 echo "${ECHO_T}$STRIP" >&6
7368 else
7369   echo "$as_me:$LINENO: result: no" >&5
7370 echo "${ECHO_T}no" >&6
7371 fi
7372
7373   fi
7374   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7375     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7376 set dummy ${ncn_progname}; ac_word=$2
7377 echo "$as_me:$LINENO: checking for $ac_word" >&5
7378 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7379 if test "${ac_cv_prog_STRIP+set}" = set; then
7380   echo $ECHO_N "(cached) $ECHO_C" >&6
7381 else
7382   if test -n "$STRIP"; then
7383   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7384 else
7385 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7386 for as_dir in $PATH
7387 do
7388   IFS=$as_save_IFS
7389   test -z "$as_dir" && as_dir=.
7390   for ac_exec_ext in '' $ac_executable_extensions; do
7391   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7392     ac_cv_prog_STRIP="${ncn_progname}"
7393     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7394     break 2
7395   fi
7396 done
7397 done
7398
7399 fi
7400 fi
7401 STRIP=$ac_cv_prog_STRIP
7402 if test -n "$STRIP"; then
7403   echo "$as_me:$LINENO: result: $STRIP" >&5
7404 echo "${ECHO_T}$STRIP" >&6
7405 else
7406   echo "$as_me:$LINENO: result: no" >&5
7407 echo "${ECHO_T}no" >&6
7408 fi
7409
7410   fi
7411   test -n "$ac_cv_prog_STRIP" && break
7412 done
7413
7414 if test -z "$ac_cv_prog_STRIP" ; then
7415   STRIP=":"
7416 fi
7417
7418
7419
7420 if test -n "$WINDRES"; then
7421   ac_cv_prog_WINDRES=$WINDRES
7422 elif test -n "$ac_cv_prog_WINDRES"; then
7423   WINDRES=$ac_cv_prog_WINDRES
7424 fi
7425
7426 if test -n "$ac_cv_prog_WINDRES"; then
7427   for ncn_progname in windres; do
7428     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7429 set dummy ${ncn_progname}; ac_word=$2
7430 echo "$as_me:$LINENO: checking for $ac_word" >&5
7431 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7432 if test "${ac_cv_prog_WINDRES+set}" = set; then
7433   echo $ECHO_N "(cached) $ECHO_C" >&6
7434 else
7435   if test -n "$WINDRES"; then
7436   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7437 else
7438 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7439 for as_dir in $PATH
7440 do
7441   IFS=$as_save_IFS
7442   test -z "$as_dir" && as_dir=.
7443   for ac_exec_ext in '' $ac_executable_extensions; do
7444   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7445     ac_cv_prog_WINDRES="${ncn_progname}"
7446     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7447     break 2
7448   fi
7449 done
7450 done
7451
7452 fi
7453 fi
7454 WINDRES=$ac_cv_prog_WINDRES
7455 if test -n "$WINDRES"; then
7456   echo "$as_me:$LINENO: result: $WINDRES" >&5
7457 echo "${ECHO_T}$WINDRES" >&6
7458 else
7459   echo "$as_me:$LINENO: result: no" >&5
7460 echo "${ECHO_T}no" >&6
7461 fi
7462
7463   done
7464 fi
7465
7466 for ncn_progname in windres; do
7467   if test -n "$ncn_tool_prefix"; then
7468     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7469 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7470 echo "$as_me:$LINENO: checking for $ac_word" >&5
7471 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7472 if test "${ac_cv_prog_WINDRES+set}" = set; then
7473   echo $ECHO_N "(cached) $ECHO_C" >&6
7474 else
7475   if test -n "$WINDRES"; then
7476   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7477 else
7478 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7479 for as_dir in $PATH
7480 do
7481   IFS=$as_save_IFS
7482   test -z "$as_dir" && as_dir=.
7483   for ac_exec_ext in '' $ac_executable_extensions; do
7484   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7485     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7486     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7487     break 2
7488   fi
7489 done
7490 done
7491
7492 fi
7493 fi
7494 WINDRES=$ac_cv_prog_WINDRES
7495 if test -n "$WINDRES"; then
7496   echo "$as_me:$LINENO: result: $WINDRES" >&5
7497 echo "${ECHO_T}$WINDRES" >&6
7498 else
7499   echo "$as_me:$LINENO: result: no" >&5
7500 echo "${ECHO_T}no" >&6
7501 fi
7502
7503   fi
7504   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7505     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7506 set dummy ${ncn_progname}; ac_word=$2
7507 echo "$as_me:$LINENO: checking for $ac_word" >&5
7508 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7509 if test "${ac_cv_prog_WINDRES+set}" = set; then
7510   echo $ECHO_N "(cached) $ECHO_C" >&6
7511 else
7512   if test -n "$WINDRES"; then
7513   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7514 else
7515 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7516 for as_dir in $PATH
7517 do
7518   IFS=$as_save_IFS
7519   test -z "$as_dir" && as_dir=.
7520   for ac_exec_ext in '' $ac_executable_extensions; do
7521   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7522     ac_cv_prog_WINDRES="${ncn_progname}"
7523     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7524     break 2
7525   fi
7526 done
7527 done
7528
7529 fi
7530 fi
7531 WINDRES=$ac_cv_prog_WINDRES
7532 if test -n "$WINDRES"; then
7533   echo "$as_me:$LINENO: result: $WINDRES" >&5
7534 echo "${ECHO_T}$WINDRES" >&6
7535 else
7536   echo "$as_me:$LINENO: result: no" >&5
7537 echo "${ECHO_T}no" >&6
7538 fi
7539
7540   fi
7541   test -n "$ac_cv_prog_WINDRES" && break
7542 done
7543
7544 if test -z "$ac_cv_prog_WINDRES" ; then
7545   set dummy windres
7546   if test $build = $host ; then
7547     WINDRES="$2"
7548   else
7549     WINDRES="${ncn_tool_prefix}$2"
7550   fi
7551 fi
7552
7553
7554
7555 if test -n "$WINDMC"; then
7556   ac_cv_prog_WINDMC=$WINDMC
7557 elif test -n "$ac_cv_prog_WINDMC"; then
7558   WINDMC=$ac_cv_prog_WINDMC
7559 fi
7560
7561 if test -n "$ac_cv_prog_WINDMC"; then
7562   for ncn_progname in windmc; do
7563     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7564 set dummy ${ncn_progname}; ac_word=$2
7565 echo "$as_me:$LINENO: checking for $ac_word" >&5
7566 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7567 if test "${ac_cv_prog_WINDMC+set}" = set; then
7568   echo $ECHO_N "(cached) $ECHO_C" >&6
7569 else
7570   if test -n "$WINDMC"; then
7571   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7572 else
7573 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7574 for as_dir in $PATH
7575 do
7576   IFS=$as_save_IFS
7577   test -z "$as_dir" && as_dir=.
7578   for ac_exec_ext in '' $ac_executable_extensions; do
7579   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7580     ac_cv_prog_WINDMC="${ncn_progname}"
7581     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7582     break 2
7583   fi
7584 done
7585 done
7586
7587 fi
7588 fi
7589 WINDMC=$ac_cv_prog_WINDMC
7590 if test -n "$WINDMC"; then
7591   echo "$as_me:$LINENO: result: $WINDMC" >&5
7592 echo "${ECHO_T}$WINDMC" >&6
7593 else
7594   echo "$as_me:$LINENO: result: no" >&5
7595 echo "${ECHO_T}no" >&6
7596 fi
7597
7598   done
7599 fi
7600
7601 for ncn_progname in windmc; do
7602   if test -n "$ncn_tool_prefix"; then
7603     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7604 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7605 echo "$as_me:$LINENO: checking for $ac_word" >&5
7606 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7607 if test "${ac_cv_prog_WINDMC+set}" = set; then
7608   echo $ECHO_N "(cached) $ECHO_C" >&6
7609 else
7610   if test -n "$WINDMC"; then
7611   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7612 else
7613 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7614 for as_dir in $PATH
7615 do
7616   IFS=$as_save_IFS
7617   test -z "$as_dir" && as_dir=.
7618   for ac_exec_ext in '' $ac_executable_extensions; do
7619   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7620     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7621     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7622     break 2
7623   fi
7624 done
7625 done
7626
7627 fi
7628 fi
7629 WINDMC=$ac_cv_prog_WINDMC
7630 if test -n "$WINDMC"; then
7631   echo "$as_me:$LINENO: result: $WINDMC" >&5
7632 echo "${ECHO_T}$WINDMC" >&6
7633 else
7634   echo "$as_me:$LINENO: result: no" >&5
7635 echo "${ECHO_T}no" >&6
7636 fi
7637
7638   fi
7639   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7640     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7641 set dummy ${ncn_progname}; ac_word=$2
7642 echo "$as_me:$LINENO: checking for $ac_word" >&5
7643 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7644 if test "${ac_cv_prog_WINDMC+set}" = set; then
7645   echo $ECHO_N "(cached) $ECHO_C" >&6
7646 else
7647   if test -n "$WINDMC"; then
7648   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7649 else
7650 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7651 for as_dir in $PATH
7652 do
7653   IFS=$as_save_IFS
7654   test -z "$as_dir" && as_dir=.
7655   for ac_exec_ext in '' $ac_executable_extensions; do
7656   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7657     ac_cv_prog_WINDMC="${ncn_progname}"
7658     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7659     break 2
7660   fi
7661 done
7662 done
7663
7664 fi
7665 fi
7666 WINDMC=$ac_cv_prog_WINDMC
7667 if test -n "$WINDMC"; then
7668   echo "$as_me:$LINENO: result: $WINDMC" >&5
7669 echo "${ECHO_T}$WINDMC" >&6
7670 else
7671   echo "$as_me:$LINENO: result: no" >&5
7672 echo "${ECHO_T}no" >&6
7673 fi
7674
7675   fi
7676   test -n "$ac_cv_prog_WINDMC" && break
7677 done
7678
7679 if test -z "$ac_cv_prog_WINDMC" ; then
7680   set dummy windmc
7681   if test $build = $host ; then
7682     WINDMC="$2"
7683   else
7684     WINDMC="${ncn_tool_prefix}$2"
7685   fi
7686 fi
7687
7688
7689
7690 if test -n "$OBJCOPY"; then
7691   ac_cv_prog_OBJCOPY=$OBJCOPY
7692 elif test -n "$ac_cv_prog_OBJCOPY"; then
7693   OBJCOPY=$ac_cv_prog_OBJCOPY
7694 fi
7695
7696 if test -n "$ac_cv_prog_OBJCOPY"; then
7697   for ncn_progname in objcopy; do
7698     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7699 set dummy ${ncn_progname}; ac_word=$2
7700 echo "$as_me:$LINENO: checking for $ac_word" >&5
7701 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7702 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7703   echo $ECHO_N "(cached) $ECHO_C" >&6
7704 else
7705   if test -n "$OBJCOPY"; then
7706   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7707 else
7708 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7709 for as_dir in $PATH
7710 do
7711   IFS=$as_save_IFS
7712   test -z "$as_dir" && as_dir=.
7713   for ac_exec_ext in '' $ac_executable_extensions; do
7714   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7715     ac_cv_prog_OBJCOPY="${ncn_progname}"
7716     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7717     break 2
7718   fi
7719 done
7720 done
7721
7722 fi
7723 fi
7724 OBJCOPY=$ac_cv_prog_OBJCOPY
7725 if test -n "$OBJCOPY"; then
7726   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7727 echo "${ECHO_T}$OBJCOPY" >&6
7728 else
7729   echo "$as_me:$LINENO: result: no" >&5
7730 echo "${ECHO_T}no" >&6
7731 fi
7732
7733   done
7734 fi
7735
7736 for ncn_progname in objcopy; do
7737   if test -n "$ncn_tool_prefix"; then
7738     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7739 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7740 echo "$as_me:$LINENO: checking for $ac_word" >&5
7741 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7742 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7743   echo $ECHO_N "(cached) $ECHO_C" >&6
7744 else
7745   if test -n "$OBJCOPY"; then
7746   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7747 else
7748 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7749 for as_dir in $PATH
7750 do
7751   IFS=$as_save_IFS
7752   test -z "$as_dir" && as_dir=.
7753   for ac_exec_ext in '' $ac_executable_extensions; do
7754   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7755     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7756     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7757     break 2
7758   fi
7759 done
7760 done
7761
7762 fi
7763 fi
7764 OBJCOPY=$ac_cv_prog_OBJCOPY
7765 if test -n "$OBJCOPY"; then
7766   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7767 echo "${ECHO_T}$OBJCOPY" >&6
7768 else
7769   echo "$as_me:$LINENO: result: no" >&5
7770 echo "${ECHO_T}no" >&6
7771 fi
7772
7773   fi
7774   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7775     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7776 set dummy ${ncn_progname}; ac_word=$2
7777 echo "$as_me:$LINENO: checking for $ac_word" >&5
7778 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7779 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7780   echo $ECHO_N "(cached) $ECHO_C" >&6
7781 else
7782   if test -n "$OBJCOPY"; then
7783   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7784 else
7785 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7786 for as_dir in $PATH
7787 do
7788   IFS=$as_save_IFS
7789   test -z "$as_dir" && as_dir=.
7790   for ac_exec_ext in '' $ac_executable_extensions; do
7791   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7792     ac_cv_prog_OBJCOPY="${ncn_progname}"
7793     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7794     break 2
7795   fi
7796 done
7797 done
7798
7799 fi
7800 fi
7801 OBJCOPY=$ac_cv_prog_OBJCOPY
7802 if test -n "$OBJCOPY"; then
7803   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7804 echo "${ECHO_T}$OBJCOPY" >&6
7805 else
7806   echo "$as_me:$LINENO: result: no" >&5
7807 echo "${ECHO_T}no" >&6
7808 fi
7809
7810   fi
7811   test -n "$ac_cv_prog_OBJCOPY" && break
7812 done
7813
7814 if test -z "$ac_cv_prog_OBJCOPY" ; then
7815   set dummy objcopy
7816   if test $build = $host ; then
7817     OBJCOPY="$2"
7818   else
7819     OBJCOPY="${ncn_tool_prefix}$2"
7820   fi
7821 fi
7822
7823
7824
7825 if test -n "$OBJDUMP"; then
7826   ac_cv_prog_OBJDUMP=$OBJDUMP
7827 elif test -n "$ac_cv_prog_OBJDUMP"; then
7828   OBJDUMP=$ac_cv_prog_OBJDUMP
7829 fi
7830
7831 if test -n "$ac_cv_prog_OBJDUMP"; then
7832   for ncn_progname in objdump; do
7833     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7834 set dummy ${ncn_progname}; ac_word=$2
7835 echo "$as_me:$LINENO: checking for $ac_word" >&5
7836 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7837 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7838   echo $ECHO_N "(cached) $ECHO_C" >&6
7839 else
7840   if test -n "$OBJDUMP"; then
7841   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7842 else
7843 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7844 for as_dir in $PATH
7845 do
7846   IFS=$as_save_IFS
7847   test -z "$as_dir" && as_dir=.
7848   for ac_exec_ext in '' $ac_executable_extensions; do
7849   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7850     ac_cv_prog_OBJDUMP="${ncn_progname}"
7851     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7852     break 2
7853   fi
7854 done
7855 done
7856
7857 fi
7858 fi
7859 OBJDUMP=$ac_cv_prog_OBJDUMP
7860 if test -n "$OBJDUMP"; then
7861   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7862 echo "${ECHO_T}$OBJDUMP" >&6
7863 else
7864   echo "$as_me:$LINENO: result: no" >&5
7865 echo "${ECHO_T}no" >&6
7866 fi
7867
7868   done
7869 fi
7870
7871 for ncn_progname in objdump; do
7872   if test -n "$ncn_tool_prefix"; then
7873     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7874 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7875 echo "$as_me:$LINENO: checking for $ac_word" >&5
7876 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7877 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7878   echo $ECHO_N "(cached) $ECHO_C" >&6
7879 else
7880   if test -n "$OBJDUMP"; then
7881   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7882 else
7883 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7884 for as_dir in $PATH
7885 do
7886   IFS=$as_save_IFS
7887   test -z "$as_dir" && as_dir=.
7888   for ac_exec_ext in '' $ac_executable_extensions; do
7889   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7890     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7891     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7892     break 2
7893   fi
7894 done
7895 done
7896
7897 fi
7898 fi
7899 OBJDUMP=$ac_cv_prog_OBJDUMP
7900 if test -n "$OBJDUMP"; then
7901   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7902 echo "${ECHO_T}$OBJDUMP" >&6
7903 else
7904   echo "$as_me:$LINENO: result: no" >&5
7905 echo "${ECHO_T}no" >&6
7906 fi
7907
7908   fi
7909   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7910     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7911 set dummy ${ncn_progname}; ac_word=$2
7912 echo "$as_me:$LINENO: checking for $ac_word" >&5
7913 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7914 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7915   echo $ECHO_N "(cached) $ECHO_C" >&6
7916 else
7917   if test -n "$OBJDUMP"; then
7918   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7919 else
7920 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7921 for as_dir in $PATH
7922 do
7923   IFS=$as_save_IFS
7924   test -z "$as_dir" && as_dir=.
7925   for ac_exec_ext in '' $ac_executable_extensions; do
7926   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7927     ac_cv_prog_OBJDUMP="${ncn_progname}"
7928     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7929     break 2
7930   fi
7931 done
7932 done
7933
7934 fi
7935 fi
7936 OBJDUMP=$ac_cv_prog_OBJDUMP
7937 if test -n "$OBJDUMP"; then
7938   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7939 echo "${ECHO_T}$OBJDUMP" >&6
7940 else
7941   echo "$as_me:$LINENO: result: no" >&5
7942 echo "${ECHO_T}no" >&6
7943 fi
7944
7945   fi
7946   test -n "$ac_cv_prog_OBJDUMP" && break
7947 done
7948
7949 if test -z "$ac_cv_prog_OBJDUMP" ; then
7950   set dummy objdump
7951   if test $build = $host ; then
7952     OBJDUMP="$2"
7953   else
7954     OBJDUMP="${ncn_tool_prefix}$2"
7955   fi
7956 fi
7957
7958
7959
7960
7961
7962
7963 # Target tools.
7964
7965 # Check whether --with-build-time-tools or --without-build-time-tools was given.
7966 if test "${with_build_time_tools+set}" = set; then
7967   withval="$with_build_time_tools"
7968   case x"$withval" in
7969      x/*) ;;
7970      *)
7971        with_build_time_tools=
7972        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
7973 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
7974        ;;
7975    esac
7976 else
7977   with_build_time_tools=
7978 fi;
7979
7980
7981
7982 if test -n "$CC_FOR_TARGET"; then
7983   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
7984 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7985   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7986 fi
7987
7988 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7989   for ncn_progname in cc gcc; do
7990     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7991 set dummy ${ncn_progname}; ac_word=$2
7992 echo "$as_me:$LINENO: checking for $ac_word" >&5
7993 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7994 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7995   echo $ECHO_N "(cached) $ECHO_C" >&6
7996 else
7997   if test -n "$CC_FOR_TARGET"; then
7998   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7999 else
8000 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8001 for as_dir in $PATH
8002 do
8003   IFS=$as_save_IFS
8004   test -z "$as_dir" && as_dir=.
8005   for ac_exec_ext in '' $ac_executable_extensions; do
8006   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8007     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8008     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8009     break 2
8010   fi
8011 done
8012 done
8013
8014 fi
8015 fi
8016 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8017 if test -n "$CC_FOR_TARGET"; then
8018   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8019 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8020 else
8021   echo "$as_me:$LINENO: result: no" >&5
8022 echo "${ECHO_T}no" >&6
8023 fi
8024
8025   done
8026 fi
8027
8028 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8029   for ncn_progname in cc gcc; do
8030     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8031 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8032     if test -x $with_build_time_tools/${ncn_progname}; then
8033       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8034       echo "$as_me:$LINENO: result: yes" >&5
8035 echo "${ECHO_T}yes" >&6
8036       break
8037     else
8038       echo "$as_me:$LINENO: result: no" >&5
8039 echo "${ECHO_T}no" >&6
8040     fi
8041   done
8042 fi
8043
8044 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8045   for ncn_progname in cc gcc; do
8046     if test -n "$ncn_target_tool_prefix"; then
8047       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8048 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8049 echo "$as_me:$LINENO: checking for $ac_word" >&5
8050 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8051 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8052   echo $ECHO_N "(cached) $ECHO_C" >&6
8053 else
8054   if test -n "$CC_FOR_TARGET"; then
8055   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8056 else
8057 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8058 for as_dir in $PATH
8059 do
8060   IFS=$as_save_IFS
8061   test -z "$as_dir" && as_dir=.
8062   for ac_exec_ext in '' $ac_executable_extensions; do
8063   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8064     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8065     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8066     break 2
8067   fi
8068 done
8069 done
8070
8071 fi
8072 fi
8073 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8074 if test -n "$CC_FOR_TARGET"; then
8075   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8076 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8077 else
8078   echo "$as_me:$LINENO: result: no" >&5
8079 echo "${ECHO_T}no" >&6
8080 fi
8081
8082     fi
8083     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8084       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8085 set dummy ${ncn_progname}; ac_word=$2
8086 echo "$as_me:$LINENO: checking for $ac_word" >&5
8087 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8088 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8089   echo $ECHO_N "(cached) $ECHO_C" >&6
8090 else
8091   if test -n "$CC_FOR_TARGET"; then
8092   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8093 else
8094 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8095 for as_dir in $PATH
8096 do
8097   IFS=$as_save_IFS
8098   test -z "$as_dir" && as_dir=.
8099   for ac_exec_ext in '' $ac_executable_extensions; do
8100   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8101     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8102     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8103     break 2
8104   fi
8105 done
8106 done
8107
8108 fi
8109 fi
8110 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8111 if test -n "$CC_FOR_TARGET"; then
8112   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8113 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8114 else
8115   echo "$as_me:$LINENO: result: no" >&5
8116 echo "${ECHO_T}no" >&6
8117 fi
8118
8119     fi
8120     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8121   done
8122 fi
8123
8124 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8125   set dummy cc gcc
8126   if test $build = $target ; then
8127     CC_FOR_TARGET="$2"
8128   else
8129     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8130   fi
8131 else
8132   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8133 fi
8134
8135
8136
8137 if test -n "$CXX_FOR_TARGET"; then
8138   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8139 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8140   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8141 fi
8142
8143 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8144   for ncn_progname in c++ g++ cxx gxx; do
8145     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8146 set dummy ${ncn_progname}; ac_word=$2
8147 echo "$as_me:$LINENO: checking for $ac_word" >&5
8148 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8149 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8150   echo $ECHO_N "(cached) $ECHO_C" >&6
8151 else
8152   if test -n "$CXX_FOR_TARGET"; then
8153   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8154 else
8155 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8156 for as_dir in $PATH
8157 do
8158   IFS=$as_save_IFS
8159   test -z "$as_dir" && as_dir=.
8160   for ac_exec_ext in '' $ac_executable_extensions; do
8161   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8162     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8163     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8164     break 2
8165   fi
8166 done
8167 done
8168
8169 fi
8170 fi
8171 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8172 if test -n "$CXX_FOR_TARGET"; then
8173   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8174 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8175 else
8176   echo "$as_me:$LINENO: result: no" >&5
8177 echo "${ECHO_T}no" >&6
8178 fi
8179
8180   done
8181 fi
8182
8183 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8184   for ncn_progname in c++ g++ cxx gxx; do
8185     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8186 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8187     if test -x $with_build_time_tools/${ncn_progname}; then
8188       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8189       echo "$as_me:$LINENO: result: yes" >&5
8190 echo "${ECHO_T}yes" >&6
8191       break
8192     else
8193       echo "$as_me:$LINENO: result: no" >&5
8194 echo "${ECHO_T}no" >&6
8195     fi
8196   done
8197 fi
8198
8199 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8200   for ncn_progname in c++ g++ cxx gxx; do
8201     if test -n "$ncn_target_tool_prefix"; then
8202       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8203 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8204 echo "$as_me:$LINENO: checking for $ac_word" >&5
8205 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8206 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8207   echo $ECHO_N "(cached) $ECHO_C" >&6
8208 else
8209   if test -n "$CXX_FOR_TARGET"; then
8210   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8211 else
8212 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8213 for as_dir in $PATH
8214 do
8215   IFS=$as_save_IFS
8216   test -z "$as_dir" && as_dir=.
8217   for ac_exec_ext in '' $ac_executable_extensions; do
8218   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8219     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8220     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8221     break 2
8222   fi
8223 done
8224 done
8225
8226 fi
8227 fi
8228 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8229 if test -n "$CXX_FOR_TARGET"; then
8230   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8231 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8232 else
8233   echo "$as_me:$LINENO: result: no" >&5
8234 echo "${ECHO_T}no" >&6
8235 fi
8236
8237     fi
8238     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8239       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8240 set dummy ${ncn_progname}; ac_word=$2
8241 echo "$as_me:$LINENO: checking for $ac_word" >&5
8242 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8243 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8244   echo $ECHO_N "(cached) $ECHO_C" >&6
8245 else
8246   if test -n "$CXX_FOR_TARGET"; then
8247   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8248 else
8249 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8250 for as_dir in $PATH
8251 do
8252   IFS=$as_save_IFS
8253   test -z "$as_dir" && as_dir=.
8254   for ac_exec_ext in '' $ac_executable_extensions; do
8255   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8256     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8257     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8258     break 2
8259   fi
8260 done
8261 done
8262
8263 fi
8264 fi
8265 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8266 if test -n "$CXX_FOR_TARGET"; then
8267   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8268 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8269 else
8270   echo "$as_me:$LINENO: result: no" >&5
8271 echo "${ECHO_T}no" >&6
8272 fi
8273
8274     fi
8275     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8276   done
8277 fi
8278
8279 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8280   set dummy c++ g++ cxx gxx
8281   if test $build = $target ; then
8282     CXX_FOR_TARGET="$2"
8283   else
8284     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8285   fi
8286 else
8287   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8288 fi
8289
8290
8291
8292 if test -n "$GCC_FOR_TARGET"; then
8293   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8294 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8295   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8296 fi
8297
8298 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8299   for ncn_progname in gcc; do
8300     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8301 set dummy ${ncn_progname}; ac_word=$2
8302 echo "$as_me:$LINENO: checking for $ac_word" >&5
8303 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8304 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8305   echo $ECHO_N "(cached) $ECHO_C" >&6
8306 else
8307   if test -n "$GCC_FOR_TARGET"; then
8308   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8309 else
8310 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8311 for as_dir in $PATH
8312 do
8313   IFS=$as_save_IFS
8314   test -z "$as_dir" && as_dir=.
8315   for ac_exec_ext in '' $ac_executable_extensions; do
8316   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8317     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8318     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8319     break 2
8320   fi
8321 done
8322 done
8323
8324 fi
8325 fi
8326 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8327 if test -n "$GCC_FOR_TARGET"; then
8328   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8329 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8330 else
8331   echo "$as_me:$LINENO: result: no" >&5
8332 echo "${ECHO_T}no" >&6
8333 fi
8334
8335   done
8336 fi
8337
8338 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8339   for ncn_progname in gcc; do
8340     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8341 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8342     if test -x $with_build_time_tools/${ncn_progname}; then
8343       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8344       echo "$as_me:$LINENO: result: yes" >&5
8345 echo "${ECHO_T}yes" >&6
8346       break
8347     else
8348       echo "$as_me:$LINENO: result: no" >&5
8349 echo "${ECHO_T}no" >&6
8350     fi
8351   done
8352 fi
8353
8354 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8355   for ncn_progname in gcc; do
8356     if test -n "$ncn_target_tool_prefix"; then
8357       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8358 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8359 echo "$as_me:$LINENO: checking for $ac_word" >&5
8360 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8361 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8362   echo $ECHO_N "(cached) $ECHO_C" >&6
8363 else
8364   if test -n "$GCC_FOR_TARGET"; then
8365   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8366 else
8367 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8368 for as_dir in $PATH
8369 do
8370   IFS=$as_save_IFS
8371   test -z "$as_dir" && as_dir=.
8372   for ac_exec_ext in '' $ac_executable_extensions; do
8373   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8374     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8375     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8376     break 2
8377   fi
8378 done
8379 done
8380
8381 fi
8382 fi
8383 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8384 if test -n "$GCC_FOR_TARGET"; then
8385   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8386 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8387 else
8388   echo "$as_me:$LINENO: result: no" >&5
8389 echo "${ECHO_T}no" >&6
8390 fi
8391
8392     fi
8393     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8394       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8395 set dummy ${ncn_progname}; ac_word=$2
8396 echo "$as_me:$LINENO: checking for $ac_word" >&5
8397 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8398 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8399   echo $ECHO_N "(cached) $ECHO_C" >&6
8400 else
8401   if test -n "$GCC_FOR_TARGET"; then
8402   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8403 else
8404 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8405 for as_dir in $PATH
8406 do
8407   IFS=$as_save_IFS
8408   test -z "$as_dir" && as_dir=.
8409   for ac_exec_ext in '' $ac_executable_extensions; do
8410   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8411     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8412     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8413     break 2
8414   fi
8415 done
8416 done
8417
8418 fi
8419 fi
8420 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8421 if test -n "$GCC_FOR_TARGET"; then
8422   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8423 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8424 else
8425   echo "$as_me:$LINENO: result: no" >&5
8426 echo "${ECHO_T}no" >&6
8427 fi
8428
8429     fi
8430     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8431   done
8432 fi
8433
8434 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8435   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8436 else
8437   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8438 fi
8439
8440
8441
8442 if test -n "$GCJ_FOR_TARGET"; then
8443   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8444 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8445   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8446 fi
8447
8448 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8449   for ncn_progname in gcj; do
8450     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8451 set dummy ${ncn_progname}; ac_word=$2
8452 echo "$as_me:$LINENO: checking for $ac_word" >&5
8453 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8454 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8455   echo $ECHO_N "(cached) $ECHO_C" >&6
8456 else
8457   if test -n "$GCJ_FOR_TARGET"; then
8458   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8459 else
8460 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8461 for as_dir in $PATH
8462 do
8463   IFS=$as_save_IFS
8464   test -z "$as_dir" && as_dir=.
8465   for ac_exec_ext in '' $ac_executable_extensions; do
8466   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8467     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8468     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8469     break 2
8470   fi
8471 done
8472 done
8473
8474 fi
8475 fi
8476 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8477 if test -n "$GCJ_FOR_TARGET"; then
8478   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8479 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8480 else
8481   echo "$as_me:$LINENO: result: no" >&5
8482 echo "${ECHO_T}no" >&6
8483 fi
8484
8485   done
8486 fi
8487
8488 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8489   for ncn_progname in gcj; do
8490     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8491 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8492     if test -x $with_build_time_tools/${ncn_progname}; then
8493       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8494       echo "$as_me:$LINENO: result: yes" >&5
8495 echo "${ECHO_T}yes" >&6
8496       break
8497     else
8498       echo "$as_me:$LINENO: result: no" >&5
8499 echo "${ECHO_T}no" >&6
8500     fi
8501   done
8502 fi
8503
8504 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8505   for ncn_progname in gcj; do
8506     if test -n "$ncn_target_tool_prefix"; then
8507       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8508 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8509 echo "$as_me:$LINENO: checking for $ac_word" >&5
8510 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8511 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8512   echo $ECHO_N "(cached) $ECHO_C" >&6
8513 else
8514   if test -n "$GCJ_FOR_TARGET"; then
8515   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8516 else
8517 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8518 for as_dir in $PATH
8519 do
8520   IFS=$as_save_IFS
8521   test -z "$as_dir" && as_dir=.
8522   for ac_exec_ext in '' $ac_executable_extensions; do
8523   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8524     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8525     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8526     break 2
8527   fi
8528 done
8529 done
8530
8531 fi
8532 fi
8533 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8534 if test -n "$GCJ_FOR_TARGET"; then
8535   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8536 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8537 else
8538   echo "$as_me:$LINENO: result: no" >&5
8539 echo "${ECHO_T}no" >&6
8540 fi
8541
8542     fi
8543     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8544       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8545 set dummy ${ncn_progname}; ac_word=$2
8546 echo "$as_me:$LINENO: checking for $ac_word" >&5
8547 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8548 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8549   echo $ECHO_N "(cached) $ECHO_C" >&6
8550 else
8551   if test -n "$GCJ_FOR_TARGET"; then
8552   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8553 else
8554 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8555 for as_dir in $PATH
8556 do
8557   IFS=$as_save_IFS
8558   test -z "$as_dir" && as_dir=.
8559   for ac_exec_ext in '' $ac_executable_extensions; do
8560   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8561     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8562     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8563     break 2
8564   fi
8565 done
8566 done
8567
8568 fi
8569 fi
8570 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8571 if test -n "$GCJ_FOR_TARGET"; then
8572   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8573 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8574 else
8575   echo "$as_me:$LINENO: result: no" >&5
8576 echo "${ECHO_T}no" >&6
8577 fi
8578
8579     fi
8580     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8581   done
8582 fi
8583
8584 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8585   set dummy gcj
8586   if test $build = $target ; then
8587     GCJ_FOR_TARGET="$2"
8588   else
8589     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8590   fi
8591 else
8592   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8593 fi
8594
8595
8596
8597 if test -n "$GFORTRAN_FOR_TARGET"; then
8598   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8599 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8600   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8601 fi
8602
8603 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8604   for ncn_progname in gfortran; do
8605     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8606 set dummy ${ncn_progname}; ac_word=$2
8607 echo "$as_me:$LINENO: checking for $ac_word" >&5
8608 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8609 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8610   echo $ECHO_N "(cached) $ECHO_C" >&6
8611 else
8612   if test -n "$GFORTRAN_FOR_TARGET"; then
8613   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8614 else
8615 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8616 for as_dir in $PATH
8617 do
8618   IFS=$as_save_IFS
8619   test -z "$as_dir" && as_dir=.
8620   for ac_exec_ext in '' $ac_executable_extensions; do
8621   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8622     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8623     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8624     break 2
8625   fi
8626 done
8627 done
8628
8629 fi
8630 fi
8631 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8632 if test -n "$GFORTRAN_FOR_TARGET"; then
8633   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8634 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8635 else
8636   echo "$as_me:$LINENO: result: no" >&5
8637 echo "${ECHO_T}no" >&6
8638 fi
8639
8640   done
8641 fi
8642
8643 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8644   for ncn_progname in gfortran; do
8645     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8646 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8647     if test -x $with_build_time_tools/${ncn_progname}; then
8648       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8649       echo "$as_me:$LINENO: result: yes" >&5
8650 echo "${ECHO_T}yes" >&6
8651       break
8652     else
8653       echo "$as_me:$LINENO: result: no" >&5
8654 echo "${ECHO_T}no" >&6
8655     fi
8656   done
8657 fi
8658
8659 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8660   for ncn_progname in gfortran; do
8661     if test -n "$ncn_target_tool_prefix"; then
8662       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8663 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8664 echo "$as_me:$LINENO: checking for $ac_word" >&5
8665 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8666 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8667   echo $ECHO_N "(cached) $ECHO_C" >&6
8668 else
8669   if test -n "$GFORTRAN_FOR_TARGET"; then
8670   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8671 else
8672 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8673 for as_dir in $PATH
8674 do
8675   IFS=$as_save_IFS
8676   test -z "$as_dir" && as_dir=.
8677   for ac_exec_ext in '' $ac_executable_extensions; do
8678   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8679     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8680     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8681     break 2
8682   fi
8683 done
8684 done
8685
8686 fi
8687 fi
8688 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8689 if test -n "$GFORTRAN_FOR_TARGET"; then
8690   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8691 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8692 else
8693   echo "$as_me:$LINENO: result: no" >&5
8694 echo "${ECHO_T}no" >&6
8695 fi
8696
8697     fi
8698     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8699       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8700 set dummy ${ncn_progname}; ac_word=$2
8701 echo "$as_me:$LINENO: checking for $ac_word" >&5
8702 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8703 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8704   echo $ECHO_N "(cached) $ECHO_C" >&6
8705 else
8706   if test -n "$GFORTRAN_FOR_TARGET"; then
8707   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8708 else
8709 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8710 for as_dir in $PATH
8711 do
8712   IFS=$as_save_IFS
8713   test -z "$as_dir" && as_dir=.
8714   for ac_exec_ext in '' $ac_executable_extensions; do
8715   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8716     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8717     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8718     break 2
8719   fi
8720 done
8721 done
8722
8723 fi
8724 fi
8725 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8726 if test -n "$GFORTRAN_FOR_TARGET"; then
8727   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8728 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8729 else
8730   echo "$as_me:$LINENO: result: no" >&5
8731 echo "${ECHO_T}no" >&6
8732 fi
8733
8734     fi
8735     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8736   done
8737 fi
8738
8739 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8740   set dummy gfortran
8741   if test $build = $target ; then
8742     GFORTRAN_FOR_TARGET="$2"
8743   else
8744     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8745   fi
8746 else
8747   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8748 fi
8749
8750
8751
8752 cat > conftest.c << \EOF
8753 #ifdef __GNUC__
8754   gcc_yay;
8755 #endif
8756 EOF
8757 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8758   have_gcc_for_target=yes
8759 else
8760   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8761   have_gcc_for_target=no
8762 fi
8763 rm conftest.c
8764
8765
8766
8767
8768 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8769   if test -n "$with_build_time_tools"; then
8770     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8771 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8772     if test -x $with_build_time_tools/ar; then
8773       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8774       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8775       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8776 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8777     else
8778       echo "$as_me:$LINENO: result: no" >&5
8779 echo "${ECHO_T}no" >&6
8780     fi
8781   elif test $build != $host && test $have_gcc_for_target = yes; then
8782     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8783     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8784     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8785   fi
8786 fi
8787 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8788   # Extract the first word of "ar", so it can be a program name with args.
8789 set dummy ar; ac_word=$2
8790 echo "$as_me:$LINENO: checking for $ac_word" >&5
8791 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8792 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8793   echo $ECHO_N "(cached) $ECHO_C" >&6
8794 else
8795   case $AR_FOR_TARGET in
8796   [\\/]* | ?:[\\/]*)
8797   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8798   ;;
8799   *)
8800   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8801 for as_dir in $gcc_cv_tool_dirs
8802 do
8803   IFS=$as_save_IFS
8804   test -z "$as_dir" && as_dir=.
8805   for ac_exec_ext in '' $ac_executable_extensions; do
8806   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8807     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8808     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8809     break 2
8810   fi
8811 done
8812 done
8813
8814   ;;
8815 esac
8816 fi
8817 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8818
8819 if test -n "$AR_FOR_TARGET"; then
8820   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8821 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8822 else
8823   echo "$as_me:$LINENO: result: no" >&5
8824 echo "${ECHO_T}no" >&6
8825 fi
8826
8827 fi
8828 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8829
8830
8831 if test -n "$AR_FOR_TARGET"; then
8832   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8833 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8834   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8835 fi
8836
8837 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8838   for ncn_progname in ar; do
8839     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8840 set dummy ${ncn_progname}; ac_word=$2
8841 echo "$as_me:$LINENO: checking for $ac_word" >&5
8842 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8843 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8844   echo $ECHO_N "(cached) $ECHO_C" >&6
8845 else
8846   if test -n "$AR_FOR_TARGET"; then
8847   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8848 else
8849 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8850 for as_dir in $PATH
8851 do
8852   IFS=$as_save_IFS
8853   test -z "$as_dir" && as_dir=.
8854   for ac_exec_ext in '' $ac_executable_extensions; do
8855   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8856     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8857     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8858     break 2
8859   fi
8860 done
8861 done
8862
8863 fi
8864 fi
8865 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8866 if test -n "$AR_FOR_TARGET"; then
8867   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8868 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8869 else
8870   echo "$as_me:$LINENO: result: no" >&5
8871 echo "${ECHO_T}no" >&6
8872 fi
8873
8874   done
8875 fi
8876
8877 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8878   for ncn_progname in ar; do
8879     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8880 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8881     if test -x $with_build_time_tools/${ncn_progname}; then
8882       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8883       echo "$as_me:$LINENO: result: yes" >&5
8884 echo "${ECHO_T}yes" >&6
8885       break
8886     else
8887       echo "$as_me:$LINENO: result: no" >&5
8888 echo "${ECHO_T}no" >&6
8889     fi
8890   done
8891 fi
8892
8893 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8894   for ncn_progname in ar; do
8895     if test -n "$ncn_target_tool_prefix"; then
8896       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8897 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8898 echo "$as_me:$LINENO: checking for $ac_word" >&5
8899 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8900 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8901   echo $ECHO_N "(cached) $ECHO_C" >&6
8902 else
8903   if test -n "$AR_FOR_TARGET"; then
8904   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8905 else
8906 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8907 for as_dir in $PATH
8908 do
8909   IFS=$as_save_IFS
8910   test -z "$as_dir" && as_dir=.
8911   for ac_exec_ext in '' $ac_executable_extensions; do
8912   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8913     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8914     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8915     break 2
8916   fi
8917 done
8918 done
8919
8920 fi
8921 fi
8922 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8923 if test -n "$AR_FOR_TARGET"; then
8924   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8925 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8926 else
8927   echo "$as_me:$LINENO: result: no" >&5
8928 echo "${ECHO_T}no" >&6
8929 fi
8930
8931     fi
8932     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8933       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8934 set dummy ${ncn_progname}; ac_word=$2
8935 echo "$as_me:$LINENO: checking for $ac_word" >&5
8936 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8937 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8938   echo $ECHO_N "(cached) $ECHO_C" >&6
8939 else
8940   if test -n "$AR_FOR_TARGET"; then
8941   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8942 else
8943 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8944 for as_dir in $PATH
8945 do
8946   IFS=$as_save_IFS
8947   test -z "$as_dir" && as_dir=.
8948   for ac_exec_ext in '' $ac_executable_extensions; do
8949   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8950     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8951     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8952     break 2
8953   fi
8954 done
8955 done
8956
8957 fi
8958 fi
8959 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8960 if test -n "$AR_FOR_TARGET"; then
8961   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8962 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8963 else
8964   echo "$as_me:$LINENO: result: no" >&5
8965 echo "${ECHO_T}no" >&6
8966 fi
8967
8968     fi
8969     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
8970   done
8971 fi
8972
8973 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
8974   set dummy ar
8975   if test $build = $target ; then
8976     AR_FOR_TARGET="$2"
8977   else
8978     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
8979   fi
8980 else
8981   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
8982 fi
8983
8984 else
8985   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8986 fi
8987
8988
8989
8990
8991 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8992   if test -n "$with_build_time_tools"; then
8993     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
8994 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
8995     if test -x $with_build_time_tools/as; then
8996       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
8997       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8998       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
8999 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9000     else
9001       echo "$as_me:$LINENO: result: no" >&5
9002 echo "${ECHO_T}no" >&6
9003     fi
9004   elif test $build != $host && test $have_gcc_for_target = yes; then
9005     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9006     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9007     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9008   fi
9009 fi
9010 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9011   # Extract the first word of "as", so it can be a program name with args.
9012 set dummy as; ac_word=$2
9013 echo "$as_me:$LINENO: checking for $ac_word" >&5
9014 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9015 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9016   echo $ECHO_N "(cached) $ECHO_C" >&6
9017 else
9018   case $AS_FOR_TARGET in
9019   [\\/]* | ?:[\\/]*)
9020   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9021   ;;
9022   *)
9023   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9024 for as_dir in $gcc_cv_tool_dirs
9025 do
9026   IFS=$as_save_IFS
9027   test -z "$as_dir" && as_dir=.
9028   for ac_exec_ext in '' $ac_executable_extensions; do
9029   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9030     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9031     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9032     break 2
9033   fi
9034 done
9035 done
9036
9037   ;;
9038 esac
9039 fi
9040 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9041
9042 if test -n "$AS_FOR_TARGET"; then
9043   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9044 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9045 else
9046   echo "$as_me:$LINENO: result: no" >&5
9047 echo "${ECHO_T}no" >&6
9048 fi
9049
9050 fi
9051 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9052
9053
9054 if test -n "$AS_FOR_TARGET"; then
9055   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9056 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9057   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9058 fi
9059
9060 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9061   for ncn_progname in as; do
9062     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9063 set dummy ${ncn_progname}; ac_word=$2
9064 echo "$as_me:$LINENO: checking for $ac_word" >&5
9065 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9066 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9067   echo $ECHO_N "(cached) $ECHO_C" >&6
9068 else
9069   if test -n "$AS_FOR_TARGET"; then
9070   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9071 else
9072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9073 for as_dir in $PATH
9074 do
9075   IFS=$as_save_IFS
9076   test -z "$as_dir" && as_dir=.
9077   for ac_exec_ext in '' $ac_executable_extensions; do
9078   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9079     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9080     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9081     break 2
9082   fi
9083 done
9084 done
9085
9086 fi
9087 fi
9088 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9089 if test -n "$AS_FOR_TARGET"; then
9090   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9091 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9092 else
9093   echo "$as_me:$LINENO: result: no" >&5
9094 echo "${ECHO_T}no" >&6
9095 fi
9096
9097   done
9098 fi
9099
9100 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9101   for ncn_progname in as; do
9102     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9103 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9104     if test -x $with_build_time_tools/${ncn_progname}; then
9105       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9106       echo "$as_me:$LINENO: result: yes" >&5
9107 echo "${ECHO_T}yes" >&6
9108       break
9109     else
9110       echo "$as_me:$LINENO: result: no" >&5
9111 echo "${ECHO_T}no" >&6
9112     fi
9113   done
9114 fi
9115
9116 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9117   for ncn_progname in as; do
9118     if test -n "$ncn_target_tool_prefix"; then
9119       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9120 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9121 echo "$as_me:$LINENO: checking for $ac_word" >&5
9122 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9123 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9124   echo $ECHO_N "(cached) $ECHO_C" >&6
9125 else
9126   if test -n "$AS_FOR_TARGET"; then
9127   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9128 else
9129 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9130 for as_dir in $PATH
9131 do
9132   IFS=$as_save_IFS
9133   test -z "$as_dir" && as_dir=.
9134   for ac_exec_ext in '' $ac_executable_extensions; do
9135   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9136     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9137     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9138     break 2
9139   fi
9140 done
9141 done
9142
9143 fi
9144 fi
9145 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9146 if test -n "$AS_FOR_TARGET"; then
9147   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9148 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9149 else
9150   echo "$as_me:$LINENO: result: no" >&5
9151 echo "${ECHO_T}no" >&6
9152 fi
9153
9154     fi
9155     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9156       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9157 set dummy ${ncn_progname}; ac_word=$2
9158 echo "$as_me:$LINENO: checking for $ac_word" >&5
9159 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9160 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9161   echo $ECHO_N "(cached) $ECHO_C" >&6
9162 else
9163   if test -n "$AS_FOR_TARGET"; then
9164   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9165 else
9166 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9167 for as_dir in $PATH
9168 do
9169   IFS=$as_save_IFS
9170   test -z "$as_dir" && as_dir=.
9171   for ac_exec_ext in '' $ac_executable_extensions; do
9172   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9173     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9174     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9175     break 2
9176   fi
9177 done
9178 done
9179
9180 fi
9181 fi
9182 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9183 if test -n "$AS_FOR_TARGET"; then
9184   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9185 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9186 else
9187   echo "$as_me:$LINENO: result: no" >&5
9188 echo "${ECHO_T}no" >&6
9189 fi
9190
9191     fi
9192     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9193   done
9194 fi
9195
9196 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9197   set dummy as
9198   if test $build = $target ; then
9199     AS_FOR_TARGET="$2"
9200   else
9201     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9202   fi
9203 else
9204   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9205 fi
9206
9207 else
9208   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9209 fi
9210
9211
9212
9213
9214 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9215   if test -n "$with_build_time_tools"; then
9216     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9217 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9218     if test -x $with_build_time_tools/dlltool; then
9219       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9220       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9221       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9222 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9223     else
9224       echo "$as_me:$LINENO: result: no" >&5
9225 echo "${ECHO_T}no" >&6
9226     fi
9227   elif test $build != $host && test $have_gcc_for_target = yes; then
9228     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9229     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9230     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9231   fi
9232 fi
9233 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9234   # Extract the first word of "dlltool", so it can be a program name with args.
9235 set dummy dlltool; ac_word=$2
9236 echo "$as_me:$LINENO: checking for $ac_word" >&5
9237 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9238 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9239   echo $ECHO_N "(cached) $ECHO_C" >&6
9240 else
9241   case $DLLTOOL_FOR_TARGET in
9242   [\\/]* | ?:[\\/]*)
9243   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9244   ;;
9245   *)
9246   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9247 for as_dir in $gcc_cv_tool_dirs
9248 do
9249   IFS=$as_save_IFS
9250   test -z "$as_dir" && as_dir=.
9251   for ac_exec_ext in '' $ac_executable_extensions; do
9252   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9253     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9254     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9255     break 2
9256   fi
9257 done
9258 done
9259
9260   ;;
9261 esac
9262 fi
9263 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9264
9265 if test -n "$DLLTOOL_FOR_TARGET"; then
9266   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9267 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9268 else
9269   echo "$as_me:$LINENO: result: no" >&5
9270 echo "${ECHO_T}no" >&6
9271 fi
9272
9273 fi
9274 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9275
9276
9277 if test -n "$DLLTOOL_FOR_TARGET"; then
9278   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9279 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9280   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9281 fi
9282
9283 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9284   for ncn_progname in dlltool; do
9285     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9286 set dummy ${ncn_progname}; ac_word=$2
9287 echo "$as_me:$LINENO: checking for $ac_word" >&5
9288 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9289 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9290   echo $ECHO_N "(cached) $ECHO_C" >&6
9291 else
9292   if test -n "$DLLTOOL_FOR_TARGET"; then
9293   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9294 else
9295 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9296 for as_dir in $PATH
9297 do
9298   IFS=$as_save_IFS
9299   test -z "$as_dir" && as_dir=.
9300   for ac_exec_ext in '' $ac_executable_extensions; do
9301   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9302     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9303     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9304     break 2
9305   fi
9306 done
9307 done
9308
9309 fi
9310 fi
9311 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9312 if test -n "$DLLTOOL_FOR_TARGET"; then
9313   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9314 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9315 else
9316   echo "$as_me:$LINENO: result: no" >&5
9317 echo "${ECHO_T}no" >&6
9318 fi
9319
9320   done
9321 fi
9322
9323 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9324   for ncn_progname in dlltool; do
9325     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9326 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9327     if test -x $with_build_time_tools/${ncn_progname}; then
9328       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9329       echo "$as_me:$LINENO: result: yes" >&5
9330 echo "${ECHO_T}yes" >&6
9331       break
9332     else
9333       echo "$as_me:$LINENO: result: no" >&5
9334 echo "${ECHO_T}no" >&6
9335     fi
9336   done
9337 fi
9338
9339 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9340   for ncn_progname in dlltool; do
9341     if test -n "$ncn_target_tool_prefix"; then
9342       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9343 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9344 echo "$as_me:$LINENO: checking for $ac_word" >&5
9345 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9346 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9347   echo $ECHO_N "(cached) $ECHO_C" >&6
9348 else
9349   if test -n "$DLLTOOL_FOR_TARGET"; then
9350   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9351 else
9352 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9353 for as_dir in $PATH
9354 do
9355   IFS=$as_save_IFS
9356   test -z "$as_dir" && as_dir=.
9357   for ac_exec_ext in '' $ac_executable_extensions; do
9358   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9359     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9360     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9361     break 2
9362   fi
9363 done
9364 done
9365
9366 fi
9367 fi
9368 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9369 if test -n "$DLLTOOL_FOR_TARGET"; then
9370   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9371 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9372 else
9373   echo "$as_me:$LINENO: result: no" >&5
9374 echo "${ECHO_T}no" >&6
9375 fi
9376
9377     fi
9378     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9379       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9380 set dummy ${ncn_progname}; ac_word=$2
9381 echo "$as_me:$LINENO: checking for $ac_word" >&5
9382 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9383 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9384   echo $ECHO_N "(cached) $ECHO_C" >&6
9385 else
9386   if test -n "$DLLTOOL_FOR_TARGET"; then
9387   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9388 else
9389 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9390 for as_dir in $PATH
9391 do
9392   IFS=$as_save_IFS
9393   test -z "$as_dir" && as_dir=.
9394   for ac_exec_ext in '' $ac_executable_extensions; do
9395   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9396     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9397     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9398     break 2
9399   fi
9400 done
9401 done
9402
9403 fi
9404 fi
9405 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9406 if test -n "$DLLTOOL_FOR_TARGET"; then
9407   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9408 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9409 else
9410   echo "$as_me:$LINENO: result: no" >&5
9411 echo "${ECHO_T}no" >&6
9412 fi
9413
9414     fi
9415     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9416   done
9417 fi
9418
9419 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9420   set dummy dlltool
9421   if test $build = $target ; then
9422     DLLTOOL_FOR_TARGET="$2"
9423   else
9424     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9425   fi
9426 else
9427   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9428 fi
9429
9430 else
9431   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9432 fi
9433
9434
9435
9436
9437 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9438   if test -n "$with_build_time_tools"; then
9439     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9440 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9441     if test -x $with_build_time_tools/ld; then
9442       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9443       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9444       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9445 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9446     else
9447       echo "$as_me:$LINENO: result: no" >&5
9448 echo "${ECHO_T}no" >&6
9449     fi
9450   elif test $build != $host && test $have_gcc_for_target = yes; then
9451     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9452     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9453     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9454   fi
9455 fi
9456 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9457   # Extract the first word of "ld", so it can be a program name with args.
9458 set dummy ld; ac_word=$2
9459 echo "$as_me:$LINENO: checking for $ac_word" >&5
9460 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9461 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9462   echo $ECHO_N "(cached) $ECHO_C" >&6
9463 else
9464   case $LD_FOR_TARGET in
9465   [\\/]* | ?:[\\/]*)
9466   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9467   ;;
9468   *)
9469   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9470 for as_dir in $gcc_cv_tool_dirs
9471 do
9472   IFS=$as_save_IFS
9473   test -z "$as_dir" && as_dir=.
9474   for ac_exec_ext in '' $ac_executable_extensions; do
9475   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9476     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9477     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9478     break 2
9479   fi
9480 done
9481 done
9482
9483   ;;
9484 esac
9485 fi
9486 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9487
9488 if test -n "$LD_FOR_TARGET"; then
9489   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9490 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9491 else
9492   echo "$as_me:$LINENO: result: no" >&5
9493 echo "${ECHO_T}no" >&6
9494 fi
9495
9496 fi
9497 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9498
9499
9500 if test -n "$LD_FOR_TARGET"; then
9501   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9502 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9503   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9504 fi
9505
9506 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9507   for ncn_progname in ld; do
9508     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9509 set dummy ${ncn_progname}; ac_word=$2
9510 echo "$as_me:$LINENO: checking for $ac_word" >&5
9511 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9512 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9513   echo $ECHO_N "(cached) $ECHO_C" >&6
9514 else
9515   if test -n "$LD_FOR_TARGET"; then
9516   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9517 else
9518 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9519 for as_dir in $PATH
9520 do
9521   IFS=$as_save_IFS
9522   test -z "$as_dir" && as_dir=.
9523   for ac_exec_ext in '' $ac_executable_extensions; do
9524   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9525     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9526     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9527     break 2
9528   fi
9529 done
9530 done
9531
9532 fi
9533 fi
9534 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9535 if test -n "$LD_FOR_TARGET"; then
9536   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9537 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9538 else
9539   echo "$as_me:$LINENO: result: no" >&5
9540 echo "${ECHO_T}no" >&6
9541 fi
9542
9543   done
9544 fi
9545
9546 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9547   for ncn_progname in ld; do
9548     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9549 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9550     if test -x $with_build_time_tools/${ncn_progname}; then
9551       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9552       echo "$as_me:$LINENO: result: yes" >&5
9553 echo "${ECHO_T}yes" >&6
9554       break
9555     else
9556       echo "$as_me:$LINENO: result: no" >&5
9557 echo "${ECHO_T}no" >&6
9558     fi
9559   done
9560 fi
9561
9562 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9563   for ncn_progname in ld; do
9564     if test -n "$ncn_target_tool_prefix"; then
9565       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9566 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9567 echo "$as_me:$LINENO: checking for $ac_word" >&5
9568 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9569 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9570   echo $ECHO_N "(cached) $ECHO_C" >&6
9571 else
9572   if test -n "$LD_FOR_TARGET"; then
9573   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9574 else
9575 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9576 for as_dir in $PATH
9577 do
9578   IFS=$as_save_IFS
9579   test -z "$as_dir" && as_dir=.
9580   for ac_exec_ext in '' $ac_executable_extensions; do
9581   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9582     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9583     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9584     break 2
9585   fi
9586 done
9587 done
9588
9589 fi
9590 fi
9591 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9592 if test -n "$LD_FOR_TARGET"; then
9593   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9594 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9595 else
9596   echo "$as_me:$LINENO: result: no" >&5
9597 echo "${ECHO_T}no" >&6
9598 fi
9599
9600     fi
9601     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9602       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9603 set dummy ${ncn_progname}; ac_word=$2
9604 echo "$as_me:$LINENO: checking for $ac_word" >&5
9605 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9606 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9607   echo $ECHO_N "(cached) $ECHO_C" >&6
9608 else
9609   if test -n "$LD_FOR_TARGET"; then
9610   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9611 else
9612 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9613 for as_dir in $PATH
9614 do
9615   IFS=$as_save_IFS
9616   test -z "$as_dir" && as_dir=.
9617   for ac_exec_ext in '' $ac_executable_extensions; do
9618   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9619     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9620     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9621     break 2
9622   fi
9623 done
9624 done
9625
9626 fi
9627 fi
9628 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9629 if test -n "$LD_FOR_TARGET"; then
9630   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9631 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9632 else
9633   echo "$as_me:$LINENO: result: no" >&5
9634 echo "${ECHO_T}no" >&6
9635 fi
9636
9637     fi
9638     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9639   done
9640 fi
9641
9642 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9643   set dummy ld
9644   if test $build = $target ; then
9645     LD_FOR_TARGET="$2"
9646   else
9647     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9648   fi
9649 else
9650   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9651 fi
9652
9653 else
9654   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9655 fi
9656
9657
9658
9659
9660 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9661   if test -n "$with_build_time_tools"; then
9662     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9663 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9664     if test -x $with_build_time_tools/lipo; then
9665       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9666       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9667       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9668 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9669     else
9670       echo "$as_me:$LINENO: result: no" >&5
9671 echo "${ECHO_T}no" >&6
9672     fi
9673   elif test $build != $host && test $have_gcc_for_target = yes; then
9674     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9675     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9676     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9677   fi
9678 fi
9679 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9680   # Extract the first word of "lipo", so it can be a program name with args.
9681 set dummy lipo; ac_word=$2
9682 echo "$as_me:$LINENO: checking for $ac_word" >&5
9683 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9684 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9685   echo $ECHO_N "(cached) $ECHO_C" >&6
9686 else
9687   case $LIPO_FOR_TARGET in
9688   [\\/]* | ?:[\\/]*)
9689   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9690   ;;
9691   *)
9692   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9693 for as_dir in $gcc_cv_tool_dirs
9694 do
9695   IFS=$as_save_IFS
9696   test -z "$as_dir" && as_dir=.
9697   for ac_exec_ext in '' $ac_executable_extensions; do
9698   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9699     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9700     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9701     break 2
9702   fi
9703 done
9704 done
9705
9706   ;;
9707 esac
9708 fi
9709 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9710
9711 if test -n "$LIPO_FOR_TARGET"; then
9712   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9713 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9714 else
9715   echo "$as_me:$LINENO: result: no" >&5
9716 echo "${ECHO_T}no" >&6
9717 fi
9718
9719 fi
9720 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9721
9722
9723 if test -n "$LIPO_FOR_TARGET"; then
9724   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9725 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9726   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9727 fi
9728
9729 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9730   for ncn_progname in lipo; do
9731     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9732 set dummy ${ncn_progname}; ac_word=$2
9733 echo "$as_me:$LINENO: checking for $ac_word" >&5
9734 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9735 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9736   echo $ECHO_N "(cached) $ECHO_C" >&6
9737 else
9738   if test -n "$LIPO_FOR_TARGET"; then
9739   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9740 else
9741 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9742 for as_dir in $PATH
9743 do
9744   IFS=$as_save_IFS
9745   test -z "$as_dir" && as_dir=.
9746   for ac_exec_ext in '' $ac_executable_extensions; do
9747   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9748     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9749     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9750     break 2
9751   fi
9752 done
9753 done
9754
9755 fi
9756 fi
9757 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9758 if test -n "$LIPO_FOR_TARGET"; then
9759   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9760 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9761 else
9762   echo "$as_me:$LINENO: result: no" >&5
9763 echo "${ECHO_T}no" >&6
9764 fi
9765
9766   done
9767 fi
9768
9769 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9770   for ncn_progname in lipo; do
9771     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9772 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9773     if test -x $with_build_time_tools/${ncn_progname}; then
9774       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9775       echo "$as_me:$LINENO: result: yes" >&5
9776 echo "${ECHO_T}yes" >&6
9777       break
9778     else
9779       echo "$as_me:$LINENO: result: no" >&5
9780 echo "${ECHO_T}no" >&6
9781     fi
9782   done
9783 fi
9784
9785 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9786   for ncn_progname in lipo; do
9787     if test -n "$ncn_target_tool_prefix"; then
9788       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9789 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9790 echo "$as_me:$LINENO: checking for $ac_word" >&5
9791 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9792 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9793   echo $ECHO_N "(cached) $ECHO_C" >&6
9794 else
9795   if test -n "$LIPO_FOR_TARGET"; then
9796   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9797 else
9798 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9799 for as_dir in $PATH
9800 do
9801   IFS=$as_save_IFS
9802   test -z "$as_dir" && as_dir=.
9803   for ac_exec_ext in '' $ac_executable_extensions; do
9804   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9805     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9806     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9807     break 2
9808   fi
9809 done
9810 done
9811
9812 fi
9813 fi
9814 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9815 if test -n "$LIPO_FOR_TARGET"; then
9816   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9817 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9818 else
9819   echo "$as_me:$LINENO: result: no" >&5
9820 echo "${ECHO_T}no" >&6
9821 fi
9822
9823     fi
9824     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9825       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9826 set dummy ${ncn_progname}; ac_word=$2
9827 echo "$as_me:$LINENO: checking for $ac_word" >&5
9828 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9829 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9830   echo $ECHO_N "(cached) $ECHO_C" >&6
9831 else
9832   if test -n "$LIPO_FOR_TARGET"; then
9833   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9834 else
9835 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9836 for as_dir in $PATH
9837 do
9838   IFS=$as_save_IFS
9839   test -z "$as_dir" && as_dir=.
9840   for ac_exec_ext in '' $ac_executable_extensions; do
9841   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9842     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9843     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9844     break 2
9845   fi
9846 done
9847 done
9848
9849 fi
9850 fi
9851 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9852 if test -n "$LIPO_FOR_TARGET"; then
9853   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9854 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9855 else
9856   echo "$as_me:$LINENO: result: no" >&5
9857 echo "${ECHO_T}no" >&6
9858 fi
9859
9860     fi
9861     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9862   done
9863 fi
9864
9865 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9866   set dummy lipo
9867   if test $build = $target ; then
9868     LIPO_FOR_TARGET="$2"
9869   else
9870     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9871   fi
9872 else
9873   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9874 fi
9875
9876 else
9877   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9878 fi
9879
9880
9881
9882
9883 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9884   if test -n "$with_build_time_tools"; then
9885     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9886 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9887     if test -x $with_build_time_tools/nm; then
9888       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9889       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9890       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9891 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9892     else
9893       echo "$as_me:$LINENO: result: no" >&5
9894 echo "${ECHO_T}no" >&6
9895     fi
9896   elif test $build != $host && test $have_gcc_for_target = yes; then
9897     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9898     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
9899     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9900   fi
9901 fi
9902 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9903   # Extract the first word of "nm", so it can be a program name with args.
9904 set dummy nm; ac_word=$2
9905 echo "$as_me:$LINENO: checking for $ac_word" >&5
9906 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9907 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9908   echo $ECHO_N "(cached) $ECHO_C" >&6
9909 else
9910   case $NM_FOR_TARGET in
9911   [\\/]* | ?:[\\/]*)
9912   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9913   ;;
9914   *)
9915   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9916 for as_dir in $gcc_cv_tool_dirs
9917 do
9918   IFS=$as_save_IFS
9919   test -z "$as_dir" && as_dir=.
9920   for ac_exec_ext in '' $ac_executable_extensions; do
9921   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9922     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9923     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9924     break 2
9925   fi
9926 done
9927 done
9928
9929   ;;
9930 esac
9931 fi
9932 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9933
9934 if test -n "$NM_FOR_TARGET"; then
9935   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9936 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9937 else
9938   echo "$as_me:$LINENO: result: no" >&5
9939 echo "${ECHO_T}no" >&6
9940 fi
9941
9942 fi
9943 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9944
9945
9946 if test -n "$NM_FOR_TARGET"; then
9947   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9948 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9949   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9950 fi
9951
9952 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9953   for ncn_progname in nm; do
9954     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9955 set dummy ${ncn_progname}; ac_word=$2
9956 echo "$as_me:$LINENO: checking for $ac_word" >&5
9957 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9958 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9959   echo $ECHO_N "(cached) $ECHO_C" >&6
9960 else
9961   if test -n "$NM_FOR_TARGET"; then
9962   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9963 else
9964 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9965 for as_dir in $PATH
9966 do
9967   IFS=$as_save_IFS
9968   test -z "$as_dir" && as_dir=.
9969   for ac_exec_ext in '' $ac_executable_extensions; do
9970   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9971     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9972     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9973     break 2
9974   fi
9975 done
9976 done
9977
9978 fi
9979 fi
9980 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9981 if test -n "$NM_FOR_TARGET"; then
9982   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9983 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9984 else
9985   echo "$as_me:$LINENO: result: no" >&5
9986 echo "${ECHO_T}no" >&6
9987 fi
9988
9989   done
9990 fi
9991
9992 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
9993   for ncn_progname in nm; do
9994     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9995 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9996     if test -x $with_build_time_tools/${ncn_progname}; then
9997       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9998       echo "$as_me:$LINENO: result: yes" >&5
9999 echo "${ECHO_T}yes" >&6
10000       break
10001     else
10002       echo "$as_me:$LINENO: result: no" >&5
10003 echo "${ECHO_T}no" >&6
10004     fi
10005   done
10006 fi
10007
10008 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10009   for ncn_progname in nm; do
10010     if test -n "$ncn_target_tool_prefix"; then
10011       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10012 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10013 echo "$as_me:$LINENO: checking for $ac_word" >&5
10014 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10015 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10016   echo $ECHO_N "(cached) $ECHO_C" >&6
10017 else
10018   if test -n "$NM_FOR_TARGET"; then
10019   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10020 else
10021 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10022 for as_dir in $PATH
10023 do
10024   IFS=$as_save_IFS
10025   test -z "$as_dir" && as_dir=.
10026   for ac_exec_ext in '' $ac_executable_extensions; do
10027   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10028     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10029     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10030     break 2
10031   fi
10032 done
10033 done
10034
10035 fi
10036 fi
10037 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10038 if test -n "$NM_FOR_TARGET"; then
10039   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10040 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10041 else
10042   echo "$as_me:$LINENO: result: no" >&5
10043 echo "${ECHO_T}no" >&6
10044 fi
10045
10046     fi
10047     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10048       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10049 set dummy ${ncn_progname}; ac_word=$2
10050 echo "$as_me:$LINENO: checking for $ac_word" >&5
10051 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10052 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10053   echo $ECHO_N "(cached) $ECHO_C" >&6
10054 else
10055   if test -n "$NM_FOR_TARGET"; then
10056   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10057 else
10058 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10059 for as_dir in $PATH
10060 do
10061   IFS=$as_save_IFS
10062   test -z "$as_dir" && as_dir=.
10063   for ac_exec_ext in '' $ac_executable_extensions; do
10064   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10065     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10066     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10067     break 2
10068   fi
10069 done
10070 done
10071
10072 fi
10073 fi
10074 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10075 if test -n "$NM_FOR_TARGET"; then
10076   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10077 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10078 else
10079   echo "$as_me:$LINENO: result: no" >&5
10080 echo "${ECHO_T}no" >&6
10081 fi
10082
10083     fi
10084     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10085   done
10086 fi
10087
10088 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10089   set dummy nm
10090   if test $build = $target ; then
10091     NM_FOR_TARGET="$2"
10092   else
10093     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10094   fi
10095 else
10096   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10097 fi
10098
10099 else
10100   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10101 fi
10102
10103
10104
10105
10106 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10107   if test -n "$with_build_time_tools"; then
10108     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10109 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10110     if test -x $with_build_time_tools/objdump; then
10111       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10112       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10113       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10114 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10115     else
10116       echo "$as_me:$LINENO: result: no" >&5
10117 echo "${ECHO_T}no" >&6
10118     fi
10119   elif test $build != $host && test $have_gcc_for_target = yes; then
10120     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10121     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10122     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10123   fi
10124 fi
10125 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10126   # Extract the first word of "objdump", so it can be a program name with args.
10127 set dummy objdump; ac_word=$2
10128 echo "$as_me:$LINENO: checking for $ac_word" >&5
10129 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10130 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10131   echo $ECHO_N "(cached) $ECHO_C" >&6
10132 else
10133   case $OBJDUMP_FOR_TARGET in
10134   [\\/]* | ?:[\\/]*)
10135   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10136   ;;
10137   *)
10138   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10139 for as_dir in $gcc_cv_tool_dirs
10140 do
10141   IFS=$as_save_IFS
10142   test -z "$as_dir" && as_dir=.
10143   for ac_exec_ext in '' $ac_executable_extensions; do
10144   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10145     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10146     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10147     break 2
10148   fi
10149 done
10150 done
10151
10152   ;;
10153 esac
10154 fi
10155 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10156
10157 if test -n "$OBJDUMP_FOR_TARGET"; then
10158   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10159 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10160 else
10161   echo "$as_me:$LINENO: result: no" >&5
10162 echo "${ECHO_T}no" >&6
10163 fi
10164
10165 fi
10166 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10167
10168
10169 if test -n "$OBJDUMP_FOR_TARGET"; then
10170   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10171 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10172   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10173 fi
10174
10175 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10176   for ncn_progname in objdump; do
10177     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10178 set dummy ${ncn_progname}; ac_word=$2
10179 echo "$as_me:$LINENO: checking for $ac_word" >&5
10180 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10181 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10182   echo $ECHO_N "(cached) $ECHO_C" >&6
10183 else
10184   if test -n "$OBJDUMP_FOR_TARGET"; then
10185   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10186 else
10187 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10188 for as_dir in $PATH
10189 do
10190   IFS=$as_save_IFS
10191   test -z "$as_dir" && as_dir=.
10192   for ac_exec_ext in '' $ac_executable_extensions; do
10193   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10194     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10195     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10196     break 2
10197   fi
10198 done
10199 done
10200
10201 fi
10202 fi
10203 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10204 if test -n "$OBJDUMP_FOR_TARGET"; then
10205   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10206 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10207 else
10208   echo "$as_me:$LINENO: result: no" >&5
10209 echo "${ECHO_T}no" >&6
10210 fi
10211
10212   done
10213 fi
10214
10215 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10216   for ncn_progname in objdump; do
10217     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10218 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10219     if test -x $with_build_time_tools/${ncn_progname}; then
10220       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10221       echo "$as_me:$LINENO: result: yes" >&5
10222 echo "${ECHO_T}yes" >&6
10223       break
10224     else
10225       echo "$as_me:$LINENO: result: no" >&5
10226 echo "${ECHO_T}no" >&6
10227     fi
10228   done
10229 fi
10230
10231 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10232   for ncn_progname in objdump; do
10233     if test -n "$ncn_target_tool_prefix"; then
10234       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10235 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10236 echo "$as_me:$LINENO: checking for $ac_word" >&5
10237 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10238 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10239   echo $ECHO_N "(cached) $ECHO_C" >&6
10240 else
10241   if test -n "$OBJDUMP_FOR_TARGET"; then
10242   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10243 else
10244 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10245 for as_dir in $PATH
10246 do
10247   IFS=$as_save_IFS
10248   test -z "$as_dir" && as_dir=.
10249   for ac_exec_ext in '' $ac_executable_extensions; do
10250   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10251     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10252     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10253     break 2
10254   fi
10255 done
10256 done
10257
10258 fi
10259 fi
10260 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10261 if test -n "$OBJDUMP_FOR_TARGET"; then
10262   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10263 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10264 else
10265   echo "$as_me:$LINENO: result: no" >&5
10266 echo "${ECHO_T}no" >&6
10267 fi
10268
10269     fi
10270     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10271       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10272 set dummy ${ncn_progname}; ac_word=$2
10273 echo "$as_me:$LINENO: checking for $ac_word" >&5
10274 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10275 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10276   echo $ECHO_N "(cached) $ECHO_C" >&6
10277 else
10278   if test -n "$OBJDUMP_FOR_TARGET"; then
10279   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10280 else
10281 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10282 for as_dir in $PATH
10283 do
10284   IFS=$as_save_IFS
10285   test -z "$as_dir" && as_dir=.
10286   for ac_exec_ext in '' $ac_executable_extensions; do
10287   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10288     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10289     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10290     break 2
10291   fi
10292 done
10293 done
10294
10295 fi
10296 fi
10297 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10298 if test -n "$OBJDUMP_FOR_TARGET"; then
10299   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10300 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10301 else
10302   echo "$as_me:$LINENO: result: no" >&5
10303 echo "${ECHO_T}no" >&6
10304 fi
10305
10306     fi
10307     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10308   done
10309 fi
10310
10311 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10312   set dummy objdump
10313   if test $build = $target ; then
10314     OBJDUMP_FOR_TARGET="$2"
10315   else
10316     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10317   fi
10318 else
10319   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10320 fi
10321
10322 else
10323   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10324 fi
10325
10326
10327
10328
10329 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10330   if test -n "$with_build_time_tools"; then
10331     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10332 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10333     if test -x $with_build_time_tools/ranlib; then
10334       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10335       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10336       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10337 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10338     else
10339       echo "$as_me:$LINENO: result: no" >&5
10340 echo "${ECHO_T}no" >&6
10341     fi
10342   elif test $build != $host && test $have_gcc_for_target = yes; then
10343     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10344     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10345     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10346   fi
10347 fi
10348 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10349   # Extract the first word of "ranlib", so it can be a program name with args.
10350 set dummy ranlib; ac_word=$2
10351 echo "$as_me:$LINENO: checking for $ac_word" >&5
10352 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10353 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10354   echo $ECHO_N "(cached) $ECHO_C" >&6
10355 else
10356   case $RANLIB_FOR_TARGET in
10357   [\\/]* | ?:[\\/]*)
10358   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10359   ;;
10360   *)
10361   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10362 for as_dir in $gcc_cv_tool_dirs
10363 do
10364   IFS=$as_save_IFS
10365   test -z "$as_dir" && as_dir=.
10366   for ac_exec_ext in '' $ac_executable_extensions; do
10367   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10368     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10369     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10370     break 2
10371   fi
10372 done
10373 done
10374
10375   ;;
10376 esac
10377 fi
10378 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10379
10380 if test -n "$RANLIB_FOR_TARGET"; then
10381   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10382 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10383 else
10384   echo "$as_me:$LINENO: result: no" >&5
10385 echo "${ECHO_T}no" >&6
10386 fi
10387
10388 fi
10389 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10390
10391
10392 if test -n "$RANLIB_FOR_TARGET"; then
10393   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10394 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10395   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10396 fi
10397
10398 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10399   for ncn_progname in ranlib; do
10400     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10401 set dummy ${ncn_progname}; ac_word=$2
10402 echo "$as_me:$LINENO: checking for $ac_word" >&5
10403 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10404 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10405   echo $ECHO_N "(cached) $ECHO_C" >&6
10406 else
10407   if test -n "$RANLIB_FOR_TARGET"; then
10408   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10409 else
10410 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10411 for as_dir in $PATH
10412 do
10413   IFS=$as_save_IFS
10414   test -z "$as_dir" && as_dir=.
10415   for ac_exec_ext in '' $ac_executable_extensions; do
10416   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10417     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10418     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10419     break 2
10420   fi
10421 done
10422 done
10423
10424 fi
10425 fi
10426 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10427 if test -n "$RANLIB_FOR_TARGET"; then
10428   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10429 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10430 else
10431   echo "$as_me:$LINENO: result: no" >&5
10432 echo "${ECHO_T}no" >&6
10433 fi
10434
10435   done
10436 fi
10437
10438 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10439   for ncn_progname in ranlib; do
10440     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10441 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10442     if test -x $with_build_time_tools/${ncn_progname}; then
10443       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10444       echo "$as_me:$LINENO: result: yes" >&5
10445 echo "${ECHO_T}yes" >&6
10446       break
10447     else
10448       echo "$as_me:$LINENO: result: no" >&5
10449 echo "${ECHO_T}no" >&6
10450     fi
10451   done
10452 fi
10453
10454 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10455   for ncn_progname in ranlib; do
10456     if test -n "$ncn_target_tool_prefix"; then
10457       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10458 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10459 echo "$as_me:$LINENO: checking for $ac_word" >&5
10460 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10461 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10462   echo $ECHO_N "(cached) $ECHO_C" >&6
10463 else
10464   if test -n "$RANLIB_FOR_TARGET"; then
10465   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10466 else
10467 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10468 for as_dir in $PATH
10469 do
10470   IFS=$as_save_IFS
10471   test -z "$as_dir" && as_dir=.
10472   for ac_exec_ext in '' $ac_executable_extensions; do
10473   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10474     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10475     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10476     break 2
10477   fi
10478 done
10479 done
10480
10481 fi
10482 fi
10483 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10484 if test -n "$RANLIB_FOR_TARGET"; then
10485   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10486 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10487 else
10488   echo "$as_me:$LINENO: result: no" >&5
10489 echo "${ECHO_T}no" >&6
10490 fi
10491
10492     fi
10493     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10494       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10495 set dummy ${ncn_progname}; ac_word=$2
10496 echo "$as_me:$LINENO: checking for $ac_word" >&5
10497 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10498 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10499   echo $ECHO_N "(cached) $ECHO_C" >&6
10500 else
10501   if test -n "$RANLIB_FOR_TARGET"; then
10502   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10503 else
10504 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10505 for as_dir in $PATH
10506 do
10507   IFS=$as_save_IFS
10508   test -z "$as_dir" && as_dir=.
10509   for ac_exec_ext in '' $ac_executable_extensions; do
10510   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10511     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10512     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10513     break 2
10514   fi
10515 done
10516 done
10517
10518 fi
10519 fi
10520 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10521 if test -n "$RANLIB_FOR_TARGET"; then
10522   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10523 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10524 else
10525   echo "$as_me:$LINENO: result: no" >&5
10526 echo "${ECHO_T}no" >&6
10527 fi
10528
10529     fi
10530     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10531   done
10532 fi
10533
10534 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10535   set dummy ranlib
10536   if test $build = $target ; then
10537     RANLIB_FOR_TARGET="$2"
10538   else
10539     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10540   fi
10541 else
10542   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10543 fi
10544
10545 else
10546   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10547 fi
10548
10549
10550
10551
10552 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10553   if test -n "$with_build_time_tools"; then
10554     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10555 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10556     if test -x $with_build_time_tools/strip; then
10557       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10558       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10559       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10560 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10561     else
10562       echo "$as_me:$LINENO: result: no" >&5
10563 echo "${ECHO_T}no" >&6
10564     fi
10565   elif test $build != $host && test $have_gcc_for_target = yes; then
10566     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10567     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10568     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10569   fi
10570 fi
10571 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10572   # Extract the first word of "strip", so it can be a program name with args.
10573 set dummy strip; ac_word=$2
10574 echo "$as_me:$LINENO: checking for $ac_word" >&5
10575 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10576 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10577   echo $ECHO_N "(cached) $ECHO_C" >&6
10578 else
10579   case $STRIP_FOR_TARGET in
10580   [\\/]* | ?:[\\/]*)
10581   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10582   ;;
10583   *)
10584   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10585 for as_dir in $gcc_cv_tool_dirs
10586 do
10587   IFS=$as_save_IFS
10588   test -z "$as_dir" && as_dir=.
10589   for ac_exec_ext in '' $ac_executable_extensions; do
10590   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10591     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10592     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10593     break 2
10594   fi
10595 done
10596 done
10597
10598   ;;
10599 esac
10600 fi
10601 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10602
10603 if test -n "$STRIP_FOR_TARGET"; then
10604   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10605 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10606 else
10607   echo "$as_me:$LINENO: result: no" >&5
10608 echo "${ECHO_T}no" >&6
10609 fi
10610
10611 fi
10612 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10613
10614
10615 if test -n "$STRIP_FOR_TARGET"; then
10616   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10617 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10618   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10619 fi
10620
10621 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10622   for ncn_progname in strip; do
10623     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10624 set dummy ${ncn_progname}; ac_word=$2
10625 echo "$as_me:$LINENO: checking for $ac_word" >&5
10626 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10627 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10628   echo $ECHO_N "(cached) $ECHO_C" >&6
10629 else
10630   if test -n "$STRIP_FOR_TARGET"; then
10631   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10632 else
10633 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10634 for as_dir in $PATH
10635 do
10636   IFS=$as_save_IFS
10637   test -z "$as_dir" && as_dir=.
10638   for ac_exec_ext in '' $ac_executable_extensions; do
10639   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10640     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10641     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10642     break 2
10643   fi
10644 done
10645 done
10646
10647 fi
10648 fi
10649 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10650 if test -n "$STRIP_FOR_TARGET"; then
10651   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10652 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10653 else
10654   echo "$as_me:$LINENO: result: no" >&5
10655 echo "${ECHO_T}no" >&6
10656 fi
10657
10658   done
10659 fi
10660
10661 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10662   for ncn_progname in strip; do
10663     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10664 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10665     if test -x $with_build_time_tools/${ncn_progname}; then
10666       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10667       echo "$as_me:$LINENO: result: yes" >&5
10668 echo "${ECHO_T}yes" >&6
10669       break
10670     else
10671       echo "$as_me:$LINENO: result: no" >&5
10672 echo "${ECHO_T}no" >&6
10673     fi
10674   done
10675 fi
10676
10677 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10678   for ncn_progname in strip; do
10679     if test -n "$ncn_target_tool_prefix"; then
10680       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10681 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10682 echo "$as_me:$LINENO: checking for $ac_word" >&5
10683 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10684 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10685   echo $ECHO_N "(cached) $ECHO_C" >&6
10686 else
10687   if test -n "$STRIP_FOR_TARGET"; then
10688   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10689 else
10690 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10691 for as_dir in $PATH
10692 do
10693   IFS=$as_save_IFS
10694   test -z "$as_dir" && as_dir=.
10695   for ac_exec_ext in '' $ac_executable_extensions; do
10696   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10697     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10698     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10699     break 2
10700   fi
10701 done
10702 done
10703
10704 fi
10705 fi
10706 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10707 if test -n "$STRIP_FOR_TARGET"; then
10708   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10709 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10710 else
10711   echo "$as_me:$LINENO: result: no" >&5
10712 echo "${ECHO_T}no" >&6
10713 fi
10714
10715     fi
10716     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10717       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10718 set dummy ${ncn_progname}; ac_word=$2
10719 echo "$as_me:$LINENO: checking for $ac_word" >&5
10720 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10721 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10722   echo $ECHO_N "(cached) $ECHO_C" >&6
10723 else
10724   if test -n "$STRIP_FOR_TARGET"; then
10725   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10726 else
10727 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10728 for as_dir in $PATH
10729 do
10730   IFS=$as_save_IFS
10731   test -z "$as_dir" && as_dir=.
10732   for ac_exec_ext in '' $ac_executable_extensions; do
10733   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10734     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10735     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10736     break 2
10737   fi
10738 done
10739 done
10740
10741 fi
10742 fi
10743 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10744 if test -n "$STRIP_FOR_TARGET"; then
10745   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10746 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10747 else
10748   echo "$as_me:$LINENO: result: no" >&5
10749 echo "${ECHO_T}no" >&6
10750 fi
10751
10752     fi
10753     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10754   done
10755 fi
10756
10757 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10758   set dummy strip
10759   if test $build = $target ; then
10760     STRIP_FOR_TARGET="$2"
10761   else
10762     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10763   fi
10764 else
10765   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10766 fi
10767
10768 else
10769   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10770 fi
10771
10772
10773
10774
10775 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10776   if test -n "$with_build_time_tools"; then
10777     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10778 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10779     if test -x $with_build_time_tools/windres; then
10780       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10781       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10782       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10783 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10784     else
10785       echo "$as_me:$LINENO: result: no" >&5
10786 echo "${ECHO_T}no" >&6
10787     fi
10788   elif test $build != $host && test $have_gcc_for_target = yes; then
10789     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10790     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10791     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10792   fi
10793 fi
10794 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10795   # Extract the first word of "windres", so it can be a program name with args.
10796 set dummy windres; ac_word=$2
10797 echo "$as_me:$LINENO: checking for $ac_word" >&5
10798 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10799 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10800   echo $ECHO_N "(cached) $ECHO_C" >&6
10801 else
10802   case $WINDRES_FOR_TARGET in
10803   [\\/]* | ?:[\\/]*)
10804   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10805   ;;
10806   *)
10807   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10808 for as_dir in $gcc_cv_tool_dirs
10809 do
10810   IFS=$as_save_IFS
10811   test -z "$as_dir" && as_dir=.
10812   for ac_exec_ext in '' $ac_executable_extensions; do
10813   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10814     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10815     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10816     break 2
10817   fi
10818 done
10819 done
10820
10821   ;;
10822 esac
10823 fi
10824 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10825
10826 if test -n "$WINDRES_FOR_TARGET"; then
10827   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10828 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10829 else
10830   echo "$as_me:$LINENO: result: no" >&5
10831 echo "${ECHO_T}no" >&6
10832 fi
10833
10834 fi
10835 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10836
10837
10838 if test -n "$WINDRES_FOR_TARGET"; then
10839   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10840 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10841   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10842 fi
10843
10844 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10845   for ncn_progname in windres; do
10846     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10847 set dummy ${ncn_progname}; ac_word=$2
10848 echo "$as_me:$LINENO: checking for $ac_word" >&5
10849 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10850 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10851   echo $ECHO_N "(cached) $ECHO_C" >&6
10852 else
10853   if test -n "$WINDRES_FOR_TARGET"; then
10854   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10855 else
10856 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10857 for as_dir in $PATH
10858 do
10859   IFS=$as_save_IFS
10860   test -z "$as_dir" && as_dir=.
10861   for ac_exec_ext in '' $ac_executable_extensions; do
10862   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10863     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10864     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10865     break 2
10866   fi
10867 done
10868 done
10869
10870 fi
10871 fi
10872 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10873 if test -n "$WINDRES_FOR_TARGET"; then
10874   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10875 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10876 else
10877   echo "$as_me:$LINENO: result: no" >&5
10878 echo "${ECHO_T}no" >&6
10879 fi
10880
10881   done
10882 fi
10883
10884 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10885   for ncn_progname in windres; do
10886     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10887 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10888     if test -x $with_build_time_tools/${ncn_progname}; then
10889       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10890       echo "$as_me:$LINENO: result: yes" >&5
10891 echo "${ECHO_T}yes" >&6
10892       break
10893     else
10894       echo "$as_me:$LINENO: result: no" >&5
10895 echo "${ECHO_T}no" >&6
10896     fi
10897   done
10898 fi
10899
10900 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10901   for ncn_progname in windres; do
10902     if test -n "$ncn_target_tool_prefix"; then
10903       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10904 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10905 echo "$as_me:$LINENO: checking for $ac_word" >&5
10906 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10907 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10908   echo $ECHO_N "(cached) $ECHO_C" >&6
10909 else
10910   if test -n "$WINDRES_FOR_TARGET"; then
10911   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10912 else
10913 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10914 for as_dir in $PATH
10915 do
10916   IFS=$as_save_IFS
10917   test -z "$as_dir" && as_dir=.
10918   for ac_exec_ext in '' $ac_executable_extensions; do
10919   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10920     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10921     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10922     break 2
10923   fi
10924 done
10925 done
10926
10927 fi
10928 fi
10929 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10930 if test -n "$WINDRES_FOR_TARGET"; then
10931   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10932 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10933 else
10934   echo "$as_me:$LINENO: result: no" >&5
10935 echo "${ECHO_T}no" >&6
10936 fi
10937
10938     fi
10939     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10940       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10941 set dummy ${ncn_progname}; ac_word=$2
10942 echo "$as_me:$LINENO: checking for $ac_word" >&5
10943 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10944 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10945   echo $ECHO_N "(cached) $ECHO_C" >&6
10946 else
10947   if test -n "$WINDRES_FOR_TARGET"; then
10948   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10949 else
10950 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10951 for as_dir in $PATH
10952 do
10953   IFS=$as_save_IFS
10954   test -z "$as_dir" && as_dir=.
10955   for ac_exec_ext in '' $ac_executable_extensions; do
10956   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10957     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10958     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10959     break 2
10960   fi
10961 done
10962 done
10963
10964 fi
10965 fi
10966 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10967 if test -n "$WINDRES_FOR_TARGET"; then
10968   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10969 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10970 else
10971   echo "$as_me:$LINENO: result: no" >&5
10972 echo "${ECHO_T}no" >&6
10973 fi
10974
10975     fi
10976     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
10977   done
10978 fi
10979
10980 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
10981   set dummy windres
10982   if test $build = $target ; then
10983     WINDRES_FOR_TARGET="$2"
10984   else
10985     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
10986   fi
10987 else
10988   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
10989 fi
10990
10991 else
10992   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10993 fi
10994
10995
10996
10997
10998 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
10999   if test -n "$with_build_time_tools"; then
11000     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11001 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11002     if test -x $with_build_time_tools/windmc; then
11003       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11004       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11005       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11006 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11007     else
11008       echo "$as_me:$LINENO: result: no" >&5
11009 echo "${ECHO_T}no" >&6
11010     fi
11011   elif test $build != $host && test $have_gcc_for_target = yes; then
11012     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11013     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11014     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11015   fi
11016 fi
11017 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11018   # Extract the first word of "windmc", so it can be a program name with args.
11019 set dummy windmc; ac_word=$2
11020 echo "$as_me:$LINENO: checking for $ac_word" >&5
11021 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11022 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11023   echo $ECHO_N "(cached) $ECHO_C" >&6
11024 else
11025   case $WINDMC_FOR_TARGET in
11026   [\\/]* | ?:[\\/]*)
11027   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11028   ;;
11029   *)
11030   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11031 for as_dir in $gcc_cv_tool_dirs
11032 do
11033   IFS=$as_save_IFS
11034   test -z "$as_dir" && as_dir=.
11035   for ac_exec_ext in '' $ac_executable_extensions; do
11036   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11037     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11038     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11039     break 2
11040   fi
11041 done
11042 done
11043
11044   ;;
11045 esac
11046 fi
11047 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11048
11049 if test -n "$WINDMC_FOR_TARGET"; then
11050   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11051 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11052 else
11053   echo "$as_me:$LINENO: result: no" >&5
11054 echo "${ECHO_T}no" >&6
11055 fi
11056
11057 fi
11058 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11059
11060
11061 if test -n "$WINDMC_FOR_TARGET"; then
11062   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11063 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11064   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11065 fi
11066
11067 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11068   for ncn_progname in windmc; do
11069     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11070 set dummy ${ncn_progname}; ac_word=$2
11071 echo "$as_me:$LINENO: checking for $ac_word" >&5
11072 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11073 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11074   echo $ECHO_N "(cached) $ECHO_C" >&6
11075 else
11076   if test -n "$WINDMC_FOR_TARGET"; then
11077   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11078 else
11079 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11080 for as_dir in $PATH
11081 do
11082   IFS=$as_save_IFS
11083   test -z "$as_dir" && as_dir=.
11084   for ac_exec_ext in '' $ac_executable_extensions; do
11085   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11086     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11087     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11088     break 2
11089   fi
11090 done
11091 done
11092
11093 fi
11094 fi
11095 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11096 if test -n "$WINDMC_FOR_TARGET"; then
11097   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11098 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11099 else
11100   echo "$as_me:$LINENO: result: no" >&5
11101 echo "${ECHO_T}no" >&6
11102 fi
11103
11104   done
11105 fi
11106
11107 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11108   for ncn_progname in windmc; do
11109     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11110 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11111     if test -x $with_build_time_tools/${ncn_progname}; then
11112       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11113       echo "$as_me:$LINENO: result: yes" >&5
11114 echo "${ECHO_T}yes" >&6
11115       break
11116     else
11117       echo "$as_me:$LINENO: result: no" >&5
11118 echo "${ECHO_T}no" >&6
11119     fi
11120   done
11121 fi
11122
11123 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11124   for ncn_progname in windmc; do
11125     if test -n "$ncn_target_tool_prefix"; then
11126       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11127 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11128 echo "$as_me:$LINENO: checking for $ac_word" >&5
11129 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11130 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11131   echo $ECHO_N "(cached) $ECHO_C" >&6
11132 else
11133   if test -n "$WINDMC_FOR_TARGET"; then
11134   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11135 else
11136 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11137 for as_dir in $PATH
11138 do
11139   IFS=$as_save_IFS
11140   test -z "$as_dir" && as_dir=.
11141   for ac_exec_ext in '' $ac_executable_extensions; do
11142   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11143     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11144     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11145     break 2
11146   fi
11147 done
11148 done
11149
11150 fi
11151 fi
11152 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11153 if test -n "$WINDMC_FOR_TARGET"; then
11154   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11155 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11156 else
11157   echo "$as_me:$LINENO: result: no" >&5
11158 echo "${ECHO_T}no" >&6
11159 fi
11160
11161     fi
11162     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11163       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11164 set dummy ${ncn_progname}; ac_word=$2
11165 echo "$as_me:$LINENO: checking for $ac_word" >&5
11166 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11167 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11168   echo $ECHO_N "(cached) $ECHO_C" >&6
11169 else
11170   if test -n "$WINDMC_FOR_TARGET"; then
11171   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11172 else
11173 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11174 for as_dir in $PATH
11175 do
11176   IFS=$as_save_IFS
11177   test -z "$as_dir" && as_dir=.
11178   for ac_exec_ext in '' $ac_executable_extensions; do
11179   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11180     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11181     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11182     break 2
11183   fi
11184 done
11185 done
11186
11187 fi
11188 fi
11189 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11190 if test -n "$WINDMC_FOR_TARGET"; then
11191   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11192 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11193 else
11194   echo "$as_me:$LINENO: result: no" >&5
11195 echo "${ECHO_T}no" >&6
11196 fi
11197
11198     fi
11199     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11200   done
11201 fi
11202
11203 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11204   set dummy windmc
11205   if test $build = $target ; then
11206     WINDMC_FOR_TARGET="$2"
11207   else
11208     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11209   fi
11210 else
11211   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11212 fi
11213
11214 else
11215   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11216 fi
11217
11218
11219 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11220
11221 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11222 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11223 if test "x${build}" != "x${host}" ; then
11224   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11225     # We already found the complete path
11226     ac_dir=`dirname $AR_FOR_TARGET`
11227     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11228 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11229   else
11230     # Canadian cross, just use what we found
11231     echo "$as_me:$LINENO: result: pre-installed" >&5
11232 echo "${ECHO_T}pre-installed" >&6
11233   fi
11234 else
11235   ok=yes
11236   case " ${configdirs} " in
11237     *" binutils "*) ;;
11238     *) ok=no ;;
11239   esac
11240
11241   if test $ok = yes; then
11242     # An in-tree tool is available and we can use it
11243     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11244     echo "$as_me:$LINENO: result: just compiled" >&5
11245 echo "${ECHO_T}just compiled" >&6
11246   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11247     # We already found the complete path
11248     ac_dir=`dirname $AR_FOR_TARGET`
11249     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11250 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11251   elif test "x$target" = "x$host"; then
11252     # We can use an host tool
11253     AR_FOR_TARGET='$(AR)'
11254     echo "$as_me:$LINENO: result: host tool" >&5
11255 echo "${ECHO_T}host tool" >&6
11256   else
11257     # We need a cross tool
11258     echo "$as_me:$LINENO: result: pre-installed" >&5
11259 echo "${ECHO_T}pre-installed" >&6
11260   fi
11261 fi
11262
11263 echo "$as_me:$LINENO: checking where to find the target as" >&5
11264 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11265 if test "x${build}" != "x${host}" ; then
11266   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11267     # We already found the complete path
11268     ac_dir=`dirname $AS_FOR_TARGET`
11269     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11270 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11271   else
11272     # Canadian cross, just use what we found
11273     echo "$as_me:$LINENO: result: pre-installed" >&5
11274 echo "${ECHO_T}pre-installed" >&6
11275   fi
11276 else
11277   ok=yes
11278   case " ${configdirs} " in
11279     *" gas "*) ;;
11280     *) ok=no ;;
11281   esac
11282
11283   if test $ok = yes; then
11284     # An in-tree tool is available and we can use it
11285     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11286     echo "$as_me:$LINENO: result: just compiled" >&5
11287 echo "${ECHO_T}just compiled" >&6
11288   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11289     # We already found the complete path
11290     ac_dir=`dirname $AS_FOR_TARGET`
11291     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11292 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11293   elif test "x$target" = "x$host"; then
11294     # We can use an host tool
11295     AS_FOR_TARGET='$(AS)'
11296     echo "$as_me:$LINENO: result: host tool" >&5
11297 echo "${ECHO_T}host tool" >&6
11298   else
11299     # We need a cross tool
11300     echo "$as_me:$LINENO: result: pre-installed" >&5
11301 echo "${ECHO_T}pre-installed" >&6
11302   fi
11303 fi
11304
11305 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11306 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11307 if test "x${build}" != "x${host}" ; then
11308   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11309     # We already found the complete path
11310     ac_dir=`dirname $CC_FOR_TARGET`
11311     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11312 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11313   else
11314     # Canadian cross, just use what we found
11315     echo "$as_me:$LINENO: result: pre-installed" >&5
11316 echo "${ECHO_T}pre-installed" >&6
11317   fi
11318 else
11319   ok=yes
11320   case " ${configdirs} " in
11321     *" gcc "*) ;;
11322     *) ok=no ;;
11323   esac
11324
11325   if test $ok = yes; then
11326     # An in-tree tool is available and we can use it
11327     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11328     echo "$as_me:$LINENO: result: just compiled" >&5
11329 echo "${ECHO_T}just compiled" >&6
11330   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11331     # We already found the complete path
11332     ac_dir=`dirname $CC_FOR_TARGET`
11333     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11334 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11335   elif test "x$target" = "x$host"; then
11336     # We can use an host tool
11337     CC_FOR_TARGET='$(CC)'
11338     echo "$as_me:$LINENO: result: host tool" >&5
11339 echo "${ECHO_T}host tool" >&6
11340   else
11341     # We need a cross tool
11342     echo "$as_me:$LINENO: result: pre-installed" >&5
11343 echo "${ECHO_T}pre-installed" >&6
11344   fi
11345 fi
11346
11347 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11348 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11349 if test "x${build}" != "x${host}" ; then
11350   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11351     # We already found the complete path
11352     ac_dir=`dirname $CXX_FOR_TARGET`
11353     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11354 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11355   else
11356     # Canadian cross, just use what we found
11357     echo "$as_me:$LINENO: result: pre-installed" >&5
11358 echo "${ECHO_T}pre-installed" >&6
11359   fi
11360 else
11361   ok=yes
11362   case " ${configdirs} " in
11363     *" gcc "*) ;;
11364     *) ok=no ;;
11365   esac
11366   case ,${enable_languages}, in
11367     *,c++,*) ;;
11368     *) ok=no ;;
11369   esac
11370   if test $ok = yes; then
11371     # An in-tree tool is available and we can use it
11372     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'
11373     echo "$as_me:$LINENO: result: just compiled" >&5
11374 echo "${ECHO_T}just compiled" >&6
11375   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11376     # We already found the complete path
11377     ac_dir=`dirname $CXX_FOR_TARGET`
11378     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11379 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11380   elif test "x$target" = "x$host"; then
11381     # We can use an host tool
11382     CXX_FOR_TARGET='$(CXX)'
11383     echo "$as_me:$LINENO: result: host tool" >&5
11384 echo "${ECHO_T}host tool" >&6
11385   else
11386     # We need a cross tool
11387     echo "$as_me:$LINENO: result: pre-installed" >&5
11388 echo "${ECHO_T}pre-installed" >&6
11389   fi
11390 fi
11391
11392 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11393 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11394 if test "x${build}" != "x${host}" ; then
11395   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11396     # We already found the complete path
11397     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11398     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11399 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11400   else
11401     # Canadian cross, just use what we found
11402     echo "$as_me:$LINENO: result: pre-installed" >&5
11403 echo "${ECHO_T}pre-installed" >&6
11404   fi
11405 else
11406   ok=yes
11407   case " ${configdirs} " in
11408     *" gcc "*) ;;
11409     *) ok=no ;;
11410   esac
11411   case ,${enable_languages}, in
11412     *,c++,*) ;;
11413     *) ok=no ;;
11414   esac
11415   if test $ok = yes; then
11416     # An in-tree tool is available and we can use it
11417     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'
11418     echo "$as_me:$LINENO: result: just compiled" >&5
11419 echo "${ECHO_T}just compiled" >&6
11420   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11421     # We already found the complete path
11422     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11423     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11424 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11425   elif test "x$target" = "x$host"; then
11426     # We can use an host tool
11427     RAW_CXX_FOR_TARGET='$(CXX)'
11428     echo "$as_me:$LINENO: result: host tool" >&5
11429 echo "${ECHO_T}host tool" >&6
11430   else
11431     # We need a cross tool
11432     echo "$as_me:$LINENO: result: pre-installed" >&5
11433 echo "${ECHO_T}pre-installed" >&6
11434   fi
11435 fi
11436
11437 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11438 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11439 if test "x${build}" != "x${host}" ; then
11440   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11441     # We already found the complete path
11442     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11443     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11444 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11445   else
11446     # Canadian cross, just use what we found
11447     echo "$as_me:$LINENO: result: pre-installed" >&5
11448 echo "${ECHO_T}pre-installed" >&6
11449   fi
11450 else
11451   ok=yes
11452   case " ${configdirs} " in
11453     *" binutils "*) ;;
11454     *) ok=no ;;
11455   esac
11456
11457   if test $ok = yes; then
11458     # An in-tree tool is available and we can use it
11459     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11460     echo "$as_me:$LINENO: result: just compiled" >&5
11461 echo "${ECHO_T}just compiled" >&6
11462   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11463     # We already found the complete path
11464     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11465     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11466 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11467   elif test "x$target" = "x$host"; then
11468     # We can use an host tool
11469     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11470     echo "$as_me:$LINENO: result: host tool" >&5
11471 echo "${ECHO_T}host tool" >&6
11472   else
11473     # We need a cross tool
11474     echo "$as_me:$LINENO: result: pre-installed" >&5
11475 echo "${ECHO_T}pre-installed" >&6
11476   fi
11477 fi
11478
11479 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11480 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11481 if test "x${build}" != "x${host}" ; then
11482   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11483     # We already found the complete path
11484     ac_dir=`dirname $GCC_FOR_TARGET`
11485     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11486 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11487   else
11488     # Canadian cross, just use what we found
11489     echo "$as_me:$LINENO: result: pre-installed" >&5
11490 echo "${ECHO_T}pre-installed" >&6
11491   fi
11492 else
11493   ok=yes
11494   case " ${configdirs} " in
11495     *" gcc "*) ;;
11496     *) ok=no ;;
11497   esac
11498
11499   if test $ok = yes; then
11500     # An in-tree tool is available and we can use it
11501     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11502     echo "$as_me:$LINENO: result: just compiled" >&5
11503 echo "${ECHO_T}just compiled" >&6
11504   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11505     # We already found the complete path
11506     ac_dir=`dirname $GCC_FOR_TARGET`
11507     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11508 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11509   elif test "x$target" = "x$host"; then
11510     # We can use an host tool
11511     GCC_FOR_TARGET='$()'
11512     echo "$as_me:$LINENO: result: host tool" >&5
11513 echo "${ECHO_T}host tool" >&6
11514   else
11515     # We need a cross tool
11516     echo "$as_me:$LINENO: result: pre-installed" >&5
11517 echo "${ECHO_T}pre-installed" >&6
11518   fi
11519 fi
11520
11521 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11522 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11523 if test "x${build}" != "x${host}" ; then
11524   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11525     # We already found the complete path
11526     ac_dir=`dirname $GCJ_FOR_TARGET`
11527     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11528 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11529   else
11530     # Canadian cross, just use what we found
11531     echo "$as_me:$LINENO: result: pre-installed" >&5
11532 echo "${ECHO_T}pre-installed" >&6
11533   fi
11534 else
11535   ok=yes
11536   case " ${configdirs} " in
11537     *" gcc "*) ;;
11538     *) ok=no ;;
11539   esac
11540   case ,${enable_languages}, in
11541     *,java,*) ;;
11542     *) ok=no ;;
11543   esac
11544   if test $ok = yes; then
11545     # An in-tree tool is available and we can use it
11546     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11547     echo "$as_me:$LINENO: result: just compiled" >&5
11548 echo "${ECHO_T}just compiled" >&6
11549   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11550     # We already found the complete path
11551     ac_dir=`dirname $GCJ_FOR_TARGET`
11552     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11553 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11554   elif test "x$target" = "x$host"; then
11555     # We can use an host tool
11556     GCJ_FOR_TARGET='$(GCJ)'
11557     echo "$as_me:$LINENO: result: host tool" >&5
11558 echo "${ECHO_T}host tool" >&6
11559   else
11560     # We need a cross tool
11561     echo "$as_me:$LINENO: result: pre-installed" >&5
11562 echo "${ECHO_T}pre-installed" >&6
11563   fi
11564 fi
11565
11566 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11567 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11568 if test "x${build}" != "x${host}" ; then
11569   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11570     # We already found the complete path
11571     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11572     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11573 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11574   else
11575     # Canadian cross, just use what we found
11576     echo "$as_me:$LINENO: result: pre-installed" >&5
11577 echo "${ECHO_T}pre-installed" >&6
11578   fi
11579 else
11580   ok=yes
11581   case " ${configdirs} " in
11582     *" gcc "*) ;;
11583     *) ok=no ;;
11584   esac
11585   case ,${enable_languages}, in
11586     *,fortran,*) ;;
11587     *) ok=no ;;
11588   esac
11589   if test $ok = yes; then
11590     # An in-tree tool is available and we can use it
11591     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11592     echo "$as_me:$LINENO: result: just compiled" >&5
11593 echo "${ECHO_T}just compiled" >&6
11594   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11595     # We already found the complete path
11596     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11597     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11598 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11599   elif test "x$target" = "x$host"; then
11600     # We can use an host tool
11601     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11602     echo "$as_me:$LINENO: result: host tool" >&5
11603 echo "${ECHO_T}host tool" >&6
11604   else
11605     # We need a cross tool
11606     echo "$as_me:$LINENO: result: pre-installed" >&5
11607 echo "${ECHO_T}pre-installed" >&6
11608   fi
11609 fi
11610
11611 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11612 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11613 if test "x${build}" != "x${host}" ; then
11614   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11615     # We already found the complete path
11616     ac_dir=`dirname $LD_FOR_TARGET`
11617     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11618 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11619   else
11620     # Canadian cross, just use what we found
11621     echo "$as_me:$LINENO: result: pre-installed" >&5
11622 echo "${ECHO_T}pre-installed" >&6
11623   fi
11624 else
11625   ok=yes
11626   case " ${configdirs} " in
11627     *" ld "*) ;;
11628     *) ok=no ;;
11629   esac
11630
11631   if test $ok = yes; then
11632     # An in-tree tool is available and we can use it
11633     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11634     echo "$as_me:$LINENO: result: just compiled" >&5
11635 echo "${ECHO_T}just compiled" >&6
11636   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11637     # We already found the complete path
11638     ac_dir=`dirname $LD_FOR_TARGET`
11639     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11640 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11641   elif test "x$target" = "x$host"; then
11642     # We can use an host tool
11643     LD_FOR_TARGET='$(LD)'
11644     echo "$as_me:$LINENO: result: host tool" >&5
11645 echo "${ECHO_T}host tool" >&6
11646   else
11647     # We need a cross tool
11648     echo "$as_me:$LINENO: result: pre-installed" >&5
11649 echo "${ECHO_T}pre-installed" >&6
11650   fi
11651 fi
11652
11653 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11654 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11655 if test "x${build}" != "x${host}" ; then
11656   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11657     # We already found the complete path
11658     ac_dir=`dirname $LIPO_FOR_TARGET`
11659     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11660 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11661   else
11662     # Canadian cross, just use what we found
11663     echo "$as_me:$LINENO: result: pre-installed" >&5
11664 echo "${ECHO_T}pre-installed" >&6
11665   fi
11666 else
11667   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11668     # We already found the complete path
11669     ac_dir=`dirname $LIPO_FOR_TARGET`
11670     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11671 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11672   elif test "x$target" = "x$host"; then
11673     # We can use an host tool
11674     LIPO_FOR_TARGET='$(LIPO)'
11675     echo "$as_me:$LINENO: result: host tool" >&5
11676 echo "${ECHO_T}host tool" >&6
11677   else
11678     # We need a cross tool
11679     echo "$as_me:$LINENO: result: pre-installed" >&5
11680 echo "${ECHO_T}pre-installed" >&6
11681   fi
11682 fi
11683
11684 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11685 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11686 if test "x${build}" != "x${host}" ; then
11687   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11688     # We already found the complete path
11689     ac_dir=`dirname $NM_FOR_TARGET`
11690     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11691 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11692   else
11693     # Canadian cross, just use what we found
11694     echo "$as_me:$LINENO: result: pre-installed" >&5
11695 echo "${ECHO_T}pre-installed" >&6
11696   fi
11697 else
11698   ok=yes
11699   case " ${configdirs} " in
11700     *" binutils "*) ;;
11701     *) ok=no ;;
11702   esac
11703
11704   if test $ok = yes; then
11705     # An in-tree tool is available and we can use it
11706     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11707     echo "$as_me:$LINENO: result: just compiled" >&5
11708 echo "${ECHO_T}just compiled" >&6
11709   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11710     # We already found the complete path
11711     ac_dir=`dirname $NM_FOR_TARGET`
11712     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11713 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11714   elif test "x$target" = "x$host"; then
11715     # We can use an host tool
11716     NM_FOR_TARGET='$(NM)'
11717     echo "$as_me:$LINENO: result: host tool" >&5
11718 echo "${ECHO_T}host tool" >&6
11719   else
11720     # We need a cross tool
11721     echo "$as_me:$LINENO: result: pre-installed" >&5
11722 echo "${ECHO_T}pre-installed" >&6
11723   fi
11724 fi
11725
11726 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11727 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11728 if test "x${build}" != "x${host}" ; then
11729   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11730     # We already found the complete path
11731     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11732     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11733 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11734   else
11735     # Canadian cross, just use what we found
11736     echo "$as_me:$LINENO: result: pre-installed" >&5
11737 echo "${ECHO_T}pre-installed" >&6
11738   fi
11739 else
11740   ok=yes
11741   case " ${configdirs} " in
11742     *" binutils "*) ;;
11743     *) ok=no ;;
11744   esac
11745
11746   if test $ok = yes; then
11747     # An in-tree tool is available and we can use it
11748     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11749     echo "$as_me:$LINENO: result: just compiled" >&5
11750 echo "${ECHO_T}just compiled" >&6
11751   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11752     # We already found the complete path
11753     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11754     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11755 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11756   elif test "x$target" = "x$host"; then
11757     # We can use an host tool
11758     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11759     echo "$as_me:$LINENO: result: host tool" >&5
11760 echo "${ECHO_T}host tool" >&6
11761   else
11762     # We need a cross tool
11763     echo "$as_me:$LINENO: result: pre-installed" >&5
11764 echo "${ECHO_T}pre-installed" >&6
11765   fi
11766 fi
11767
11768 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11769 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11770 if test "x${build}" != "x${host}" ; then
11771   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11772     # We already found the complete path
11773     ac_dir=`dirname $RANLIB_FOR_TARGET`
11774     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11775 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11776   else
11777     # Canadian cross, just use what we found
11778     echo "$as_me:$LINENO: result: pre-installed" >&5
11779 echo "${ECHO_T}pre-installed" >&6
11780   fi
11781 else
11782   ok=yes
11783   case " ${configdirs} " in
11784     *" binutils "*) ;;
11785     *) ok=no ;;
11786   esac
11787
11788   if test $ok = yes; then
11789     # An in-tree tool is available and we can use it
11790     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11791     echo "$as_me:$LINENO: result: just compiled" >&5
11792 echo "${ECHO_T}just compiled" >&6
11793   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11794     # We already found the complete path
11795     ac_dir=`dirname $RANLIB_FOR_TARGET`
11796     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11797 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11798   elif test "x$target" = "x$host"; then
11799     # We can use an host tool
11800     RANLIB_FOR_TARGET='$(RANLIB)'
11801     echo "$as_me:$LINENO: result: host tool" >&5
11802 echo "${ECHO_T}host tool" >&6
11803   else
11804     # We need a cross tool
11805     echo "$as_me:$LINENO: result: pre-installed" >&5
11806 echo "${ECHO_T}pre-installed" >&6
11807   fi
11808 fi
11809
11810 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11811 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11812 if test "x${build}" != "x${host}" ; then
11813   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11814     # We already found the complete path
11815     ac_dir=`dirname $STRIP_FOR_TARGET`
11816     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11817 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11818   else
11819     # Canadian cross, just use what we found
11820     echo "$as_me:$LINENO: result: pre-installed" >&5
11821 echo "${ECHO_T}pre-installed" >&6
11822   fi
11823 else
11824   ok=yes
11825   case " ${configdirs} " in
11826     *" binutils "*) ;;
11827     *) ok=no ;;
11828   esac
11829
11830   if test $ok = yes; then
11831     # An in-tree tool is available and we can use it
11832     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11833     echo "$as_me:$LINENO: result: just compiled" >&5
11834 echo "${ECHO_T}just compiled" >&6
11835   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11836     # We already found the complete path
11837     ac_dir=`dirname $STRIP_FOR_TARGET`
11838     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11839 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11840   elif test "x$target" = "x$host"; then
11841     # We can use an host tool
11842     STRIP_FOR_TARGET='$(STRIP)'
11843     echo "$as_me:$LINENO: result: host tool" >&5
11844 echo "${ECHO_T}host tool" >&6
11845   else
11846     # We need a cross tool
11847     echo "$as_me:$LINENO: result: pre-installed" >&5
11848 echo "${ECHO_T}pre-installed" >&6
11849   fi
11850 fi
11851
11852 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11853 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11854 if test "x${build}" != "x${host}" ; then
11855   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11856     # We already found the complete path
11857     ac_dir=`dirname $WINDRES_FOR_TARGET`
11858     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11859 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11860   else
11861     # Canadian cross, just use what we found
11862     echo "$as_me:$LINENO: result: pre-installed" >&5
11863 echo "${ECHO_T}pre-installed" >&6
11864   fi
11865 else
11866   ok=yes
11867   case " ${configdirs} " in
11868     *" binutils "*) ;;
11869     *) ok=no ;;
11870   esac
11871
11872   if test $ok = yes; then
11873     # An in-tree tool is available and we can use it
11874     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11875     echo "$as_me:$LINENO: result: just compiled" >&5
11876 echo "${ECHO_T}just compiled" >&6
11877   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11878     # We already found the complete path
11879     ac_dir=`dirname $WINDRES_FOR_TARGET`
11880     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11881 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11882   elif test "x$target" = "x$host"; then
11883     # We can use an host tool
11884     WINDRES_FOR_TARGET='$(WINDRES)'
11885     echo "$as_me:$LINENO: result: host tool" >&5
11886 echo "${ECHO_T}host tool" >&6
11887   else
11888     # We need a cross tool
11889     echo "$as_me:$LINENO: result: pre-installed" >&5
11890 echo "${ECHO_T}pre-installed" >&6
11891   fi
11892 fi
11893
11894 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
11895 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
11896 if test "x${build}" != "x${host}" ; then
11897   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11898     # We already found the complete path
11899     ac_dir=`dirname $WINDMC_FOR_TARGET`
11900     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11901 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11902   else
11903     # Canadian cross, just use what we found
11904     echo "$as_me:$LINENO: result: pre-installed" >&5
11905 echo "${ECHO_T}pre-installed" >&6
11906   fi
11907 else
11908   ok=yes
11909   case " ${configdirs} " in
11910     *" binutils "*) ;;
11911     *) ok=no ;;
11912   esac
11913
11914   if test $ok = yes; then
11915     # An in-tree tool is available and we can use it
11916     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
11917     echo "$as_me:$LINENO: result: just compiled" >&5
11918 echo "${ECHO_T}just compiled" >&6
11919   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11920     # We already found the complete path
11921     ac_dir=`dirname $WINDMC_FOR_TARGET`
11922     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11923 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11924   elif test "x$target" = "x$host"; then
11925     # We can use an host tool
11926     WINDMC_FOR_TARGET='$(WINDMC)'
11927     echo "$as_me:$LINENO: result: host tool" >&5
11928 echo "${ECHO_T}host tool" >&6
11929   else
11930     # We need a cross tool
11931     echo "$as_me:$LINENO: result: pre-installed" >&5
11932 echo "${ECHO_T}pre-installed" >&6
11933   fi
11934 fi
11935
11936
11937
11938
11939
11940 # Certain tools may need extra flags.
11941 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11942 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11943 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11944
11945 # When building target libraries, except in a Canadian cross, we use
11946 # the same toolchain as the compiler we just built.
11947 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11948 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11949 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11950 if test $host = $build; then
11951   case " $configdirs " in
11952     *" gcc "*)
11953       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11954       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11955       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11956       ;;
11957   esac
11958 fi
11959
11960
11961
11962
11963
11964 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
11965 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
11966 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
11967 if test "${enable_maintainer_mode+set}" = set; then
11968   enableval="$enable_maintainer_mode"
11969   USE_MAINTAINER_MODE=$enableval
11970 else
11971   USE_MAINTAINER_MODE=no
11972 fi;
11973 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
11974 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
11975
11976
11977 if test "$USE_MAINTAINER_MODE" = yes; then
11978   MAINTAINER_MODE_TRUE=
11979   MAINTAINER_MODE_FALSE='#'
11980 else
11981   MAINTAINER_MODE_TRUE='#'
11982   MAINTAINER_MODE_FALSE=
11983 fi
11984 MAINT=$MAINTAINER_MODE_TRUE
11985
11986 # ---------------------
11987 # GCC bootstrap support
11988 # ---------------------
11989
11990 # Stage specific cflags for build.
11991 stage1_cflags="-g"
11992 case $build in
11993   vax-*-*)
11994     case ${GCC} in
11995       yes) stage1_cflags="-g -Wa,-J" ;;
11996       *) stage1_cflags="-g -J" ;;
11997     esac ;;
11998 esac
11999
12000 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12001 if test "$GCC" = yes; then
12002   saved_CFLAGS="$CFLAGS"
12003
12004   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12005   CFLAGS="$CFLAGS -fkeep-inline-functions"
12006   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12007 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12008   cat >conftest.$ac_ext <<_ACEOF
12009 /* confdefs.h.  */
12010 _ACEOF
12011 cat confdefs.h >>conftest.$ac_ext
12012 cat >>conftest.$ac_ext <<_ACEOF
12013 /* end confdefs.h.  */
12014
12015 #if (__GNUC__ < 3) \
12016     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12017                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12018 #error http://gcc.gnu.org/PR29382
12019 #endif
12020
12021 int
12022 main ()
12023 {
12024
12025   ;
12026   return 0;
12027 }
12028 _ACEOF
12029 rm -f conftest.$ac_objext
12030 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12031   (eval $ac_compile) 2>conftest.er1
12032   ac_status=$?
12033   grep -v '^ *+' conftest.er1 >conftest.err
12034   rm -f conftest.er1
12035   cat conftest.err >&5
12036   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12037   (exit $ac_status); } &&
12038          { ac_try='test -z "$ac_c_werror_flag"
12039                          || test ! -s conftest.err'
12040   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12041   (eval $ac_try) 2>&5
12042   ac_status=$?
12043   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12044   (exit $ac_status); }; } &&
12045          { ac_try='test -s conftest.$ac_objext'
12046   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12047   (eval $ac_try) 2>&5
12048   ac_status=$?
12049   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12050   (exit $ac_status); }; }; then
12051   echo "$as_me:$LINENO: result: yes" >&5
12052 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12053 else
12054   echo "$as_me: failed program was:" >&5
12055 sed 's/^/| /' conftest.$ac_ext >&5
12056
12057 echo "$as_me:$LINENO: result: no" >&5
12058 echo "${ECHO_T}no" >&6
12059 fi
12060 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12061
12062   CFLAGS="$saved_CFLAGS"
12063 fi
12064
12065
12066
12067 # Enable --enable-checking in stage1 of the compiler.
12068 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12069 if test "${enable_stage1_checking+set}" = set; then
12070   enableval="$enable_stage1_checking"
12071   stage1_checking=--enable-checking=${enable_stage1_checking}
12072 else
12073   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12074   stage1_checking=--enable-checking=yes,types
12075 else
12076   stage1_checking=--enable-checking=$enable_checking,types
12077 fi
12078 fi;
12079
12080
12081 # Enable -Werror in bootstrap stage2 and later.
12082 # Check whether --enable-werror or --disable-werror was given.
12083 if test "${enable_werror+set}" = set; then
12084   enableval="$enable_werror"
12085
12086 else
12087   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12088   enable_werror=yes
12089 else
12090   enable_werror=no
12091 fi
12092 fi;
12093 case ${enable_werror} in
12094   yes) stage2_werror_flag="--enable-werror-always" ;;
12095   *) stage2_werror_flag="" ;;
12096 esac
12097
12098
12099 # Flags needed to enable html installing and building
12100
12101 # Check whether --with-datarootdir or --without-datarootdir was given.
12102 if test "${with_datarootdir+set}" = set; then
12103   withval="$with_datarootdir"
12104   datarootdir="\${prefix}/${withval}"
12105 else
12106   datarootdir="\${prefix}/share"
12107 fi;
12108
12109
12110 # Check whether --with-docdir or --without-docdir was given.
12111 if test "${with_docdir+set}" = set; then
12112   withval="$with_docdir"
12113   docdir="\${prefix}/${withval}"
12114 else
12115   docdir="\${datarootdir}/doc"
12116 fi;
12117
12118
12119 # Check whether --with-pdfdir or --without-pdfdir was given.
12120 if test "${with_pdfdir+set}" = set; then
12121   withval="$with_pdfdir"
12122   pdfdir="\${prefix}/${withval}"
12123 else
12124   pdfdir="\${docdir}"
12125 fi;
12126
12127
12128 # Check whether --with-htmldir or --without-htmldir was given.
12129 if test "${with_htmldir+set}" = set; then
12130   withval="$with_htmldir"
12131   htmldir="\${prefix}/${withval}"
12132 else
12133   htmldir="\${docdir}"
12134 fi;
12135
12136
12137
12138
12139
12140
12141           ac_config_files="$ac_config_files Makefile"
12142 cat >confcache <<\_ACEOF
12143 # This file is a shell script that caches the results of configure
12144 # tests run on this system so they can be shared between configure
12145 # scripts and configure runs, see configure's option --config-cache.
12146 # It is not useful on other systems.  If it contains results you don't
12147 # want to keep, you may remove or edit it.
12148 #
12149 # config.status only pays attention to the cache file if you give it
12150 # the --recheck option to rerun configure.
12151 #
12152 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12153 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12154 # following values.
12155
12156 _ACEOF
12157
12158 # The following way of writing the cache mishandles newlines in values,
12159 # but we know of no workaround that is simple, portable, and efficient.
12160 # So, don't put newlines in cache variables' values.
12161 # Ultrix sh set writes to stderr and can't be redirected directly,
12162 # and sets the high bit in the cache file unless we assign to the vars.
12163 {
12164   (set) 2>&1 |
12165     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12166     *ac_space=\ *)
12167       # `set' does not quote correctly, so add quotes (double-quote
12168       # substitution turns \\\\ into \\, and sed turns \\ into \).
12169       sed -n \
12170         "s/'/'\\\\''/g;
12171           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12172       ;;
12173     *)
12174       # `set' quotes correctly as required by POSIX, so do not add quotes.
12175       sed -n \
12176         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12177       ;;
12178     esac;
12179 } |
12180   sed '
12181      t clear
12182      : clear
12183      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12184      t end
12185      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12186      : end' >>confcache
12187 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12188   if test -w $cache_file; then
12189     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12190     cat confcache >$cache_file
12191   else
12192     echo "not updating unwritable cache $cache_file"
12193   fi
12194 fi
12195 rm -f confcache
12196
12197 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12198 # Let make expand exec_prefix.
12199 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12200
12201 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12202 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12203 # trailing colons and then remove the whole line if VPATH becomes empty
12204 # (actually we leave an empty line to preserve line numbers).
12205 if test "x$srcdir" = x.; then
12206   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12207 s/:*\$(srcdir):*/:/;
12208 s/:*\${srcdir}:*/:/;
12209 s/:*@srcdir@:*/:/;
12210 s/^\([^=]*=[     ]*\):*/\1/;
12211 s/:*$//;
12212 s/^[^=]*=[       ]*$//;
12213 }'
12214 fi
12215
12216 # Transform confdefs.h into DEFS.
12217 # Protect against shell expansion while executing Makefile rules.
12218 # Protect against Makefile macro expansion.
12219 #
12220 # If the first sed substitution is executed (which looks for macros that
12221 # take arguments), then we branch to the quote section.  Otherwise,
12222 # look for a macro that doesn't take arguments.
12223 cat >confdef2opt.sed <<\_ACEOF
12224 t clear
12225 : clear
12226 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12227 t quote
12228 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12229 t quote
12230 d
12231 : quote
12232 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12233 s,\[,\\&,g
12234 s,\],\\&,g
12235 s,\$,$$,g
12236 p
12237 _ACEOF
12238 # We use echo to avoid assuming a particular line-breaking character.
12239 # The extra dot is to prevent the shell from consuming trailing
12240 # line-breaks from the sub-command output.  A line-break within
12241 # single-quotes doesn't work because, if this script is created in a
12242 # platform that uses two characters for line-breaks (e.g., DOS), tr
12243 # would break.
12244 ac_LF_and_DOT=`echo; echo .`
12245 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12246 rm -f confdef2opt.sed
12247
12248
12249 ac_libobjs=
12250 ac_ltlibobjs=
12251 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12252   # 1. Remove the extension, and $U if already installed.
12253   ac_i=`echo "$ac_i" |
12254          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12255   # 2. Add them.
12256   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12257   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12258 done
12259 LIBOBJS=$ac_libobjs
12260
12261 LTLIBOBJS=$ac_ltlibobjs
12262
12263
12264
12265 : ${CONFIG_STATUS=./config.status}
12266 ac_clean_files_save=$ac_clean_files
12267 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12268 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12269 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12270 cat >$CONFIG_STATUS <<_ACEOF
12271 #! $SHELL
12272 # Generated by $as_me.
12273 # Run this file to recreate the current configuration.
12274 # Compiler output produced by configure, useful for debugging
12275 # configure, is in config.log if it exists.
12276
12277 debug=false
12278 ac_cs_recheck=false
12279 ac_cs_silent=false
12280 SHELL=\${CONFIG_SHELL-$SHELL}
12281 _ACEOF
12282
12283 cat >>$CONFIG_STATUS <<\_ACEOF
12284 ## --------------------- ##
12285 ## M4sh Initialization.  ##
12286 ## --------------------- ##
12287
12288 # Be Bourne compatible
12289 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12290   emulate sh
12291   NULLCMD=:
12292   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12293   # is contrary to our usage.  Disable this feature.
12294   alias -g '${1+"$@"}'='"$@"'
12295 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12296   set -o posix
12297 fi
12298 DUALCASE=1; export DUALCASE # for MKS sh
12299
12300 # Support unset when possible.
12301 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12302   as_unset=unset
12303 else
12304   as_unset=false
12305 fi
12306
12307
12308 # Work around bugs in pre-3.0 UWIN ksh.
12309 $as_unset ENV MAIL MAILPATH
12310 PS1='$ '
12311 PS2='> '
12312 PS4='+ '
12313
12314 # NLS nuisances.
12315 for as_var in \
12316   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12317   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12318   LC_TELEPHONE LC_TIME
12319 do
12320   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12321     eval $as_var=C; export $as_var
12322   else
12323     $as_unset $as_var
12324   fi
12325 done
12326
12327 # Required to use basename.
12328 if expr a : '\(a\)' >/dev/null 2>&1; then
12329   as_expr=expr
12330 else
12331   as_expr=false
12332 fi
12333
12334 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12335   as_basename=basename
12336 else
12337   as_basename=false
12338 fi
12339
12340
12341 # Name of the executable.
12342 as_me=`$as_basename "$0" ||
12343 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12344          X"$0" : 'X\(//\)$' \| \
12345          X"$0" : 'X\(/\)$' \| \
12346          .     : '\(.\)' 2>/dev/null ||
12347 echo X/"$0" |
12348     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12349           /^X\/\(\/\/\)$/{ s//\1/; q; }
12350           /^X\/\(\/\).*/{ s//\1/; q; }
12351           s/.*/./; q'`
12352
12353
12354 # PATH needs CR, and LINENO needs CR and PATH.
12355 # Avoid depending upon Character Ranges.
12356 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12357 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12358 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12359 as_cr_digits='0123456789'
12360 as_cr_alnum=$as_cr_Letters$as_cr_digits
12361
12362 # The user is always right.
12363 if test "${PATH_SEPARATOR+set}" != set; then
12364   echo "#! /bin/sh" >conf$$.sh
12365   echo  "exit 0"   >>conf$$.sh
12366   chmod +x conf$$.sh
12367   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12368     PATH_SEPARATOR=';'
12369   else
12370     PATH_SEPARATOR=:
12371   fi
12372   rm -f conf$$.sh
12373 fi
12374
12375
12376   as_lineno_1=$LINENO
12377   as_lineno_2=$LINENO
12378   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12379   test "x$as_lineno_1" != "x$as_lineno_2" &&
12380   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12381   # Find who we are.  Look in the path if we contain no path at all
12382   # relative or not.
12383   case $0 in
12384     *[\\/]* ) as_myself=$0 ;;
12385     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12386 for as_dir in $PATH
12387 do
12388   IFS=$as_save_IFS
12389   test -z "$as_dir" && as_dir=.
12390   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12391 done
12392
12393        ;;
12394   esac
12395   # We did not find ourselves, most probably we were run as `sh COMMAND'
12396   # in which case we are not to be found in the path.
12397   if test "x$as_myself" = x; then
12398     as_myself=$0
12399   fi
12400   if test ! -f "$as_myself"; then
12401     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12402 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12403    { (exit 1); exit 1; }; }
12404   fi
12405   case $CONFIG_SHELL in
12406   '')
12407     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12408 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12409 do
12410   IFS=$as_save_IFS
12411   test -z "$as_dir" && as_dir=.
12412   for as_base in sh bash ksh sh5; do
12413          case $as_dir in
12414          /*)
12415            if ("$as_dir/$as_base" -c '
12416   as_lineno_1=$LINENO
12417   as_lineno_2=$LINENO
12418   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12419   test "x$as_lineno_1" != "x$as_lineno_2" &&
12420   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12421              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12422              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12423              CONFIG_SHELL=$as_dir/$as_base
12424              export CONFIG_SHELL
12425              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12426            fi;;
12427          esac
12428        done
12429 done
12430 ;;
12431   esac
12432
12433   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12434   # uniformly replaced by the line number.  The first 'sed' inserts a
12435   # line-number line before each line; the second 'sed' does the real
12436   # work.  The second script uses 'N' to pair each line-number line
12437   # with the numbered line, and appends trailing '-' during
12438   # substitution so that $LINENO is not a special case at line end.
12439   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12440   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12441   sed '=' <$as_myself |
12442     sed '
12443       N
12444       s,$,-,
12445       : loop
12446       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12447       t loop
12448       s,-$,,
12449       s,^['$as_cr_digits']*\n,,
12450     ' >$as_me.lineno &&
12451   chmod +x $as_me.lineno ||
12452     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12453 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12454    { (exit 1); exit 1; }; }
12455
12456   # Don't try to exec as it changes $[0], causing all sort of problems
12457   # (the dirname of $[0] is not the place where we might find the
12458   # original and so on.  Autoconf is especially sensible to this).
12459   . ./$as_me.lineno
12460   # Exit status is that of the last command.
12461   exit
12462 }
12463
12464
12465 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12466   *c*,-n*) ECHO_N= ECHO_C='
12467 ' ECHO_T='      ' ;;
12468   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12469   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12470 esac
12471
12472 if expr a : '\(a\)' >/dev/null 2>&1; then
12473   as_expr=expr
12474 else
12475   as_expr=false
12476 fi
12477
12478 rm -f conf$$ conf$$.exe conf$$.file
12479 echo >conf$$.file
12480 if ln -s conf$$.file conf$$ 2>/dev/null; then
12481   # We could just check for DJGPP; but this test a) works b) is more generic
12482   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12483   if test -f conf$$.exe; then
12484     # Don't use ln at all; we don't have any links
12485     as_ln_s='cp -p'
12486   else
12487     as_ln_s='ln -s'
12488   fi
12489 elif ln conf$$.file conf$$ 2>/dev/null; then
12490   as_ln_s=ln
12491 else
12492   as_ln_s='cp -p'
12493 fi
12494 rm -f conf$$ conf$$.exe conf$$.file
12495
12496 if mkdir -p . 2>/dev/null; then
12497   as_mkdir_p=:
12498 else
12499   test -d ./-p && rmdir ./-p
12500   as_mkdir_p=false
12501 fi
12502
12503 as_executable_p="test -f"
12504
12505 # Sed expression to map a string onto a valid CPP name.
12506 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12507
12508 # Sed expression to map a string onto a valid variable name.
12509 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12510
12511
12512 # IFS
12513 # We need space, tab and new line, in precisely that order.
12514 as_nl='
12515 '
12516 IFS="   $as_nl"
12517
12518 # CDPATH.
12519 $as_unset CDPATH
12520
12521 exec 6>&1
12522
12523 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12524 # report actual input values of CONFIG_FILES etc. instead of their
12525 # values after options handling.  Logging --version etc. is OK.
12526 exec 5>>config.log
12527 {
12528   echo
12529   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12530 ## Running $as_me. ##
12531 _ASBOX
12532 } >&5
12533 cat >&5 <<_CSEOF
12534
12535 This file was extended by $as_me, which was
12536 generated by GNU Autoconf 2.59.  Invocation command line was
12537
12538   CONFIG_FILES    = $CONFIG_FILES
12539   CONFIG_HEADERS  = $CONFIG_HEADERS
12540   CONFIG_LINKS    = $CONFIG_LINKS
12541   CONFIG_COMMANDS = $CONFIG_COMMANDS
12542   $ $0 $@
12543
12544 _CSEOF
12545 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12546 echo >&5
12547 _ACEOF
12548
12549 # Files that config.status was made for.
12550 if test -n "$ac_config_files"; then
12551   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12552 fi
12553
12554 if test -n "$ac_config_headers"; then
12555   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12556 fi
12557
12558 if test -n "$ac_config_links"; then
12559   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12560 fi
12561
12562 if test -n "$ac_config_commands"; then
12563   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12564 fi
12565
12566 cat >>$CONFIG_STATUS <<\_ACEOF
12567
12568 ac_cs_usage="\
12569 \`$as_me' instantiates files from templates according to the
12570 current configuration.
12571
12572 Usage: $0 [OPTIONS] [FILE]...
12573
12574   -h, --help       print this help, then exit
12575   -V, --version    print version number, then exit
12576   -q, --quiet      do not print progress messages
12577   -d, --debug      don't remove temporary files
12578       --recheck    update $as_me by reconfiguring in the same conditions
12579   --file=FILE[:TEMPLATE]
12580                    instantiate the configuration file FILE
12581
12582 Configuration files:
12583 $config_files
12584
12585 Report bugs to <bug-autoconf@gnu.org>."
12586 _ACEOF
12587
12588 cat >>$CONFIG_STATUS <<_ACEOF
12589 ac_cs_version="\\
12590 config.status
12591 configured by $0, generated by GNU Autoconf 2.59,
12592   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12593
12594 Copyright (C) 2003 Free Software Foundation, Inc.
12595 This config.status script is free software; the Free Software Foundation
12596 gives unlimited permission to copy, distribute and modify it."
12597 srcdir=$srcdir
12598 INSTALL="$INSTALL"
12599 _ACEOF
12600
12601 cat >>$CONFIG_STATUS <<\_ACEOF
12602 # If no file are specified by the user, then we need to provide default
12603 # value.  By we need to know if files were specified by the user.
12604 ac_need_defaults=:
12605 while test $# != 0
12606 do
12607   case $1 in
12608   --*=*)
12609     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12610     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12611     ac_shift=:
12612     ;;
12613   -*)
12614     ac_option=$1
12615     ac_optarg=$2
12616     ac_shift=shift
12617     ;;
12618   *) # This is not an option, so the user has probably given explicit
12619      # arguments.
12620      ac_option=$1
12621      ac_need_defaults=false;;
12622   esac
12623
12624   case $ac_option in
12625   # Handling of the options.
12626 _ACEOF
12627 cat >>$CONFIG_STATUS <<\_ACEOF
12628   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12629     ac_cs_recheck=: ;;
12630   --version | --vers* | -V )
12631     echo "$ac_cs_version"; exit 0 ;;
12632   --he | --h)
12633     # Conflict between --help and --header
12634     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12635 Try \`$0 --help' for more information." >&5
12636 echo "$as_me: error: ambiguous option: $1
12637 Try \`$0 --help' for more information." >&2;}
12638    { (exit 1); exit 1; }; };;
12639   --help | --hel | -h )
12640     echo "$ac_cs_usage"; exit 0 ;;
12641   --debug | --d* | -d )
12642     debug=: ;;
12643   --file | --fil | --fi | --f )
12644     $ac_shift
12645     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12646     ac_need_defaults=false;;
12647   --header | --heade | --head | --hea )
12648     $ac_shift
12649     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12650     ac_need_defaults=false;;
12651   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12652   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12653     ac_cs_silent=: ;;
12654
12655   # This is an error.
12656   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12657 Try \`$0 --help' for more information." >&5
12658 echo "$as_me: error: unrecognized option: $1
12659 Try \`$0 --help' for more information." >&2;}
12660    { (exit 1); exit 1; }; } ;;
12661
12662   *) ac_config_targets="$ac_config_targets $1" ;;
12663
12664   esac
12665   shift
12666 done
12667
12668 ac_configure_extra_args=
12669
12670 if $ac_cs_silent; then
12671   exec 6>/dev/null
12672   ac_configure_extra_args="$ac_configure_extra_args --silent"
12673 fi
12674
12675 _ACEOF
12676 cat >>$CONFIG_STATUS <<_ACEOF
12677 if \$ac_cs_recheck; then
12678   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12679   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12680 fi
12681
12682 _ACEOF
12683
12684
12685
12686
12687
12688 cat >>$CONFIG_STATUS <<\_ACEOF
12689 for ac_config_target in $ac_config_targets
12690 do
12691   case "$ac_config_target" in
12692   # Handling of arguments.
12693   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12694   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12695 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12696    { (exit 1); exit 1; }; };;
12697   esac
12698 done
12699
12700 # If the user did not use the arguments to specify the items to instantiate,
12701 # then the envvar interface is used.  Set only those that are not.
12702 # We use the long form for the default assignment because of an extremely
12703 # bizarre bug on SunOS 4.1.3.
12704 if $ac_need_defaults; then
12705   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12706 fi
12707
12708 # Have a temporary directory for convenience.  Make it in the build tree
12709 # simply because there is no reason to put it here, and in addition,
12710 # creating and moving files from /tmp can sometimes cause problems.
12711 # Create a temporary directory, and hook for its removal unless debugging.
12712 $debug ||
12713 {
12714   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12715   trap '{ (exit 1); exit 1; }' 1 2 13 15
12716 }
12717
12718 # Create a (secure) tmp directory for tmp files.
12719
12720 {
12721   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12722   test -n "$tmp" && test -d "$tmp"
12723 }  ||
12724 {
12725   tmp=./confstat$$-$RANDOM
12726   (umask 077 && mkdir $tmp)
12727 } ||
12728 {
12729    echo "$me: cannot create a temporary directory in ." >&2
12730    { (exit 1); exit 1; }
12731 }
12732
12733 _ACEOF
12734
12735 cat >>$CONFIG_STATUS <<_ACEOF
12736
12737 #
12738 # CONFIG_FILES section.
12739 #
12740
12741 # No need to generate the scripts if there are no CONFIG_FILES.
12742 # This happens for instance when ./config.status config.h
12743 if test -n "\$CONFIG_FILES"; then
12744   # Protect against being on the right side of a sed subst in config.status.
12745   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12746    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12747 s,@SHELL@,$SHELL,;t t
12748 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12749 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12750 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12751 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12752 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12753 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12754 s,@exec_prefix@,$exec_prefix,;t t
12755 s,@prefix@,$prefix,;t t
12756 s,@program_transform_name@,$program_transform_name,;t t
12757 s,@bindir@,$bindir,;t t
12758 s,@sbindir@,$sbindir,;t t
12759 s,@libexecdir@,$libexecdir,;t t
12760 s,@datadir@,$datadir,;t t
12761 s,@sysconfdir@,$sysconfdir,;t t
12762 s,@sharedstatedir@,$sharedstatedir,;t t
12763 s,@localstatedir@,$localstatedir,;t t
12764 s,@libdir@,$libdir,;t t
12765 s,@includedir@,$includedir,;t t
12766 s,@oldincludedir@,$oldincludedir,;t t
12767 s,@infodir@,$infodir,;t t
12768 s,@mandir@,$mandir,;t t
12769 s,@build_alias@,$build_alias,;t t
12770 s,@host_alias@,$host_alias,;t t
12771 s,@target_alias@,$target_alias,;t t
12772 s,@DEFS@,$DEFS,;t t
12773 s,@ECHO_C@,$ECHO_C,;t t
12774 s,@ECHO_N@,$ECHO_N,;t t
12775 s,@ECHO_T@,$ECHO_T,;t t
12776 s,@LIBS@,$LIBS,;t t
12777 s,@build@,$build,;t t
12778 s,@build_cpu@,$build_cpu,;t t
12779 s,@build_vendor@,$build_vendor,;t t
12780 s,@build_os@,$build_os,;t t
12781 s,@build_noncanonical@,$build_noncanonical,;t t
12782 s,@host_noncanonical@,$host_noncanonical,;t t
12783 s,@target_noncanonical@,$target_noncanonical,;t t
12784 s,@host@,$host,;t t
12785 s,@host_cpu@,$host_cpu,;t t
12786 s,@host_vendor@,$host_vendor,;t t
12787 s,@host_os@,$host_os,;t t
12788 s,@target@,$target,;t t
12789 s,@target_cpu@,$target_cpu,;t t
12790 s,@target_vendor@,$target_vendor,;t t
12791 s,@target_os@,$target_os,;t t
12792 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12793 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12794 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12795 s,@LN@,$LN,;t t
12796 s,@LN_S@,$LN_S,;t t
12797 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12798 s,@build_libsubdir@,$build_libsubdir,;t t
12799 s,@build_subdir@,$build_subdir,;t t
12800 s,@host_subdir@,$host_subdir,;t t
12801 s,@target_subdir@,$target_subdir,;t t
12802 s,@CC@,$CC,;t t
12803 s,@CFLAGS@,$CFLAGS,;t t
12804 s,@LDFLAGS@,$LDFLAGS,;t t
12805 s,@CPPFLAGS@,$CPPFLAGS,;t t
12806 s,@ac_ct_CC@,$ac_ct_CC,;t t
12807 s,@EXEEXT@,$EXEEXT,;t t
12808 s,@OBJEXT@,$OBJEXT,;t t
12809 s,@CXX@,$CXX,;t t
12810 s,@CXXFLAGS@,$CXXFLAGS,;t t
12811 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12812 s,@GNATBIND@,$GNATBIND,;t t
12813 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12814 s,@GNATMAKE@,$GNATMAKE,;t t
12815 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12816 s,@do_compare@,$do_compare,;t t
12817 s,@gmplibs@,$gmplibs,;t t
12818 s,@gmpinc@,$gmpinc,;t t
12819 s,@stage1_languages@,$stage1_languages,;t t
12820 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12821 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12822 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12823 s,@tooldir@,$tooldir,;t t
12824 s,@build_tooldir@,$build_tooldir,;t t
12825 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12826 s,@GDB_TK@,$GDB_TK,;t t
12827 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12828 s,@build_configargs@,$build_configargs,;t t
12829 s,@build_configdirs@,$build_configdirs,;t t
12830 s,@host_configargs@,$host_configargs,;t t
12831 s,@configdirs@,$configdirs,;t t
12832 s,@target_configargs@,$target_configargs,;t t
12833 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
12834 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
12835 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12836 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12837 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
12838 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
12839 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
12840 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
12841 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
12842 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
12843 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
12844 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
12845 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
12846 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
12847 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
12848 s,@config_shell@,$config_shell,;t t
12849 s,@YACC@,$YACC,;t t
12850 s,@BISON@,$BISON,;t t
12851 s,@M4@,$M4,;t t
12852 s,@LEX@,$LEX,;t t
12853 s,@FLEX@,$FLEX,;t t
12854 s,@MAKEINFO@,$MAKEINFO,;t t
12855 s,@EXPECT@,$EXPECT,;t t
12856 s,@RUNTEST@,$RUNTEST,;t t
12857 s,@AR@,$AR,;t t
12858 s,@AS@,$AS,;t t
12859 s,@DLLTOOL@,$DLLTOOL,;t t
12860 s,@LD@,$LD,;t t
12861 s,@LIPO@,$LIPO,;t t
12862 s,@NM@,$NM,;t t
12863 s,@RANLIB@,$RANLIB,;t t
12864 s,@STRIP@,$STRIP,;t t
12865 s,@WINDRES@,$WINDRES,;t t
12866 s,@WINDMC@,$WINDMC,;t t
12867 s,@OBJCOPY@,$OBJCOPY,;t t
12868 s,@OBJDUMP@,$OBJDUMP,;t t
12869 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12870 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12871 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12872 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12873 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12874 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12875 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12876 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12877 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12878 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12879 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12880 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12881 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12882 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12883 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12884 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
12885 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12886 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12887 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12888 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12889 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12890 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12891 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12892 s,@MAINT@,$MAINT,;t t
12893 s,@stage1_cflags@,$stage1_cflags,;t t
12894 s,@stage1_checking@,$stage1_checking,;t t
12895 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12896 s,@datarootdir@,$datarootdir,;t t
12897 s,@docdir@,$docdir,;t t
12898 s,@pdfdir@,$pdfdir,;t t
12899 s,@htmldir@,$htmldir,;t t
12900 s,@LIBOBJS@,$LIBOBJS,;t t
12901 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12902 /@serialization_dependencies@/r $serialization_dependencies
12903 s,@serialization_dependencies@,,;t t
12904 /@host_makefile_frag@/r $host_makefile_frag
12905 s,@host_makefile_frag@,,;t t
12906 /@target_makefile_frag@/r $target_makefile_frag
12907 s,@target_makefile_frag@,,;t t
12908 /@alphaieee_frag@/r $alphaieee_frag
12909 s,@alphaieee_frag@,,;t t
12910 /@ospace_frag@/r $ospace_frag
12911 s,@ospace_frag@,,;t t
12912 CEOF
12913
12914 _ACEOF
12915
12916   cat >>$CONFIG_STATUS <<\_ACEOF
12917   # Split the substitutions into bite-sized pieces for seds with
12918   # small command number limits, like on Digital OSF/1 and HP-UX.
12919   ac_max_sed_lines=48
12920   ac_sed_frag=1 # Number of current file.
12921   ac_beg=1 # First line for current file.
12922   ac_end=$ac_max_sed_lines # Line after last line for current file.
12923   ac_more_lines=:
12924   ac_sed_cmds=
12925   while $ac_more_lines; do
12926     if test $ac_beg -gt 1; then
12927       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12928     else
12929       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12930     fi
12931     if test ! -s $tmp/subs.frag; then
12932       ac_more_lines=false
12933     else
12934       # The purpose of the label and of the branching condition is to
12935       # speed up the sed processing (if there are no `@' at all, there
12936       # is no need to browse any of the substitutions).
12937       # These are the two extra sed commands mentioned above.
12938       (echo ':t
12939   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12940       if test -z "$ac_sed_cmds"; then
12941         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12942       else
12943         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12944       fi
12945       ac_sed_frag=`expr $ac_sed_frag + 1`
12946       ac_beg=$ac_end
12947       ac_end=`expr $ac_end + $ac_max_sed_lines`
12948     fi
12949   done
12950   if test -z "$ac_sed_cmds"; then
12951     ac_sed_cmds=cat
12952   fi
12953 fi # test -n "$CONFIG_FILES"
12954
12955 _ACEOF
12956 cat >>$CONFIG_STATUS <<\_ACEOF
12957 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12958   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12959   case $ac_file in
12960   - | *:- | *:-:* ) # input from stdin
12961         cat >$tmp/stdin
12962         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12963         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12964   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12965         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12966   * )   ac_file_in=$ac_file.in ;;
12967   esac
12968
12969   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
12970   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
12971 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12972          X"$ac_file" : 'X\(//\)[^/]' \| \
12973          X"$ac_file" : 'X\(//\)$' \| \
12974          X"$ac_file" : 'X\(/\)' \| \
12975          .     : '\(.\)' 2>/dev/null ||
12976 echo X"$ac_file" |
12977     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12978           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12979           /^X\(\/\/\)$/{ s//\1/; q; }
12980           /^X\(\/\).*/{ s//\1/; q; }
12981           s/.*/./; q'`
12982   { if $as_mkdir_p; then
12983     mkdir -p "$ac_dir"
12984   else
12985     as_dir="$ac_dir"
12986     as_dirs=
12987     while test ! -d "$as_dir"; do
12988       as_dirs="$as_dir $as_dirs"
12989       as_dir=`(dirname "$as_dir") 2>/dev/null ||
12990 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12991          X"$as_dir" : 'X\(//\)[^/]' \| \
12992          X"$as_dir" : 'X\(//\)$' \| \
12993          X"$as_dir" : 'X\(/\)' \| \
12994          .     : '\(.\)' 2>/dev/null ||
12995 echo X"$as_dir" |
12996     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12997           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12998           /^X\(\/\/\)$/{ s//\1/; q; }
12999           /^X\(\/\).*/{ s//\1/; q; }
13000           s/.*/./; q'`
13001     done
13002     test ! -n "$as_dirs" || mkdir $as_dirs
13003   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13004 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13005    { (exit 1); exit 1; }; }; }
13006
13007   ac_builddir=.
13008
13009 if test "$ac_dir" != .; then
13010   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13011   # A "../" for each directory in $ac_dir_suffix.
13012   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13013 else
13014   ac_dir_suffix= ac_top_builddir=
13015 fi
13016
13017 case $srcdir in
13018   .)  # No --srcdir option.  We are building in place.
13019     ac_srcdir=.
13020     if test -z "$ac_top_builddir"; then
13021        ac_top_srcdir=.
13022     else
13023        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13024     fi ;;
13025   [\\/]* | ?:[\\/]* )  # Absolute path.
13026     ac_srcdir=$srcdir$ac_dir_suffix;
13027     ac_top_srcdir=$srcdir ;;
13028   *) # Relative path.
13029     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13030     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13031 esac
13032
13033 # Do not use `cd foo && pwd` to compute absolute paths, because
13034 # the directories may not exist.
13035 case `pwd` in
13036 .) ac_abs_builddir="$ac_dir";;
13037 *)
13038   case "$ac_dir" in
13039   .) ac_abs_builddir=`pwd`;;
13040   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13041   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13042   esac;;
13043 esac
13044 case $ac_abs_builddir in
13045 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13046 *)
13047   case ${ac_top_builddir}. in
13048   .) ac_abs_top_builddir=$ac_abs_builddir;;
13049   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13050   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13051   esac;;
13052 esac
13053 case $ac_abs_builddir in
13054 .) ac_abs_srcdir=$ac_srcdir;;
13055 *)
13056   case $ac_srcdir in
13057   .) ac_abs_srcdir=$ac_abs_builddir;;
13058   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13059   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13060   esac;;
13061 esac
13062 case $ac_abs_builddir in
13063 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13064 *)
13065   case $ac_top_srcdir in
13066   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13067   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13068   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13069   esac;;
13070 esac
13071
13072
13073   case $INSTALL in
13074   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13075   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13076   esac
13077
13078   if test x"$ac_file" != x-; then
13079     { echo "$as_me:$LINENO: creating $ac_file" >&5
13080 echo "$as_me: creating $ac_file" >&6;}
13081     rm -f "$ac_file"
13082   fi
13083   # Let's still pretend it is `configure' which instantiates (i.e., don't
13084   # use $as_me), people would be surprised to read:
13085   #    /* config.h.  Generated by config.status.  */
13086   if test x"$ac_file" = x-; then
13087     configure_input=
13088   else
13089     configure_input="$ac_file.  "
13090   fi
13091   configure_input=$configure_input"Generated from `echo $ac_file_in |
13092                                      sed 's,.*/,,'` by configure."
13093
13094   # First look for the input files in the build tree, otherwise in the
13095   # src tree.
13096   ac_file_inputs=`IFS=:
13097     for f in $ac_file_in; do
13098       case $f in
13099       -) echo $tmp/stdin ;;
13100       [\\/$]*)
13101          # Absolute (can't be DOS-style, as IFS=:)
13102          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13103 echo "$as_me: error: cannot find input file: $f" >&2;}
13104    { (exit 1); exit 1; }; }
13105          echo "$f";;
13106       *) # Relative
13107          if test -f "$f"; then
13108            # Build tree
13109            echo "$f"
13110          elif test -f "$srcdir/$f"; then
13111            # Source tree
13112            echo "$srcdir/$f"
13113          else
13114            # /dev/null tree
13115            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13116 echo "$as_me: error: cannot find input file: $f" >&2;}
13117    { (exit 1); exit 1; }; }
13118          fi;;
13119       esac
13120     done` || { (exit 1); exit 1; }
13121 _ACEOF
13122 cat >>$CONFIG_STATUS <<_ACEOF
13123   sed "$ac_vpsub
13124 $extrasub
13125 _ACEOF
13126 cat >>$CONFIG_STATUS <<\_ACEOF
13127 :t
13128 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13129 s,@configure_input@,$configure_input,;t t
13130 s,@srcdir@,$ac_srcdir,;t t
13131 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13132 s,@top_srcdir@,$ac_top_srcdir,;t t
13133 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13134 s,@builddir@,$ac_builddir,;t t
13135 s,@abs_builddir@,$ac_abs_builddir,;t t
13136 s,@top_builddir@,$ac_top_builddir,;t t
13137 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13138 s,@INSTALL@,$ac_INSTALL,;t t
13139 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13140   rm -f $tmp/stdin
13141   if test x"$ac_file" != x-; then
13142     mv $tmp/out $ac_file
13143   else
13144     cat $tmp/out
13145     rm -f $tmp/out
13146   fi
13147
13148 done
13149 _ACEOF
13150
13151 cat >>$CONFIG_STATUS <<\_ACEOF
13152
13153 { (exit 0); exit 0; }
13154 _ACEOF
13155 chmod +x $CONFIG_STATUS
13156 ac_clean_files=$ac_clean_files_save
13157
13158
13159 # configure is writing to config.log, and then calls config.status.
13160 # config.status does its own redirection, appending to config.log.
13161 # Unfortunately, on DOS this fails, as config.log is still kept open
13162 # by configure, so config.status won't be able to write to it; its
13163 # output is simply discarded.  So we exec the FD to /dev/null,
13164 # effectively closing config.log, so it can be properly (re)opened and
13165 # appended to by config.status.  When coming back to configure, we
13166 # need to make the FD available again.
13167 if test "$no_create" != yes; then
13168   ac_cs_success=:
13169   ac_config_status_args=
13170   test "$silent" = yes &&
13171     ac_config_status_args="$ac_config_status_args --quiet"
13172   exec 5>/dev/null
13173   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13174   exec 5>>config.log
13175   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13176   # would make configure fail if this is the last instruction.
13177   $ac_cs_success || { (exit 1); exit 1; }
13178 fi
13179