configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S TOPLEVEL_CONFIGURE_ARGUMENTS build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277
 278 # Initialize some variables set by options.
 279 ac_init_help=
 280 ac_init_version=false
 281 # The variables have the same names as the options, with
 282 # dashes changed to underlines.
 283 cache_file=/dev/null
 284 exec_prefix=NONE
 285 no_create=
 286 no_recursion=
 287 prefix=NONE
 288 program_prefix=NONE
 289 program_suffix=NONE
 290 program_transform_name=s,x,x,
 291 silent=
 292 site=
 293 srcdir=
 294 verbose=
 295 x_includes=NONE
 296 x_libraries=NONE
 297
 298 # Installation directory options.
 299 # These are left unexpanded so users can "make install exec_prefix=/foo"
 300 # and all the variables that are supposed to be based on exec_prefix
 301 # by default will actually change.
 302 # Use braces instead of parens because sh, perl, etc. also accept them.
 303 bindir='${exec_prefix}/bin'
 304 sbindir='${exec_prefix}/sbin'
 305 libexecdir='${exec_prefix}/libexec'
 306 datadir='${prefix}/share'
 307 sysconfdir='${prefix}/etc'
 308 sharedstatedir='${prefix}/com'
 309 localstatedir='${prefix}/var'
 310 libdir='${exec_prefix}/lib'
 311 includedir='${prefix}/include'
 312 oldincludedir='/usr/include'
 313 infodir='${prefix}/info'
 314 mandir='${prefix}/man'
 315
 316 ac_prev=
 317 for ac_option
 318 do
 319   # If the previous option needs an argument, assign it.
 320   if test -n "$ac_prev"; then
 321     eval "$ac_prev=\$ac_option"
 322     ac_prev=
 323     continue
 324   fi
 325
 326   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 327
 328   # Accept the important Cygnus configure options, so we can diagnose typos.
 329
 330   case $ac_option in
 331
 332   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 333     ac_prev=bindir ;;
 334   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 335     bindir=$ac_optarg ;;
 336
 337   -build | --build | --buil | --bui | --bu)
 338     ac_prev=build_alias ;;
 339   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 340     build_alias=$ac_optarg ;;
 341
 342   -cache-file | --cache-file | --cache-fil | --cache-fi \
 343   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 344     ac_prev=cache_file ;;
 345   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 346   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 347     cache_file=$ac_optarg ;;
 348
 349   --config-cache | -C)
 350     cache_file=config.cache ;;
 351
 352   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 353     ac_prev=datadir ;;
 354   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 355   | --da=*)
 356     datadir=$ac_optarg ;;
 357
 358   -disable-* | --disable-*)
 359     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 360     # Reject names that are not valid shell variable names.
 361     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 362       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 363    { (exit 1); exit 1; }; }
 364     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 365     eval "enable_$ac_feature=no" ;;
 366
 367   -enable-* | --enable-*)
 368     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 369     # Reject names that are not valid shell variable names.
 370     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 371       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 372    { (exit 1); exit 1; }; }
 373     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 374     case $ac_option in
 375       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 376       *) ac_optarg=yes ;;
 377     esac
 378     eval "enable_$ac_feature='$ac_optarg'" ;;
 379
 380   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 381   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 382   | --exec | --exe | --ex)
 383     ac_prev=exec_prefix ;;
 384   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 385   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 386   | --exec=* | --exe=* | --ex=*)
 387     exec_prefix=$ac_optarg ;;
 388
 389   -gas | --gas | --ga | --g)
 390     # Obsolete; use --with-gas.
 391     with_gas=yes ;;
 392
 393   -help | --help | --hel | --he | -h)
 394     ac_init_help=long ;;
 395   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 396     ac_init_help=recursive ;;
 397   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 398     ac_init_help=short ;;
 399
 400   -host | --host | --hos | --ho)
 401     ac_prev=host_alias ;;
 402   -host=* | --host=* | --hos=* | --ho=*)
 403     host_alias=$ac_optarg ;;
 404
 405   -includedir | --includedir | --includedi | --included | --include \
 406   | --includ | --inclu | --incl | --inc)
 407     ac_prev=includedir ;;
 408   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 409   | --includ=* | --inclu=* | --incl=* | --inc=*)
 410     includedir=$ac_optarg ;;
 411
 412   -infodir | --infodir | --infodi | --infod | --info | --inf)
 413     ac_prev=infodir ;;
 414   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 415     infodir=$ac_optarg ;;
 416
 417   -libdir | --libdir | --libdi | --libd)
 418     ac_prev=libdir ;;
 419   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 420     libdir=$ac_optarg ;;
 421
 422   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 423   | --libexe | --libex | --libe)
 424     ac_prev=libexecdir ;;
 425   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 426   | --libexe=* | --libex=* | --libe=*)
 427     libexecdir=$ac_optarg ;;
 428
 429   -localstatedir | --localstatedir | --localstatedi | --localstated \
 430   | --localstate | --localstat | --localsta | --localst \
 431   | --locals | --local | --loca | --loc | --lo)
 432     ac_prev=localstatedir ;;
 433   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 434   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 435   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 436     localstatedir=$ac_optarg ;;
 437
 438   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 439     ac_prev=mandir ;;
 440   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 441     mandir=$ac_optarg ;;
 442
 443   -nfp | --nfp | --nf)
 444     # Obsolete; use --without-fp.
 445     with_fp=no ;;
 446
 447   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 448   | --no-cr | --no-c | -n)
 449     no_create=yes ;;
 450
 451   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 452   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 453     no_recursion=yes ;;
 454
 455   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 456   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 457   | --oldin | --oldi | --old | --ol | --o)
 458     ac_prev=oldincludedir ;;
 459   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 460   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 461   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 462     oldincludedir=$ac_optarg ;;
 463
 464   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 465     ac_prev=prefix ;;
 466   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 467     prefix=$ac_optarg ;;
 468
 469   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 470   | --program-pre | --program-pr | --program-p)
 471     ac_prev=program_prefix ;;
 472   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 473   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 474     program_prefix=$ac_optarg ;;
 475
 476   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 477   | --program-suf | --program-su | --program-s)
 478     ac_prev=program_suffix ;;
 479   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 480   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 481     program_suffix=$ac_optarg ;;
 482
 483   -program-transform-name | --program-transform-name \
 484   | --program-transform-nam | --program-transform-na \
 485   | --program-transform-n | --program-transform- \
 486   | --program-transform | --program-transfor \
 487   | --program-transfo | --program-transf \
 488   | --program-trans | --program-tran \
 489   | --progr-tra | --program-tr | --program-t)
 490     ac_prev=program_transform_name ;;
 491   -program-transform-name=* | --program-transform-name=* \
 492   | --program-transform-nam=* | --program-transform-na=* \
 493   | --program-transform-n=* | --program-transform-=* \
 494   | --program-transform=* | --program-transfor=* \
 495   | --program-transfo=* | --program-transf=* \
 496   | --program-trans=* | --program-tran=* \
 497   | --progr-tra=* | --program-tr=* | --program-t=*)
 498     program_transform_name=$ac_optarg ;;
 499
 500   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 501   | -silent | --silent | --silen | --sile | --sil)
 502     silent=yes ;;
 503
 504   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 505     ac_prev=sbindir ;;
 506   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 507   | --sbi=* | --sb=*)
 508     sbindir=$ac_optarg ;;
 509
 510   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 511   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 512   | --sharedst | --shareds | --shared | --share | --shar \
 513   | --sha | --sh)
 514     ac_prev=sharedstatedir ;;
 515   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 516   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 517   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 518   | --sha=* | --sh=*)
 519     sharedstatedir=$ac_optarg ;;
 520
 521   -site | --site | --sit)
 522     ac_prev=site ;;
 523   -site=* | --site=* | --sit=*)
 524     site=$ac_optarg ;;
 525
 526   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 527     ac_prev=srcdir ;;
 528   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 529     srcdir=$ac_optarg ;;
 530
 531   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 532   | --syscon | --sysco | --sysc | --sys | --sy)
 533     ac_prev=sysconfdir ;;
 534   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 535   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 536     sysconfdir=$ac_optarg ;;
 537
 538   -target | --target | --targe | --targ | --tar | --ta | --t)
 539     ac_prev=target_alias ;;
 540   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 541     target_alias=$ac_optarg ;;
 542
 543   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 544     verbose=yes ;;
 545
 546   -version | --version | --versio | --versi | --vers | -V)
 547     ac_init_version=: ;;
 548
 549   -with-* | --with-*)
 550     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 551     # Reject names that are not valid shell variable names.
 552     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 553       { echo "$as_me: error: invalid package name: $ac_package" >&2
 554    { (exit 1); exit 1; }; }
 555     ac_package=`echo $ac_package| sed 's/-/_/g'`
 556     case $ac_option in
 557       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 558       *) ac_optarg=yes ;;
 559     esac
 560     eval "with_$ac_package='$ac_optarg'" ;;
 561
 562   -without-* | --without-*)
 563     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 564     # Reject names that are not valid shell variable names.
 565     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 566       { echo "$as_me: error: invalid package name: $ac_package" >&2
 567    { (exit 1); exit 1; }; }
 568     ac_package=`echo $ac_package | sed 's/-/_/g'`
 569     eval "with_$ac_package=no" ;;
 570
 571   --x)
 572     # Obsolete; use --with-x.
 573     with_x=yes ;;
 574
 575   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 576   | --x-incl | --x-inc | --x-in | --x-i)
 577     ac_prev=x_includes ;;
 578   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 579   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 580     x_includes=$ac_optarg ;;
 581
 582   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 583   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 584     ac_prev=x_libraries ;;
 585   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 586   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 587     x_libraries=$ac_optarg ;;
 588
 589   -*) { echo "$as_me: error: unrecognized option: $ac_option
 590 Try \`$0 --help' for more information." >&2
 591    { (exit 1); exit 1; }; }
 592     ;;
 593
 594   *=*)
 595     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 596     # Reject names that are not valid shell variable names.
 597     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 598       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 599    { (exit 1); exit 1; }; }
 600     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 601     eval "$ac_envvar='$ac_optarg'"
 602     export $ac_envvar ;;
 603
 604   *)
 605     # FIXME: should be removed in autoconf 3.0.
 606     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 607     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 608       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 609     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 610     ;;
 611
 612   esac
 613 done
 614
 615 if test -n "$ac_prev"; then
 616   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 617   { echo "$as_me: error: missing argument to $ac_option" >&2
 618    { (exit 1); exit 1; }; }
 619 fi
 620
 621 # Be sure to have absolute paths.
 622 for ac_var in exec_prefix prefix
 623 do
 624   eval ac_val=$`echo $ac_var`
 625   case $ac_val in
 626     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 627     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 628    { (exit 1); exit 1; }; };;
 629   esac
 630 done
 631
 632 # Be sure to have absolute paths.
 633 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 634               localstatedir libdir includedir oldincludedir infodir mandir
 635 do
 636   eval ac_val=$`echo $ac_var`
 637   case $ac_val in
 638     [\\/$]* | ?:[\\/]* ) ;;
 639     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 640    { (exit 1); exit 1; }; };;
 641   esac
 642 done
 643
 644 # There might be people who depend on the old broken behavior: `$host'
 645 # used to hold the argument of --host etc.
 646 # FIXME: To remove some day.
 647 build=$build_alias
 648 host=$host_alias
 649 target=$target_alias
 650
 651 # FIXME: To remove some day.
 652 if test "x$host_alias" != x; then
 653   if test "x$build_alias" = x; then
 654     cross_compiling=maybe
 655     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 656     If a cross compiler is detected then cross compile mode will be used." >&2
 657   elif test "x$build_alias" != "x$host_alias"; then
 658     cross_compiling=yes
 659   fi
 660 fi
 661
 662 ac_tool_prefix=
 663 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 664
 665 test "$silent" = yes && exec 6>/dev/null
 666
 667
 668 # Find the source files, if location was not specified.
 669 if test -z "$srcdir"; then
 670   ac_srcdir_defaulted=yes
 671   # Try the directory containing this script, then its parent.
 672   ac_confdir=`(dirname "$0") 2>/dev/null ||
 673 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 674          X"$0" : 'X\(//\)[^/]' \| \
 675          X"$0" : 'X\(//\)$' \| \
 676          X"$0" : 'X\(/\)' \| \
 677          .     : '\(.\)' 2>/dev/null ||
 678 echo X"$0" |
 679     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 680           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 681           /^X\(\/\/\)$/{ s//\1/; q; }
 682           /^X\(\/\).*/{ s//\1/; q; }
 683           s/.*/./; q'`
 684   srcdir=$ac_confdir
 685   if test ! -r $srcdir/$ac_unique_file; then
 686     srcdir=..
 687   fi
 688 else
 689   ac_srcdir_defaulted=no
 690 fi
 691 if test ! -r $srcdir/$ac_unique_file; then
 692   if test "$ac_srcdir_defaulted" = yes; then
 693     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 694    { (exit 1); exit 1; }; }
 695   else
 696     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 697    { (exit 1); exit 1; }; }
 698   fi
 699 fi
 700 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 701   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 702    { (exit 1); exit 1; }; }
 703 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 704 ac_env_build_alias_set=${build_alias+set}
 705 ac_env_build_alias_value=$build_alias
 706 ac_cv_env_build_alias_set=${build_alias+set}
 707 ac_cv_env_build_alias_value=$build_alias
 708 ac_env_host_alias_set=${host_alias+set}
 709 ac_env_host_alias_value=$host_alias
 710 ac_cv_env_host_alias_set=${host_alias+set}
 711 ac_cv_env_host_alias_value=$host_alias
 712 ac_env_target_alias_set=${target_alias+set}
 713 ac_env_target_alias_value=$target_alias
 714 ac_cv_env_target_alias_set=${target_alias+set}
 715 ac_cv_env_target_alias_value=$target_alias
 716 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 717
 718 ac_env_CC_set=${CC+set}
 719 ac_env_CC_value=$CC
 720 ac_cv_env_CC_set=${CC+set}
 721 ac_cv_env_CC_value=$CC
 722 ac_env_CFLAGS_set=${CFLAGS+set}
 723 ac_env_CFLAGS_value=$CFLAGS
 724 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 725 ac_cv_env_CFLAGS_value=$CFLAGS
 726 ac_env_LDFLAGS_set=${LDFLAGS+set}
 727 ac_env_LDFLAGS_value=$LDFLAGS
 728 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 729 ac_cv_env_LDFLAGS_value=$LDFLAGS
 730 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 731 ac_env_CPPFLAGS_value=$CPPFLAGS
 732 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 733 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 734 ac_env_CXX_set=${CXX+set}
 735 ac_env_CXX_value=$CXX
 736 ac_cv_env_CXX_set=${CXX+set}
 737 ac_cv_env_CXX_value=$CXX
 738 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 739 ac_env_CXXFLAGS_value=$CXXFLAGS
 740 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 741 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 742 ac_env_AR_set=${AR+set}
 743 ac_env_AR_value=$AR
 744 ac_cv_env_AR_set=${AR+set}
 745 ac_cv_env_AR_value=$AR
 746 ac_env_AS_set=${AS+set}
 747 ac_env_AS_value=$AS
 748 ac_cv_env_AS_set=${AS+set}
 749 ac_cv_env_AS_value=$AS
 750 ac_env_DLLTOOL_set=${DLLTOOL+set}
 751 ac_env_DLLTOOL_value=$DLLTOOL
 752 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 753 ac_cv_env_DLLTOOL_value=$DLLTOOL
 754 ac_env_LD_set=${LD+set}
 755 ac_env_LD_value=$LD
 756 ac_cv_env_LD_set=${LD+set}
 757 ac_cv_env_LD_value=$LD
 758 ac_env_LIPO_set=${LIPO+set}
 759 ac_env_LIPO_value=$LIPO
 760 ac_cv_env_LIPO_set=${LIPO+set}
 761 ac_cv_env_LIPO_value=$LIPO
 762 ac_env_NM_set=${NM+set}
 763 ac_env_NM_value=$NM
 764 ac_cv_env_NM_set=${NM+set}
 765 ac_cv_env_NM_value=$NM
 766 ac_env_RANLIB_set=${RANLIB+set}
 767 ac_env_RANLIB_value=$RANLIB
 768 ac_cv_env_RANLIB_set=${RANLIB+set}
 769 ac_cv_env_RANLIB_value=$RANLIB
 770 ac_env_STRIP_set=${STRIP+set}
 771 ac_env_STRIP_value=$STRIP
 772 ac_cv_env_STRIP_set=${STRIP+set}
 773 ac_cv_env_STRIP_value=$STRIP
 774 ac_env_WINDRES_set=${WINDRES+set}
 775 ac_env_WINDRES_value=$WINDRES
 776 ac_cv_env_WINDRES_set=${WINDRES+set}
 777 ac_cv_env_WINDRES_value=$WINDRES
 778 ac_env_WINDMC_set=${WINDMC+set}
 779 ac_env_WINDMC_value=$WINDMC
 780 ac_cv_env_WINDMC_set=${WINDMC+set}
 781 ac_cv_env_WINDMC_value=$WINDMC
 782 ac_env_OBJCOPY_set=${OBJCOPY+set}
 783 ac_env_OBJCOPY_value=$OBJCOPY
 784 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 785 ac_cv_env_OBJCOPY_value=$OBJCOPY
 786 ac_env_OBJDUMP_set=${OBJDUMP+set}
 787 ac_env_OBJDUMP_value=$OBJDUMP
 788 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 789 ac_cv_env_OBJDUMP_value=$OBJDUMP
 790 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 791 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 792 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 793 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 794 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 795 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 796 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 797 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 798 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 799 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 800 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 801 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 802 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 803 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 804 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 805 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 806 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 807 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 808 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 809 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 810 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 811 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 812 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 813 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 814 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 815 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 816 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 817 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 818 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 819 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 820 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 821 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 822 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 823 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 824 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 825 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 826 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 827 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 828 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 829 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 830 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 831 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 832 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 833 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 834 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 835 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 836 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 837 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 838 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 839 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 840 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 841 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 842 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 843 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 844 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 845 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 846 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 847 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 848 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 849 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 850 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 851 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 852 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 853 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 854
 855 #
 856 # Report the --help message.
 857 #
 858 if test "$ac_init_help" = "long"; then
 859   # Omit some internal or obsolete options to make the list less imposing.
 860   # This message is too long to be a string in the A/UX 3.1 sh.
 861   cat <<_ACEOF
 862 \`configure' configures this package to adapt to many kinds of systems.
 863
 864 Usage: $0 [OPTION]... [VAR=VALUE]...
 865
 866 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 867 VAR=VALUE.  See below for descriptions of some of the useful variables.
 868
 869 Defaults for the options are specified in brackets.
 870
 871 Configuration:
 872   -h, --help              display this help and exit
 873       --help=short        display options specific to this package
 874       --help=recursive    display the short help of all the included packages
 875   -V, --version           display version information and exit
 876   -q, --quiet, --silent   do not print \`checking...' messages
 877       --cache-file=FILE   cache test results in FILE [disabled]
 878   -C, --config-cache      alias for \`--cache-file=config.cache'
 879   -n, --no-create         do not create output files
 880       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 881
 882 _ACEOF
 883
 884   cat <<_ACEOF
 885 Installation directories:
 886   --prefix=PREFIX         install architecture-independent files in PREFIX
 887                           [$ac_default_prefix]
 888   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 889                           [PREFIX]
 890
 891 By default, \`make install' will install all the files in
 892 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 893 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 894 for instance \`--prefix=\$HOME'.
 895
 896 For better control, use the options below.
 897
 898 Fine tuning of the installation directories:
 899   --bindir=DIR           user executables [EPREFIX/bin]
 900   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 901   --libexecdir=DIR       program executables [EPREFIX/libexec]
 902   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 903   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 904   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 905   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 906   --libdir=DIR           object code libraries [EPREFIX/lib]
 907   --includedir=DIR       C header files [PREFIX/include]
 908   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 909   --infodir=DIR          info documentation [PREFIX/info]
 910   --mandir=DIR           man documentation [PREFIX/man]
 911 _ACEOF
 912
 913   cat <<\_ACEOF
 914
 915 Program names:
 916   --program-prefix=PREFIX            prepend PREFIX to installed program names
 917   --program-suffix=SUFFIX            append SUFFIX to installed program names
 918   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 919
 920 System types:
 921   --build=BUILD     configure for building on BUILD [guessed]
 922   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 923   --target=TARGET   configure for building compilers for TARGET [HOST]
 924 _ACEOF
 925 fi
 926
 927 if test -n "$ac_init_help"; then
 928
 929   cat <<\_ACEOF
 930
 931 Optional Features:
 932   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 933   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 934   --enable-gold           use gold instead of ld
 935   --enable-libada         build libada directory
 936   --enable-libssp         build libssp directory
 937   --enable-stage1-languages[=all]   choose additional languages to build during
 938                           stage1.  Mostly useful for compiler development.
 939   --enable-objc-gc        enable use of Boehm's garbage collector with the
 940                           GNU Objective-C runtime
 941   --enable-bootstrap      enable bootstrapping [yes if native build]
 942   --enable-serial-[{host,target,build}-]configure
 943                           force sequential configuration of
 944                           sub-packages for the host, target or build
 945                           machine, or all sub-packages
 946   --enable-maintainer-mode enable make rules and dependencies not useful
 947                           (and sometimes confusing) to the casual installer
 948   --enable-stage1-checking[=all]   choose additional checking for stage1
 949                           of the compiler
 950   --enable-werror         enable -Werror in bootstrap stage2 and later
 951
 952 Optional Packages:
 953   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 954   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 955   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 956   --with-mpfr-dir=PATH    this option has been REMOVED
 957   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 958                           Equivalent to --with-mpfr-include=PATH/include
 959                           plus --with-mpfr-lib=PATH/lib
 960   --with-mpfr-include=PATH
 961                           specify directory for installed MPFR include files
 962   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 963   --with-gmp-dir=PATH     this option has been REMOVED
 964   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 965                           Equivalent to --with-gmp-include=PATH/include
 966                           plus --with-gmp-lib=PATH/lib
 967   --with-gmp-include=PATH specify directory for installed GMP include files
 968   --with-gmp-lib=PATH     specify directory for the installed GMP library
 969   --with-build-sysroot=SYSROOT
 970                           use sysroot as the system root during the build
 971   --with-debug-prefix-map='A=B C=D ...'
 972                              map A to B, C to D ... in debug information
 973   --with-build-time-tools=PATH
 974                           use given path to find target tools during the build
 975   --with-datarootdir      use datarootdir as the data root directory.
 976   --with-docdir           install documentation in this directory.
 977   --with-pdfdir           install pdf in this directory.
 978   --with-htmldir          install html in this directory.
 979
 980 Some influential environment variables:
 981   CC          C compiler command
 982   CFLAGS      C compiler flags
 983   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 984               nonstandard directory <lib dir>
 985   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 986               headers in a nonstandard directory <include dir>
 987   CXX         C++ compiler command
 988   CXXFLAGS    C++ compiler flags
 989   AR          AR for the host
 990   AS          AS for the host
 991   DLLTOOL     DLLTOOL for the host
 992   LD          LD for the host
 993   LIPO        LIPO for the host
 994   NM          NM for the host
 995   RANLIB      RANLIB for the host
 996   STRIP       STRIP for the host
 997   WINDRES     WINDRES for the host
 998   WINDMC      WINDMC for the host
 999   OBJCOPY     OBJCOPY for the host
1000   OBJDUMP     OBJDUMP for the host
1001   CC_FOR_TARGET
1002               CC for the target
1003   CXX_FOR_TARGET
1004               CXX for the target
1005   GCC_FOR_TARGET
1006               GCC for the target
1007   GCJ_FOR_TARGET
1008               GCJ for the target
1009   GFORTRAN_FOR_TARGET
1010               GFORTRAN for the target
1011   AR_FOR_TARGET
1012               AR for the target
1013   AS_FOR_TARGET
1014               AS for the target
1015   DLLTOOL_FOR_TARGET
1016               DLLTOOL for the target
1017   LD_FOR_TARGET
1018               LD for the target
1019   LIPO_FOR_TARGET
1020               LIPO for the target
1021   NM_FOR_TARGET
1022               NM for the target
1023   OBJDUMP_FOR_TARGET
1024               OBJDUMP for the target
1025   RANLIB_FOR_TARGET
1026               RANLIB for the target
1027   STRIP_FOR_TARGET
1028               STRIP for the target
1029   WINDRES_FOR_TARGET
1030               WINDRES for the target
1031   WINDMC_FOR_TARGET
1032               WINDMC for the target
1033
1034 Use these variables to override the choices made by `configure' or to help
1035 it to find libraries and programs with nonstandard names/locations.
1036
1037 _ACEOF
1038 fi
1039
1040 if test "$ac_init_help" = "recursive"; then
1041   # If there are subdirs, report their specific --help.
1042   ac_popdir=`pwd`
1043   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1044     test -d $ac_dir || continue
1045     ac_builddir=.
1046
1047 if test "$ac_dir" != .; then
1048   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1049   # A "../" for each directory in $ac_dir_suffix.
1050   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1051 else
1052   ac_dir_suffix= ac_top_builddir=
1053 fi
1054
1055 case $srcdir in
1056   .)  # No --srcdir option.  We are building in place.
1057     ac_srcdir=.
1058     if test -z "$ac_top_builddir"; then
1059        ac_top_srcdir=.
1060     else
1061        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1062     fi ;;
1063   [\\/]* | ?:[\\/]* )  # Absolute path.
1064     ac_srcdir=$srcdir$ac_dir_suffix;
1065     ac_top_srcdir=$srcdir ;;
1066   *) # Relative path.
1067     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1068     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1069 esac
1070
1071 # Do not use `cd foo && pwd` to compute absolute paths, because
1072 # the directories may not exist.
1073 case `pwd` in
1074 .) ac_abs_builddir="$ac_dir";;
1075 *)
1076   case "$ac_dir" in
1077   .) ac_abs_builddir=`pwd`;;
1078   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1079   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1080   esac;;
1081 esac
1082 case $ac_abs_builddir in
1083 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1084 *)
1085   case ${ac_top_builddir}. in
1086   .) ac_abs_top_builddir=$ac_abs_builddir;;
1087   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1088   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1089   esac;;
1090 esac
1091 case $ac_abs_builddir in
1092 .) ac_abs_srcdir=$ac_srcdir;;
1093 *)
1094   case $ac_srcdir in
1095   .) ac_abs_srcdir=$ac_abs_builddir;;
1096   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1097   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1098   esac;;
1099 esac
1100 case $ac_abs_builddir in
1101 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1102 *)
1103   case $ac_top_srcdir in
1104   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1105   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1106   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1107   esac;;
1108 esac
1109
1110     cd $ac_dir
1111     # Check for guested configure; otherwise get Cygnus style configure.
1112     if test -f $ac_srcdir/configure.gnu; then
1113       echo
1114       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1115     elif test -f $ac_srcdir/configure; then
1116       echo
1117       $SHELL $ac_srcdir/configure  --help=recursive
1118     elif test -f $ac_srcdir/configure.ac ||
1119            test -f $ac_srcdir/configure.in; then
1120       echo
1121       $ac_configure --help
1122     else
1123       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1124     fi
1125     cd $ac_popdir
1126   done
1127 fi
1128
1129 test -n "$ac_init_help" && exit 0
1130 if $ac_init_version; then
1131   cat <<\_ACEOF
1132
1133 Copyright (C) 2003 Free Software Foundation, Inc.
1134 This configure script is free software; the Free Software Foundation
1135 gives unlimited permission to copy, distribute and modify it.
1136 _ACEOF
1137   exit 0
1138 fi
1139 exec 5>config.log
1140 cat >&5 <<_ACEOF
1141 This file contains any messages produced by compilers while
1142 running configure, to aid debugging if configure makes a mistake.
1143
1144 It was created by $as_me, which was
1145 generated by GNU Autoconf 2.59.  Invocation command line was
1146
1147   $ $0 $@
1148
1149 _ACEOF
1150 {
1151 cat <<_ASUNAME
1152 ## --------- ##
1153 ## Platform. ##
1154 ## --------- ##
1155
1156 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1157 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1158 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1159 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1160 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1161
1162 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1163 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1164
1165 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1166 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1167 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1168 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1169 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1170 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1171 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1172
1173 _ASUNAME
1174
1175 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1176 for as_dir in $PATH
1177 do
1178   IFS=$as_save_IFS
1179   test -z "$as_dir" && as_dir=.
1180   echo "PATH: $as_dir"
1181 done
1182
1183 } >&5
1184
1185 cat >&5 <<_ACEOF
1186
1187
1188 ## ----------- ##
1189 ## Core tests. ##
1190 ## ----------- ##
1191
1192 _ACEOF
1193
1194
1195 # Keep a trace of the command line.
1196 # Strip out --no-create and --no-recursion so they do not pile up.
1197 # Strip out --silent because we don't want to record it for future runs.
1198 # Also quote any args containing shell meta-characters.
1199 # Make two passes to allow for proper duplicate-argument suppression.
1200 ac_configure_args=
1201 ac_configure_args0=
1202 ac_configure_args1=
1203 ac_sep=
1204 ac_must_keep_next=false
1205 for ac_pass in 1 2
1206 do
1207   for ac_arg
1208   do
1209     case $ac_arg in
1210     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1211     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1212     | -silent | --silent | --silen | --sile | --sil)
1213       continue ;;
1214     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1215       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1216     esac
1217     case $ac_pass in
1218     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1219     2)
1220       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1221       if test $ac_must_keep_next = true; then
1222         ac_must_keep_next=false # Got value, back to normal.
1223       else
1224         case $ac_arg in
1225           *=* | --config-cache | -C | -disable-* | --disable-* \
1226           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1227           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1228           | -with-* | --with-* | -without-* | --without-* | --x)
1229             case "$ac_configure_args0 " in
1230               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1231             esac
1232             ;;
1233           -* ) ac_must_keep_next=true ;;
1234         esac
1235       fi
1236       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1237       # Get rid of the leading space.
1238       ac_sep=" "
1239       ;;
1240     esac
1241   done
1242 done
1243 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1244 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1245
1246 # When interrupted or exit'd, cleanup temporary files, and complete
1247 # config.log.  We remove comments because anyway the quotes in there
1248 # would cause problems or look ugly.
1249 # WARNING: Be sure not to use single quotes in there, as some shells,
1250 # such as our DU 5.0 friend, will then `close' the trap.
1251 trap 'exit_status=$?
1252   # Save into config.log some information that might help in debugging.
1253   {
1254     echo
1255
1256     cat <<\_ASBOX
1257 ## ---------------- ##
1258 ## Cache variables. ##
1259 ## ---------------- ##
1260 _ASBOX
1261     echo
1262     # The following way of writing the cache mishandles newlines in values,
1263 {
1264   (set) 2>&1 |
1265     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1266     *ac_space=\ *)
1267       sed -n \
1268         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1269           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1270       ;;
1271     *)
1272       sed -n \
1273         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1274       ;;
1275     esac;
1276 }
1277     echo
1278
1279     cat <<\_ASBOX
1280 ## ----------------- ##
1281 ## Output variables. ##
1282 ## ----------------- ##
1283 _ASBOX
1284     echo
1285     for ac_var in $ac_subst_vars
1286     do
1287       eval ac_val=$`echo $ac_var`
1288       echo "$ac_var='"'"'$ac_val'"'"'"
1289     done | sort
1290     echo
1291
1292     if test -n "$ac_subst_files"; then
1293       cat <<\_ASBOX
1294 ## ------------- ##
1295 ## Output files. ##
1296 ## ------------- ##
1297 _ASBOX
1298       echo
1299       for ac_var in $ac_subst_files
1300       do
1301         eval ac_val=$`echo $ac_var`
1302         echo "$ac_var='"'"'$ac_val'"'"'"
1303       done | sort
1304       echo
1305     fi
1306
1307     if test -s confdefs.h; then
1308       cat <<\_ASBOX
1309 ## ----------- ##
1310 ## confdefs.h. ##
1311 ## ----------- ##
1312 _ASBOX
1313       echo
1314       sed "/^$/d" confdefs.h | sort
1315       echo
1316     fi
1317     test "$ac_signal" != 0 &&
1318       echo "$as_me: caught signal $ac_signal"
1319     echo "$as_me: exit $exit_status"
1320   } >&5
1321   rm -f core *.core &&
1322   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1323     exit $exit_status
1324      ' 0
1325 for ac_signal in 1 2 13 15; do
1326   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1327 done
1328 ac_signal=0
1329
1330 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1331 rm -rf conftest* confdefs.h
1332 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1333 echo >confdefs.h
1334
1335 # Predefined preprocessor variables.
1336
1337 cat >>confdefs.h <<_ACEOF
1338 #define PACKAGE_NAME "$PACKAGE_NAME"
1339 _ACEOF
1340
1341
1342 cat >>confdefs.h <<_ACEOF
1343 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1344 _ACEOF
1345
1346
1347 cat >>confdefs.h <<_ACEOF
1348 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1349 _ACEOF
1350
1351
1352 cat >>confdefs.h <<_ACEOF
1353 #define PACKAGE_STRING "$PACKAGE_STRING"
1354 _ACEOF
1355
1356
1357 cat >>confdefs.h <<_ACEOF
1358 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1359 _ACEOF
1360
1361
1362 # Let the site file select an alternate cache file if it wants to.
1363 # Prefer explicitly selected file to automatically selected ones.
1364 if test -z "$CONFIG_SITE"; then
1365   if test "x$prefix" != xNONE; then
1366     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1367   else
1368     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1369   fi
1370 fi
1371 for ac_site_file in $CONFIG_SITE; do
1372   if test -r "$ac_site_file"; then
1373     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1374 echo "$as_me: loading site script $ac_site_file" >&6;}
1375     sed 's/^/| /' "$ac_site_file" >&5
1376     . "$ac_site_file"
1377   fi
1378 done
1379
1380 if test -r "$cache_file"; then
1381   # Some versions of bash will fail to source /dev/null (special
1382   # files actually), so we avoid doing that.
1383   if test -f "$cache_file"; then
1384     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1385 echo "$as_me: loading cache $cache_file" >&6;}
1386     case $cache_file in
1387       [\\/]* | ?:[\\/]* ) . $cache_file;;
1388       *)                      . ./$cache_file;;
1389     esac
1390   fi
1391 else
1392   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1393 echo "$as_me: creating cache $cache_file" >&6;}
1394   >$cache_file
1395 fi
1396
1397 # Check that the precious variables saved in the cache have kept the same
1398 # value.
1399 ac_cache_corrupted=false
1400 for ac_var in `(set) 2>&1 |
1401                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1402   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1403   eval ac_new_set=\$ac_env_${ac_var}_set
1404   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1405   eval ac_new_val="\$ac_env_${ac_var}_value"
1406   case $ac_old_set,$ac_new_set in
1407     set,)
1408       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1409 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1410       ac_cache_corrupted=: ;;
1411     ,set)
1412       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1413 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1414       ac_cache_corrupted=: ;;
1415     ,);;
1416     *)
1417       if test "x$ac_old_val" != "x$ac_new_val"; then
1418         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1419 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1420         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1421 echo "$as_me:   former value:  $ac_old_val" >&2;}
1422         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1423 echo "$as_me:   current value: $ac_new_val" >&2;}
1424         ac_cache_corrupted=:
1425       fi;;
1426   esac
1427   # Pass precious variables to config.status.
1428   if test "$ac_new_set" = set; then
1429     case $ac_new_val in
1430     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1431       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1432     *) ac_arg=$ac_var=$ac_new_val ;;
1433     esac
1434     case " $ac_configure_args " in
1435       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1436       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1437     esac
1438   fi
1439 done
1440 if $ac_cache_corrupted; then
1441   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1442 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1443   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1444 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1445    { (exit 1); exit 1; }; }
1446 fi
1447
1448 ac_ext=c
1449 ac_cpp='$CPP $CPPFLAGS'
1450 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1451 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1452 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474 # Find the build, host, and target systems.
1475 ac_aux_dir=
1476 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1477   if test -f $ac_dir/install-sh; then
1478     ac_aux_dir=$ac_dir
1479     ac_install_sh="$ac_aux_dir/install-sh -c"
1480     break
1481   elif test -f $ac_dir/install.sh; then
1482     ac_aux_dir=$ac_dir
1483     ac_install_sh="$ac_aux_dir/install.sh -c"
1484     break
1485   elif test -f $ac_dir/shtool; then
1486     ac_aux_dir=$ac_dir
1487     ac_install_sh="$ac_aux_dir/shtool install -c"
1488     break
1489   fi
1490 done
1491 if test -z "$ac_aux_dir"; then
1492   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1493 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1494    { (exit 1); exit 1; }; }
1495 fi
1496 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1497 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1498 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1499
1500 # Make sure we can run config.sub.
1501 $ac_config_sub sun4 >/dev/null 2>&1 ||
1502   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1503 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1504    { (exit 1); exit 1; }; }
1505
1506 echo "$as_me:$LINENO: checking build system type" >&5
1507 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1508 if test "${ac_cv_build+set}" = set; then
1509   echo $ECHO_N "(cached) $ECHO_C" >&6
1510 else
1511   ac_cv_build_alias=$build_alias
1512 test -z "$ac_cv_build_alias" &&
1513   ac_cv_build_alias=`$ac_config_guess`
1514 test -z "$ac_cv_build_alias" &&
1515   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1516 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1517    { (exit 1); exit 1; }; }
1518 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1519   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1520 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1521    { (exit 1); exit 1; }; }
1522
1523 fi
1524 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1525 echo "${ECHO_T}$ac_cv_build" >&6
1526 build=$ac_cv_build
1527 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1528 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1529 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1530
1531
1532  case ${build_alias} in
1533   "") build_noncanonical=${build} ;;
1534   *) build_noncanonical=${build_alias} ;;
1535 esac
1536
1537
1538
1539  case ${host_alias} in
1540   "") host_noncanonical=${build_noncanonical} ;;
1541   *) host_noncanonical=${host_alias} ;;
1542 esac
1543
1544
1545
1546  case ${target_alias} in
1547   "") target_noncanonical=${host_noncanonical} ;;
1548   *) target_noncanonical=${target_alias} ;;
1549 esac
1550
1551
1552
1553
1554 test "$host_noncanonical" = "$target_noncanonical" &&
1555   test "$program_prefix$program_suffix$program_transform_name" = \
1556     NONENONEs,x,x, &&
1557   program_transform_name=s,y,y,
1558
1559 echo "$as_me:$LINENO: checking host system type" >&5
1560 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1561 if test "${ac_cv_host+set}" = set; then
1562   echo $ECHO_N "(cached) $ECHO_C" >&6
1563 else
1564   ac_cv_host_alias=$host_alias
1565 test -z "$ac_cv_host_alias" &&
1566   ac_cv_host_alias=$ac_cv_build_alias
1567 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1568   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1569 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1570    { (exit 1); exit 1; }; }
1571
1572 fi
1573 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1574 echo "${ECHO_T}$ac_cv_host" >&6
1575 host=$ac_cv_host
1576 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1577 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1578 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1579
1580
1581 echo "$as_me:$LINENO: checking target system type" >&5
1582 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1583 if test "${ac_cv_target+set}" = set; then
1584   echo $ECHO_N "(cached) $ECHO_C" >&6
1585 else
1586   ac_cv_target_alias=$target_alias
1587 test "x$ac_cv_target_alias" = "x" &&
1588   ac_cv_target_alias=$ac_cv_host_alias
1589 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1590   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1591 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1592    { (exit 1); exit 1; }; }
1593
1594 fi
1595 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1596 echo "${ECHO_T}$ac_cv_target" >&6
1597 target=$ac_cv_target
1598 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1599 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1600 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1601
1602
1603 # The aliases save the names the user supplied, while $host etc.
1604 # will get canonicalized.
1605 test -n "$target_alias" &&
1606   test "$program_prefix$program_suffix$program_transform_name" = \
1607     NONENONEs,x,x, &&
1608   program_prefix=${target_alias}-
1609 test "$program_prefix" != NONE &&
1610   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1611 # Use a double $ so make ignores it.
1612 test "$program_suffix" != NONE &&
1613   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1614 # Double any \ or $.  echo might interpret backslashes.
1615 # By default was `s,x,x', remove it if useless.
1616 cat <<\_ACEOF >conftest.sed
1617 s/[\\$]/&&/g;s/;s,x,x,$//
1618 _ACEOF
1619 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1620 rm conftest.sed
1621
1622
1623
1624 # Get 'install' or 'install-sh' and its variants.
1625 # Find a good install program.  We prefer a C program (faster),
1626 # so one script is as good as another.  But avoid the broken or
1627 # incompatible versions:
1628 # SysV /etc/install, /usr/sbin/install
1629 # SunOS /usr/etc/install
1630 # IRIX /sbin/install
1631 # AIX /bin/install
1632 # AmigaOS /C/install, which installs bootblocks on floppy discs
1633 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1634 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1635 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1636 # OS/2's system install, which has a completely different semantic
1637 # ./install, which can be erroneously created by make from ./install.sh.
1638 # Reject install programs that cannot install multiple files.
1639 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1640 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1641 if test -z "$INSTALL"; then
1642 if test "${ac_cv_path_install+set}" = set; then
1643   echo $ECHO_N "(cached) $ECHO_C" >&6
1644 else
1645   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1646 for as_dir in $PATH
1647 do
1648   IFS=$as_save_IFS
1649   test -z "$as_dir" && as_dir=.
1650   # Account for people who put trailing slashes in PATH elements.
1651 case $as_dir/ in
1652   ./ | .// | /cC/* | \
1653   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1654   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1655   /usr/ucb/* ) ;;
1656   *)
1657     # OSF1 and SCO ODT 3.0 have their own names for install.
1658     # Don't use installbsd from OSF since it installs stuff as root
1659     # by default.
1660     for ac_prog in ginstall scoinst install; do
1661       for ac_exec_ext in '' $ac_executable_extensions; do
1662         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1663           if test $ac_prog = install &&
1664             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1665             # AIX install.  It has an incompatible calling convention.
1666             :
1667           elif test $ac_prog = install &&
1668             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1669             # program-specific install script used by HP pwplus--don't use.
1670             :
1671           else
1672             rm -rf conftest.one conftest.two conftest.dir
1673             echo one > conftest.one
1674             echo two > conftest.two
1675             mkdir conftest.dir
1676             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1677               test -s conftest.one && test -s conftest.two &&
1678               test -s conftest.dir/conftest.one &&
1679               test -s conftest.dir/conftest.two
1680             then
1681               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1682               break 3
1683             fi
1684           fi
1685         fi
1686       done
1687     done
1688     ;;
1689 esac
1690 done
1691
1692 rm -rf conftest.one conftest.two conftest.dir
1693
1694 fi
1695   if test "${ac_cv_path_install+set}" = set; then
1696     INSTALL=$ac_cv_path_install
1697   else
1698     # As a last resort, use the slow shell script.  Don't cache a
1699     # value for INSTALL within a source directory, because that will
1700     # break other packages using the cache if that directory is
1701     # removed, or if the value is a relative name.
1702     INSTALL=$ac_install_sh
1703   fi
1704 fi
1705 echo "$as_me:$LINENO: result: $INSTALL" >&5
1706 echo "${ECHO_T}$INSTALL" >&6
1707
1708 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1709 # It thinks the first close brace ends the variable substitution.
1710 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1711
1712 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1713
1714 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1715
1716 echo "$as_me:$LINENO: checking whether ln works" >&5
1717 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1718 if test "${acx_cv_prog_LN+set}" = set; then
1719   echo $ECHO_N "(cached) $ECHO_C" >&6
1720 else
1721   rm -f conftestdata_t
1722 echo >conftestdata_f
1723 if ln conftestdata_f conftestdata_t 2>/dev/null
1724 then
1725   acx_cv_prog_LN=ln
1726 else
1727   acx_cv_prog_LN=no
1728 fi
1729 rm -f conftestdata_f conftestdata_t
1730
1731 fi
1732 if test $acx_cv_prog_LN = no; then
1733   LN="cp"
1734   echo "$as_me:$LINENO: result: no, using $LN" >&5
1735 echo "${ECHO_T}no, using $LN" >&6
1736 else
1737   LN="$acx_cv_prog_LN"
1738   echo "$as_me:$LINENO: result: yes" >&5
1739 echo "${ECHO_T}yes" >&6
1740 fi
1741
1742 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1743 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1744 LN_S=$as_ln_s
1745 if test "$LN_S" = "ln -s"; then
1746   echo "$as_me:$LINENO: result: yes" >&5
1747 echo "${ECHO_T}yes" >&6
1748 else
1749   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1750 echo "${ECHO_T}no, using $LN_S" >&6
1751 fi
1752
1753
1754 ### we might need to use some other shell than /bin/sh for running subshells
1755 ### If we are on Windows, search for the shell.  This will permit people
1756 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1757 ### without also having to set CONFIG_SHELL.  This code will work when
1758 ### using bash, which sets OSTYPE.
1759 case "${OSTYPE}" in
1760 *win32*)
1761   if test x${CONFIG_SHELL} = x ; then
1762     if test ! -f /bin/sh ; then
1763       if test x${SHELL} != x && test -f ${SHELL} ; then
1764         CONFIG_SHELL=${SHELL}
1765         export CONFIG_SHELL
1766       else
1767         for prog in sh sh.exe bash bash.exe; do
1768           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1769           for dir in $PATH; do
1770             test -z "$dir" && dir=.
1771             if test -f $dir/$prog; then
1772               CONFIG_SHELL=$dir/$prog
1773               export CONFIG_SHELL
1774               break
1775             fi
1776           done
1777           IFS="$save_ifs"
1778           test -n "${CONFIG_SHELL}" && break
1779         done
1780       fi
1781     fi
1782   fi
1783   ;;
1784 esac
1785
1786 config_shell=${CONFIG_SHELL-/bin/sh}
1787
1788 progname=$0
1789 # if PWD already has a value, it is probably wrong.
1790 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1791
1792 # Export original configure arguments for use by sub-configures.
1793 # Quote arguments with shell meta charatcers.
1794 TOPLEVEL_CONFIGURE_ARGUMENTS=
1795 set -- "$progname" "$@"
1796 for ac_arg
1797 do
1798   case "$ac_arg" in
1799   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1800     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1801     # if the argument is of the form -foo=baz, quote the baz part only
1802     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1803   *) ;;
1804   esac
1805   # Add the quoted argument to the list.
1806   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1807 done
1808 if test "$silent" = yes; then
1809   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1810 fi
1811 # Remove the initial space we just introduced and, as these will be
1812 # expanded by make, quote '$'.
1813 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1814
1815
1816 moveifchange=${srcdir}/move-if-change
1817
1818 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1819
1820 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1821 # a relative path.
1822 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1823   INSTALL="${srcpwd}/install-sh -c"
1824 fi
1825
1826 # Set srcdir to "." if that's what it is.
1827 # This is important for multilib support.
1828 pwd=`${PWDCMD-pwd}`
1829 if test "${pwd}" = "${srcpwd}" ; then
1830   srcdir=.
1831 fi
1832
1833 topsrcdir=$srcpwd
1834
1835 extra_host_args=
1836
1837 ### To add a new directory to the tree, first choose whether it is a target
1838 ### or a host dependent tool.  Then put it into the appropriate list
1839 ### (library or tools, host or target), doing a dependency sort.
1840
1841 # Subdirs will be configured in the order listed in build_configdirs,
1842 # configdirs, or target_configdirs; see the serialization section below.
1843
1844 # Dependency sorting is only needed when *configuration* must be done in
1845 # a particular order.  In all cases a dependency should be specified in
1846 # the Makefile, whether or not it's implicitly specified here.
1847
1848 # Double entries in build_configdirs, configdirs, or target_configdirs may
1849 # cause circular dependencies and break everything horribly.
1850
1851 # these library is used by various programs built for the build
1852 # environment
1853 #
1854 build_libs="build-libiberty"
1855
1856 # these tools are built for the build environment
1857 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1858
1859 # these libraries are used by various programs built for the host environment
1860 #
1861 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1862
1863 # these tools are built for the host environment
1864 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1865 # know that we are building the simulator.
1866 # binutils, gas and ld appear in that order because it makes sense to run
1867 # "make check" in that particular order.
1868 # If --enable-gold is used, "gold" will replace "ld".
1869 host_tools="texinfo byacc flex bison binutils gas ld fixincludes gcc sid sim gdb make patch prms send-pr gprof etc expect dejagnu ash bash bzip2 m4 autoconf automake libtool diff rcs fileutils shellutils time textutils wdiff find uudecode hello tar gzip indent recode release sed utils guile perl gawk findutils gettext zip fastjar gnattools"
1870
1871 # libgcj represents the runtime libraries only used by gcj.
1872 libgcj="target-libffi \
1873         target-zlib \
1874         target-qthreads \
1875         target-libjava"
1876
1877 # these libraries are built for the target environment, and are built after
1878 # the host libraries and the host tools (which may be a cross compiler)
1879 #
1880 target_libraries="target-libgcc \
1881                 target-libiberty \
1882                 target-libgloss \
1883                 target-newlib \
1884                 target-libgomp \
1885                 target-libstdc++-v3 \
1886                 target-libmudflap \
1887                 target-libssp \
1888                 target-libgfortran \
1889                 target-boehm-gc \
1890                 ${libgcj} \
1891                 target-libobjc \
1892                 target-libada"
1893
1894 # these tools are built using the target libraries, and are intended to
1895 # run only in the target environment
1896 #
1897 # note: any program that *uses* libraries that are in the "target_libraries"
1898 # list belongs in this list.  those programs are also very likely
1899 # candidates for the "native_only" list which follows
1900 #
1901 target_tools="target-examples target-groff target-gperf target-rda"
1902
1903 ################################################################################
1904
1905 ## All tools belong in one of the four categories, and are assigned above
1906 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1907 ## is important because configure will choke if they ever get through.
1908 ## ${configdirs} is directories we build using the host tools.
1909 ## ${target_configdirs} is directories we build using the target tools.
1910 configdirs=`echo ${host_libs} ${host_tools}`
1911 target_configdirs=`echo ${target_libraries} ${target_tools}`
1912 build_configdirs=`echo ${build_libs} ${build_tools}`
1913
1914
1915
1916 ################################################################################
1917
1918 srcname="gnu development package"
1919
1920 # This gets set non-empty for some net releases of packages.
1921 appdirs=""
1922
1923 # Define is_cross_compiler to save on calls to 'test'.
1924 is_cross_compiler=
1925 if test x"${host}" = x"${target}" ; then
1926   is_cross_compiler=no
1927 else
1928   is_cross_compiler=yes
1929 fi
1930
1931 # Find the build and target subdir names.
1932
1933 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1934 # have matching libraries, they should use host libraries: Makefile.tpl
1935 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1936 # However, they still use the build modules, because the corresponding
1937 # host modules (e.g. bison) are only built for the host when bootstrap
1938 # finishes. So:
1939 # - build_subdir is where we find build modules, and never changes.
1940 # - build_libsubdir is where we find build libraries, and can be overridden.
1941
1942 # Prefix 'build-' so this never conflicts with target_subdir.
1943 build_subdir="build-${build_noncanonical}"
1944
1945 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1946 if test "${with_build_libsubdir+set}" = set; then
1947   withval="$with_build_libsubdir"
1948   build_libsubdir="$withval"
1949 else
1950   build_libsubdir="$build_subdir"
1951 fi;
1952 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1953 if ( test $srcdir = . && test -d gcc ) \
1954    || test -d $srcdir/../host-${host_noncanonical}; then
1955   host_subdir="host-${host_noncanonical}"
1956 else
1957   host_subdir=.
1958 fi
1959 # No prefix.
1960 target_subdir=${target_noncanonical}
1961
1962
1963 # Skipdirs are removed silently.
1964 skipdirs=
1965 # Noconfigdirs are removed loudly.
1966 noconfigdirs=""
1967
1968 use_gnu_ld=
1969 # Make sure we don't let GNU ld be added if we didn't want it.
1970 if test x$with_gnu_ld = xno ; then
1971   use_gnu_ld=no
1972   noconfigdirs="$noconfigdirs ld gold"
1973 fi
1974
1975 use_gnu_as=
1976 # Make sure we don't let GNU as be added if we didn't want it.
1977 if test x$with_gnu_as = xno ; then
1978   use_gnu_as=no
1979   noconfigdirs="$noconfigdirs gas"
1980 fi
1981
1982 # some tools are so dependent upon X11 that if we're not building with X,
1983 # it's not even worth trying to configure, much less build, that tool.
1984
1985 case ${with_x} in
1986   yes | "") ;; # the default value for this tree is that X11 is available
1987   no)
1988     skipdirs="${skipdirs} tk itcl libgui"
1989     # We won't be able to build gdbtk without X.
1990     enable_gdbtk=no
1991     ;;
1992   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1993 esac
1994
1995 # Some tools are only suitable for building in a "native" situation.
1996 # Remove these if host!=target.
1997 native_only="autoconf automake libtool fileutils find gawk gettext gzip hello indent m4 rcs recode sed shellutils tar textutils uudecode wdiff target-groff guile perl time ash bash bzip2 prms gnuserv target-gperf"
1998
1999 # Similarly, some are only suitable for cross toolchains.
2000 # Remove these if host=target.
2001 cross_only="target-libgloss target-newlib target-opcodes"
2002
2003 case $is_cross_compiler in
2004   no) skipdirs="${skipdirs} ${cross_only}" ;;
2005   yes) skipdirs="${skipdirs} ${native_only}" ;;
2006 esac
2007
2008 # If both --with-headers and --with-libs are specified, default to
2009 # --without-newlib.
2010 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2011    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2012   if test x"${with_newlib}" = x ; then
2013     with_newlib=no
2014   fi
2015 fi
2016
2017 # Recognize --with-newlib/--without-newlib.
2018 case ${with_newlib} in
2019   no) skipdirs="${skipdirs} target-newlib" ;;
2020   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2021 esac
2022
2023 # Handle --enable-gold.
2024
2025 # Check whether --enable-gold or --disable-gold was given.
2026 if test "${enable_gold+set}" = set; then
2027   enableval="$enable_gold"
2028   ENABLE_GOLD=$enableval
2029 else
2030   ENABLE_GOLD=no
2031 fi;
2032 if test "${ENABLE_GOLD}" = "yes"; then
2033   # Check for ELF target.
2034   is_elf=no
2035   case "${target}" in
2036     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2037     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2038     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2039       case "${target}" in
2040         *-*-linux*aout* | *-*-linux*oldld*)
2041           ;;
2042         *)
2043           is_elf=yes
2044           ;;
2045       esac
2046   esac
2047
2048   if test "$is_elf" = "yes"; then
2049     # Check for target supported by gold.
2050     case "${target}" in
2051       i?86-*-* | x86_64-*-*)
2052         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2053         ;;
2054     esac
2055   fi
2056 fi
2057
2058 # Configure extra directories which are host specific
2059
2060 case "${host}" in
2061   *-cygwin*)
2062     configdirs="$configdirs libtermcap" ;;
2063 esac
2064
2065 # A target can indicate whether a language isn't supported for some reason.
2066 # Only spaces may be used in this macro; not newlines or tabs.
2067 unsupported_languages=
2068
2069 # Remove more programs from consideration, based on the host or
2070 # target this usually means that a port of the program doesn't
2071 # exist yet.
2072
2073 case "${host}" in
2074   hppa*64*-*-*)
2075     noconfigdirs="$noconfigdirs byacc"
2076     ;;
2077   i[3456789]86-*-vsta)
2078     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2079     ;;
2080   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2081     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2082     ;;
2083   x86_64-*-mingw*)
2084     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2085     ;;
2086   i[3456789]86-*-mingw32*)
2087     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2088     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2089     ;;
2090   i[3456789]86-*-beos*)
2091     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2092     ;;
2093   *-*-cygwin*)
2094     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2095     ;;
2096   *-*-netbsd*)
2097     noconfigdirs="$noconfigdirs rcs"
2098     ;;
2099   ppc*-*-pe)
2100     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2101     ;;
2102   powerpc-*-beos*)
2103     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2104     ;;
2105 esac
2106
2107
2108 # Check whether --enable-libada or --disable-libada was given.
2109 if test "${enable_libada+set}" = set; then
2110   enableval="$enable_libada"
2111   ENABLE_LIBADA=$enableval
2112 else
2113   ENABLE_LIBADA=yes
2114 fi;
2115 if test "${ENABLE_LIBADA}" != "yes" ; then
2116   noconfigdirs="$noconfigdirs gnattools"
2117 fi
2118
2119 # Check whether --enable-libssp or --disable-libssp was given.
2120 if test "${enable_libssp+set}" = set; then
2121   enableval="$enable_libssp"
2122   ENABLE_LIBSSP=$enableval
2123 else
2124   ENABLE_LIBSSP=yes
2125 fi;
2126
2127 # Save it here so that, even in case of --enable-libgcj, if the Java
2128 # front-end isn't enabled, we still get libgcj disabled.
2129 libgcj_saved=$libgcj
2130 case $enable_libgcj in
2131 yes)
2132   # If we reset it here, it won't get added to noconfigdirs in the
2133   # target-specific build rules, so it will be forcibly enabled
2134   # (unless the Java language itself isn't enabled).
2135   libgcj=
2136   ;;
2137 no)
2138   # Make sure we get it printed in the list of not supported target libs.
2139   noconfigdirs="$noconfigdirs ${libgcj}"
2140   ;;
2141 esac
2142
2143
2144 # Disable libmudflap on some systems.
2145 if test x$enable_libmudflap = x ; then
2146     case "${target}" in
2147     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2148         # Enable libmudflap by default in GNU and friends.
2149         ;;
2150     *-*-freebsd*)
2151         # Enable libmudflap by default in FreeBSD.
2152         ;;
2153     *)
2154         # Disable it by default everywhere else.
2155         noconfigdirs="$noconfigdirs target-libmudflap"
2156         ;;
2157     esac
2158 fi
2159
2160 # Disable libgomp on non POSIX hosted systems.
2161 if test x$enable_libgomp = x ; then
2162     # Enable libgomp by default on hosted POSIX systems.
2163     case "${target}" in
2164     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2165         ;;
2166     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2167         ;;
2168     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2169         ;;
2170     *-*-darwin* | *-*-aix*)
2171         ;;
2172     *)
2173         noconfigdirs="$noconfigdirs target-libgomp"
2174         ;;
2175     esac
2176 fi
2177
2178 # Default libgloss CPU subdirectory.
2179 libgloss_dir="$target_cpu"
2180
2181 case "${target}" in
2182   *-*-chorusos)
2183     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2184     ;;
2185   powerpc-*-darwin* | i[3456789]86-*-darwin* | x86_64-*-darwin9*)
2186     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2187     noconfigdirs="$noconfigdirs sim target-rda"
2188     ;;
2189   *-*-darwin*)
2190     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2191     noconfigdirs="$noconfigdirs sim target-rda"
2192     noconfigdirs="$noconfigdirs ${libgcj}"
2193     ;;
2194   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2195     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2196     ;;
2197   *-*-freebsd*)
2198     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2199     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2200         && test -f /usr/local/include/gmp.h; then
2201       with_gmp=/usr/local
2202     fi
2203
2204     # Skip some stuff that's unsupported on some FreeBSD configurations.
2205     case "${target}" in
2206       i*86-*-*) ;;
2207       alpha*-*-*) ;;
2208       *)
2209         noconfigdirs="$noconfigdirs ${libgcj}"
2210         ;;
2211     esac
2212     ;;
2213   *-*-kaos*)
2214     # Remove unsupported stuff on all kaOS configurations.
2215     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2216     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2217     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2218     noconfigdirs="$noconfigdirs target-libgloss"
2219     ;;
2220   *-*-netbsd*)
2221     # Skip some stuff on all NetBSD configurations.
2222     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2223
2224     # Skip some stuff that's unsupported on some NetBSD configurations.
2225     case "${target}" in
2226       i*86-*-netbsdelf*) ;;
2227       arm*-*-netbsdelf*) ;;
2228       *)
2229         noconfigdirs="$noconfigdirs ${libgcj}"
2230         ;;
2231     esac
2232     ;;
2233   *-*-netware*)
2234     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2235     ;;
2236   *-*-rtems*)
2237     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2238     ;;
2239     # The tpf target doesn't support gdb yet.
2240   *-*-tpf*)
2241     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2242     ;;
2243   *-*-uclinux*)
2244     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2245     ;;
2246   *-*-vxworks*)
2247     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2248     ;;
2249   alpha*-dec-osf*)
2250     # ld works, but does not support shared libraries.
2251     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2252     # gas doesn't generate exception information.
2253     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2254     ;;
2255   alpha*-*-*vms*)
2256     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2257     ;;
2258   alpha*-*-linux*)
2259     # newlib is not 64 bit ready
2260     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2261     ;;
2262   alpha*-*-*)
2263     # newlib is not 64 bit ready
2264     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2265     ;;
2266   am33_2.0-*-linux*)
2267     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2268     ;;
2269   sh-*-linux*)
2270     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2271     ;;
2272   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2273     noconfigdirs="$noconfigdirs ${libgcj}"
2274     noconfigdirs="$noconfigdirs target-examples"
2275     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2276     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2277     noconfigdirs="$noconfigdirs expect dejagnu"
2278     # the C++ libraries don't build on top of CE's C libraries
2279     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2280     noconfigdirs="$noconfigdirs target-newlib"
2281     case "${host}" in
2282       *-*-cygwin*) ;; # keep gdb and readline
2283       *) noconfigdirs="$noconfigdirs gdb readline"
2284          ;;
2285     esac
2286     libgloss_dir=wince
2287     ;;
2288   arc-*-*)
2289     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2290     ;;
2291   arm-semi-aof )
2292     ;;
2293   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2294     noconfigdirs="$noconfigdirs ${libgcj}"
2295     libgloss_dir=arm
2296     ;;
2297   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2298     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2299     libgloss_dir=arm
2300     ;;
2301   arm*-*-linux-gnueabi)
2302     noconfigdirs="$noconfigdirs target-qthreads"
2303     noconfigdirs="$noconfigdirs target-libobjc"
2304     case ${with_newlib} in
2305       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2306     esac
2307     libgloss_dir=arm
2308     ;;
2309   arm*-*-symbianelf*)
2310     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2311     libgloss_dir=arm
2312     ;;
2313   arm-*-pe*)
2314     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2315     ;;
2316   thumb-*-coff)
2317     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2318     ;;
2319   thumb-*-elf)
2320     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2321     ;;
2322   thumb-*-pe)
2323     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2324     ;;
2325   arm-*-riscix*)
2326     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2327     ;;
2328   avr-*-*)
2329     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2330     ;;
2331   bfin-*-*)
2332     noconfigdirs="$noconfigdirs gdb"
2333     if test x${is_cross_compiler} != xno ; then
2334       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2335     fi
2336     ;;
2337   c4x-*-* | tic4x-*-*)
2338     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2339     ;;
2340   c54x*-*-* | tic54x-*-*)
2341     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2342     ;;
2343   cris-*-* | crisv32-*-*)
2344     unsupported_languages="$unsupported_languages java"
2345     case "${target}" in
2346       *-*-aout)
2347         unsupported_languages="$unsupported_languages fortran"
2348         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2349       *-*-elf)
2350         noconfigdirs="$noconfigdirs target-boehm-gc";;
2351       *-*-linux*)
2352         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2353       *)
2354         unsupported_languages="$unsupported_languages fortran"
2355         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2356     esac
2357     libgloss_dir=cris
2358     ;;
2359   crx-*-*)
2360     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2361     ;;
2362   d10v-*-*)
2363     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2364     ;;
2365   d30v-*-*)
2366     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2367     ;;
2368   ep9312-*-elf | ep9312-*-coff)
2369     libgloss_dir=arm
2370     ;;
2371   fr30-*-elf*)
2372     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2373     ;;
2374   frv-*-*)
2375     noconfigdirs="$noconfigdirs ${libgcj}"
2376     ;;
2377   h8300*-*-*)
2378     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2379     ;;
2380   h8500-*-*)
2381     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2382     ;;
2383   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2384     ;;
2385   hppa*64*-*-linux* | parisc*64*-*-linux*)
2386     # In this case, it's because the hppa64-linux target is for
2387     # the kernel only at this point and has no libc, and thus no
2388     # headers, crt*.o, etc., all of which are needed by these.
2389     noconfigdirs="$noconfigdirs target-zlib"
2390     ;;
2391   parisc*-*-linux* | hppa*-*-linux*)
2392     ;;
2393   hppa*-*-*elf* | \
2394   hppa*-*-lites* | \
2395   hppa*-*-openbsd* | \
2396   hppa*64*-*-*)
2397     noconfigdirs="$noconfigdirs ${libgcj}"
2398     ;;
2399   hppa*-hp-hpux11*)
2400     noconfigdirs="$noconfigdirs ld shellutils"
2401     ;;
2402   hppa*-*-pro*)
2403     libgloss_dir=pa
2404     ;;
2405   hppa*-*-*)
2406     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2407     # build on HP-UX 10.20.
2408     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2409     ;;
2410   i960-*-*)
2411     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2412     ;;
2413   ia64*-*-elf*)
2414     # No gdb support yet.
2415     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2416     ;;
2417   ia64*-**-hpux*)
2418     # No gdb or ld support yet.
2419     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2420     ;;
2421   i370-*-opened*)
2422     ;;
2423   i[3456789]86-*-coff | i[3456789]86-*-elf)
2424     noconfigdirs="$noconfigdirs ${libgcj}"
2425     libgloss_dir=i386
2426     ;;
2427   i[3456789]86-*-linux*)
2428     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2429     # not build java stuff by default.
2430     case "${target}" in
2431       *-*-*libc1*)
2432         noconfigdirs="$noconfigdirs ${libgcj}";;
2433     esac
2434
2435     # This section makes it possible to build newlib natively on linux.
2436     # If we are using a cross compiler then don't configure newlib.
2437     if test x${is_cross_compiler} != xno ; then
2438       noconfigdirs="$noconfigdirs target-newlib"
2439     fi
2440     noconfigdirs="$noconfigdirs target-libgloss"
2441     # If we are not using a cross compiler, do configure newlib.
2442     # Note however, that newlib will only be configured in this situation
2443     # if the --with-newlib option has been given, because otherwise
2444     # 'target-newlib' will appear in skipdirs.
2445     ;;
2446   i[3456789]86-*-mingw32*)
2447     target_configdirs="$target_configdirs target-winsup"
2448     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2449     ;;
2450   x86_64-*-mingw*)
2451     target_configdirs="$target_configdirs target-winsup"
2452     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2453     ;;
2454   *-*-cygwin*)
2455     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2456     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2457     # always build newlib if winsup directory is present.
2458     if test -d "$srcdir/winsup/cygwin"; then
2459       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2460     elif test -d "$srcdir/newlib"; then
2461       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2462     fi
2463     ;;
2464   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2465   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2466     ;;
2467   i[3456789]86-*-pe)
2468     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2469     ;;
2470   i[3456789]86-*-sco3.2v5*)
2471     # The linker does not yet know about weak symbols in COFF,
2472     # and is not configured to handle mixed ELF and COFF.
2473     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2474     ;;
2475   i[3456789]86-*-sco*)
2476     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2477     ;;
2478   i[3456789]86-*-solaris2*)
2479     noconfigdirs="$noconfigdirs target-libgloss"
2480     ;;
2481   i[3456789]86-*-sysv4*)
2482     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2483     ;;
2484   i[3456789]86-*-beos*)
2485     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2486     ;;
2487   i[3456789]86-*-rdos*)
2488     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2489     ;;
2490   m32r-*-*)
2491     noconfigdirs="$noconfigdirs ${libgcj}"
2492     ;;
2493   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2494     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2495     libgloss_dir=m68hc11
2496     ;;
2497   m68k-*-elf*)
2498     noconfigdirs="$noconfigdirs ${libgcj}"
2499     ;;
2500   m68k-*-coff*)
2501     noconfigdirs="$noconfigdirs ${libgcj}"
2502     ;;
2503   m68*-*-* | fido-*-*)
2504     libgloss_dir=m68k
2505     ;;
2506   mcore-*-pe*)
2507   # The EPOC C++ environment does not support exceptions or rtti,
2508   # and so building libstdc++-v3 tends not to always work.
2509     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2510     ;;
2511   mmix-*-*)
2512     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2513     unsupported_languages="$unsupported_languages fortran java"
2514     ;;
2515   mn10200-*-*)
2516     noconfigdirs="$noconfigdirs ${libgcj}"
2517     ;;
2518   mn10300-*-*)
2519     noconfigdirs="$noconfigdirs ${libgcj}"
2520     ;;
2521   mt-*-*)
2522     noconfigdirs="$noconfigdirs sim"
2523     ;;
2524   powerpc-*-aix*)
2525     # copied from rs6000-*-* entry
2526     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2527     ;;
2528   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2529     target_configdirs="$target_configdirs target-winsup"
2530     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2531     # always build newlib.
2532     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2533     ;;
2534     # This is temporary until we can link against shared libraries
2535   powerpcle-*-solaris*)
2536     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2537     libgloss_dir=rs6000
2538     ;;
2539   powerpc-*-beos*)
2540     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2541     ;;
2542   powerpc-*-eabi)
2543     noconfigdirs="$noconfigdirs ${libgcj}"
2544     libgloss_dir=rs6000
2545     ;;
2546   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2547     libgloss_dir=rs6000
2548     ;;
2549   rs6000-*-lynxos*)
2550     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2551     ;;
2552   rs6000-*-aix*)
2553     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2554     ;;
2555   rs6000-*-*)
2556     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2557     ;;
2558   m68k-apollo-*)
2559     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2560     ;;
2561   mips*-sde-elf*)
2562     skipdirs="$skipdirs target-libiberty"
2563     noconfigdirs="$noconfigdirs ${libgcj}"
2564     if test x$with_newlib = xyes; then
2565       noconfigdirs="$noconfigdirs gprof"
2566     fi
2567     libgloss_dir=mips
2568     ;;
2569   mips*-*-irix5*)
2570     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2571     ;;
2572   mips*-*-irix6*)
2573     # Linking libjava exceeds command-line length limits on at least
2574     # IRIX 6.2, but not on IRIX 6.5.
2575     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2576     # <oldham@codesourcery.com>
2577     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2578     ;;
2579   mips*-*-bsd*)
2580     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2581     ;;
2582   mips*-*-linux*)
2583     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2584     ;;
2585   mips*-*-*)
2586     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2587     libgloss_dir=mips
2588     ;;
2589   romp-*-*)
2590     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2591     ;;
2592   sh-*-* | sh64-*-*)
2593     case "${host}" in
2594       i[3456789]86-*-vsta) ;; # don't add gprof back in
2595       i[3456789]86-*-go32*) ;; # don't add gprof back in
2596       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2597       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2598     esac
2599     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2600     ;;
2601   sparclet-*-aout* | sparc86x-*-*)
2602     libgloss_dir=sparc
2603     ;;
2604   sparc-*-elf*)
2605     noconfigdirs="$noconfigdirs ${libgcj}"
2606     ;;
2607   sparc64-*-elf*)
2608     noconfigdirs="$noconfigdirs ${libgcj}"
2609     libgloss_dir=sparc
2610     ;;
2611   sparclite-*-*)
2612     noconfigdirs="$noconfigdirs ${libgcj}"
2613     libgloss_dir=sparc
2614     ;;
2615   sparc-*-sunos4*)
2616     noconfigdirs="$noconfigdirs ${libgcj}"
2617     if test x${is_cross_compiler} != xno ; then
2618            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2619     else
2620            use_gnu_ld=no
2621     fi
2622     ;;
2623   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2624     noconfigdirs="$noconfigdirs ${libgcj}"
2625     ;;
2626   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2627     ;;
2628   spu-*-*)
2629     skipdirs="target-libssp"
2630     ;;
2631   v810-*-*)
2632     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2633     ;;
2634   v850-*-*)
2635     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2636     ;;
2637   v850e-*-*)
2638     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2639     ;;
2640   v850ea-*-*)
2641     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2642     ;;
2643   vax-*-vms)
2644     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2645     ;;
2646   vax-*-*)
2647     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2648     ;;
2649   xtensa*-*-*)
2650     noconfigdirs="$noconfigdirs ${libgcj}"
2651     ;;
2652   ip2k-*-*)
2653     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2654     ;;
2655   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2656     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2657     ;;
2658   *-*-lynxos*)
2659     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2660     ;;
2661   *-*-*)
2662     noconfigdirs="$noconfigdirs ${libgcj}"
2663     ;;
2664 esac
2665
2666 # If we aren't building newlib, then don't build libgloss, since libgloss
2667 # depends upon some newlib header files.
2668 case "${noconfigdirs}" in
2669   *target-libgloss*) ;;
2670   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2671 esac
2672
2673 # Work in distributions that contain no compiler tools, like Autoconf.
2674 tentative_cc=""
2675 host_makefile_frag=/dev/null
2676 if test -d ${srcdir}/config ; then
2677 case "${host}" in
2678   m68k-hp-hpux*)
2679     # Avoid "too much defining" errors from HPUX compiler.
2680     tentative_cc="cc -Wp,-H256000"
2681     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2682     # If it's HP/UX ar, this should be harmless.
2683     RANLIB="ar ts"
2684     ;;
2685   m68k-apollo-sysv*)
2686     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2687     ;;
2688   m68k-apollo-bsd*)
2689     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2690     # chokes on bfd, the compiler won't let you assign integers to enums, and
2691     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2692     # the apollo compiler" (the preferred version of GCC could be called cc,
2693     # or whatever), but I'm not sure leaving CC as cc is any better...
2694     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2695     # Used to have BISON=yacc.
2696     tentative_cc=gcc
2697     ;;
2698   m88k-dg-dgux*)
2699     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2700     ;;
2701   m88k-harris-cxux*)
2702     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2703     tentative_cc="cc -Xa"
2704     host_makefile_frag="config/mh-cxux"
2705     ;;
2706   m88k-motorola-sysv*)
2707     ;;
2708   mips*-dec-ultrix*)
2709     tentative_cc="cc -Wf,-XNg1000"
2710     host_makefile_frag="config/mh-decstation"
2711     ;;
2712   mips*-nec-sysv4*)
2713     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2714     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2715     host_makefile_frag="config/mh-necv4"
2716     ;;
2717   mips*-sgi-irix4*)
2718     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2719     # environment.  Also bump switch table size so that cp-parse will
2720     # compile.  Bump string length limit so linker builds.
2721     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2722     ;;
2723   mips*-*-sysv4*)
2724     host_makefile_frag="config/mh-sysv4"
2725     ;;
2726   mips*-*-sysv*)
2727     # This is for a MIPS running RISC/os 4.52C.
2728
2729     # This is needed for GDB, but needs to be in the top-level make because
2730     # if a library is compiled with the bsd headers and gets linked with the
2731     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2732     # a different size).
2733     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2734     # known except to select the sysv environment.  Could we use /proc instead?
2735     # These "sysv environments" and "bsd environments" often end up being a pain.
2736     #
2737     # This is not part of CFLAGS because perhaps not all C compilers have this
2738     # option.
2739     tentative_cc="cc -systype sysv"
2740     ;;
2741   i370-ibm-opened*)
2742     tentative_cc="c89"
2743     ;;
2744   i[3456789]86-*-sysv5*)
2745     host_makefile_frag="config/mh-sysv5"
2746     ;;
2747   i[3456789]86-*-dgux*)
2748     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2749     host_makefile_frag="config/mh-dgux386"
2750     ;;
2751   i[3456789]86-ncr-sysv4.3*)
2752     # The MetaWare compiler will generate a copyright message unless you
2753     # turn it off by adding the -Hnocopyr flag.
2754     tentative_cc="cc -Hnocopyr"
2755     ;;
2756   i[3456789]86-ncr-sysv4*)
2757     # for an NCR 3000 (i486/SVR4) system.
2758     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2759     # This compiler not only emits obnoxious copyright messages every time
2760     # you run it, but it chokes and dies on a whole bunch of GNU source
2761     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2762     tentative_cc="/usr/ccs/ATT/cc"
2763     host_makefile_frag="config/mh-ncr3000"
2764     ;;
2765   i[3456789]86-*-sco3.2v5*)
2766     ;;
2767   i[3456789]86-*-sco*)
2768     # The native C compiler botches some simple uses of const.  Unfortunately,
2769     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2770     tentative_cc="cc -Dconst="
2771     host_makefile_frag="config/mh-sco"
2772     ;;
2773   i[3456789]86-*-udk*)
2774     host_makefile_frag="config/mh-sysv5"
2775     ;;
2776   i[3456789]86-*-solaris2*)
2777     host_makefile_frag="config/mh-sysv4"
2778     ;;
2779   i[3456789]86-*-msdosdjgpp*)
2780     host_makefile_frag="config/mh-djgpp"
2781     ;;
2782   *-cygwin*)
2783
2784 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2785 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2786 echo a >cygwin-cat-check
2787 if test `cat cygwin-cat-check` == a ; then
2788   rm cygwin-cat-check
2789   echo "$as_me:$LINENO: result: yes" >&5
2790 echo "${ECHO_T}yes" >&6
2791 else
2792   rm cygwin-cat-check
2793   echo "$as_me:$LINENO: result: no" >&5
2794 echo "${ECHO_T}no" >&6
2795   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2796   Please either mount the build directory in binary mode or run the following
2797   commands before running any configure script:
2798 set -o igncr
2799 export SHELLOPTS
2800   " >&5
2801 echo "$as_me: error: The cat command does not ignore carriage return characters.
2802   Please either mount the build directory in binary mode or run the following
2803   commands before running any configure script:
2804 set -o igncr
2805 export SHELLOPTS
2806   " >&2;}
2807    { (exit 1); exit 1; }; }
2808 fi
2809
2810     host_makefile_frag="config/mh-cygwin"
2811     ;;
2812   *-mingw*)
2813     host_makefile_frag="config/mh-mingw"
2814     ;;
2815   *-interix*)
2816     host_makefile_frag="config/mh-interix"
2817     ;;
2818   vax-*-ultrix2*)
2819     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2820     tentative_cc=gcc
2821     ;;
2822   *-*-solaris2*)
2823     host_makefile_frag="config/mh-solaris"
2824     ;;
2825   m68k-sun-sunos*)
2826     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2827     # without overflowing the jump tables (-J says to use a 32 bit table)
2828     tentative_cc="cc -J"
2829     ;;
2830   *-hp-hpux*)
2831     tentative_cc="cc -Wp,-H256000"
2832     ;;
2833   *-*-hiux*)
2834     tentative_cc="cc -Wp,-H256000"
2835     ;;
2836   rs6000-*-lynxos*)
2837     # /bin/cc is less than useful for our purposes.  Always use GCC
2838     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2839     host_makefile_frag="config/mh-lynxrs6k"
2840     ;;
2841   powerpc-*-darwin*)
2842     host_makefile_frag="config/mh-ppc-darwin"
2843     ;;
2844   powerpc-*-aix*)
2845     host_makefile_frag="config/mh-ppc-aix"
2846     ;;
2847   rs6000-*-aix*)
2848     host_makefile_frag="config/mh-ppc-aix"
2849     ;;
2850   *-*-lynxos*)
2851     # /bin/cc is less than useful for our purposes.  Always use GCC
2852     tentative_cc="/bin/gcc"
2853     ;;
2854   *-*-sysv4*)
2855     host_makefile_frag="config/mh-sysv4"
2856     ;;
2857   # This is placed last to prevent interfering with the cases above.
2858   i[3456789]86-*-*)
2859     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2860     host_makefile_frag="config/mh-x86omitfp"
2861     ;;
2862 esac
2863 fi
2864
2865 # If we aren't going to be using gcc, see if we can extract a definition
2866 # of CC from the fragment.
2867 # Actually, use the 'pre-extracted' version above.
2868 if test -z "${CC}" && test "${build}" = "${host}" ; then
2869   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2870   found=
2871   for dir in $PATH; do
2872     test -z "$dir" && dir=.
2873     if test -f $dir/gcc; then
2874       found=yes
2875       break
2876     fi
2877   done
2878   IFS="$save_ifs"
2879   if test -z "${found}" && test -n "${tentative_cc}" ; then
2880     CC=$tentative_cc
2881   fi
2882 fi
2883
2884 if test "${build}" != "${host}" ; then
2885   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2886   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2887   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2888   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2889   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2890   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2891   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2892   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2893   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2894   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2895   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2896   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2897 else
2898   AR_FOR_BUILD="\$(AR)"
2899   AS_FOR_BUILD="\$(AS)"
2900   CC_FOR_BUILD="\$(CC)"
2901   CXX_FOR_BUILD="\$(CXX)"
2902   GCJ_FOR_BUILD="\$(GCJ)"
2903   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2904   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2905   LD_FOR_BUILD="\$(LD)"
2906   NM_FOR_BUILD="\$(NM)"
2907   RANLIB_FOR_BUILD="\$(RANLIB)"
2908   WINDRES_FOR_BUILD="\$(WINDRES)"
2909   WINDMC_FOR_BUILD="\$(WINDMC)"
2910 fi
2911
2912 ac_ext=c
2913 ac_cpp='$CPP $CPPFLAGS'
2914 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2915 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2916 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2917 if test -n "$ac_tool_prefix"; then
2918   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2919 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2920 echo "$as_me:$LINENO: checking for $ac_word" >&5
2921 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2922 if test "${ac_cv_prog_CC+set}" = set; then
2923   echo $ECHO_N "(cached) $ECHO_C" >&6
2924 else
2925   if test -n "$CC"; then
2926   ac_cv_prog_CC="$CC" # Let the user override the test.
2927 else
2928 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2929 for as_dir in $PATH
2930 do
2931   IFS=$as_save_IFS
2932   test -z "$as_dir" && as_dir=.
2933   for ac_exec_ext in '' $ac_executable_extensions; do
2934   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2935     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2936     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2937     break 2
2938   fi
2939 done
2940 done
2941
2942 fi
2943 fi
2944 CC=$ac_cv_prog_CC
2945 if test -n "$CC"; then
2946   echo "$as_me:$LINENO: result: $CC" >&5
2947 echo "${ECHO_T}$CC" >&6
2948 else
2949   echo "$as_me:$LINENO: result: no" >&5
2950 echo "${ECHO_T}no" >&6
2951 fi
2952
2953 fi
2954 if test -z "$ac_cv_prog_CC"; then
2955   ac_ct_CC=$CC
2956   # Extract the first word of "gcc", so it can be a program name with args.
2957 set dummy gcc; ac_word=$2
2958 echo "$as_me:$LINENO: checking for $ac_word" >&5
2959 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2960 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2961   echo $ECHO_N "(cached) $ECHO_C" >&6
2962 else
2963   if test -n "$ac_ct_CC"; then
2964   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2965 else
2966 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2967 for as_dir in $PATH
2968 do
2969   IFS=$as_save_IFS
2970   test -z "$as_dir" && as_dir=.
2971   for ac_exec_ext in '' $ac_executable_extensions; do
2972   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2973     ac_cv_prog_ac_ct_CC="gcc"
2974     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2975     break 2
2976   fi
2977 done
2978 done
2979
2980 fi
2981 fi
2982 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2983 if test -n "$ac_ct_CC"; then
2984   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2985 echo "${ECHO_T}$ac_ct_CC" >&6
2986 else
2987   echo "$as_me:$LINENO: result: no" >&5
2988 echo "${ECHO_T}no" >&6
2989 fi
2990
2991   CC=$ac_ct_CC
2992 else
2993   CC="$ac_cv_prog_CC"
2994 fi
2995
2996 if test -z "$CC"; then
2997   if test -n "$ac_tool_prefix"; then
2998   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2999 set dummy ${ac_tool_prefix}cc; ac_word=$2
3000 echo "$as_me:$LINENO: checking for $ac_word" >&5
3001 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3002 if test "${ac_cv_prog_CC+set}" = set; then
3003   echo $ECHO_N "(cached) $ECHO_C" >&6
3004 else
3005   if test -n "$CC"; then
3006   ac_cv_prog_CC="$CC" # Let the user override the test.
3007 else
3008 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3009 for as_dir in $PATH
3010 do
3011   IFS=$as_save_IFS
3012   test -z "$as_dir" && as_dir=.
3013   for ac_exec_ext in '' $ac_executable_extensions; do
3014   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3015     ac_cv_prog_CC="${ac_tool_prefix}cc"
3016     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3017     break 2
3018   fi
3019 done
3020 done
3021
3022 fi
3023 fi
3024 CC=$ac_cv_prog_CC
3025 if test -n "$CC"; then
3026   echo "$as_me:$LINENO: result: $CC" >&5
3027 echo "${ECHO_T}$CC" >&6
3028 else
3029   echo "$as_me:$LINENO: result: no" >&5
3030 echo "${ECHO_T}no" >&6
3031 fi
3032
3033 fi
3034 if test -z "$ac_cv_prog_CC"; then
3035   ac_ct_CC=$CC
3036   # Extract the first word of "cc", so it can be a program name with args.
3037 set dummy cc; ac_word=$2
3038 echo "$as_me:$LINENO: checking for $ac_word" >&5
3039 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3040 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3041   echo $ECHO_N "(cached) $ECHO_C" >&6
3042 else
3043   if test -n "$ac_ct_CC"; then
3044   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3045 else
3046 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3047 for as_dir in $PATH
3048 do
3049   IFS=$as_save_IFS
3050   test -z "$as_dir" && as_dir=.
3051   for ac_exec_ext in '' $ac_executable_extensions; do
3052   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3053     ac_cv_prog_ac_ct_CC="cc"
3054     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3055     break 2
3056   fi
3057 done
3058 done
3059
3060 fi
3061 fi
3062 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3063 if test -n "$ac_ct_CC"; then
3064   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3065 echo "${ECHO_T}$ac_ct_CC" >&6
3066 else
3067   echo "$as_me:$LINENO: result: no" >&5
3068 echo "${ECHO_T}no" >&6
3069 fi
3070
3071   CC=$ac_ct_CC
3072 else
3073   CC="$ac_cv_prog_CC"
3074 fi
3075
3076 fi
3077 if test -z "$CC"; then
3078   # Extract the first word of "cc", so it can be a program name with args.
3079 set dummy cc; ac_word=$2
3080 echo "$as_me:$LINENO: checking for $ac_word" >&5
3081 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3082 if test "${ac_cv_prog_CC+set}" = set; then
3083   echo $ECHO_N "(cached) $ECHO_C" >&6
3084 else
3085   if test -n "$CC"; then
3086   ac_cv_prog_CC="$CC" # Let the user override the test.
3087 else
3088   ac_prog_rejected=no
3089 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3090 for as_dir in $PATH
3091 do
3092   IFS=$as_save_IFS
3093   test -z "$as_dir" && as_dir=.
3094   for ac_exec_ext in '' $ac_executable_extensions; do
3095   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3096     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3097        ac_prog_rejected=yes
3098        continue
3099      fi
3100     ac_cv_prog_CC="cc"
3101     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3102     break 2
3103   fi
3104 done
3105 done
3106
3107 if test $ac_prog_rejected = yes; then
3108   # We found a bogon in the path, so make sure we never use it.
3109   set dummy $ac_cv_prog_CC
3110   shift
3111   if test $# != 0; then
3112     # We chose a different compiler from the bogus one.
3113     # However, it has the same basename, so the bogon will be chosen
3114     # first if we set CC to just the basename; use the full file name.
3115     shift
3116     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3117   fi
3118 fi
3119 fi
3120 fi
3121 CC=$ac_cv_prog_CC
3122 if test -n "$CC"; then
3123   echo "$as_me:$LINENO: result: $CC" >&5
3124 echo "${ECHO_T}$CC" >&6
3125 else
3126   echo "$as_me:$LINENO: result: no" >&5
3127 echo "${ECHO_T}no" >&6
3128 fi
3129
3130 fi
3131 if test -z "$CC"; then
3132   if test -n "$ac_tool_prefix"; then
3133   for ac_prog in cl
3134   do
3135     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3136 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3137 echo "$as_me:$LINENO: checking for $ac_word" >&5
3138 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3139 if test "${ac_cv_prog_CC+set}" = set; then
3140   echo $ECHO_N "(cached) $ECHO_C" >&6
3141 else
3142   if test -n "$CC"; then
3143   ac_cv_prog_CC="$CC" # Let the user override the test.
3144 else
3145 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3146 for as_dir in $PATH
3147 do
3148   IFS=$as_save_IFS
3149   test -z "$as_dir" && as_dir=.
3150   for ac_exec_ext in '' $ac_executable_extensions; do
3151   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3152     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3153     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3154     break 2
3155   fi
3156 done
3157 done
3158
3159 fi
3160 fi
3161 CC=$ac_cv_prog_CC
3162 if test -n "$CC"; then
3163   echo "$as_me:$LINENO: result: $CC" >&5
3164 echo "${ECHO_T}$CC" >&6
3165 else
3166   echo "$as_me:$LINENO: result: no" >&5
3167 echo "${ECHO_T}no" >&6
3168 fi
3169
3170     test -n "$CC" && break
3171   done
3172 fi
3173 if test -z "$CC"; then
3174   ac_ct_CC=$CC
3175   for ac_prog in cl
3176 do
3177   # Extract the first word of "$ac_prog", so it can be a program name with args.
3178 set dummy $ac_prog; ac_word=$2
3179 echo "$as_me:$LINENO: checking for $ac_word" >&5
3180 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3181 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3182   echo $ECHO_N "(cached) $ECHO_C" >&6
3183 else
3184   if test -n "$ac_ct_CC"; then
3185   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3186 else
3187 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3188 for as_dir in $PATH
3189 do
3190   IFS=$as_save_IFS
3191   test -z "$as_dir" && as_dir=.
3192   for ac_exec_ext in '' $ac_executable_extensions; do
3193   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3194     ac_cv_prog_ac_ct_CC="$ac_prog"
3195     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3196     break 2
3197   fi
3198 done
3199 done
3200
3201 fi
3202 fi
3203 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3204 if test -n "$ac_ct_CC"; then
3205   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3206 echo "${ECHO_T}$ac_ct_CC" >&6
3207 else
3208   echo "$as_me:$LINENO: result: no" >&5
3209 echo "${ECHO_T}no" >&6
3210 fi
3211
3212   test -n "$ac_ct_CC" && break
3213 done
3214
3215   CC=$ac_ct_CC
3216 fi
3217
3218 fi
3219
3220
3221 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3222 See \`config.log' for more details." >&5
3223 echo "$as_me: error: no acceptable C compiler found in \$PATH
3224 See \`config.log' for more details." >&2;}
3225    { (exit 1); exit 1; }; }
3226
3227 # Provide some information about the compiler.
3228 echo "$as_me:$LINENO:" \
3229      "checking for C compiler version" >&5
3230 ac_compiler=`set X $ac_compile; echo $2`
3231 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3232   (eval $ac_compiler --version </dev/null >&5) 2>&5
3233   ac_status=$?
3234   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3235   (exit $ac_status); }
3236 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3237   (eval $ac_compiler -v </dev/null >&5) 2>&5
3238   ac_status=$?
3239   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3240   (exit $ac_status); }
3241 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3242   (eval $ac_compiler -V </dev/null >&5) 2>&5
3243   ac_status=$?
3244   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3245   (exit $ac_status); }
3246
3247 cat >conftest.$ac_ext <<_ACEOF
3248 /* confdefs.h.  */
3249 _ACEOF
3250 cat confdefs.h >>conftest.$ac_ext
3251 cat >>conftest.$ac_ext <<_ACEOF
3252 /* end confdefs.h.  */
3253
3254 int
3255 main ()
3256 {
3257
3258   ;
3259   return 0;
3260 }
3261 _ACEOF
3262 ac_clean_files_save=$ac_clean_files
3263 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3264 # Try to create an executable without -o first, disregard a.out.
3265 # It will help us diagnose broken compilers, and finding out an intuition
3266 # of exeext.
3267 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3268 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3269 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3270 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3271   (eval $ac_link_default) 2>&5
3272   ac_status=$?
3273   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3274   (exit $ac_status); }; then
3275   # Find the output, starting from the most likely.  This scheme is
3276 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3277 # resort.
3278
3279 # Be careful to initialize this variable, since it used to be cached.
3280 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3281 ac_cv_exeext=
3282 # b.out is created by i960 compilers.
3283 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3284 do
3285   test -f "$ac_file" || continue
3286   case $ac_file in
3287     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3288         ;;
3289     conftest.$ac_ext )
3290         # This is the source file.
3291         ;;
3292     [ab].out )
3293         # We found the default executable, but exeext='' is most
3294         # certainly right.
3295         break;;
3296     *.* )
3297         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3298         # FIXME: I believe we export ac_cv_exeext for Libtool,
3299         # but it would be cool to find out if it's true.  Does anybody
3300         # maintain Libtool? --akim.
3301         export ac_cv_exeext
3302         break;;
3303     * )
3304         break;;
3305   esac
3306 done
3307 else
3308   echo "$as_me: failed program was:" >&5
3309 sed 's/^/| /' conftest.$ac_ext >&5
3310
3311 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3312 See \`config.log' for more details." >&5
3313 echo "$as_me: error: C compiler cannot create executables
3314 See \`config.log' for more details." >&2;}
3315    { (exit 77); exit 77; }; }
3316 fi
3317
3318 ac_exeext=$ac_cv_exeext
3319 echo "$as_me:$LINENO: result: $ac_file" >&5
3320 echo "${ECHO_T}$ac_file" >&6
3321
3322 # Check the compiler produces executables we can run.  If not, either
3323 # the compiler is broken, or we cross compile.
3324 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3325 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3326 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3327 # If not cross compiling, check that we can run a simple program.
3328 if test "$cross_compiling" != yes; then
3329   if { ac_try='./$ac_file'
3330   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3331   (eval $ac_try) 2>&5
3332   ac_status=$?
3333   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3334   (exit $ac_status); }; }; then
3335     cross_compiling=no
3336   else
3337     if test "$cross_compiling" = maybe; then
3338         cross_compiling=yes
3339     else
3340         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3341 If you meant to cross compile, use \`--host'.
3342 See \`config.log' for more details." >&5
3343 echo "$as_me: error: cannot run C compiled programs.
3344 If you meant to cross compile, use \`--host'.
3345 See \`config.log' for more details." >&2;}
3346    { (exit 1); exit 1; }; }
3347     fi
3348   fi
3349 fi
3350 echo "$as_me:$LINENO: result: yes" >&5
3351 echo "${ECHO_T}yes" >&6
3352
3353 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3354 ac_clean_files=$ac_clean_files_save
3355 # Check the compiler produces executables we can run.  If not, either
3356 # the compiler is broken, or we cross compile.
3357 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3358 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3359 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3360 echo "${ECHO_T}$cross_compiling" >&6
3361
3362 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3363 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3364 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3365   (eval $ac_link) 2>&5
3366   ac_status=$?
3367   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3368   (exit $ac_status); }; then
3369   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3370 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3371 # work properly (i.e., refer to `conftest.exe'), while it won't with
3372 # `rm'.
3373 for ac_file in conftest.exe conftest conftest.*; do
3374   test -f "$ac_file" || continue
3375   case $ac_file in
3376     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3377     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3378           export ac_cv_exeext
3379           break;;
3380     * ) break;;
3381   esac
3382 done
3383 else
3384   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3385 See \`config.log' for more details." >&5
3386 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3387 See \`config.log' for more details." >&2;}
3388    { (exit 1); exit 1; }; }
3389 fi
3390
3391 rm -f conftest$ac_cv_exeext
3392 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3393 echo "${ECHO_T}$ac_cv_exeext" >&6
3394
3395 rm -f conftest.$ac_ext
3396 EXEEXT=$ac_cv_exeext
3397 ac_exeext=$EXEEXT
3398 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3399 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3400 if test "${ac_cv_objext+set}" = set; then
3401   echo $ECHO_N "(cached) $ECHO_C" >&6
3402 else
3403   cat >conftest.$ac_ext <<_ACEOF
3404 /* confdefs.h.  */
3405 _ACEOF
3406 cat confdefs.h >>conftest.$ac_ext
3407 cat >>conftest.$ac_ext <<_ACEOF
3408 /* end confdefs.h.  */
3409
3410 int
3411 main ()
3412 {
3413
3414   ;
3415   return 0;
3416 }
3417 _ACEOF
3418 rm -f conftest.o conftest.obj
3419 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3420   (eval $ac_compile) 2>&5
3421   ac_status=$?
3422   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3423   (exit $ac_status); }; then
3424   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3425   case $ac_file in
3426     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3427     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3428        break;;
3429   esac
3430 done
3431 else
3432   echo "$as_me: failed program was:" >&5
3433 sed 's/^/| /' conftest.$ac_ext >&5
3434
3435 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3436 See \`config.log' for more details." >&5
3437 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3438 See \`config.log' for more details." >&2;}
3439    { (exit 1); exit 1; }; }
3440 fi
3441
3442 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3443 fi
3444 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3445 echo "${ECHO_T}$ac_cv_objext" >&6
3446 OBJEXT=$ac_cv_objext
3447 ac_objext=$OBJEXT
3448 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3449 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3450 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3451   echo $ECHO_N "(cached) $ECHO_C" >&6
3452 else
3453   cat >conftest.$ac_ext <<_ACEOF
3454 /* confdefs.h.  */
3455 _ACEOF
3456 cat confdefs.h >>conftest.$ac_ext
3457 cat >>conftest.$ac_ext <<_ACEOF
3458 /* end confdefs.h.  */
3459
3460 int
3461 main ()
3462 {
3463 #ifndef __GNUC__
3464        choke me
3465 #endif
3466
3467   ;
3468   return 0;
3469 }
3470 _ACEOF
3471 rm -f conftest.$ac_objext
3472 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3473   (eval $ac_compile) 2>conftest.er1
3474   ac_status=$?
3475   grep -v '^ *+' conftest.er1 >conftest.err
3476   rm -f conftest.er1
3477   cat conftest.err >&5
3478   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3479   (exit $ac_status); } &&
3480          { ac_try='test -z "$ac_c_werror_flag"
3481                          || test ! -s conftest.err'
3482   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3483   (eval $ac_try) 2>&5
3484   ac_status=$?
3485   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3486   (exit $ac_status); }; } &&
3487          { ac_try='test -s conftest.$ac_objext'
3488   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3489   (eval $ac_try) 2>&5
3490   ac_status=$?
3491   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3492   (exit $ac_status); }; }; then
3493   ac_compiler_gnu=yes
3494 else
3495   echo "$as_me: failed program was:" >&5
3496 sed 's/^/| /' conftest.$ac_ext >&5
3497
3498 ac_compiler_gnu=no
3499 fi
3500 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3501 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3502
3503 fi
3504 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3505 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3506 GCC=`test $ac_compiler_gnu = yes && echo yes`
3507 ac_test_CFLAGS=${CFLAGS+set}
3508 ac_save_CFLAGS=$CFLAGS
3509 CFLAGS="-g"
3510 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3511 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3512 if test "${ac_cv_prog_cc_g+set}" = set; then
3513   echo $ECHO_N "(cached) $ECHO_C" >&6
3514 else
3515   cat >conftest.$ac_ext <<_ACEOF
3516 /* confdefs.h.  */
3517 _ACEOF
3518 cat confdefs.h >>conftest.$ac_ext
3519 cat >>conftest.$ac_ext <<_ACEOF
3520 /* end confdefs.h.  */
3521
3522 int
3523 main ()
3524 {
3525
3526   ;
3527   return 0;
3528 }
3529 _ACEOF
3530 rm -f conftest.$ac_objext
3531 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3532   (eval $ac_compile) 2>conftest.er1
3533   ac_status=$?
3534   grep -v '^ *+' conftest.er1 >conftest.err
3535   rm -f conftest.er1
3536   cat conftest.err >&5
3537   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3538   (exit $ac_status); } &&
3539          { ac_try='test -z "$ac_c_werror_flag"
3540                          || test ! -s conftest.err'
3541   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3542   (eval $ac_try) 2>&5
3543   ac_status=$?
3544   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3545   (exit $ac_status); }; } &&
3546          { ac_try='test -s conftest.$ac_objext'
3547   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3548   (eval $ac_try) 2>&5
3549   ac_status=$?
3550   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3551   (exit $ac_status); }; }; then
3552   ac_cv_prog_cc_g=yes
3553 else
3554   echo "$as_me: failed program was:" >&5
3555 sed 's/^/| /' conftest.$ac_ext >&5
3556
3557 ac_cv_prog_cc_g=no
3558 fi
3559 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3560 fi
3561 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3562 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3563 if test "$ac_test_CFLAGS" = set; then
3564   CFLAGS=$ac_save_CFLAGS
3565 elif test $ac_cv_prog_cc_g = yes; then
3566   if test "$GCC" = yes; then
3567     CFLAGS="-g -O2"
3568   else
3569     CFLAGS="-g"
3570   fi
3571 else
3572   if test "$GCC" = yes; then
3573     CFLAGS="-O2"
3574   else
3575     CFLAGS=
3576   fi
3577 fi
3578 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3579 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3580 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3581   echo $ECHO_N "(cached) $ECHO_C" >&6
3582 else
3583   ac_cv_prog_cc_stdc=no
3584 ac_save_CC=$CC
3585 cat >conftest.$ac_ext <<_ACEOF
3586 /* confdefs.h.  */
3587 _ACEOF
3588 cat confdefs.h >>conftest.$ac_ext
3589 cat >>conftest.$ac_ext <<_ACEOF
3590 /* end confdefs.h.  */
3591 #include <stdarg.h>
3592 #include <stdio.h>
3593 #include <sys/types.h>
3594 #include <sys/stat.h>
3595 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3596 struct buf { int x; };
3597 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3598 static char *e (p, i)
3599      char **p;
3600      int i;
3601 {
3602   return p[i];
3603 }
3604 static char *f (char * (*g) (char **, int), char **p, ...)
3605 {
3606   char *s;
3607   va_list v;
3608   va_start (v,p);
3609   s = g (p, va_arg (v,int));
3610   va_end (v);
3611   return s;
3612 }
3613
3614 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3615    function prototypes and stuff, but not '\xHH' hex character constants.
3616    These don't provoke an error unfortunately, instead are silently treated
3617    as 'x'.  The following induces an error, until -std1 is added to get
3618    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3619    array size at least.  It's necessary to write '\x00'==0 to get something
3620    that's true only with -std1.  */
3621 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3622
3623 int test (int i, double x);
3624 struct s1 {int (*f) (int a);};
3625 struct s2 {int (*f) (double a);};
3626 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3627 int argc;
3628 char **argv;
3629 int
3630 main ()
3631 {
3632 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3633   ;
3634   return 0;
3635 }
3636 _ACEOF
3637 # Don't try gcc -ansi; that turns off useful extensions and
3638 # breaks some systems' header files.
3639 # AIX                   -qlanglvl=ansi
3640 # Ultrix and OSF/1      -std1
3641 # HP-UX 10.20 and later -Ae
3642 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3643 # SVR4                  -Xc -D__EXTENSIONS__
3644 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3645 do
3646   CC="$ac_save_CC $ac_arg"
3647   rm -f conftest.$ac_objext
3648 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3649   (eval $ac_compile) 2>conftest.er1
3650   ac_status=$?
3651   grep -v '^ *+' conftest.er1 >conftest.err
3652   rm -f conftest.er1
3653   cat conftest.err >&5
3654   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3655   (exit $ac_status); } &&
3656          { ac_try='test -z "$ac_c_werror_flag"
3657                          || test ! -s conftest.err'
3658   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3659   (eval $ac_try) 2>&5
3660   ac_status=$?
3661   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3662   (exit $ac_status); }; } &&
3663          { ac_try='test -s conftest.$ac_objext'
3664   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3665   (eval $ac_try) 2>&5
3666   ac_status=$?
3667   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3668   (exit $ac_status); }; }; then
3669   ac_cv_prog_cc_stdc=$ac_arg
3670 break
3671 else
3672   echo "$as_me: failed program was:" >&5
3673 sed 's/^/| /' conftest.$ac_ext >&5
3674
3675 fi
3676 rm -f conftest.err conftest.$ac_objext
3677 done
3678 rm -f conftest.$ac_ext conftest.$ac_objext
3679 CC=$ac_save_CC
3680
3681 fi
3682
3683 case "x$ac_cv_prog_cc_stdc" in
3684   x|xno)
3685     echo "$as_me:$LINENO: result: none needed" >&5
3686 echo "${ECHO_T}none needed" >&6 ;;
3687   *)
3688     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3689 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3690     CC="$CC $ac_cv_prog_cc_stdc" ;;
3691 esac
3692
3693 # Some people use a C++ compiler to compile C.  Since we use `exit',
3694 # in C++ we need to declare it.  In case someone uses the same compiler
3695 # for both compiling C and C++ we need to have the C++ compiler decide
3696 # the declaration of exit, since it's the most demanding environment.
3697 cat >conftest.$ac_ext <<_ACEOF
3698 #ifndef __cplusplus
3699   choke me
3700 #endif
3701 _ACEOF
3702 rm -f conftest.$ac_objext
3703 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3704   (eval $ac_compile) 2>conftest.er1
3705   ac_status=$?
3706   grep -v '^ *+' conftest.er1 >conftest.err
3707   rm -f conftest.er1
3708   cat conftest.err >&5
3709   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3710   (exit $ac_status); } &&
3711          { ac_try='test -z "$ac_c_werror_flag"
3712                          || test ! -s conftest.err'
3713   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3714   (eval $ac_try) 2>&5
3715   ac_status=$?
3716   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3717   (exit $ac_status); }; } &&
3718          { ac_try='test -s conftest.$ac_objext'
3719   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3720   (eval $ac_try) 2>&5
3721   ac_status=$?
3722   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3723   (exit $ac_status); }; }; then
3724   for ac_declaration in \
3725    '' \
3726    'extern "C" void std::exit (int) throw (); using std::exit;' \
3727    'extern "C" void std::exit (int); using std::exit;' \
3728    'extern "C" void exit (int) throw ();' \
3729    'extern "C" void exit (int);' \
3730    'void exit (int);'
3731 do
3732   cat >conftest.$ac_ext <<_ACEOF
3733 /* confdefs.h.  */
3734 _ACEOF
3735 cat confdefs.h >>conftest.$ac_ext
3736 cat >>conftest.$ac_ext <<_ACEOF
3737 /* end confdefs.h.  */
3738 $ac_declaration
3739 #include <stdlib.h>
3740 int
3741 main ()
3742 {
3743 exit (42);
3744   ;
3745   return 0;
3746 }
3747 _ACEOF
3748 rm -f conftest.$ac_objext
3749 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3750   (eval $ac_compile) 2>conftest.er1
3751   ac_status=$?
3752   grep -v '^ *+' conftest.er1 >conftest.err
3753   rm -f conftest.er1
3754   cat conftest.err >&5
3755   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3756   (exit $ac_status); } &&
3757          { ac_try='test -z "$ac_c_werror_flag"
3758                          || test ! -s conftest.err'
3759   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3760   (eval $ac_try) 2>&5
3761   ac_status=$?
3762   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3763   (exit $ac_status); }; } &&
3764          { ac_try='test -s conftest.$ac_objext'
3765   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3766   (eval $ac_try) 2>&5
3767   ac_status=$?
3768   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3769   (exit $ac_status); }; }; then
3770   :
3771 else
3772   echo "$as_me: failed program was:" >&5
3773 sed 's/^/| /' conftest.$ac_ext >&5
3774
3775 continue
3776 fi
3777 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3778   cat >conftest.$ac_ext <<_ACEOF
3779 /* confdefs.h.  */
3780 _ACEOF
3781 cat confdefs.h >>conftest.$ac_ext
3782 cat >>conftest.$ac_ext <<_ACEOF
3783 /* end confdefs.h.  */
3784 $ac_declaration
3785 int
3786 main ()
3787 {
3788 exit (42);
3789   ;
3790   return 0;
3791 }
3792 _ACEOF
3793 rm -f conftest.$ac_objext
3794 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3795   (eval $ac_compile) 2>conftest.er1
3796   ac_status=$?
3797   grep -v '^ *+' conftest.er1 >conftest.err
3798   rm -f conftest.er1
3799   cat conftest.err >&5
3800   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3801   (exit $ac_status); } &&
3802          { ac_try='test -z "$ac_c_werror_flag"
3803                          || test ! -s conftest.err'
3804   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3805   (eval $ac_try) 2>&5
3806   ac_status=$?
3807   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3808   (exit $ac_status); }; } &&
3809          { ac_try='test -s conftest.$ac_objext'
3810   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3811   (eval $ac_try) 2>&5
3812   ac_status=$?
3813   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3814   (exit $ac_status); }; }; then
3815   break
3816 else
3817   echo "$as_me: failed program was:" >&5
3818 sed 's/^/| /' conftest.$ac_ext >&5
3819
3820 fi
3821 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3822 done
3823 rm -f conftest*
3824 if test -n "$ac_declaration"; then
3825   echo '#ifdef __cplusplus' >>confdefs.h
3826   echo $ac_declaration      >>confdefs.h
3827   echo '#endif'             >>confdefs.h
3828 fi
3829
3830 else
3831   echo "$as_me: failed program was:" >&5
3832 sed 's/^/| /' conftest.$ac_ext >&5
3833
3834 fi
3835 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3836 ac_ext=c
3837 ac_cpp='$CPP $CPPFLAGS'
3838 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3839 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3840 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3841
3842 ac_ext=cc
3843 ac_cpp='$CXXCPP $CPPFLAGS'
3844 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3845 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3846 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3847 if test -n "$ac_tool_prefix"; then
3848   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3849   do
3850     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3851 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3852 echo "$as_me:$LINENO: checking for $ac_word" >&5
3853 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3854 if test "${ac_cv_prog_CXX+set}" = set; then
3855   echo $ECHO_N "(cached) $ECHO_C" >&6
3856 else
3857   if test -n "$CXX"; then
3858   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3859 else
3860 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3861 for as_dir in $PATH
3862 do
3863   IFS=$as_save_IFS
3864   test -z "$as_dir" && as_dir=.
3865   for ac_exec_ext in '' $ac_executable_extensions; do
3866   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3867     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3868     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3869     break 2
3870   fi
3871 done
3872 done
3873
3874 fi
3875 fi
3876 CXX=$ac_cv_prog_CXX
3877 if test -n "$CXX"; then
3878   echo "$as_me:$LINENO: result: $CXX" >&5
3879 echo "${ECHO_T}$CXX" >&6
3880 else
3881   echo "$as_me:$LINENO: result: no" >&5
3882 echo "${ECHO_T}no" >&6
3883 fi
3884
3885     test -n "$CXX" && break
3886   done
3887 fi
3888 if test -z "$CXX"; then
3889   ac_ct_CXX=$CXX
3890   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3891 do
3892   # Extract the first word of "$ac_prog", so it can be a program name with args.
3893 set dummy $ac_prog; ac_word=$2
3894 echo "$as_me:$LINENO: checking for $ac_word" >&5
3895 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3896 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3897   echo $ECHO_N "(cached) $ECHO_C" >&6
3898 else
3899   if test -n "$ac_ct_CXX"; then
3900   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3901 else
3902 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3903 for as_dir in $PATH
3904 do
3905   IFS=$as_save_IFS
3906   test -z "$as_dir" && as_dir=.
3907   for ac_exec_ext in '' $ac_executable_extensions; do
3908   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3909     ac_cv_prog_ac_ct_CXX="$ac_prog"
3910     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3911     break 2
3912   fi
3913 done
3914 done
3915
3916 fi
3917 fi
3918 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3919 if test -n "$ac_ct_CXX"; then
3920   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3921 echo "${ECHO_T}$ac_ct_CXX" >&6
3922 else
3923   echo "$as_me:$LINENO: result: no" >&5
3924 echo "${ECHO_T}no" >&6
3925 fi
3926
3927   test -n "$ac_ct_CXX" && break
3928 done
3929 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3930
3931   CXX=$ac_ct_CXX
3932 fi
3933
3934
3935 # Provide some information about the compiler.
3936 echo "$as_me:$LINENO:" \
3937      "checking for C++ compiler version" >&5
3938 ac_compiler=`set X $ac_compile; echo $2`
3939 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3940   (eval $ac_compiler --version </dev/null >&5) 2>&5
3941   ac_status=$?
3942   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3943   (exit $ac_status); }
3944 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3945   (eval $ac_compiler -v </dev/null >&5) 2>&5
3946   ac_status=$?
3947   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3948   (exit $ac_status); }
3949 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3950   (eval $ac_compiler -V </dev/null >&5) 2>&5
3951   ac_status=$?
3952   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3953   (exit $ac_status); }
3954
3955 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3956 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3957 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3958   echo $ECHO_N "(cached) $ECHO_C" >&6
3959 else
3960   cat >conftest.$ac_ext <<_ACEOF
3961 /* confdefs.h.  */
3962 _ACEOF
3963 cat confdefs.h >>conftest.$ac_ext
3964 cat >>conftest.$ac_ext <<_ACEOF
3965 /* end confdefs.h.  */
3966
3967 int
3968 main ()
3969 {
3970 #ifndef __GNUC__
3971        choke me
3972 #endif
3973
3974   ;
3975   return 0;
3976 }
3977 _ACEOF
3978 rm -f conftest.$ac_objext
3979 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3980   (eval $ac_compile) 2>conftest.er1
3981   ac_status=$?
3982   grep -v '^ *+' conftest.er1 >conftest.err
3983   rm -f conftest.er1
3984   cat conftest.err >&5
3985   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3986   (exit $ac_status); } &&
3987          { ac_try='test -z "$ac_cxx_werror_flag"
3988                          || test ! -s conftest.err'
3989   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3990   (eval $ac_try) 2>&5
3991   ac_status=$?
3992   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3993   (exit $ac_status); }; } &&
3994          { ac_try='test -s conftest.$ac_objext'
3995   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3996   (eval $ac_try) 2>&5
3997   ac_status=$?
3998   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3999   (exit $ac_status); }; }; then
4000   ac_compiler_gnu=yes
4001 else
4002   echo "$as_me: failed program was:" >&5
4003 sed 's/^/| /' conftest.$ac_ext >&5
4004
4005 ac_compiler_gnu=no
4006 fi
4007 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4008 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4009
4010 fi
4011 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4012 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4013 GXX=`test $ac_compiler_gnu = yes && echo yes`
4014 ac_test_CXXFLAGS=${CXXFLAGS+set}
4015 ac_save_CXXFLAGS=$CXXFLAGS
4016 CXXFLAGS="-g"
4017 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4018 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4019 if test "${ac_cv_prog_cxx_g+set}" = set; then
4020   echo $ECHO_N "(cached) $ECHO_C" >&6
4021 else
4022   cat >conftest.$ac_ext <<_ACEOF
4023 /* confdefs.h.  */
4024 _ACEOF
4025 cat confdefs.h >>conftest.$ac_ext
4026 cat >>conftest.$ac_ext <<_ACEOF
4027 /* end confdefs.h.  */
4028
4029 int
4030 main ()
4031 {
4032
4033   ;
4034   return 0;
4035 }
4036 _ACEOF
4037 rm -f conftest.$ac_objext
4038 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4039   (eval $ac_compile) 2>conftest.er1
4040   ac_status=$?
4041   grep -v '^ *+' conftest.er1 >conftest.err
4042   rm -f conftest.er1
4043   cat conftest.err >&5
4044   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4045   (exit $ac_status); } &&
4046          { ac_try='test -z "$ac_cxx_werror_flag"
4047                          || test ! -s conftest.err'
4048   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4049   (eval $ac_try) 2>&5
4050   ac_status=$?
4051   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4052   (exit $ac_status); }; } &&
4053          { ac_try='test -s conftest.$ac_objext'
4054   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4055   (eval $ac_try) 2>&5
4056   ac_status=$?
4057   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4058   (exit $ac_status); }; }; then
4059   ac_cv_prog_cxx_g=yes
4060 else
4061   echo "$as_me: failed program was:" >&5
4062 sed 's/^/| /' conftest.$ac_ext >&5
4063
4064 ac_cv_prog_cxx_g=no
4065 fi
4066 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4067 fi
4068 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4069 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4070 if test "$ac_test_CXXFLAGS" = set; then
4071   CXXFLAGS=$ac_save_CXXFLAGS
4072 elif test $ac_cv_prog_cxx_g = yes; then
4073   if test "$GXX" = yes; then
4074     CXXFLAGS="-g -O2"
4075   else
4076     CXXFLAGS="-g"
4077   fi
4078 else
4079   if test "$GXX" = yes; then
4080     CXXFLAGS="-O2"
4081   else
4082     CXXFLAGS=
4083   fi
4084 fi
4085 for ac_declaration in \
4086    '' \
4087    'extern "C" void std::exit (int) throw (); using std::exit;' \
4088    'extern "C" void std::exit (int); using std::exit;' \
4089    'extern "C" void exit (int) throw ();' \
4090    'extern "C" void exit (int);' \
4091    'void exit (int);'
4092 do
4093   cat >conftest.$ac_ext <<_ACEOF
4094 /* confdefs.h.  */
4095 _ACEOF
4096 cat confdefs.h >>conftest.$ac_ext
4097 cat >>conftest.$ac_ext <<_ACEOF
4098 /* end confdefs.h.  */
4099 $ac_declaration
4100 #include <stdlib.h>
4101 int
4102 main ()
4103 {
4104 exit (42);
4105   ;
4106   return 0;
4107 }
4108 _ACEOF
4109 rm -f conftest.$ac_objext
4110 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4111   (eval $ac_compile) 2>conftest.er1
4112   ac_status=$?
4113   grep -v '^ *+' conftest.er1 >conftest.err
4114   rm -f conftest.er1
4115   cat conftest.err >&5
4116   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4117   (exit $ac_status); } &&
4118          { ac_try='test -z "$ac_cxx_werror_flag"
4119                          || test ! -s conftest.err'
4120   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4121   (eval $ac_try) 2>&5
4122   ac_status=$?
4123   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4124   (exit $ac_status); }; } &&
4125          { ac_try='test -s conftest.$ac_objext'
4126   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4127   (eval $ac_try) 2>&5
4128   ac_status=$?
4129   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4130   (exit $ac_status); }; }; then
4131   :
4132 else
4133   echo "$as_me: failed program was:" >&5
4134 sed 's/^/| /' conftest.$ac_ext >&5
4135
4136 continue
4137 fi
4138 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4139   cat >conftest.$ac_ext <<_ACEOF
4140 /* confdefs.h.  */
4141 _ACEOF
4142 cat confdefs.h >>conftest.$ac_ext
4143 cat >>conftest.$ac_ext <<_ACEOF
4144 /* end confdefs.h.  */
4145 $ac_declaration
4146 int
4147 main ()
4148 {
4149 exit (42);
4150   ;
4151   return 0;
4152 }
4153 _ACEOF
4154 rm -f conftest.$ac_objext
4155 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4156   (eval $ac_compile) 2>conftest.er1
4157   ac_status=$?
4158   grep -v '^ *+' conftest.er1 >conftest.err
4159   rm -f conftest.er1
4160   cat conftest.err >&5
4161   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4162   (exit $ac_status); } &&
4163          { ac_try='test -z "$ac_cxx_werror_flag"
4164                          || test ! -s conftest.err'
4165   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4166   (eval $ac_try) 2>&5
4167   ac_status=$?
4168   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4169   (exit $ac_status); }; } &&
4170          { ac_try='test -s conftest.$ac_objext'
4171   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4172   (eval $ac_try) 2>&5
4173   ac_status=$?
4174   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4175   (exit $ac_status); }; }; then
4176   break
4177 else
4178   echo "$as_me: failed program was:" >&5
4179 sed 's/^/| /' conftest.$ac_ext >&5
4180
4181 fi
4182 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4183 done
4184 rm -f conftest*
4185 if test -n "$ac_declaration"; then
4186   echo '#ifdef __cplusplus' >>confdefs.h
4187   echo $ac_declaration      >>confdefs.h
4188   echo '#endif'             >>confdefs.h
4189 fi
4190
4191 ac_ext=c
4192 ac_cpp='$CPP $CPPFLAGS'
4193 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4194 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4195 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4196
4197
4198 # We must set the default linker to the linker used by gcc for the correct
4199 # operation of libtool.  If LD is not defined and we are using gcc, try to
4200 # set the LD default to the ld used by gcc.
4201 if test -z "$LD"; then
4202   if test "$GCC" = yes; then
4203     case $build in
4204     *-*-mingw*)
4205       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4206     *)
4207       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4208     esac
4209     case $gcc_prog_ld in
4210     # Accept absolute paths.
4211     [\\/]* | [A-Za-z]:[\\/]*)
4212       LD="$gcc_prog_ld" ;;
4213     esac
4214   fi
4215 fi
4216
4217
4218
4219
4220 if test -n "$ac_tool_prefix"; then
4221   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4222 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4223 echo "$as_me:$LINENO: checking for $ac_word" >&5
4224 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4225 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4226   echo $ECHO_N "(cached) $ECHO_C" >&6
4227 else
4228   if test -n "$GNATBIND"; then
4229   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4230 else
4231 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4232 for as_dir in $PATH
4233 do
4234   IFS=$as_save_IFS
4235   test -z "$as_dir" && as_dir=.
4236   for ac_exec_ext in '' $ac_executable_extensions; do
4237   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4238     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4239     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4240     break 2
4241   fi
4242 done
4243 done
4244
4245 fi
4246 fi
4247 GNATBIND=$ac_cv_prog_GNATBIND
4248 if test -n "$GNATBIND"; then
4249   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4250 echo "${ECHO_T}$GNATBIND" >&6
4251 else
4252   echo "$as_me:$LINENO: result: no" >&5
4253 echo "${ECHO_T}no" >&6
4254 fi
4255
4256 fi
4257 if test -z "$ac_cv_prog_GNATBIND"; then
4258   ac_ct_GNATBIND=$GNATBIND
4259   # Extract the first word of "gnatbind", so it can be a program name with args.
4260 set dummy gnatbind; ac_word=$2
4261 echo "$as_me:$LINENO: checking for $ac_word" >&5
4262 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4263 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4264   echo $ECHO_N "(cached) $ECHO_C" >&6
4265 else
4266   if test -n "$ac_ct_GNATBIND"; then
4267   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4268 else
4269 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4270 for as_dir in $PATH
4271 do
4272   IFS=$as_save_IFS
4273   test -z "$as_dir" && as_dir=.
4274   for ac_exec_ext in '' $ac_executable_extensions; do
4275   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4276     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4277     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4278     break 2
4279   fi
4280 done
4281 done
4282
4283   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4284 fi
4285 fi
4286 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4287 if test -n "$ac_ct_GNATBIND"; then
4288   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4289 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4290 else
4291   echo "$as_me:$LINENO: result: no" >&5
4292 echo "${ECHO_T}no" >&6
4293 fi
4294
4295   GNATBIND=$ac_ct_GNATBIND
4296 else
4297   GNATBIND="$ac_cv_prog_GNATBIND"
4298 fi
4299
4300 if test -n "$ac_tool_prefix"; then
4301   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4302 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4303 echo "$as_me:$LINENO: checking for $ac_word" >&5
4304 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4305 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4306   echo $ECHO_N "(cached) $ECHO_C" >&6
4307 else
4308   if test -n "$GNATMAKE"; then
4309   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4310 else
4311 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4312 for as_dir in $PATH
4313 do
4314   IFS=$as_save_IFS
4315   test -z "$as_dir" && as_dir=.
4316   for ac_exec_ext in '' $ac_executable_extensions; do
4317   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4318     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4319     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4320     break 2
4321   fi
4322 done
4323 done
4324
4325 fi
4326 fi
4327 GNATMAKE=$ac_cv_prog_GNATMAKE
4328 if test -n "$GNATMAKE"; then
4329   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4330 echo "${ECHO_T}$GNATMAKE" >&6
4331 else
4332   echo "$as_me:$LINENO: result: no" >&5
4333 echo "${ECHO_T}no" >&6
4334 fi
4335
4336 fi
4337 if test -z "$ac_cv_prog_GNATMAKE"; then
4338   ac_ct_GNATMAKE=$GNATMAKE
4339   # Extract the first word of "gnatmake", so it can be a program name with args.
4340 set dummy gnatmake; ac_word=$2
4341 echo "$as_me:$LINENO: checking for $ac_word" >&5
4342 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4343 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4344   echo $ECHO_N "(cached) $ECHO_C" >&6
4345 else
4346   if test -n "$ac_ct_GNATMAKE"; then
4347   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4348 else
4349 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4350 for as_dir in $PATH
4351 do
4352   IFS=$as_save_IFS
4353   test -z "$as_dir" && as_dir=.
4354   for ac_exec_ext in '' $ac_executable_extensions; do
4355   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4356     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4357     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4358     break 2
4359   fi
4360 done
4361 done
4362
4363   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4364 fi
4365 fi
4366 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4367 if test -n "$ac_ct_GNATMAKE"; then
4368   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4369 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4370 else
4371   echo "$as_me:$LINENO: result: no" >&5
4372 echo "${ECHO_T}no" >&6
4373 fi
4374
4375   GNATMAKE=$ac_ct_GNATMAKE
4376 else
4377   GNATMAKE="$ac_cv_prog_GNATMAKE"
4378 fi
4379
4380 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4381 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4382 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4383   echo $ECHO_N "(cached) $ECHO_C" >&6
4384 else
4385   cat >conftest.adb <<EOF
4386 procedure conftest is begin null; end conftest;
4387 EOF
4388 acx_cv_cc_gcc_supports_ada=no
4389 # There is a bug in old released versions of GCC which causes the
4390 # driver to exit successfully when the appropriate language module
4391 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4392 # Therefore we must check for the error message as well as an
4393 # unsuccessful exit.
4394 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4395 # given a .adb file, but produce no object file.  So we must check
4396 # if an object file was really produced to guard against this.
4397 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4398 if test x"$errors" = x && test -f conftest.$ac_objext; then
4399   acx_cv_cc_gcc_supports_ada=yes
4400 fi
4401 rm -f conftest.*
4402 fi
4403 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4404 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4405
4406 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4407   have_gnat=yes
4408 else
4409   have_gnat=no
4410 fi
4411
4412 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4413 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4414 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4415   echo $ECHO_N "(cached) $ECHO_C" >&6
4416 else
4417    echo abfoo >t1
4418   echo cdfoo >t2
4419   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4420   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4421     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4422       :
4423     else
4424       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4425     fi
4426   fi
4427   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4428     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4429       :
4430     else
4431       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4432     fi
4433   fi
4434   rm t1 t2
4435
4436 fi
4437 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4438 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4439 do_compare="$gcc_cv_prog_cmp_skip"
4440
4441
4442
4443 # Check for GMP and MPFR
4444 gmplibs="-lmpfr -lgmp"
4445 gmpinc=
4446 have_gmp=no
4447
4448 # Specify a location for mpfr
4449 # check for this first so it ends up on the link line before gmp.
4450
4451 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4452 if test "${with_mpfr_dir+set}" = set; then
4453   withval="$with_mpfr_dir"
4454   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4455 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4456 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4457 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4458    { (exit 1); exit 1; }; }
4459 fi;
4460
4461
4462 # Check whether --with-mpfr or --without-mpfr was given.
4463 if test "${with_mpfr+set}" = set; then
4464   withval="$with_mpfr"
4465
4466 fi;
4467
4468 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4469 if test "${with_mpfr_include+set}" = set; then
4470   withval="$with_mpfr_include"
4471
4472 fi;
4473
4474 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4475 if test "${with_mpfr_lib+set}" = set; then
4476   withval="$with_mpfr_lib"
4477
4478 fi;
4479
4480 if test "x$with_mpfr" != x; then
4481   gmplibs="-L$with_mpfr/lib $gmplibs"
4482   gmpinc="-I$with_mpfr/include"
4483 fi
4484 if test "x$with_mpfr_include" != x; then
4485   gmpinc="-I$with_mpfr_include"
4486 fi
4487 if test "x$with_mpfr_lib" != x; then
4488   gmplibs="-L$with_mpfr_lib $gmplibs"
4489 fi
4490 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4491   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4492   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4493   # Do not test the mpfr version.  Assume that it is sufficient, since
4494   # it is in the source tree, and the library has not been built yet
4495   # but it would be included on the link line in the version check below
4496   # hence making the test fail.
4497   have_gmp=yes
4498 fi
4499
4500 # Specify a location for gmp
4501
4502 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4503 if test "${with_gmp_dir+set}" = set; then
4504   withval="$with_gmp_dir"
4505   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4506 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4507 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4508 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4509    { (exit 1); exit 1; }; }
4510 fi;
4511
4512
4513 # Check whether --with-gmp or --without-gmp was given.
4514 if test "${with_gmp+set}" = set; then
4515   withval="$with_gmp"
4516
4517 fi;
4518
4519 # Check whether --with-gmp_include or --without-gmp_include was given.
4520 if test "${with_gmp_include+set}" = set; then
4521   withval="$with_gmp_include"
4522
4523 fi;
4524
4525 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4526 if test "${with_gmp_lib+set}" = set; then
4527   withval="$with_gmp_lib"
4528
4529 fi;
4530
4531
4532 if test "x$with_gmp" != x; then
4533   gmplibs="-L$with_gmp/lib $gmplibs"
4534   gmpinc="-I$with_gmp/include $gmpinc"
4535 fi
4536 if test "x$with_gmp_include" != x; then
4537   gmpinc="-I$with_gmp_include $gmpinc"
4538 fi
4539 if test "x$with_gmp_lib" != x; then
4540   gmplibs="-L$with_gmp_lib $gmplibs"
4541 fi
4542 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4543   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4544   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4545   # Do not test the gmp version.  Assume that it is sufficient, since
4546   # it is in the source tree, and the library has not been built yet
4547   # but it would be included on the link line in the version check below
4548   # hence making the test fail.
4549   have_gmp=yes
4550 fi
4551
4552 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4553   have_gmp=yes
4554   saved_CFLAGS="$CFLAGS"
4555   CFLAGS="$CFLAGS $gmpinc"
4556   # Check GMP actually works
4557   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4558 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4559
4560 cat >conftest.$ac_ext <<_ACEOF
4561 /* confdefs.h.  */
4562 _ACEOF
4563 cat confdefs.h >>conftest.$ac_ext
4564 cat >>conftest.$ac_ext <<_ACEOF
4565 /* end confdefs.h.  */
4566 #include "gmp.h"
4567 int
4568 main ()
4569 {
4570
4571   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4572   choke me
4573   #endif
4574
4575   ;
4576   return 0;
4577 }
4578 _ACEOF
4579 rm -f conftest.$ac_objext
4580 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4581   (eval $ac_compile) 2>conftest.er1
4582   ac_status=$?
4583   grep -v '^ *+' conftest.er1 >conftest.err
4584   rm -f conftest.er1
4585   cat conftest.err >&5
4586   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4587   (exit $ac_status); } &&
4588          { ac_try='test -z "$ac_c_werror_flag"
4589                          || test ! -s conftest.err'
4590   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4591   (eval $ac_try) 2>&5
4592   ac_status=$?
4593   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4594   (exit $ac_status); }; } &&
4595          { ac_try='test -s conftest.$ac_objext'
4596   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4597   (eval $ac_try) 2>&5
4598   ac_status=$?
4599   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4600   (exit $ac_status); }; }; then
4601   echo "$as_me:$LINENO: result: yes" >&5
4602 echo "${ECHO_T}yes" >&6
4603 else
4604   echo "$as_me: failed program was:" >&5
4605 sed 's/^/| /' conftest.$ac_ext >&5
4606
4607 echo "$as_me:$LINENO: result: no" >&5
4608 echo "${ECHO_T}no" >&6; have_gmp=no
4609 fi
4610 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4611
4612   if test x"$have_gmp" = xyes; then
4613     saved_LIBS="$LIBS"
4614     LIBS="$LIBS $gmplibs"
4615         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4616 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4617     cat >conftest.$ac_ext <<_ACEOF
4618 /* confdefs.h.  */
4619 _ACEOF
4620 cat confdefs.h >>conftest.$ac_ext
4621 cat >>conftest.$ac_ext <<_ACEOF
4622 /* end confdefs.h.  */
4623 #include <gmp.h>
4624     #include <mpfr.h>
4625 int
4626 main ()
4627 {
4628
4629     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4630     choke me
4631     #endif
4632     mpfr_t n;
4633     mpfr_t x;
4634     int t;
4635     mpfr_init (n);
4636     mpfr_init (x);
4637     mpfr_atan2 (n, n, x, GMP_RNDN);
4638     mpfr_erfc (n, x, GMP_RNDN);
4639     mpfr_subnormalize (x, t, GMP_RNDN);
4640
4641   ;
4642   return 0;
4643 }
4644 _ACEOF
4645 rm -f conftest.$ac_objext conftest$ac_exeext
4646 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4647   (eval $ac_link) 2>conftest.er1
4648   ac_status=$?
4649   grep -v '^ *+' conftest.er1 >conftest.err
4650   rm -f conftest.er1
4651   cat conftest.err >&5
4652   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4653   (exit $ac_status); } &&
4654          { ac_try='test -z "$ac_c_werror_flag"
4655                          || test ! -s conftest.err'
4656   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4657   (eval $ac_try) 2>&5
4658   ac_status=$?
4659   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4660   (exit $ac_status); }; } &&
4661          { ac_try='test -s conftest$ac_exeext'
4662   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4663   (eval $ac_try) 2>&5
4664   ac_status=$?
4665   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4666   (exit $ac_status); }; }; then
4667   cat >conftest.$ac_ext <<_ACEOF
4668 /* confdefs.h.  */
4669 _ACEOF
4670 cat confdefs.h >>conftest.$ac_ext
4671 cat >>conftest.$ac_ext <<_ACEOF
4672 /* end confdefs.h.  */
4673 #include <gmp.h>
4674     #include <mpfr.h>
4675 int
4676 main ()
4677 {
4678
4679     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4680     choke me
4681     #endif
4682     mpfr_t n; mpfr_init(n);
4683
4684   ;
4685   return 0;
4686 }
4687 _ACEOF
4688 rm -f conftest.$ac_objext conftest$ac_exeext
4689 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4690   (eval $ac_link) 2>conftest.er1
4691   ac_status=$?
4692   grep -v '^ *+' conftest.er1 >conftest.err
4693   rm -f conftest.er1
4694   cat conftest.err >&5
4695   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4696   (exit $ac_status); } &&
4697          { ac_try='test -z "$ac_c_werror_flag"
4698                          || test ! -s conftest.err'
4699   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4700   (eval $ac_try) 2>&5
4701   ac_status=$?
4702   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4703   (exit $ac_status); }; } &&
4704          { ac_try='test -s conftest$ac_exeext'
4705   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4706   (eval $ac_try) 2>&5
4707   ac_status=$?
4708   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4709   (exit $ac_status); }; }; then
4710   echo "$as_me:$LINENO: result: yes" >&5
4711 echo "${ECHO_T}yes" >&6
4712 else
4713   echo "$as_me: failed program was:" >&5
4714 sed 's/^/| /' conftest.$ac_ext >&5
4715
4716 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4717 echo "${ECHO_T}buggy but acceptable" >&6
4718 fi
4719 rm -f conftest.err conftest.$ac_objext \
4720       conftest$ac_exeext conftest.$ac_ext
4721 else
4722   echo "$as_me: failed program was:" >&5
4723 sed 's/^/| /' conftest.$ac_ext >&5
4724
4725 echo "$as_me:$LINENO: result: no" >&5
4726 echo "${ECHO_T}no" >&6; have_gmp=no
4727 fi
4728 rm -f conftest.err conftest.$ac_objext \
4729       conftest$ac_exeext conftest.$ac_ext
4730       LIBS="$saved_LIBS"
4731   fi
4732   CFLAGS="$saved_CFLAGS"
4733
4734   if test x$have_gmp != xyes; then
4735     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4736 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4737 Copies of these libraries' source code can be found at their respective
4738 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4739 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4740 If you obtained GMP and/or MPFR from a vendor distribution package, make
4741 sure that you have installed both the libraries and the header files.
4742 They may be located in separate packages." >&5
4743 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4744 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4745 Copies of these libraries' source code can be found at their respective
4746 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4747 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4748 If you obtained GMP and/or MPFR from a vendor distribution package, make
4749 sure that you have installed both the libraries and the header files.
4750 They may be located in separate packages." >&2;}
4751    { (exit 1); exit 1; }; }
4752   fi
4753 fi
4754
4755 # Flags needed for both GMP and/or MPFR
4756
4757
4758
4759 # By default, C is the only stage 1 language.
4760 stage1_languages=,c,
4761
4762 # Figure out what language subdirectories are present.
4763 # Look if the user specified --enable-languages="..."; if not, use
4764 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4765 # go away some day.
4766 # NB:  embedded tabs in this IF block -- do not untabify
4767 if test -d ${srcdir}/gcc; then
4768   if test x"${enable_languages+set}" != xset; then
4769     if test x"${LANGUAGES+set}" = xset; then
4770       enable_languages="${LANGUAGES}"
4771         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4772     else
4773       enable_languages=all
4774     fi
4775   else
4776     if test x"${enable_languages}" = x ||
4777        test x"${enable_languages}" = xyes;
4778        then
4779       echo configure.in: --enable-languages needs at least one language argument 1>&2
4780       exit 1
4781     fi
4782   fi
4783   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4784
4785   # 'f95' is the old name for the 'fortran' language. We issue a warning
4786   # and make the substitution.
4787   case ,${enable_languages}, in
4788     *,f95,*)
4789       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4790       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4791       ;;
4792   esac
4793
4794   # First scan to see if an enabled language requires some other language.
4795   # We assume that a given config-lang.in will list all the language
4796   # front ends it requires, even if some are required indirectly.
4797   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4798     case ${lang_frag} in
4799       ..) ;;
4800       # The odd quoting in the next line works around
4801       # an apparent bug in bash 1.12 on linux.
4802       ${srcdir}/gcc/[*]/config-lang.in) ;;
4803       *)
4804         # From the config-lang.in, get $language, $lang_requires
4805         language=
4806         lang_requires=
4807         . ${lang_frag}
4808         for other in ${lang_requires} ; do
4809           case ,${enable_languages}, in
4810             *,$other,*) ;;
4811             *,all,*) ;;
4812             *,$language,*)
4813               echo " \`$other' language required by \`$language'; enabling" 1>&2
4814               enable_languages="${enable_languages},${other}"
4815               ;;
4816           esac
4817         done
4818         ;;
4819     esac
4820   done
4821
4822   new_enable_languages=,c,
4823   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4824   potential_languages=,c,
4825
4826   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4827     case ${lang_frag} in
4828       ..) ;;
4829       # The odd quoting in the next line works around
4830       # an apparent bug in bash 1.12 on linux.
4831       ${srcdir}/gcc/[*]/config-lang.in) ;;
4832       *)
4833         # From the config-lang.in, get $language, $target_libs,
4834         # $lang_dirs, $boot_language, and $build_by_default
4835         language=
4836         target_libs=
4837         lang_dirs=
4838         subdir_requires=
4839         boot_language=no
4840         build_by_default=yes
4841         . ${lang_frag}
4842         if test x${language} = x; then
4843           echo "${lang_frag} doesn't set \$language." 1>&2
4844           exit 1
4845         fi
4846
4847         case ,${enable_languages}, in
4848           *,${language},*)
4849             # Language was explicitly selected; include it.
4850             add_this_lang=yes
4851             ;;
4852           *,all,*)
4853             # 'all' was selected, select it if it is a default language
4854             add_this_lang=${build_by_default}
4855             ;;
4856           *)
4857             add_this_lang=no
4858             ;;
4859         esac
4860
4861         # Disable languages that need other directories if these aren't available.
4862         for i in $subdir_requires; do
4863           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4864           case ,${enable_languages}, in
4865             *,${language},*)
4866               # Specifically requested language; tell them.
4867               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4868 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4869    { (exit 1); exit 1; }; }
4870               ;;
4871             *)
4872               # Silently disable.
4873               add_this_lang=unsupported
4874               ;;
4875           esac
4876         done
4877
4878         # Disable Ada if no preexisting GNAT is available.
4879         case ,${enable_languages},:${language}:${have_gnat} in
4880           *,${language},*:ada:no)
4881             # Specifically requested language; tell them.
4882             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4883 echo "$as_me: error: GNAT is required to build $language" >&2;}
4884    { (exit 1); exit 1; }; }
4885             ;;
4886           *:ada:no)
4887             # Silently disable.
4888             add_this_lang=unsupported
4889             ;;
4890         esac
4891
4892         # Disable a language that is unsupported by the target.
4893         case " $unsupported_languages " in
4894           *" $language "*)
4895             add_this_lang=unsupported
4896             ;;
4897         esac
4898
4899         case $add_this_lang in
4900           unsupported)
4901             # Remove language-dependent dirs.
4902             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4903             ;;
4904           no)
4905             # Remove language-dependent dirs; still show language as supported.
4906             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4907             potential_languages="${potential_languages}${language},"
4908             ;;
4909           yes)
4910             new_enable_languages="${new_enable_languages}${language},"
4911             potential_languages="${potential_languages}${language},"
4912             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4913             case ${boot_language} in
4914               yes)
4915                 # Add to (comma-separated) list of stage 1 languages.
4916                 stage1_languages="${stage1_languages}${language},"
4917                 ;;
4918             esac
4919             ;;
4920         esac
4921         ;;
4922     esac
4923   done
4924
4925   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4926 if test "${enable_stage1_languages+set}" = set; then
4927   enableval="$enable_stage1_languages"
4928   case ,${enable_stage1_languages}, in
4929     ,no,|,,)
4930       # Set it to something that will have no effect in the loop below
4931       enable_stage1_languages=c ;;
4932     ,yes,)
4933       enable_stage1_languages=`echo $new_enable_languages | \
4934         sed -e "s/^,//" -e "s/,$//" ` ;;
4935     *,all,*)
4936       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4937         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4938   esac
4939
4940   # Add "good" languages from enable_stage1_languages to stage1_languages,
4941   # while "bad" languages go in missing_languages.  Leave no duplicates.
4942   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4943     case $potential_languages in
4944       *,$i,*)
4945         case $stage1_languages in
4946           *,$i,*) ;;
4947           *) stage1_languages="$stage1_languages$i," ;;
4948         esac ;;
4949       *)
4950         case $missing_languages in
4951           *,$i,*) ;;
4952           *) missing_languages="$missing_languages$i," ;;
4953         esac ;;
4954      esac
4955   done
4956 fi;
4957
4958   # Remove leading/trailing commas that were added for simplicity
4959   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4960   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4961   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4962   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4963
4964   if test "x$missing_languages" != x; then
4965     { { echo "$as_me:$LINENO: error:
4966 The following requested languages could not be built: ${missing_languages}
4967 Supported languages are: ${potential_languages}" >&5
4968 echo "$as_me: error:
4969 The following requested languages could not be built: ${missing_languages}
4970 Supported languages are: ${potential_languages}" >&2;}
4971    { (exit 1); exit 1; }; }
4972   fi
4973   if test "x$new_enable_languages" != "x$enable_languages"; then
4974     echo The following languages will be built: ${new_enable_languages}
4975     enable_languages="$new_enable_languages"
4976   fi
4977
4978
4979   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4980 fi
4981
4982 # Handle --disable-<component> generically.
4983 for dir in $configdirs $build_configdirs $target_configdirs ; do
4984   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4985   varname=`echo $dirname | sed -e s/+/_/g`
4986   if eval test x\${enable_${varname}} "=" xno ; then
4987     noconfigdirs="$noconfigdirs $dir"
4988   fi
4989 done
4990
4991 # Check for Boehm's garbage collector
4992 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4993 if test "${enable_objc_gc+set}" = set; then
4994   enableval="$enable_objc_gc"
4995   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4996   *,objc,*:*:yes:*target-boehm-gc*)
4997     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4998 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4999    { (exit 1); exit 1; }; }
5000     ;;
5001 esac
5002 fi;
5003
5004 # Make sure we only build Boehm's garbage collector if required.
5005 case ,${enable_languages},:${enable_objc_gc} in
5006   *,objc,*:yes)
5007     # Keep target-boehm-gc if requested for Objective-C.
5008     ;;
5009   *)
5010     # Otherwise remove target-boehm-gc depending on target-libjava.
5011     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5012       noconfigdirs="$noconfigdirs target-boehm-gc"
5013     fi
5014     ;;
5015 esac
5016
5017 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5018 # $build_configdirs and $target_configdirs.
5019 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5020
5021 notsupp=""
5022 for dir in . $skipdirs $noconfigdirs ; do
5023   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5024   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5025     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5026     if test -r $srcdir/$dirname/configure ; then
5027       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5028         true
5029       else
5030         notsupp="$notsupp $dir"
5031       fi
5032     fi
5033   fi
5034   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5035     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5036     if test -r $srcdir/$dirname/configure ; then
5037       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5038         true
5039       else
5040         notsupp="$notsupp $dir"
5041       fi
5042     fi
5043   fi
5044   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5045     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5046     if test -r $srcdir/$dirname/configure ; then
5047       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5048         true
5049       else
5050         notsupp="$notsupp $dir"
5051       fi
5052     fi
5053   fi
5054 done
5055
5056 # Sometimes the tools are distributed with libiberty but with no other
5057 # libraries.  In that case, we don't want to build target-libiberty.
5058 # Don't let libgcc imply libiberty either.
5059 if test -n "${target_configdirs}" ; then
5060   libgcc=
5061   others=
5062   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5063     if test "$i" = "libgcc"; then
5064       libgcc=target-libgcc
5065     elif test "$i" != "libiberty" ; then
5066       if test -r $srcdir/$i/configure ; then
5067         others=yes;
5068         break;
5069       fi
5070     fi
5071   done
5072   if test -z "${others}" ; then
5073     target_configdirs=$libgcc
5074   fi
5075 fi
5076
5077 # Quietly strip out all directories which aren't configurable in this tree.
5078 # This relies on all configurable subdirectories being autoconfiscated, which
5079 # is now the case.
5080 build_configdirs_all="$build_configdirs"
5081 build_configdirs=
5082 for i in ${build_configdirs_all} ; do
5083   j=`echo $i | sed -e s/build-//g`
5084   if test -f ${srcdir}/$j/configure ; then
5085     build_configdirs="${build_configdirs} $i"
5086   fi
5087 done
5088
5089 configdirs_all="$configdirs"
5090 configdirs=
5091 for i in ${configdirs_all} ; do
5092   if test -f ${srcdir}/$i/configure ; then
5093     configdirs="${configdirs} $i"
5094   fi
5095 done
5096
5097 target_configdirs_all="$target_configdirs"
5098 target_configdirs=
5099 for i in ${target_configdirs_all} ; do
5100   j=`echo $i | sed -e s/target-//g`
5101   if test -f ${srcdir}/$j/configure ; then
5102     target_configdirs="${target_configdirs} $i"
5103   fi
5104 done
5105
5106 # Produce a warning message for the subdirs we can't configure.
5107 # This isn't especially interesting in the Cygnus tree, but in the individual
5108 # FSF releases, it's important to let people know when their machine isn't
5109 # supported by the one or two programs in a package.
5110
5111 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5112   # If $appdirs is non-empty, at least one of those directories must still
5113   # be configured, or we error out.  (E.g., if the gas release supports a
5114   # specified target in some subdirs but not the gas subdir, we shouldn't
5115   # pretend that all is well.)
5116   if test -n "$appdirs" ; then
5117     for dir in $appdirs ; do
5118       if test -r $dir/Makefile.in ; then
5119         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5120           appdirs=""
5121           break
5122         fi
5123         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5124           appdirs=""
5125           break
5126         fi
5127       fi
5128     done
5129     if test -n "$appdirs" ; then
5130       echo "*** This configuration is not supported by this package." 1>&2
5131       exit 1
5132     fi
5133   fi
5134   # Okay, some application will build, or we don't care to check.  Still
5135   # notify of subdirs not getting built.
5136   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5137   echo "    ${notsupp}" 1>&2
5138   echo "    (Any other directories should still work fine.)" 1>&2
5139 fi
5140
5141 case "$host" in
5142   *msdosdjgpp*)
5143     enable_gdbtk=no ;;
5144 esac
5145
5146 # To find our prefix, in gcc_cv_tool_prefix.
5147
5148 # The user is always right.
5149 if test "${PATH_SEPARATOR+set}" != set; then
5150   echo "#! /bin/sh" >conf$$.sh
5151   echo  "exit 0"   >>conf$$.sh
5152   chmod +x conf$$.sh
5153   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5154     PATH_SEPARATOR=';'
5155   else
5156     PATH_SEPARATOR=:
5157   fi
5158   rm -f conf$$.sh
5159 fi
5160
5161
5162
5163 if test "x$exec_prefix" = xNONE; then
5164         if test "x$prefix" = xNONE; then
5165                 gcc_cv_tool_prefix=$ac_default_prefix
5166         else
5167                 gcc_cv_tool_prefix=$prefix
5168         fi
5169 else
5170         gcc_cv_tool_prefix=$exec_prefix
5171 fi
5172
5173 # If there is no compiler in the tree, use the PATH only.  In any
5174 # case, if there is no compiler in the tree nobody should use
5175 # AS_FOR_TARGET and LD_FOR_TARGET.
5176 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5177     gcc_version=`cat $srcdir/gcc/BASE-VER`
5178     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5179     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5180     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5181     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5182     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5183     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5184 else
5185     gcc_cv_tool_dirs=
5186 fi
5187
5188 if test x$build = x$target && test -n "$md_exec_prefix"; then
5189         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5190 fi
5191
5192
5193
5194 copy_dirs=
5195
5196
5197 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5198 if test "${with_build_sysroot+set}" = set; then
5199   withval="$with_build_sysroot"
5200   if test x"$withval" != x ; then
5201      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5202    fi
5203 else
5204   SYSROOT_CFLAGS_FOR_TARGET=
5205 fi;
5206
5207
5208
5209 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5210 if test "${with_debug_prefix_map+set}" = set; then
5211   withval="$with_debug_prefix_map"
5212   if test x"$withval" != x; then
5213      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5214      for debug_map in $withval; do
5215        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5216      done
5217    fi
5218 else
5219   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5220 fi;
5221
5222
5223 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5224 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5225 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5226 # We want to ensure that TARGET libraries (which we know are built with
5227 # gcc) are built with "-O2 -g", so include those options when setting
5228 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5229 if test "x$CFLAGS_FOR_TARGET" = x; then
5230   CFLAGS_FOR_TARGET=$CFLAGS
5231   case " $CFLAGS " in
5232     *" -O2 "*) ;;
5233     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5234   esac
5235   case " $CFLAGS " in
5236     *" -g "* | *" -g3 "*) ;;
5237     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5238   esac
5239 fi
5240
5241
5242 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5243   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5244   case " $CXXFLAGS " in
5245     *" -O2 "*) ;;
5246     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5247   esac
5248   case " $CXXFLAGS " in
5249     *" -g "* | *" -g3 "*) ;;
5250     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5251   esac
5252 fi
5253
5254
5255 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5256 # the named directory are copied to $(tooldir)/sys-include.
5257 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5258   if test x${is_cross_compiler} = xno ; then
5259     echo 1>&2 '***' --with-headers is only supported when cross compiling
5260     exit 1
5261   fi
5262   if test x"${with_headers}" != xyes ; then
5263     x=${gcc_cv_tool_prefix}
5264     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5265   fi
5266 fi
5267
5268 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5269 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5270 # are permitted.
5271 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5272   if test x${is_cross_compiler} = xno ; then
5273     echo 1>&2 '***' --with-libs is only supported when cross compiling
5274     exit 1
5275   fi
5276   if test x"${with_libs}" != xyes ; then
5277     # Copy the libraries in reverse order, so that files in the first named
5278     # library override files in subsequent libraries.
5279     x=${gcc_cv_tool_prefix}
5280     for l in ${with_libs}; do
5281       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5282     done
5283   fi
5284 fi
5285
5286 # Set with_gnu_as and with_gnu_ld as appropriate.
5287 #
5288 # This is done by determining whether or not the appropriate directory
5289 # is available, and by checking whether or not specific configurations
5290 # have requested that this magic not happen.
5291 #
5292 # The command line options always override the explicit settings in
5293 # configure.in, and the settings in configure.in override this magic.
5294 #
5295 # If the default for a toolchain is to use GNU as and ld, and you don't
5296 # want to do that, then you should use the --without-gnu-as and
5297 # --without-gnu-ld options for the configure script.
5298
5299 if test x${use_gnu_as} = x &&
5300    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5301   with_gnu_as=yes
5302   extra_host_args="$extra_host_args --with-gnu-as"
5303 fi
5304
5305 if test x${use_gnu_ld} = x &&
5306    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5307   with_gnu_ld=yes
5308   extra_host_args="$extra_host_args --with-gnu-ld"
5309 fi
5310
5311 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5312 # can detect this case.
5313
5314 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5315   with_newlib=yes
5316   extra_host_args="$extra_host_args --with-newlib"
5317 fi
5318
5319 # Handle ${copy_dirs}
5320 set fnord ${copy_dirs}
5321 shift
5322 while test $# != 0 ; do
5323   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5324     :
5325   else
5326     echo Copying $1 to $2
5327
5328     # Use the install script to create the directory and all required
5329     # parent directories.
5330     if test -d $2 ; then
5331       :
5332     else
5333       echo >config.temp
5334       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5335     fi
5336
5337     # Copy the directory, assuming we have tar.
5338     # FIXME: Should we use B in the second tar?  Not all systems support it.
5339     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5340
5341     # It is the responsibility of the user to correctly adjust all
5342     # symlinks.  If somebody can figure out how to handle them correctly
5343     # here, feel free to add the code.
5344
5345     echo $1 > $2/COPIED
5346   fi
5347   shift; shift
5348 done
5349
5350 # Determine a target-dependent exec_prefix that the installed
5351 # gcc will search in.  Keep this list sorted by triplet, with
5352 # the *-*-osname triplets last.
5353 md_exec_prefix=
5354 case "${target}" in
5355   alpha*-*-*vms*)
5356     md_exec_prefix=/gnu/lib/gcc-lib
5357     ;;
5358   i[34567]86-pc-msdosdjgpp*)
5359     md_exec_prefix=/dev/env/DJDIR/bin
5360     ;;
5361   i[34567]86-*-sco3.2v5*)
5362     if test $with_gnu_as = yes; then
5363       md_exec_prefix=/usr/gnu/bin
5364     else
5365       md_exec_prefix=/usr/ccs/bin/elf
5366     fi
5367     ;;
5368
5369   mn10300-*-* | \
5370   powerpc-*-chorusos* | \
5371   powerpc*-*-eabi* | \
5372   powerpc*-*-sysv* | \
5373   powerpc*-*-kaos* | \
5374   s390x-ibm-tpf*)
5375     md_exec_prefix=/usr/ccs/bin
5376     ;;
5377   sparc64-*-elf*)
5378     ;;
5379   v850*-*-*)
5380     md_exec_prefix=/usr/ccs/bin
5381     ;;
5382   xtensa*-*-elf*)
5383     ;;
5384
5385   *-*-beos* | \
5386   *-*-elf* | \
5387   *-*-hpux* | \
5388   *-*-netware* | \
5389   *-*-nto-qnx* | \
5390   *-*-rtems* | \
5391   *-*-solaris2* | \
5392   *-*-sysv[45]* | \
5393   *-*-vxworks* | \
5394   *-wrs-windiss)
5395     md_exec_prefix=/usr/ccs/bin
5396     ;;
5397 esac
5398
5399 extra_arflags_for_target=
5400 extra_nmflags_for_target=
5401 extra_ranlibflags_for_target=
5402 target_makefile_frag=/dev/null
5403 case "${target}" in
5404   mep*-*-*)
5405     target_makefile_frag="config/mt-mep"
5406     ;;
5407   spu-*-*)
5408     target_makefile_frag="config/mt-spu"
5409     ;;
5410   mips*-sde-elf*)
5411     target_makefile_frag="config/mt-sde"
5412     ;;
5413   mipsisa*-*-elfoabi*)
5414     target_makefile_frag="config/mt-mips-elfoabi"
5415     ;;
5416   *-*-netware*)
5417     target_makefile_frag="config/mt-netware"
5418     ;;
5419   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5420     target_makefile_frag="config/mt-gnu"
5421     ;;
5422   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5423     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5424     # commands to handle both 32-bit and 64-bit objects.  These flags are
5425     # harmless if we're using GNU nm or ar.
5426     extra_arflags_for_target=" -X32_64"
5427     extra_nmflags_for_target=" -B -X32_64"
5428     ;;
5429   *-*-darwin*)
5430     # ranlib from Darwin requires the -c flag to look at common symbols.
5431     extra_ranlibflags_for_target=" -c"
5432     ;;
5433   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5434     target_makefile_frag="config/mt-wince"
5435     ;;
5436 esac
5437
5438 alphaieee_frag=/dev/null
5439 case $target in
5440   alpha*-*-*)
5441     # This just makes sure to use the -mieee option to build target libs.
5442     # This should probably be set individually by each library.
5443     alphaieee_frag="config/mt-alphaieee"
5444     ;;
5445 esac
5446
5447 # If --enable-target-optspace always use -Os instead of -O2 to build
5448 # the target libraries, similarly if it is not specified, use -Os
5449 # on selected platforms.
5450 ospace_frag=/dev/null
5451 case "${enable_target_optspace}:${target}" in
5452   yes:*)
5453     ospace_frag="config/mt-ospace"
5454     ;;
5455   :d30v-*)
5456     ospace_frag="config/mt-d30v"
5457     ;;
5458   :m32r-* | :d10v-* | :fr30-*)
5459     ospace_frag="config/mt-ospace"
5460     ;;
5461   no:* | :*)
5462     ;;
5463   *)
5464     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5465     ;;
5466 esac
5467
5468 # Default to using --with-stabs for certain targets.
5469 if test x${with_stabs} = x ; then
5470   case "${target}" in
5471   mips*-*-irix[56]*)
5472     ;;
5473   mips*-*-* | alpha*-*-osf*)
5474     with_stabs=yes;
5475     extra_host_args="${extra_host_args} --with-stabs"
5476     ;;
5477   esac
5478 fi
5479
5480 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5481 # them automatically.
5482 case "${host}" in
5483   hppa*64*-*-hpux11*)
5484     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5485     ;;
5486 esac
5487
5488 # Some systems (e.g., one of the i386-aix systems the gas testers are
5489 # using) don't handle "\$" correctly, so don't use it here.
5490 tooldir='${exec_prefix}'/${target_noncanonical}
5491 build_tooldir=${tooldir}
5492
5493 # Create a .gdbinit file which runs the one in srcdir
5494 # and tells GDB to look there for source files.
5495
5496 if test -r ${srcdir}/.gdbinit ; then
5497   case ${srcdir} in
5498     .) ;;
5499     *) cat > ./.gdbinit <<EOF
5500 # ${NO_EDIT}
5501 dir ${srcdir}
5502 dir .
5503 source ${srcdir}/.gdbinit
5504 EOF
5505     ;;
5506   esac
5507 fi
5508
5509 # Make sure that the compiler is able to generate an executable.  If it
5510 # can't, we are probably in trouble.  We don't care whether we can run the
5511 # executable--we might be using a cross compiler--we only care whether it
5512 # can be created.  At this point the main configure script has set CC.
5513 we_are_ok=no
5514 echo "int main () { return 0; }" > conftest.c
5515 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5516 if test $? = 0 ; then
5517   if test -s conftest || test -s conftest.exe ; then
5518     we_are_ok=yes
5519   fi
5520 fi
5521 case $we_are_ok in
5522   no)
5523     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5524     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5525     rm -f conftest*
5526     exit 1
5527     ;;
5528 esac
5529 rm -f conftest*
5530
5531 # The Solaris /usr/ucb/cc compiler does not appear to work.
5532 case "${host}" in
5533   sparc-sun-solaris2*)
5534       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5535       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5536           could_use=
5537           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5538           if test -d /opt/cygnus/bin ; then
5539               if test "$could_use" = "" ; then
5540                   could_use="/opt/cygnus/bin"
5541               else
5542                   could_use="$could_use or /opt/cygnus/bin"
5543               fi
5544           fi
5545         if test "$could_use" = "" ; then
5546             echo "Warning: compilation may fail because you're using"
5547             echo "/usr/ucb/cc.  You should change your PATH or CC "
5548             echo "variable and rerun configure."
5549         else
5550             echo "Warning: compilation may fail because you're using"
5551             echo "/usr/ucb/cc, when you should use the C compiler from"
5552             echo "$could_use.  You should change your"
5553             echo "PATH or CC variable and rerun configure."
5554         fi
5555       fi
5556   ;;
5557 esac
5558
5559 case "${host}" in
5560   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5561   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5562   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5563 esac
5564
5565 # Record target_configdirs and the configure arguments for target and
5566 # build configuration in Makefile.
5567 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5568 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5569
5570 # Determine whether gdb needs tk/tcl or not.
5571 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5572 # and in that case we want gdb to be built without tk.  Ugh!
5573 # In fact I believe gdb is the *only* package directly dependent on tk,
5574 # so we should be able to put the 'maybe's in unconditionally and
5575 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5576 # 100% sure that that's safe though.
5577
5578 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5579 case "$enable_gdbtk" in
5580   no)
5581     GDB_TK="" ;;
5582   yes)
5583     GDB_TK="${gdb_tk}" ;;
5584   *)
5585     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5586     # distro.  Eventually someone will fix this and move Insight, nee
5587     # gdbtk to a separate directory.
5588     if test -d ${srcdir}/gdb/gdbtk ; then
5589       GDB_TK="${gdb_tk}"
5590     else
5591       GDB_TK=""
5592     fi
5593     ;;
5594 esac
5595 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5596 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5597
5598 # Strip out unwanted targets.
5599
5600 # While at that, we remove Makefiles if we were started for recursive
5601 # configuration, so that the top-level Makefile reconfigures them,
5602 # like we used to do when configure itself was recursive.
5603
5604 # Loop over modules.  $extrasub must be used with care, limiting as
5605 # much as possible the usage of range addresses.  That's because autoconf
5606 # splits the sed script to overcome limits in the number of commands,
5607 # and relying on carefully-timed sed passes may turn out to be very hard
5608 # to maintain later.  In this particular case, you just have to be careful
5609 # not to nest @if/@endif pairs, because configure will not warn you at all.
5610
5611 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5612 if test "${enable_bootstrap+set}" = set; then
5613   enableval="$enable_bootstrap"
5614
5615 else
5616   enable_bootstrap=default
5617 fi;
5618
5619 # Issue errors and warnings for invalid/strange bootstrap combinations.
5620 case "$configdirs" in
5621   *gcc*) have_compiler=yes ;;
5622   *) have_compiler=no ;;
5623 esac
5624
5625 case "$have_compiler:$host:$target:$enable_bootstrap" in
5626   *:*:*:no) ;;
5627
5628   # Default behavior.  Enable bootstrap if we have a compiler
5629   # and we are in a native configuration.
5630   yes:$build:$build:default)
5631     enable_bootstrap=yes ;;
5632
5633   *:*:*:default)
5634     enable_bootstrap=no ;;
5635
5636   # We have a compiler and we are in a native configuration, bootstrap is ok
5637   yes:$build:$build:yes)
5638     ;;
5639
5640   # Other configurations, but we have a compiler.  Assume the user knows
5641   # what he's doing.
5642   yes:*:*:yes)
5643     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5644 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5645     ;;
5646
5647   # No compiler: if they passed --enable-bootstrap explicitly, fail
5648   no:*:*:yes)
5649     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5650 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5651    { (exit 1); exit 1; }; } ;;
5652
5653   # Fail if wrong command line
5654   *)
5655     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5656 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5657    { (exit 1); exit 1; }; }
5658     ;;
5659 esac
5660
5661 # Adjust the toplevel makefile according to whether bootstrap was selected.
5662 case "$enable_bootstrap" in
5663   yes)
5664     bootstrap_suffix=bootstrap ;;
5665   no)
5666     bootstrap_suffix=no-bootstrap ;;
5667 esac
5668
5669 for module in ${build_configdirs} ; do
5670   if test -z "${no_recursion}" \
5671      && test -f ${build_subdir}/${module}/Makefile; then
5672     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5673     rm -f ${build_subdir}/${module}/Makefile
5674   fi
5675   extrasub="$extrasub
5676 /^@if build-$module\$/d
5677 /^@endif build-$module\$/d
5678 /^@if build-$module-$bootstrap_suffix\$/d
5679 /^@endif build-$module-$bootstrap_suffix\$/d"
5680 done
5681 for module in ${configdirs} ; do
5682   if test -z "${no_recursion}"; then
5683     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5684       if test -f ${file}; then
5685         echo 1>&2 "*** removing ${file} to force reconfigure"
5686         rm -f ${file}
5687       fi
5688     done
5689   fi
5690   extrasub="$extrasub
5691 /^@if $module\$/d
5692 /^@endif $module\$/d
5693 /^@if $module-$bootstrap_suffix\$/d
5694 /^@endif $module-$bootstrap_suffix\$/d"
5695 done
5696 for module in ${target_configdirs} ; do
5697   if test -z "${no_recursion}" \
5698      && test -f ${target_subdir}/${module}/Makefile; then
5699     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5700     rm -f ${target_subdir}/${module}/Makefile
5701   fi
5702   extrasub="$extrasub
5703 /^@if target-$module\$/d
5704 /^@endif target-$module\$/d
5705 /^@if target-$module-$bootstrap_suffix\$/d
5706 /^@endif target-$module-$bootstrap_suffix\$/d"
5707 done
5708
5709 extrasub="$extrasub
5710 /^@if /,/^@endif /d"
5711
5712 # Create the serialization dependencies.  This uses a temporary file.
5713
5714 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5715 if test "${enable_serial_configure+set}" = set; then
5716   enableval="$enable_serial_configure"
5717
5718 fi;
5719
5720 case ${enable_serial_configure} in
5721   yes)
5722     enable_serial_build_configure=yes
5723     enable_serial_host_configure=yes
5724     enable_serial_target_configure=yes
5725     ;;
5726 esac
5727
5728 # These force 'configure's to be done one at a time, to avoid problems
5729 # with contention over a shared config.cache.
5730 rm -f serdep.tmp
5731 echo '# serdep.tmp' > serdep.tmp
5732 olditem=
5733 test "x${enable_serial_build_configure}" = xyes &&
5734 for item in ${build_configdirs} ; do
5735   case ${olditem} in
5736     "") ;;
5737     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5738   esac
5739   olditem=${item}
5740 done
5741 olditem=
5742 test "x${enable_serial_host_configure}" = xyes &&
5743 for item in ${configdirs} ; do
5744   case ${olditem} in
5745     "") ;;
5746     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5747   esac
5748   olditem=${item}
5749 done
5750 olditem=
5751 test "x${enable_serial_target_configure}" = xyes &&
5752 for item in ${target_configdirs} ; do
5753   case ${olditem} in
5754     "") ;;
5755     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5756   esac
5757   olditem=${item}
5758 done
5759 serialization_dependencies=serdep.tmp
5760
5761
5762 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5763 # target, nonopt, and variable assignments.  These are the ones we
5764 # might not want to pass down to subconfigures.  Also strip
5765 # program-prefix, program-suffix, and program-transform-name, so that
5766 # we can pass down a consistent program-transform-name.
5767 baseargs=
5768 keep_next=no
5769 skip_next=no
5770 eval "set -- $ac_configure_args"
5771 for ac_arg
5772 do
5773   if test X"$skip_next" = X"yes"; then
5774     skip_next=no
5775     continue
5776   fi
5777   if test X"$keep_next" = X"yes"; then
5778     case $ac_arg in
5779       *\'*)
5780         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5781     esac
5782     baseargs="$baseargs '$ac_arg'"
5783     keep_next=no
5784     continue
5785   fi
5786
5787   # Handle separated arguments.  Based on the logic generated by
5788   # autoconf 2.59.
5789   case $ac_arg in
5790     *=* | --config-cache | -C | -disable-* | --disable-* \
5791       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5792       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5793       | -with-* | --with-* | -without-* | --without-* | --x)
5794       separate_arg=no
5795       ;;
5796     -*)
5797       separate_arg=yes
5798       ;;
5799     *)
5800       separate_arg=no
5801       ;;
5802   esac
5803
5804   case "$ac_arg" in
5805     --no*)
5806       continue
5807       ;;
5808     --c* | \
5809     --sr* | \
5810     --ho* | \
5811     --bu* | \
5812     --t* | \
5813     --program-* | \
5814     -cache_file* | \
5815     -srcdir* | \
5816     -host* | \
5817     -build* | \
5818     -target* | \
5819     -program-prefix* | \
5820     -program-suffix* | \
5821     -program-transform-name* )
5822       skip_next=$separate_arg
5823       continue
5824       ;;
5825     -*)
5826       # An option.  Add it.
5827       case $ac_arg in
5828         *\'*)
5829           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5830       esac
5831       baseargs="$baseargs '$ac_arg'"
5832       keep_next=$separate_arg
5833       ;;
5834     *)
5835       # Either a variable assignment, or a nonopt (triplet).  Don't
5836       # pass it down; let the Makefile handle this.
5837       continue
5838       ;;
5839   esac
5840 done
5841 # Remove the initial space we just introduced and, as these will be
5842 # expanded by make, quote '$'.
5843 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5844
5845 # Add in --program-transform-name, after --program-prefix and
5846 # --program-suffix have been applied to it.  Autoconf has already
5847 # doubled dollar signs and backslashes in program_transform_name; we want
5848 # the backslashes un-doubled, and then the entire thing wrapped in single
5849 # quotes, because this will be expanded first by make and then by the shell.
5850 # Also, because we want to override the logic in subdir configure scripts to
5851 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5852 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5853 ${program_transform_name}
5854 EOF_SED
5855 gcc_transform_name=`cat conftestsed.out`
5856 rm -f conftestsed.out
5857 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5858 if test "$silent" = yes; then
5859   baseargs="$baseargs --silent"
5860 fi
5861
5862 # For the build-side libraries, we just need to pretend we're native,
5863 # and not use the same cache file.  Multilibs are neither needed nor
5864 # desired.
5865 build_configargs="--cache-file=../config.cache ${baseargs}"
5866
5867 # For host modules, accept cache file option, or specification as blank.
5868 case "${cache_file}" in
5869 "") # empty
5870   cache_file_option="" ;;
5871 /* | [A-Za-z]:[\\/]* ) # absolute path
5872   cache_file_option="--cache-file=${cache_file}" ;;
5873 *) # relative path
5874   cache_file_option="--cache-file=../${cache_file}" ;;
5875 esac
5876
5877 # Host dirs don't like to share a cache file either, horribly enough.
5878 # This seems to be due to autoconf 2.5x stupidity.
5879 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5880
5881 target_configargs=${baseargs}
5882
5883 # Passing a --with-cross-host argument lets the target libraries know
5884 # whether they are being built with a cross-compiler or being built
5885 # native.  However, it would be better to use other mechanisms to make the
5886 # sorts of decisions they want to make on this basis.  Please consider
5887 # this option to be deprecated.  FIXME.
5888 if test x${is_cross_compiler} = xyes ; then
5889   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5890 fi
5891
5892 # Default to --enable-multilib.
5893 if test x${enable_multilib} = x ; then
5894   target_configargs="--enable-multilib ${target_configargs}"
5895 fi
5896
5897 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5898 # changed from the earlier setting of with_newlib.
5899 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5900   target_configargs="--with-newlib ${target_configargs}"
5901 fi
5902
5903 # Different target subdirs use different values of certain variables
5904 # (notably CXX).  Worse, multilibs use *lots* of different values.
5905 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5906 # it doesn't automatically accept command-line overrides of them.
5907 # This means it's not safe for target subdirs to share a cache file,
5908 # which is disgusting, but there you have it.  Hopefully this can be
5909 # fixed in future.  It's still worthwhile to use a cache file for each
5910 # directory.  I think.
5911
5912 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5913 # We need to pass --target, as newer autoconf's requires consistency
5914 # for target_alias and gcc doesn't manage it consistently.
5915 target_configargs="--cache-file=./config.cache ${target_configargs}"
5916
5917 FLAGS_FOR_TARGET=
5918 case " $target_configdirs " in
5919  *" newlib "*)
5920   case " $target_configargs " in
5921   *" --with-newlib "*)
5922    case "$target" in
5923    *-cygwin*)
5924      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' ;;
5925    esac
5926
5927    # If we're not building GCC, don't discard standard headers.
5928    if test -d ${srcdir}/gcc; then
5929      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5930
5931      if test "${build}" != "${host}"; then
5932        # On Canadian crosses, CC_FOR_TARGET will have already been set
5933        # by `configure', so we won't have an opportunity to add -Bgcc/
5934        # to it.  This is right: we don't want to search that directory
5935        # for binaries, but we want the header files in there, so add
5936        # them explicitly.
5937        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5938
5939        # Someone might think of using the pre-installed headers on
5940        # Canadian crosses, in case the installed compiler is not fully
5941        # compatible with the compiler being built.  In this case, it
5942        # would be better to flag an error than risking having
5943        # incompatible object files being constructed.  We can't
5944        # guarantee that an error will be flagged, but let's hope the
5945        # compiler will do it, when presented with incompatible header
5946        # files.
5947      fi
5948    fi
5949
5950    case "${target}-${is_cross_compiler}" in
5951    i[3456789]86-*-linux*-no)
5952       # Here host == target, so we don't need to build gcc,
5953       # so we don't want to discard standard headers.
5954       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5955       ;;
5956    *)
5957       # If we're building newlib, use its generic headers last, but search
5958       # for any libc-related directories first (so make it the last -B
5959       # switch).
5960       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5961
5962       # If we're building libgloss, find the startup file, simulator library
5963       # and linker script.
5964       case " $target_configdirs " in
5965         *" libgloss "*)
5966         # Look for startup file, simulator library and maybe linker script.
5967         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
5968         # Look for libnosys.a in case the target needs it.
5969         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5970         # Most targets have the linker script in the source directory.
5971         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
5972         ;;
5973       esac
5974       ;;
5975    esac
5976    ;;
5977   esac
5978   ;;
5979 esac
5980 case "$target" in
5981 *-mingw*)
5982   # Can't be handled as Cygwin above since Mingw does not use newlib.
5983   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' ;;
5984 esac
5985
5986 # Allow the user to override the flags for
5987 # our build compiler if desired.
5988 if test x"${build}" = x"${host}" ; then
5989   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5990   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
5991   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
5992 fi
5993
5994 # On Canadian crosses, we'll be searching the right directories for
5995 # the previously-installed cross compiler, so don't bother to add
5996 # flags for directories within the install tree of the compiler
5997 # being built; programs in there won't even run.
5998 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5999   # Search for pre-installed headers if nothing else fits.
6000   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6001 fi
6002
6003 if test "x${use_gnu_ld}" = x &&
6004    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6005   # Arrange for us to find uninstalled linker scripts.
6006   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6007 fi
6008
6009 # Search for other target-specific linker scripts and such.
6010 case "${target}" in
6011   mep*)
6012     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6013     ;;
6014 esac
6015
6016 # Makefile fragments.
6017 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6018 do
6019   eval fragval=\$$frag
6020   if test $fragval != /dev/null; then
6021     eval $frag=${srcdir}/$fragval
6022   fi
6023 done
6024
6025
6026
6027
6028
6029 # Miscellanea: directories, flags, etc.
6030
6031
6032
6033
6034
6035
6036
6037 # Build module lists & subconfigure args.
6038
6039
6040
6041 # Host module lists & subconfigure args.
6042
6043
6044
6045 # Target module lists & subconfigure args.
6046
6047
6048
6049 # Build tools.
6050
6051
6052
6053
6054
6055
6056
6057
6058
6059
6060
6061
6062
6063
6064
6065
6066
6067 # Generate default definitions for YACC, M4, LEX and other programs that run
6068 # on the build machine.  These are used if the Makefile can't locate these
6069 # programs in objdir.
6070 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6071
6072 for ac_prog in 'bison -y' byacc yacc
6073 do
6074   # Extract the first word of "$ac_prog", so it can be a program name with args.
6075 set dummy $ac_prog; ac_word=$2
6076 echo "$as_me:$LINENO: checking for $ac_word" >&5
6077 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6078 if test "${ac_cv_prog_YACC+set}" = set; then
6079   echo $ECHO_N "(cached) $ECHO_C" >&6
6080 else
6081   if test -n "$YACC"; then
6082   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6083 else
6084 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6085 for as_dir in $PATH
6086 do
6087   IFS=$as_save_IFS
6088   test -z "$as_dir" && as_dir=.
6089   for ac_exec_ext in '' $ac_executable_extensions; do
6090   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6091     ac_cv_prog_YACC="$ac_prog"
6092     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6093     break 2
6094   fi
6095 done
6096 done
6097
6098 fi
6099 fi
6100 YACC=$ac_cv_prog_YACC
6101 if test -n "$YACC"; then
6102   echo "$as_me:$LINENO: result: $YACC" >&5
6103 echo "${ECHO_T}$YACC" >&6
6104 else
6105   echo "$as_me:$LINENO: result: no" >&5
6106 echo "${ECHO_T}no" >&6
6107 fi
6108
6109   test -n "$YACC" && break
6110 done
6111 test -n "$YACC" || YACC="$MISSING bison -y"
6112
6113 case " $build_configdirs " in
6114   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6115   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6116 esac
6117
6118 for ac_prog in bison
6119 do
6120   # Extract the first word of "$ac_prog", so it can be a program name with args.
6121 set dummy $ac_prog; ac_word=$2
6122 echo "$as_me:$LINENO: checking for $ac_word" >&5
6123 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6124 if test "${ac_cv_prog_BISON+set}" = set; then
6125   echo $ECHO_N "(cached) $ECHO_C" >&6
6126 else
6127   if test -n "$BISON"; then
6128   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6129 else
6130 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6131 for as_dir in $PATH
6132 do
6133   IFS=$as_save_IFS
6134   test -z "$as_dir" && as_dir=.
6135   for ac_exec_ext in '' $ac_executable_extensions; do
6136   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6137     ac_cv_prog_BISON="$ac_prog"
6138     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6139     break 2
6140   fi
6141 done
6142 done
6143
6144 fi
6145 fi
6146 BISON=$ac_cv_prog_BISON
6147 if test -n "$BISON"; then
6148   echo "$as_me:$LINENO: result: $BISON" >&5
6149 echo "${ECHO_T}$BISON" >&6
6150 else
6151   echo "$as_me:$LINENO: result: no" >&5
6152 echo "${ECHO_T}no" >&6
6153 fi
6154
6155   test -n "$BISON" && break
6156 done
6157 test -n "$BISON" || BISON="$MISSING bison"
6158
6159 case " $build_configdirs " in
6160   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6161 esac
6162
6163 for ac_prog in gm4 gnum4 m4
6164 do
6165   # Extract the first word of "$ac_prog", so it can be a program name with args.
6166 set dummy $ac_prog; ac_word=$2
6167 echo "$as_me:$LINENO: checking for $ac_word" >&5
6168 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6169 if test "${ac_cv_prog_M4+set}" = set; then
6170   echo $ECHO_N "(cached) $ECHO_C" >&6
6171 else
6172   if test -n "$M4"; then
6173   ac_cv_prog_M4="$M4" # Let the user override the test.
6174 else
6175 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6176 for as_dir in $PATH
6177 do
6178   IFS=$as_save_IFS
6179   test -z "$as_dir" && as_dir=.
6180   for ac_exec_ext in '' $ac_executable_extensions; do
6181   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6182     ac_cv_prog_M4="$ac_prog"
6183     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6184     break 2
6185   fi
6186 done
6187 done
6188
6189 fi
6190 fi
6191 M4=$ac_cv_prog_M4
6192 if test -n "$M4"; then
6193   echo "$as_me:$LINENO: result: $M4" >&5
6194 echo "${ECHO_T}$M4" >&6
6195 else
6196   echo "$as_me:$LINENO: result: no" >&5
6197 echo "${ECHO_T}no" >&6
6198 fi
6199
6200   test -n "$M4" && break
6201 done
6202 test -n "$M4" || M4="$MISSING m4"
6203
6204 case " $build_configdirs " in
6205   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6206 esac
6207
6208 for ac_prog in flex lex
6209 do
6210   # Extract the first word of "$ac_prog", so it can be a program name with args.
6211 set dummy $ac_prog; ac_word=$2
6212 echo "$as_me:$LINENO: checking for $ac_word" >&5
6213 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6214 if test "${ac_cv_prog_LEX+set}" = set; then
6215   echo $ECHO_N "(cached) $ECHO_C" >&6
6216 else
6217   if test -n "$LEX"; then
6218   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6219 else
6220 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6221 for as_dir in $PATH
6222 do
6223   IFS=$as_save_IFS
6224   test -z "$as_dir" && as_dir=.
6225   for ac_exec_ext in '' $ac_executable_extensions; do
6226   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6227     ac_cv_prog_LEX="$ac_prog"
6228     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6229     break 2
6230   fi
6231 done
6232 done
6233
6234 fi
6235 fi
6236 LEX=$ac_cv_prog_LEX
6237 if test -n "$LEX"; then
6238   echo "$as_me:$LINENO: result: $LEX" >&5
6239 echo "${ECHO_T}$LEX" >&6
6240 else
6241   echo "$as_me:$LINENO: result: no" >&5
6242 echo "${ECHO_T}no" >&6
6243 fi
6244
6245   test -n "$LEX" && break
6246 done
6247 test -n "$LEX" || LEX="$MISSING flex"
6248
6249 case " $build_configdirs " in
6250   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6251   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6252 esac
6253
6254 for ac_prog in flex
6255 do
6256   # Extract the first word of "$ac_prog", so it can be a program name with args.
6257 set dummy $ac_prog; ac_word=$2
6258 echo "$as_me:$LINENO: checking for $ac_word" >&5
6259 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6260 if test "${ac_cv_prog_FLEX+set}" = set; then
6261   echo $ECHO_N "(cached) $ECHO_C" >&6
6262 else
6263   if test -n "$FLEX"; then
6264   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6265 else
6266 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6267 for as_dir in $PATH
6268 do
6269   IFS=$as_save_IFS
6270   test -z "$as_dir" && as_dir=.
6271   for ac_exec_ext in '' $ac_executable_extensions; do
6272   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6273     ac_cv_prog_FLEX="$ac_prog"
6274     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6275     break 2
6276   fi
6277 done
6278 done
6279
6280 fi
6281 fi
6282 FLEX=$ac_cv_prog_FLEX
6283 if test -n "$FLEX"; then
6284   echo "$as_me:$LINENO: result: $FLEX" >&5
6285 echo "${ECHO_T}$FLEX" >&6
6286 else
6287   echo "$as_me:$LINENO: result: no" >&5
6288 echo "${ECHO_T}no" >&6
6289 fi
6290
6291   test -n "$FLEX" && break
6292 done
6293 test -n "$FLEX" || FLEX="$MISSING flex"
6294
6295 case " $build_configdirs " in
6296   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6297 esac
6298
6299 for ac_prog in makeinfo
6300 do
6301   # Extract the first word of "$ac_prog", so it can be a program name with args.
6302 set dummy $ac_prog; ac_word=$2
6303 echo "$as_me:$LINENO: checking for $ac_word" >&5
6304 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6305 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6306   echo $ECHO_N "(cached) $ECHO_C" >&6
6307 else
6308   if test -n "$MAKEINFO"; then
6309   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6310 else
6311 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6312 for as_dir in $PATH
6313 do
6314   IFS=$as_save_IFS
6315   test -z "$as_dir" && as_dir=.
6316   for ac_exec_ext in '' $ac_executable_extensions; do
6317   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6318     ac_cv_prog_MAKEINFO="$ac_prog"
6319     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6320     break 2
6321   fi
6322 done
6323 done
6324
6325 fi
6326 fi
6327 MAKEINFO=$ac_cv_prog_MAKEINFO
6328 if test -n "$MAKEINFO"; then
6329   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6330 echo "${ECHO_T}$MAKEINFO" >&6
6331 else
6332   echo "$as_me:$LINENO: result: no" >&5
6333 echo "${ECHO_T}no" >&6
6334 fi
6335
6336   test -n "$MAKEINFO" && break
6337 done
6338 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6339
6340 case " $build_configdirs " in
6341   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6342   *)
6343
6344     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6345     # higher, else we use the "missing" dummy.
6346     if ${MAKEINFO} --version \
6347        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6348       :
6349     else
6350       MAKEINFO="$MISSING makeinfo"
6351     fi
6352     ;;
6353
6354 esac
6355
6356 # FIXME: expect and dejagnu may become build tools?
6357
6358 for ac_prog in expect
6359 do
6360   # Extract the first word of "$ac_prog", so it can be a program name with args.
6361 set dummy $ac_prog; ac_word=$2
6362 echo "$as_me:$LINENO: checking for $ac_word" >&5
6363 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6364 if test "${ac_cv_prog_EXPECT+set}" = set; then
6365   echo $ECHO_N "(cached) $ECHO_C" >&6
6366 else
6367   if test -n "$EXPECT"; then
6368   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6369 else
6370 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6371 for as_dir in $PATH
6372 do
6373   IFS=$as_save_IFS
6374   test -z "$as_dir" && as_dir=.
6375   for ac_exec_ext in '' $ac_executable_extensions; do
6376   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6377     ac_cv_prog_EXPECT="$ac_prog"
6378     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6379     break 2
6380   fi
6381 done
6382 done
6383
6384 fi
6385 fi
6386 EXPECT=$ac_cv_prog_EXPECT
6387 if test -n "$EXPECT"; then
6388   echo "$as_me:$LINENO: result: $EXPECT" >&5
6389 echo "${ECHO_T}$EXPECT" >&6
6390 else
6391   echo "$as_me:$LINENO: result: no" >&5
6392 echo "${ECHO_T}no" >&6
6393 fi
6394
6395   test -n "$EXPECT" && break
6396 done
6397 test -n "$EXPECT" || EXPECT="expect"
6398
6399 case " $configdirs " in
6400   *" expect "*)
6401     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6402     ;;
6403 esac
6404
6405 for ac_prog in runtest
6406 do
6407   # Extract the first word of "$ac_prog", so it can be a program name with args.
6408 set dummy $ac_prog; ac_word=$2
6409 echo "$as_me:$LINENO: checking for $ac_word" >&5
6410 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6411 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6412   echo $ECHO_N "(cached) $ECHO_C" >&6
6413 else
6414   if test -n "$RUNTEST"; then
6415   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6416 else
6417 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6418 for as_dir in $PATH
6419 do
6420   IFS=$as_save_IFS
6421   test -z "$as_dir" && as_dir=.
6422   for ac_exec_ext in '' $ac_executable_extensions; do
6423   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6424     ac_cv_prog_RUNTEST="$ac_prog"
6425     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6426     break 2
6427   fi
6428 done
6429 done
6430
6431 fi
6432 fi
6433 RUNTEST=$ac_cv_prog_RUNTEST
6434 if test -n "$RUNTEST"; then
6435   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6436 echo "${ECHO_T}$RUNTEST" >&6
6437 else
6438   echo "$as_me:$LINENO: result: no" >&5
6439 echo "${ECHO_T}no" >&6
6440 fi
6441
6442   test -n "$RUNTEST" && break
6443 done
6444 test -n "$RUNTEST" || RUNTEST="runtest"
6445
6446 case " $configdirs " in
6447   *" dejagnu "*)
6448     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6449     ;;
6450 esac
6451
6452
6453 # Host tools.
6454 ncn_tool_prefix=
6455 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6456 ncn_target_tool_prefix=
6457 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6458
6459
6460
6461 if test -n "$AR"; then
6462   ac_cv_prog_AR=$AR
6463 elif test -n "$ac_cv_prog_AR"; then
6464   AR=$ac_cv_prog_AR
6465 fi
6466
6467 if test -n "$ac_cv_prog_AR"; then
6468   for ncn_progname in ar; do
6469     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6470 set dummy ${ncn_progname}; ac_word=$2
6471 echo "$as_me:$LINENO: checking for $ac_word" >&5
6472 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6473 if test "${ac_cv_prog_AR+set}" = set; then
6474   echo $ECHO_N "(cached) $ECHO_C" >&6
6475 else
6476   if test -n "$AR"; then
6477   ac_cv_prog_AR="$AR" # Let the user override the test.
6478 else
6479 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6480 for as_dir in $PATH
6481 do
6482   IFS=$as_save_IFS
6483   test -z "$as_dir" && as_dir=.
6484   for ac_exec_ext in '' $ac_executable_extensions; do
6485   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6486     ac_cv_prog_AR="${ncn_progname}"
6487     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6488     break 2
6489   fi
6490 done
6491 done
6492
6493 fi
6494 fi
6495 AR=$ac_cv_prog_AR
6496 if test -n "$AR"; then
6497   echo "$as_me:$LINENO: result: $AR" >&5
6498 echo "${ECHO_T}$AR" >&6
6499 else
6500   echo "$as_me:$LINENO: result: no" >&5
6501 echo "${ECHO_T}no" >&6
6502 fi
6503
6504   done
6505 fi
6506
6507 for ncn_progname in ar; do
6508   if test -n "$ncn_tool_prefix"; then
6509     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6510 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6511 echo "$as_me:$LINENO: checking for $ac_word" >&5
6512 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6513 if test "${ac_cv_prog_AR+set}" = set; then
6514   echo $ECHO_N "(cached) $ECHO_C" >&6
6515 else
6516   if test -n "$AR"; then
6517   ac_cv_prog_AR="$AR" # Let the user override the test.
6518 else
6519 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6520 for as_dir in $PATH
6521 do
6522   IFS=$as_save_IFS
6523   test -z "$as_dir" && as_dir=.
6524   for ac_exec_ext in '' $ac_executable_extensions; do
6525   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6526     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6527     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6528     break 2
6529   fi
6530 done
6531 done
6532
6533 fi
6534 fi
6535 AR=$ac_cv_prog_AR
6536 if test -n "$AR"; then
6537   echo "$as_me:$LINENO: result: $AR" >&5
6538 echo "${ECHO_T}$AR" >&6
6539 else
6540   echo "$as_me:$LINENO: result: no" >&5
6541 echo "${ECHO_T}no" >&6
6542 fi
6543
6544   fi
6545   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6546     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6547 set dummy ${ncn_progname}; ac_word=$2
6548 echo "$as_me:$LINENO: checking for $ac_word" >&5
6549 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6550 if test "${ac_cv_prog_AR+set}" = set; then
6551   echo $ECHO_N "(cached) $ECHO_C" >&6
6552 else
6553   if test -n "$AR"; then
6554   ac_cv_prog_AR="$AR" # Let the user override the test.
6555 else
6556 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6557 for as_dir in $PATH
6558 do
6559   IFS=$as_save_IFS
6560   test -z "$as_dir" && as_dir=.
6561   for ac_exec_ext in '' $ac_executable_extensions; do
6562   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6563     ac_cv_prog_AR="${ncn_progname}"
6564     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6565     break 2
6566   fi
6567 done
6568 done
6569
6570 fi
6571 fi
6572 AR=$ac_cv_prog_AR
6573 if test -n "$AR"; then
6574   echo "$as_me:$LINENO: result: $AR" >&5
6575 echo "${ECHO_T}$AR" >&6
6576 else
6577   echo "$as_me:$LINENO: result: no" >&5
6578 echo "${ECHO_T}no" >&6
6579 fi
6580
6581   fi
6582   test -n "$ac_cv_prog_AR" && break
6583 done
6584
6585 if test -z "$ac_cv_prog_AR" ; then
6586   set dummy ar
6587   if test $build = $host ; then
6588     AR="$2"
6589   else
6590     AR="${ncn_tool_prefix}$2"
6591   fi
6592 fi
6593
6594
6595
6596 if test -n "$AS"; then
6597   ac_cv_prog_AS=$AS
6598 elif test -n "$ac_cv_prog_AS"; then
6599   AS=$ac_cv_prog_AS
6600 fi
6601
6602 if test -n "$ac_cv_prog_AS"; then
6603   for ncn_progname in as; do
6604     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6605 set dummy ${ncn_progname}; ac_word=$2
6606 echo "$as_me:$LINENO: checking for $ac_word" >&5
6607 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6608 if test "${ac_cv_prog_AS+set}" = set; then
6609   echo $ECHO_N "(cached) $ECHO_C" >&6
6610 else
6611   if test -n "$AS"; then
6612   ac_cv_prog_AS="$AS" # Let the user override the test.
6613 else
6614 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6615 for as_dir in $PATH
6616 do
6617   IFS=$as_save_IFS
6618   test -z "$as_dir" && as_dir=.
6619   for ac_exec_ext in '' $ac_executable_extensions; do
6620   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6621     ac_cv_prog_AS="${ncn_progname}"
6622     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6623     break 2
6624   fi
6625 done
6626 done
6627
6628 fi
6629 fi
6630 AS=$ac_cv_prog_AS
6631 if test -n "$AS"; then
6632   echo "$as_me:$LINENO: result: $AS" >&5
6633 echo "${ECHO_T}$AS" >&6
6634 else
6635   echo "$as_me:$LINENO: result: no" >&5
6636 echo "${ECHO_T}no" >&6
6637 fi
6638
6639   done
6640 fi
6641
6642 for ncn_progname in as; do
6643   if test -n "$ncn_tool_prefix"; then
6644     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6645 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6646 echo "$as_me:$LINENO: checking for $ac_word" >&5
6647 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6648 if test "${ac_cv_prog_AS+set}" = set; then
6649   echo $ECHO_N "(cached) $ECHO_C" >&6
6650 else
6651   if test -n "$AS"; then
6652   ac_cv_prog_AS="$AS" # Let the user override the test.
6653 else
6654 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6655 for as_dir in $PATH
6656 do
6657   IFS=$as_save_IFS
6658   test -z "$as_dir" && as_dir=.
6659   for ac_exec_ext in '' $ac_executable_extensions; do
6660   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6661     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6662     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6663     break 2
6664   fi
6665 done
6666 done
6667
6668 fi
6669 fi
6670 AS=$ac_cv_prog_AS
6671 if test -n "$AS"; then
6672   echo "$as_me:$LINENO: result: $AS" >&5
6673 echo "${ECHO_T}$AS" >&6
6674 else
6675   echo "$as_me:$LINENO: result: no" >&5
6676 echo "${ECHO_T}no" >&6
6677 fi
6678
6679   fi
6680   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6681     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6682 set dummy ${ncn_progname}; ac_word=$2
6683 echo "$as_me:$LINENO: checking for $ac_word" >&5
6684 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6685 if test "${ac_cv_prog_AS+set}" = set; then
6686   echo $ECHO_N "(cached) $ECHO_C" >&6
6687 else
6688   if test -n "$AS"; then
6689   ac_cv_prog_AS="$AS" # Let the user override the test.
6690 else
6691 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6692 for as_dir in $PATH
6693 do
6694   IFS=$as_save_IFS
6695   test -z "$as_dir" && as_dir=.
6696   for ac_exec_ext in '' $ac_executable_extensions; do
6697   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6698     ac_cv_prog_AS="${ncn_progname}"
6699     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6700     break 2
6701   fi
6702 done
6703 done
6704
6705 fi
6706 fi
6707 AS=$ac_cv_prog_AS
6708 if test -n "$AS"; then
6709   echo "$as_me:$LINENO: result: $AS" >&5
6710 echo "${ECHO_T}$AS" >&6
6711 else
6712   echo "$as_me:$LINENO: result: no" >&5
6713 echo "${ECHO_T}no" >&6
6714 fi
6715
6716   fi
6717   test -n "$ac_cv_prog_AS" && break
6718 done
6719
6720 if test -z "$ac_cv_prog_AS" ; then
6721   set dummy as
6722   if test $build = $host ; then
6723     AS="$2"
6724   else
6725     AS="${ncn_tool_prefix}$2"
6726   fi
6727 fi
6728
6729
6730
6731 if test -n "$DLLTOOL"; then
6732   ac_cv_prog_DLLTOOL=$DLLTOOL
6733 elif test -n "$ac_cv_prog_DLLTOOL"; then
6734   DLLTOOL=$ac_cv_prog_DLLTOOL
6735 fi
6736
6737 if test -n "$ac_cv_prog_DLLTOOL"; then
6738   for ncn_progname in dlltool; do
6739     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6740 set dummy ${ncn_progname}; ac_word=$2
6741 echo "$as_me:$LINENO: checking for $ac_word" >&5
6742 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6743 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6744   echo $ECHO_N "(cached) $ECHO_C" >&6
6745 else
6746   if test -n "$DLLTOOL"; then
6747   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6748 else
6749 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6750 for as_dir in $PATH
6751 do
6752   IFS=$as_save_IFS
6753   test -z "$as_dir" && as_dir=.
6754   for ac_exec_ext in '' $ac_executable_extensions; do
6755   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6756     ac_cv_prog_DLLTOOL="${ncn_progname}"
6757     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6758     break 2
6759   fi
6760 done
6761 done
6762
6763 fi
6764 fi
6765 DLLTOOL=$ac_cv_prog_DLLTOOL
6766 if test -n "$DLLTOOL"; then
6767   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6768 echo "${ECHO_T}$DLLTOOL" >&6
6769 else
6770   echo "$as_me:$LINENO: result: no" >&5
6771 echo "${ECHO_T}no" >&6
6772 fi
6773
6774   done
6775 fi
6776
6777 for ncn_progname in dlltool; do
6778   if test -n "$ncn_tool_prefix"; then
6779     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6780 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6781 echo "$as_me:$LINENO: checking for $ac_word" >&5
6782 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6783 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6784   echo $ECHO_N "(cached) $ECHO_C" >&6
6785 else
6786   if test -n "$DLLTOOL"; then
6787   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6788 else
6789 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6790 for as_dir in $PATH
6791 do
6792   IFS=$as_save_IFS
6793   test -z "$as_dir" && as_dir=.
6794   for ac_exec_ext in '' $ac_executable_extensions; do
6795   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6796     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6797     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6798     break 2
6799   fi
6800 done
6801 done
6802
6803 fi
6804 fi
6805 DLLTOOL=$ac_cv_prog_DLLTOOL
6806 if test -n "$DLLTOOL"; then
6807   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6808 echo "${ECHO_T}$DLLTOOL" >&6
6809 else
6810   echo "$as_me:$LINENO: result: no" >&5
6811 echo "${ECHO_T}no" >&6
6812 fi
6813
6814   fi
6815   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6816     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6817 set dummy ${ncn_progname}; ac_word=$2
6818 echo "$as_me:$LINENO: checking for $ac_word" >&5
6819 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6820 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6821   echo $ECHO_N "(cached) $ECHO_C" >&6
6822 else
6823   if test -n "$DLLTOOL"; then
6824   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6825 else
6826 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6827 for as_dir in $PATH
6828 do
6829   IFS=$as_save_IFS
6830   test -z "$as_dir" && as_dir=.
6831   for ac_exec_ext in '' $ac_executable_extensions; do
6832   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6833     ac_cv_prog_DLLTOOL="${ncn_progname}"
6834     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6835     break 2
6836   fi
6837 done
6838 done
6839
6840 fi
6841 fi
6842 DLLTOOL=$ac_cv_prog_DLLTOOL
6843 if test -n "$DLLTOOL"; then
6844   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6845 echo "${ECHO_T}$DLLTOOL" >&6
6846 else
6847   echo "$as_me:$LINENO: result: no" >&5
6848 echo "${ECHO_T}no" >&6
6849 fi
6850
6851   fi
6852   test -n "$ac_cv_prog_DLLTOOL" && break
6853 done
6854
6855 if test -z "$ac_cv_prog_DLLTOOL" ; then
6856   set dummy dlltool
6857   if test $build = $host ; then
6858     DLLTOOL="$2"
6859   else
6860     DLLTOOL="${ncn_tool_prefix}$2"
6861   fi
6862 fi
6863
6864
6865
6866 if test -n "$LD"; then
6867   ac_cv_prog_LD=$LD
6868 elif test -n "$ac_cv_prog_LD"; then
6869   LD=$ac_cv_prog_LD
6870 fi
6871
6872 if test -n "$ac_cv_prog_LD"; then
6873   for ncn_progname in ld; do
6874     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6875 set dummy ${ncn_progname}; ac_word=$2
6876 echo "$as_me:$LINENO: checking for $ac_word" >&5
6877 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6878 if test "${ac_cv_prog_LD+set}" = set; then
6879   echo $ECHO_N "(cached) $ECHO_C" >&6
6880 else
6881   if test -n "$LD"; then
6882   ac_cv_prog_LD="$LD" # Let the user override the test.
6883 else
6884 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6885 for as_dir in $PATH
6886 do
6887   IFS=$as_save_IFS
6888   test -z "$as_dir" && as_dir=.
6889   for ac_exec_ext in '' $ac_executable_extensions; do
6890   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6891     ac_cv_prog_LD="${ncn_progname}"
6892     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6893     break 2
6894   fi
6895 done
6896 done
6897
6898 fi
6899 fi
6900 LD=$ac_cv_prog_LD
6901 if test -n "$LD"; then
6902   echo "$as_me:$LINENO: result: $LD" >&5
6903 echo "${ECHO_T}$LD" >&6
6904 else
6905   echo "$as_me:$LINENO: result: no" >&5
6906 echo "${ECHO_T}no" >&6
6907 fi
6908
6909   done
6910 fi
6911
6912 for ncn_progname in ld; do
6913   if test -n "$ncn_tool_prefix"; then
6914     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6915 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6916 echo "$as_me:$LINENO: checking for $ac_word" >&5
6917 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6918 if test "${ac_cv_prog_LD+set}" = set; then
6919   echo $ECHO_N "(cached) $ECHO_C" >&6
6920 else
6921   if test -n "$LD"; then
6922   ac_cv_prog_LD="$LD" # Let the user override the test.
6923 else
6924 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6925 for as_dir in $PATH
6926 do
6927   IFS=$as_save_IFS
6928   test -z "$as_dir" && as_dir=.
6929   for ac_exec_ext in '' $ac_executable_extensions; do
6930   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6931     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6932     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6933     break 2
6934   fi
6935 done
6936 done
6937
6938 fi
6939 fi
6940 LD=$ac_cv_prog_LD
6941 if test -n "$LD"; then
6942   echo "$as_me:$LINENO: result: $LD" >&5
6943 echo "${ECHO_T}$LD" >&6
6944 else
6945   echo "$as_me:$LINENO: result: no" >&5
6946 echo "${ECHO_T}no" >&6
6947 fi
6948
6949   fi
6950   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6951     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6952 set dummy ${ncn_progname}; ac_word=$2
6953 echo "$as_me:$LINENO: checking for $ac_word" >&5
6954 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6955 if test "${ac_cv_prog_LD+set}" = set; then
6956   echo $ECHO_N "(cached) $ECHO_C" >&6
6957 else
6958   if test -n "$LD"; then
6959   ac_cv_prog_LD="$LD" # Let the user override the test.
6960 else
6961 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6962 for as_dir in $PATH
6963 do
6964   IFS=$as_save_IFS
6965   test -z "$as_dir" && as_dir=.
6966   for ac_exec_ext in '' $ac_executable_extensions; do
6967   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6968     ac_cv_prog_LD="${ncn_progname}"
6969     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6970     break 2
6971   fi
6972 done
6973 done
6974
6975 fi
6976 fi
6977 LD=$ac_cv_prog_LD
6978 if test -n "$LD"; then
6979   echo "$as_me:$LINENO: result: $LD" >&5
6980 echo "${ECHO_T}$LD" >&6
6981 else
6982   echo "$as_me:$LINENO: result: no" >&5
6983 echo "${ECHO_T}no" >&6
6984 fi
6985
6986   fi
6987   test -n "$ac_cv_prog_LD" && break
6988 done
6989
6990 if test -z "$ac_cv_prog_LD" ; then
6991   set dummy ld
6992   if test $build = $host ; then
6993     LD="$2"
6994   else
6995     LD="${ncn_tool_prefix}$2"
6996   fi
6997 fi
6998
6999
7000
7001 if test -n "$LIPO"; then
7002   ac_cv_prog_LIPO=$LIPO
7003 elif test -n "$ac_cv_prog_LIPO"; then
7004   LIPO=$ac_cv_prog_LIPO
7005 fi
7006
7007 if test -n "$ac_cv_prog_LIPO"; then
7008   for ncn_progname in lipo; do
7009     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7010 set dummy ${ncn_progname}; ac_word=$2
7011 echo "$as_me:$LINENO: checking for $ac_word" >&5
7012 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7013 if test "${ac_cv_prog_LIPO+set}" = set; then
7014   echo $ECHO_N "(cached) $ECHO_C" >&6
7015 else
7016   if test -n "$LIPO"; then
7017   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7018 else
7019 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7020 for as_dir in $PATH
7021 do
7022   IFS=$as_save_IFS
7023   test -z "$as_dir" && as_dir=.
7024   for ac_exec_ext in '' $ac_executable_extensions; do
7025   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7026     ac_cv_prog_LIPO="${ncn_progname}"
7027     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7028     break 2
7029   fi
7030 done
7031 done
7032
7033 fi
7034 fi
7035 LIPO=$ac_cv_prog_LIPO
7036 if test -n "$LIPO"; then
7037   echo "$as_me:$LINENO: result: $LIPO" >&5
7038 echo "${ECHO_T}$LIPO" >&6
7039 else
7040   echo "$as_me:$LINENO: result: no" >&5
7041 echo "${ECHO_T}no" >&6
7042 fi
7043
7044   done
7045 fi
7046
7047 for ncn_progname in lipo; do
7048   if test -n "$ncn_tool_prefix"; then
7049     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7050 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7051 echo "$as_me:$LINENO: checking for $ac_word" >&5
7052 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7053 if test "${ac_cv_prog_LIPO+set}" = set; then
7054   echo $ECHO_N "(cached) $ECHO_C" >&6
7055 else
7056   if test -n "$LIPO"; then
7057   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7058 else
7059 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7060 for as_dir in $PATH
7061 do
7062   IFS=$as_save_IFS
7063   test -z "$as_dir" && as_dir=.
7064   for ac_exec_ext in '' $ac_executable_extensions; do
7065   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7066     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7067     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7068     break 2
7069   fi
7070 done
7071 done
7072
7073 fi
7074 fi
7075 LIPO=$ac_cv_prog_LIPO
7076 if test -n "$LIPO"; then
7077   echo "$as_me:$LINENO: result: $LIPO" >&5
7078 echo "${ECHO_T}$LIPO" >&6
7079 else
7080   echo "$as_me:$LINENO: result: no" >&5
7081 echo "${ECHO_T}no" >&6
7082 fi
7083
7084   fi
7085   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7086     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7087 set dummy ${ncn_progname}; ac_word=$2
7088 echo "$as_me:$LINENO: checking for $ac_word" >&5
7089 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7090 if test "${ac_cv_prog_LIPO+set}" = set; then
7091   echo $ECHO_N "(cached) $ECHO_C" >&6
7092 else
7093   if test -n "$LIPO"; then
7094   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7095 else
7096 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7097 for as_dir in $PATH
7098 do
7099   IFS=$as_save_IFS
7100   test -z "$as_dir" && as_dir=.
7101   for ac_exec_ext in '' $ac_executable_extensions; do
7102   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7103     ac_cv_prog_LIPO="${ncn_progname}"
7104     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7105     break 2
7106   fi
7107 done
7108 done
7109
7110 fi
7111 fi
7112 LIPO=$ac_cv_prog_LIPO
7113 if test -n "$LIPO"; then
7114   echo "$as_me:$LINENO: result: $LIPO" >&5
7115 echo "${ECHO_T}$LIPO" >&6
7116 else
7117   echo "$as_me:$LINENO: result: no" >&5
7118 echo "${ECHO_T}no" >&6
7119 fi
7120
7121   fi
7122   test -n "$ac_cv_prog_LIPO" && break
7123 done
7124
7125 if test -z "$ac_cv_prog_LIPO" ; then
7126   set dummy lipo
7127   if test $build = $host ; then
7128     LIPO="$2"
7129   else
7130     LIPO="${ncn_tool_prefix}$2"
7131   fi
7132 fi
7133
7134
7135
7136 if test -n "$NM"; then
7137   ac_cv_prog_NM=$NM
7138 elif test -n "$ac_cv_prog_NM"; then
7139   NM=$ac_cv_prog_NM
7140 fi
7141
7142 if test -n "$ac_cv_prog_NM"; then
7143   for ncn_progname in nm; do
7144     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7145 set dummy ${ncn_progname}; ac_word=$2
7146 echo "$as_me:$LINENO: checking for $ac_word" >&5
7147 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7148 if test "${ac_cv_prog_NM+set}" = set; then
7149   echo $ECHO_N "(cached) $ECHO_C" >&6
7150 else
7151   if test -n "$NM"; then
7152   ac_cv_prog_NM="$NM" # Let the user override the test.
7153 else
7154 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7155 for as_dir in $PATH
7156 do
7157   IFS=$as_save_IFS
7158   test -z "$as_dir" && as_dir=.
7159   for ac_exec_ext in '' $ac_executable_extensions; do
7160   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7161     ac_cv_prog_NM="${ncn_progname}"
7162     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7163     break 2
7164   fi
7165 done
7166 done
7167
7168 fi
7169 fi
7170 NM=$ac_cv_prog_NM
7171 if test -n "$NM"; then
7172   echo "$as_me:$LINENO: result: $NM" >&5
7173 echo "${ECHO_T}$NM" >&6
7174 else
7175   echo "$as_me:$LINENO: result: no" >&5
7176 echo "${ECHO_T}no" >&6
7177 fi
7178
7179   done
7180 fi
7181
7182 for ncn_progname in nm; do
7183   if test -n "$ncn_tool_prefix"; then
7184     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7185 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7186 echo "$as_me:$LINENO: checking for $ac_word" >&5
7187 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7188 if test "${ac_cv_prog_NM+set}" = set; then
7189   echo $ECHO_N "(cached) $ECHO_C" >&6
7190 else
7191   if test -n "$NM"; then
7192   ac_cv_prog_NM="$NM" # Let the user override the test.
7193 else
7194 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7195 for as_dir in $PATH
7196 do
7197   IFS=$as_save_IFS
7198   test -z "$as_dir" && as_dir=.
7199   for ac_exec_ext in '' $ac_executable_extensions; do
7200   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7201     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7202     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7203     break 2
7204   fi
7205 done
7206 done
7207
7208 fi
7209 fi
7210 NM=$ac_cv_prog_NM
7211 if test -n "$NM"; then
7212   echo "$as_me:$LINENO: result: $NM" >&5
7213 echo "${ECHO_T}$NM" >&6
7214 else
7215   echo "$as_me:$LINENO: result: no" >&5
7216 echo "${ECHO_T}no" >&6
7217 fi
7218
7219   fi
7220   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7221     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7222 set dummy ${ncn_progname}; ac_word=$2
7223 echo "$as_me:$LINENO: checking for $ac_word" >&5
7224 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7225 if test "${ac_cv_prog_NM+set}" = set; then
7226   echo $ECHO_N "(cached) $ECHO_C" >&6
7227 else
7228   if test -n "$NM"; then
7229   ac_cv_prog_NM="$NM" # Let the user override the test.
7230 else
7231 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7232 for as_dir in $PATH
7233 do
7234   IFS=$as_save_IFS
7235   test -z "$as_dir" && as_dir=.
7236   for ac_exec_ext in '' $ac_executable_extensions; do
7237   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7238     ac_cv_prog_NM="${ncn_progname}"
7239     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7240     break 2
7241   fi
7242 done
7243 done
7244
7245 fi
7246 fi
7247 NM=$ac_cv_prog_NM
7248 if test -n "$NM"; then
7249   echo "$as_me:$LINENO: result: $NM" >&5
7250 echo "${ECHO_T}$NM" >&6
7251 else
7252   echo "$as_me:$LINENO: result: no" >&5
7253 echo "${ECHO_T}no" >&6
7254 fi
7255
7256   fi
7257   test -n "$ac_cv_prog_NM" && break
7258 done
7259
7260 if test -z "$ac_cv_prog_NM" ; then
7261   set dummy nm
7262   if test $build = $host ; then
7263     NM="$2"
7264   else
7265     NM="${ncn_tool_prefix}$2"
7266   fi
7267 fi
7268
7269
7270
7271 if test -n "$RANLIB"; then
7272   ac_cv_prog_RANLIB=$RANLIB
7273 elif test -n "$ac_cv_prog_RANLIB"; then
7274   RANLIB=$ac_cv_prog_RANLIB
7275 fi
7276
7277 if test -n "$ac_cv_prog_RANLIB"; then
7278   for ncn_progname in ranlib; do
7279     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7280 set dummy ${ncn_progname}; ac_word=$2
7281 echo "$as_me:$LINENO: checking for $ac_word" >&5
7282 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7283 if test "${ac_cv_prog_RANLIB+set}" = set; then
7284   echo $ECHO_N "(cached) $ECHO_C" >&6
7285 else
7286   if test -n "$RANLIB"; then
7287   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7288 else
7289 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7290 for as_dir in $PATH
7291 do
7292   IFS=$as_save_IFS
7293   test -z "$as_dir" && as_dir=.
7294   for ac_exec_ext in '' $ac_executable_extensions; do
7295   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7296     ac_cv_prog_RANLIB="${ncn_progname}"
7297     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7298     break 2
7299   fi
7300 done
7301 done
7302
7303 fi
7304 fi
7305 RANLIB=$ac_cv_prog_RANLIB
7306 if test -n "$RANLIB"; then
7307   echo "$as_me:$LINENO: result: $RANLIB" >&5
7308 echo "${ECHO_T}$RANLIB" >&6
7309 else
7310   echo "$as_me:$LINENO: result: no" >&5
7311 echo "${ECHO_T}no" >&6
7312 fi
7313
7314   done
7315 fi
7316
7317 for ncn_progname in ranlib; do
7318   if test -n "$ncn_tool_prefix"; then
7319     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7320 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7321 echo "$as_me:$LINENO: checking for $ac_word" >&5
7322 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7323 if test "${ac_cv_prog_RANLIB+set}" = set; then
7324   echo $ECHO_N "(cached) $ECHO_C" >&6
7325 else
7326   if test -n "$RANLIB"; then
7327   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7328 else
7329 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7330 for as_dir in $PATH
7331 do
7332   IFS=$as_save_IFS
7333   test -z "$as_dir" && as_dir=.
7334   for ac_exec_ext in '' $ac_executable_extensions; do
7335   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7336     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7337     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7338     break 2
7339   fi
7340 done
7341 done
7342
7343 fi
7344 fi
7345 RANLIB=$ac_cv_prog_RANLIB
7346 if test -n "$RANLIB"; then
7347   echo "$as_me:$LINENO: result: $RANLIB" >&5
7348 echo "${ECHO_T}$RANLIB" >&6
7349 else
7350   echo "$as_me:$LINENO: result: no" >&5
7351 echo "${ECHO_T}no" >&6
7352 fi
7353
7354   fi
7355   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7356     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7357 set dummy ${ncn_progname}; ac_word=$2
7358 echo "$as_me:$LINENO: checking for $ac_word" >&5
7359 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7360 if test "${ac_cv_prog_RANLIB+set}" = set; then
7361   echo $ECHO_N "(cached) $ECHO_C" >&6
7362 else
7363   if test -n "$RANLIB"; then
7364   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7365 else
7366 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7367 for as_dir in $PATH
7368 do
7369   IFS=$as_save_IFS
7370   test -z "$as_dir" && as_dir=.
7371   for ac_exec_ext in '' $ac_executable_extensions; do
7372   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7373     ac_cv_prog_RANLIB="${ncn_progname}"
7374     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7375     break 2
7376   fi
7377 done
7378 done
7379
7380 fi
7381 fi
7382 RANLIB=$ac_cv_prog_RANLIB
7383 if test -n "$RANLIB"; then
7384   echo "$as_me:$LINENO: result: $RANLIB" >&5
7385 echo "${ECHO_T}$RANLIB" >&6
7386 else
7387   echo "$as_me:$LINENO: result: no" >&5
7388 echo "${ECHO_T}no" >&6
7389 fi
7390
7391   fi
7392   test -n "$ac_cv_prog_RANLIB" && break
7393 done
7394
7395 if test -z "$ac_cv_prog_RANLIB" ; then
7396   RANLIB=":"
7397 fi
7398
7399
7400
7401 if test -n "$STRIP"; then
7402   ac_cv_prog_STRIP=$STRIP
7403 elif test -n "$ac_cv_prog_STRIP"; then
7404   STRIP=$ac_cv_prog_STRIP
7405 fi
7406
7407 if test -n "$ac_cv_prog_STRIP"; then
7408   for ncn_progname in strip; do
7409     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7410 set dummy ${ncn_progname}; ac_word=$2
7411 echo "$as_me:$LINENO: checking for $ac_word" >&5
7412 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7413 if test "${ac_cv_prog_STRIP+set}" = set; then
7414   echo $ECHO_N "(cached) $ECHO_C" >&6
7415 else
7416   if test -n "$STRIP"; then
7417   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7418 else
7419 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7420 for as_dir in $PATH
7421 do
7422   IFS=$as_save_IFS
7423   test -z "$as_dir" && as_dir=.
7424   for ac_exec_ext in '' $ac_executable_extensions; do
7425   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7426     ac_cv_prog_STRIP="${ncn_progname}"
7427     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7428     break 2
7429   fi
7430 done
7431 done
7432
7433 fi
7434 fi
7435 STRIP=$ac_cv_prog_STRIP
7436 if test -n "$STRIP"; then
7437   echo "$as_me:$LINENO: result: $STRIP" >&5
7438 echo "${ECHO_T}$STRIP" >&6
7439 else
7440   echo "$as_me:$LINENO: result: no" >&5
7441 echo "${ECHO_T}no" >&6
7442 fi
7443
7444   done
7445 fi
7446
7447 for ncn_progname in strip; do
7448   if test -n "$ncn_tool_prefix"; then
7449     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7450 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7451 echo "$as_me:$LINENO: checking for $ac_word" >&5
7452 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7453 if test "${ac_cv_prog_STRIP+set}" = set; then
7454   echo $ECHO_N "(cached) $ECHO_C" >&6
7455 else
7456   if test -n "$STRIP"; then
7457   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7458 else
7459 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7460 for as_dir in $PATH
7461 do
7462   IFS=$as_save_IFS
7463   test -z "$as_dir" && as_dir=.
7464   for ac_exec_ext in '' $ac_executable_extensions; do
7465   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7466     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7467     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7468     break 2
7469   fi
7470 done
7471 done
7472
7473 fi
7474 fi
7475 STRIP=$ac_cv_prog_STRIP
7476 if test -n "$STRIP"; then
7477   echo "$as_me:$LINENO: result: $STRIP" >&5
7478 echo "${ECHO_T}$STRIP" >&6
7479 else
7480   echo "$as_me:$LINENO: result: no" >&5
7481 echo "${ECHO_T}no" >&6
7482 fi
7483
7484   fi
7485   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7486     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7487 set dummy ${ncn_progname}; ac_word=$2
7488 echo "$as_me:$LINENO: checking for $ac_word" >&5
7489 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7490 if test "${ac_cv_prog_STRIP+set}" = set; then
7491   echo $ECHO_N "(cached) $ECHO_C" >&6
7492 else
7493   if test -n "$STRIP"; then
7494   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7495 else
7496 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7497 for as_dir in $PATH
7498 do
7499   IFS=$as_save_IFS
7500   test -z "$as_dir" && as_dir=.
7501   for ac_exec_ext in '' $ac_executable_extensions; do
7502   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7503     ac_cv_prog_STRIP="${ncn_progname}"
7504     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7505     break 2
7506   fi
7507 done
7508 done
7509
7510 fi
7511 fi
7512 STRIP=$ac_cv_prog_STRIP
7513 if test -n "$STRIP"; then
7514   echo "$as_me:$LINENO: result: $STRIP" >&5
7515 echo "${ECHO_T}$STRIP" >&6
7516 else
7517   echo "$as_me:$LINENO: result: no" >&5
7518 echo "${ECHO_T}no" >&6
7519 fi
7520
7521   fi
7522   test -n "$ac_cv_prog_STRIP" && break
7523 done
7524
7525 if test -z "$ac_cv_prog_STRIP" ; then
7526   STRIP=":"
7527 fi
7528
7529
7530
7531 if test -n "$WINDRES"; then
7532   ac_cv_prog_WINDRES=$WINDRES
7533 elif test -n "$ac_cv_prog_WINDRES"; then
7534   WINDRES=$ac_cv_prog_WINDRES
7535 fi
7536
7537 if test -n "$ac_cv_prog_WINDRES"; then
7538   for ncn_progname in windres; do
7539     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7540 set dummy ${ncn_progname}; ac_word=$2
7541 echo "$as_me:$LINENO: checking for $ac_word" >&5
7542 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7543 if test "${ac_cv_prog_WINDRES+set}" = set; then
7544   echo $ECHO_N "(cached) $ECHO_C" >&6
7545 else
7546   if test -n "$WINDRES"; then
7547   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7548 else
7549 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7550 for as_dir in $PATH
7551 do
7552   IFS=$as_save_IFS
7553   test -z "$as_dir" && as_dir=.
7554   for ac_exec_ext in '' $ac_executable_extensions; do
7555   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7556     ac_cv_prog_WINDRES="${ncn_progname}"
7557     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7558     break 2
7559   fi
7560 done
7561 done
7562
7563 fi
7564 fi
7565 WINDRES=$ac_cv_prog_WINDRES
7566 if test -n "$WINDRES"; then
7567   echo "$as_me:$LINENO: result: $WINDRES" >&5
7568 echo "${ECHO_T}$WINDRES" >&6
7569 else
7570   echo "$as_me:$LINENO: result: no" >&5
7571 echo "${ECHO_T}no" >&6
7572 fi
7573
7574   done
7575 fi
7576
7577 for ncn_progname in windres; do
7578   if test -n "$ncn_tool_prefix"; then
7579     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7580 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7581 echo "$as_me:$LINENO: checking for $ac_word" >&5
7582 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7583 if test "${ac_cv_prog_WINDRES+set}" = set; then
7584   echo $ECHO_N "(cached) $ECHO_C" >&6
7585 else
7586   if test -n "$WINDRES"; then
7587   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7588 else
7589 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7590 for as_dir in $PATH
7591 do
7592   IFS=$as_save_IFS
7593   test -z "$as_dir" && as_dir=.
7594   for ac_exec_ext in '' $ac_executable_extensions; do
7595   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7596     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7597     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7598     break 2
7599   fi
7600 done
7601 done
7602
7603 fi
7604 fi
7605 WINDRES=$ac_cv_prog_WINDRES
7606 if test -n "$WINDRES"; then
7607   echo "$as_me:$LINENO: result: $WINDRES" >&5
7608 echo "${ECHO_T}$WINDRES" >&6
7609 else
7610   echo "$as_me:$LINENO: result: no" >&5
7611 echo "${ECHO_T}no" >&6
7612 fi
7613
7614   fi
7615   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7616     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7617 set dummy ${ncn_progname}; ac_word=$2
7618 echo "$as_me:$LINENO: checking for $ac_word" >&5
7619 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7620 if test "${ac_cv_prog_WINDRES+set}" = set; then
7621   echo $ECHO_N "(cached) $ECHO_C" >&6
7622 else
7623   if test -n "$WINDRES"; then
7624   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7625 else
7626 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7627 for as_dir in $PATH
7628 do
7629   IFS=$as_save_IFS
7630   test -z "$as_dir" && as_dir=.
7631   for ac_exec_ext in '' $ac_executable_extensions; do
7632   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7633     ac_cv_prog_WINDRES="${ncn_progname}"
7634     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7635     break 2
7636   fi
7637 done
7638 done
7639
7640 fi
7641 fi
7642 WINDRES=$ac_cv_prog_WINDRES
7643 if test -n "$WINDRES"; then
7644   echo "$as_me:$LINENO: result: $WINDRES" >&5
7645 echo "${ECHO_T}$WINDRES" >&6
7646 else
7647   echo "$as_me:$LINENO: result: no" >&5
7648 echo "${ECHO_T}no" >&6
7649 fi
7650
7651   fi
7652   test -n "$ac_cv_prog_WINDRES" && break
7653 done
7654
7655 if test -z "$ac_cv_prog_WINDRES" ; then
7656   set dummy windres
7657   if test $build = $host ; then
7658     WINDRES="$2"
7659   else
7660     WINDRES="${ncn_tool_prefix}$2"
7661   fi
7662 fi
7663
7664
7665
7666 if test -n "$WINDMC"; then
7667   ac_cv_prog_WINDMC=$WINDMC
7668 elif test -n "$ac_cv_prog_WINDMC"; then
7669   WINDMC=$ac_cv_prog_WINDMC
7670 fi
7671
7672 if test -n "$ac_cv_prog_WINDMC"; then
7673   for ncn_progname in windmc; do
7674     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7675 set dummy ${ncn_progname}; ac_word=$2
7676 echo "$as_me:$LINENO: checking for $ac_word" >&5
7677 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7678 if test "${ac_cv_prog_WINDMC+set}" = set; then
7679   echo $ECHO_N "(cached) $ECHO_C" >&6
7680 else
7681   if test -n "$WINDMC"; then
7682   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7683 else
7684 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7685 for as_dir in $PATH
7686 do
7687   IFS=$as_save_IFS
7688   test -z "$as_dir" && as_dir=.
7689   for ac_exec_ext in '' $ac_executable_extensions; do
7690   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7691     ac_cv_prog_WINDMC="${ncn_progname}"
7692     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7693     break 2
7694   fi
7695 done
7696 done
7697
7698 fi
7699 fi
7700 WINDMC=$ac_cv_prog_WINDMC
7701 if test -n "$WINDMC"; then
7702   echo "$as_me:$LINENO: result: $WINDMC" >&5
7703 echo "${ECHO_T}$WINDMC" >&6
7704 else
7705   echo "$as_me:$LINENO: result: no" >&5
7706 echo "${ECHO_T}no" >&6
7707 fi
7708
7709   done
7710 fi
7711
7712 for ncn_progname in windmc; do
7713   if test -n "$ncn_tool_prefix"; then
7714     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7715 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7716 echo "$as_me:$LINENO: checking for $ac_word" >&5
7717 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7718 if test "${ac_cv_prog_WINDMC+set}" = set; then
7719   echo $ECHO_N "(cached) $ECHO_C" >&6
7720 else
7721   if test -n "$WINDMC"; then
7722   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7723 else
7724 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7725 for as_dir in $PATH
7726 do
7727   IFS=$as_save_IFS
7728   test -z "$as_dir" && as_dir=.
7729   for ac_exec_ext in '' $ac_executable_extensions; do
7730   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7731     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7732     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7733     break 2
7734   fi
7735 done
7736 done
7737
7738 fi
7739 fi
7740 WINDMC=$ac_cv_prog_WINDMC
7741 if test -n "$WINDMC"; then
7742   echo "$as_me:$LINENO: result: $WINDMC" >&5
7743 echo "${ECHO_T}$WINDMC" >&6
7744 else
7745   echo "$as_me:$LINENO: result: no" >&5
7746 echo "${ECHO_T}no" >&6
7747 fi
7748
7749   fi
7750   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7751     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7752 set dummy ${ncn_progname}; ac_word=$2
7753 echo "$as_me:$LINENO: checking for $ac_word" >&5
7754 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7755 if test "${ac_cv_prog_WINDMC+set}" = set; then
7756   echo $ECHO_N "(cached) $ECHO_C" >&6
7757 else
7758   if test -n "$WINDMC"; then
7759   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7760 else
7761 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7762 for as_dir in $PATH
7763 do
7764   IFS=$as_save_IFS
7765   test -z "$as_dir" && as_dir=.
7766   for ac_exec_ext in '' $ac_executable_extensions; do
7767   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7768     ac_cv_prog_WINDMC="${ncn_progname}"
7769     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7770     break 2
7771   fi
7772 done
7773 done
7774
7775 fi
7776 fi
7777 WINDMC=$ac_cv_prog_WINDMC
7778 if test -n "$WINDMC"; then
7779   echo "$as_me:$LINENO: result: $WINDMC" >&5
7780 echo "${ECHO_T}$WINDMC" >&6
7781 else
7782   echo "$as_me:$LINENO: result: no" >&5
7783 echo "${ECHO_T}no" >&6
7784 fi
7785
7786   fi
7787   test -n "$ac_cv_prog_WINDMC" && break
7788 done
7789
7790 if test -z "$ac_cv_prog_WINDMC" ; then
7791   set dummy windmc
7792   if test $build = $host ; then
7793     WINDMC="$2"
7794   else
7795     WINDMC="${ncn_tool_prefix}$2"
7796   fi
7797 fi
7798
7799
7800
7801 if test -n "$OBJCOPY"; then
7802   ac_cv_prog_OBJCOPY=$OBJCOPY
7803 elif test -n "$ac_cv_prog_OBJCOPY"; then
7804   OBJCOPY=$ac_cv_prog_OBJCOPY
7805 fi
7806
7807 if test -n "$ac_cv_prog_OBJCOPY"; then
7808   for ncn_progname in objcopy; do
7809     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7810 set dummy ${ncn_progname}; ac_word=$2
7811 echo "$as_me:$LINENO: checking for $ac_word" >&5
7812 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7813 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7814   echo $ECHO_N "(cached) $ECHO_C" >&6
7815 else
7816   if test -n "$OBJCOPY"; then
7817   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7818 else
7819 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7820 for as_dir in $PATH
7821 do
7822   IFS=$as_save_IFS
7823   test -z "$as_dir" && as_dir=.
7824   for ac_exec_ext in '' $ac_executable_extensions; do
7825   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7826     ac_cv_prog_OBJCOPY="${ncn_progname}"
7827     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7828     break 2
7829   fi
7830 done
7831 done
7832
7833 fi
7834 fi
7835 OBJCOPY=$ac_cv_prog_OBJCOPY
7836 if test -n "$OBJCOPY"; then
7837   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7838 echo "${ECHO_T}$OBJCOPY" >&6
7839 else
7840   echo "$as_me:$LINENO: result: no" >&5
7841 echo "${ECHO_T}no" >&6
7842 fi
7843
7844   done
7845 fi
7846
7847 for ncn_progname in objcopy; do
7848   if test -n "$ncn_tool_prefix"; then
7849     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7850 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7851 echo "$as_me:$LINENO: checking for $ac_word" >&5
7852 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7853 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7854   echo $ECHO_N "(cached) $ECHO_C" >&6
7855 else
7856   if test -n "$OBJCOPY"; then
7857   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7858 else
7859 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7860 for as_dir in $PATH
7861 do
7862   IFS=$as_save_IFS
7863   test -z "$as_dir" && as_dir=.
7864   for ac_exec_ext in '' $ac_executable_extensions; do
7865   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7866     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7867     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7868     break 2
7869   fi
7870 done
7871 done
7872
7873 fi
7874 fi
7875 OBJCOPY=$ac_cv_prog_OBJCOPY
7876 if test -n "$OBJCOPY"; then
7877   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7878 echo "${ECHO_T}$OBJCOPY" >&6
7879 else
7880   echo "$as_me:$LINENO: result: no" >&5
7881 echo "${ECHO_T}no" >&6
7882 fi
7883
7884   fi
7885   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7886     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7887 set dummy ${ncn_progname}; ac_word=$2
7888 echo "$as_me:$LINENO: checking for $ac_word" >&5
7889 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7890 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7891   echo $ECHO_N "(cached) $ECHO_C" >&6
7892 else
7893   if test -n "$OBJCOPY"; then
7894   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7895 else
7896 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7897 for as_dir in $PATH
7898 do
7899   IFS=$as_save_IFS
7900   test -z "$as_dir" && as_dir=.
7901   for ac_exec_ext in '' $ac_executable_extensions; do
7902   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7903     ac_cv_prog_OBJCOPY="${ncn_progname}"
7904     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7905     break 2
7906   fi
7907 done
7908 done
7909
7910 fi
7911 fi
7912 OBJCOPY=$ac_cv_prog_OBJCOPY
7913 if test -n "$OBJCOPY"; then
7914   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7915 echo "${ECHO_T}$OBJCOPY" >&6
7916 else
7917   echo "$as_me:$LINENO: result: no" >&5
7918 echo "${ECHO_T}no" >&6
7919 fi
7920
7921   fi
7922   test -n "$ac_cv_prog_OBJCOPY" && break
7923 done
7924
7925 if test -z "$ac_cv_prog_OBJCOPY" ; then
7926   set dummy objcopy
7927   if test $build = $host ; then
7928     OBJCOPY="$2"
7929   else
7930     OBJCOPY="${ncn_tool_prefix}$2"
7931   fi
7932 fi
7933
7934
7935
7936 if test -n "$OBJDUMP"; then
7937   ac_cv_prog_OBJDUMP=$OBJDUMP
7938 elif test -n "$ac_cv_prog_OBJDUMP"; then
7939   OBJDUMP=$ac_cv_prog_OBJDUMP
7940 fi
7941
7942 if test -n "$ac_cv_prog_OBJDUMP"; then
7943   for ncn_progname in objdump; do
7944     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7945 set dummy ${ncn_progname}; ac_word=$2
7946 echo "$as_me:$LINENO: checking for $ac_word" >&5
7947 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7948 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7949   echo $ECHO_N "(cached) $ECHO_C" >&6
7950 else
7951   if test -n "$OBJDUMP"; then
7952   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7953 else
7954 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7955 for as_dir in $PATH
7956 do
7957   IFS=$as_save_IFS
7958   test -z "$as_dir" && as_dir=.
7959   for ac_exec_ext in '' $ac_executable_extensions; do
7960   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7961     ac_cv_prog_OBJDUMP="${ncn_progname}"
7962     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7963     break 2
7964   fi
7965 done
7966 done
7967
7968 fi
7969 fi
7970 OBJDUMP=$ac_cv_prog_OBJDUMP
7971 if test -n "$OBJDUMP"; then
7972   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7973 echo "${ECHO_T}$OBJDUMP" >&6
7974 else
7975   echo "$as_me:$LINENO: result: no" >&5
7976 echo "${ECHO_T}no" >&6
7977 fi
7978
7979   done
7980 fi
7981
7982 for ncn_progname in objdump; do
7983   if test -n "$ncn_tool_prefix"; then
7984     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7985 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7986 echo "$as_me:$LINENO: checking for $ac_word" >&5
7987 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7988 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7989   echo $ECHO_N "(cached) $ECHO_C" >&6
7990 else
7991   if test -n "$OBJDUMP"; then
7992   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7993 else
7994 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7995 for as_dir in $PATH
7996 do
7997   IFS=$as_save_IFS
7998   test -z "$as_dir" && as_dir=.
7999   for ac_exec_ext in '' $ac_executable_extensions; do
8000   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8001     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8002     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8003     break 2
8004   fi
8005 done
8006 done
8007
8008 fi
8009 fi
8010 OBJDUMP=$ac_cv_prog_OBJDUMP
8011 if test -n "$OBJDUMP"; then
8012   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8013 echo "${ECHO_T}$OBJDUMP" >&6
8014 else
8015   echo "$as_me:$LINENO: result: no" >&5
8016 echo "${ECHO_T}no" >&6
8017 fi
8018
8019   fi
8020   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8021     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8022 set dummy ${ncn_progname}; ac_word=$2
8023 echo "$as_me:$LINENO: checking for $ac_word" >&5
8024 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8025 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8026   echo $ECHO_N "(cached) $ECHO_C" >&6
8027 else
8028   if test -n "$OBJDUMP"; then
8029   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8030 else
8031 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8032 for as_dir in $PATH
8033 do
8034   IFS=$as_save_IFS
8035   test -z "$as_dir" && as_dir=.
8036   for ac_exec_ext in '' $ac_executable_extensions; do
8037   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8038     ac_cv_prog_OBJDUMP="${ncn_progname}"
8039     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8040     break 2
8041   fi
8042 done
8043 done
8044
8045 fi
8046 fi
8047 OBJDUMP=$ac_cv_prog_OBJDUMP
8048 if test -n "$OBJDUMP"; then
8049   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8050 echo "${ECHO_T}$OBJDUMP" >&6
8051 else
8052   echo "$as_me:$LINENO: result: no" >&5
8053 echo "${ECHO_T}no" >&6
8054 fi
8055
8056   fi
8057   test -n "$ac_cv_prog_OBJDUMP" && break
8058 done
8059
8060 if test -z "$ac_cv_prog_OBJDUMP" ; then
8061   set dummy objdump
8062   if test $build = $host ; then
8063     OBJDUMP="$2"
8064   else
8065     OBJDUMP="${ncn_tool_prefix}$2"
8066   fi
8067 fi
8068
8069
8070
8071
8072
8073
8074 # Target tools.
8075
8076 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8077 if test "${with_build_time_tools+set}" = set; then
8078   withval="$with_build_time_tools"
8079   case x"$withval" in
8080      x/*) ;;
8081      *)
8082        with_build_time_tools=
8083        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8084 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8085        ;;
8086    esac
8087 else
8088   with_build_time_tools=
8089 fi;
8090
8091
8092
8093 if test -n "$CC_FOR_TARGET"; then
8094   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8095 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8096   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8097 fi
8098
8099 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8100   for ncn_progname in cc gcc; do
8101     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8102 set dummy ${ncn_progname}; ac_word=$2
8103 echo "$as_me:$LINENO: checking for $ac_word" >&5
8104 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8105 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8106   echo $ECHO_N "(cached) $ECHO_C" >&6
8107 else
8108   if test -n "$CC_FOR_TARGET"; then
8109   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8110 else
8111 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8112 for as_dir in $PATH
8113 do
8114   IFS=$as_save_IFS
8115   test -z "$as_dir" && as_dir=.
8116   for ac_exec_ext in '' $ac_executable_extensions; do
8117   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8118     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8119     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8120     break 2
8121   fi
8122 done
8123 done
8124
8125 fi
8126 fi
8127 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8128 if test -n "$CC_FOR_TARGET"; then
8129   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8130 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8131 else
8132   echo "$as_me:$LINENO: result: no" >&5
8133 echo "${ECHO_T}no" >&6
8134 fi
8135
8136   done
8137 fi
8138
8139 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8140   for ncn_progname in cc gcc; do
8141     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8142 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8143     if test -x $with_build_time_tools/${ncn_progname}; then
8144       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8145       echo "$as_me:$LINENO: result: yes" >&5
8146 echo "${ECHO_T}yes" >&6
8147       break
8148     else
8149       echo "$as_me:$LINENO: result: no" >&5
8150 echo "${ECHO_T}no" >&6
8151     fi
8152   done
8153 fi
8154
8155 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8156   for ncn_progname in cc gcc; do
8157     if test -n "$ncn_target_tool_prefix"; then
8158       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8159 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8160 echo "$as_me:$LINENO: checking for $ac_word" >&5
8161 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8162 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8163   echo $ECHO_N "(cached) $ECHO_C" >&6
8164 else
8165   if test -n "$CC_FOR_TARGET"; then
8166   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8167 else
8168 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8169 for as_dir in $PATH
8170 do
8171   IFS=$as_save_IFS
8172   test -z "$as_dir" && as_dir=.
8173   for ac_exec_ext in '' $ac_executable_extensions; do
8174   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8175     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8176     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8177     break 2
8178   fi
8179 done
8180 done
8181
8182 fi
8183 fi
8184 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8185 if test -n "$CC_FOR_TARGET"; then
8186   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8187 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8188 else
8189   echo "$as_me:$LINENO: result: no" >&5
8190 echo "${ECHO_T}no" >&6
8191 fi
8192
8193     fi
8194     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8195       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8196 set dummy ${ncn_progname}; ac_word=$2
8197 echo "$as_me:$LINENO: checking for $ac_word" >&5
8198 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8199 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8200   echo $ECHO_N "(cached) $ECHO_C" >&6
8201 else
8202   if test -n "$CC_FOR_TARGET"; then
8203   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8204 else
8205 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8206 for as_dir in $PATH
8207 do
8208   IFS=$as_save_IFS
8209   test -z "$as_dir" && as_dir=.
8210   for ac_exec_ext in '' $ac_executable_extensions; do
8211   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8212     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8213     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8214     break 2
8215   fi
8216 done
8217 done
8218
8219 fi
8220 fi
8221 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8222 if test -n "$CC_FOR_TARGET"; then
8223   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8224 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8225 else
8226   echo "$as_me:$LINENO: result: no" >&5
8227 echo "${ECHO_T}no" >&6
8228 fi
8229
8230     fi
8231     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8232   done
8233 fi
8234
8235 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8236   set dummy cc gcc
8237   if test $build = $target ; then
8238     CC_FOR_TARGET="$2"
8239   else
8240     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8241   fi
8242 else
8243   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8244 fi
8245
8246
8247
8248 if test -n "$CXX_FOR_TARGET"; then
8249   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8250 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8251   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8252 fi
8253
8254 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8255   for ncn_progname in c++ g++ cxx gxx; do
8256     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8257 set dummy ${ncn_progname}; ac_word=$2
8258 echo "$as_me:$LINENO: checking for $ac_word" >&5
8259 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8260 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8261   echo $ECHO_N "(cached) $ECHO_C" >&6
8262 else
8263   if test -n "$CXX_FOR_TARGET"; then
8264   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8265 else
8266 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8267 for as_dir in $PATH
8268 do
8269   IFS=$as_save_IFS
8270   test -z "$as_dir" && as_dir=.
8271   for ac_exec_ext in '' $ac_executable_extensions; do
8272   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8273     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8274     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8275     break 2
8276   fi
8277 done
8278 done
8279
8280 fi
8281 fi
8282 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8283 if test -n "$CXX_FOR_TARGET"; then
8284   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8285 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8286 else
8287   echo "$as_me:$LINENO: result: no" >&5
8288 echo "${ECHO_T}no" >&6
8289 fi
8290
8291   done
8292 fi
8293
8294 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8295   for ncn_progname in c++ g++ cxx gxx; do
8296     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8297 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8298     if test -x $with_build_time_tools/${ncn_progname}; then
8299       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8300       echo "$as_me:$LINENO: result: yes" >&5
8301 echo "${ECHO_T}yes" >&6
8302       break
8303     else
8304       echo "$as_me:$LINENO: result: no" >&5
8305 echo "${ECHO_T}no" >&6
8306     fi
8307   done
8308 fi
8309
8310 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8311   for ncn_progname in c++ g++ cxx gxx; do
8312     if test -n "$ncn_target_tool_prefix"; then
8313       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8314 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8315 echo "$as_me:$LINENO: checking for $ac_word" >&5
8316 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8317 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8318   echo $ECHO_N "(cached) $ECHO_C" >&6
8319 else
8320   if test -n "$CXX_FOR_TARGET"; then
8321   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8322 else
8323 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8324 for as_dir in $PATH
8325 do
8326   IFS=$as_save_IFS
8327   test -z "$as_dir" && as_dir=.
8328   for ac_exec_ext in '' $ac_executable_extensions; do
8329   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8330     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8331     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8332     break 2
8333   fi
8334 done
8335 done
8336
8337 fi
8338 fi
8339 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8340 if test -n "$CXX_FOR_TARGET"; then
8341   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8342 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8343 else
8344   echo "$as_me:$LINENO: result: no" >&5
8345 echo "${ECHO_T}no" >&6
8346 fi
8347
8348     fi
8349     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8350       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8351 set dummy ${ncn_progname}; ac_word=$2
8352 echo "$as_me:$LINENO: checking for $ac_word" >&5
8353 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8354 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8355   echo $ECHO_N "(cached) $ECHO_C" >&6
8356 else
8357   if test -n "$CXX_FOR_TARGET"; then
8358   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8359 else
8360 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8361 for as_dir in $PATH
8362 do
8363   IFS=$as_save_IFS
8364   test -z "$as_dir" && as_dir=.
8365   for ac_exec_ext in '' $ac_executable_extensions; do
8366   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8367     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8368     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8369     break 2
8370   fi
8371 done
8372 done
8373
8374 fi
8375 fi
8376 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8377 if test -n "$CXX_FOR_TARGET"; then
8378   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8379 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8380 else
8381   echo "$as_me:$LINENO: result: no" >&5
8382 echo "${ECHO_T}no" >&6
8383 fi
8384
8385     fi
8386     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8387   done
8388 fi
8389
8390 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8391   set dummy c++ g++ cxx gxx
8392   if test $build = $target ; then
8393     CXX_FOR_TARGET="$2"
8394   else
8395     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8396   fi
8397 else
8398   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8399 fi
8400
8401
8402
8403 if test -n "$GCC_FOR_TARGET"; then
8404   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8405 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8406   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8407 fi
8408
8409 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8410   for ncn_progname in gcc; do
8411     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8412 set dummy ${ncn_progname}; ac_word=$2
8413 echo "$as_me:$LINENO: checking for $ac_word" >&5
8414 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8415 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8416   echo $ECHO_N "(cached) $ECHO_C" >&6
8417 else
8418   if test -n "$GCC_FOR_TARGET"; then
8419   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8420 else
8421 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8422 for as_dir in $PATH
8423 do
8424   IFS=$as_save_IFS
8425   test -z "$as_dir" && as_dir=.
8426   for ac_exec_ext in '' $ac_executable_extensions; do
8427   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8428     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8429     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8430     break 2
8431   fi
8432 done
8433 done
8434
8435 fi
8436 fi
8437 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8438 if test -n "$GCC_FOR_TARGET"; then
8439   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8440 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8441 else
8442   echo "$as_me:$LINENO: result: no" >&5
8443 echo "${ECHO_T}no" >&6
8444 fi
8445
8446   done
8447 fi
8448
8449 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8450   for ncn_progname in gcc; do
8451     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8452 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8453     if test -x $with_build_time_tools/${ncn_progname}; then
8454       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8455       echo "$as_me:$LINENO: result: yes" >&5
8456 echo "${ECHO_T}yes" >&6
8457       break
8458     else
8459       echo "$as_me:$LINENO: result: no" >&5
8460 echo "${ECHO_T}no" >&6
8461     fi
8462   done
8463 fi
8464
8465 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8466   for ncn_progname in gcc; do
8467     if test -n "$ncn_target_tool_prefix"; then
8468       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8469 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8470 echo "$as_me:$LINENO: checking for $ac_word" >&5
8471 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8472 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8473   echo $ECHO_N "(cached) $ECHO_C" >&6
8474 else
8475   if test -n "$GCC_FOR_TARGET"; then
8476   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8477 else
8478 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8479 for as_dir in $PATH
8480 do
8481   IFS=$as_save_IFS
8482   test -z "$as_dir" && as_dir=.
8483   for ac_exec_ext in '' $ac_executable_extensions; do
8484   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8485     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8486     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8487     break 2
8488   fi
8489 done
8490 done
8491
8492 fi
8493 fi
8494 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8495 if test -n "$GCC_FOR_TARGET"; then
8496   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8497 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8498 else
8499   echo "$as_me:$LINENO: result: no" >&5
8500 echo "${ECHO_T}no" >&6
8501 fi
8502
8503     fi
8504     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8505       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8506 set dummy ${ncn_progname}; ac_word=$2
8507 echo "$as_me:$LINENO: checking for $ac_word" >&5
8508 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8509 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8510   echo $ECHO_N "(cached) $ECHO_C" >&6
8511 else
8512   if test -n "$GCC_FOR_TARGET"; then
8513   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8514 else
8515 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8516 for as_dir in $PATH
8517 do
8518   IFS=$as_save_IFS
8519   test -z "$as_dir" && as_dir=.
8520   for ac_exec_ext in '' $ac_executable_extensions; do
8521   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8522     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8523     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8524     break 2
8525   fi
8526 done
8527 done
8528
8529 fi
8530 fi
8531 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8532 if test -n "$GCC_FOR_TARGET"; then
8533   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8534 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8535 else
8536   echo "$as_me:$LINENO: result: no" >&5
8537 echo "${ECHO_T}no" >&6
8538 fi
8539
8540     fi
8541     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8542   done
8543 fi
8544
8545 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8546   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8547 else
8548   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8549 fi
8550
8551
8552
8553 if test -n "$GCJ_FOR_TARGET"; then
8554   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8555 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8556   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8557 fi
8558
8559 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8560   for ncn_progname in gcj; do
8561     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8562 set dummy ${ncn_progname}; ac_word=$2
8563 echo "$as_me:$LINENO: checking for $ac_word" >&5
8564 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8565 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8566   echo $ECHO_N "(cached) $ECHO_C" >&6
8567 else
8568   if test -n "$GCJ_FOR_TARGET"; then
8569   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8570 else
8571 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8572 for as_dir in $PATH
8573 do
8574   IFS=$as_save_IFS
8575   test -z "$as_dir" && as_dir=.
8576   for ac_exec_ext in '' $ac_executable_extensions; do
8577   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8578     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8579     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8580     break 2
8581   fi
8582 done
8583 done
8584
8585 fi
8586 fi
8587 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8588 if test -n "$GCJ_FOR_TARGET"; then
8589   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8590 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8591 else
8592   echo "$as_me:$LINENO: result: no" >&5
8593 echo "${ECHO_T}no" >&6
8594 fi
8595
8596   done
8597 fi
8598
8599 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8600   for ncn_progname in gcj; do
8601     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8602 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8603     if test -x $with_build_time_tools/${ncn_progname}; then
8604       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8605       echo "$as_me:$LINENO: result: yes" >&5
8606 echo "${ECHO_T}yes" >&6
8607       break
8608     else
8609       echo "$as_me:$LINENO: result: no" >&5
8610 echo "${ECHO_T}no" >&6
8611     fi
8612   done
8613 fi
8614
8615 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8616   for ncn_progname in gcj; do
8617     if test -n "$ncn_target_tool_prefix"; then
8618       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8619 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8620 echo "$as_me:$LINENO: checking for $ac_word" >&5
8621 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8622 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8623   echo $ECHO_N "(cached) $ECHO_C" >&6
8624 else
8625   if test -n "$GCJ_FOR_TARGET"; then
8626   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8627 else
8628 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8629 for as_dir in $PATH
8630 do
8631   IFS=$as_save_IFS
8632   test -z "$as_dir" && as_dir=.
8633   for ac_exec_ext in '' $ac_executable_extensions; do
8634   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8635     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8636     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8637     break 2
8638   fi
8639 done
8640 done
8641
8642 fi
8643 fi
8644 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8645 if test -n "$GCJ_FOR_TARGET"; then
8646   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8647 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8648 else
8649   echo "$as_me:$LINENO: result: no" >&5
8650 echo "${ECHO_T}no" >&6
8651 fi
8652
8653     fi
8654     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8655       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8656 set dummy ${ncn_progname}; ac_word=$2
8657 echo "$as_me:$LINENO: checking for $ac_word" >&5
8658 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8659 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8660   echo $ECHO_N "(cached) $ECHO_C" >&6
8661 else
8662   if test -n "$GCJ_FOR_TARGET"; then
8663   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8664 else
8665 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8666 for as_dir in $PATH
8667 do
8668   IFS=$as_save_IFS
8669   test -z "$as_dir" && as_dir=.
8670   for ac_exec_ext in '' $ac_executable_extensions; do
8671   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8672     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8673     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8674     break 2
8675   fi
8676 done
8677 done
8678
8679 fi
8680 fi
8681 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8682 if test -n "$GCJ_FOR_TARGET"; then
8683   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8684 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8685 else
8686   echo "$as_me:$LINENO: result: no" >&5
8687 echo "${ECHO_T}no" >&6
8688 fi
8689
8690     fi
8691     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8692   done
8693 fi
8694
8695 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8696   set dummy gcj
8697   if test $build = $target ; then
8698     GCJ_FOR_TARGET="$2"
8699   else
8700     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8701   fi
8702 else
8703   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8704 fi
8705
8706
8707
8708 if test -n "$GFORTRAN_FOR_TARGET"; then
8709   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8710 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8711   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8712 fi
8713
8714 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8715   for ncn_progname in gfortran; do
8716     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8717 set dummy ${ncn_progname}; ac_word=$2
8718 echo "$as_me:$LINENO: checking for $ac_word" >&5
8719 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8720 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8721   echo $ECHO_N "(cached) $ECHO_C" >&6
8722 else
8723   if test -n "$GFORTRAN_FOR_TARGET"; then
8724   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8725 else
8726 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8727 for as_dir in $PATH
8728 do
8729   IFS=$as_save_IFS
8730   test -z "$as_dir" && as_dir=.
8731   for ac_exec_ext in '' $ac_executable_extensions; do
8732   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8733     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8734     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8735     break 2
8736   fi
8737 done
8738 done
8739
8740 fi
8741 fi
8742 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8743 if test -n "$GFORTRAN_FOR_TARGET"; then
8744   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8745 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8746 else
8747   echo "$as_me:$LINENO: result: no" >&5
8748 echo "${ECHO_T}no" >&6
8749 fi
8750
8751   done
8752 fi
8753
8754 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8755   for ncn_progname in gfortran; do
8756     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8757 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8758     if test -x $with_build_time_tools/${ncn_progname}; then
8759       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8760       echo "$as_me:$LINENO: result: yes" >&5
8761 echo "${ECHO_T}yes" >&6
8762       break
8763     else
8764       echo "$as_me:$LINENO: result: no" >&5
8765 echo "${ECHO_T}no" >&6
8766     fi
8767   done
8768 fi
8769
8770 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8771   for ncn_progname in gfortran; do
8772     if test -n "$ncn_target_tool_prefix"; then
8773       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8774 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8775 echo "$as_me:$LINENO: checking for $ac_word" >&5
8776 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8777 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8778   echo $ECHO_N "(cached) $ECHO_C" >&6
8779 else
8780   if test -n "$GFORTRAN_FOR_TARGET"; then
8781   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8782 else
8783 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8784 for as_dir in $PATH
8785 do
8786   IFS=$as_save_IFS
8787   test -z "$as_dir" && as_dir=.
8788   for ac_exec_ext in '' $ac_executable_extensions; do
8789   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8790     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8791     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8792     break 2
8793   fi
8794 done
8795 done
8796
8797 fi
8798 fi
8799 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8800 if test -n "$GFORTRAN_FOR_TARGET"; then
8801   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8802 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8803 else
8804   echo "$as_me:$LINENO: result: no" >&5
8805 echo "${ECHO_T}no" >&6
8806 fi
8807
8808     fi
8809     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8810       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8811 set dummy ${ncn_progname}; ac_word=$2
8812 echo "$as_me:$LINENO: checking for $ac_word" >&5
8813 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8814 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8815   echo $ECHO_N "(cached) $ECHO_C" >&6
8816 else
8817   if test -n "$GFORTRAN_FOR_TARGET"; then
8818   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8819 else
8820 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8821 for as_dir in $PATH
8822 do
8823   IFS=$as_save_IFS
8824   test -z "$as_dir" && as_dir=.
8825   for ac_exec_ext in '' $ac_executable_extensions; do
8826   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8827     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8828     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8829     break 2
8830   fi
8831 done
8832 done
8833
8834 fi
8835 fi
8836 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8837 if test -n "$GFORTRAN_FOR_TARGET"; then
8838   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8839 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8840 else
8841   echo "$as_me:$LINENO: result: no" >&5
8842 echo "${ECHO_T}no" >&6
8843 fi
8844
8845     fi
8846     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8847   done
8848 fi
8849
8850 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8851   set dummy gfortran
8852   if test $build = $target ; then
8853     GFORTRAN_FOR_TARGET="$2"
8854   else
8855     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8856   fi
8857 else
8858   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8859 fi
8860
8861
8862
8863 cat > conftest.c << \EOF
8864 #ifdef __GNUC__
8865   gcc_yay;
8866 #endif
8867 EOF
8868 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8869   have_gcc_for_target=yes
8870 else
8871   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8872   have_gcc_for_target=no
8873 fi
8874 rm conftest.c
8875
8876
8877
8878
8879 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8880   if test -n "$with_build_time_tools"; then
8881     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8882 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8883     if test -x $with_build_time_tools/ar; then
8884       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8885       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8886       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8887 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8888     else
8889       echo "$as_me:$LINENO: result: no" >&5
8890 echo "${ECHO_T}no" >&6
8891     fi
8892   elif test $build != $host && test $have_gcc_for_target = yes; then
8893     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8894     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8895     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8896   fi
8897 fi
8898 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8899   # Extract the first word of "ar", so it can be a program name with args.
8900 set dummy ar; ac_word=$2
8901 echo "$as_me:$LINENO: checking for $ac_word" >&5
8902 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8903 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8904   echo $ECHO_N "(cached) $ECHO_C" >&6
8905 else
8906   case $AR_FOR_TARGET in
8907   [\\/]* | ?:[\\/]*)
8908   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8909   ;;
8910   *)
8911   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8912 for as_dir in $gcc_cv_tool_dirs
8913 do
8914   IFS=$as_save_IFS
8915   test -z "$as_dir" && as_dir=.
8916   for ac_exec_ext in '' $ac_executable_extensions; do
8917   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8918     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8919     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8920     break 2
8921   fi
8922 done
8923 done
8924
8925   ;;
8926 esac
8927 fi
8928 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8929
8930 if test -n "$AR_FOR_TARGET"; then
8931   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8932 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8933 else
8934   echo "$as_me:$LINENO: result: no" >&5
8935 echo "${ECHO_T}no" >&6
8936 fi
8937
8938 fi
8939 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8940
8941
8942 if test -n "$AR_FOR_TARGET"; then
8943   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8944 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8945   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8946 fi
8947
8948 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8949   for ncn_progname in ar; do
8950     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8951 set dummy ${ncn_progname}; ac_word=$2
8952 echo "$as_me:$LINENO: checking for $ac_word" >&5
8953 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8954 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8955   echo $ECHO_N "(cached) $ECHO_C" >&6
8956 else
8957   if test -n "$AR_FOR_TARGET"; then
8958   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8959 else
8960 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8961 for as_dir in $PATH
8962 do
8963   IFS=$as_save_IFS
8964   test -z "$as_dir" && as_dir=.
8965   for ac_exec_ext in '' $ac_executable_extensions; do
8966   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8967     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8968     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8969     break 2
8970   fi
8971 done
8972 done
8973
8974 fi
8975 fi
8976 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8977 if test -n "$AR_FOR_TARGET"; then
8978   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8979 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8980 else
8981   echo "$as_me:$LINENO: result: no" >&5
8982 echo "${ECHO_T}no" >&6
8983 fi
8984
8985   done
8986 fi
8987
8988 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8989   for ncn_progname in ar; do
8990     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8991 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8992     if test -x $with_build_time_tools/${ncn_progname}; then
8993       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8994       echo "$as_me:$LINENO: result: yes" >&5
8995 echo "${ECHO_T}yes" >&6
8996       break
8997     else
8998       echo "$as_me:$LINENO: result: no" >&5
8999 echo "${ECHO_T}no" >&6
9000     fi
9001   done
9002 fi
9003
9004 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9005   for ncn_progname in ar; do
9006     if test -n "$ncn_target_tool_prefix"; then
9007       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9008 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9009 echo "$as_me:$LINENO: checking for $ac_word" >&5
9010 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9011 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9012   echo $ECHO_N "(cached) $ECHO_C" >&6
9013 else
9014   if test -n "$AR_FOR_TARGET"; then
9015   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9016 else
9017 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9018 for as_dir in $PATH
9019 do
9020   IFS=$as_save_IFS
9021   test -z "$as_dir" && as_dir=.
9022   for ac_exec_ext in '' $ac_executable_extensions; do
9023   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9024     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9025     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9026     break 2
9027   fi
9028 done
9029 done
9030
9031 fi
9032 fi
9033 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9034 if test -n "$AR_FOR_TARGET"; then
9035   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9036 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9037 else
9038   echo "$as_me:$LINENO: result: no" >&5
9039 echo "${ECHO_T}no" >&6
9040 fi
9041
9042     fi
9043     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9044       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9045 set dummy ${ncn_progname}; ac_word=$2
9046 echo "$as_me:$LINENO: checking for $ac_word" >&5
9047 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9048 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9049   echo $ECHO_N "(cached) $ECHO_C" >&6
9050 else
9051   if test -n "$AR_FOR_TARGET"; then
9052   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9053 else
9054 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9055 for as_dir in $PATH
9056 do
9057   IFS=$as_save_IFS
9058   test -z "$as_dir" && as_dir=.
9059   for ac_exec_ext in '' $ac_executable_extensions; do
9060   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9061     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9062     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9063     break 2
9064   fi
9065 done
9066 done
9067
9068 fi
9069 fi
9070 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9071 if test -n "$AR_FOR_TARGET"; then
9072   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9073 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9074 else
9075   echo "$as_me:$LINENO: result: no" >&5
9076 echo "${ECHO_T}no" >&6
9077 fi
9078
9079     fi
9080     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9081   done
9082 fi
9083
9084 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9085   set dummy ar
9086   if test $build = $target ; then
9087     AR_FOR_TARGET="$2"
9088   else
9089     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9090   fi
9091 else
9092   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9093 fi
9094
9095 else
9096   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9097 fi
9098
9099
9100
9101
9102 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9103   if test -n "$with_build_time_tools"; then
9104     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9105 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9106     if test -x $with_build_time_tools/as; then
9107       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9108       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9109       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9110 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9111     else
9112       echo "$as_me:$LINENO: result: no" >&5
9113 echo "${ECHO_T}no" >&6
9114     fi
9115   elif test $build != $host && test $have_gcc_for_target = yes; then
9116     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9117     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9118     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9119   fi
9120 fi
9121 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9122   # Extract the first word of "as", so it can be a program name with args.
9123 set dummy as; ac_word=$2
9124 echo "$as_me:$LINENO: checking for $ac_word" >&5
9125 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9126 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9127   echo $ECHO_N "(cached) $ECHO_C" >&6
9128 else
9129   case $AS_FOR_TARGET in
9130   [\\/]* | ?:[\\/]*)
9131   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9132   ;;
9133   *)
9134   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9135 for as_dir in $gcc_cv_tool_dirs
9136 do
9137   IFS=$as_save_IFS
9138   test -z "$as_dir" && as_dir=.
9139   for ac_exec_ext in '' $ac_executable_extensions; do
9140   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9141     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9142     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9143     break 2
9144   fi
9145 done
9146 done
9147
9148   ;;
9149 esac
9150 fi
9151 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9152
9153 if test -n "$AS_FOR_TARGET"; then
9154   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9155 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9156 else
9157   echo "$as_me:$LINENO: result: no" >&5
9158 echo "${ECHO_T}no" >&6
9159 fi
9160
9161 fi
9162 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9163
9164
9165 if test -n "$AS_FOR_TARGET"; then
9166   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9167 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9168   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9169 fi
9170
9171 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9172   for ncn_progname in as; do
9173     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9174 set dummy ${ncn_progname}; ac_word=$2
9175 echo "$as_me:$LINENO: checking for $ac_word" >&5
9176 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9177 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9178   echo $ECHO_N "(cached) $ECHO_C" >&6
9179 else
9180   if test -n "$AS_FOR_TARGET"; then
9181   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9182 else
9183 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9184 for as_dir in $PATH
9185 do
9186   IFS=$as_save_IFS
9187   test -z "$as_dir" && as_dir=.
9188   for ac_exec_ext in '' $ac_executable_extensions; do
9189   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9190     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9191     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9192     break 2
9193   fi
9194 done
9195 done
9196
9197 fi
9198 fi
9199 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9200 if test -n "$AS_FOR_TARGET"; then
9201   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9202 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9203 else
9204   echo "$as_me:$LINENO: result: no" >&5
9205 echo "${ECHO_T}no" >&6
9206 fi
9207
9208   done
9209 fi
9210
9211 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9212   for ncn_progname in as; do
9213     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9214 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9215     if test -x $with_build_time_tools/${ncn_progname}; then
9216       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9217       echo "$as_me:$LINENO: result: yes" >&5
9218 echo "${ECHO_T}yes" >&6
9219       break
9220     else
9221       echo "$as_me:$LINENO: result: no" >&5
9222 echo "${ECHO_T}no" >&6
9223     fi
9224   done
9225 fi
9226
9227 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9228   for ncn_progname in as; do
9229     if test -n "$ncn_target_tool_prefix"; then
9230       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9231 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9232 echo "$as_me:$LINENO: checking for $ac_word" >&5
9233 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9234 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9235   echo $ECHO_N "(cached) $ECHO_C" >&6
9236 else
9237   if test -n "$AS_FOR_TARGET"; then
9238   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9239 else
9240 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9241 for as_dir in $PATH
9242 do
9243   IFS=$as_save_IFS
9244   test -z "$as_dir" && as_dir=.
9245   for ac_exec_ext in '' $ac_executable_extensions; do
9246   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9247     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9248     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9249     break 2
9250   fi
9251 done
9252 done
9253
9254 fi
9255 fi
9256 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9257 if test -n "$AS_FOR_TARGET"; then
9258   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9259 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9260 else
9261   echo "$as_me:$LINENO: result: no" >&5
9262 echo "${ECHO_T}no" >&6
9263 fi
9264
9265     fi
9266     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9267       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9268 set dummy ${ncn_progname}; ac_word=$2
9269 echo "$as_me:$LINENO: checking for $ac_word" >&5
9270 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9271 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9272   echo $ECHO_N "(cached) $ECHO_C" >&6
9273 else
9274   if test -n "$AS_FOR_TARGET"; then
9275   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9276 else
9277 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9278 for as_dir in $PATH
9279 do
9280   IFS=$as_save_IFS
9281   test -z "$as_dir" && as_dir=.
9282   for ac_exec_ext in '' $ac_executable_extensions; do
9283   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9284     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9285     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9286     break 2
9287   fi
9288 done
9289 done
9290
9291 fi
9292 fi
9293 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9294 if test -n "$AS_FOR_TARGET"; then
9295   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9296 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9297 else
9298   echo "$as_me:$LINENO: result: no" >&5
9299 echo "${ECHO_T}no" >&6
9300 fi
9301
9302     fi
9303     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9304   done
9305 fi
9306
9307 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9308   set dummy as
9309   if test $build = $target ; then
9310     AS_FOR_TARGET="$2"
9311   else
9312     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9313   fi
9314 else
9315   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9316 fi
9317
9318 else
9319   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9320 fi
9321
9322
9323
9324
9325 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9326   if test -n "$with_build_time_tools"; then
9327     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9328 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9329     if test -x $with_build_time_tools/dlltool; then
9330       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9331       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9332       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9333 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9334     else
9335       echo "$as_me:$LINENO: result: no" >&5
9336 echo "${ECHO_T}no" >&6
9337     fi
9338   elif test $build != $host && test $have_gcc_for_target = yes; then
9339     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9340     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9341     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9342   fi
9343 fi
9344 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9345   # Extract the first word of "dlltool", so it can be a program name with args.
9346 set dummy dlltool; ac_word=$2
9347 echo "$as_me:$LINENO: checking for $ac_word" >&5
9348 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9349 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9350   echo $ECHO_N "(cached) $ECHO_C" >&6
9351 else
9352   case $DLLTOOL_FOR_TARGET in
9353   [\\/]* | ?:[\\/]*)
9354   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9355   ;;
9356   *)
9357   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9358 for as_dir in $gcc_cv_tool_dirs
9359 do
9360   IFS=$as_save_IFS
9361   test -z "$as_dir" && as_dir=.
9362   for ac_exec_ext in '' $ac_executable_extensions; do
9363   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9364     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9365     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9366     break 2
9367   fi
9368 done
9369 done
9370
9371   ;;
9372 esac
9373 fi
9374 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9375
9376 if test -n "$DLLTOOL_FOR_TARGET"; then
9377   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9378 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9379 else
9380   echo "$as_me:$LINENO: result: no" >&5
9381 echo "${ECHO_T}no" >&6
9382 fi
9383
9384 fi
9385 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9386
9387
9388 if test -n "$DLLTOOL_FOR_TARGET"; then
9389   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9390 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9391   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9392 fi
9393
9394 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9395   for ncn_progname in dlltool; do
9396     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9397 set dummy ${ncn_progname}; ac_word=$2
9398 echo "$as_me:$LINENO: checking for $ac_word" >&5
9399 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9400 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9401   echo $ECHO_N "(cached) $ECHO_C" >&6
9402 else
9403   if test -n "$DLLTOOL_FOR_TARGET"; then
9404   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9405 else
9406 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9407 for as_dir in $PATH
9408 do
9409   IFS=$as_save_IFS
9410   test -z "$as_dir" && as_dir=.
9411   for ac_exec_ext in '' $ac_executable_extensions; do
9412   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9413     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9414     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9415     break 2
9416   fi
9417 done
9418 done
9419
9420 fi
9421 fi
9422 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9423 if test -n "$DLLTOOL_FOR_TARGET"; then
9424   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9425 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9426 else
9427   echo "$as_me:$LINENO: result: no" >&5
9428 echo "${ECHO_T}no" >&6
9429 fi
9430
9431   done
9432 fi
9433
9434 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9435   for ncn_progname in dlltool; do
9436     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9437 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9438     if test -x $with_build_time_tools/${ncn_progname}; then
9439       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9440       echo "$as_me:$LINENO: result: yes" >&5
9441 echo "${ECHO_T}yes" >&6
9442       break
9443     else
9444       echo "$as_me:$LINENO: result: no" >&5
9445 echo "${ECHO_T}no" >&6
9446     fi
9447   done
9448 fi
9449
9450 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9451   for ncn_progname in dlltool; do
9452     if test -n "$ncn_target_tool_prefix"; then
9453       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9454 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9455 echo "$as_me:$LINENO: checking for $ac_word" >&5
9456 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9457 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9458   echo $ECHO_N "(cached) $ECHO_C" >&6
9459 else
9460   if test -n "$DLLTOOL_FOR_TARGET"; then
9461   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9462 else
9463 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9464 for as_dir in $PATH
9465 do
9466   IFS=$as_save_IFS
9467   test -z "$as_dir" && as_dir=.
9468   for ac_exec_ext in '' $ac_executable_extensions; do
9469   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9470     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9471     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9472     break 2
9473   fi
9474 done
9475 done
9476
9477 fi
9478 fi
9479 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9480 if test -n "$DLLTOOL_FOR_TARGET"; then
9481   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9482 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9483 else
9484   echo "$as_me:$LINENO: result: no" >&5
9485 echo "${ECHO_T}no" >&6
9486 fi
9487
9488     fi
9489     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9490       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9491 set dummy ${ncn_progname}; ac_word=$2
9492 echo "$as_me:$LINENO: checking for $ac_word" >&5
9493 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9494 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9495   echo $ECHO_N "(cached) $ECHO_C" >&6
9496 else
9497   if test -n "$DLLTOOL_FOR_TARGET"; then
9498   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9499 else
9500 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9501 for as_dir in $PATH
9502 do
9503   IFS=$as_save_IFS
9504   test -z "$as_dir" && as_dir=.
9505   for ac_exec_ext in '' $ac_executable_extensions; do
9506   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9507     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9508     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9509     break 2
9510   fi
9511 done
9512 done
9513
9514 fi
9515 fi
9516 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9517 if test -n "$DLLTOOL_FOR_TARGET"; then
9518   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9519 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9520 else
9521   echo "$as_me:$LINENO: result: no" >&5
9522 echo "${ECHO_T}no" >&6
9523 fi
9524
9525     fi
9526     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9527   done
9528 fi
9529
9530 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9531   set dummy dlltool
9532   if test $build = $target ; then
9533     DLLTOOL_FOR_TARGET="$2"
9534   else
9535     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9536   fi
9537 else
9538   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9539 fi
9540
9541 else
9542   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9543 fi
9544
9545
9546
9547
9548 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9549   if test -n "$with_build_time_tools"; then
9550     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9551 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9552     if test -x $with_build_time_tools/ld; then
9553       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9554       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9555       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9556 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9557     else
9558       echo "$as_me:$LINENO: result: no" >&5
9559 echo "${ECHO_T}no" >&6
9560     fi
9561   elif test $build != $host && test $have_gcc_for_target = yes; then
9562     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9563     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9564     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9565   fi
9566 fi
9567 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9568   # Extract the first word of "ld", so it can be a program name with args.
9569 set dummy ld; ac_word=$2
9570 echo "$as_me:$LINENO: checking for $ac_word" >&5
9571 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9572 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9573   echo $ECHO_N "(cached) $ECHO_C" >&6
9574 else
9575   case $LD_FOR_TARGET in
9576   [\\/]* | ?:[\\/]*)
9577   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9578   ;;
9579   *)
9580   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9581 for as_dir in $gcc_cv_tool_dirs
9582 do
9583   IFS=$as_save_IFS
9584   test -z "$as_dir" && as_dir=.
9585   for ac_exec_ext in '' $ac_executable_extensions; do
9586   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9587     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9588     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9589     break 2
9590   fi
9591 done
9592 done
9593
9594   ;;
9595 esac
9596 fi
9597 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9598
9599 if test -n "$LD_FOR_TARGET"; then
9600   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9601 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9602 else
9603   echo "$as_me:$LINENO: result: no" >&5
9604 echo "${ECHO_T}no" >&6
9605 fi
9606
9607 fi
9608 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9609
9610
9611 if test -n "$LD_FOR_TARGET"; then
9612   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9613 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9614   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9615 fi
9616
9617 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9618   for ncn_progname in ld; do
9619     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9620 set dummy ${ncn_progname}; ac_word=$2
9621 echo "$as_me:$LINENO: checking for $ac_word" >&5
9622 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9623 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9624   echo $ECHO_N "(cached) $ECHO_C" >&6
9625 else
9626   if test -n "$LD_FOR_TARGET"; then
9627   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9628 else
9629 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9630 for as_dir in $PATH
9631 do
9632   IFS=$as_save_IFS
9633   test -z "$as_dir" && as_dir=.
9634   for ac_exec_ext in '' $ac_executable_extensions; do
9635   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9636     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9637     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9638     break 2
9639   fi
9640 done
9641 done
9642
9643 fi
9644 fi
9645 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9646 if test -n "$LD_FOR_TARGET"; then
9647   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9648 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9649 else
9650   echo "$as_me:$LINENO: result: no" >&5
9651 echo "${ECHO_T}no" >&6
9652 fi
9653
9654   done
9655 fi
9656
9657 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9658   for ncn_progname in ld; do
9659     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9660 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9661     if test -x $with_build_time_tools/${ncn_progname}; then
9662       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9663       echo "$as_me:$LINENO: result: yes" >&5
9664 echo "${ECHO_T}yes" >&6
9665       break
9666     else
9667       echo "$as_me:$LINENO: result: no" >&5
9668 echo "${ECHO_T}no" >&6
9669     fi
9670   done
9671 fi
9672
9673 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9674   for ncn_progname in ld; do
9675     if test -n "$ncn_target_tool_prefix"; then
9676       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9677 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9678 echo "$as_me:$LINENO: checking for $ac_word" >&5
9679 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9680 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9681   echo $ECHO_N "(cached) $ECHO_C" >&6
9682 else
9683   if test -n "$LD_FOR_TARGET"; then
9684   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9685 else
9686 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9687 for as_dir in $PATH
9688 do
9689   IFS=$as_save_IFS
9690   test -z "$as_dir" && as_dir=.
9691   for ac_exec_ext in '' $ac_executable_extensions; do
9692   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9693     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9694     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9695     break 2
9696   fi
9697 done
9698 done
9699
9700 fi
9701 fi
9702 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9703 if test -n "$LD_FOR_TARGET"; then
9704   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9705 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9706 else
9707   echo "$as_me:$LINENO: result: no" >&5
9708 echo "${ECHO_T}no" >&6
9709 fi
9710
9711     fi
9712     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9713       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9714 set dummy ${ncn_progname}; ac_word=$2
9715 echo "$as_me:$LINENO: checking for $ac_word" >&5
9716 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9717 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9718   echo $ECHO_N "(cached) $ECHO_C" >&6
9719 else
9720   if test -n "$LD_FOR_TARGET"; then
9721   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9722 else
9723 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9724 for as_dir in $PATH
9725 do
9726   IFS=$as_save_IFS
9727   test -z "$as_dir" && as_dir=.
9728   for ac_exec_ext in '' $ac_executable_extensions; do
9729   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9730     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9731     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9732     break 2
9733   fi
9734 done
9735 done
9736
9737 fi
9738 fi
9739 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9740 if test -n "$LD_FOR_TARGET"; then
9741   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9742 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9743 else
9744   echo "$as_me:$LINENO: result: no" >&5
9745 echo "${ECHO_T}no" >&6
9746 fi
9747
9748     fi
9749     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9750   done
9751 fi
9752
9753 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9754   set dummy ld
9755   if test $build = $target ; then
9756     LD_FOR_TARGET="$2"
9757   else
9758     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9759   fi
9760 else
9761   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9762 fi
9763
9764 else
9765   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9766 fi
9767
9768
9769
9770
9771 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9772   if test -n "$with_build_time_tools"; then
9773     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9774 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9775     if test -x $with_build_time_tools/lipo; then
9776       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9777       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9778       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9779 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9780     else
9781       echo "$as_me:$LINENO: result: no" >&5
9782 echo "${ECHO_T}no" >&6
9783     fi
9784   elif test $build != $host && test $have_gcc_for_target = yes; then
9785     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9786     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9787     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9788   fi
9789 fi
9790 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9791   # Extract the first word of "lipo", so it can be a program name with args.
9792 set dummy lipo; ac_word=$2
9793 echo "$as_me:$LINENO: checking for $ac_word" >&5
9794 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9795 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9796   echo $ECHO_N "(cached) $ECHO_C" >&6
9797 else
9798   case $LIPO_FOR_TARGET in
9799   [\\/]* | ?:[\\/]*)
9800   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9801   ;;
9802   *)
9803   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9804 for as_dir in $gcc_cv_tool_dirs
9805 do
9806   IFS=$as_save_IFS
9807   test -z "$as_dir" && as_dir=.
9808   for ac_exec_ext in '' $ac_executable_extensions; do
9809   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9810     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9811     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9812     break 2
9813   fi
9814 done
9815 done
9816
9817   ;;
9818 esac
9819 fi
9820 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9821
9822 if test -n "$LIPO_FOR_TARGET"; then
9823   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9824 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9825 else
9826   echo "$as_me:$LINENO: result: no" >&5
9827 echo "${ECHO_T}no" >&6
9828 fi
9829
9830 fi
9831 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9832
9833
9834 if test -n "$LIPO_FOR_TARGET"; then
9835   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9836 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9837   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9838 fi
9839
9840 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9841   for ncn_progname in lipo; do
9842     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9843 set dummy ${ncn_progname}; ac_word=$2
9844 echo "$as_me:$LINENO: checking for $ac_word" >&5
9845 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9846 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9847   echo $ECHO_N "(cached) $ECHO_C" >&6
9848 else
9849   if test -n "$LIPO_FOR_TARGET"; then
9850   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9851 else
9852 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9853 for as_dir in $PATH
9854 do
9855   IFS=$as_save_IFS
9856   test -z "$as_dir" && as_dir=.
9857   for ac_exec_ext in '' $ac_executable_extensions; do
9858   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9859     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9860     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9861     break 2
9862   fi
9863 done
9864 done
9865
9866 fi
9867 fi
9868 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9869 if test -n "$LIPO_FOR_TARGET"; then
9870   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9871 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9872 else
9873   echo "$as_me:$LINENO: result: no" >&5
9874 echo "${ECHO_T}no" >&6
9875 fi
9876
9877   done
9878 fi
9879
9880 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9881   for ncn_progname in lipo; do
9882     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9883 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9884     if test -x $with_build_time_tools/${ncn_progname}; then
9885       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9886       echo "$as_me:$LINENO: result: yes" >&5
9887 echo "${ECHO_T}yes" >&6
9888       break
9889     else
9890       echo "$as_me:$LINENO: result: no" >&5
9891 echo "${ECHO_T}no" >&6
9892     fi
9893   done
9894 fi
9895
9896 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9897   for ncn_progname in lipo; do
9898     if test -n "$ncn_target_tool_prefix"; then
9899       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9900 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9901 echo "$as_me:$LINENO: checking for $ac_word" >&5
9902 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9903 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9904   echo $ECHO_N "(cached) $ECHO_C" >&6
9905 else
9906   if test -n "$LIPO_FOR_TARGET"; then
9907   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9908 else
9909 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9910 for as_dir in $PATH
9911 do
9912   IFS=$as_save_IFS
9913   test -z "$as_dir" && as_dir=.
9914   for ac_exec_ext in '' $ac_executable_extensions; do
9915   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9916     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9917     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9918     break 2
9919   fi
9920 done
9921 done
9922
9923 fi
9924 fi
9925 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9926 if test -n "$LIPO_FOR_TARGET"; then
9927   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9928 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9929 else
9930   echo "$as_me:$LINENO: result: no" >&5
9931 echo "${ECHO_T}no" >&6
9932 fi
9933
9934     fi
9935     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9936       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9937 set dummy ${ncn_progname}; ac_word=$2
9938 echo "$as_me:$LINENO: checking for $ac_word" >&5
9939 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9940 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9941   echo $ECHO_N "(cached) $ECHO_C" >&6
9942 else
9943   if test -n "$LIPO_FOR_TARGET"; then
9944   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9945 else
9946 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9947 for as_dir in $PATH
9948 do
9949   IFS=$as_save_IFS
9950   test -z "$as_dir" && as_dir=.
9951   for ac_exec_ext in '' $ac_executable_extensions; do
9952   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9953     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9954     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9955     break 2
9956   fi
9957 done
9958 done
9959
9960 fi
9961 fi
9962 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9963 if test -n "$LIPO_FOR_TARGET"; then
9964   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9965 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9966 else
9967   echo "$as_me:$LINENO: result: no" >&5
9968 echo "${ECHO_T}no" >&6
9969 fi
9970
9971     fi
9972     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9973   done
9974 fi
9975
9976 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9977   set dummy lipo
9978   if test $build = $target ; then
9979     LIPO_FOR_TARGET="$2"
9980   else
9981     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9982   fi
9983 else
9984   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9985 fi
9986
9987 else
9988   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9989 fi
9990
9991
9992
9993
9994 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9995   if test -n "$with_build_time_tools"; then
9996     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9997 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9998     if test -x $with_build_time_tools/nm; then
9999       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10000       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10001       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10002 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10003     else
10004       echo "$as_me:$LINENO: result: no" >&5
10005 echo "${ECHO_T}no" >&6
10006     fi
10007   elif test $build != $host && test $have_gcc_for_target = yes; then
10008     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10009     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10010     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10011   fi
10012 fi
10013 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10014   # Extract the first word of "nm", so it can be a program name with args.
10015 set dummy nm; ac_word=$2
10016 echo "$as_me:$LINENO: checking for $ac_word" >&5
10017 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10018 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10019   echo $ECHO_N "(cached) $ECHO_C" >&6
10020 else
10021   case $NM_FOR_TARGET in
10022   [\\/]* | ?:[\\/]*)
10023   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10024   ;;
10025   *)
10026   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10027 for as_dir in $gcc_cv_tool_dirs
10028 do
10029   IFS=$as_save_IFS
10030   test -z "$as_dir" && as_dir=.
10031   for ac_exec_ext in '' $ac_executable_extensions; do
10032   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10033     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10034     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10035     break 2
10036   fi
10037 done
10038 done
10039
10040   ;;
10041 esac
10042 fi
10043 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10044
10045 if test -n "$NM_FOR_TARGET"; then
10046   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10047 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10048 else
10049   echo "$as_me:$LINENO: result: no" >&5
10050 echo "${ECHO_T}no" >&6
10051 fi
10052
10053 fi
10054 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10055
10056
10057 if test -n "$NM_FOR_TARGET"; then
10058   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10059 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10060   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10061 fi
10062
10063 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10064   for ncn_progname in nm; do
10065     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10066 set dummy ${ncn_progname}; ac_word=$2
10067 echo "$as_me:$LINENO: checking for $ac_word" >&5
10068 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10069 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10070   echo $ECHO_N "(cached) $ECHO_C" >&6
10071 else
10072   if test -n "$NM_FOR_TARGET"; then
10073   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10074 else
10075 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10076 for as_dir in $PATH
10077 do
10078   IFS=$as_save_IFS
10079   test -z "$as_dir" && as_dir=.
10080   for ac_exec_ext in '' $ac_executable_extensions; do
10081   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10082     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10083     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10084     break 2
10085   fi
10086 done
10087 done
10088
10089 fi
10090 fi
10091 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10092 if test -n "$NM_FOR_TARGET"; then
10093   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10094 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10095 else
10096   echo "$as_me:$LINENO: result: no" >&5
10097 echo "${ECHO_T}no" >&6
10098 fi
10099
10100   done
10101 fi
10102
10103 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10104   for ncn_progname in nm; do
10105     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10106 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10107     if test -x $with_build_time_tools/${ncn_progname}; then
10108       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10109       echo "$as_me:$LINENO: result: yes" >&5
10110 echo "${ECHO_T}yes" >&6
10111       break
10112     else
10113       echo "$as_me:$LINENO: result: no" >&5
10114 echo "${ECHO_T}no" >&6
10115     fi
10116   done
10117 fi
10118
10119 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10120   for ncn_progname in nm; do
10121     if test -n "$ncn_target_tool_prefix"; then
10122       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10123 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10124 echo "$as_me:$LINENO: checking for $ac_word" >&5
10125 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10126 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10127   echo $ECHO_N "(cached) $ECHO_C" >&6
10128 else
10129   if test -n "$NM_FOR_TARGET"; then
10130   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10131 else
10132 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10133 for as_dir in $PATH
10134 do
10135   IFS=$as_save_IFS
10136   test -z "$as_dir" && as_dir=.
10137   for ac_exec_ext in '' $ac_executable_extensions; do
10138   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10139     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10140     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10141     break 2
10142   fi
10143 done
10144 done
10145
10146 fi
10147 fi
10148 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10149 if test -n "$NM_FOR_TARGET"; then
10150   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10151 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10152 else
10153   echo "$as_me:$LINENO: result: no" >&5
10154 echo "${ECHO_T}no" >&6
10155 fi
10156
10157     fi
10158     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10159       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10160 set dummy ${ncn_progname}; ac_word=$2
10161 echo "$as_me:$LINENO: checking for $ac_word" >&5
10162 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10163 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10164   echo $ECHO_N "(cached) $ECHO_C" >&6
10165 else
10166   if test -n "$NM_FOR_TARGET"; then
10167   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10168 else
10169 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10170 for as_dir in $PATH
10171 do
10172   IFS=$as_save_IFS
10173   test -z "$as_dir" && as_dir=.
10174   for ac_exec_ext in '' $ac_executable_extensions; do
10175   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10176     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10177     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10178     break 2
10179   fi
10180 done
10181 done
10182
10183 fi
10184 fi
10185 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10186 if test -n "$NM_FOR_TARGET"; then
10187   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10188 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10189 else
10190   echo "$as_me:$LINENO: result: no" >&5
10191 echo "${ECHO_T}no" >&6
10192 fi
10193
10194     fi
10195     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10196   done
10197 fi
10198
10199 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10200   set dummy nm
10201   if test $build = $target ; then
10202     NM_FOR_TARGET="$2"
10203   else
10204     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10205   fi
10206 else
10207   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10208 fi
10209
10210 else
10211   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10212 fi
10213
10214
10215
10216
10217 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10218   if test -n "$with_build_time_tools"; then
10219     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10220 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10221     if test -x $with_build_time_tools/objdump; then
10222       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10223       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10224       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10225 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10226     else
10227       echo "$as_me:$LINENO: result: no" >&5
10228 echo "${ECHO_T}no" >&6
10229     fi
10230   elif test $build != $host && test $have_gcc_for_target = yes; then
10231     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10232     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10233     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10234   fi
10235 fi
10236 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10237   # Extract the first word of "objdump", so it can be a program name with args.
10238 set dummy objdump; ac_word=$2
10239 echo "$as_me:$LINENO: checking for $ac_word" >&5
10240 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10241 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10242   echo $ECHO_N "(cached) $ECHO_C" >&6
10243 else
10244   case $OBJDUMP_FOR_TARGET in
10245   [\\/]* | ?:[\\/]*)
10246   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10247   ;;
10248   *)
10249   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10250 for as_dir in $gcc_cv_tool_dirs
10251 do
10252   IFS=$as_save_IFS
10253   test -z "$as_dir" && as_dir=.
10254   for ac_exec_ext in '' $ac_executable_extensions; do
10255   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10256     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10257     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10258     break 2
10259   fi
10260 done
10261 done
10262
10263   ;;
10264 esac
10265 fi
10266 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10267
10268 if test -n "$OBJDUMP_FOR_TARGET"; then
10269   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10270 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10271 else
10272   echo "$as_me:$LINENO: result: no" >&5
10273 echo "${ECHO_T}no" >&6
10274 fi
10275
10276 fi
10277 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10278
10279
10280 if test -n "$OBJDUMP_FOR_TARGET"; then
10281   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10282 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10283   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10284 fi
10285
10286 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10287   for ncn_progname in objdump; do
10288     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10289 set dummy ${ncn_progname}; ac_word=$2
10290 echo "$as_me:$LINENO: checking for $ac_word" >&5
10291 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10292 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10293   echo $ECHO_N "(cached) $ECHO_C" >&6
10294 else
10295   if test -n "$OBJDUMP_FOR_TARGET"; then
10296   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10297 else
10298 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10299 for as_dir in $PATH
10300 do
10301   IFS=$as_save_IFS
10302   test -z "$as_dir" && as_dir=.
10303   for ac_exec_ext in '' $ac_executable_extensions; do
10304   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10305     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10306     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10307     break 2
10308   fi
10309 done
10310 done
10311
10312 fi
10313 fi
10314 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10315 if test -n "$OBJDUMP_FOR_TARGET"; then
10316   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10317 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10318 else
10319   echo "$as_me:$LINENO: result: no" >&5
10320 echo "${ECHO_T}no" >&6
10321 fi
10322
10323   done
10324 fi
10325
10326 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10327   for ncn_progname in objdump; do
10328     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10329 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10330     if test -x $with_build_time_tools/${ncn_progname}; then
10331       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10332       echo "$as_me:$LINENO: result: yes" >&5
10333 echo "${ECHO_T}yes" >&6
10334       break
10335     else
10336       echo "$as_me:$LINENO: result: no" >&5
10337 echo "${ECHO_T}no" >&6
10338     fi
10339   done
10340 fi
10341
10342 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10343   for ncn_progname in objdump; do
10344     if test -n "$ncn_target_tool_prefix"; then
10345       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10346 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10347 echo "$as_me:$LINENO: checking for $ac_word" >&5
10348 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10349 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10350   echo $ECHO_N "(cached) $ECHO_C" >&6
10351 else
10352   if test -n "$OBJDUMP_FOR_TARGET"; then
10353   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10354 else
10355 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10356 for as_dir in $PATH
10357 do
10358   IFS=$as_save_IFS
10359   test -z "$as_dir" && as_dir=.
10360   for ac_exec_ext in '' $ac_executable_extensions; do
10361   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10362     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10363     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10364     break 2
10365   fi
10366 done
10367 done
10368
10369 fi
10370 fi
10371 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10372 if test -n "$OBJDUMP_FOR_TARGET"; then
10373   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10374 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10375 else
10376   echo "$as_me:$LINENO: result: no" >&5
10377 echo "${ECHO_T}no" >&6
10378 fi
10379
10380     fi
10381     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10382       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10383 set dummy ${ncn_progname}; ac_word=$2
10384 echo "$as_me:$LINENO: checking for $ac_word" >&5
10385 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10386 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10387   echo $ECHO_N "(cached) $ECHO_C" >&6
10388 else
10389   if test -n "$OBJDUMP_FOR_TARGET"; then
10390   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10391 else
10392 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10393 for as_dir in $PATH
10394 do
10395   IFS=$as_save_IFS
10396   test -z "$as_dir" && as_dir=.
10397   for ac_exec_ext in '' $ac_executable_extensions; do
10398   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10399     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10400     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10401     break 2
10402   fi
10403 done
10404 done
10405
10406 fi
10407 fi
10408 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10409 if test -n "$OBJDUMP_FOR_TARGET"; then
10410   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10411 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10412 else
10413   echo "$as_me:$LINENO: result: no" >&5
10414 echo "${ECHO_T}no" >&6
10415 fi
10416
10417     fi
10418     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10419   done
10420 fi
10421
10422 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10423   set dummy objdump
10424   if test $build = $target ; then
10425     OBJDUMP_FOR_TARGET="$2"
10426   else
10427     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10428   fi
10429 else
10430   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10431 fi
10432
10433 else
10434   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10435 fi
10436
10437
10438
10439
10440 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10441   if test -n "$with_build_time_tools"; then
10442     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10443 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10444     if test -x $with_build_time_tools/ranlib; then
10445       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10446       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10447       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10448 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10449     else
10450       echo "$as_me:$LINENO: result: no" >&5
10451 echo "${ECHO_T}no" >&6
10452     fi
10453   elif test $build != $host && test $have_gcc_for_target = yes; then
10454     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10455     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10456     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10457   fi
10458 fi
10459 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10460   # Extract the first word of "ranlib", so it can be a program name with args.
10461 set dummy ranlib; ac_word=$2
10462 echo "$as_me:$LINENO: checking for $ac_word" >&5
10463 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10464 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10465   echo $ECHO_N "(cached) $ECHO_C" >&6
10466 else
10467   case $RANLIB_FOR_TARGET in
10468   [\\/]* | ?:[\\/]*)
10469   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10470   ;;
10471   *)
10472   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10473 for as_dir in $gcc_cv_tool_dirs
10474 do
10475   IFS=$as_save_IFS
10476   test -z "$as_dir" && as_dir=.
10477   for ac_exec_ext in '' $ac_executable_extensions; do
10478   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10479     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10480     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10481     break 2
10482   fi
10483 done
10484 done
10485
10486   ;;
10487 esac
10488 fi
10489 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10490
10491 if test -n "$RANLIB_FOR_TARGET"; then
10492   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10493 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10494 else
10495   echo "$as_me:$LINENO: result: no" >&5
10496 echo "${ECHO_T}no" >&6
10497 fi
10498
10499 fi
10500 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10501
10502
10503 if test -n "$RANLIB_FOR_TARGET"; then
10504   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10505 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10506   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10507 fi
10508
10509 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10510   for ncn_progname in ranlib; do
10511     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10512 set dummy ${ncn_progname}; ac_word=$2
10513 echo "$as_me:$LINENO: checking for $ac_word" >&5
10514 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10515 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10516   echo $ECHO_N "(cached) $ECHO_C" >&6
10517 else
10518   if test -n "$RANLIB_FOR_TARGET"; then
10519   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10520 else
10521 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10522 for as_dir in $PATH
10523 do
10524   IFS=$as_save_IFS
10525   test -z "$as_dir" && as_dir=.
10526   for ac_exec_ext in '' $ac_executable_extensions; do
10527   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10528     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10529     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10530     break 2
10531   fi
10532 done
10533 done
10534
10535 fi
10536 fi
10537 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10538 if test -n "$RANLIB_FOR_TARGET"; then
10539   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10540 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10541 else
10542   echo "$as_me:$LINENO: result: no" >&5
10543 echo "${ECHO_T}no" >&6
10544 fi
10545
10546   done
10547 fi
10548
10549 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10550   for ncn_progname in ranlib; do
10551     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10552 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10553     if test -x $with_build_time_tools/${ncn_progname}; then
10554       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10555       echo "$as_me:$LINENO: result: yes" >&5
10556 echo "${ECHO_T}yes" >&6
10557       break
10558     else
10559       echo "$as_me:$LINENO: result: no" >&5
10560 echo "${ECHO_T}no" >&6
10561     fi
10562   done
10563 fi
10564
10565 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10566   for ncn_progname in ranlib; do
10567     if test -n "$ncn_target_tool_prefix"; then
10568       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10569 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10570 echo "$as_me:$LINENO: checking for $ac_word" >&5
10571 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10572 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10573   echo $ECHO_N "(cached) $ECHO_C" >&6
10574 else
10575   if test -n "$RANLIB_FOR_TARGET"; then
10576   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10577 else
10578 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10579 for as_dir in $PATH
10580 do
10581   IFS=$as_save_IFS
10582   test -z "$as_dir" && as_dir=.
10583   for ac_exec_ext in '' $ac_executable_extensions; do
10584   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10585     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10586     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10587     break 2
10588   fi
10589 done
10590 done
10591
10592 fi
10593 fi
10594 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10595 if test -n "$RANLIB_FOR_TARGET"; then
10596   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10597 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10598 else
10599   echo "$as_me:$LINENO: result: no" >&5
10600 echo "${ECHO_T}no" >&6
10601 fi
10602
10603     fi
10604     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10605       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10606 set dummy ${ncn_progname}; ac_word=$2
10607 echo "$as_me:$LINENO: checking for $ac_word" >&5
10608 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10609 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10610   echo $ECHO_N "(cached) $ECHO_C" >&6
10611 else
10612   if test -n "$RANLIB_FOR_TARGET"; then
10613   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10614 else
10615 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10616 for as_dir in $PATH
10617 do
10618   IFS=$as_save_IFS
10619   test -z "$as_dir" && as_dir=.
10620   for ac_exec_ext in '' $ac_executable_extensions; do
10621   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10622     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10623     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10624     break 2
10625   fi
10626 done
10627 done
10628
10629 fi
10630 fi
10631 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10632 if test -n "$RANLIB_FOR_TARGET"; then
10633   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10634 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10635 else
10636   echo "$as_me:$LINENO: result: no" >&5
10637 echo "${ECHO_T}no" >&6
10638 fi
10639
10640     fi
10641     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10642   done
10643 fi
10644
10645 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10646   set dummy ranlib
10647   if test $build = $target ; then
10648     RANLIB_FOR_TARGET="$2"
10649   else
10650     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10651   fi
10652 else
10653   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10654 fi
10655
10656 else
10657   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10658 fi
10659
10660
10661
10662
10663 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10664   if test -n "$with_build_time_tools"; then
10665     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10666 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10667     if test -x $with_build_time_tools/strip; then
10668       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10669       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10670       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10671 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10672     else
10673       echo "$as_me:$LINENO: result: no" >&5
10674 echo "${ECHO_T}no" >&6
10675     fi
10676   elif test $build != $host && test $have_gcc_for_target = yes; then
10677     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10678     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10679     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10680   fi
10681 fi
10682 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10683   # Extract the first word of "strip", so it can be a program name with args.
10684 set dummy strip; ac_word=$2
10685 echo "$as_me:$LINENO: checking for $ac_word" >&5
10686 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10687 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10688   echo $ECHO_N "(cached) $ECHO_C" >&6
10689 else
10690   case $STRIP_FOR_TARGET in
10691   [\\/]* | ?:[\\/]*)
10692   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10693   ;;
10694   *)
10695   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10696 for as_dir in $gcc_cv_tool_dirs
10697 do
10698   IFS=$as_save_IFS
10699   test -z "$as_dir" && as_dir=.
10700   for ac_exec_ext in '' $ac_executable_extensions; do
10701   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10702     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10703     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10704     break 2
10705   fi
10706 done
10707 done
10708
10709   ;;
10710 esac
10711 fi
10712 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10713
10714 if test -n "$STRIP_FOR_TARGET"; then
10715   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10716 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10717 else
10718   echo "$as_me:$LINENO: result: no" >&5
10719 echo "${ECHO_T}no" >&6
10720 fi
10721
10722 fi
10723 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10724
10725
10726 if test -n "$STRIP_FOR_TARGET"; then
10727   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10728 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10729   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10730 fi
10731
10732 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10733   for ncn_progname in strip; do
10734     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10735 set dummy ${ncn_progname}; ac_word=$2
10736 echo "$as_me:$LINENO: checking for $ac_word" >&5
10737 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10738 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10739   echo $ECHO_N "(cached) $ECHO_C" >&6
10740 else
10741   if test -n "$STRIP_FOR_TARGET"; then
10742   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10743 else
10744 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10745 for as_dir in $PATH
10746 do
10747   IFS=$as_save_IFS
10748   test -z "$as_dir" && as_dir=.
10749   for ac_exec_ext in '' $ac_executable_extensions; do
10750   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10751     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10752     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10753     break 2
10754   fi
10755 done
10756 done
10757
10758 fi
10759 fi
10760 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10761 if test -n "$STRIP_FOR_TARGET"; then
10762   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10763 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10764 else
10765   echo "$as_me:$LINENO: result: no" >&5
10766 echo "${ECHO_T}no" >&6
10767 fi
10768
10769   done
10770 fi
10771
10772 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10773   for ncn_progname in strip; do
10774     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10775 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10776     if test -x $with_build_time_tools/${ncn_progname}; then
10777       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10778       echo "$as_me:$LINENO: result: yes" >&5
10779 echo "${ECHO_T}yes" >&6
10780       break
10781     else
10782       echo "$as_me:$LINENO: result: no" >&5
10783 echo "${ECHO_T}no" >&6
10784     fi
10785   done
10786 fi
10787
10788 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10789   for ncn_progname in strip; do
10790     if test -n "$ncn_target_tool_prefix"; then
10791       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10792 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10793 echo "$as_me:$LINENO: checking for $ac_word" >&5
10794 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10795 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10796   echo $ECHO_N "(cached) $ECHO_C" >&6
10797 else
10798   if test -n "$STRIP_FOR_TARGET"; then
10799   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10800 else
10801 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10802 for as_dir in $PATH
10803 do
10804   IFS=$as_save_IFS
10805   test -z "$as_dir" && as_dir=.
10806   for ac_exec_ext in '' $ac_executable_extensions; do
10807   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10808     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10809     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10810     break 2
10811   fi
10812 done
10813 done
10814
10815 fi
10816 fi
10817 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10818 if test -n "$STRIP_FOR_TARGET"; then
10819   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10820 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10821 else
10822   echo "$as_me:$LINENO: result: no" >&5
10823 echo "${ECHO_T}no" >&6
10824 fi
10825
10826     fi
10827     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10828       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10829 set dummy ${ncn_progname}; ac_word=$2
10830 echo "$as_me:$LINENO: checking for $ac_word" >&5
10831 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10832 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10833   echo $ECHO_N "(cached) $ECHO_C" >&6
10834 else
10835   if test -n "$STRIP_FOR_TARGET"; then
10836   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10837 else
10838 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10839 for as_dir in $PATH
10840 do
10841   IFS=$as_save_IFS
10842   test -z "$as_dir" && as_dir=.
10843   for ac_exec_ext in '' $ac_executable_extensions; do
10844   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10845     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10846     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10847     break 2
10848   fi
10849 done
10850 done
10851
10852 fi
10853 fi
10854 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10855 if test -n "$STRIP_FOR_TARGET"; then
10856   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10857 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10858 else
10859   echo "$as_me:$LINENO: result: no" >&5
10860 echo "${ECHO_T}no" >&6
10861 fi
10862
10863     fi
10864     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10865   done
10866 fi
10867
10868 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10869   set dummy strip
10870   if test $build = $target ; then
10871     STRIP_FOR_TARGET="$2"
10872   else
10873     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10874   fi
10875 else
10876   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10877 fi
10878
10879 else
10880   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10881 fi
10882
10883
10884
10885
10886 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10887   if test -n "$with_build_time_tools"; then
10888     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10889 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10890     if test -x $with_build_time_tools/windres; then
10891       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10892       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10893       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10894 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10895     else
10896       echo "$as_me:$LINENO: result: no" >&5
10897 echo "${ECHO_T}no" >&6
10898     fi
10899   elif test $build != $host && test $have_gcc_for_target = yes; then
10900     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10901     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10902     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10903   fi
10904 fi
10905 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10906   # Extract the first word of "windres", so it can be a program name with args.
10907 set dummy windres; ac_word=$2
10908 echo "$as_me:$LINENO: checking for $ac_word" >&5
10909 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10910 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10911   echo $ECHO_N "(cached) $ECHO_C" >&6
10912 else
10913   case $WINDRES_FOR_TARGET in
10914   [\\/]* | ?:[\\/]*)
10915   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10916   ;;
10917   *)
10918   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10919 for as_dir in $gcc_cv_tool_dirs
10920 do
10921   IFS=$as_save_IFS
10922   test -z "$as_dir" && as_dir=.
10923   for ac_exec_ext in '' $ac_executable_extensions; do
10924   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10925     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10926     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10927     break 2
10928   fi
10929 done
10930 done
10931
10932   ;;
10933 esac
10934 fi
10935 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10936
10937 if test -n "$WINDRES_FOR_TARGET"; then
10938   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10939 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10940 else
10941   echo "$as_me:$LINENO: result: no" >&5
10942 echo "${ECHO_T}no" >&6
10943 fi
10944
10945 fi
10946 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10947
10948
10949 if test -n "$WINDRES_FOR_TARGET"; then
10950   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10951 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10952   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10953 fi
10954
10955 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10956   for ncn_progname in windres; do
10957     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10958 set dummy ${ncn_progname}; ac_word=$2
10959 echo "$as_me:$LINENO: checking for $ac_word" >&5
10960 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10961 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10962   echo $ECHO_N "(cached) $ECHO_C" >&6
10963 else
10964   if test -n "$WINDRES_FOR_TARGET"; then
10965   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10966 else
10967 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10968 for as_dir in $PATH
10969 do
10970   IFS=$as_save_IFS
10971   test -z "$as_dir" && as_dir=.
10972   for ac_exec_ext in '' $ac_executable_extensions; do
10973   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10974     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10975     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10976     break 2
10977   fi
10978 done
10979 done
10980
10981 fi
10982 fi
10983 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10984 if test -n "$WINDRES_FOR_TARGET"; then
10985   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10986 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10987 else
10988   echo "$as_me:$LINENO: result: no" >&5
10989 echo "${ECHO_T}no" >&6
10990 fi
10991
10992   done
10993 fi
10994
10995 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10996   for ncn_progname in windres; do
10997     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10998 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10999     if test -x $with_build_time_tools/${ncn_progname}; then
11000       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11001       echo "$as_me:$LINENO: result: yes" >&5
11002 echo "${ECHO_T}yes" >&6
11003       break
11004     else
11005       echo "$as_me:$LINENO: result: no" >&5
11006 echo "${ECHO_T}no" >&6
11007     fi
11008   done
11009 fi
11010
11011 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11012   for ncn_progname in windres; do
11013     if test -n "$ncn_target_tool_prefix"; then
11014       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11015 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11016 echo "$as_me:$LINENO: checking for $ac_word" >&5
11017 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11018 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11019   echo $ECHO_N "(cached) $ECHO_C" >&6
11020 else
11021   if test -n "$WINDRES_FOR_TARGET"; then
11022   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11023 else
11024 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11025 for as_dir in $PATH
11026 do
11027   IFS=$as_save_IFS
11028   test -z "$as_dir" && as_dir=.
11029   for ac_exec_ext in '' $ac_executable_extensions; do
11030   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11031     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11032     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11033     break 2
11034   fi
11035 done
11036 done
11037
11038 fi
11039 fi
11040 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11041 if test -n "$WINDRES_FOR_TARGET"; then
11042   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11043 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11044 else
11045   echo "$as_me:$LINENO: result: no" >&5
11046 echo "${ECHO_T}no" >&6
11047 fi
11048
11049     fi
11050     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11051       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11052 set dummy ${ncn_progname}; ac_word=$2
11053 echo "$as_me:$LINENO: checking for $ac_word" >&5
11054 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11055 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11056   echo $ECHO_N "(cached) $ECHO_C" >&6
11057 else
11058   if test -n "$WINDRES_FOR_TARGET"; then
11059   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11060 else
11061 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11062 for as_dir in $PATH
11063 do
11064   IFS=$as_save_IFS
11065   test -z "$as_dir" && as_dir=.
11066   for ac_exec_ext in '' $ac_executable_extensions; do
11067   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11068     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11069     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11070     break 2
11071   fi
11072 done
11073 done
11074
11075 fi
11076 fi
11077 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11078 if test -n "$WINDRES_FOR_TARGET"; then
11079   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11080 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11081 else
11082   echo "$as_me:$LINENO: result: no" >&5
11083 echo "${ECHO_T}no" >&6
11084 fi
11085
11086     fi
11087     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11088   done
11089 fi
11090
11091 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11092   set dummy windres
11093   if test $build = $target ; then
11094     WINDRES_FOR_TARGET="$2"
11095   else
11096     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11097   fi
11098 else
11099   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11100 fi
11101
11102 else
11103   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11104 fi
11105
11106
11107
11108
11109 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11110   if test -n "$with_build_time_tools"; then
11111     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11112 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11113     if test -x $with_build_time_tools/windmc; then
11114       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11115       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11116       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11117 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11118     else
11119       echo "$as_me:$LINENO: result: no" >&5
11120 echo "${ECHO_T}no" >&6
11121     fi
11122   elif test $build != $host && test $have_gcc_for_target = yes; then
11123     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11124     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11125     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11126   fi
11127 fi
11128 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11129   # Extract the first word of "windmc", so it can be a program name with args.
11130 set dummy windmc; ac_word=$2
11131 echo "$as_me:$LINENO: checking for $ac_word" >&5
11132 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11133 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11134   echo $ECHO_N "(cached) $ECHO_C" >&6
11135 else
11136   case $WINDMC_FOR_TARGET in
11137   [\\/]* | ?:[\\/]*)
11138   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11139   ;;
11140   *)
11141   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11142 for as_dir in $gcc_cv_tool_dirs
11143 do
11144   IFS=$as_save_IFS
11145   test -z "$as_dir" && as_dir=.
11146   for ac_exec_ext in '' $ac_executable_extensions; do
11147   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11148     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11149     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11150     break 2
11151   fi
11152 done
11153 done
11154
11155   ;;
11156 esac
11157 fi
11158 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11159
11160 if test -n "$WINDMC_FOR_TARGET"; then
11161   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11162 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11163 else
11164   echo "$as_me:$LINENO: result: no" >&5
11165 echo "${ECHO_T}no" >&6
11166 fi
11167
11168 fi
11169 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11170
11171
11172 if test -n "$WINDMC_FOR_TARGET"; then
11173   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11174 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11175   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11176 fi
11177
11178 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11179   for ncn_progname in windmc; do
11180     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11181 set dummy ${ncn_progname}; ac_word=$2
11182 echo "$as_me:$LINENO: checking for $ac_word" >&5
11183 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11184 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11185   echo $ECHO_N "(cached) $ECHO_C" >&6
11186 else
11187   if test -n "$WINDMC_FOR_TARGET"; then
11188   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11189 else
11190 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11191 for as_dir in $PATH
11192 do
11193   IFS=$as_save_IFS
11194   test -z "$as_dir" && as_dir=.
11195   for ac_exec_ext in '' $ac_executable_extensions; do
11196   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11197     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11198     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11199     break 2
11200   fi
11201 done
11202 done
11203
11204 fi
11205 fi
11206 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11207 if test -n "$WINDMC_FOR_TARGET"; then
11208   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11209 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11210 else
11211   echo "$as_me:$LINENO: result: no" >&5
11212 echo "${ECHO_T}no" >&6
11213 fi
11214
11215   done
11216 fi
11217
11218 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11219   for ncn_progname in windmc; do
11220     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11221 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11222     if test -x $with_build_time_tools/${ncn_progname}; then
11223       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11224       echo "$as_me:$LINENO: result: yes" >&5
11225 echo "${ECHO_T}yes" >&6
11226       break
11227     else
11228       echo "$as_me:$LINENO: result: no" >&5
11229 echo "${ECHO_T}no" >&6
11230     fi
11231   done
11232 fi
11233
11234 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11235   for ncn_progname in windmc; do
11236     if test -n "$ncn_target_tool_prefix"; then
11237       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11238 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11239 echo "$as_me:$LINENO: checking for $ac_word" >&5
11240 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11241 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11242   echo $ECHO_N "(cached) $ECHO_C" >&6
11243 else
11244   if test -n "$WINDMC_FOR_TARGET"; then
11245   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11246 else
11247 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11248 for as_dir in $PATH
11249 do
11250   IFS=$as_save_IFS
11251   test -z "$as_dir" && as_dir=.
11252   for ac_exec_ext in '' $ac_executable_extensions; do
11253   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11254     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11255     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11256     break 2
11257   fi
11258 done
11259 done
11260
11261 fi
11262 fi
11263 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11264 if test -n "$WINDMC_FOR_TARGET"; then
11265   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11266 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11267 else
11268   echo "$as_me:$LINENO: result: no" >&5
11269 echo "${ECHO_T}no" >&6
11270 fi
11271
11272     fi
11273     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11274       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11275 set dummy ${ncn_progname}; ac_word=$2
11276 echo "$as_me:$LINENO: checking for $ac_word" >&5
11277 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11278 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11279   echo $ECHO_N "(cached) $ECHO_C" >&6
11280 else
11281   if test -n "$WINDMC_FOR_TARGET"; then
11282   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11283 else
11284 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11285 for as_dir in $PATH
11286 do
11287   IFS=$as_save_IFS
11288   test -z "$as_dir" && as_dir=.
11289   for ac_exec_ext in '' $ac_executable_extensions; do
11290   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11291     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11292     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11293     break 2
11294   fi
11295 done
11296 done
11297
11298 fi
11299 fi
11300 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11301 if test -n "$WINDMC_FOR_TARGET"; then
11302   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11303 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11304 else
11305   echo "$as_me:$LINENO: result: no" >&5
11306 echo "${ECHO_T}no" >&6
11307 fi
11308
11309     fi
11310     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11311   done
11312 fi
11313
11314 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11315   set dummy windmc
11316   if test $build = $target ; then
11317     WINDMC_FOR_TARGET="$2"
11318   else
11319     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11320   fi
11321 else
11322   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11323 fi
11324
11325 else
11326   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11327 fi
11328
11329
11330 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11331
11332 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11333 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11334 if test "x${build}" != "x${host}" ; then
11335   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11336     # We already found the complete path
11337     ac_dir=`dirname $AR_FOR_TARGET`
11338     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11339 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11340   else
11341     # Canadian cross, just use what we found
11342     echo "$as_me:$LINENO: result: pre-installed" >&5
11343 echo "${ECHO_T}pre-installed" >&6
11344   fi
11345 else
11346   ok=yes
11347   case " ${configdirs} " in
11348     *" binutils "*) ;;
11349     *) ok=no ;;
11350   esac
11351
11352   if test $ok = yes; then
11353     # An in-tree tool is available and we can use it
11354     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11355     echo "$as_me:$LINENO: result: just compiled" >&5
11356 echo "${ECHO_T}just compiled" >&6
11357   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11358     # We already found the complete path
11359     ac_dir=`dirname $AR_FOR_TARGET`
11360     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11361 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11362   elif test "x$target" = "x$host"; then
11363     # We can use an host tool
11364     AR_FOR_TARGET='$(AR)'
11365     echo "$as_me:$LINENO: result: host tool" >&5
11366 echo "${ECHO_T}host tool" >&6
11367   else
11368     # We need a cross tool
11369     echo "$as_me:$LINENO: result: pre-installed" >&5
11370 echo "${ECHO_T}pre-installed" >&6
11371   fi
11372 fi
11373
11374 echo "$as_me:$LINENO: checking where to find the target as" >&5
11375 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11376 if test "x${build}" != "x${host}" ; then
11377   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11378     # We already found the complete path
11379     ac_dir=`dirname $AS_FOR_TARGET`
11380     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11381 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11382   else
11383     # Canadian cross, just use what we found
11384     echo "$as_me:$LINENO: result: pre-installed" >&5
11385 echo "${ECHO_T}pre-installed" >&6
11386   fi
11387 else
11388   ok=yes
11389   case " ${configdirs} " in
11390     *" gas "*) ;;
11391     *) ok=no ;;
11392   esac
11393
11394   if test $ok = yes; then
11395     # An in-tree tool is available and we can use it
11396     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11397     echo "$as_me:$LINENO: result: just compiled" >&5
11398 echo "${ECHO_T}just compiled" >&6
11399   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11400     # We already found the complete path
11401     ac_dir=`dirname $AS_FOR_TARGET`
11402     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11403 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11404   elif test "x$target" = "x$host"; then
11405     # We can use an host tool
11406     AS_FOR_TARGET='$(AS)'
11407     echo "$as_me:$LINENO: result: host tool" >&5
11408 echo "${ECHO_T}host tool" >&6
11409   else
11410     # We need a cross tool
11411     echo "$as_me:$LINENO: result: pre-installed" >&5
11412 echo "${ECHO_T}pre-installed" >&6
11413   fi
11414 fi
11415
11416 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11417 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11418 if test "x${build}" != "x${host}" ; then
11419   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11420     # We already found the complete path
11421     ac_dir=`dirname $CC_FOR_TARGET`
11422     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11423 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11424   else
11425     # Canadian cross, just use what we found
11426     echo "$as_me:$LINENO: result: pre-installed" >&5
11427 echo "${ECHO_T}pre-installed" >&6
11428   fi
11429 else
11430   ok=yes
11431   case " ${configdirs} " in
11432     *" gcc "*) ;;
11433     *) ok=no ;;
11434   esac
11435
11436   if test $ok = yes; then
11437     # An in-tree tool is available and we can use it
11438     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11439     echo "$as_me:$LINENO: result: just compiled" >&5
11440 echo "${ECHO_T}just compiled" >&6
11441   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11442     # We already found the complete path
11443     ac_dir=`dirname $CC_FOR_TARGET`
11444     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11445 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11446   elif test "x$target" = "x$host"; then
11447     # We can use an host tool
11448     CC_FOR_TARGET='$(CC)'
11449     echo "$as_me:$LINENO: result: host tool" >&5
11450 echo "${ECHO_T}host tool" >&6
11451   else
11452     # We need a cross tool
11453     echo "$as_me:$LINENO: result: pre-installed" >&5
11454 echo "${ECHO_T}pre-installed" >&6
11455   fi
11456 fi
11457
11458 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11459 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11460 if test "x${build}" != "x${host}" ; then
11461   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11462     # We already found the complete path
11463     ac_dir=`dirname $CXX_FOR_TARGET`
11464     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11465 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11466   else
11467     # Canadian cross, just use what we found
11468     echo "$as_me:$LINENO: result: pre-installed" >&5
11469 echo "${ECHO_T}pre-installed" >&6
11470   fi
11471 else
11472   ok=yes
11473   case " ${configdirs} " in
11474     *" gcc "*) ;;
11475     *) ok=no ;;
11476   esac
11477   case ,${enable_languages}, in
11478     *,c++,*) ;;
11479     *) ok=no ;;
11480   esac
11481   if test $ok = yes; then
11482     # An in-tree tool is available and we can use it
11483     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'
11484     echo "$as_me:$LINENO: result: just compiled" >&5
11485 echo "${ECHO_T}just compiled" >&6
11486   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11487     # We already found the complete path
11488     ac_dir=`dirname $CXX_FOR_TARGET`
11489     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11490 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11491   elif test "x$target" = "x$host"; then
11492     # We can use an host tool
11493     CXX_FOR_TARGET='$(CXX)'
11494     echo "$as_me:$LINENO: result: host tool" >&5
11495 echo "${ECHO_T}host tool" >&6
11496   else
11497     # We need a cross tool
11498     echo "$as_me:$LINENO: result: pre-installed" >&5
11499 echo "${ECHO_T}pre-installed" >&6
11500   fi
11501 fi
11502
11503 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11504 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11505 if test "x${build}" != "x${host}" ; then
11506   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11507     # We already found the complete path
11508     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11509     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11510 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11511   else
11512     # Canadian cross, just use what we found
11513     echo "$as_me:$LINENO: result: pre-installed" >&5
11514 echo "${ECHO_T}pre-installed" >&6
11515   fi
11516 else
11517   ok=yes
11518   case " ${configdirs} " in
11519     *" gcc "*) ;;
11520     *) ok=no ;;
11521   esac
11522   case ,${enable_languages}, in
11523     *,c++,*) ;;
11524     *) ok=no ;;
11525   esac
11526   if test $ok = yes; then
11527     # An in-tree tool is available and we can use it
11528     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'
11529     echo "$as_me:$LINENO: result: just compiled" >&5
11530 echo "${ECHO_T}just compiled" >&6
11531   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11532     # We already found the complete path
11533     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11534     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11535 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11536   elif test "x$target" = "x$host"; then
11537     # We can use an host tool
11538     RAW_CXX_FOR_TARGET='$(CXX)'
11539     echo "$as_me:$LINENO: result: host tool" >&5
11540 echo "${ECHO_T}host tool" >&6
11541   else
11542     # We need a cross tool
11543     echo "$as_me:$LINENO: result: pre-installed" >&5
11544 echo "${ECHO_T}pre-installed" >&6
11545   fi
11546 fi
11547
11548 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11549 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11550 if test "x${build}" != "x${host}" ; then
11551   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11552     # We already found the complete path
11553     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11554     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11555 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11556   else
11557     # Canadian cross, just use what we found
11558     echo "$as_me:$LINENO: result: pre-installed" >&5
11559 echo "${ECHO_T}pre-installed" >&6
11560   fi
11561 else
11562   ok=yes
11563   case " ${configdirs} " in
11564     *" binutils "*) ;;
11565     *) ok=no ;;
11566   esac
11567
11568   if test $ok = yes; then
11569     # An in-tree tool is available and we can use it
11570     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11571     echo "$as_me:$LINENO: result: just compiled" >&5
11572 echo "${ECHO_T}just compiled" >&6
11573   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11574     # We already found the complete path
11575     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11576     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11577 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11578   elif test "x$target" = "x$host"; then
11579     # We can use an host tool
11580     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11581     echo "$as_me:$LINENO: result: host tool" >&5
11582 echo "${ECHO_T}host tool" >&6
11583   else
11584     # We need a cross tool
11585     echo "$as_me:$LINENO: result: pre-installed" >&5
11586 echo "${ECHO_T}pre-installed" >&6
11587   fi
11588 fi
11589
11590 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11591 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11592 if test "x${build}" != "x${host}" ; then
11593   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11594     # We already found the complete path
11595     ac_dir=`dirname $GCC_FOR_TARGET`
11596     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11597 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11598   else
11599     # Canadian cross, just use what we found
11600     echo "$as_me:$LINENO: result: pre-installed" >&5
11601 echo "${ECHO_T}pre-installed" >&6
11602   fi
11603 else
11604   ok=yes
11605   case " ${configdirs} " in
11606     *" gcc "*) ;;
11607     *) ok=no ;;
11608   esac
11609
11610   if test $ok = yes; then
11611     # An in-tree tool is available and we can use it
11612     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11613     echo "$as_me:$LINENO: result: just compiled" >&5
11614 echo "${ECHO_T}just compiled" >&6
11615   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11616     # We already found the complete path
11617     ac_dir=`dirname $GCC_FOR_TARGET`
11618     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11619 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11620   elif test "x$target" = "x$host"; then
11621     # We can use an host tool
11622     GCC_FOR_TARGET='$()'
11623     echo "$as_me:$LINENO: result: host tool" >&5
11624 echo "${ECHO_T}host tool" >&6
11625   else
11626     # We need a cross tool
11627     echo "$as_me:$LINENO: result: pre-installed" >&5
11628 echo "${ECHO_T}pre-installed" >&6
11629   fi
11630 fi
11631
11632 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11633 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11634 if test "x${build}" != "x${host}" ; then
11635   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11636     # We already found the complete path
11637     ac_dir=`dirname $GCJ_FOR_TARGET`
11638     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11639 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11640   else
11641     # Canadian cross, just use what we found
11642     echo "$as_me:$LINENO: result: pre-installed" >&5
11643 echo "${ECHO_T}pre-installed" >&6
11644   fi
11645 else
11646   ok=yes
11647   case " ${configdirs} " in
11648     *" gcc "*) ;;
11649     *) ok=no ;;
11650   esac
11651   case ,${enable_languages}, in
11652     *,java,*) ;;
11653     *) ok=no ;;
11654   esac
11655   if test $ok = yes; then
11656     # An in-tree tool is available and we can use it
11657     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11658     echo "$as_me:$LINENO: result: just compiled" >&5
11659 echo "${ECHO_T}just compiled" >&6
11660   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11661     # We already found the complete path
11662     ac_dir=`dirname $GCJ_FOR_TARGET`
11663     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11664 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11665   elif test "x$target" = "x$host"; then
11666     # We can use an host tool
11667     GCJ_FOR_TARGET='$(GCJ)'
11668     echo "$as_me:$LINENO: result: host tool" >&5
11669 echo "${ECHO_T}host tool" >&6
11670   else
11671     # We need a cross tool
11672     echo "$as_me:$LINENO: result: pre-installed" >&5
11673 echo "${ECHO_T}pre-installed" >&6
11674   fi
11675 fi
11676
11677 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11678 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11679 if test "x${build}" != "x${host}" ; then
11680   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11681     # We already found the complete path
11682     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11683     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11684 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11685   else
11686     # Canadian cross, just use what we found
11687     echo "$as_me:$LINENO: result: pre-installed" >&5
11688 echo "${ECHO_T}pre-installed" >&6
11689   fi
11690 else
11691   ok=yes
11692   case " ${configdirs} " in
11693     *" gcc "*) ;;
11694     *) ok=no ;;
11695   esac
11696   case ,${enable_languages}, in
11697     *,fortran,*) ;;
11698     *) ok=no ;;
11699   esac
11700   if test $ok = yes; then
11701     # An in-tree tool is available and we can use it
11702     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11703     echo "$as_me:$LINENO: result: just compiled" >&5
11704 echo "${ECHO_T}just compiled" >&6
11705   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11706     # We already found the complete path
11707     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11708     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11709 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11710   elif test "x$target" = "x$host"; then
11711     # We can use an host tool
11712     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11713     echo "$as_me:$LINENO: result: host tool" >&5
11714 echo "${ECHO_T}host tool" >&6
11715   else
11716     # We need a cross tool
11717     echo "$as_me:$LINENO: result: pre-installed" >&5
11718 echo "${ECHO_T}pre-installed" >&6
11719   fi
11720 fi
11721
11722 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11723 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11724 if test "x${build}" != "x${host}" ; then
11725   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11726     # We already found the complete path
11727     ac_dir=`dirname $LD_FOR_TARGET`
11728     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11729 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11730   else
11731     # Canadian cross, just use what we found
11732     echo "$as_me:$LINENO: result: pre-installed" >&5
11733 echo "${ECHO_T}pre-installed" >&6
11734   fi
11735 else
11736   ok=yes
11737   case " ${configdirs} " in
11738     *" ld "*) ;;
11739     *) ok=no ;;
11740   esac
11741
11742   if test $ok = yes; then
11743     # An in-tree tool is available and we can use it
11744     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11745     echo "$as_me:$LINENO: result: just compiled" >&5
11746 echo "${ECHO_T}just compiled" >&6
11747   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11748     # We already found the complete path
11749     ac_dir=`dirname $LD_FOR_TARGET`
11750     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11751 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11752   elif test "x$target" = "x$host"; then
11753     # We can use an host tool
11754     LD_FOR_TARGET='$(LD)'
11755     echo "$as_me:$LINENO: result: host tool" >&5
11756 echo "${ECHO_T}host tool" >&6
11757   else
11758     # We need a cross tool
11759     echo "$as_me:$LINENO: result: pre-installed" >&5
11760 echo "${ECHO_T}pre-installed" >&6
11761   fi
11762 fi
11763
11764 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11765 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11766 if test "x${build}" != "x${host}" ; then
11767   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11768     # We already found the complete path
11769     ac_dir=`dirname $LIPO_FOR_TARGET`
11770     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11771 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11772   else
11773     # Canadian cross, just use what we found
11774     echo "$as_me:$LINENO: result: pre-installed" >&5
11775 echo "${ECHO_T}pre-installed" >&6
11776   fi
11777 else
11778   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11779     # We already found the complete path
11780     ac_dir=`dirname $LIPO_FOR_TARGET`
11781     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11782 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11783   elif test "x$target" = "x$host"; then
11784     # We can use an host tool
11785     LIPO_FOR_TARGET='$(LIPO)'
11786     echo "$as_me:$LINENO: result: host tool" >&5
11787 echo "${ECHO_T}host tool" >&6
11788   else
11789     # We need a cross tool
11790     echo "$as_me:$LINENO: result: pre-installed" >&5
11791 echo "${ECHO_T}pre-installed" >&6
11792   fi
11793 fi
11794
11795 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11796 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11797 if test "x${build}" != "x${host}" ; then
11798   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11799     # We already found the complete path
11800     ac_dir=`dirname $NM_FOR_TARGET`
11801     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11802 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11803   else
11804     # Canadian cross, just use what we found
11805     echo "$as_me:$LINENO: result: pre-installed" >&5
11806 echo "${ECHO_T}pre-installed" >&6
11807   fi
11808 else
11809   ok=yes
11810   case " ${configdirs} " in
11811     *" binutils "*) ;;
11812     *) ok=no ;;
11813   esac
11814
11815   if test $ok = yes; then
11816     # An in-tree tool is available and we can use it
11817     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11818     echo "$as_me:$LINENO: result: just compiled" >&5
11819 echo "${ECHO_T}just compiled" >&6
11820   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11821     # We already found the complete path
11822     ac_dir=`dirname $NM_FOR_TARGET`
11823     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11824 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11825   elif test "x$target" = "x$host"; then
11826     # We can use an host tool
11827     NM_FOR_TARGET='$(NM)'
11828     echo "$as_me:$LINENO: result: host tool" >&5
11829 echo "${ECHO_T}host tool" >&6
11830   else
11831     # We need a cross tool
11832     echo "$as_me:$LINENO: result: pre-installed" >&5
11833 echo "${ECHO_T}pre-installed" >&6
11834   fi
11835 fi
11836
11837 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11838 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11839 if test "x${build}" != "x${host}" ; then
11840   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11841     # We already found the complete path
11842     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11843     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11844 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11845   else
11846     # Canadian cross, just use what we found
11847     echo "$as_me:$LINENO: result: pre-installed" >&5
11848 echo "${ECHO_T}pre-installed" >&6
11849   fi
11850 else
11851   ok=yes
11852   case " ${configdirs} " in
11853     *" binutils "*) ;;
11854     *) ok=no ;;
11855   esac
11856
11857   if test $ok = yes; then
11858     # An in-tree tool is available and we can use it
11859     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11860     echo "$as_me:$LINENO: result: just compiled" >&5
11861 echo "${ECHO_T}just compiled" >&6
11862   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11863     # We already found the complete path
11864     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11865     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11866 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11867   elif test "x$target" = "x$host"; then
11868     # We can use an host tool
11869     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11870     echo "$as_me:$LINENO: result: host tool" >&5
11871 echo "${ECHO_T}host tool" >&6
11872   else
11873     # We need a cross tool
11874     echo "$as_me:$LINENO: result: pre-installed" >&5
11875 echo "${ECHO_T}pre-installed" >&6
11876   fi
11877 fi
11878
11879 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11880 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11881 if test "x${build}" != "x${host}" ; then
11882   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11883     # We already found the complete path
11884     ac_dir=`dirname $RANLIB_FOR_TARGET`
11885     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11886 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11887   else
11888     # Canadian cross, just use what we found
11889     echo "$as_me:$LINENO: result: pre-installed" >&5
11890 echo "${ECHO_T}pre-installed" >&6
11891   fi
11892 else
11893   ok=yes
11894   case " ${configdirs} " in
11895     *" binutils "*) ;;
11896     *) ok=no ;;
11897   esac
11898
11899   if test $ok = yes; then
11900     # An in-tree tool is available and we can use it
11901     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11902     echo "$as_me:$LINENO: result: just compiled" >&5
11903 echo "${ECHO_T}just compiled" >&6
11904   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11905     # We already found the complete path
11906     ac_dir=`dirname $RANLIB_FOR_TARGET`
11907     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11908 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11909   elif test "x$target" = "x$host"; then
11910     # We can use an host tool
11911     RANLIB_FOR_TARGET='$(RANLIB)'
11912     echo "$as_me:$LINENO: result: host tool" >&5
11913 echo "${ECHO_T}host tool" >&6
11914   else
11915     # We need a cross tool
11916     echo "$as_me:$LINENO: result: pre-installed" >&5
11917 echo "${ECHO_T}pre-installed" >&6
11918   fi
11919 fi
11920
11921 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11922 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11923 if test "x${build}" != "x${host}" ; then
11924   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11925     # We already found the complete path
11926     ac_dir=`dirname $STRIP_FOR_TARGET`
11927     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11928 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11929   else
11930     # Canadian cross, just use what we found
11931     echo "$as_me:$LINENO: result: pre-installed" >&5
11932 echo "${ECHO_T}pre-installed" >&6
11933   fi
11934 else
11935   ok=yes
11936   case " ${configdirs} " in
11937     *" binutils "*) ;;
11938     *) ok=no ;;
11939   esac
11940
11941   if test $ok = yes; then
11942     # An in-tree tool is available and we can use it
11943     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11944     echo "$as_me:$LINENO: result: just compiled" >&5
11945 echo "${ECHO_T}just compiled" >&6
11946   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11947     # We already found the complete path
11948     ac_dir=`dirname $STRIP_FOR_TARGET`
11949     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11950 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11951   elif test "x$target" = "x$host"; then
11952     # We can use an host tool
11953     STRIP_FOR_TARGET='$(STRIP)'
11954     echo "$as_me:$LINENO: result: host tool" >&5
11955 echo "${ECHO_T}host tool" >&6
11956   else
11957     # We need a cross tool
11958     echo "$as_me:$LINENO: result: pre-installed" >&5
11959 echo "${ECHO_T}pre-installed" >&6
11960   fi
11961 fi
11962
11963 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11964 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11965 if test "x${build}" != "x${host}" ; then
11966   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11967     # We already found the complete path
11968     ac_dir=`dirname $WINDRES_FOR_TARGET`
11969     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11970 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11971   else
11972     # Canadian cross, just use what we found
11973     echo "$as_me:$LINENO: result: pre-installed" >&5
11974 echo "${ECHO_T}pre-installed" >&6
11975   fi
11976 else
11977   ok=yes
11978   case " ${configdirs} " in
11979     *" binutils "*) ;;
11980     *) ok=no ;;
11981   esac
11982
11983   if test $ok = yes; then
11984     # An in-tree tool is available and we can use it
11985     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11986     echo "$as_me:$LINENO: result: just compiled" >&5
11987 echo "${ECHO_T}just compiled" >&6
11988   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11989     # We already found the complete path
11990     ac_dir=`dirname $WINDRES_FOR_TARGET`
11991     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11992 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11993   elif test "x$target" = "x$host"; then
11994     # We can use an host tool
11995     WINDRES_FOR_TARGET='$(WINDRES)'
11996     echo "$as_me:$LINENO: result: host tool" >&5
11997 echo "${ECHO_T}host tool" >&6
11998   else
11999     # We need a cross tool
12000     echo "$as_me:$LINENO: result: pre-installed" >&5
12001 echo "${ECHO_T}pre-installed" >&6
12002   fi
12003 fi
12004
12005 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12006 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12007 if test "x${build}" != "x${host}" ; then
12008   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12009     # We already found the complete path
12010     ac_dir=`dirname $WINDMC_FOR_TARGET`
12011     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12012 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12013   else
12014     # Canadian cross, just use what we found
12015     echo "$as_me:$LINENO: result: pre-installed" >&5
12016 echo "${ECHO_T}pre-installed" >&6
12017   fi
12018 else
12019   ok=yes
12020   case " ${configdirs} " in
12021     *" binutils "*) ;;
12022     *) ok=no ;;
12023   esac
12024
12025   if test $ok = yes; then
12026     # An in-tree tool is available and we can use it
12027     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12028     echo "$as_me:$LINENO: result: just compiled" >&5
12029 echo "${ECHO_T}just compiled" >&6
12030   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12031     # We already found the complete path
12032     ac_dir=`dirname $WINDMC_FOR_TARGET`
12033     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12034 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12035   elif test "x$target" = "x$host"; then
12036     # We can use an host tool
12037     WINDMC_FOR_TARGET='$(WINDMC)'
12038     echo "$as_me:$LINENO: result: host tool" >&5
12039 echo "${ECHO_T}host tool" >&6
12040   else
12041     # We need a cross tool
12042     echo "$as_me:$LINENO: result: pre-installed" >&5
12043 echo "${ECHO_T}pre-installed" >&6
12044   fi
12045 fi
12046
12047
12048
12049
12050
12051 # Certain tools may need extra flags.
12052 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12053 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12054 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12055
12056 # When building target libraries, except in a Canadian cross, we use
12057 # the same toolchain as the compiler we just built.
12058 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12059 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12060 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12061 if test $host = $build; then
12062   case " $configdirs " in
12063     *" gcc "*)
12064       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12065       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12066       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12067       ;;
12068   esac
12069 fi
12070
12071
12072
12073
12074
12075 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12076 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12077 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12078 if test "${enable_maintainer_mode+set}" = set; then
12079   enableval="$enable_maintainer_mode"
12080   USE_MAINTAINER_MODE=$enableval
12081 else
12082   USE_MAINTAINER_MODE=no
12083 fi;
12084 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12085 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12086
12087
12088 if test "$USE_MAINTAINER_MODE" = yes; then
12089   MAINTAINER_MODE_TRUE=
12090   MAINTAINER_MODE_FALSE='#'
12091 else
12092   MAINTAINER_MODE_TRUE='#'
12093   MAINTAINER_MODE_FALSE=
12094 fi
12095 MAINT=$MAINTAINER_MODE_TRUE
12096
12097 # ---------------------
12098 # GCC bootstrap support
12099 # ---------------------
12100
12101 # Stage specific cflags for build.
12102 stage1_cflags="-g"
12103 case $build in
12104   vax-*-*)
12105     case ${GCC} in
12106       yes) stage1_cflags="-g -Wa,-J" ;;
12107       *) stage1_cflags="-g -J" ;;
12108     esac ;;
12109 esac
12110
12111 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12112 if test "$GCC" = yes; then
12113   saved_CFLAGS="$CFLAGS"
12114
12115   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12116   CFLAGS="$CFLAGS -fkeep-inline-functions"
12117   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12118 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12119   cat >conftest.$ac_ext <<_ACEOF
12120 /* confdefs.h.  */
12121 _ACEOF
12122 cat confdefs.h >>conftest.$ac_ext
12123 cat >>conftest.$ac_ext <<_ACEOF
12124 /* end confdefs.h.  */
12125
12126 #if (__GNUC__ < 3) \
12127     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12128                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12129 #error http://gcc.gnu.org/PR29382
12130 #endif
12131
12132 int
12133 main ()
12134 {
12135
12136   ;
12137   return 0;
12138 }
12139 _ACEOF
12140 rm -f conftest.$ac_objext
12141 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12142   (eval $ac_compile) 2>conftest.er1
12143   ac_status=$?
12144   grep -v '^ *+' conftest.er1 >conftest.err
12145   rm -f conftest.er1
12146   cat conftest.err >&5
12147   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12148   (exit $ac_status); } &&
12149          { ac_try='test -z "$ac_c_werror_flag"
12150                          || test ! -s conftest.err'
12151   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12152   (eval $ac_try) 2>&5
12153   ac_status=$?
12154   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12155   (exit $ac_status); }; } &&
12156          { ac_try='test -s conftest.$ac_objext'
12157   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12158   (eval $ac_try) 2>&5
12159   ac_status=$?
12160   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12161   (exit $ac_status); }; }; then
12162   echo "$as_me:$LINENO: result: yes" >&5
12163 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12164 else
12165   echo "$as_me: failed program was:" >&5
12166 sed 's/^/| /' conftest.$ac_ext >&5
12167
12168 echo "$as_me:$LINENO: result: no" >&5
12169 echo "${ECHO_T}no" >&6
12170 fi
12171 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12172
12173   CFLAGS="$saved_CFLAGS"
12174 fi
12175
12176
12177
12178 # Enable --enable-checking in stage1 of the compiler.
12179 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12180 if test "${enable_stage1_checking+set}" = set; then
12181   enableval="$enable_stage1_checking"
12182   stage1_checking=--enable-checking=${enable_stage1_checking}
12183 else
12184   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12185   stage1_checking=--enable-checking=yes,types
12186 else
12187   stage1_checking=--enable-checking=$enable_checking,types
12188 fi
12189 fi;
12190
12191
12192 # Enable -Werror in bootstrap stage2 and later.
12193 # Check whether --enable-werror or --disable-werror was given.
12194 if test "${enable_werror+set}" = set; then
12195   enableval="$enable_werror"
12196
12197 else
12198   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12199   enable_werror=yes
12200 else
12201   enable_werror=no
12202 fi
12203 fi;
12204 case ${enable_werror} in
12205   yes) stage2_werror_flag="--enable-werror-always" ;;
12206   *) stage2_werror_flag="" ;;
12207 esac
12208
12209
12210 # Flags needed to enable html installing and building
12211
12212 # Check whether --with-datarootdir or --without-datarootdir was given.
12213 if test "${with_datarootdir+set}" = set; then
12214   withval="$with_datarootdir"
12215   datarootdir="\${prefix}/${withval}"
12216 else
12217   datarootdir="\${prefix}/share"
12218 fi;
12219
12220
12221 # Check whether --with-docdir or --without-docdir was given.
12222 if test "${with_docdir+set}" = set; then
12223   withval="$with_docdir"
12224   docdir="\${prefix}/${withval}"
12225 else
12226   docdir="\${datarootdir}/doc"
12227 fi;
12228
12229
12230 # Check whether --with-pdfdir or --without-pdfdir was given.
12231 if test "${with_pdfdir+set}" = set; then
12232   withval="$with_pdfdir"
12233   pdfdir="\${prefix}/${withval}"
12234 else
12235   pdfdir="\${docdir}"
12236 fi;
12237
12238
12239 # Check whether --with-htmldir or --without-htmldir was given.
12240 if test "${with_htmldir+set}" = set; then
12241   withval="$with_htmldir"
12242   htmldir="\${prefix}/${withval}"
12243 else
12244   htmldir="\${docdir}"
12245 fi;
12246
12247
12248
12249
12250
12251
12252           ac_config_files="$ac_config_files Makefile"
12253 cat >confcache <<\_ACEOF
12254 # This file is a shell script that caches the results of configure
12255 # tests run on this system so they can be shared between configure
12256 # scripts and configure runs, see configure's option --config-cache.
12257 # It is not useful on other systems.  If it contains results you don't
12258 # want to keep, you may remove or edit it.
12259 #
12260 # config.status only pays attention to the cache file if you give it
12261 # the --recheck option to rerun configure.
12262 #
12263 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12264 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12265 # following values.
12266
12267 _ACEOF
12268
12269 # The following way of writing the cache mishandles newlines in values,
12270 # but we know of no workaround that is simple, portable, and efficient.
12271 # So, don't put newlines in cache variables' values.
12272 # Ultrix sh set writes to stderr and can't be redirected directly,
12273 # and sets the high bit in the cache file unless we assign to the vars.
12274 {
12275   (set) 2>&1 |
12276     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12277     *ac_space=\ *)
12278       # `set' does not quote correctly, so add quotes (double-quote
12279       # substitution turns \\\\ into \\, and sed turns \\ into \).
12280       sed -n \
12281         "s/'/'\\\\''/g;
12282           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12283       ;;
12284     *)
12285       # `set' quotes correctly as required by POSIX, so do not add quotes.
12286       sed -n \
12287         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12288       ;;
12289     esac;
12290 } |
12291   sed '
12292      t clear
12293      : clear
12294      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12295      t end
12296      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12297      : end' >>confcache
12298 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12299   if test -w $cache_file; then
12300     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12301     cat confcache >$cache_file
12302   else
12303     echo "not updating unwritable cache $cache_file"
12304   fi
12305 fi
12306 rm -f confcache
12307
12308 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12309 # Let make expand exec_prefix.
12310 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12311
12312 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12313 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12314 # trailing colons and then remove the whole line if VPATH becomes empty
12315 # (actually we leave an empty line to preserve line numbers).
12316 if test "x$srcdir" = x.; then
12317   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12318 s/:*\$(srcdir):*/:/;
12319 s/:*\${srcdir}:*/:/;
12320 s/:*@srcdir@:*/:/;
12321 s/^\([^=]*=[     ]*\):*/\1/;
12322 s/:*$//;
12323 s/^[^=]*=[       ]*$//;
12324 }'
12325 fi
12326
12327 # Transform confdefs.h into DEFS.
12328 # Protect against shell expansion while executing Makefile rules.
12329 # Protect against Makefile macro expansion.
12330 #
12331 # If the first sed substitution is executed (which looks for macros that
12332 # take arguments), then we branch to the quote section.  Otherwise,
12333 # look for a macro that doesn't take arguments.
12334 cat >confdef2opt.sed <<\_ACEOF
12335 t clear
12336 : clear
12337 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12338 t quote
12339 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12340 t quote
12341 d
12342 : quote
12343 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12344 s,\[,\\&,g
12345 s,\],\\&,g
12346 s,\$,$$,g
12347 p
12348 _ACEOF
12349 # We use echo to avoid assuming a particular line-breaking character.
12350 # The extra dot is to prevent the shell from consuming trailing
12351 # line-breaks from the sub-command output.  A line-break within
12352 # single-quotes doesn't work because, if this script is created in a
12353 # platform that uses two characters for line-breaks (e.g., DOS), tr
12354 # would break.
12355 ac_LF_and_DOT=`echo; echo .`
12356 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12357 rm -f confdef2opt.sed
12358
12359
12360 ac_libobjs=
12361 ac_ltlibobjs=
12362 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12363   # 1. Remove the extension, and $U if already installed.
12364   ac_i=`echo "$ac_i" |
12365          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12366   # 2. Add them.
12367   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12368   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12369 done
12370 LIBOBJS=$ac_libobjs
12371
12372 LTLIBOBJS=$ac_ltlibobjs
12373
12374
12375
12376 : ${CONFIG_STATUS=./config.status}
12377 ac_clean_files_save=$ac_clean_files
12378 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12379 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12380 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12381 cat >$CONFIG_STATUS <<_ACEOF
12382 #! $SHELL
12383 # Generated by $as_me.
12384 # Run this file to recreate the current configuration.
12385 # Compiler output produced by configure, useful for debugging
12386 # configure, is in config.log if it exists.
12387
12388 debug=false
12389 ac_cs_recheck=false
12390 ac_cs_silent=false
12391 SHELL=\${CONFIG_SHELL-$SHELL}
12392 _ACEOF
12393
12394 cat >>$CONFIG_STATUS <<\_ACEOF
12395 ## --------------------- ##
12396 ## M4sh Initialization.  ##
12397 ## --------------------- ##
12398
12399 # Be Bourne compatible
12400 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12401   emulate sh
12402   NULLCMD=:
12403   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12404   # is contrary to our usage.  Disable this feature.
12405   alias -g '${1+"$@"}'='"$@"'
12406 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12407   set -o posix
12408 fi
12409 DUALCASE=1; export DUALCASE # for MKS sh
12410
12411 # Support unset when possible.
12412 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12413   as_unset=unset
12414 else
12415   as_unset=false
12416 fi
12417
12418
12419 # Work around bugs in pre-3.0 UWIN ksh.
12420 $as_unset ENV MAIL MAILPATH
12421 PS1='$ '
12422 PS2='> '
12423 PS4='+ '
12424
12425 # NLS nuisances.
12426 for as_var in \
12427   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12428   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12429   LC_TELEPHONE LC_TIME
12430 do
12431   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12432     eval $as_var=C; export $as_var
12433   else
12434     $as_unset $as_var
12435   fi
12436 done
12437
12438 # Required to use basename.
12439 if expr a : '\(a\)' >/dev/null 2>&1; then
12440   as_expr=expr
12441 else
12442   as_expr=false
12443 fi
12444
12445 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12446   as_basename=basename
12447 else
12448   as_basename=false
12449 fi
12450
12451
12452 # Name of the executable.
12453 as_me=`$as_basename "$0" ||
12454 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12455          X"$0" : 'X\(//\)$' \| \
12456          X"$0" : 'X\(/\)$' \| \
12457          .     : '\(.\)' 2>/dev/null ||
12458 echo X/"$0" |
12459     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12460           /^X\/\(\/\/\)$/{ s//\1/; q; }
12461           /^X\/\(\/\).*/{ s//\1/; q; }
12462           s/.*/./; q'`
12463
12464
12465 # PATH needs CR, and LINENO needs CR and PATH.
12466 # Avoid depending upon Character Ranges.
12467 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12468 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12469 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12470 as_cr_digits='0123456789'
12471 as_cr_alnum=$as_cr_Letters$as_cr_digits
12472
12473 # The user is always right.
12474 if test "${PATH_SEPARATOR+set}" != set; then
12475   echo "#! /bin/sh" >conf$$.sh
12476   echo  "exit 0"   >>conf$$.sh
12477   chmod +x conf$$.sh
12478   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12479     PATH_SEPARATOR=';'
12480   else
12481     PATH_SEPARATOR=:
12482   fi
12483   rm -f conf$$.sh
12484 fi
12485
12486
12487   as_lineno_1=$LINENO
12488   as_lineno_2=$LINENO
12489   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12490   test "x$as_lineno_1" != "x$as_lineno_2" &&
12491   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12492   # Find who we are.  Look in the path if we contain no path at all
12493   # relative or not.
12494   case $0 in
12495     *[\\/]* ) as_myself=$0 ;;
12496     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12497 for as_dir in $PATH
12498 do
12499   IFS=$as_save_IFS
12500   test -z "$as_dir" && as_dir=.
12501   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12502 done
12503
12504        ;;
12505   esac
12506   # We did not find ourselves, most probably we were run as `sh COMMAND'
12507   # in which case we are not to be found in the path.
12508   if test "x$as_myself" = x; then
12509     as_myself=$0
12510   fi
12511   if test ! -f "$as_myself"; then
12512     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12513 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12514    { (exit 1); exit 1; }; }
12515   fi
12516   case $CONFIG_SHELL in
12517   '')
12518     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12519 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12520 do
12521   IFS=$as_save_IFS
12522   test -z "$as_dir" && as_dir=.
12523   for as_base in sh bash ksh sh5; do
12524          case $as_dir in
12525          /*)
12526            if ("$as_dir/$as_base" -c '
12527   as_lineno_1=$LINENO
12528   as_lineno_2=$LINENO
12529   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12530   test "x$as_lineno_1" != "x$as_lineno_2" &&
12531   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12532              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12533              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12534              CONFIG_SHELL=$as_dir/$as_base
12535              export CONFIG_SHELL
12536              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12537            fi;;
12538          esac
12539        done
12540 done
12541 ;;
12542   esac
12543
12544   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12545   # uniformly replaced by the line number.  The first 'sed' inserts a
12546   # line-number line before each line; the second 'sed' does the real
12547   # work.  The second script uses 'N' to pair each line-number line
12548   # with the numbered line, and appends trailing '-' during
12549   # substitution so that $LINENO is not a special case at line end.
12550   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12551   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12552   sed '=' <$as_myself |
12553     sed '
12554       N
12555       s,$,-,
12556       : loop
12557       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12558       t loop
12559       s,-$,,
12560       s,^['$as_cr_digits']*\n,,
12561     ' >$as_me.lineno &&
12562   chmod +x $as_me.lineno ||
12563     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12564 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12565    { (exit 1); exit 1; }; }
12566
12567   # Don't try to exec as it changes $[0], causing all sort of problems
12568   # (the dirname of $[0] is not the place where we might find the
12569   # original and so on.  Autoconf is especially sensible to this).
12570   . ./$as_me.lineno
12571   # Exit status is that of the last command.
12572   exit
12573 }
12574
12575
12576 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12577   *c*,-n*) ECHO_N= ECHO_C='
12578 ' ECHO_T='      ' ;;
12579   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12580   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12581 esac
12582
12583 if expr a : '\(a\)' >/dev/null 2>&1; then
12584   as_expr=expr
12585 else
12586   as_expr=false
12587 fi
12588
12589 rm -f conf$$ conf$$.exe conf$$.file
12590 echo >conf$$.file
12591 if ln -s conf$$.file conf$$ 2>/dev/null; then
12592   # We could just check for DJGPP; but this test a) works b) is more generic
12593   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12594   if test -f conf$$.exe; then
12595     # Don't use ln at all; we don't have any links
12596     as_ln_s='cp -p'
12597   else
12598     as_ln_s='ln -s'
12599   fi
12600 elif ln conf$$.file conf$$ 2>/dev/null; then
12601   as_ln_s=ln
12602 else
12603   as_ln_s='cp -p'
12604 fi
12605 rm -f conf$$ conf$$.exe conf$$.file
12606
12607 if mkdir -p . 2>/dev/null; then
12608   as_mkdir_p=:
12609 else
12610   test -d ./-p && rmdir ./-p
12611   as_mkdir_p=false
12612 fi
12613
12614 as_executable_p="test -f"
12615
12616 # Sed expression to map a string onto a valid CPP name.
12617 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12618
12619 # Sed expression to map a string onto a valid variable name.
12620 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12621
12622
12623 # IFS
12624 # We need space, tab and new line, in precisely that order.
12625 as_nl='
12626 '
12627 IFS="   $as_nl"
12628
12629 # CDPATH.
12630 $as_unset CDPATH
12631
12632 exec 6>&1
12633
12634 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12635 # report actual input values of CONFIG_FILES etc. instead of their
12636 # values after options handling.  Logging --version etc. is OK.
12637 exec 5>>config.log
12638 {
12639   echo
12640   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12641 ## Running $as_me. ##
12642 _ASBOX
12643 } >&5
12644 cat >&5 <<_CSEOF
12645
12646 This file was extended by $as_me, which was
12647 generated by GNU Autoconf 2.59.  Invocation command line was
12648
12649   CONFIG_FILES    = $CONFIG_FILES
12650   CONFIG_HEADERS  = $CONFIG_HEADERS
12651   CONFIG_LINKS    = $CONFIG_LINKS
12652   CONFIG_COMMANDS = $CONFIG_COMMANDS
12653   $ $0 $@
12654
12655 _CSEOF
12656 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12657 echo >&5
12658 _ACEOF
12659
12660 # Files that config.status was made for.
12661 if test -n "$ac_config_files"; then
12662   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12663 fi
12664
12665 if test -n "$ac_config_headers"; then
12666   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12667 fi
12668
12669 if test -n "$ac_config_links"; then
12670   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12671 fi
12672
12673 if test -n "$ac_config_commands"; then
12674   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12675 fi
12676
12677 cat >>$CONFIG_STATUS <<\_ACEOF
12678
12679 ac_cs_usage="\
12680 \`$as_me' instantiates files from templates according to the
12681 current configuration.
12682
12683 Usage: $0 [OPTIONS] [FILE]...
12684
12685   -h, --help       print this help, then exit
12686   -V, --version    print version number, then exit
12687   -q, --quiet      do not print progress messages
12688   -d, --debug      don't remove temporary files
12689       --recheck    update $as_me by reconfiguring in the same conditions
12690   --file=FILE[:TEMPLATE]
12691                    instantiate the configuration file FILE
12692
12693 Configuration files:
12694 $config_files
12695
12696 Report bugs to <bug-autoconf@gnu.org>."
12697 _ACEOF
12698
12699 cat >>$CONFIG_STATUS <<_ACEOF
12700 ac_cs_version="\\
12701 config.status
12702 configured by $0, generated by GNU Autoconf 2.59,
12703   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12704
12705 Copyright (C) 2003 Free Software Foundation, Inc.
12706 This config.status script is free software; the Free Software Foundation
12707 gives unlimited permission to copy, distribute and modify it."
12708 srcdir=$srcdir
12709 INSTALL="$INSTALL"
12710 _ACEOF
12711
12712 cat >>$CONFIG_STATUS <<\_ACEOF
12713 # If no file are specified by the user, then we need to provide default
12714 # value.  By we need to know if files were specified by the user.
12715 ac_need_defaults=:
12716 while test $# != 0
12717 do
12718   case $1 in
12719   --*=*)
12720     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12721     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12722     ac_shift=:
12723     ;;
12724   -*)
12725     ac_option=$1
12726     ac_optarg=$2
12727     ac_shift=shift
12728     ;;
12729   *) # This is not an option, so the user has probably given explicit
12730      # arguments.
12731      ac_option=$1
12732      ac_need_defaults=false;;
12733   esac
12734
12735   case $ac_option in
12736   # Handling of the options.
12737 _ACEOF
12738 cat >>$CONFIG_STATUS <<\_ACEOF
12739   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12740     ac_cs_recheck=: ;;
12741   --version | --vers* | -V )
12742     echo "$ac_cs_version"; exit 0 ;;
12743   --he | --h)
12744     # Conflict between --help and --header
12745     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12746 Try \`$0 --help' for more information." >&5
12747 echo "$as_me: error: ambiguous option: $1
12748 Try \`$0 --help' for more information." >&2;}
12749    { (exit 1); exit 1; }; };;
12750   --help | --hel | -h )
12751     echo "$ac_cs_usage"; exit 0 ;;
12752   --debug | --d* | -d )
12753     debug=: ;;
12754   --file | --fil | --fi | --f )
12755     $ac_shift
12756     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12757     ac_need_defaults=false;;
12758   --header | --heade | --head | --hea )
12759     $ac_shift
12760     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12761     ac_need_defaults=false;;
12762   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12763   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12764     ac_cs_silent=: ;;
12765
12766   # This is an error.
12767   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12768 Try \`$0 --help' for more information." >&5
12769 echo "$as_me: error: unrecognized option: $1
12770 Try \`$0 --help' for more information." >&2;}
12771    { (exit 1); exit 1; }; } ;;
12772
12773   *) ac_config_targets="$ac_config_targets $1" ;;
12774
12775   esac
12776   shift
12777 done
12778
12779 ac_configure_extra_args=
12780
12781 if $ac_cs_silent; then
12782   exec 6>/dev/null
12783   ac_configure_extra_args="$ac_configure_extra_args --silent"
12784 fi
12785
12786 _ACEOF
12787 cat >>$CONFIG_STATUS <<_ACEOF
12788 if \$ac_cs_recheck; then
12789   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12790   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12791 fi
12792
12793 _ACEOF
12794
12795
12796
12797
12798
12799 cat >>$CONFIG_STATUS <<\_ACEOF
12800 for ac_config_target in $ac_config_targets
12801 do
12802   case "$ac_config_target" in
12803   # Handling of arguments.
12804   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12805   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12806 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12807    { (exit 1); exit 1; }; };;
12808   esac
12809 done
12810
12811 # If the user did not use the arguments to specify the items to instantiate,
12812 # then the envvar interface is used.  Set only those that are not.
12813 # We use the long form for the default assignment because of an extremely
12814 # bizarre bug on SunOS 4.1.3.
12815 if $ac_need_defaults; then
12816   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12817 fi
12818
12819 # Have a temporary directory for convenience.  Make it in the build tree
12820 # simply because there is no reason to put it here, and in addition,
12821 # creating and moving files from /tmp can sometimes cause problems.
12822 # Create a temporary directory, and hook for its removal unless debugging.
12823 $debug ||
12824 {
12825   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12826   trap '{ (exit 1); exit 1; }' 1 2 13 15
12827 }
12828
12829 # Create a (secure) tmp directory for tmp files.
12830
12831 {
12832   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12833   test -n "$tmp" && test -d "$tmp"
12834 }  ||
12835 {
12836   tmp=./confstat$$-$RANDOM
12837   (umask 077 && mkdir $tmp)
12838 } ||
12839 {
12840    echo "$me: cannot create a temporary directory in ." >&2
12841    { (exit 1); exit 1; }
12842 }
12843
12844 _ACEOF
12845
12846 cat >>$CONFIG_STATUS <<_ACEOF
12847
12848 #
12849 # CONFIG_FILES section.
12850 #
12851
12852 # No need to generate the scripts if there are no CONFIG_FILES.
12853 # This happens for instance when ./config.status config.h
12854 if test -n "\$CONFIG_FILES"; then
12855   # Protect against being on the right side of a sed subst in config.status.
12856   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12857    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12858 s,@SHELL@,$SHELL,;t t
12859 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12860 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12861 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12862 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12863 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12864 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12865 s,@exec_prefix@,$exec_prefix,;t t
12866 s,@prefix@,$prefix,;t t
12867 s,@program_transform_name@,$program_transform_name,;t t
12868 s,@bindir@,$bindir,;t t
12869 s,@sbindir@,$sbindir,;t t
12870 s,@libexecdir@,$libexecdir,;t t
12871 s,@datadir@,$datadir,;t t
12872 s,@sysconfdir@,$sysconfdir,;t t
12873 s,@sharedstatedir@,$sharedstatedir,;t t
12874 s,@localstatedir@,$localstatedir,;t t
12875 s,@libdir@,$libdir,;t t
12876 s,@includedir@,$includedir,;t t
12877 s,@oldincludedir@,$oldincludedir,;t t
12878 s,@infodir@,$infodir,;t t
12879 s,@mandir@,$mandir,;t t
12880 s,@build_alias@,$build_alias,;t t
12881 s,@host_alias@,$host_alias,;t t
12882 s,@target_alias@,$target_alias,;t t
12883 s,@DEFS@,$DEFS,;t t
12884 s,@ECHO_C@,$ECHO_C,;t t
12885 s,@ECHO_N@,$ECHO_N,;t t
12886 s,@ECHO_T@,$ECHO_T,;t t
12887 s,@LIBS@,$LIBS,;t t
12888 s,@build@,$build,;t t
12889 s,@build_cpu@,$build_cpu,;t t
12890 s,@build_vendor@,$build_vendor,;t t
12891 s,@build_os@,$build_os,;t t
12892 s,@build_noncanonical@,$build_noncanonical,;t t
12893 s,@host_noncanonical@,$host_noncanonical,;t t
12894 s,@target_noncanonical@,$target_noncanonical,;t t
12895 s,@host@,$host,;t t
12896 s,@host_cpu@,$host_cpu,;t t
12897 s,@host_vendor@,$host_vendor,;t t
12898 s,@host_os@,$host_os,;t t
12899 s,@target@,$target,;t t
12900 s,@target_cpu@,$target_cpu,;t t
12901 s,@target_vendor@,$target_vendor,;t t
12902 s,@target_os@,$target_os,;t t
12903 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12904 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12905 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12906 s,@LN@,$LN,;t t
12907 s,@LN_S@,$LN_S,;t t
12908 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12909 s,@build_libsubdir@,$build_libsubdir,;t t
12910 s,@build_subdir@,$build_subdir,;t t
12911 s,@host_subdir@,$host_subdir,;t t
12912 s,@target_subdir@,$target_subdir,;t t
12913 s,@CC@,$CC,;t t
12914 s,@CFLAGS@,$CFLAGS,;t t
12915 s,@LDFLAGS@,$LDFLAGS,;t t
12916 s,@CPPFLAGS@,$CPPFLAGS,;t t
12917 s,@ac_ct_CC@,$ac_ct_CC,;t t
12918 s,@EXEEXT@,$EXEEXT,;t t
12919 s,@OBJEXT@,$OBJEXT,;t t
12920 s,@CXX@,$CXX,;t t
12921 s,@CXXFLAGS@,$CXXFLAGS,;t t
12922 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12923 s,@GNATBIND@,$GNATBIND,;t t
12924 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12925 s,@GNATMAKE@,$GNATMAKE,;t t
12926 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12927 s,@do_compare@,$do_compare,;t t
12928 s,@gmplibs@,$gmplibs,;t t
12929 s,@gmpinc@,$gmpinc,;t t
12930 s,@stage1_languages@,$stage1_languages,;t t
12931 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12932 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12933 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
12934 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
12935 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12936 s,@tooldir@,$tooldir,;t t
12937 s,@build_tooldir@,$build_tooldir,;t t
12938 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12939 s,@GDB_TK@,$GDB_TK,;t t
12940 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12941 s,@build_configargs@,$build_configargs,;t t
12942 s,@build_configdirs@,$build_configdirs,;t t
12943 s,@host_configargs@,$host_configargs,;t t
12944 s,@configdirs@,$configdirs,;t t
12945 s,@target_configargs@,$target_configargs,;t t
12946 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
12947 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
12948 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12949 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12950 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
12951 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
12952 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
12953 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
12954 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
12955 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
12956 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
12957 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
12958 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
12959 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
12960 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
12961 s,@config_shell@,$config_shell,;t t
12962 s,@YACC@,$YACC,;t t
12963 s,@BISON@,$BISON,;t t
12964 s,@M4@,$M4,;t t
12965 s,@LEX@,$LEX,;t t
12966 s,@FLEX@,$FLEX,;t t
12967 s,@MAKEINFO@,$MAKEINFO,;t t
12968 s,@EXPECT@,$EXPECT,;t t
12969 s,@RUNTEST@,$RUNTEST,;t t
12970 s,@AR@,$AR,;t t
12971 s,@AS@,$AS,;t t
12972 s,@DLLTOOL@,$DLLTOOL,;t t
12973 s,@LD@,$LD,;t t
12974 s,@LIPO@,$LIPO,;t t
12975 s,@NM@,$NM,;t t
12976 s,@RANLIB@,$RANLIB,;t t
12977 s,@STRIP@,$STRIP,;t t
12978 s,@WINDRES@,$WINDRES,;t t
12979 s,@WINDMC@,$WINDMC,;t t
12980 s,@OBJCOPY@,$OBJCOPY,;t t
12981 s,@OBJDUMP@,$OBJDUMP,;t t
12982 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12983 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12984 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12985 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12986 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12987 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12988 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12989 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12990 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12991 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12992 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12993 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12994 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12995 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12996 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12997 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
12998 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12999 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13000 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13001 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13002 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13003 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13004 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13005 s,@MAINT@,$MAINT,;t t
13006 s,@stage1_cflags@,$stage1_cflags,;t t
13007 s,@stage1_checking@,$stage1_checking,;t t
13008 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13009 s,@datarootdir@,$datarootdir,;t t
13010 s,@docdir@,$docdir,;t t
13011 s,@pdfdir@,$pdfdir,;t t
13012 s,@htmldir@,$htmldir,;t t
13013 s,@LIBOBJS@,$LIBOBJS,;t t
13014 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13015 /@serialization_dependencies@/r $serialization_dependencies
13016 s,@serialization_dependencies@,,;t t
13017 /@host_makefile_frag@/r $host_makefile_frag
13018 s,@host_makefile_frag@,,;t t
13019 /@target_makefile_frag@/r $target_makefile_frag
13020 s,@target_makefile_frag@,,;t t
13021 /@alphaieee_frag@/r $alphaieee_frag
13022 s,@alphaieee_frag@,,;t t
13023 /@ospace_frag@/r $ospace_frag
13024 s,@ospace_frag@,,;t t
13025 CEOF
13026
13027 _ACEOF
13028
13029   cat >>$CONFIG_STATUS <<\_ACEOF
13030   # Split the substitutions into bite-sized pieces for seds with
13031   # small command number limits, like on Digital OSF/1 and HP-UX.
13032   ac_max_sed_lines=48
13033   ac_sed_frag=1 # Number of current file.
13034   ac_beg=1 # First line for current file.
13035   ac_end=$ac_max_sed_lines # Line after last line for current file.
13036   ac_more_lines=:
13037   ac_sed_cmds=
13038   while $ac_more_lines; do
13039     if test $ac_beg -gt 1; then
13040       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13041     else
13042       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13043     fi
13044     if test ! -s $tmp/subs.frag; then
13045       ac_more_lines=false
13046     else
13047       # The purpose of the label and of the branching condition is to
13048       # speed up the sed processing (if there are no `@' at all, there
13049       # is no need to browse any of the substitutions).
13050       # These are the two extra sed commands mentioned above.
13051       (echo ':t
13052   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13053       if test -z "$ac_sed_cmds"; then
13054         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13055       else
13056         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13057       fi
13058       ac_sed_frag=`expr $ac_sed_frag + 1`
13059       ac_beg=$ac_end
13060       ac_end=`expr $ac_end + $ac_max_sed_lines`
13061     fi
13062   done
13063   if test -z "$ac_sed_cmds"; then
13064     ac_sed_cmds=cat
13065   fi
13066 fi # test -n "$CONFIG_FILES"
13067
13068 _ACEOF
13069 cat >>$CONFIG_STATUS <<\_ACEOF
13070 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13071   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13072   case $ac_file in
13073   - | *:- | *:-:* ) # input from stdin
13074         cat >$tmp/stdin
13075         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13076         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13077   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13078         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13079   * )   ac_file_in=$ac_file.in ;;
13080   esac
13081
13082   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13083   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13084 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13085          X"$ac_file" : 'X\(//\)[^/]' \| \
13086          X"$ac_file" : 'X\(//\)$' \| \
13087          X"$ac_file" : 'X\(/\)' \| \
13088          .     : '\(.\)' 2>/dev/null ||
13089 echo X"$ac_file" |
13090     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13091           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13092           /^X\(\/\/\)$/{ s//\1/; q; }
13093           /^X\(\/\).*/{ s//\1/; q; }
13094           s/.*/./; q'`
13095   { if $as_mkdir_p; then
13096     mkdir -p "$ac_dir"
13097   else
13098     as_dir="$ac_dir"
13099     as_dirs=
13100     while test ! -d "$as_dir"; do
13101       as_dirs="$as_dir $as_dirs"
13102       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13103 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13104          X"$as_dir" : 'X\(//\)[^/]' \| \
13105          X"$as_dir" : 'X\(//\)$' \| \
13106          X"$as_dir" : 'X\(/\)' \| \
13107          .     : '\(.\)' 2>/dev/null ||
13108 echo X"$as_dir" |
13109     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13110           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13111           /^X\(\/\/\)$/{ s//\1/; q; }
13112           /^X\(\/\).*/{ s//\1/; q; }
13113           s/.*/./; q'`
13114     done
13115     test ! -n "$as_dirs" || mkdir $as_dirs
13116   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13117 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13118    { (exit 1); exit 1; }; }; }
13119
13120   ac_builddir=.
13121
13122 if test "$ac_dir" != .; then
13123   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13124   # A "../" for each directory in $ac_dir_suffix.
13125   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13126 else
13127   ac_dir_suffix= ac_top_builddir=
13128 fi
13129
13130 case $srcdir in
13131   .)  # No --srcdir option.  We are building in place.
13132     ac_srcdir=.
13133     if test -z "$ac_top_builddir"; then
13134        ac_top_srcdir=.
13135     else
13136        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13137     fi ;;
13138   [\\/]* | ?:[\\/]* )  # Absolute path.
13139     ac_srcdir=$srcdir$ac_dir_suffix;
13140     ac_top_srcdir=$srcdir ;;
13141   *) # Relative path.
13142     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13143     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13144 esac
13145
13146 # Do not use `cd foo && pwd` to compute absolute paths, because
13147 # the directories may not exist.
13148 case `pwd` in
13149 .) ac_abs_builddir="$ac_dir";;
13150 *)
13151   case "$ac_dir" in
13152   .) ac_abs_builddir=`pwd`;;
13153   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13154   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13155   esac;;
13156 esac
13157 case $ac_abs_builddir in
13158 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13159 *)
13160   case ${ac_top_builddir}. in
13161   .) ac_abs_top_builddir=$ac_abs_builddir;;
13162   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13163   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13164   esac;;
13165 esac
13166 case $ac_abs_builddir in
13167 .) ac_abs_srcdir=$ac_srcdir;;
13168 *)
13169   case $ac_srcdir in
13170   .) ac_abs_srcdir=$ac_abs_builddir;;
13171   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13172   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13173   esac;;
13174 esac
13175 case $ac_abs_builddir in
13176 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13177 *)
13178   case $ac_top_srcdir in
13179   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13180   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13181   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13182   esac;;
13183 esac
13184
13185
13186   case $INSTALL in
13187   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13188   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13189   esac
13190
13191   if test x"$ac_file" != x-; then
13192     { echo "$as_me:$LINENO: creating $ac_file" >&5
13193 echo "$as_me: creating $ac_file" >&6;}
13194     rm -f "$ac_file"
13195   fi
13196   # Let's still pretend it is `configure' which instantiates (i.e., don't
13197   # use $as_me), people would be surprised to read:
13198   #    /* config.h.  Generated by config.status.  */
13199   if test x"$ac_file" = x-; then
13200     configure_input=
13201   else
13202     configure_input="$ac_file.  "
13203   fi
13204   configure_input=$configure_input"Generated from `echo $ac_file_in |
13205                                      sed 's,.*/,,'` by configure."
13206
13207   # First look for the input files in the build tree, otherwise in the
13208   # src tree.
13209   ac_file_inputs=`IFS=:
13210     for f in $ac_file_in; do
13211       case $f in
13212       -) echo $tmp/stdin ;;
13213       [\\/$]*)
13214          # Absolute (can't be DOS-style, as IFS=:)
13215          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13216 echo "$as_me: error: cannot find input file: $f" >&2;}
13217    { (exit 1); exit 1; }; }
13218          echo "$f";;
13219       *) # Relative
13220          if test -f "$f"; then
13221            # Build tree
13222            echo "$f"
13223          elif test -f "$srcdir/$f"; then
13224            # Source tree
13225            echo "$srcdir/$f"
13226          else
13227            # /dev/null tree
13228            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13229 echo "$as_me: error: cannot find input file: $f" >&2;}
13230    { (exit 1); exit 1; }; }
13231          fi;;
13232       esac
13233     done` || { (exit 1); exit 1; }
13234 _ACEOF
13235 cat >>$CONFIG_STATUS <<_ACEOF
13236   sed "$ac_vpsub
13237 $extrasub
13238 _ACEOF
13239 cat >>$CONFIG_STATUS <<\_ACEOF
13240 :t
13241 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13242 s,@configure_input@,$configure_input,;t t
13243 s,@srcdir@,$ac_srcdir,;t t
13244 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13245 s,@top_srcdir@,$ac_top_srcdir,;t t
13246 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13247 s,@builddir@,$ac_builddir,;t t
13248 s,@abs_builddir@,$ac_abs_builddir,;t t
13249 s,@top_builddir@,$ac_top_builddir,;t t
13250 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13251 s,@INSTALL@,$ac_INSTALL,;t t
13252 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13253   rm -f $tmp/stdin
13254   if test x"$ac_file" != x-; then
13255     mv $tmp/out $ac_file
13256   else
13257     cat $tmp/out
13258     rm -f $tmp/out
13259   fi
13260
13261 done
13262 _ACEOF
13263
13264 cat >>$CONFIG_STATUS <<\_ACEOF
13265
13266 { (exit 0); exit 0; }
13267 _ACEOF
13268 chmod +x $CONFIG_STATUS
13269 ac_clean_files=$ac_clean_files_save
13270
13271
13272 # configure is writing to config.log, and then calls config.status.
13273 # config.status does its own redirection, appending to config.log.
13274 # Unfortunately, on DOS this fails, as config.log is still kept open
13275 # by configure, so config.status won't be able to write to it; its
13276 # output is simply discarded.  So we exec the FD to /dev/null,
13277 # effectively closing config.log, so it can be properly (re)opened and
13278 # appended to by config.status.  When coming back to configure, we
13279 # need to make the FD available again.
13280 if test "$no_create" != yes; then
13281   ac_cs_success=:
13282   ac_config_status_args=
13283   test "$silent" = yes &&
13284     ac_config_status_args="$ac_config_status_args --quiet"
13285   exec 5>/dev/null
13286   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13287   exec 5>>config.log
13288   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13289   # would make configure fail if this is the last instruction.
13290   $ac_cs_success || { (exit 1); exit 1; }
13291 fi
13292