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} target-libssp"
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   cr16-*-*)
2344     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2345     ;;
2346   cris-*-* | crisv32-*-*)
2347     unsupported_languages="$unsupported_languages java"
2348     case "${target}" in
2349       *-*-aout)
2350         unsupported_languages="$unsupported_languages fortran"
2351         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2352       *-*-elf)
2353         noconfigdirs="$noconfigdirs target-boehm-gc";;
2354       *-*-linux*)
2355         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2356       *)
2357         unsupported_languages="$unsupported_languages fortran"
2358         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2359     esac
2360     libgloss_dir=cris
2361     ;;
2362   crx-*-*)
2363     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2364     ;;
2365   d10v-*-*)
2366     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2367     ;;
2368   d30v-*-*)
2369     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2370     ;;
2371   ep9312-*-elf | ep9312-*-coff)
2372     libgloss_dir=arm
2373     ;;
2374   fr30-*-elf*)
2375     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2376     ;;
2377   frv-*-*)
2378     noconfigdirs="$noconfigdirs ${libgcj}"
2379     ;;
2380   h8300*-*-*)
2381     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2382     ;;
2383   h8500-*-*)
2384     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2385     ;;
2386   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2387     ;;
2388   hppa*64*-*-linux* | parisc*64*-*-linux*)
2389     # In this case, it's because the hppa64-linux target is for
2390     # the kernel only at this point and has no libc, and thus no
2391     # headers, crt*.o, etc., all of which are needed by these.
2392     noconfigdirs="$noconfigdirs target-zlib"
2393     ;;
2394   parisc*-*-linux* | hppa*-*-linux*)
2395     ;;
2396   hppa*-*-*elf* | \
2397   hppa*-*-lites* | \
2398   hppa*-*-openbsd* | \
2399   hppa*64*-*-*)
2400     noconfigdirs="$noconfigdirs ${libgcj}"
2401     ;;
2402   hppa*-hp-hpux11*)
2403     noconfigdirs="$noconfigdirs ld shellutils"
2404     ;;
2405   hppa*-*-pro*)
2406     libgloss_dir=pa
2407     ;;
2408   hppa*-*-*)
2409     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2410     # build on HP-UX 10.20.
2411     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2412     ;;
2413   i960-*-*)
2414     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2415     ;;
2416   ia64*-*-elf*)
2417     # No gdb support yet.
2418     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2419     ;;
2420   ia64*-**-hpux*)
2421     # No gdb or ld support yet.
2422     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2423     ;;
2424   i370-*-opened*)
2425     ;;
2426   i[3456789]86-*-coff | i[3456789]86-*-elf)
2427     noconfigdirs="$noconfigdirs ${libgcj}"
2428     libgloss_dir=i386
2429     ;;
2430   i[3456789]86-*-linux*)
2431     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2432     # not build java stuff by default.
2433     case "${target}" in
2434       *-*-*libc1*)
2435         noconfigdirs="$noconfigdirs ${libgcj}";;
2436     esac
2437
2438     # This section makes it possible to build newlib natively on linux.
2439     # If we are using a cross compiler then don't configure newlib.
2440     if test x${is_cross_compiler} != xno ; then
2441       noconfigdirs="$noconfigdirs target-newlib"
2442     fi
2443     noconfigdirs="$noconfigdirs target-libgloss"
2444     # If we are not using a cross compiler, do configure newlib.
2445     # Note however, that newlib will only be configured in this situation
2446     # if the --with-newlib option has been given, because otherwise
2447     # 'target-newlib' will appear in skipdirs.
2448     ;;
2449   i[3456789]86-*-mingw32*)
2450     target_configdirs="$target_configdirs target-winsup"
2451     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2452     ;;
2453   x86_64-*-mingw*)
2454     target_configdirs="$target_configdirs target-winsup"
2455     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2456     ;;
2457   *-*-cygwin*)
2458     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2459     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2460     # always build newlib if winsup directory is present.
2461     if test -d "$srcdir/winsup/cygwin"; then
2462       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2463     elif test -d "$srcdir/newlib"; then
2464       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2465     fi
2466     ;;
2467   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2468   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2469     ;;
2470   i[3456789]86-*-pe)
2471     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2472     ;;
2473   i[3456789]86-*-sco3.2v5*)
2474     # The linker does not yet know about weak symbols in COFF,
2475     # and is not configured to handle mixed ELF and COFF.
2476     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2477     ;;
2478   i[3456789]86-*-sco*)
2479     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2480     ;;
2481   i[3456789]86-*-solaris2*)
2482     noconfigdirs="$noconfigdirs target-libgloss"
2483     ;;
2484   i[3456789]86-*-sysv4*)
2485     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2486     ;;
2487   i[3456789]86-*-beos*)
2488     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2489     ;;
2490   i[3456789]86-*-rdos*)
2491     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2492     ;;
2493   m32r-*-*)
2494     noconfigdirs="$noconfigdirs ${libgcj}"
2495     ;;
2496   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2497     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2498     libgloss_dir=m68hc11
2499     ;;
2500   m68k-*-elf*)
2501     noconfigdirs="$noconfigdirs ${libgcj}"
2502     ;;
2503   m68k-*-coff*)
2504     noconfigdirs="$noconfigdirs ${libgcj}"
2505     ;;
2506   m68*-*-* | fido-*-*)
2507     libgloss_dir=m68k
2508     ;;
2509   mcore-*-pe*)
2510   # The EPOC C++ environment does not support exceptions or rtti,
2511   # and so building libstdc++-v3 tends not to always work.
2512     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2513     ;;
2514   mmix-*-*)
2515     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2516     unsupported_languages="$unsupported_languages fortran java"
2517     ;;
2518   mn10200-*-*)
2519     noconfigdirs="$noconfigdirs ${libgcj}"
2520     ;;
2521   mn10300-*-*)
2522     noconfigdirs="$noconfigdirs ${libgcj}"
2523     ;;
2524   mt-*-*)
2525     noconfigdirs="$noconfigdirs sim"
2526     ;;
2527   powerpc-*-aix*)
2528     # copied from rs6000-*-* entry
2529     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2530     ;;
2531   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2532     target_configdirs="$target_configdirs target-winsup"
2533     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2534     # always build newlib.
2535     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2536     ;;
2537     # This is temporary until we can link against shared libraries
2538   powerpcle-*-solaris*)
2539     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2540     libgloss_dir=rs6000
2541     ;;
2542   powerpc-*-beos*)
2543     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2544     ;;
2545   powerpc-*-eabi)
2546     noconfigdirs="$noconfigdirs ${libgcj}"
2547     libgloss_dir=rs6000
2548     ;;
2549   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2550     libgloss_dir=rs6000
2551     ;;
2552   rs6000-*-lynxos*)
2553     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2554     ;;
2555   rs6000-*-aix*)
2556     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2557     ;;
2558   rs6000-*-*)
2559     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2560     ;;
2561   m68k-apollo-*)
2562     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2563     ;;
2564   mips*-sde-elf*)
2565     skipdirs="$skipdirs target-libiberty"
2566     noconfigdirs="$noconfigdirs ${libgcj}"
2567     if test x$with_newlib = xyes; then
2568       noconfigdirs="$noconfigdirs gprof"
2569     fi
2570     libgloss_dir=mips
2571     ;;
2572   mips*-*-irix5*)
2573     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2574     ;;
2575   mips*-*-irix6*)
2576     # Linking libjava exceeds command-line length limits on at least
2577     # IRIX 6.2, but not on IRIX 6.5.
2578     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2579     # <oldham@codesourcery.com>
2580     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2581     ;;
2582   mips*-*-bsd*)
2583     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2584     ;;
2585   mips*-*-linux*)
2586     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2587     ;;
2588   mips*-*-*)
2589     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2590     libgloss_dir=mips
2591     ;;
2592   romp-*-*)
2593     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2594     ;;
2595   sh-*-* | sh64-*-*)
2596     case "${host}" in
2597       i[3456789]86-*-vsta) ;; # don't add gprof back in
2598       i[3456789]86-*-go32*) ;; # don't add gprof back in
2599       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2600       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2601     esac
2602     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2603     ;;
2604   sparclet-*-aout* | sparc86x-*-*)
2605     libgloss_dir=sparc
2606     ;;
2607   sparc-*-elf*)
2608     noconfigdirs="$noconfigdirs ${libgcj}"
2609     ;;
2610   sparc64-*-elf*)
2611     noconfigdirs="$noconfigdirs ${libgcj}"
2612     libgloss_dir=sparc
2613     ;;
2614   sparclite-*-*)
2615     noconfigdirs="$noconfigdirs ${libgcj}"
2616     libgloss_dir=sparc
2617     ;;
2618   sparc-*-sunos4*)
2619     noconfigdirs="$noconfigdirs ${libgcj}"
2620     if test x${is_cross_compiler} != xno ; then
2621            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2622     else
2623            use_gnu_ld=no
2624     fi
2625     ;;
2626   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2627     noconfigdirs="$noconfigdirs ${libgcj}"
2628     ;;
2629   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2630     ;;
2631   spu-*-*)
2632     skipdirs="target-libssp"
2633     ;;
2634   v810-*-*)
2635     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2636     ;;
2637   v850-*-*)
2638     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2639     ;;
2640   v850e-*-*)
2641     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2642     ;;
2643   v850ea-*-*)
2644     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2645     ;;
2646   vax-*-vms)
2647     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2648     ;;
2649   vax-*-*)
2650     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2651     ;;
2652   xtensa*-*-*)
2653     noconfigdirs="$noconfigdirs ${libgcj}"
2654     ;;
2655   ip2k-*-*)
2656     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2657     ;;
2658   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2659     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2660     ;;
2661   *-*-lynxos*)
2662     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2663     ;;
2664   *-*-*)
2665     noconfigdirs="$noconfigdirs ${libgcj}"
2666     ;;
2667 esac
2668
2669 # If we aren't building newlib, then don't build libgloss, since libgloss
2670 # depends upon some newlib header files.
2671 case "${noconfigdirs}" in
2672   *target-libgloss*) ;;
2673   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2674 esac
2675
2676 # Work in distributions that contain no compiler tools, like Autoconf.
2677 tentative_cc=""
2678 host_makefile_frag=/dev/null
2679 if test -d ${srcdir}/config ; then
2680 case "${host}" in
2681   m68k-hp-hpux*)
2682     # Avoid "too much defining" errors from HPUX compiler.
2683     tentative_cc="cc -Wp,-H256000"
2684     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2685     # If it's HP/UX ar, this should be harmless.
2686     RANLIB="ar ts"
2687     ;;
2688   m68k-apollo-sysv*)
2689     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2690     ;;
2691   m68k-apollo-bsd*)
2692     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2693     # chokes on bfd, the compiler won't let you assign integers to enums, and
2694     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2695     # the apollo compiler" (the preferred version of GCC could be called cc,
2696     # or whatever), but I'm not sure leaving CC as cc is any better...
2697     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2698     # Used to have BISON=yacc.
2699     tentative_cc=gcc
2700     ;;
2701   m88k-dg-dgux*)
2702     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2703     ;;
2704   m88k-harris-cxux*)
2705     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2706     tentative_cc="cc -Xa"
2707     host_makefile_frag="config/mh-cxux"
2708     ;;
2709   m88k-motorola-sysv*)
2710     ;;
2711   mips*-dec-ultrix*)
2712     tentative_cc="cc -Wf,-XNg1000"
2713     host_makefile_frag="config/mh-decstation"
2714     ;;
2715   mips*-nec-sysv4*)
2716     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2717     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2718     host_makefile_frag="config/mh-necv4"
2719     ;;
2720   mips*-sgi-irix4*)
2721     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2722     # environment.  Also bump switch table size so that cp-parse will
2723     # compile.  Bump string length limit so linker builds.
2724     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2725     ;;
2726   mips*-*-sysv4*)
2727     host_makefile_frag="config/mh-sysv4"
2728     ;;
2729   mips*-*-sysv*)
2730     # This is for a MIPS running RISC/os 4.52C.
2731
2732     # This is needed for GDB, but needs to be in the top-level make because
2733     # if a library is compiled with the bsd headers and gets linked with the
2734     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2735     # a different size).
2736     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2737     # known except to select the sysv environment.  Could we use /proc instead?
2738     # These "sysv environments" and "bsd environments" often end up being a pain.
2739     #
2740     # This is not part of CFLAGS because perhaps not all C compilers have this
2741     # option.
2742     tentative_cc="cc -systype sysv"
2743     ;;
2744   i370-ibm-opened*)
2745     tentative_cc="c89"
2746     ;;
2747   i[3456789]86-*-sysv5*)
2748     host_makefile_frag="config/mh-sysv5"
2749     ;;
2750   i[3456789]86-*-dgux*)
2751     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2752     host_makefile_frag="config/mh-dgux386"
2753     ;;
2754   i[3456789]86-ncr-sysv4.3*)
2755     # The MetaWare compiler will generate a copyright message unless you
2756     # turn it off by adding the -Hnocopyr flag.
2757     tentative_cc="cc -Hnocopyr"
2758     ;;
2759   i[3456789]86-ncr-sysv4*)
2760     # for an NCR 3000 (i486/SVR4) system.
2761     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2762     # This compiler not only emits obnoxious copyright messages every time
2763     # you run it, but it chokes and dies on a whole bunch of GNU source
2764     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2765     tentative_cc="/usr/ccs/ATT/cc"
2766     host_makefile_frag="config/mh-ncr3000"
2767     ;;
2768   i[3456789]86-*-sco3.2v5*)
2769     ;;
2770   i[3456789]86-*-sco*)
2771     # The native C compiler botches some simple uses of const.  Unfortunately,
2772     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2773     tentative_cc="cc -Dconst="
2774     host_makefile_frag="config/mh-sco"
2775     ;;
2776   i[3456789]86-*-udk*)
2777     host_makefile_frag="config/mh-sysv5"
2778     ;;
2779   i[3456789]86-*-solaris2*)
2780     host_makefile_frag="config/mh-sysv4"
2781     ;;
2782   i[3456789]86-*-msdosdjgpp*)
2783     host_makefile_frag="config/mh-djgpp"
2784     ;;
2785   *-cygwin*)
2786
2787 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2788 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2789 echo a >cygwin-cat-check
2790 if test `cat cygwin-cat-check` == a ; then
2791   rm cygwin-cat-check
2792   echo "$as_me:$LINENO: result: yes" >&5
2793 echo "${ECHO_T}yes" >&6
2794 else
2795   rm cygwin-cat-check
2796   echo "$as_me:$LINENO: result: no" >&5
2797 echo "${ECHO_T}no" >&6
2798   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2799   Please either mount the build directory in binary mode or run the following
2800   commands before running any configure script:
2801 set -o igncr
2802 export SHELLOPTS
2803   " >&5
2804 echo "$as_me: error: The cat command does not ignore carriage return characters.
2805   Please either mount the build directory in binary mode or run the following
2806   commands before running any configure script:
2807 set -o igncr
2808 export SHELLOPTS
2809   " >&2;}
2810    { (exit 1); exit 1; }; }
2811 fi
2812
2813     host_makefile_frag="config/mh-cygwin"
2814     ;;
2815   *-mingw*)
2816     host_makefile_frag="config/mh-mingw"
2817     ;;
2818   *-interix*)
2819     host_makefile_frag="config/mh-interix"
2820     ;;
2821   vax-*-ultrix2*)
2822     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2823     tentative_cc=gcc
2824     ;;
2825   *-*-solaris2*)
2826     host_makefile_frag="config/mh-solaris"
2827     ;;
2828   m68k-sun-sunos*)
2829     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2830     # without overflowing the jump tables (-J says to use a 32 bit table)
2831     tentative_cc="cc -J"
2832     ;;
2833   *-hp-hpux*)
2834     tentative_cc="cc -Wp,-H256000"
2835     ;;
2836   *-*-hiux*)
2837     tentative_cc="cc -Wp,-H256000"
2838     ;;
2839   rs6000-*-lynxos*)
2840     # /bin/cc is less than useful for our purposes.  Always use GCC
2841     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2842     host_makefile_frag="config/mh-lynxrs6k"
2843     ;;
2844   powerpc-*-darwin*)
2845     host_makefile_frag="config/mh-ppc-darwin"
2846     ;;
2847   powerpc-*-aix*)
2848     host_makefile_frag="config/mh-ppc-aix"
2849     ;;
2850   rs6000-*-aix*)
2851     host_makefile_frag="config/mh-ppc-aix"
2852     ;;
2853   *-*-lynxos*)
2854     # /bin/cc is less than useful for our purposes.  Always use GCC
2855     tentative_cc="/bin/gcc"
2856     ;;
2857   *-*-sysv4*)
2858     host_makefile_frag="config/mh-sysv4"
2859     ;;
2860   # This is placed last to prevent interfering with the cases above.
2861   i[3456789]86-*-*)
2862     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2863     host_makefile_frag="config/mh-x86omitfp"
2864     ;;
2865 esac
2866 fi
2867
2868 # If we aren't going to be using gcc, see if we can extract a definition
2869 # of CC from the fragment.
2870 # Actually, use the 'pre-extracted' version above.
2871 if test -z "${CC}" && test "${build}" = "${host}" ; then
2872   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2873   found=
2874   for dir in $PATH; do
2875     test -z "$dir" && dir=.
2876     if test -f $dir/gcc; then
2877       found=yes
2878       break
2879     fi
2880   done
2881   IFS="$save_ifs"
2882   if test -z "${found}" && test -n "${tentative_cc}" ; then
2883     CC=$tentative_cc
2884   fi
2885 fi
2886
2887 if test "${build}" != "${host}" ; then
2888   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2889   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2890   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2891   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2892   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2893   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2894   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2895   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2896   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2897   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2898   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2899   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2900 else
2901   AR_FOR_BUILD="\$(AR)"
2902   AS_FOR_BUILD="\$(AS)"
2903   CC_FOR_BUILD="\$(CC)"
2904   CXX_FOR_BUILD="\$(CXX)"
2905   GCJ_FOR_BUILD="\$(GCJ)"
2906   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2907   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2908   LD_FOR_BUILD="\$(LD)"
2909   NM_FOR_BUILD="\$(NM)"
2910   RANLIB_FOR_BUILD="\$(RANLIB)"
2911   WINDRES_FOR_BUILD="\$(WINDRES)"
2912   WINDMC_FOR_BUILD="\$(WINDMC)"
2913 fi
2914
2915 ac_ext=c
2916 ac_cpp='$CPP $CPPFLAGS'
2917 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2918 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2919 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2920 if test -n "$ac_tool_prefix"; then
2921   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2922 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2923 echo "$as_me:$LINENO: checking for $ac_word" >&5
2924 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2925 if test "${ac_cv_prog_CC+set}" = set; then
2926   echo $ECHO_N "(cached) $ECHO_C" >&6
2927 else
2928   if test -n "$CC"; then
2929   ac_cv_prog_CC="$CC" # Let the user override the test.
2930 else
2931 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2932 for as_dir in $PATH
2933 do
2934   IFS=$as_save_IFS
2935   test -z "$as_dir" && as_dir=.
2936   for ac_exec_ext in '' $ac_executable_extensions; do
2937   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2938     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2939     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2940     break 2
2941   fi
2942 done
2943 done
2944
2945 fi
2946 fi
2947 CC=$ac_cv_prog_CC
2948 if test -n "$CC"; then
2949   echo "$as_me:$LINENO: result: $CC" >&5
2950 echo "${ECHO_T}$CC" >&6
2951 else
2952   echo "$as_me:$LINENO: result: no" >&5
2953 echo "${ECHO_T}no" >&6
2954 fi
2955
2956 fi
2957 if test -z "$ac_cv_prog_CC"; then
2958   ac_ct_CC=$CC
2959   # Extract the first word of "gcc", so it can be a program name with args.
2960 set dummy gcc; ac_word=$2
2961 echo "$as_me:$LINENO: checking for $ac_word" >&5
2962 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2963 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2964   echo $ECHO_N "(cached) $ECHO_C" >&6
2965 else
2966   if test -n "$ac_ct_CC"; then
2967   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2968 else
2969 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2970 for as_dir in $PATH
2971 do
2972   IFS=$as_save_IFS
2973   test -z "$as_dir" && as_dir=.
2974   for ac_exec_ext in '' $ac_executable_extensions; do
2975   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2976     ac_cv_prog_ac_ct_CC="gcc"
2977     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2978     break 2
2979   fi
2980 done
2981 done
2982
2983 fi
2984 fi
2985 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2986 if test -n "$ac_ct_CC"; then
2987   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2988 echo "${ECHO_T}$ac_ct_CC" >&6
2989 else
2990   echo "$as_me:$LINENO: result: no" >&5
2991 echo "${ECHO_T}no" >&6
2992 fi
2993
2994   CC=$ac_ct_CC
2995 else
2996   CC="$ac_cv_prog_CC"
2997 fi
2998
2999 if test -z "$CC"; then
3000   if test -n "$ac_tool_prefix"; then
3001   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3002 set dummy ${ac_tool_prefix}cc; ac_word=$2
3003 echo "$as_me:$LINENO: checking for $ac_word" >&5
3004 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3005 if test "${ac_cv_prog_CC+set}" = set; then
3006   echo $ECHO_N "(cached) $ECHO_C" >&6
3007 else
3008   if test -n "$CC"; then
3009   ac_cv_prog_CC="$CC" # Let the user override the test.
3010 else
3011 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3012 for as_dir in $PATH
3013 do
3014   IFS=$as_save_IFS
3015   test -z "$as_dir" && as_dir=.
3016   for ac_exec_ext in '' $ac_executable_extensions; do
3017   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3018     ac_cv_prog_CC="${ac_tool_prefix}cc"
3019     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3020     break 2
3021   fi
3022 done
3023 done
3024
3025 fi
3026 fi
3027 CC=$ac_cv_prog_CC
3028 if test -n "$CC"; then
3029   echo "$as_me:$LINENO: result: $CC" >&5
3030 echo "${ECHO_T}$CC" >&6
3031 else
3032   echo "$as_me:$LINENO: result: no" >&5
3033 echo "${ECHO_T}no" >&6
3034 fi
3035
3036 fi
3037 if test -z "$ac_cv_prog_CC"; then
3038   ac_ct_CC=$CC
3039   # Extract the first word of "cc", so it can be a program name with args.
3040 set dummy cc; ac_word=$2
3041 echo "$as_me:$LINENO: checking for $ac_word" >&5
3042 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3043 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3044   echo $ECHO_N "(cached) $ECHO_C" >&6
3045 else
3046   if test -n "$ac_ct_CC"; then
3047   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3048 else
3049 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3050 for as_dir in $PATH
3051 do
3052   IFS=$as_save_IFS
3053   test -z "$as_dir" && as_dir=.
3054   for ac_exec_ext in '' $ac_executable_extensions; do
3055   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3056     ac_cv_prog_ac_ct_CC="cc"
3057     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3058     break 2
3059   fi
3060 done
3061 done
3062
3063 fi
3064 fi
3065 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3066 if test -n "$ac_ct_CC"; then
3067   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3068 echo "${ECHO_T}$ac_ct_CC" >&6
3069 else
3070   echo "$as_me:$LINENO: result: no" >&5
3071 echo "${ECHO_T}no" >&6
3072 fi
3073
3074   CC=$ac_ct_CC
3075 else
3076   CC="$ac_cv_prog_CC"
3077 fi
3078
3079 fi
3080 if test -z "$CC"; then
3081   # Extract the first word of "cc", so it can be a program name with args.
3082 set dummy cc; ac_word=$2
3083 echo "$as_me:$LINENO: checking for $ac_word" >&5
3084 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3085 if test "${ac_cv_prog_CC+set}" = set; then
3086   echo $ECHO_N "(cached) $ECHO_C" >&6
3087 else
3088   if test -n "$CC"; then
3089   ac_cv_prog_CC="$CC" # Let the user override the test.
3090 else
3091   ac_prog_rejected=no
3092 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3093 for as_dir in $PATH
3094 do
3095   IFS=$as_save_IFS
3096   test -z "$as_dir" && as_dir=.
3097   for ac_exec_ext in '' $ac_executable_extensions; do
3098   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3099     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3100        ac_prog_rejected=yes
3101        continue
3102      fi
3103     ac_cv_prog_CC="cc"
3104     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3105     break 2
3106   fi
3107 done
3108 done
3109
3110 if test $ac_prog_rejected = yes; then
3111   # We found a bogon in the path, so make sure we never use it.
3112   set dummy $ac_cv_prog_CC
3113   shift
3114   if test $# != 0; then
3115     # We chose a different compiler from the bogus one.
3116     # However, it has the same basename, so the bogon will be chosen
3117     # first if we set CC to just the basename; use the full file name.
3118     shift
3119     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3120   fi
3121 fi
3122 fi
3123 fi
3124 CC=$ac_cv_prog_CC
3125 if test -n "$CC"; then
3126   echo "$as_me:$LINENO: result: $CC" >&5
3127 echo "${ECHO_T}$CC" >&6
3128 else
3129   echo "$as_me:$LINENO: result: no" >&5
3130 echo "${ECHO_T}no" >&6
3131 fi
3132
3133 fi
3134 if test -z "$CC"; then
3135   if test -n "$ac_tool_prefix"; then
3136   for ac_prog in cl
3137   do
3138     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3139 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3140 echo "$as_me:$LINENO: checking for $ac_word" >&5
3141 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3142 if test "${ac_cv_prog_CC+set}" = set; then
3143   echo $ECHO_N "(cached) $ECHO_C" >&6
3144 else
3145   if test -n "$CC"; then
3146   ac_cv_prog_CC="$CC" # Let the user override the test.
3147 else
3148 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3149 for as_dir in $PATH
3150 do
3151   IFS=$as_save_IFS
3152   test -z "$as_dir" && as_dir=.
3153   for ac_exec_ext in '' $ac_executable_extensions; do
3154   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3155     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3156     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3157     break 2
3158   fi
3159 done
3160 done
3161
3162 fi
3163 fi
3164 CC=$ac_cv_prog_CC
3165 if test -n "$CC"; then
3166   echo "$as_me:$LINENO: result: $CC" >&5
3167 echo "${ECHO_T}$CC" >&6
3168 else
3169   echo "$as_me:$LINENO: result: no" >&5
3170 echo "${ECHO_T}no" >&6
3171 fi
3172
3173     test -n "$CC" && break
3174   done
3175 fi
3176 if test -z "$CC"; then
3177   ac_ct_CC=$CC
3178   for ac_prog in cl
3179 do
3180   # Extract the first word of "$ac_prog", so it can be a program name with args.
3181 set dummy $ac_prog; ac_word=$2
3182 echo "$as_me:$LINENO: checking for $ac_word" >&5
3183 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3184 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3185   echo $ECHO_N "(cached) $ECHO_C" >&6
3186 else
3187   if test -n "$ac_ct_CC"; then
3188   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3189 else
3190 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3191 for as_dir in $PATH
3192 do
3193   IFS=$as_save_IFS
3194   test -z "$as_dir" && as_dir=.
3195   for ac_exec_ext in '' $ac_executable_extensions; do
3196   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3197     ac_cv_prog_ac_ct_CC="$ac_prog"
3198     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3199     break 2
3200   fi
3201 done
3202 done
3203
3204 fi
3205 fi
3206 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3207 if test -n "$ac_ct_CC"; then
3208   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3209 echo "${ECHO_T}$ac_ct_CC" >&6
3210 else
3211   echo "$as_me:$LINENO: result: no" >&5
3212 echo "${ECHO_T}no" >&6
3213 fi
3214
3215   test -n "$ac_ct_CC" && break
3216 done
3217
3218   CC=$ac_ct_CC
3219 fi
3220
3221 fi
3222
3223
3224 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3225 See \`config.log' for more details." >&5
3226 echo "$as_me: error: no acceptable C compiler found in \$PATH
3227 See \`config.log' for more details." >&2;}
3228    { (exit 1); exit 1; }; }
3229
3230 # Provide some information about the compiler.
3231 echo "$as_me:$LINENO:" \
3232      "checking for C compiler version" >&5
3233 ac_compiler=`set X $ac_compile; echo $2`
3234 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3235   (eval $ac_compiler --version </dev/null >&5) 2>&5
3236   ac_status=$?
3237   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3238   (exit $ac_status); }
3239 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3240   (eval $ac_compiler -v </dev/null >&5) 2>&5
3241   ac_status=$?
3242   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3243   (exit $ac_status); }
3244 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3245   (eval $ac_compiler -V </dev/null >&5) 2>&5
3246   ac_status=$?
3247   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3248   (exit $ac_status); }
3249
3250 cat >conftest.$ac_ext <<_ACEOF
3251 /* confdefs.h.  */
3252 _ACEOF
3253 cat confdefs.h >>conftest.$ac_ext
3254 cat >>conftest.$ac_ext <<_ACEOF
3255 /* end confdefs.h.  */
3256
3257 int
3258 main ()
3259 {
3260
3261   ;
3262   return 0;
3263 }
3264 _ACEOF
3265 ac_clean_files_save=$ac_clean_files
3266 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3267 # Try to create an executable without -o first, disregard a.out.
3268 # It will help us diagnose broken compilers, and finding out an intuition
3269 # of exeext.
3270 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3271 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3272 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3273 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3274   (eval $ac_link_default) 2>&5
3275   ac_status=$?
3276   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3277   (exit $ac_status); }; then
3278   # Find the output, starting from the most likely.  This scheme is
3279 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3280 # resort.
3281
3282 # Be careful to initialize this variable, since it used to be cached.
3283 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3284 ac_cv_exeext=
3285 # b.out is created by i960 compilers.
3286 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3287 do
3288   test -f "$ac_file" || continue
3289   case $ac_file in
3290     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3291         ;;
3292     conftest.$ac_ext )
3293         # This is the source file.
3294         ;;
3295     [ab].out )
3296         # We found the default executable, but exeext='' is most
3297         # certainly right.
3298         break;;
3299     *.* )
3300         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3301         # FIXME: I believe we export ac_cv_exeext for Libtool,
3302         # but it would be cool to find out if it's true.  Does anybody
3303         # maintain Libtool? --akim.
3304         export ac_cv_exeext
3305         break;;
3306     * )
3307         break;;
3308   esac
3309 done
3310 else
3311   echo "$as_me: failed program was:" >&5
3312 sed 's/^/| /' conftest.$ac_ext >&5
3313
3314 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3315 See \`config.log' for more details." >&5
3316 echo "$as_me: error: C compiler cannot create executables
3317 See \`config.log' for more details." >&2;}
3318    { (exit 77); exit 77; }; }
3319 fi
3320
3321 ac_exeext=$ac_cv_exeext
3322 echo "$as_me:$LINENO: result: $ac_file" >&5
3323 echo "${ECHO_T}$ac_file" >&6
3324
3325 # Check the compiler produces executables we can run.  If not, either
3326 # the compiler is broken, or we cross compile.
3327 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3328 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3329 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3330 # If not cross compiling, check that we can run a simple program.
3331 if test "$cross_compiling" != yes; then
3332   if { ac_try='./$ac_file'
3333   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3334   (eval $ac_try) 2>&5
3335   ac_status=$?
3336   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3337   (exit $ac_status); }; }; then
3338     cross_compiling=no
3339   else
3340     if test "$cross_compiling" = maybe; then
3341         cross_compiling=yes
3342     else
3343         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3344 If you meant to cross compile, use \`--host'.
3345 See \`config.log' for more details." >&5
3346 echo "$as_me: error: cannot run C compiled programs.
3347 If you meant to cross compile, use \`--host'.
3348 See \`config.log' for more details." >&2;}
3349    { (exit 1); exit 1; }; }
3350     fi
3351   fi
3352 fi
3353 echo "$as_me:$LINENO: result: yes" >&5
3354 echo "${ECHO_T}yes" >&6
3355
3356 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3357 ac_clean_files=$ac_clean_files_save
3358 # Check the compiler produces executables we can run.  If not, either
3359 # the compiler is broken, or we cross compile.
3360 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3361 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3362 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3363 echo "${ECHO_T}$cross_compiling" >&6
3364
3365 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3366 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3367 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3368   (eval $ac_link) 2>&5
3369   ac_status=$?
3370   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3371   (exit $ac_status); }; then
3372   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3373 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3374 # work properly (i.e., refer to `conftest.exe'), while it won't with
3375 # `rm'.
3376 for ac_file in conftest.exe conftest conftest.*; do
3377   test -f "$ac_file" || continue
3378   case $ac_file in
3379     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3380     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3381           export ac_cv_exeext
3382           break;;
3383     * ) break;;
3384   esac
3385 done
3386 else
3387   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3388 See \`config.log' for more details." >&5
3389 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3390 See \`config.log' for more details." >&2;}
3391    { (exit 1); exit 1; }; }
3392 fi
3393
3394 rm -f conftest$ac_cv_exeext
3395 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3396 echo "${ECHO_T}$ac_cv_exeext" >&6
3397
3398 rm -f conftest.$ac_ext
3399 EXEEXT=$ac_cv_exeext
3400 ac_exeext=$EXEEXT
3401 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3402 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3403 if test "${ac_cv_objext+set}" = set; then
3404   echo $ECHO_N "(cached) $ECHO_C" >&6
3405 else
3406   cat >conftest.$ac_ext <<_ACEOF
3407 /* confdefs.h.  */
3408 _ACEOF
3409 cat confdefs.h >>conftest.$ac_ext
3410 cat >>conftest.$ac_ext <<_ACEOF
3411 /* end confdefs.h.  */
3412
3413 int
3414 main ()
3415 {
3416
3417   ;
3418   return 0;
3419 }
3420 _ACEOF
3421 rm -f conftest.o conftest.obj
3422 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3423   (eval $ac_compile) 2>&5
3424   ac_status=$?
3425   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3426   (exit $ac_status); }; then
3427   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3428   case $ac_file in
3429     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3430     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3431        break;;
3432   esac
3433 done
3434 else
3435   echo "$as_me: failed program was:" >&5
3436 sed 's/^/| /' conftest.$ac_ext >&5
3437
3438 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3439 See \`config.log' for more details." >&5
3440 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3441 See \`config.log' for more details." >&2;}
3442    { (exit 1); exit 1; }; }
3443 fi
3444
3445 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3446 fi
3447 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3448 echo "${ECHO_T}$ac_cv_objext" >&6
3449 OBJEXT=$ac_cv_objext
3450 ac_objext=$OBJEXT
3451 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3452 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3453 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3454   echo $ECHO_N "(cached) $ECHO_C" >&6
3455 else
3456   cat >conftest.$ac_ext <<_ACEOF
3457 /* confdefs.h.  */
3458 _ACEOF
3459 cat confdefs.h >>conftest.$ac_ext
3460 cat >>conftest.$ac_ext <<_ACEOF
3461 /* end confdefs.h.  */
3462
3463 int
3464 main ()
3465 {
3466 #ifndef __GNUC__
3467        choke me
3468 #endif
3469
3470   ;
3471   return 0;
3472 }
3473 _ACEOF
3474 rm -f conftest.$ac_objext
3475 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3476   (eval $ac_compile) 2>conftest.er1
3477   ac_status=$?
3478   grep -v '^ *+' conftest.er1 >conftest.err
3479   rm -f conftest.er1
3480   cat conftest.err >&5
3481   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3482   (exit $ac_status); } &&
3483          { ac_try='test -z "$ac_c_werror_flag"
3484                          || test ! -s conftest.err'
3485   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3486   (eval $ac_try) 2>&5
3487   ac_status=$?
3488   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3489   (exit $ac_status); }; } &&
3490          { ac_try='test -s conftest.$ac_objext'
3491   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3492   (eval $ac_try) 2>&5
3493   ac_status=$?
3494   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3495   (exit $ac_status); }; }; then
3496   ac_compiler_gnu=yes
3497 else
3498   echo "$as_me: failed program was:" >&5
3499 sed 's/^/| /' conftest.$ac_ext >&5
3500
3501 ac_compiler_gnu=no
3502 fi
3503 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3504 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3505
3506 fi
3507 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3508 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3509 GCC=`test $ac_compiler_gnu = yes && echo yes`
3510 ac_test_CFLAGS=${CFLAGS+set}
3511 ac_save_CFLAGS=$CFLAGS
3512 CFLAGS="-g"
3513 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3514 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3515 if test "${ac_cv_prog_cc_g+set}" = set; then
3516   echo $ECHO_N "(cached) $ECHO_C" >&6
3517 else
3518   cat >conftest.$ac_ext <<_ACEOF
3519 /* confdefs.h.  */
3520 _ACEOF
3521 cat confdefs.h >>conftest.$ac_ext
3522 cat >>conftest.$ac_ext <<_ACEOF
3523 /* end confdefs.h.  */
3524
3525 int
3526 main ()
3527 {
3528
3529   ;
3530   return 0;
3531 }
3532 _ACEOF
3533 rm -f conftest.$ac_objext
3534 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3535   (eval $ac_compile) 2>conftest.er1
3536   ac_status=$?
3537   grep -v '^ *+' conftest.er1 >conftest.err
3538   rm -f conftest.er1
3539   cat conftest.err >&5
3540   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3541   (exit $ac_status); } &&
3542          { ac_try='test -z "$ac_c_werror_flag"
3543                          || test ! -s conftest.err'
3544   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3545   (eval $ac_try) 2>&5
3546   ac_status=$?
3547   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3548   (exit $ac_status); }; } &&
3549          { ac_try='test -s conftest.$ac_objext'
3550   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3551   (eval $ac_try) 2>&5
3552   ac_status=$?
3553   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3554   (exit $ac_status); }; }; then
3555   ac_cv_prog_cc_g=yes
3556 else
3557   echo "$as_me: failed program was:" >&5
3558 sed 's/^/| /' conftest.$ac_ext >&5
3559
3560 ac_cv_prog_cc_g=no
3561 fi
3562 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3563 fi
3564 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3565 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3566 if test "$ac_test_CFLAGS" = set; then
3567   CFLAGS=$ac_save_CFLAGS
3568 elif test $ac_cv_prog_cc_g = yes; then
3569   if test "$GCC" = yes; then
3570     CFLAGS="-g -O2"
3571   else
3572     CFLAGS="-g"
3573   fi
3574 else
3575   if test "$GCC" = yes; then
3576     CFLAGS="-O2"
3577   else
3578     CFLAGS=
3579   fi
3580 fi
3581 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3582 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3583 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3584   echo $ECHO_N "(cached) $ECHO_C" >&6
3585 else
3586   ac_cv_prog_cc_stdc=no
3587 ac_save_CC=$CC
3588 cat >conftest.$ac_ext <<_ACEOF
3589 /* confdefs.h.  */
3590 _ACEOF
3591 cat confdefs.h >>conftest.$ac_ext
3592 cat >>conftest.$ac_ext <<_ACEOF
3593 /* end confdefs.h.  */
3594 #include <stdarg.h>
3595 #include <stdio.h>
3596 #include <sys/types.h>
3597 #include <sys/stat.h>
3598 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3599 struct buf { int x; };
3600 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3601 static char *e (p, i)
3602      char **p;
3603      int i;
3604 {
3605   return p[i];
3606 }
3607 static char *f (char * (*g) (char **, int), char **p, ...)
3608 {
3609   char *s;
3610   va_list v;
3611   va_start (v,p);
3612   s = g (p, va_arg (v,int));
3613   va_end (v);
3614   return s;
3615 }
3616
3617 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3618    function prototypes and stuff, but not '\xHH' hex character constants.
3619    These don't provoke an error unfortunately, instead are silently treated
3620    as 'x'.  The following induces an error, until -std1 is added to get
3621    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3622    array size at least.  It's necessary to write '\x00'==0 to get something
3623    that's true only with -std1.  */
3624 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3625
3626 int test (int i, double x);
3627 struct s1 {int (*f) (int a);};
3628 struct s2 {int (*f) (double a);};
3629 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3630 int argc;
3631 char **argv;
3632 int
3633 main ()
3634 {
3635 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3636   ;
3637   return 0;
3638 }
3639 _ACEOF
3640 # Don't try gcc -ansi; that turns off useful extensions and
3641 # breaks some systems' header files.
3642 # AIX                   -qlanglvl=ansi
3643 # Ultrix and OSF/1      -std1
3644 # HP-UX 10.20 and later -Ae
3645 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3646 # SVR4                  -Xc -D__EXTENSIONS__
3647 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3648 do
3649   CC="$ac_save_CC $ac_arg"
3650   rm -f conftest.$ac_objext
3651 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3652   (eval $ac_compile) 2>conftest.er1
3653   ac_status=$?
3654   grep -v '^ *+' conftest.er1 >conftest.err
3655   rm -f conftest.er1
3656   cat conftest.err >&5
3657   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3658   (exit $ac_status); } &&
3659          { ac_try='test -z "$ac_c_werror_flag"
3660                          || test ! -s conftest.err'
3661   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3662   (eval $ac_try) 2>&5
3663   ac_status=$?
3664   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3665   (exit $ac_status); }; } &&
3666          { ac_try='test -s conftest.$ac_objext'
3667   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3668   (eval $ac_try) 2>&5
3669   ac_status=$?
3670   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3671   (exit $ac_status); }; }; then
3672   ac_cv_prog_cc_stdc=$ac_arg
3673 break
3674 else
3675   echo "$as_me: failed program was:" >&5
3676 sed 's/^/| /' conftest.$ac_ext >&5
3677
3678 fi
3679 rm -f conftest.err conftest.$ac_objext
3680 done
3681 rm -f conftest.$ac_ext conftest.$ac_objext
3682 CC=$ac_save_CC
3683
3684 fi
3685
3686 case "x$ac_cv_prog_cc_stdc" in
3687   x|xno)
3688     echo "$as_me:$LINENO: result: none needed" >&5
3689 echo "${ECHO_T}none needed" >&6 ;;
3690   *)
3691     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3692 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3693     CC="$CC $ac_cv_prog_cc_stdc" ;;
3694 esac
3695
3696 # Some people use a C++ compiler to compile C.  Since we use `exit',
3697 # in C++ we need to declare it.  In case someone uses the same compiler
3698 # for both compiling C and C++ we need to have the C++ compiler decide
3699 # the declaration of exit, since it's the most demanding environment.
3700 cat >conftest.$ac_ext <<_ACEOF
3701 #ifndef __cplusplus
3702   choke me
3703 #endif
3704 _ACEOF
3705 rm -f conftest.$ac_objext
3706 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3707   (eval $ac_compile) 2>conftest.er1
3708   ac_status=$?
3709   grep -v '^ *+' conftest.er1 >conftest.err
3710   rm -f conftest.er1
3711   cat conftest.err >&5
3712   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3713   (exit $ac_status); } &&
3714          { ac_try='test -z "$ac_c_werror_flag"
3715                          || test ! -s conftest.err'
3716   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3717   (eval $ac_try) 2>&5
3718   ac_status=$?
3719   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3720   (exit $ac_status); }; } &&
3721          { ac_try='test -s conftest.$ac_objext'
3722   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3723   (eval $ac_try) 2>&5
3724   ac_status=$?
3725   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3726   (exit $ac_status); }; }; then
3727   for ac_declaration in \
3728    '' \
3729    'extern "C" void std::exit (int) throw (); using std::exit;' \
3730    'extern "C" void std::exit (int); using std::exit;' \
3731    'extern "C" void exit (int) throw ();' \
3732    'extern "C" void exit (int);' \
3733    'void exit (int);'
3734 do
3735   cat >conftest.$ac_ext <<_ACEOF
3736 /* confdefs.h.  */
3737 _ACEOF
3738 cat confdefs.h >>conftest.$ac_ext
3739 cat >>conftest.$ac_ext <<_ACEOF
3740 /* end confdefs.h.  */
3741 $ac_declaration
3742 #include <stdlib.h>
3743 int
3744 main ()
3745 {
3746 exit (42);
3747   ;
3748   return 0;
3749 }
3750 _ACEOF
3751 rm -f conftest.$ac_objext
3752 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3753   (eval $ac_compile) 2>conftest.er1
3754   ac_status=$?
3755   grep -v '^ *+' conftest.er1 >conftest.err
3756   rm -f conftest.er1
3757   cat conftest.err >&5
3758   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3759   (exit $ac_status); } &&
3760          { ac_try='test -z "$ac_c_werror_flag"
3761                          || test ! -s conftest.err'
3762   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3763   (eval $ac_try) 2>&5
3764   ac_status=$?
3765   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3766   (exit $ac_status); }; } &&
3767          { ac_try='test -s conftest.$ac_objext'
3768   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3769   (eval $ac_try) 2>&5
3770   ac_status=$?
3771   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3772   (exit $ac_status); }; }; then
3773   :
3774 else
3775   echo "$as_me: failed program was:" >&5
3776 sed 's/^/| /' conftest.$ac_ext >&5
3777
3778 continue
3779 fi
3780 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3781   cat >conftest.$ac_ext <<_ACEOF
3782 /* confdefs.h.  */
3783 _ACEOF
3784 cat confdefs.h >>conftest.$ac_ext
3785 cat >>conftest.$ac_ext <<_ACEOF
3786 /* end confdefs.h.  */
3787 $ac_declaration
3788 int
3789 main ()
3790 {
3791 exit (42);
3792   ;
3793   return 0;
3794 }
3795 _ACEOF
3796 rm -f conftest.$ac_objext
3797 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3798   (eval $ac_compile) 2>conftest.er1
3799   ac_status=$?
3800   grep -v '^ *+' conftest.er1 >conftest.err
3801   rm -f conftest.er1
3802   cat conftest.err >&5
3803   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3804   (exit $ac_status); } &&
3805          { ac_try='test -z "$ac_c_werror_flag"
3806                          || test ! -s conftest.err'
3807   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3808   (eval $ac_try) 2>&5
3809   ac_status=$?
3810   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3811   (exit $ac_status); }; } &&
3812          { ac_try='test -s conftest.$ac_objext'
3813   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3814   (eval $ac_try) 2>&5
3815   ac_status=$?
3816   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3817   (exit $ac_status); }; }; then
3818   break
3819 else
3820   echo "$as_me: failed program was:" >&5
3821 sed 's/^/| /' conftest.$ac_ext >&5
3822
3823 fi
3824 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3825 done
3826 rm -f conftest*
3827 if test -n "$ac_declaration"; then
3828   echo '#ifdef __cplusplus' >>confdefs.h
3829   echo $ac_declaration      >>confdefs.h
3830   echo '#endif'             >>confdefs.h
3831 fi
3832
3833 else
3834   echo "$as_me: failed program was:" >&5
3835 sed 's/^/| /' conftest.$ac_ext >&5
3836
3837 fi
3838 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3839 ac_ext=c
3840 ac_cpp='$CPP $CPPFLAGS'
3841 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3842 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3843 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3844
3845 ac_ext=cc
3846 ac_cpp='$CXXCPP $CPPFLAGS'
3847 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3848 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3849 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3850 if test -n "$ac_tool_prefix"; then
3851   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3852   do
3853     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3854 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3855 echo "$as_me:$LINENO: checking for $ac_word" >&5
3856 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3857 if test "${ac_cv_prog_CXX+set}" = set; then
3858   echo $ECHO_N "(cached) $ECHO_C" >&6
3859 else
3860   if test -n "$CXX"; then
3861   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3862 else
3863 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3864 for as_dir in $PATH
3865 do
3866   IFS=$as_save_IFS
3867   test -z "$as_dir" && as_dir=.
3868   for ac_exec_ext in '' $ac_executable_extensions; do
3869   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3870     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3871     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3872     break 2
3873   fi
3874 done
3875 done
3876
3877 fi
3878 fi
3879 CXX=$ac_cv_prog_CXX
3880 if test -n "$CXX"; then
3881   echo "$as_me:$LINENO: result: $CXX" >&5
3882 echo "${ECHO_T}$CXX" >&6
3883 else
3884   echo "$as_me:$LINENO: result: no" >&5
3885 echo "${ECHO_T}no" >&6
3886 fi
3887
3888     test -n "$CXX" && break
3889   done
3890 fi
3891 if test -z "$CXX"; then
3892   ac_ct_CXX=$CXX
3893   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3894 do
3895   # Extract the first word of "$ac_prog", so it can be a program name with args.
3896 set dummy $ac_prog; ac_word=$2
3897 echo "$as_me:$LINENO: checking for $ac_word" >&5
3898 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3899 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3900   echo $ECHO_N "(cached) $ECHO_C" >&6
3901 else
3902   if test -n "$ac_ct_CXX"; then
3903   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3904 else
3905 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3906 for as_dir in $PATH
3907 do
3908   IFS=$as_save_IFS
3909   test -z "$as_dir" && as_dir=.
3910   for ac_exec_ext in '' $ac_executable_extensions; do
3911   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3912     ac_cv_prog_ac_ct_CXX="$ac_prog"
3913     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3914     break 2
3915   fi
3916 done
3917 done
3918
3919 fi
3920 fi
3921 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3922 if test -n "$ac_ct_CXX"; then
3923   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3924 echo "${ECHO_T}$ac_ct_CXX" >&6
3925 else
3926   echo "$as_me:$LINENO: result: no" >&5
3927 echo "${ECHO_T}no" >&6
3928 fi
3929
3930   test -n "$ac_ct_CXX" && break
3931 done
3932 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3933
3934   CXX=$ac_ct_CXX
3935 fi
3936
3937
3938 # Provide some information about the compiler.
3939 echo "$as_me:$LINENO:" \
3940      "checking for C++ compiler version" >&5
3941 ac_compiler=`set X $ac_compile; echo $2`
3942 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3943   (eval $ac_compiler --version </dev/null >&5) 2>&5
3944   ac_status=$?
3945   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3946   (exit $ac_status); }
3947 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3948   (eval $ac_compiler -v </dev/null >&5) 2>&5
3949   ac_status=$?
3950   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3951   (exit $ac_status); }
3952 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3953   (eval $ac_compiler -V </dev/null >&5) 2>&5
3954   ac_status=$?
3955   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3956   (exit $ac_status); }
3957
3958 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3959 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3960 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3961   echo $ECHO_N "(cached) $ECHO_C" >&6
3962 else
3963   cat >conftest.$ac_ext <<_ACEOF
3964 /* confdefs.h.  */
3965 _ACEOF
3966 cat confdefs.h >>conftest.$ac_ext
3967 cat >>conftest.$ac_ext <<_ACEOF
3968 /* end confdefs.h.  */
3969
3970 int
3971 main ()
3972 {
3973 #ifndef __GNUC__
3974        choke me
3975 #endif
3976
3977   ;
3978   return 0;
3979 }
3980 _ACEOF
3981 rm -f conftest.$ac_objext
3982 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3983   (eval $ac_compile) 2>conftest.er1
3984   ac_status=$?
3985   grep -v '^ *+' conftest.er1 >conftest.err
3986   rm -f conftest.er1
3987   cat conftest.err >&5
3988   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3989   (exit $ac_status); } &&
3990          { ac_try='test -z "$ac_cxx_werror_flag"
3991                          || test ! -s conftest.err'
3992   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3993   (eval $ac_try) 2>&5
3994   ac_status=$?
3995   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3996   (exit $ac_status); }; } &&
3997          { ac_try='test -s conftest.$ac_objext'
3998   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3999   (eval $ac_try) 2>&5
4000   ac_status=$?
4001   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4002   (exit $ac_status); }; }; then
4003   ac_compiler_gnu=yes
4004 else
4005   echo "$as_me: failed program was:" >&5
4006 sed 's/^/| /' conftest.$ac_ext >&5
4007
4008 ac_compiler_gnu=no
4009 fi
4010 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4011 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4012
4013 fi
4014 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4015 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4016 GXX=`test $ac_compiler_gnu = yes && echo yes`
4017 ac_test_CXXFLAGS=${CXXFLAGS+set}
4018 ac_save_CXXFLAGS=$CXXFLAGS
4019 CXXFLAGS="-g"
4020 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4021 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4022 if test "${ac_cv_prog_cxx_g+set}" = set; then
4023   echo $ECHO_N "(cached) $ECHO_C" >&6
4024 else
4025   cat >conftest.$ac_ext <<_ACEOF
4026 /* confdefs.h.  */
4027 _ACEOF
4028 cat confdefs.h >>conftest.$ac_ext
4029 cat >>conftest.$ac_ext <<_ACEOF
4030 /* end confdefs.h.  */
4031
4032 int
4033 main ()
4034 {
4035
4036   ;
4037   return 0;
4038 }
4039 _ACEOF
4040 rm -f conftest.$ac_objext
4041 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4042   (eval $ac_compile) 2>conftest.er1
4043   ac_status=$?
4044   grep -v '^ *+' conftest.er1 >conftest.err
4045   rm -f conftest.er1
4046   cat conftest.err >&5
4047   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4048   (exit $ac_status); } &&
4049          { ac_try='test -z "$ac_cxx_werror_flag"
4050                          || test ! -s conftest.err'
4051   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4052   (eval $ac_try) 2>&5
4053   ac_status=$?
4054   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4055   (exit $ac_status); }; } &&
4056          { ac_try='test -s conftest.$ac_objext'
4057   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4058   (eval $ac_try) 2>&5
4059   ac_status=$?
4060   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4061   (exit $ac_status); }; }; then
4062   ac_cv_prog_cxx_g=yes
4063 else
4064   echo "$as_me: failed program was:" >&5
4065 sed 's/^/| /' conftest.$ac_ext >&5
4066
4067 ac_cv_prog_cxx_g=no
4068 fi
4069 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4070 fi
4071 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4072 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4073 if test "$ac_test_CXXFLAGS" = set; then
4074   CXXFLAGS=$ac_save_CXXFLAGS
4075 elif test $ac_cv_prog_cxx_g = yes; then
4076   if test "$GXX" = yes; then
4077     CXXFLAGS="-g -O2"
4078   else
4079     CXXFLAGS="-g"
4080   fi
4081 else
4082   if test "$GXX" = yes; then
4083     CXXFLAGS="-O2"
4084   else
4085     CXXFLAGS=
4086   fi
4087 fi
4088 for ac_declaration in \
4089    '' \
4090    'extern "C" void std::exit (int) throw (); using std::exit;' \
4091    'extern "C" void std::exit (int); using std::exit;' \
4092    'extern "C" void exit (int) throw ();' \
4093    'extern "C" void exit (int);' \
4094    'void exit (int);'
4095 do
4096   cat >conftest.$ac_ext <<_ACEOF
4097 /* confdefs.h.  */
4098 _ACEOF
4099 cat confdefs.h >>conftest.$ac_ext
4100 cat >>conftest.$ac_ext <<_ACEOF
4101 /* end confdefs.h.  */
4102 $ac_declaration
4103 #include <stdlib.h>
4104 int
4105 main ()
4106 {
4107 exit (42);
4108   ;
4109   return 0;
4110 }
4111 _ACEOF
4112 rm -f conftest.$ac_objext
4113 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4114   (eval $ac_compile) 2>conftest.er1
4115   ac_status=$?
4116   grep -v '^ *+' conftest.er1 >conftest.err
4117   rm -f conftest.er1
4118   cat conftest.err >&5
4119   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4120   (exit $ac_status); } &&
4121          { ac_try='test -z "$ac_cxx_werror_flag"
4122                          || test ! -s conftest.err'
4123   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4124   (eval $ac_try) 2>&5
4125   ac_status=$?
4126   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4127   (exit $ac_status); }; } &&
4128          { ac_try='test -s conftest.$ac_objext'
4129   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4130   (eval $ac_try) 2>&5
4131   ac_status=$?
4132   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4133   (exit $ac_status); }; }; then
4134   :
4135 else
4136   echo "$as_me: failed program was:" >&5
4137 sed 's/^/| /' conftest.$ac_ext >&5
4138
4139 continue
4140 fi
4141 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4142   cat >conftest.$ac_ext <<_ACEOF
4143 /* confdefs.h.  */
4144 _ACEOF
4145 cat confdefs.h >>conftest.$ac_ext
4146 cat >>conftest.$ac_ext <<_ACEOF
4147 /* end confdefs.h.  */
4148 $ac_declaration
4149 int
4150 main ()
4151 {
4152 exit (42);
4153   ;
4154   return 0;
4155 }
4156 _ACEOF
4157 rm -f conftest.$ac_objext
4158 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4159   (eval $ac_compile) 2>conftest.er1
4160   ac_status=$?
4161   grep -v '^ *+' conftest.er1 >conftest.err
4162   rm -f conftest.er1
4163   cat conftest.err >&5
4164   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4165   (exit $ac_status); } &&
4166          { ac_try='test -z "$ac_cxx_werror_flag"
4167                          || test ! -s conftest.err'
4168   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4169   (eval $ac_try) 2>&5
4170   ac_status=$?
4171   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4172   (exit $ac_status); }; } &&
4173          { ac_try='test -s conftest.$ac_objext'
4174   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4175   (eval $ac_try) 2>&5
4176   ac_status=$?
4177   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4178   (exit $ac_status); }; }; then
4179   break
4180 else
4181   echo "$as_me: failed program was:" >&5
4182 sed 's/^/| /' conftest.$ac_ext >&5
4183
4184 fi
4185 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4186 done
4187 rm -f conftest*
4188 if test -n "$ac_declaration"; then
4189   echo '#ifdef __cplusplus' >>confdefs.h
4190   echo $ac_declaration      >>confdefs.h
4191   echo '#endif'             >>confdefs.h
4192 fi
4193
4194 ac_ext=c
4195 ac_cpp='$CPP $CPPFLAGS'
4196 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4197 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4198 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4199
4200
4201 # We must set the default linker to the linker used by gcc for the correct
4202 # operation of libtool.  If LD is not defined and we are using gcc, try to
4203 # set the LD default to the ld used by gcc.
4204 if test -z "$LD"; then
4205   if test "$GCC" = yes; then
4206     case $build in
4207     *-*-mingw*)
4208       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4209     *)
4210       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4211     esac
4212     case $gcc_prog_ld in
4213     # Accept absolute paths.
4214     [\\/]* | [A-Za-z]:[\\/]*)
4215       LD="$gcc_prog_ld" ;;
4216     esac
4217   fi
4218 fi
4219
4220
4221
4222
4223 if test -n "$ac_tool_prefix"; then
4224   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4225 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4226 echo "$as_me:$LINENO: checking for $ac_word" >&5
4227 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4228 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4229   echo $ECHO_N "(cached) $ECHO_C" >&6
4230 else
4231   if test -n "$GNATBIND"; then
4232   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4233 else
4234 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4235 for as_dir in $PATH
4236 do
4237   IFS=$as_save_IFS
4238   test -z "$as_dir" && as_dir=.
4239   for ac_exec_ext in '' $ac_executable_extensions; do
4240   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4241     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4242     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4243     break 2
4244   fi
4245 done
4246 done
4247
4248 fi
4249 fi
4250 GNATBIND=$ac_cv_prog_GNATBIND
4251 if test -n "$GNATBIND"; then
4252   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4253 echo "${ECHO_T}$GNATBIND" >&6
4254 else
4255   echo "$as_me:$LINENO: result: no" >&5
4256 echo "${ECHO_T}no" >&6
4257 fi
4258
4259 fi
4260 if test -z "$ac_cv_prog_GNATBIND"; then
4261   ac_ct_GNATBIND=$GNATBIND
4262   # Extract the first word of "gnatbind", so it can be a program name with args.
4263 set dummy gnatbind; ac_word=$2
4264 echo "$as_me:$LINENO: checking for $ac_word" >&5
4265 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4266 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4267   echo $ECHO_N "(cached) $ECHO_C" >&6
4268 else
4269   if test -n "$ac_ct_GNATBIND"; then
4270   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4271 else
4272 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4273 for as_dir in $PATH
4274 do
4275   IFS=$as_save_IFS
4276   test -z "$as_dir" && as_dir=.
4277   for ac_exec_ext in '' $ac_executable_extensions; do
4278   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4279     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4280     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4281     break 2
4282   fi
4283 done
4284 done
4285
4286   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4287 fi
4288 fi
4289 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4290 if test -n "$ac_ct_GNATBIND"; then
4291   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4292 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4293 else
4294   echo "$as_me:$LINENO: result: no" >&5
4295 echo "${ECHO_T}no" >&6
4296 fi
4297
4298   GNATBIND=$ac_ct_GNATBIND
4299 else
4300   GNATBIND="$ac_cv_prog_GNATBIND"
4301 fi
4302
4303 if test -n "$ac_tool_prefix"; then
4304   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4305 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4306 echo "$as_me:$LINENO: checking for $ac_word" >&5
4307 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4308 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4309   echo $ECHO_N "(cached) $ECHO_C" >&6
4310 else
4311   if test -n "$GNATMAKE"; then
4312   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4313 else
4314 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4315 for as_dir in $PATH
4316 do
4317   IFS=$as_save_IFS
4318   test -z "$as_dir" && as_dir=.
4319   for ac_exec_ext in '' $ac_executable_extensions; do
4320   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4321     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4322     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4323     break 2
4324   fi
4325 done
4326 done
4327
4328 fi
4329 fi
4330 GNATMAKE=$ac_cv_prog_GNATMAKE
4331 if test -n "$GNATMAKE"; then
4332   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4333 echo "${ECHO_T}$GNATMAKE" >&6
4334 else
4335   echo "$as_me:$LINENO: result: no" >&5
4336 echo "${ECHO_T}no" >&6
4337 fi
4338
4339 fi
4340 if test -z "$ac_cv_prog_GNATMAKE"; then
4341   ac_ct_GNATMAKE=$GNATMAKE
4342   # Extract the first word of "gnatmake", so it can be a program name with args.
4343 set dummy gnatmake; ac_word=$2
4344 echo "$as_me:$LINENO: checking for $ac_word" >&5
4345 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4346 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4347   echo $ECHO_N "(cached) $ECHO_C" >&6
4348 else
4349   if test -n "$ac_ct_GNATMAKE"; then
4350   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4351 else
4352 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4353 for as_dir in $PATH
4354 do
4355   IFS=$as_save_IFS
4356   test -z "$as_dir" && as_dir=.
4357   for ac_exec_ext in '' $ac_executable_extensions; do
4358   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4359     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4360     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4361     break 2
4362   fi
4363 done
4364 done
4365
4366   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4367 fi
4368 fi
4369 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4370 if test -n "$ac_ct_GNATMAKE"; then
4371   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4372 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4373 else
4374   echo "$as_me:$LINENO: result: no" >&5
4375 echo "${ECHO_T}no" >&6
4376 fi
4377
4378   GNATMAKE=$ac_ct_GNATMAKE
4379 else
4380   GNATMAKE="$ac_cv_prog_GNATMAKE"
4381 fi
4382
4383 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4384 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4385 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4386   echo $ECHO_N "(cached) $ECHO_C" >&6
4387 else
4388   cat >conftest.adb <<EOF
4389 procedure conftest is begin null; end conftest;
4390 EOF
4391 acx_cv_cc_gcc_supports_ada=no
4392 # There is a bug in old released versions of GCC which causes the
4393 # driver to exit successfully when the appropriate language module
4394 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4395 # Therefore we must check for the error message as well as an
4396 # unsuccessful exit.
4397 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4398 # given a .adb file, but produce no object file.  So we must check
4399 # if an object file was really produced to guard against this.
4400 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4401 if test x"$errors" = x && test -f conftest.$ac_objext; then
4402   acx_cv_cc_gcc_supports_ada=yes
4403 fi
4404 rm -f conftest.*
4405 fi
4406 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4407 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4408
4409 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4410   have_gnat=yes
4411 else
4412   have_gnat=no
4413 fi
4414
4415 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4416 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4417 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4418   echo $ECHO_N "(cached) $ECHO_C" >&6
4419 else
4420    echo abfoo >t1
4421   echo cdfoo >t2
4422   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4423   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4424     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4425       :
4426     else
4427       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4428     fi
4429   fi
4430   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4431     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4432       :
4433     else
4434       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4435     fi
4436   fi
4437   rm t1 t2
4438
4439 fi
4440 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4441 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4442 do_compare="$gcc_cv_prog_cmp_skip"
4443
4444
4445
4446 # Check for GMP and MPFR
4447 gmplibs="-lmpfr -lgmp"
4448 gmpinc=
4449 have_gmp=no
4450
4451 # Specify a location for mpfr
4452 # check for this first so it ends up on the link line before gmp.
4453
4454 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4455 if test "${with_mpfr_dir+set}" = set; then
4456   withval="$with_mpfr_dir"
4457   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4458 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4459 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4460 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4461    { (exit 1); exit 1; }; }
4462 fi;
4463
4464
4465 # Check whether --with-mpfr or --without-mpfr was given.
4466 if test "${with_mpfr+set}" = set; then
4467   withval="$with_mpfr"
4468
4469 fi;
4470
4471 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4472 if test "${with_mpfr_include+set}" = set; then
4473   withval="$with_mpfr_include"
4474
4475 fi;
4476
4477 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4478 if test "${with_mpfr_lib+set}" = set; then
4479   withval="$with_mpfr_lib"
4480
4481 fi;
4482
4483 if test "x$with_mpfr" != x; then
4484   gmplibs="-L$with_mpfr/lib $gmplibs"
4485   gmpinc="-I$with_mpfr/include"
4486 fi
4487 if test "x$with_mpfr_include" != x; then
4488   gmpinc="-I$with_mpfr_include"
4489 fi
4490 if test "x$with_mpfr_lib" != x; then
4491   gmplibs="-L$with_mpfr_lib $gmplibs"
4492 fi
4493 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4494   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4495   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4496   # Do not test the mpfr version.  Assume that it is sufficient, since
4497   # it is in the source tree, and the library has not been built yet
4498   # but it would be included on the link line in the version check below
4499   # hence making the test fail.
4500   have_gmp=yes
4501 fi
4502
4503 # Specify a location for gmp
4504
4505 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4506 if test "${with_gmp_dir+set}" = set; then
4507   withval="$with_gmp_dir"
4508   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4509 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4510 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4511 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4512    { (exit 1); exit 1; }; }
4513 fi;
4514
4515
4516 # Check whether --with-gmp or --without-gmp was given.
4517 if test "${with_gmp+set}" = set; then
4518   withval="$with_gmp"
4519
4520 fi;
4521
4522 # Check whether --with-gmp_include or --without-gmp_include was given.
4523 if test "${with_gmp_include+set}" = set; then
4524   withval="$with_gmp_include"
4525
4526 fi;
4527
4528 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4529 if test "${with_gmp_lib+set}" = set; then
4530   withval="$with_gmp_lib"
4531
4532 fi;
4533
4534
4535 if test "x$with_gmp" != x; then
4536   gmplibs="-L$with_gmp/lib $gmplibs"
4537   gmpinc="-I$with_gmp/include $gmpinc"
4538 fi
4539 if test "x$with_gmp_include" != x; then
4540   gmpinc="-I$with_gmp_include $gmpinc"
4541 fi
4542 if test "x$with_gmp_lib" != x; then
4543   gmplibs="-L$with_gmp_lib $gmplibs"
4544 fi
4545 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4546   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4547   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4548   # Do not test the gmp version.  Assume that it is sufficient, since
4549   # it is in the source tree, and the library has not been built yet
4550   # but it would be included on the link line in the version check below
4551   # hence making the test fail.
4552   have_gmp=yes
4553 fi
4554
4555 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4556   have_gmp=yes
4557   saved_CFLAGS="$CFLAGS"
4558   CFLAGS="$CFLAGS $gmpinc"
4559   # Check GMP actually works
4560   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4561 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4562
4563 cat >conftest.$ac_ext <<_ACEOF
4564 /* confdefs.h.  */
4565 _ACEOF
4566 cat confdefs.h >>conftest.$ac_ext
4567 cat >>conftest.$ac_ext <<_ACEOF
4568 /* end confdefs.h.  */
4569 #include "gmp.h"
4570 int
4571 main ()
4572 {
4573
4574   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4575   choke me
4576   #endif
4577
4578   ;
4579   return 0;
4580 }
4581 _ACEOF
4582 rm -f conftest.$ac_objext
4583 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4584   (eval $ac_compile) 2>conftest.er1
4585   ac_status=$?
4586   grep -v '^ *+' conftest.er1 >conftest.err
4587   rm -f conftest.er1
4588   cat conftest.err >&5
4589   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4590   (exit $ac_status); } &&
4591          { ac_try='test -z "$ac_c_werror_flag"
4592                          || test ! -s conftest.err'
4593   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4594   (eval $ac_try) 2>&5
4595   ac_status=$?
4596   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4597   (exit $ac_status); }; } &&
4598          { ac_try='test -s conftest.$ac_objext'
4599   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4600   (eval $ac_try) 2>&5
4601   ac_status=$?
4602   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4603   (exit $ac_status); }; }; then
4604   echo "$as_me:$LINENO: result: yes" >&5
4605 echo "${ECHO_T}yes" >&6
4606 else
4607   echo "$as_me: failed program was:" >&5
4608 sed 's/^/| /' conftest.$ac_ext >&5
4609
4610 echo "$as_me:$LINENO: result: no" >&5
4611 echo "${ECHO_T}no" >&6; have_gmp=no
4612 fi
4613 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4614
4615   if test x"$have_gmp" = xyes; then
4616     saved_LIBS="$LIBS"
4617     LIBS="$LIBS $gmplibs"
4618         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4619 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4620     cat >conftest.$ac_ext <<_ACEOF
4621 /* confdefs.h.  */
4622 _ACEOF
4623 cat confdefs.h >>conftest.$ac_ext
4624 cat >>conftest.$ac_ext <<_ACEOF
4625 /* end confdefs.h.  */
4626 #include <gmp.h>
4627     #include <mpfr.h>
4628 int
4629 main ()
4630 {
4631
4632     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4633     choke me
4634     #endif
4635     mpfr_t n;
4636     mpfr_t x;
4637     int t;
4638     mpfr_init (n);
4639     mpfr_init (x);
4640     mpfr_atan2 (n, n, x, GMP_RNDN);
4641     mpfr_erfc (n, x, GMP_RNDN);
4642     mpfr_subnormalize (x, t, GMP_RNDN);
4643
4644   ;
4645   return 0;
4646 }
4647 _ACEOF
4648 rm -f conftest.$ac_objext conftest$ac_exeext
4649 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4650   (eval $ac_link) 2>conftest.er1
4651   ac_status=$?
4652   grep -v '^ *+' conftest.er1 >conftest.err
4653   rm -f conftest.er1
4654   cat conftest.err >&5
4655   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4656   (exit $ac_status); } &&
4657          { ac_try='test -z "$ac_c_werror_flag"
4658                          || test ! -s conftest.err'
4659   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4660   (eval $ac_try) 2>&5
4661   ac_status=$?
4662   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4663   (exit $ac_status); }; } &&
4664          { ac_try='test -s conftest$ac_exeext'
4665   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4666   (eval $ac_try) 2>&5
4667   ac_status=$?
4668   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4669   (exit $ac_status); }; }; then
4670   cat >conftest.$ac_ext <<_ACEOF
4671 /* confdefs.h.  */
4672 _ACEOF
4673 cat confdefs.h >>conftest.$ac_ext
4674 cat >>conftest.$ac_ext <<_ACEOF
4675 /* end confdefs.h.  */
4676 #include <gmp.h>
4677     #include <mpfr.h>
4678 int
4679 main ()
4680 {
4681
4682     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4683     choke me
4684     #endif
4685     mpfr_t n; mpfr_init(n);
4686
4687   ;
4688   return 0;
4689 }
4690 _ACEOF
4691 rm -f conftest.$ac_objext conftest$ac_exeext
4692 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4693   (eval $ac_link) 2>conftest.er1
4694   ac_status=$?
4695   grep -v '^ *+' conftest.er1 >conftest.err
4696   rm -f conftest.er1
4697   cat conftest.err >&5
4698   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4699   (exit $ac_status); } &&
4700          { ac_try='test -z "$ac_c_werror_flag"
4701                          || test ! -s conftest.err'
4702   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4703   (eval $ac_try) 2>&5
4704   ac_status=$?
4705   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4706   (exit $ac_status); }; } &&
4707          { ac_try='test -s conftest$ac_exeext'
4708   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4709   (eval $ac_try) 2>&5
4710   ac_status=$?
4711   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4712   (exit $ac_status); }; }; then
4713   echo "$as_me:$LINENO: result: yes" >&5
4714 echo "${ECHO_T}yes" >&6
4715 else
4716   echo "$as_me: failed program was:" >&5
4717 sed 's/^/| /' conftest.$ac_ext >&5
4718
4719 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4720 echo "${ECHO_T}buggy but acceptable" >&6
4721 fi
4722 rm -f conftest.err conftest.$ac_objext \
4723       conftest$ac_exeext conftest.$ac_ext
4724 else
4725   echo "$as_me: failed program was:" >&5
4726 sed 's/^/| /' conftest.$ac_ext >&5
4727
4728 echo "$as_me:$LINENO: result: no" >&5
4729 echo "${ECHO_T}no" >&6; have_gmp=no
4730 fi
4731 rm -f conftest.err conftest.$ac_objext \
4732       conftest$ac_exeext conftest.$ac_ext
4733       LIBS="$saved_LIBS"
4734   fi
4735   CFLAGS="$saved_CFLAGS"
4736
4737   if test x$have_gmp != xyes; then
4738     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4739 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4740 Copies of these libraries' source code can be found at their respective
4741 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4742 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4743 If you obtained GMP and/or MPFR from a vendor distribution package, make
4744 sure that you have installed both the libraries and the header files.
4745 They may be located in separate packages." >&5
4746 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4747 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4748 Copies of these libraries' source code can be found at their respective
4749 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4750 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4751 If you obtained GMP and/or MPFR from a vendor distribution package, make
4752 sure that you have installed both the libraries and the header files.
4753 They may be located in separate packages." >&2;}
4754    { (exit 1); exit 1; }; }
4755   fi
4756 fi
4757
4758 # Flags needed for both GMP and/or MPFR
4759
4760
4761
4762 # By default, C is the only stage 1 language.
4763 stage1_languages=,c,
4764
4765 # Figure out what language subdirectories are present.
4766 # Look if the user specified --enable-languages="..."; if not, use
4767 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4768 # go away some day.
4769 # NB:  embedded tabs in this IF block -- do not untabify
4770 if test -d ${srcdir}/gcc; then
4771   if test x"${enable_languages+set}" != xset; then
4772     if test x"${LANGUAGES+set}" = xset; then
4773       enable_languages="${LANGUAGES}"
4774         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4775     else
4776       enable_languages=all
4777     fi
4778   else
4779     if test x"${enable_languages}" = x ||
4780        test x"${enable_languages}" = xyes;
4781        then
4782       echo configure.in: --enable-languages needs at least one language argument 1>&2
4783       exit 1
4784     fi
4785   fi
4786   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4787
4788   # 'f95' is the old name for the 'fortran' language. We issue a warning
4789   # and make the substitution.
4790   case ,${enable_languages}, in
4791     *,f95,*)
4792       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4793       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4794       ;;
4795   esac
4796
4797   # First scan to see if an enabled language requires some other language.
4798   # We assume that a given config-lang.in will list all the language
4799   # front ends it requires, even if some are required indirectly.
4800   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4801     case ${lang_frag} in
4802       ..) ;;
4803       # The odd quoting in the next line works around
4804       # an apparent bug in bash 1.12 on linux.
4805       ${srcdir}/gcc/[*]/config-lang.in) ;;
4806       *)
4807         # From the config-lang.in, get $language, $lang_requires
4808         language=
4809         lang_requires=
4810         . ${lang_frag}
4811         for other in ${lang_requires} ; do
4812           case ,${enable_languages}, in
4813             *,$other,*) ;;
4814             *,all,*) ;;
4815             *,$language,*)
4816               echo " \`$other' language required by \`$language'; enabling" 1>&2
4817               enable_languages="${enable_languages},${other}"
4818               ;;
4819           esac
4820         done
4821         ;;
4822     esac
4823   done
4824
4825   new_enable_languages=,c,
4826   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4827   potential_languages=,c,
4828
4829   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4830     case ${lang_frag} in
4831       ..) ;;
4832       # The odd quoting in the next line works around
4833       # an apparent bug in bash 1.12 on linux.
4834       ${srcdir}/gcc/[*]/config-lang.in) ;;
4835       *)
4836         # From the config-lang.in, get $language, $target_libs,
4837         # $lang_dirs, $boot_language, and $build_by_default
4838         language=
4839         target_libs=
4840         lang_dirs=
4841         subdir_requires=
4842         boot_language=no
4843         build_by_default=yes
4844         . ${lang_frag}
4845         if test x${language} = x; then
4846           echo "${lang_frag} doesn't set \$language." 1>&2
4847           exit 1
4848         fi
4849
4850         case ,${enable_languages}, in
4851           *,${language},*)
4852             # Language was explicitly selected; include it.
4853             add_this_lang=yes
4854             ;;
4855           *,all,*)
4856             # 'all' was selected, select it if it is a default language
4857             add_this_lang=${build_by_default}
4858             ;;
4859           *)
4860             add_this_lang=no
4861             ;;
4862         esac
4863
4864         # Disable languages that need other directories if these aren't available.
4865         for i in $subdir_requires; do
4866           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4867           case ,${enable_languages}, in
4868             *,${language},*)
4869               # Specifically requested language; tell them.
4870               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4871 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4872    { (exit 1); exit 1; }; }
4873               ;;
4874             *)
4875               # Silently disable.
4876               add_this_lang=unsupported
4877               ;;
4878           esac
4879         done
4880
4881         # Disable Ada if no preexisting GNAT is available.
4882         case ,${enable_languages},:${language}:${have_gnat} in
4883           *,${language},*:ada:no)
4884             # Specifically requested language; tell them.
4885             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4886 echo "$as_me: error: GNAT is required to build $language" >&2;}
4887    { (exit 1); exit 1; }; }
4888             ;;
4889           *:ada:no)
4890             # Silently disable.
4891             add_this_lang=unsupported
4892             ;;
4893         esac
4894
4895         # Disable a language that is unsupported by the target.
4896         case " $unsupported_languages " in
4897           *" $language "*)
4898             add_this_lang=unsupported
4899             ;;
4900         esac
4901
4902         case $add_this_lang in
4903           unsupported)
4904             # Remove language-dependent dirs.
4905             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4906             ;;
4907           no)
4908             # Remove language-dependent dirs; still show language as supported.
4909             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4910             potential_languages="${potential_languages}${language},"
4911             ;;
4912           yes)
4913             new_enable_languages="${new_enable_languages}${language},"
4914             potential_languages="${potential_languages}${language},"
4915             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4916             case ${boot_language} in
4917               yes)
4918                 # Add to (comma-separated) list of stage 1 languages.
4919                 stage1_languages="${stage1_languages}${language},"
4920                 ;;
4921             esac
4922             ;;
4923         esac
4924         ;;
4925     esac
4926   done
4927
4928   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4929 if test "${enable_stage1_languages+set}" = set; then
4930   enableval="$enable_stage1_languages"
4931   case ,${enable_stage1_languages}, in
4932     ,no,|,,)
4933       # Set it to something that will have no effect in the loop below
4934       enable_stage1_languages=c ;;
4935     ,yes,)
4936       enable_stage1_languages=`echo $new_enable_languages | \
4937         sed -e "s/^,//" -e "s/,$//" ` ;;
4938     *,all,*)
4939       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4940         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4941   esac
4942
4943   # Add "good" languages from enable_stage1_languages to stage1_languages,
4944   # while "bad" languages go in missing_languages.  Leave no duplicates.
4945   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4946     case $potential_languages in
4947       *,$i,*)
4948         case $stage1_languages in
4949           *,$i,*) ;;
4950           *) stage1_languages="$stage1_languages$i," ;;
4951         esac ;;
4952       *)
4953         case $missing_languages in
4954           *,$i,*) ;;
4955           *) missing_languages="$missing_languages$i," ;;
4956         esac ;;
4957      esac
4958   done
4959 fi;
4960
4961   # Remove leading/trailing commas that were added for simplicity
4962   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4963   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4964   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4965   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4966
4967   if test "x$missing_languages" != x; then
4968     { { echo "$as_me:$LINENO: error:
4969 The following requested languages could not be built: ${missing_languages}
4970 Supported languages are: ${potential_languages}" >&5
4971 echo "$as_me: error:
4972 The following requested languages could not be built: ${missing_languages}
4973 Supported languages are: ${potential_languages}" >&2;}
4974    { (exit 1); exit 1; }; }
4975   fi
4976   if test "x$new_enable_languages" != "x$enable_languages"; then
4977     echo The following languages will be built: ${new_enable_languages}
4978     enable_languages="$new_enable_languages"
4979   fi
4980
4981
4982   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4983 fi
4984
4985 # Handle --disable-<component> generically.
4986 for dir in $configdirs $build_configdirs $target_configdirs ; do
4987   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4988   varname=`echo $dirname | sed -e s/+/_/g`
4989   if eval test x\${enable_${varname}} "=" xno ; then
4990     noconfigdirs="$noconfigdirs $dir"
4991   fi
4992 done
4993
4994 # Check for Boehm's garbage collector
4995 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4996 if test "${enable_objc_gc+set}" = set; then
4997   enableval="$enable_objc_gc"
4998   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4999   *,objc,*:*:yes:*target-boehm-gc*)
5000     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5001 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5002    { (exit 1); exit 1; }; }
5003     ;;
5004 esac
5005 fi;
5006
5007 # Make sure we only build Boehm's garbage collector if required.
5008 case ,${enable_languages},:${enable_objc_gc} in
5009   *,objc,*:yes)
5010     # Keep target-boehm-gc if requested for Objective-C.
5011     ;;
5012   *)
5013     # Otherwise remove target-boehm-gc depending on target-libjava.
5014     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5015       noconfigdirs="$noconfigdirs target-boehm-gc"
5016     fi
5017     ;;
5018 esac
5019
5020 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5021 # $build_configdirs and $target_configdirs.
5022 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5023
5024 notsupp=""
5025 for dir in . $skipdirs $noconfigdirs ; do
5026   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5027   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5028     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5029     if test -r $srcdir/$dirname/configure ; then
5030       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5031         true
5032       else
5033         notsupp="$notsupp $dir"
5034       fi
5035     fi
5036   fi
5037   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5038     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5039     if test -r $srcdir/$dirname/configure ; then
5040       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5041         true
5042       else
5043         notsupp="$notsupp $dir"
5044       fi
5045     fi
5046   fi
5047   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5048     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5049     if test -r $srcdir/$dirname/configure ; then
5050       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5051         true
5052       else
5053         notsupp="$notsupp $dir"
5054       fi
5055     fi
5056   fi
5057 done
5058
5059 # Sometimes the tools are distributed with libiberty but with no other
5060 # libraries.  In that case, we don't want to build target-libiberty.
5061 # Don't let libgcc imply libiberty either.
5062 if test -n "${target_configdirs}" ; then
5063   libgcc=
5064   others=
5065   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5066     if test "$i" = "libgcc"; then
5067       libgcc=target-libgcc
5068     elif test "$i" != "libiberty" ; then
5069       if test -r $srcdir/$i/configure ; then
5070         others=yes;
5071         break;
5072       fi
5073     fi
5074   done
5075   if test -z "${others}" ; then
5076     target_configdirs=$libgcc
5077   fi
5078 fi
5079
5080 # Quietly strip out all directories which aren't configurable in this tree.
5081 # This relies on all configurable subdirectories being autoconfiscated, which
5082 # is now the case.
5083 build_configdirs_all="$build_configdirs"
5084 build_configdirs=
5085 for i in ${build_configdirs_all} ; do
5086   j=`echo $i | sed -e s/build-//g`
5087   if test -f ${srcdir}/$j/configure ; then
5088     build_configdirs="${build_configdirs} $i"
5089   fi
5090 done
5091
5092 configdirs_all="$configdirs"
5093 configdirs=
5094 for i in ${configdirs_all} ; do
5095   if test -f ${srcdir}/$i/configure ; then
5096     configdirs="${configdirs} $i"
5097   fi
5098 done
5099
5100 target_configdirs_all="$target_configdirs"
5101 target_configdirs=
5102 for i in ${target_configdirs_all} ; do
5103   j=`echo $i | sed -e s/target-//g`
5104   if test -f ${srcdir}/$j/configure ; then
5105     target_configdirs="${target_configdirs} $i"
5106   fi
5107 done
5108
5109 # Produce a warning message for the subdirs we can't configure.
5110 # This isn't especially interesting in the Cygnus tree, but in the individual
5111 # FSF releases, it's important to let people know when their machine isn't
5112 # supported by the one or two programs in a package.
5113
5114 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5115   # If $appdirs is non-empty, at least one of those directories must still
5116   # be configured, or we error out.  (E.g., if the gas release supports a
5117   # specified target in some subdirs but not the gas subdir, we shouldn't
5118   # pretend that all is well.)
5119   if test -n "$appdirs" ; then
5120     for dir in $appdirs ; do
5121       if test -r $dir/Makefile.in ; then
5122         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5123           appdirs=""
5124           break
5125         fi
5126         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5127           appdirs=""
5128           break
5129         fi
5130       fi
5131     done
5132     if test -n "$appdirs" ; then
5133       echo "*** This configuration is not supported by this package." 1>&2
5134       exit 1
5135     fi
5136   fi
5137   # Okay, some application will build, or we don't care to check.  Still
5138   # notify of subdirs not getting built.
5139   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5140   echo "    ${notsupp}" 1>&2
5141   echo "    (Any other directories should still work fine.)" 1>&2
5142 fi
5143
5144 case "$host" in
5145   *msdosdjgpp*)
5146     enable_gdbtk=no ;;
5147 esac
5148
5149 # To find our prefix, in gcc_cv_tool_prefix.
5150
5151 # The user is always right.
5152 if test "${PATH_SEPARATOR+set}" != set; then
5153   echo "#! /bin/sh" >conf$$.sh
5154   echo  "exit 0"   >>conf$$.sh
5155   chmod +x conf$$.sh
5156   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5157     PATH_SEPARATOR=';'
5158   else
5159     PATH_SEPARATOR=:
5160   fi
5161   rm -f conf$$.sh
5162 fi
5163
5164
5165
5166 if test "x$exec_prefix" = xNONE; then
5167         if test "x$prefix" = xNONE; then
5168                 gcc_cv_tool_prefix=$ac_default_prefix
5169         else
5170                 gcc_cv_tool_prefix=$prefix
5171         fi
5172 else
5173         gcc_cv_tool_prefix=$exec_prefix
5174 fi
5175
5176 # If there is no compiler in the tree, use the PATH only.  In any
5177 # case, if there is no compiler in the tree nobody should use
5178 # AS_FOR_TARGET and LD_FOR_TARGET.
5179 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5180     gcc_version=`cat $srcdir/gcc/BASE-VER`
5181     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5182     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5183     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5184     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5185     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5186     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5187 else
5188     gcc_cv_tool_dirs=
5189 fi
5190
5191 if test x$build = x$target && test -n "$md_exec_prefix"; then
5192         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5193 fi
5194
5195
5196
5197 copy_dirs=
5198
5199
5200 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5201 if test "${with_build_sysroot+set}" = set; then
5202   withval="$with_build_sysroot"
5203   if test x"$withval" != x ; then
5204      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5205    fi
5206 else
5207   SYSROOT_CFLAGS_FOR_TARGET=
5208 fi;
5209
5210
5211
5212 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5213 if test "${with_debug_prefix_map+set}" = set; then
5214   withval="$with_debug_prefix_map"
5215   if test x"$withval" != x; then
5216      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5217      for debug_map in $withval; do
5218        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5219      done
5220    fi
5221 else
5222   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5223 fi;
5224
5225
5226 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5227 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5228 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5229 # We want to ensure that TARGET libraries (which we know are built with
5230 # gcc) are built with "-O2 -g", so include those options when setting
5231 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5232 if test "x$CFLAGS_FOR_TARGET" = x; then
5233   CFLAGS_FOR_TARGET=$CFLAGS
5234   case " $CFLAGS " in
5235     *" -O2 "*) ;;
5236     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5237   esac
5238   case " $CFLAGS " in
5239     *" -g "* | *" -g3 "*) ;;
5240     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5241   esac
5242 fi
5243
5244
5245 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5246   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5247   case " $CXXFLAGS " in
5248     *" -O2 "*) ;;
5249     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5250   esac
5251   case " $CXXFLAGS " in
5252     *" -g "* | *" -g3 "*) ;;
5253     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5254   esac
5255 fi
5256
5257
5258 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5259 # the named directory are copied to $(tooldir)/sys-include.
5260 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5261   if test x${is_cross_compiler} = xno ; then
5262     echo 1>&2 '***' --with-headers is only supported when cross compiling
5263     exit 1
5264   fi
5265   if test x"${with_headers}" != xyes ; then
5266     x=${gcc_cv_tool_prefix}
5267     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5268   fi
5269 fi
5270
5271 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5272 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5273 # are permitted.
5274 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5275   if test x${is_cross_compiler} = xno ; then
5276     echo 1>&2 '***' --with-libs is only supported when cross compiling
5277     exit 1
5278   fi
5279   if test x"${with_libs}" != xyes ; then
5280     # Copy the libraries in reverse order, so that files in the first named
5281     # library override files in subsequent libraries.
5282     x=${gcc_cv_tool_prefix}
5283     for l in ${with_libs}; do
5284       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5285     done
5286   fi
5287 fi
5288
5289 # Set with_gnu_as and with_gnu_ld as appropriate.
5290 #
5291 # This is done by determining whether or not the appropriate directory
5292 # is available, and by checking whether or not specific configurations
5293 # have requested that this magic not happen.
5294 #
5295 # The command line options always override the explicit settings in
5296 # configure.in, and the settings in configure.in override this magic.
5297 #
5298 # If the default for a toolchain is to use GNU as and ld, and you don't
5299 # want to do that, then you should use the --without-gnu-as and
5300 # --without-gnu-ld options for the configure script.
5301
5302 if test x${use_gnu_as} = x &&
5303    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5304   with_gnu_as=yes
5305   extra_host_args="$extra_host_args --with-gnu-as"
5306 fi
5307
5308 if test x${use_gnu_ld} = x &&
5309    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5310   with_gnu_ld=yes
5311   extra_host_args="$extra_host_args --with-gnu-ld"
5312 fi
5313
5314 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5315 # can detect this case.
5316
5317 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5318   with_newlib=yes
5319   extra_host_args="$extra_host_args --with-newlib"
5320 fi
5321
5322 # Handle ${copy_dirs}
5323 set fnord ${copy_dirs}
5324 shift
5325 while test $# != 0 ; do
5326   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5327     :
5328   else
5329     echo Copying $1 to $2
5330
5331     # Use the install script to create the directory and all required
5332     # parent directories.
5333     if test -d $2 ; then
5334       :
5335     else
5336       echo >config.temp
5337       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5338     fi
5339
5340     # Copy the directory, assuming we have tar.
5341     # FIXME: Should we use B in the second tar?  Not all systems support it.
5342     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5343
5344     # It is the responsibility of the user to correctly adjust all
5345     # symlinks.  If somebody can figure out how to handle them correctly
5346     # here, feel free to add the code.
5347
5348     echo $1 > $2/COPIED
5349   fi
5350   shift; shift
5351 done
5352
5353 # Determine a target-dependent exec_prefix that the installed
5354 # gcc will search in.  Keep this list sorted by triplet, with
5355 # the *-*-osname triplets last.
5356 md_exec_prefix=
5357 case "${target}" in
5358   alpha*-*-*vms*)
5359     md_exec_prefix=/gnu/lib/gcc-lib
5360     ;;
5361   i[34567]86-pc-msdosdjgpp*)
5362     md_exec_prefix=/dev/env/DJDIR/bin
5363     ;;
5364   i[34567]86-*-sco3.2v5*)
5365     if test $with_gnu_as = yes; then
5366       md_exec_prefix=/usr/gnu/bin
5367     else
5368       md_exec_prefix=/usr/ccs/bin/elf
5369     fi
5370     ;;
5371
5372   mn10300-*-* | \
5373   powerpc-*-chorusos* | \
5374   powerpc*-*-eabi* | \
5375   powerpc*-*-sysv* | \
5376   powerpc*-*-kaos* | \
5377   s390x-ibm-tpf*)
5378     md_exec_prefix=/usr/ccs/bin
5379     ;;
5380   sparc64-*-elf*)
5381     ;;
5382   v850*-*-*)
5383     md_exec_prefix=/usr/ccs/bin
5384     ;;
5385   xtensa*-*-elf*)
5386     ;;
5387
5388   *-*-beos* | \
5389   *-*-elf* | \
5390   *-*-hpux* | \
5391   *-*-netware* | \
5392   *-*-nto-qnx* | \
5393   *-*-rtems* | \
5394   *-*-solaris2* | \
5395   *-*-sysv[45]* | \
5396   *-*-vxworks* | \
5397   *-wrs-windiss)
5398     md_exec_prefix=/usr/ccs/bin
5399     ;;
5400 esac
5401
5402 extra_arflags_for_target=
5403 extra_nmflags_for_target=
5404 extra_ranlibflags_for_target=
5405 target_makefile_frag=/dev/null
5406 case "${target}" in
5407   mep*-*-*)
5408     target_makefile_frag="config/mt-mep"
5409     ;;
5410   spu-*-*)
5411     target_makefile_frag="config/mt-spu"
5412     ;;
5413   mips*-sde-elf*)
5414     target_makefile_frag="config/mt-sde"
5415     ;;
5416   mipsisa*-*-elfoabi*)
5417     target_makefile_frag="config/mt-mips-elfoabi"
5418     ;;
5419   *-*-netware*)
5420     target_makefile_frag="config/mt-netware"
5421     ;;
5422   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5423     target_makefile_frag="config/mt-gnu"
5424     ;;
5425   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5426     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5427     # commands to handle both 32-bit and 64-bit objects.  These flags are
5428     # harmless if we're using GNU nm or ar.
5429     extra_arflags_for_target=" -X32_64"
5430     extra_nmflags_for_target=" -B -X32_64"
5431     ;;
5432   *-*-darwin*)
5433     # ranlib from Darwin requires the -c flag to look at common symbols.
5434     extra_ranlibflags_for_target=" -c"
5435     ;;
5436   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5437     target_makefile_frag="config/mt-wince"
5438     ;;
5439 esac
5440
5441 alphaieee_frag=/dev/null
5442 case $target in
5443   alpha*-*-*)
5444     # This just makes sure to use the -mieee option to build target libs.
5445     # This should probably be set individually by each library.
5446     alphaieee_frag="config/mt-alphaieee"
5447     ;;
5448 esac
5449
5450 # If --enable-target-optspace always use -Os instead of -O2 to build
5451 # the target libraries, similarly if it is not specified, use -Os
5452 # on selected platforms.
5453 ospace_frag=/dev/null
5454 case "${enable_target_optspace}:${target}" in
5455   yes:*)
5456     ospace_frag="config/mt-ospace"
5457     ;;
5458   :d30v-*)
5459     ospace_frag="config/mt-d30v"
5460     ;;
5461   :m32r-* | :d10v-* | :fr30-*)
5462     ospace_frag="config/mt-ospace"
5463     ;;
5464   no:* | :*)
5465     ;;
5466   *)
5467     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5468     ;;
5469 esac
5470
5471 # Default to using --with-stabs for certain targets.
5472 if test x${with_stabs} = x ; then
5473   case "${target}" in
5474   mips*-*-irix[56]*)
5475     ;;
5476   mips*-*-* | alpha*-*-osf*)
5477     with_stabs=yes;
5478     extra_host_args="${extra_host_args} --with-stabs"
5479     ;;
5480   esac
5481 fi
5482
5483 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5484 # them automatically.
5485 case "${host}" in
5486   hppa*64*-*-hpux11*)
5487     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5488     ;;
5489 esac
5490
5491 # Some systems (e.g., one of the i386-aix systems the gas testers are
5492 # using) don't handle "\$" correctly, so don't use it here.
5493 tooldir='${exec_prefix}'/${target_noncanonical}
5494 build_tooldir=${tooldir}
5495
5496 # Create a .gdbinit file which runs the one in srcdir
5497 # and tells GDB to look there for source files.
5498
5499 if test -r ${srcdir}/.gdbinit ; then
5500   case ${srcdir} in
5501     .) ;;
5502     *) cat > ./.gdbinit <<EOF
5503 # ${NO_EDIT}
5504 dir ${srcdir}
5505 dir .
5506 source ${srcdir}/.gdbinit
5507 EOF
5508     ;;
5509   esac
5510 fi
5511
5512 # Make sure that the compiler is able to generate an executable.  If it
5513 # can't, we are probably in trouble.  We don't care whether we can run the
5514 # executable--we might be using a cross compiler--we only care whether it
5515 # can be created.  At this point the main configure script has set CC.
5516 we_are_ok=no
5517 echo "int main () { return 0; }" > conftest.c
5518 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5519 if test $? = 0 ; then
5520   if test -s conftest || test -s conftest.exe ; then
5521     we_are_ok=yes
5522   fi
5523 fi
5524 case $we_are_ok in
5525   no)
5526     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5527     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5528     rm -f conftest*
5529     exit 1
5530     ;;
5531 esac
5532 rm -f conftest*
5533
5534 # The Solaris /usr/ucb/cc compiler does not appear to work.
5535 case "${host}" in
5536   sparc-sun-solaris2*)
5537       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5538       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5539           could_use=
5540           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5541           if test -d /opt/cygnus/bin ; then
5542               if test "$could_use" = "" ; then
5543                   could_use="/opt/cygnus/bin"
5544               else
5545                   could_use="$could_use or /opt/cygnus/bin"
5546               fi
5547           fi
5548         if test "$could_use" = "" ; then
5549             echo "Warning: compilation may fail because you're using"
5550             echo "/usr/ucb/cc.  You should change your PATH or CC "
5551             echo "variable and rerun configure."
5552         else
5553             echo "Warning: compilation may fail because you're using"
5554             echo "/usr/ucb/cc, when you should use the C compiler from"
5555             echo "$could_use.  You should change your"
5556             echo "PATH or CC variable and rerun configure."
5557         fi
5558       fi
5559   ;;
5560 esac
5561
5562 case "${host}" in
5563   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5564   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5565   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5566 esac
5567
5568 # Record target_configdirs and the configure arguments for target and
5569 # build configuration in Makefile.
5570 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5571 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5572
5573 # Determine whether gdb needs tk/tcl or not.
5574 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5575 # and in that case we want gdb to be built without tk.  Ugh!
5576 # In fact I believe gdb is the *only* package directly dependent on tk,
5577 # so we should be able to put the 'maybe's in unconditionally and
5578 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5579 # 100% sure that that's safe though.
5580
5581 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5582 case "$enable_gdbtk" in
5583   no)
5584     GDB_TK="" ;;
5585   yes)
5586     GDB_TK="${gdb_tk}" ;;
5587   *)
5588     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5589     # distro.  Eventually someone will fix this and move Insight, nee
5590     # gdbtk to a separate directory.
5591     if test -d ${srcdir}/gdb/gdbtk ; then
5592       GDB_TK="${gdb_tk}"
5593     else
5594       GDB_TK=""
5595     fi
5596     ;;
5597 esac
5598 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5599 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5600
5601 # Strip out unwanted targets.
5602
5603 # While at that, we remove Makefiles if we were started for recursive
5604 # configuration, so that the top-level Makefile reconfigures them,
5605 # like we used to do when configure itself was recursive.
5606
5607 # Loop over modules.  $extrasub must be used with care, limiting as
5608 # much as possible the usage of range addresses.  That's because autoconf
5609 # splits the sed script to overcome limits in the number of commands,
5610 # and relying on carefully-timed sed passes may turn out to be very hard
5611 # to maintain later.  In this particular case, you just have to be careful
5612 # not to nest @if/@endif pairs, because configure will not warn you at all.
5613
5614 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5615 if test "${enable_bootstrap+set}" = set; then
5616   enableval="$enable_bootstrap"
5617
5618 else
5619   enable_bootstrap=default
5620 fi;
5621
5622 # Issue errors and warnings for invalid/strange bootstrap combinations.
5623 case "$configdirs" in
5624   *gcc*) have_compiler=yes ;;
5625   *) have_compiler=no ;;
5626 esac
5627
5628 case "$have_compiler:$host:$target:$enable_bootstrap" in
5629   *:*:*:no) ;;
5630
5631   # Default behavior.  Enable bootstrap if we have a compiler
5632   # and we are in a native configuration.
5633   yes:$build:$build:default)
5634     enable_bootstrap=yes ;;
5635
5636   *:*:*:default)
5637     enable_bootstrap=no ;;
5638
5639   # We have a compiler and we are in a native configuration, bootstrap is ok
5640   yes:$build:$build:yes)
5641     ;;
5642
5643   # Other configurations, but we have a compiler.  Assume the user knows
5644   # what he's doing.
5645   yes:*:*:yes)
5646     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5647 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5648     ;;
5649
5650   # No compiler: if they passed --enable-bootstrap explicitly, fail
5651   no:*:*:yes)
5652     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5653 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5654    { (exit 1); exit 1; }; } ;;
5655
5656   # Fail if wrong command line
5657   *)
5658     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5659 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5660    { (exit 1); exit 1; }; }
5661     ;;
5662 esac
5663
5664 # Adjust the toplevel makefile according to whether bootstrap was selected.
5665 case "$enable_bootstrap" in
5666   yes)
5667     bootstrap_suffix=bootstrap ;;
5668   no)
5669     bootstrap_suffix=no-bootstrap ;;
5670 esac
5671
5672 for module in ${build_configdirs} ; do
5673   if test -z "${no_recursion}" \
5674      && test -f ${build_subdir}/${module}/Makefile; then
5675     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5676     rm -f ${build_subdir}/${module}/Makefile
5677   fi
5678   extrasub="$extrasub
5679 /^@if build-$module\$/d
5680 /^@endif build-$module\$/d
5681 /^@if build-$module-$bootstrap_suffix\$/d
5682 /^@endif build-$module-$bootstrap_suffix\$/d"
5683 done
5684 for module in ${configdirs} ; do
5685   if test -z "${no_recursion}"; then
5686     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5687       if test -f ${file}; then
5688         echo 1>&2 "*** removing ${file} to force reconfigure"
5689         rm -f ${file}
5690       fi
5691     done
5692   fi
5693   extrasub="$extrasub
5694 /^@if $module\$/d
5695 /^@endif $module\$/d
5696 /^@if $module-$bootstrap_suffix\$/d
5697 /^@endif $module-$bootstrap_suffix\$/d"
5698 done
5699 for module in ${target_configdirs} ; do
5700   if test -z "${no_recursion}" \
5701      && test -f ${target_subdir}/${module}/Makefile; then
5702     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5703     rm -f ${target_subdir}/${module}/Makefile
5704   fi
5705   extrasub="$extrasub
5706 /^@if target-$module\$/d
5707 /^@endif target-$module\$/d
5708 /^@if target-$module-$bootstrap_suffix\$/d
5709 /^@endif target-$module-$bootstrap_suffix\$/d"
5710 done
5711
5712 extrasub="$extrasub
5713 /^@if /,/^@endif /d"
5714
5715 # Create the serialization dependencies.  This uses a temporary file.
5716
5717 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5718 if test "${enable_serial_configure+set}" = set; then
5719   enableval="$enable_serial_configure"
5720
5721 fi;
5722
5723 case ${enable_serial_configure} in
5724   yes)
5725     enable_serial_build_configure=yes
5726     enable_serial_host_configure=yes
5727     enable_serial_target_configure=yes
5728     ;;
5729 esac
5730
5731 # These force 'configure's to be done one at a time, to avoid problems
5732 # with contention over a shared config.cache.
5733 rm -f serdep.tmp
5734 echo '# serdep.tmp' > serdep.tmp
5735 olditem=
5736 test "x${enable_serial_build_configure}" = xyes &&
5737 for item in ${build_configdirs} ; do
5738   case ${olditem} in
5739     "") ;;
5740     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5741   esac
5742   olditem=${item}
5743 done
5744 olditem=
5745 test "x${enable_serial_host_configure}" = xyes &&
5746 for item in ${configdirs} ; do
5747   case ${olditem} in
5748     "") ;;
5749     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5750   esac
5751   olditem=${item}
5752 done
5753 olditem=
5754 test "x${enable_serial_target_configure}" = xyes &&
5755 for item in ${target_configdirs} ; do
5756   case ${olditem} in
5757     "") ;;
5758     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5759   esac
5760   olditem=${item}
5761 done
5762 serialization_dependencies=serdep.tmp
5763
5764
5765 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5766 # target, nonopt, and variable assignments.  These are the ones we
5767 # might not want to pass down to subconfigures.  Also strip
5768 # program-prefix, program-suffix, and program-transform-name, so that
5769 # we can pass down a consistent program-transform-name.
5770 baseargs=
5771 keep_next=no
5772 skip_next=no
5773 eval "set -- $ac_configure_args"
5774 for ac_arg
5775 do
5776   if test X"$skip_next" = X"yes"; then
5777     skip_next=no
5778     continue
5779   fi
5780   if test X"$keep_next" = X"yes"; then
5781     case $ac_arg in
5782       *\'*)
5783         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5784     esac
5785     baseargs="$baseargs '$ac_arg'"
5786     keep_next=no
5787     continue
5788   fi
5789
5790   # Handle separated arguments.  Based on the logic generated by
5791   # autoconf 2.59.
5792   case $ac_arg in
5793     *=* | --config-cache | -C | -disable-* | --disable-* \
5794       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5795       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5796       | -with-* | --with-* | -without-* | --without-* | --x)
5797       separate_arg=no
5798       ;;
5799     -*)
5800       separate_arg=yes
5801       ;;
5802     *)
5803       separate_arg=no
5804       ;;
5805   esac
5806
5807   case "$ac_arg" in
5808     --no*)
5809       continue
5810       ;;
5811     --c* | \
5812     --sr* | \
5813     --ho* | \
5814     --bu* | \
5815     --t* | \
5816     --program-* | \
5817     -cache_file* | \
5818     -srcdir* | \
5819     -host* | \
5820     -build* | \
5821     -target* | \
5822     -program-prefix* | \
5823     -program-suffix* | \
5824     -program-transform-name* )
5825       skip_next=$separate_arg
5826       continue
5827       ;;
5828     -*)
5829       # An option.  Add it.
5830       case $ac_arg in
5831         *\'*)
5832           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5833       esac
5834       baseargs="$baseargs '$ac_arg'"
5835       keep_next=$separate_arg
5836       ;;
5837     *)
5838       # Either a variable assignment, or a nonopt (triplet).  Don't
5839       # pass it down; let the Makefile handle this.
5840       continue
5841       ;;
5842   esac
5843 done
5844 # Remove the initial space we just introduced and, as these will be
5845 # expanded by make, quote '$'.
5846 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5847
5848 # Add in --program-transform-name, after --program-prefix and
5849 # --program-suffix have been applied to it.  Autoconf has already
5850 # doubled dollar signs and backslashes in program_transform_name; we want
5851 # the backslashes un-doubled, and then the entire thing wrapped in single
5852 # quotes, because this will be expanded first by make and then by the shell.
5853 # Also, because we want to override the logic in subdir configure scripts to
5854 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5855 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5856 ${program_transform_name}
5857 EOF_SED
5858 gcc_transform_name=`cat conftestsed.out`
5859 rm -f conftestsed.out
5860 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5861 if test "$silent" = yes; then
5862   baseargs="$baseargs --silent"
5863 fi
5864
5865 # For the build-side libraries, we just need to pretend we're native,
5866 # and not use the same cache file.  Multilibs are neither needed nor
5867 # desired.
5868 build_configargs="--cache-file=../config.cache ${baseargs}"
5869
5870 # For host modules, accept cache file option, or specification as blank.
5871 case "${cache_file}" in
5872 "") # empty
5873   cache_file_option="" ;;
5874 /* | [A-Za-z]:[\\/]* ) # absolute path
5875   cache_file_option="--cache-file=${cache_file}" ;;
5876 *) # relative path
5877   cache_file_option="--cache-file=../${cache_file}" ;;
5878 esac
5879
5880 # Host dirs don't like to share a cache file either, horribly enough.
5881 # This seems to be due to autoconf 2.5x stupidity.
5882 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5883
5884 target_configargs=${baseargs}
5885
5886 # Passing a --with-cross-host argument lets the target libraries know
5887 # whether they are being built with a cross-compiler or being built
5888 # native.  However, it would be better to use other mechanisms to make the
5889 # sorts of decisions they want to make on this basis.  Please consider
5890 # this option to be deprecated.  FIXME.
5891 if test x${is_cross_compiler} = xyes ; then
5892   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5893 fi
5894
5895 # Default to --enable-multilib.
5896 if test x${enable_multilib} = x ; then
5897   target_configargs="--enable-multilib ${target_configargs}"
5898 fi
5899
5900 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5901 # changed from the earlier setting of with_newlib.
5902 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5903   target_configargs="--with-newlib ${target_configargs}"
5904 fi
5905
5906 # Different target subdirs use different values of certain variables
5907 # (notably CXX).  Worse, multilibs use *lots* of different values.
5908 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5909 # it doesn't automatically accept command-line overrides of them.
5910 # This means it's not safe for target subdirs to share a cache file,
5911 # which is disgusting, but there you have it.  Hopefully this can be
5912 # fixed in future.  It's still worthwhile to use a cache file for each
5913 # directory.  I think.
5914
5915 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5916 # We need to pass --target, as newer autoconf's requires consistency
5917 # for target_alias and gcc doesn't manage it consistently.
5918 target_configargs="--cache-file=./config.cache ${target_configargs}"
5919
5920 FLAGS_FOR_TARGET=
5921 case " $target_configdirs " in
5922  *" newlib "*)
5923   case " $target_configargs " in
5924   *" --with-newlib "*)
5925    case "$target" in
5926    *-cygwin*)
5927      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' ;;
5928    esac
5929
5930    # If we're not building GCC, don't discard standard headers.
5931    if test -d ${srcdir}/gcc; then
5932      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5933
5934      if test "${build}" != "${host}"; then
5935        # On Canadian crosses, CC_FOR_TARGET will have already been set
5936        # by `configure', so we won't have an opportunity to add -Bgcc/
5937        # to it.  This is right: we don't want to search that directory
5938        # for binaries, but we want the header files in there, so add
5939        # them explicitly.
5940        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5941
5942        # Someone might think of using the pre-installed headers on
5943        # Canadian crosses, in case the installed compiler is not fully
5944        # compatible with the compiler being built.  In this case, it
5945        # would be better to flag an error than risking having
5946        # incompatible object files being constructed.  We can't
5947        # guarantee that an error will be flagged, but let's hope the
5948        # compiler will do it, when presented with incompatible header
5949        # files.
5950      fi
5951    fi
5952
5953    case "${target}-${is_cross_compiler}" in
5954    i[3456789]86-*-linux*-no)
5955       # Here host == target, so we don't need to build gcc,
5956       # so we don't want to discard standard headers.
5957       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5958       ;;
5959    *)
5960       # If we're building newlib, use its generic headers last, but search
5961       # for any libc-related directories first (so make it the last -B
5962       # switch).
5963       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5964
5965       # If we're building libgloss, find the startup file, simulator library
5966       # and linker script.
5967       case " $target_configdirs " in
5968         *" libgloss "*)
5969         # Look for startup file, simulator library and maybe linker script.
5970         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
5971         # Look for libnosys.a in case the target needs it.
5972         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5973         # Most targets have the linker script in the source directory.
5974         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
5975         ;;
5976       esac
5977       ;;
5978    esac
5979    ;;
5980   esac
5981   ;;
5982 esac
5983 case "$target" in
5984 *-mingw*)
5985   # Can't be handled as Cygwin above since Mingw does not use newlib.
5986   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' ;;
5987 esac
5988
5989 # Allow the user to override the flags for
5990 # our build compiler if desired.
5991 if test x"${build}" = x"${host}" ; then
5992   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5993   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
5994   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
5995 fi
5996
5997 # On Canadian crosses, we'll be searching the right directories for
5998 # the previously-installed cross compiler, so don't bother to add
5999 # flags for directories within the install tree of the compiler
6000 # being built; programs in there won't even run.
6001 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6002   # Search for pre-installed headers if nothing else fits.
6003   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6004 fi
6005
6006 if test "x${use_gnu_ld}" = x &&
6007    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6008   # Arrange for us to find uninstalled linker scripts.
6009   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6010 fi
6011
6012 # Search for other target-specific linker scripts and such.
6013 case "${target}" in
6014   mep*)
6015     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6016     ;;
6017 esac
6018
6019 # Makefile fragments.
6020 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6021 do
6022   eval fragval=\$$frag
6023   if test $fragval != /dev/null; then
6024     eval $frag=${srcdir}/$fragval
6025   fi
6026 done
6027
6028
6029
6030
6031
6032 # Miscellanea: directories, flags, etc.
6033
6034
6035
6036
6037
6038
6039
6040 # Build module lists & subconfigure args.
6041
6042
6043
6044 # Host module lists & subconfigure args.
6045
6046
6047
6048 # Target module lists & subconfigure args.
6049
6050
6051
6052 # Build tools.
6053
6054
6055
6056
6057
6058
6059
6060
6061
6062
6063
6064
6065
6066
6067
6068
6069
6070 # Generate default definitions for YACC, M4, LEX and other programs that run
6071 # on the build machine.  These are used if the Makefile can't locate these
6072 # programs in objdir.
6073 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6074
6075 for ac_prog in 'bison -y' byacc yacc
6076 do
6077   # Extract the first word of "$ac_prog", so it can be a program name with args.
6078 set dummy $ac_prog; ac_word=$2
6079 echo "$as_me:$LINENO: checking for $ac_word" >&5
6080 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6081 if test "${ac_cv_prog_YACC+set}" = set; then
6082   echo $ECHO_N "(cached) $ECHO_C" >&6
6083 else
6084   if test -n "$YACC"; then
6085   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6086 else
6087 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6088 for as_dir in $PATH
6089 do
6090   IFS=$as_save_IFS
6091   test -z "$as_dir" && as_dir=.
6092   for ac_exec_ext in '' $ac_executable_extensions; do
6093   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6094     ac_cv_prog_YACC="$ac_prog"
6095     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6096     break 2
6097   fi
6098 done
6099 done
6100
6101 fi
6102 fi
6103 YACC=$ac_cv_prog_YACC
6104 if test -n "$YACC"; then
6105   echo "$as_me:$LINENO: result: $YACC" >&5
6106 echo "${ECHO_T}$YACC" >&6
6107 else
6108   echo "$as_me:$LINENO: result: no" >&5
6109 echo "${ECHO_T}no" >&6
6110 fi
6111
6112   test -n "$YACC" && break
6113 done
6114 test -n "$YACC" || YACC="$MISSING bison -y"
6115
6116 case " $build_configdirs " in
6117   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6118   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6119 esac
6120
6121 for ac_prog in bison
6122 do
6123   # Extract the first word of "$ac_prog", so it can be a program name with args.
6124 set dummy $ac_prog; ac_word=$2
6125 echo "$as_me:$LINENO: checking for $ac_word" >&5
6126 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6127 if test "${ac_cv_prog_BISON+set}" = set; then
6128   echo $ECHO_N "(cached) $ECHO_C" >&6
6129 else
6130   if test -n "$BISON"; then
6131   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6132 else
6133 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6134 for as_dir in $PATH
6135 do
6136   IFS=$as_save_IFS
6137   test -z "$as_dir" && as_dir=.
6138   for ac_exec_ext in '' $ac_executable_extensions; do
6139   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6140     ac_cv_prog_BISON="$ac_prog"
6141     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6142     break 2
6143   fi
6144 done
6145 done
6146
6147 fi
6148 fi
6149 BISON=$ac_cv_prog_BISON
6150 if test -n "$BISON"; then
6151   echo "$as_me:$LINENO: result: $BISON" >&5
6152 echo "${ECHO_T}$BISON" >&6
6153 else
6154   echo "$as_me:$LINENO: result: no" >&5
6155 echo "${ECHO_T}no" >&6
6156 fi
6157
6158   test -n "$BISON" && break
6159 done
6160 test -n "$BISON" || BISON="$MISSING bison"
6161
6162 case " $build_configdirs " in
6163   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6164 esac
6165
6166 for ac_prog in gm4 gnum4 m4
6167 do
6168   # Extract the first word of "$ac_prog", so it can be a program name with args.
6169 set dummy $ac_prog; ac_word=$2
6170 echo "$as_me:$LINENO: checking for $ac_word" >&5
6171 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6172 if test "${ac_cv_prog_M4+set}" = set; then
6173   echo $ECHO_N "(cached) $ECHO_C" >&6
6174 else
6175   if test -n "$M4"; then
6176   ac_cv_prog_M4="$M4" # Let the user override the test.
6177 else
6178 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6179 for as_dir in $PATH
6180 do
6181   IFS=$as_save_IFS
6182   test -z "$as_dir" && as_dir=.
6183   for ac_exec_ext in '' $ac_executable_extensions; do
6184   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6185     ac_cv_prog_M4="$ac_prog"
6186     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6187     break 2
6188   fi
6189 done
6190 done
6191
6192 fi
6193 fi
6194 M4=$ac_cv_prog_M4
6195 if test -n "$M4"; then
6196   echo "$as_me:$LINENO: result: $M4" >&5
6197 echo "${ECHO_T}$M4" >&6
6198 else
6199   echo "$as_me:$LINENO: result: no" >&5
6200 echo "${ECHO_T}no" >&6
6201 fi
6202
6203   test -n "$M4" && break
6204 done
6205 test -n "$M4" || M4="$MISSING m4"
6206
6207 case " $build_configdirs " in
6208   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6209 esac
6210
6211 for ac_prog in flex lex
6212 do
6213   # Extract the first word of "$ac_prog", so it can be a program name with args.
6214 set dummy $ac_prog; ac_word=$2
6215 echo "$as_me:$LINENO: checking for $ac_word" >&5
6216 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6217 if test "${ac_cv_prog_LEX+set}" = set; then
6218   echo $ECHO_N "(cached) $ECHO_C" >&6
6219 else
6220   if test -n "$LEX"; then
6221   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6222 else
6223 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6224 for as_dir in $PATH
6225 do
6226   IFS=$as_save_IFS
6227   test -z "$as_dir" && as_dir=.
6228   for ac_exec_ext in '' $ac_executable_extensions; do
6229   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6230     ac_cv_prog_LEX="$ac_prog"
6231     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6232     break 2
6233   fi
6234 done
6235 done
6236
6237 fi
6238 fi
6239 LEX=$ac_cv_prog_LEX
6240 if test -n "$LEX"; then
6241   echo "$as_me:$LINENO: result: $LEX" >&5
6242 echo "${ECHO_T}$LEX" >&6
6243 else
6244   echo "$as_me:$LINENO: result: no" >&5
6245 echo "${ECHO_T}no" >&6
6246 fi
6247
6248   test -n "$LEX" && break
6249 done
6250 test -n "$LEX" || LEX="$MISSING flex"
6251
6252 case " $build_configdirs " in
6253   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6254   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6255 esac
6256
6257 for ac_prog in flex
6258 do
6259   # Extract the first word of "$ac_prog", so it can be a program name with args.
6260 set dummy $ac_prog; ac_word=$2
6261 echo "$as_me:$LINENO: checking for $ac_word" >&5
6262 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6263 if test "${ac_cv_prog_FLEX+set}" = set; then
6264   echo $ECHO_N "(cached) $ECHO_C" >&6
6265 else
6266   if test -n "$FLEX"; then
6267   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6268 else
6269 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6270 for as_dir in $PATH
6271 do
6272   IFS=$as_save_IFS
6273   test -z "$as_dir" && as_dir=.
6274   for ac_exec_ext in '' $ac_executable_extensions; do
6275   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6276     ac_cv_prog_FLEX="$ac_prog"
6277     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6278     break 2
6279   fi
6280 done
6281 done
6282
6283 fi
6284 fi
6285 FLEX=$ac_cv_prog_FLEX
6286 if test -n "$FLEX"; then
6287   echo "$as_me:$LINENO: result: $FLEX" >&5
6288 echo "${ECHO_T}$FLEX" >&6
6289 else
6290   echo "$as_me:$LINENO: result: no" >&5
6291 echo "${ECHO_T}no" >&6
6292 fi
6293
6294   test -n "$FLEX" && break
6295 done
6296 test -n "$FLEX" || FLEX="$MISSING flex"
6297
6298 case " $build_configdirs " in
6299   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6300 esac
6301
6302 for ac_prog in makeinfo
6303 do
6304   # Extract the first word of "$ac_prog", so it can be a program name with args.
6305 set dummy $ac_prog; ac_word=$2
6306 echo "$as_me:$LINENO: checking for $ac_word" >&5
6307 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6308 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6309   echo $ECHO_N "(cached) $ECHO_C" >&6
6310 else
6311   if test -n "$MAKEINFO"; then
6312   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6313 else
6314 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6315 for as_dir in $PATH
6316 do
6317   IFS=$as_save_IFS
6318   test -z "$as_dir" && as_dir=.
6319   for ac_exec_ext in '' $ac_executable_extensions; do
6320   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6321     ac_cv_prog_MAKEINFO="$ac_prog"
6322     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6323     break 2
6324   fi
6325 done
6326 done
6327
6328 fi
6329 fi
6330 MAKEINFO=$ac_cv_prog_MAKEINFO
6331 if test -n "$MAKEINFO"; then
6332   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6333 echo "${ECHO_T}$MAKEINFO" >&6
6334 else
6335   echo "$as_me:$LINENO: result: no" >&5
6336 echo "${ECHO_T}no" >&6
6337 fi
6338
6339   test -n "$MAKEINFO" && break
6340 done
6341 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6342
6343 case " $build_configdirs " in
6344   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6345   *)
6346
6347     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6348     # higher, else we use the "missing" dummy.
6349     if ${MAKEINFO} --version \
6350        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6351       :
6352     else
6353       MAKEINFO="$MISSING makeinfo"
6354     fi
6355     ;;
6356
6357 esac
6358
6359 # FIXME: expect and dejagnu may become build tools?
6360
6361 for ac_prog in expect
6362 do
6363   # Extract the first word of "$ac_prog", so it can be a program name with args.
6364 set dummy $ac_prog; ac_word=$2
6365 echo "$as_me:$LINENO: checking for $ac_word" >&5
6366 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6367 if test "${ac_cv_prog_EXPECT+set}" = set; then
6368   echo $ECHO_N "(cached) $ECHO_C" >&6
6369 else
6370   if test -n "$EXPECT"; then
6371   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6372 else
6373 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6374 for as_dir in $PATH
6375 do
6376   IFS=$as_save_IFS
6377   test -z "$as_dir" && as_dir=.
6378   for ac_exec_ext in '' $ac_executable_extensions; do
6379   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6380     ac_cv_prog_EXPECT="$ac_prog"
6381     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6382     break 2
6383   fi
6384 done
6385 done
6386
6387 fi
6388 fi
6389 EXPECT=$ac_cv_prog_EXPECT
6390 if test -n "$EXPECT"; then
6391   echo "$as_me:$LINENO: result: $EXPECT" >&5
6392 echo "${ECHO_T}$EXPECT" >&6
6393 else
6394   echo "$as_me:$LINENO: result: no" >&5
6395 echo "${ECHO_T}no" >&6
6396 fi
6397
6398   test -n "$EXPECT" && break
6399 done
6400 test -n "$EXPECT" || EXPECT="expect"
6401
6402 case " $configdirs " in
6403   *" expect "*)
6404     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6405     ;;
6406 esac
6407
6408 for ac_prog in runtest
6409 do
6410   # Extract the first word of "$ac_prog", so it can be a program name with args.
6411 set dummy $ac_prog; ac_word=$2
6412 echo "$as_me:$LINENO: checking for $ac_word" >&5
6413 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6414 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6415   echo $ECHO_N "(cached) $ECHO_C" >&6
6416 else
6417   if test -n "$RUNTEST"; then
6418   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6419 else
6420 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6421 for as_dir in $PATH
6422 do
6423   IFS=$as_save_IFS
6424   test -z "$as_dir" && as_dir=.
6425   for ac_exec_ext in '' $ac_executable_extensions; do
6426   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6427     ac_cv_prog_RUNTEST="$ac_prog"
6428     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6429     break 2
6430   fi
6431 done
6432 done
6433
6434 fi
6435 fi
6436 RUNTEST=$ac_cv_prog_RUNTEST
6437 if test -n "$RUNTEST"; then
6438   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6439 echo "${ECHO_T}$RUNTEST" >&6
6440 else
6441   echo "$as_me:$LINENO: result: no" >&5
6442 echo "${ECHO_T}no" >&6
6443 fi
6444
6445   test -n "$RUNTEST" && break
6446 done
6447 test -n "$RUNTEST" || RUNTEST="runtest"
6448
6449 case " $configdirs " in
6450   *" dejagnu "*)
6451     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6452     ;;
6453 esac
6454
6455
6456 # Host tools.
6457 ncn_tool_prefix=
6458 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6459 ncn_target_tool_prefix=
6460 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6461
6462
6463
6464 if test -n "$AR"; then
6465   ac_cv_prog_AR=$AR
6466 elif test -n "$ac_cv_prog_AR"; then
6467   AR=$ac_cv_prog_AR
6468 fi
6469
6470 if test -n "$ac_cv_prog_AR"; then
6471   for ncn_progname in ar; do
6472     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6473 set dummy ${ncn_progname}; ac_word=$2
6474 echo "$as_me:$LINENO: checking for $ac_word" >&5
6475 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6476 if test "${ac_cv_prog_AR+set}" = set; then
6477   echo $ECHO_N "(cached) $ECHO_C" >&6
6478 else
6479   if test -n "$AR"; then
6480   ac_cv_prog_AR="$AR" # Let the user override the test.
6481 else
6482 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6483 for as_dir in $PATH
6484 do
6485   IFS=$as_save_IFS
6486   test -z "$as_dir" && as_dir=.
6487   for ac_exec_ext in '' $ac_executable_extensions; do
6488   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6489     ac_cv_prog_AR="${ncn_progname}"
6490     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6491     break 2
6492   fi
6493 done
6494 done
6495
6496 fi
6497 fi
6498 AR=$ac_cv_prog_AR
6499 if test -n "$AR"; then
6500   echo "$as_me:$LINENO: result: $AR" >&5
6501 echo "${ECHO_T}$AR" >&6
6502 else
6503   echo "$as_me:$LINENO: result: no" >&5
6504 echo "${ECHO_T}no" >&6
6505 fi
6506
6507   done
6508 fi
6509
6510 for ncn_progname in ar; do
6511   if test -n "$ncn_tool_prefix"; then
6512     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6513 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6514 echo "$as_me:$LINENO: checking for $ac_word" >&5
6515 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6516 if test "${ac_cv_prog_AR+set}" = set; then
6517   echo $ECHO_N "(cached) $ECHO_C" >&6
6518 else
6519   if test -n "$AR"; then
6520   ac_cv_prog_AR="$AR" # Let the user override the test.
6521 else
6522 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6523 for as_dir in $PATH
6524 do
6525   IFS=$as_save_IFS
6526   test -z "$as_dir" && as_dir=.
6527   for ac_exec_ext in '' $ac_executable_extensions; do
6528   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6529     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6530     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6531     break 2
6532   fi
6533 done
6534 done
6535
6536 fi
6537 fi
6538 AR=$ac_cv_prog_AR
6539 if test -n "$AR"; then
6540   echo "$as_me:$LINENO: result: $AR" >&5
6541 echo "${ECHO_T}$AR" >&6
6542 else
6543   echo "$as_me:$LINENO: result: no" >&5
6544 echo "${ECHO_T}no" >&6
6545 fi
6546
6547   fi
6548   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6549     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6550 set dummy ${ncn_progname}; ac_word=$2
6551 echo "$as_me:$LINENO: checking for $ac_word" >&5
6552 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6553 if test "${ac_cv_prog_AR+set}" = set; then
6554   echo $ECHO_N "(cached) $ECHO_C" >&6
6555 else
6556   if test -n "$AR"; then
6557   ac_cv_prog_AR="$AR" # Let the user override the test.
6558 else
6559 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6560 for as_dir in $PATH
6561 do
6562   IFS=$as_save_IFS
6563   test -z "$as_dir" && as_dir=.
6564   for ac_exec_ext in '' $ac_executable_extensions; do
6565   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6566     ac_cv_prog_AR="${ncn_progname}"
6567     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6568     break 2
6569   fi
6570 done
6571 done
6572
6573 fi
6574 fi
6575 AR=$ac_cv_prog_AR
6576 if test -n "$AR"; then
6577   echo "$as_me:$LINENO: result: $AR" >&5
6578 echo "${ECHO_T}$AR" >&6
6579 else
6580   echo "$as_me:$LINENO: result: no" >&5
6581 echo "${ECHO_T}no" >&6
6582 fi
6583
6584   fi
6585   test -n "$ac_cv_prog_AR" && break
6586 done
6587
6588 if test -z "$ac_cv_prog_AR" ; then
6589   set dummy ar
6590   if test $build = $host ; then
6591     AR="$2"
6592   else
6593     AR="${ncn_tool_prefix}$2"
6594   fi
6595 fi
6596
6597
6598
6599 if test -n "$AS"; then
6600   ac_cv_prog_AS=$AS
6601 elif test -n "$ac_cv_prog_AS"; then
6602   AS=$ac_cv_prog_AS
6603 fi
6604
6605 if test -n "$ac_cv_prog_AS"; then
6606   for ncn_progname in as; do
6607     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6608 set dummy ${ncn_progname}; ac_word=$2
6609 echo "$as_me:$LINENO: checking for $ac_word" >&5
6610 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6611 if test "${ac_cv_prog_AS+set}" = set; then
6612   echo $ECHO_N "(cached) $ECHO_C" >&6
6613 else
6614   if test -n "$AS"; then
6615   ac_cv_prog_AS="$AS" # Let the user override the test.
6616 else
6617 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6618 for as_dir in $PATH
6619 do
6620   IFS=$as_save_IFS
6621   test -z "$as_dir" && as_dir=.
6622   for ac_exec_ext in '' $ac_executable_extensions; do
6623   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6624     ac_cv_prog_AS="${ncn_progname}"
6625     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6626     break 2
6627   fi
6628 done
6629 done
6630
6631 fi
6632 fi
6633 AS=$ac_cv_prog_AS
6634 if test -n "$AS"; then
6635   echo "$as_me:$LINENO: result: $AS" >&5
6636 echo "${ECHO_T}$AS" >&6
6637 else
6638   echo "$as_me:$LINENO: result: no" >&5
6639 echo "${ECHO_T}no" >&6
6640 fi
6641
6642   done
6643 fi
6644
6645 for ncn_progname in as; do
6646   if test -n "$ncn_tool_prefix"; then
6647     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6648 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6649 echo "$as_me:$LINENO: checking for $ac_word" >&5
6650 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6651 if test "${ac_cv_prog_AS+set}" = set; then
6652   echo $ECHO_N "(cached) $ECHO_C" >&6
6653 else
6654   if test -n "$AS"; then
6655   ac_cv_prog_AS="$AS" # Let the user override the test.
6656 else
6657 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6658 for as_dir in $PATH
6659 do
6660   IFS=$as_save_IFS
6661   test -z "$as_dir" && as_dir=.
6662   for ac_exec_ext in '' $ac_executable_extensions; do
6663   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6664     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6665     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6666     break 2
6667   fi
6668 done
6669 done
6670
6671 fi
6672 fi
6673 AS=$ac_cv_prog_AS
6674 if test -n "$AS"; then
6675   echo "$as_me:$LINENO: result: $AS" >&5
6676 echo "${ECHO_T}$AS" >&6
6677 else
6678   echo "$as_me:$LINENO: result: no" >&5
6679 echo "${ECHO_T}no" >&6
6680 fi
6681
6682   fi
6683   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6684     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6685 set dummy ${ncn_progname}; ac_word=$2
6686 echo "$as_me:$LINENO: checking for $ac_word" >&5
6687 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6688 if test "${ac_cv_prog_AS+set}" = set; then
6689   echo $ECHO_N "(cached) $ECHO_C" >&6
6690 else
6691   if test -n "$AS"; then
6692   ac_cv_prog_AS="$AS" # Let the user override the test.
6693 else
6694 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6695 for as_dir in $PATH
6696 do
6697   IFS=$as_save_IFS
6698   test -z "$as_dir" && as_dir=.
6699   for ac_exec_ext in '' $ac_executable_extensions; do
6700   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6701     ac_cv_prog_AS="${ncn_progname}"
6702     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6703     break 2
6704   fi
6705 done
6706 done
6707
6708 fi
6709 fi
6710 AS=$ac_cv_prog_AS
6711 if test -n "$AS"; then
6712   echo "$as_me:$LINENO: result: $AS" >&5
6713 echo "${ECHO_T}$AS" >&6
6714 else
6715   echo "$as_me:$LINENO: result: no" >&5
6716 echo "${ECHO_T}no" >&6
6717 fi
6718
6719   fi
6720   test -n "$ac_cv_prog_AS" && break
6721 done
6722
6723 if test -z "$ac_cv_prog_AS" ; then
6724   set dummy as
6725   if test $build = $host ; then
6726     AS="$2"
6727   else
6728     AS="${ncn_tool_prefix}$2"
6729   fi
6730 fi
6731
6732
6733
6734 if test -n "$DLLTOOL"; then
6735   ac_cv_prog_DLLTOOL=$DLLTOOL
6736 elif test -n "$ac_cv_prog_DLLTOOL"; then
6737   DLLTOOL=$ac_cv_prog_DLLTOOL
6738 fi
6739
6740 if test -n "$ac_cv_prog_DLLTOOL"; then
6741   for ncn_progname in dlltool; do
6742     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6743 set dummy ${ncn_progname}; ac_word=$2
6744 echo "$as_me:$LINENO: checking for $ac_word" >&5
6745 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6746 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6747   echo $ECHO_N "(cached) $ECHO_C" >&6
6748 else
6749   if test -n "$DLLTOOL"; then
6750   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6751 else
6752 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6753 for as_dir in $PATH
6754 do
6755   IFS=$as_save_IFS
6756   test -z "$as_dir" && as_dir=.
6757   for ac_exec_ext in '' $ac_executable_extensions; do
6758   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6759     ac_cv_prog_DLLTOOL="${ncn_progname}"
6760     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6761     break 2
6762   fi
6763 done
6764 done
6765
6766 fi
6767 fi
6768 DLLTOOL=$ac_cv_prog_DLLTOOL
6769 if test -n "$DLLTOOL"; then
6770   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6771 echo "${ECHO_T}$DLLTOOL" >&6
6772 else
6773   echo "$as_me:$LINENO: result: no" >&5
6774 echo "${ECHO_T}no" >&6
6775 fi
6776
6777   done
6778 fi
6779
6780 for ncn_progname in dlltool; do
6781   if test -n "$ncn_tool_prefix"; then
6782     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6783 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6784 echo "$as_me:$LINENO: checking for $ac_word" >&5
6785 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6786 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6787   echo $ECHO_N "(cached) $ECHO_C" >&6
6788 else
6789   if test -n "$DLLTOOL"; then
6790   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6791 else
6792 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6793 for as_dir in $PATH
6794 do
6795   IFS=$as_save_IFS
6796   test -z "$as_dir" && as_dir=.
6797   for ac_exec_ext in '' $ac_executable_extensions; do
6798   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6799     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6800     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6801     break 2
6802   fi
6803 done
6804 done
6805
6806 fi
6807 fi
6808 DLLTOOL=$ac_cv_prog_DLLTOOL
6809 if test -n "$DLLTOOL"; then
6810   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6811 echo "${ECHO_T}$DLLTOOL" >&6
6812 else
6813   echo "$as_me:$LINENO: result: no" >&5
6814 echo "${ECHO_T}no" >&6
6815 fi
6816
6817   fi
6818   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6819     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6820 set dummy ${ncn_progname}; ac_word=$2
6821 echo "$as_me:$LINENO: checking for $ac_word" >&5
6822 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6823 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6824   echo $ECHO_N "(cached) $ECHO_C" >&6
6825 else
6826   if test -n "$DLLTOOL"; then
6827   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6828 else
6829 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6830 for as_dir in $PATH
6831 do
6832   IFS=$as_save_IFS
6833   test -z "$as_dir" && as_dir=.
6834   for ac_exec_ext in '' $ac_executable_extensions; do
6835   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6836     ac_cv_prog_DLLTOOL="${ncn_progname}"
6837     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6838     break 2
6839   fi
6840 done
6841 done
6842
6843 fi
6844 fi
6845 DLLTOOL=$ac_cv_prog_DLLTOOL
6846 if test -n "$DLLTOOL"; then
6847   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6848 echo "${ECHO_T}$DLLTOOL" >&6
6849 else
6850   echo "$as_me:$LINENO: result: no" >&5
6851 echo "${ECHO_T}no" >&6
6852 fi
6853
6854   fi
6855   test -n "$ac_cv_prog_DLLTOOL" && break
6856 done
6857
6858 if test -z "$ac_cv_prog_DLLTOOL" ; then
6859   set dummy dlltool
6860   if test $build = $host ; then
6861     DLLTOOL="$2"
6862   else
6863     DLLTOOL="${ncn_tool_prefix}$2"
6864   fi
6865 fi
6866
6867
6868
6869 if test -n "$LD"; then
6870   ac_cv_prog_LD=$LD
6871 elif test -n "$ac_cv_prog_LD"; then
6872   LD=$ac_cv_prog_LD
6873 fi
6874
6875 if test -n "$ac_cv_prog_LD"; then
6876   for ncn_progname in ld; do
6877     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6878 set dummy ${ncn_progname}; ac_word=$2
6879 echo "$as_me:$LINENO: checking for $ac_word" >&5
6880 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6881 if test "${ac_cv_prog_LD+set}" = set; then
6882   echo $ECHO_N "(cached) $ECHO_C" >&6
6883 else
6884   if test -n "$LD"; then
6885   ac_cv_prog_LD="$LD" # Let the user override the test.
6886 else
6887 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6888 for as_dir in $PATH
6889 do
6890   IFS=$as_save_IFS
6891   test -z "$as_dir" && as_dir=.
6892   for ac_exec_ext in '' $ac_executable_extensions; do
6893   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6894     ac_cv_prog_LD="${ncn_progname}"
6895     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6896     break 2
6897   fi
6898 done
6899 done
6900
6901 fi
6902 fi
6903 LD=$ac_cv_prog_LD
6904 if test -n "$LD"; then
6905   echo "$as_me:$LINENO: result: $LD" >&5
6906 echo "${ECHO_T}$LD" >&6
6907 else
6908   echo "$as_me:$LINENO: result: no" >&5
6909 echo "${ECHO_T}no" >&6
6910 fi
6911
6912   done
6913 fi
6914
6915 for ncn_progname in ld; do
6916   if test -n "$ncn_tool_prefix"; then
6917     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6918 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6919 echo "$as_me:$LINENO: checking for $ac_word" >&5
6920 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6921 if test "${ac_cv_prog_LD+set}" = set; then
6922   echo $ECHO_N "(cached) $ECHO_C" >&6
6923 else
6924   if test -n "$LD"; then
6925   ac_cv_prog_LD="$LD" # Let the user override the test.
6926 else
6927 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6928 for as_dir in $PATH
6929 do
6930   IFS=$as_save_IFS
6931   test -z "$as_dir" && as_dir=.
6932   for ac_exec_ext in '' $ac_executable_extensions; do
6933   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6934     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6935     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6936     break 2
6937   fi
6938 done
6939 done
6940
6941 fi
6942 fi
6943 LD=$ac_cv_prog_LD
6944 if test -n "$LD"; then
6945   echo "$as_me:$LINENO: result: $LD" >&5
6946 echo "${ECHO_T}$LD" >&6
6947 else
6948   echo "$as_me:$LINENO: result: no" >&5
6949 echo "${ECHO_T}no" >&6
6950 fi
6951
6952   fi
6953   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6954     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6955 set dummy ${ncn_progname}; ac_word=$2
6956 echo "$as_me:$LINENO: checking for $ac_word" >&5
6957 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6958 if test "${ac_cv_prog_LD+set}" = set; then
6959   echo $ECHO_N "(cached) $ECHO_C" >&6
6960 else
6961   if test -n "$LD"; then
6962   ac_cv_prog_LD="$LD" # Let the user override the test.
6963 else
6964 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6965 for as_dir in $PATH
6966 do
6967   IFS=$as_save_IFS
6968   test -z "$as_dir" && as_dir=.
6969   for ac_exec_ext in '' $ac_executable_extensions; do
6970   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6971     ac_cv_prog_LD="${ncn_progname}"
6972     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6973     break 2
6974   fi
6975 done
6976 done
6977
6978 fi
6979 fi
6980 LD=$ac_cv_prog_LD
6981 if test -n "$LD"; then
6982   echo "$as_me:$LINENO: result: $LD" >&5
6983 echo "${ECHO_T}$LD" >&6
6984 else
6985   echo "$as_me:$LINENO: result: no" >&5
6986 echo "${ECHO_T}no" >&6
6987 fi
6988
6989   fi
6990   test -n "$ac_cv_prog_LD" && break
6991 done
6992
6993 if test -z "$ac_cv_prog_LD" ; then
6994   set dummy ld
6995   if test $build = $host ; then
6996     LD="$2"
6997   else
6998     LD="${ncn_tool_prefix}$2"
6999   fi
7000 fi
7001
7002
7003
7004 if test -n "$LIPO"; then
7005   ac_cv_prog_LIPO=$LIPO
7006 elif test -n "$ac_cv_prog_LIPO"; then
7007   LIPO=$ac_cv_prog_LIPO
7008 fi
7009
7010 if test -n "$ac_cv_prog_LIPO"; then
7011   for ncn_progname in lipo; do
7012     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7013 set dummy ${ncn_progname}; ac_word=$2
7014 echo "$as_me:$LINENO: checking for $ac_word" >&5
7015 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7016 if test "${ac_cv_prog_LIPO+set}" = set; then
7017   echo $ECHO_N "(cached) $ECHO_C" >&6
7018 else
7019   if test -n "$LIPO"; then
7020   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7021 else
7022 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7023 for as_dir in $PATH
7024 do
7025   IFS=$as_save_IFS
7026   test -z "$as_dir" && as_dir=.
7027   for ac_exec_ext in '' $ac_executable_extensions; do
7028   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7029     ac_cv_prog_LIPO="${ncn_progname}"
7030     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7031     break 2
7032   fi
7033 done
7034 done
7035
7036 fi
7037 fi
7038 LIPO=$ac_cv_prog_LIPO
7039 if test -n "$LIPO"; then
7040   echo "$as_me:$LINENO: result: $LIPO" >&5
7041 echo "${ECHO_T}$LIPO" >&6
7042 else
7043   echo "$as_me:$LINENO: result: no" >&5
7044 echo "${ECHO_T}no" >&6
7045 fi
7046
7047   done
7048 fi
7049
7050 for ncn_progname in lipo; do
7051   if test -n "$ncn_tool_prefix"; then
7052     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7053 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7054 echo "$as_me:$LINENO: checking for $ac_word" >&5
7055 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7056 if test "${ac_cv_prog_LIPO+set}" = set; then
7057   echo $ECHO_N "(cached) $ECHO_C" >&6
7058 else
7059   if test -n "$LIPO"; then
7060   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7061 else
7062 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7063 for as_dir in $PATH
7064 do
7065   IFS=$as_save_IFS
7066   test -z "$as_dir" && as_dir=.
7067   for ac_exec_ext in '' $ac_executable_extensions; do
7068   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7069     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7070     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7071     break 2
7072   fi
7073 done
7074 done
7075
7076 fi
7077 fi
7078 LIPO=$ac_cv_prog_LIPO
7079 if test -n "$LIPO"; then
7080   echo "$as_me:$LINENO: result: $LIPO" >&5
7081 echo "${ECHO_T}$LIPO" >&6
7082 else
7083   echo "$as_me:$LINENO: result: no" >&5
7084 echo "${ECHO_T}no" >&6
7085 fi
7086
7087   fi
7088   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7089     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7090 set dummy ${ncn_progname}; ac_word=$2
7091 echo "$as_me:$LINENO: checking for $ac_word" >&5
7092 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7093 if test "${ac_cv_prog_LIPO+set}" = set; then
7094   echo $ECHO_N "(cached) $ECHO_C" >&6
7095 else
7096   if test -n "$LIPO"; then
7097   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7098 else
7099 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7100 for as_dir in $PATH
7101 do
7102   IFS=$as_save_IFS
7103   test -z "$as_dir" && as_dir=.
7104   for ac_exec_ext in '' $ac_executable_extensions; do
7105   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7106     ac_cv_prog_LIPO="${ncn_progname}"
7107     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7108     break 2
7109   fi
7110 done
7111 done
7112
7113 fi
7114 fi
7115 LIPO=$ac_cv_prog_LIPO
7116 if test -n "$LIPO"; then
7117   echo "$as_me:$LINENO: result: $LIPO" >&5
7118 echo "${ECHO_T}$LIPO" >&6
7119 else
7120   echo "$as_me:$LINENO: result: no" >&5
7121 echo "${ECHO_T}no" >&6
7122 fi
7123
7124   fi
7125   test -n "$ac_cv_prog_LIPO" && break
7126 done
7127
7128 if test -z "$ac_cv_prog_LIPO" ; then
7129   set dummy lipo
7130   if test $build = $host ; then
7131     LIPO="$2"
7132   else
7133     LIPO="${ncn_tool_prefix}$2"
7134   fi
7135 fi
7136
7137
7138
7139 if test -n "$NM"; then
7140   ac_cv_prog_NM=$NM
7141 elif test -n "$ac_cv_prog_NM"; then
7142   NM=$ac_cv_prog_NM
7143 fi
7144
7145 if test -n "$ac_cv_prog_NM"; then
7146   for ncn_progname in nm; do
7147     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7148 set dummy ${ncn_progname}; ac_word=$2
7149 echo "$as_me:$LINENO: checking for $ac_word" >&5
7150 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7151 if test "${ac_cv_prog_NM+set}" = set; then
7152   echo $ECHO_N "(cached) $ECHO_C" >&6
7153 else
7154   if test -n "$NM"; then
7155   ac_cv_prog_NM="$NM" # Let the user override the test.
7156 else
7157 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7158 for as_dir in $PATH
7159 do
7160   IFS=$as_save_IFS
7161   test -z "$as_dir" && as_dir=.
7162   for ac_exec_ext in '' $ac_executable_extensions; do
7163   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7164     ac_cv_prog_NM="${ncn_progname}"
7165     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7166     break 2
7167   fi
7168 done
7169 done
7170
7171 fi
7172 fi
7173 NM=$ac_cv_prog_NM
7174 if test -n "$NM"; then
7175   echo "$as_me:$LINENO: result: $NM" >&5
7176 echo "${ECHO_T}$NM" >&6
7177 else
7178   echo "$as_me:$LINENO: result: no" >&5
7179 echo "${ECHO_T}no" >&6
7180 fi
7181
7182   done
7183 fi
7184
7185 for ncn_progname in nm; do
7186   if test -n "$ncn_tool_prefix"; then
7187     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7188 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7189 echo "$as_me:$LINENO: checking for $ac_word" >&5
7190 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7191 if test "${ac_cv_prog_NM+set}" = set; then
7192   echo $ECHO_N "(cached) $ECHO_C" >&6
7193 else
7194   if test -n "$NM"; then
7195   ac_cv_prog_NM="$NM" # Let the user override the test.
7196 else
7197 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7198 for as_dir in $PATH
7199 do
7200   IFS=$as_save_IFS
7201   test -z "$as_dir" && as_dir=.
7202   for ac_exec_ext in '' $ac_executable_extensions; do
7203   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7204     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7205     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7206     break 2
7207   fi
7208 done
7209 done
7210
7211 fi
7212 fi
7213 NM=$ac_cv_prog_NM
7214 if test -n "$NM"; then
7215   echo "$as_me:$LINENO: result: $NM" >&5
7216 echo "${ECHO_T}$NM" >&6
7217 else
7218   echo "$as_me:$LINENO: result: no" >&5
7219 echo "${ECHO_T}no" >&6
7220 fi
7221
7222   fi
7223   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7224     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7225 set dummy ${ncn_progname}; ac_word=$2
7226 echo "$as_me:$LINENO: checking for $ac_word" >&5
7227 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7228 if test "${ac_cv_prog_NM+set}" = set; then
7229   echo $ECHO_N "(cached) $ECHO_C" >&6
7230 else
7231   if test -n "$NM"; then
7232   ac_cv_prog_NM="$NM" # Let the user override the test.
7233 else
7234 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7235 for as_dir in $PATH
7236 do
7237   IFS=$as_save_IFS
7238   test -z "$as_dir" && as_dir=.
7239   for ac_exec_ext in '' $ac_executable_extensions; do
7240   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7241     ac_cv_prog_NM="${ncn_progname}"
7242     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7243     break 2
7244   fi
7245 done
7246 done
7247
7248 fi
7249 fi
7250 NM=$ac_cv_prog_NM
7251 if test -n "$NM"; then
7252   echo "$as_me:$LINENO: result: $NM" >&5
7253 echo "${ECHO_T}$NM" >&6
7254 else
7255   echo "$as_me:$LINENO: result: no" >&5
7256 echo "${ECHO_T}no" >&6
7257 fi
7258
7259   fi
7260   test -n "$ac_cv_prog_NM" && break
7261 done
7262
7263 if test -z "$ac_cv_prog_NM" ; then
7264   set dummy nm
7265   if test $build = $host ; then
7266     NM="$2"
7267   else
7268     NM="${ncn_tool_prefix}$2"
7269   fi
7270 fi
7271
7272
7273
7274 if test -n "$RANLIB"; then
7275   ac_cv_prog_RANLIB=$RANLIB
7276 elif test -n "$ac_cv_prog_RANLIB"; then
7277   RANLIB=$ac_cv_prog_RANLIB
7278 fi
7279
7280 if test -n "$ac_cv_prog_RANLIB"; then
7281   for ncn_progname in ranlib; do
7282     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7283 set dummy ${ncn_progname}; ac_word=$2
7284 echo "$as_me:$LINENO: checking for $ac_word" >&5
7285 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7286 if test "${ac_cv_prog_RANLIB+set}" = set; then
7287   echo $ECHO_N "(cached) $ECHO_C" >&6
7288 else
7289   if test -n "$RANLIB"; then
7290   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7291 else
7292 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7293 for as_dir in $PATH
7294 do
7295   IFS=$as_save_IFS
7296   test -z "$as_dir" && as_dir=.
7297   for ac_exec_ext in '' $ac_executable_extensions; do
7298   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7299     ac_cv_prog_RANLIB="${ncn_progname}"
7300     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7301     break 2
7302   fi
7303 done
7304 done
7305
7306 fi
7307 fi
7308 RANLIB=$ac_cv_prog_RANLIB
7309 if test -n "$RANLIB"; then
7310   echo "$as_me:$LINENO: result: $RANLIB" >&5
7311 echo "${ECHO_T}$RANLIB" >&6
7312 else
7313   echo "$as_me:$LINENO: result: no" >&5
7314 echo "${ECHO_T}no" >&6
7315 fi
7316
7317   done
7318 fi
7319
7320 for ncn_progname in ranlib; do
7321   if test -n "$ncn_tool_prefix"; then
7322     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7323 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7324 echo "$as_me:$LINENO: checking for $ac_word" >&5
7325 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7326 if test "${ac_cv_prog_RANLIB+set}" = set; then
7327   echo $ECHO_N "(cached) $ECHO_C" >&6
7328 else
7329   if test -n "$RANLIB"; then
7330   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7331 else
7332 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7333 for as_dir in $PATH
7334 do
7335   IFS=$as_save_IFS
7336   test -z "$as_dir" && as_dir=.
7337   for ac_exec_ext in '' $ac_executable_extensions; do
7338   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7339     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7340     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7341     break 2
7342   fi
7343 done
7344 done
7345
7346 fi
7347 fi
7348 RANLIB=$ac_cv_prog_RANLIB
7349 if test -n "$RANLIB"; then
7350   echo "$as_me:$LINENO: result: $RANLIB" >&5
7351 echo "${ECHO_T}$RANLIB" >&6
7352 else
7353   echo "$as_me:$LINENO: result: no" >&5
7354 echo "${ECHO_T}no" >&6
7355 fi
7356
7357   fi
7358   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7359     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7360 set dummy ${ncn_progname}; ac_word=$2
7361 echo "$as_me:$LINENO: checking for $ac_word" >&5
7362 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7363 if test "${ac_cv_prog_RANLIB+set}" = set; then
7364   echo $ECHO_N "(cached) $ECHO_C" >&6
7365 else
7366   if test -n "$RANLIB"; then
7367   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7368 else
7369 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7370 for as_dir in $PATH
7371 do
7372   IFS=$as_save_IFS
7373   test -z "$as_dir" && as_dir=.
7374   for ac_exec_ext in '' $ac_executable_extensions; do
7375   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7376     ac_cv_prog_RANLIB="${ncn_progname}"
7377     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7378     break 2
7379   fi
7380 done
7381 done
7382
7383 fi
7384 fi
7385 RANLIB=$ac_cv_prog_RANLIB
7386 if test -n "$RANLIB"; then
7387   echo "$as_me:$LINENO: result: $RANLIB" >&5
7388 echo "${ECHO_T}$RANLIB" >&6
7389 else
7390   echo "$as_me:$LINENO: result: no" >&5
7391 echo "${ECHO_T}no" >&6
7392 fi
7393
7394   fi
7395   test -n "$ac_cv_prog_RANLIB" && break
7396 done
7397
7398 if test -z "$ac_cv_prog_RANLIB" ; then
7399   RANLIB=":"
7400 fi
7401
7402
7403
7404 if test -n "$STRIP"; then
7405   ac_cv_prog_STRIP=$STRIP
7406 elif test -n "$ac_cv_prog_STRIP"; then
7407   STRIP=$ac_cv_prog_STRIP
7408 fi
7409
7410 if test -n "$ac_cv_prog_STRIP"; then
7411   for ncn_progname in strip; do
7412     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7413 set dummy ${ncn_progname}; ac_word=$2
7414 echo "$as_me:$LINENO: checking for $ac_word" >&5
7415 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7416 if test "${ac_cv_prog_STRIP+set}" = set; then
7417   echo $ECHO_N "(cached) $ECHO_C" >&6
7418 else
7419   if test -n "$STRIP"; then
7420   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7421 else
7422 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7423 for as_dir in $PATH
7424 do
7425   IFS=$as_save_IFS
7426   test -z "$as_dir" && as_dir=.
7427   for ac_exec_ext in '' $ac_executable_extensions; do
7428   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7429     ac_cv_prog_STRIP="${ncn_progname}"
7430     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7431     break 2
7432   fi
7433 done
7434 done
7435
7436 fi
7437 fi
7438 STRIP=$ac_cv_prog_STRIP
7439 if test -n "$STRIP"; then
7440   echo "$as_me:$LINENO: result: $STRIP" >&5
7441 echo "${ECHO_T}$STRIP" >&6
7442 else
7443   echo "$as_me:$LINENO: result: no" >&5
7444 echo "${ECHO_T}no" >&6
7445 fi
7446
7447   done
7448 fi
7449
7450 for ncn_progname in strip; do
7451   if test -n "$ncn_tool_prefix"; then
7452     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7453 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7454 echo "$as_me:$LINENO: checking for $ac_word" >&5
7455 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7456 if test "${ac_cv_prog_STRIP+set}" = set; then
7457   echo $ECHO_N "(cached) $ECHO_C" >&6
7458 else
7459   if test -n "$STRIP"; then
7460   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7461 else
7462 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7463 for as_dir in $PATH
7464 do
7465   IFS=$as_save_IFS
7466   test -z "$as_dir" && as_dir=.
7467   for ac_exec_ext in '' $ac_executable_extensions; do
7468   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7469     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7470     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7471     break 2
7472   fi
7473 done
7474 done
7475
7476 fi
7477 fi
7478 STRIP=$ac_cv_prog_STRIP
7479 if test -n "$STRIP"; then
7480   echo "$as_me:$LINENO: result: $STRIP" >&5
7481 echo "${ECHO_T}$STRIP" >&6
7482 else
7483   echo "$as_me:$LINENO: result: no" >&5
7484 echo "${ECHO_T}no" >&6
7485 fi
7486
7487   fi
7488   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7489     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7490 set dummy ${ncn_progname}; ac_word=$2
7491 echo "$as_me:$LINENO: checking for $ac_word" >&5
7492 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7493 if test "${ac_cv_prog_STRIP+set}" = set; then
7494   echo $ECHO_N "(cached) $ECHO_C" >&6
7495 else
7496   if test -n "$STRIP"; then
7497   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7498 else
7499 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7500 for as_dir in $PATH
7501 do
7502   IFS=$as_save_IFS
7503   test -z "$as_dir" && as_dir=.
7504   for ac_exec_ext in '' $ac_executable_extensions; do
7505   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7506     ac_cv_prog_STRIP="${ncn_progname}"
7507     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7508     break 2
7509   fi
7510 done
7511 done
7512
7513 fi
7514 fi
7515 STRIP=$ac_cv_prog_STRIP
7516 if test -n "$STRIP"; then
7517   echo "$as_me:$LINENO: result: $STRIP" >&5
7518 echo "${ECHO_T}$STRIP" >&6
7519 else
7520   echo "$as_me:$LINENO: result: no" >&5
7521 echo "${ECHO_T}no" >&6
7522 fi
7523
7524   fi
7525   test -n "$ac_cv_prog_STRIP" && break
7526 done
7527
7528 if test -z "$ac_cv_prog_STRIP" ; then
7529   STRIP=":"
7530 fi
7531
7532
7533
7534 if test -n "$WINDRES"; then
7535   ac_cv_prog_WINDRES=$WINDRES
7536 elif test -n "$ac_cv_prog_WINDRES"; then
7537   WINDRES=$ac_cv_prog_WINDRES
7538 fi
7539
7540 if test -n "$ac_cv_prog_WINDRES"; then
7541   for ncn_progname in windres; do
7542     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7543 set dummy ${ncn_progname}; ac_word=$2
7544 echo "$as_me:$LINENO: checking for $ac_word" >&5
7545 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7546 if test "${ac_cv_prog_WINDRES+set}" = set; then
7547   echo $ECHO_N "(cached) $ECHO_C" >&6
7548 else
7549   if test -n "$WINDRES"; then
7550   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7551 else
7552 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7553 for as_dir in $PATH
7554 do
7555   IFS=$as_save_IFS
7556   test -z "$as_dir" && as_dir=.
7557   for ac_exec_ext in '' $ac_executable_extensions; do
7558   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7559     ac_cv_prog_WINDRES="${ncn_progname}"
7560     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7561     break 2
7562   fi
7563 done
7564 done
7565
7566 fi
7567 fi
7568 WINDRES=$ac_cv_prog_WINDRES
7569 if test -n "$WINDRES"; then
7570   echo "$as_me:$LINENO: result: $WINDRES" >&5
7571 echo "${ECHO_T}$WINDRES" >&6
7572 else
7573   echo "$as_me:$LINENO: result: no" >&5
7574 echo "${ECHO_T}no" >&6
7575 fi
7576
7577   done
7578 fi
7579
7580 for ncn_progname in windres; do
7581   if test -n "$ncn_tool_prefix"; then
7582     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7583 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7584 echo "$as_me:$LINENO: checking for $ac_word" >&5
7585 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7586 if test "${ac_cv_prog_WINDRES+set}" = set; then
7587   echo $ECHO_N "(cached) $ECHO_C" >&6
7588 else
7589   if test -n "$WINDRES"; then
7590   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7591 else
7592 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7593 for as_dir in $PATH
7594 do
7595   IFS=$as_save_IFS
7596   test -z "$as_dir" && as_dir=.
7597   for ac_exec_ext in '' $ac_executable_extensions; do
7598   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7599     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7600     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7601     break 2
7602   fi
7603 done
7604 done
7605
7606 fi
7607 fi
7608 WINDRES=$ac_cv_prog_WINDRES
7609 if test -n "$WINDRES"; then
7610   echo "$as_me:$LINENO: result: $WINDRES" >&5
7611 echo "${ECHO_T}$WINDRES" >&6
7612 else
7613   echo "$as_me:$LINENO: result: no" >&5
7614 echo "${ECHO_T}no" >&6
7615 fi
7616
7617   fi
7618   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7619     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7620 set dummy ${ncn_progname}; ac_word=$2
7621 echo "$as_me:$LINENO: checking for $ac_word" >&5
7622 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7623 if test "${ac_cv_prog_WINDRES+set}" = set; then
7624   echo $ECHO_N "(cached) $ECHO_C" >&6
7625 else
7626   if test -n "$WINDRES"; then
7627   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7628 else
7629 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7630 for as_dir in $PATH
7631 do
7632   IFS=$as_save_IFS
7633   test -z "$as_dir" && as_dir=.
7634   for ac_exec_ext in '' $ac_executable_extensions; do
7635   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7636     ac_cv_prog_WINDRES="${ncn_progname}"
7637     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7638     break 2
7639   fi
7640 done
7641 done
7642
7643 fi
7644 fi
7645 WINDRES=$ac_cv_prog_WINDRES
7646 if test -n "$WINDRES"; then
7647   echo "$as_me:$LINENO: result: $WINDRES" >&5
7648 echo "${ECHO_T}$WINDRES" >&6
7649 else
7650   echo "$as_me:$LINENO: result: no" >&5
7651 echo "${ECHO_T}no" >&6
7652 fi
7653
7654   fi
7655   test -n "$ac_cv_prog_WINDRES" && break
7656 done
7657
7658 if test -z "$ac_cv_prog_WINDRES" ; then
7659   set dummy windres
7660   if test $build = $host ; then
7661     WINDRES="$2"
7662   else
7663     WINDRES="${ncn_tool_prefix}$2"
7664   fi
7665 fi
7666
7667
7668
7669 if test -n "$WINDMC"; then
7670   ac_cv_prog_WINDMC=$WINDMC
7671 elif test -n "$ac_cv_prog_WINDMC"; then
7672   WINDMC=$ac_cv_prog_WINDMC
7673 fi
7674
7675 if test -n "$ac_cv_prog_WINDMC"; then
7676   for ncn_progname in windmc; do
7677     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7678 set dummy ${ncn_progname}; ac_word=$2
7679 echo "$as_me:$LINENO: checking for $ac_word" >&5
7680 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7681 if test "${ac_cv_prog_WINDMC+set}" = set; then
7682   echo $ECHO_N "(cached) $ECHO_C" >&6
7683 else
7684   if test -n "$WINDMC"; then
7685   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7686 else
7687 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7688 for as_dir in $PATH
7689 do
7690   IFS=$as_save_IFS
7691   test -z "$as_dir" && as_dir=.
7692   for ac_exec_ext in '' $ac_executable_extensions; do
7693   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7694     ac_cv_prog_WINDMC="${ncn_progname}"
7695     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7696     break 2
7697   fi
7698 done
7699 done
7700
7701 fi
7702 fi
7703 WINDMC=$ac_cv_prog_WINDMC
7704 if test -n "$WINDMC"; then
7705   echo "$as_me:$LINENO: result: $WINDMC" >&5
7706 echo "${ECHO_T}$WINDMC" >&6
7707 else
7708   echo "$as_me:$LINENO: result: no" >&5
7709 echo "${ECHO_T}no" >&6
7710 fi
7711
7712   done
7713 fi
7714
7715 for ncn_progname in windmc; do
7716   if test -n "$ncn_tool_prefix"; then
7717     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7718 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7719 echo "$as_me:$LINENO: checking for $ac_word" >&5
7720 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7721 if test "${ac_cv_prog_WINDMC+set}" = set; then
7722   echo $ECHO_N "(cached) $ECHO_C" >&6
7723 else
7724   if test -n "$WINDMC"; then
7725   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7726 else
7727 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7728 for as_dir in $PATH
7729 do
7730   IFS=$as_save_IFS
7731   test -z "$as_dir" && as_dir=.
7732   for ac_exec_ext in '' $ac_executable_extensions; do
7733   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7734     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7735     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7736     break 2
7737   fi
7738 done
7739 done
7740
7741 fi
7742 fi
7743 WINDMC=$ac_cv_prog_WINDMC
7744 if test -n "$WINDMC"; then
7745   echo "$as_me:$LINENO: result: $WINDMC" >&5
7746 echo "${ECHO_T}$WINDMC" >&6
7747 else
7748   echo "$as_me:$LINENO: result: no" >&5
7749 echo "${ECHO_T}no" >&6
7750 fi
7751
7752   fi
7753   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7754     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7755 set dummy ${ncn_progname}; ac_word=$2
7756 echo "$as_me:$LINENO: checking for $ac_word" >&5
7757 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7758 if test "${ac_cv_prog_WINDMC+set}" = set; then
7759   echo $ECHO_N "(cached) $ECHO_C" >&6
7760 else
7761   if test -n "$WINDMC"; then
7762   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7763 else
7764 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7765 for as_dir in $PATH
7766 do
7767   IFS=$as_save_IFS
7768   test -z "$as_dir" && as_dir=.
7769   for ac_exec_ext in '' $ac_executable_extensions; do
7770   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7771     ac_cv_prog_WINDMC="${ncn_progname}"
7772     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7773     break 2
7774   fi
7775 done
7776 done
7777
7778 fi
7779 fi
7780 WINDMC=$ac_cv_prog_WINDMC
7781 if test -n "$WINDMC"; then
7782   echo "$as_me:$LINENO: result: $WINDMC" >&5
7783 echo "${ECHO_T}$WINDMC" >&6
7784 else
7785   echo "$as_me:$LINENO: result: no" >&5
7786 echo "${ECHO_T}no" >&6
7787 fi
7788
7789   fi
7790   test -n "$ac_cv_prog_WINDMC" && break
7791 done
7792
7793 if test -z "$ac_cv_prog_WINDMC" ; then
7794   set dummy windmc
7795   if test $build = $host ; then
7796     WINDMC="$2"
7797   else
7798     WINDMC="${ncn_tool_prefix}$2"
7799   fi
7800 fi
7801
7802
7803
7804 if test -n "$OBJCOPY"; then
7805   ac_cv_prog_OBJCOPY=$OBJCOPY
7806 elif test -n "$ac_cv_prog_OBJCOPY"; then
7807   OBJCOPY=$ac_cv_prog_OBJCOPY
7808 fi
7809
7810 if test -n "$ac_cv_prog_OBJCOPY"; then
7811   for ncn_progname in objcopy; do
7812     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7813 set dummy ${ncn_progname}; ac_word=$2
7814 echo "$as_me:$LINENO: checking for $ac_word" >&5
7815 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7816 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7817   echo $ECHO_N "(cached) $ECHO_C" >&6
7818 else
7819   if test -n "$OBJCOPY"; then
7820   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7821 else
7822 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7823 for as_dir in $PATH
7824 do
7825   IFS=$as_save_IFS
7826   test -z "$as_dir" && as_dir=.
7827   for ac_exec_ext in '' $ac_executable_extensions; do
7828   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7829     ac_cv_prog_OBJCOPY="${ncn_progname}"
7830     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7831     break 2
7832   fi
7833 done
7834 done
7835
7836 fi
7837 fi
7838 OBJCOPY=$ac_cv_prog_OBJCOPY
7839 if test -n "$OBJCOPY"; then
7840   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7841 echo "${ECHO_T}$OBJCOPY" >&6
7842 else
7843   echo "$as_me:$LINENO: result: no" >&5
7844 echo "${ECHO_T}no" >&6
7845 fi
7846
7847   done
7848 fi
7849
7850 for ncn_progname in objcopy; do
7851   if test -n "$ncn_tool_prefix"; then
7852     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7853 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7854 echo "$as_me:$LINENO: checking for $ac_word" >&5
7855 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7856 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7857   echo $ECHO_N "(cached) $ECHO_C" >&6
7858 else
7859   if test -n "$OBJCOPY"; then
7860   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7861 else
7862 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7863 for as_dir in $PATH
7864 do
7865   IFS=$as_save_IFS
7866   test -z "$as_dir" && as_dir=.
7867   for ac_exec_ext in '' $ac_executable_extensions; do
7868   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7869     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7870     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7871     break 2
7872   fi
7873 done
7874 done
7875
7876 fi
7877 fi
7878 OBJCOPY=$ac_cv_prog_OBJCOPY
7879 if test -n "$OBJCOPY"; then
7880   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7881 echo "${ECHO_T}$OBJCOPY" >&6
7882 else
7883   echo "$as_me:$LINENO: result: no" >&5
7884 echo "${ECHO_T}no" >&6
7885 fi
7886
7887   fi
7888   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7889     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7890 set dummy ${ncn_progname}; ac_word=$2
7891 echo "$as_me:$LINENO: checking for $ac_word" >&5
7892 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7893 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7894   echo $ECHO_N "(cached) $ECHO_C" >&6
7895 else
7896   if test -n "$OBJCOPY"; then
7897   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7898 else
7899 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7900 for as_dir in $PATH
7901 do
7902   IFS=$as_save_IFS
7903   test -z "$as_dir" && as_dir=.
7904   for ac_exec_ext in '' $ac_executable_extensions; do
7905   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7906     ac_cv_prog_OBJCOPY="${ncn_progname}"
7907     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7908     break 2
7909   fi
7910 done
7911 done
7912
7913 fi
7914 fi
7915 OBJCOPY=$ac_cv_prog_OBJCOPY
7916 if test -n "$OBJCOPY"; then
7917   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7918 echo "${ECHO_T}$OBJCOPY" >&6
7919 else
7920   echo "$as_me:$LINENO: result: no" >&5
7921 echo "${ECHO_T}no" >&6
7922 fi
7923
7924   fi
7925   test -n "$ac_cv_prog_OBJCOPY" && break
7926 done
7927
7928 if test -z "$ac_cv_prog_OBJCOPY" ; then
7929   set dummy objcopy
7930   if test $build = $host ; then
7931     OBJCOPY="$2"
7932   else
7933     OBJCOPY="${ncn_tool_prefix}$2"
7934   fi
7935 fi
7936
7937
7938
7939 if test -n "$OBJDUMP"; then
7940   ac_cv_prog_OBJDUMP=$OBJDUMP
7941 elif test -n "$ac_cv_prog_OBJDUMP"; then
7942   OBJDUMP=$ac_cv_prog_OBJDUMP
7943 fi
7944
7945 if test -n "$ac_cv_prog_OBJDUMP"; then
7946   for ncn_progname in objdump; do
7947     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7948 set dummy ${ncn_progname}; ac_word=$2
7949 echo "$as_me:$LINENO: checking for $ac_word" >&5
7950 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7951 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7952   echo $ECHO_N "(cached) $ECHO_C" >&6
7953 else
7954   if test -n "$OBJDUMP"; then
7955   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7956 else
7957 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7958 for as_dir in $PATH
7959 do
7960   IFS=$as_save_IFS
7961   test -z "$as_dir" && as_dir=.
7962   for ac_exec_ext in '' $ac_executable_extensions; do
7963   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7964     ac_cv_prog_OBJDUMP="${ncn_progname}"
7965     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7966     break 2
7967   fi
7968 done
7969 done
7970
7971 fi
7972 fi
7973 OBJDUMP=$ac_cv_prog_OBJDUMP
7974 if test -n "$OBJDUMP"; then
7975   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7976 echo "${ECHO_T}$OBJDUMP" >&6
7977 else
7978   echo "$as_me:$LINENO: result: no" >&5
7979 echo "${ECHO_T}no" >&6
7980 fi
7981
7982   done
7983 fi
7984
7985 for ncn_progname in objdump; do
7986   if test -n "$ncn_tool_prefix"; then
7987     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7988 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7989 echo "$as_me:$LINENO: checking for $ac_word" >&5
7990 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7991 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7992   echo $ECHO_N "(cached) $ECHO_C" >&6
7993 else
7994   if test -n "$OBJDUMP"; then
7995   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7996 else
7997 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7998 for as_dir in $PATH
7999 do
8000   IFS=$as_save_IFS
8001   test -z "$as_dir" && as_dir=.
8002   for ac_exec_ext in '' $ac_executable_extensions; do
8003   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8004     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8005     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8006     break 2
8007   fi
8008 done
8009 done
8010
8011 fi
8012 fi
8013 OBJDUMP=$ac_cv_prog_OBJDUMP
8014 if test -n "$OBJDUMP"; then
8015   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8016 echo "${ECHO_T}$OBJDUMP" >&6
8017 else
8018   echo "$as_me:$LINENO: result: no" >&5
8019 echo "${ECHO_T}no" >&6
8020 fi
8021
8022   fi
8023   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8024     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8025 set dummy ${ncn_progname}; ac_word=$2
8026 echo "$as_me:$LINENO: checking for $ac_word" >&5
8027 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8028 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8029   echo $ECHO_N "(cached) $ECHO_C" >&6
8030 else
8031   if test -n "$OBJDUMP"; then
8032   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8033 else
8034 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8035 for as_dir in $PATH
8036 do
8037   IFS=$as_save_IFS
8038   test -z "$as_dir" && as_dir=.
8039   for ac_exec_ext in '' $ac_executable_extensions; do
8040   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8041     ac_cv_prog_OBJDUMP="${ncn_progname}"
8042     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8043     break 2
8044   fi
8045 done
8046 done
8047
8048 fi
8049 fi
8050 OBJDUMP=$ac_cv_prog_OBJDUMP
8051 if test -n "$OBJDUMP"; then
8052   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8053 echo "${ECHO_T}$OBJDUMP" >&6
8054 else
8055   echo "$as_me:$LINENO: result: no" >&5
8056 echo "${ECHO_T}no" >&6
8057 fi
8058
8059   fi
8060   test -n "$ac_cv_prog_OBJDUMP" && break
8061 done
8062
8063 if test -z "$ac_cv_prog_OBJDUMP" ; then
8064   set dummy objdump
8065   if test $build = $host ; then
8066     OBJDUMP="$2"
8067   else
8068     OBJDUMP="${ncn_tool_prefix}$2"
8069   fi
8070 fi
8071
8072
8073
8074
8075
8076
8077 # Target tools.
8078
8079 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8080 if test "${with_build_time_tools+set}" = set; then
8081   withval="$with_build_time_tools"
8082   case x"$withval" in
8083      x/*) ;;
8084      *)
8085        with_build_time_tools=
8086        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8087 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8088        ;;
8089    esac
8090 else
8091   with_build_time_tools=
8092 fi;
8093
8094
8095
8096 if test -n "$CC_FOR_TARGET"; then
8097   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8098 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8099   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8100 fi
8101
8102 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8103   for ncn_progname in cc gcc; do
8104     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8105 set dummy ${ncn_progname}; ac_word=$2
8106 echo "$as_me:$LINENO: checking for $ac_word" >&5
8107 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8108 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8109   echo $ECHO_N "(cached) $ECHO_C" >&6
8110 else
8111   if test -n "$CC_FOR_TARGET"; then
8112   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8113 else
8114 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8115 for as_dir in $PATH
8116 do
8117   IFS=$as_save_IFS
8118   test -z "$as_dir" && as_dir=.
8119   for ac_exec_ext in '' $ac_executable_extensions; do
8120   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8121     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8122     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8123     break 2
8124   fi
8125 done
8126 done
8127
8128 fi
8129 fi
8130 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8131 if test -n "$CC_FOR_TARGET"; then
8132   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8133 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8134 else
8135   echo "$as_me:$LINENO: result: no" >&5
8136 echo "${ECHO_T}no" >&6
8137 fi
8138
8139   done
8140 fi
8141
8142 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8143   for ncn_progname in cc gcc; do
8144     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8145 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8146     if test -x $with_build_time_tools/${ncn_progname}; then
8147       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8148       echo "$as_me:$LINENO: result: yes" >&5
8149 echo "${ECHO_T}yes" >&6
8150       break
8151     else
8152       echo "$as_me:$LINENO: result: no" >&5
8153 echo "${ECHO_T}no" >&6
8154     fi
8155   done
8156 fi
8157
8158 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8159   for ncn_progname in cc gcc; do
8160     if test -n "$ncn_target_tool_prefix"; then
8161       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8162 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8163 echo "$as_me:$LINENO: checking for $ac_word" >&5
8164 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8165 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8166   echo $ECHO_N "(cached) $ECHO_C" >&6
8167 else
8168   if test -n "$CC_FOR_TARGET"; then
8169   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8170 else
8171 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8172 for as_dir in $PATH
8173 do
8174   IFS=$as_save_IFS
8175   test -z "$as_dir" && as_dir=.
8176   for ac_exec_ext in '' $ac_executable_extensions; do
8177   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8178     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8179     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8180     break 2
8181   fi
8182 done
8183 done
8184
8185 fi
8186 fi
8187 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8188 if test -n "$CC_FOR_TARGET"; then
8189   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8190 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8191 else
8192   echo "$as_me:$LINENO: result: no" >&5
8193 echo "${ECHO_T}no" >&6
8194 fi
8195
8196     fi
8197     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8198       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8199 set dummy ${ncn_progname}; ac_word=$2
8200 echo "$as_me:$LINENO: checking for $ac_word" >&5
8201 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8202 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8203   echo $ECHO_N "(cached) $ECHO_C" >&6
8204 else
8205   if test -n "$CC_FOR_TARGET"; then
8206   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8207 else
8208 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8209 for as_dir in $PATH
8210 do
8211   IFS=$as_save_IFS
8212   test -z "$as_dir" && as_dir=.
8213   for ac_exec_ext in '' $ac_executable_extensions; do
8214   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8215     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8216     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8217     break 2
8218   fi
8219 done
8220 done
8221
8222 fi
8223 fi
8224 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8225 if test -n "$CC_FOR_TARGET"; then
8226   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8227 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8228 else
8229   echo "$as_me:$LINENO: result: no" >&5
8230 echo "${ECHO_T}no" >&6
8231 fi
8232
8233     fi
8234     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8235   done
8236 fi
8237
8238 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8239   set dummy cc gcc
8240   if test $build = $target ; then
8241     CC_FOR_TARGET="$2"
8242   else
8243     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8244   fi
8245 else
8246   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8247 fi
8248
8249
8250
8251 if test -n "$CXX_FOR_TARGET"; then
8252   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8253 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8254   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8255 fi
8256
8257 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8258   for ncn_progname in c++ g++ cxx gxx; do
8259     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8260 set dummy ${ncn_progname}; ac_word=$2
8261 echo "$as_me:$LINENO: checking for $ac_word" >&5
8262 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8263 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8264   echo $ECHO_N "(cached) $ECHO_C" >&6
8265 else
8266   if test -n "$CXX_FOR_TARGET"; then
8267   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8268 else
8269 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8270 for as_dir in $PATH
8271 do
8272   IFS=$as_save_IFS
8273   test -z "$as_dir" && as_dir=.
8274   for ac_exec_ext in '' $ac_executable_extensions; do
8275   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8276     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8277     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8278     break 2
8279   fi
8280 done
8281 done
8282
8283 fi
8284 fi
8285 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8286 if test -n "$CXX_FOR_TARGET"; then
8287   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8288 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8289 else
8290   echo "$as_me:$LINENO: result: no" >&5
8291 echo "${ECHO_T}no" >&6
8292 fi
8293
8294   done
8295 fi
8296
8297 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8298   for ncn_progname in c++ g++ cxx gxx; do
8299     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8300 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8301     if test -x $with_build_time_tools/${ncn_progname}; then
8302       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8303       echo "$as_me:$LINENO: result: yes" >&5
8304 echo "${ECHO_T}yes" >&6
8305       break
8306     else
8307       echo "$as_me:$LINENO: result: no" >&5
8308 echo "${ECHO_T}no" >&6
8309     fi
8310   done
8311 fi
8312
8313 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8314   for ncn_progname in c++ g++ cxx gxx; do
8315     if test -n "$ncn_target_tool_prefix"; then
8316       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8317 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8318 echo "$as_me:$LINENO: checking for $ac_word" >&5
8319 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8320 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8321   echo $ECHO_N "(cached) $ECHO_C" >&6
8322 else
8323   if test -n "$CXX_FOR_TARGET"; then
8324   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8325 else
8326 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8327 for as_dir in $PATH
8328 do
8329   IFS=$as_save_IFS
8330   test -z "$as_dir" && as_dir=.
8331   for ac_exec_ext in '' $ac_executable_extensions; do
8332   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8333     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8334     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8335     break 2
8336   fi
8337 done
8338 done
8339
8340 fi
8341 fi
8342 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8343 if test -n "$CXX_FOR_TARGET"; then
8344   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8345 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8346 else
8347   echo "$as_me:$LINENO: result: no" >&5
8348 echo "${ECHO_T}no" >&6
8349 fi
8350
8351     fi
8352     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8353       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8354 set dummy ${ncn_progname}; ac_word=$2
8355 echo "$as_me:$LINENO: checking for $ac_word" >&5
8356 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8357 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8358   echo $ECHO_N "(cached) $ECHO_C" >&6
8359 else
8360   if test -n "$CXX_FOR_TARGET"; then
8361   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8362 else
8363 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8364 for as_dir in $PATH
8365 do
8366   IFS=$as_save_IFS
8367   test -z "$as_dir" && as_dir=.
8368   for ac_exec_ext in '' $ac_executable_extensions; do
8369   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8370     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8371     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8372     break 2
8373   fi
8374 done
8375 done
8376
8377 fi
8378 fi
8379 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8380 if test -n "$CXX_FOR_TARGET"; then
8381   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8382 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8383 else
8384   echo "$as_me:$LINENO: result: no" >&5
8385 echo "${ECHO_T}no" >&6
8386 fi
8387
8388     fi
8389     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8390   done
8391 fi
8392
8393 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8394   set dummy c++ g++ cxx gxx
8395   if test $build = $target ; then
8396     CXX_FOR_TARGET="$2"
8397   else
8398     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8399   fi
8400 else
8401   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8402 fi
8403
8404
8405
8406 if test -n "$GCC_FOR_TARGET"; then
8407   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8408 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8409   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8410 fi
8411
8412 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8413   for ncn_progname in gcc; do
8414     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8415 set dummy ${ncn_progname}; ac_word=$2
8416 echo "$as_me:$LINENO: checking for $ac_word" >&5
8417 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8418 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8419   echo $ECHO_N "(cached) $ECHO_C" >&6
8420 else
8421   if test -n "$GCC_FOR_TARGET"; then
8422   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8423 else
8424 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8425 for as_dir in $PATH
8426 do
8427   IFS=$as_save_IFS
8428   test -z "$as_dir" && as_dir=.
8429   for ac_exec_ext in '' $ac_executable_extensions; do
8430   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8431     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8432     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8433     break 2
8434   fi
8435 done
8436 done
8437
8438 fi
8439 fi
8440 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8441 if test -n "$GCC_FOR_TARGET"; then
8442   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8443 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8444 else
8445   echo "$as_me:$LINENO: result: no" >&5
8446 echo "${ECHO_T}no" >&6
8447 fi
8448
8449   done
8450 fi
8451
8452 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8453   for ncn_progname in gcc; do
8454     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8455 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8456     if test -x $with_build_time_tools/${ncn_progname}; then
8457       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8458       echo "$as_me:$LINENO: result: yes" >&5
8459 echo "${ECHO_T}yes" >&6
8460       break
8461     else
8462       echo "$as_me:$LINENO: result: no" >&5
8463 echo "${ECHO_T}no" >&6
8464     fi
8465   done
8466 fi
8467
8468 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8469   for ncn_progname in gcc; do
8470     if test -n "$ncn_target_tool_prefix"; then
8471       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8472 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8473 echo "$as_me:$LINENO: checking for $ac_word" >&5
8474 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8475 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8476   echo $ECHO_N "(cached) $ECHO_C" >&6
8477 else
8478   if test -n "$GCC_FOR_TARGET"; then
8479   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8480 else
8481 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8482 for as_dir in $PATH
8483 do
8484   IFS=$as_save_IFS
8485   test -z "$as_dir" && as_dir=.
8486   for ac_exec_ext in '' $ac_executable_extensions; do
8487   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8488     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8489     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8490     break 2
8491   fi
8492 done
8493 done
8494
8495 fi
8496 fi
8497 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8498 if test -n "$GCC_FOR_TARGET"; then
8499   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8500 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8501 else
8502   echo "$as_me:$LINENO: result: no" >&5
8503 echo "${ECHO_T}no" >&6
8504 fi
8505
8506     fi
8507     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8508       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8509 set dummy ${ncn_progname}; ac_word=$2
8510 echo "$as_me:$LINENO: checking for $ac_word" >&5
8511 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8512 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8513   echo $ECHO_N "(cached) $ECHO_C" >&6
8514 else
8515   if test -n "$GCC_FOR_TARGET"; then
8516   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8517 else
8518 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8519 for as_dir in $PATH
8520 do
8521   IFS=$as_save_IFS
8522   test -z "$as_dir" && as_dir=.
8523   for ac_exec_ext in '' $ac_executable_extensions; do
8524   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8525     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8526     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8527     break 2
8528   fi
8529 done
8530 done
8531
8532 fi
8533 fi
8534 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8535 if test -n "$GCC_FOR_TARGET"; then
8536   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8537 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8538 else
8539   echo "$as_me:$LINENO: result: no" >&5
8540 echo "${ECHO_T}no" >&6
8541 fi
8542
8543     fi
8544     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8545   done
8546 fi
8547
8548 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8549   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8550 else
8551   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8552 fi
8553
8554
8555
8556 if test -n "$GCJ_FOR_TARGET"; then
8557   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8558 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8559   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8560 fi
8561
8562 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8563   for ncn_progname in gcj; do
8564     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8565 set dummy ${ncn_progname}; ac_word=$2
8566 echo "$as_me:$LINENO: checking for $ac_word" >&5
8567 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8568 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8569   echo $ECHO_N "(cached) $ECHO_C" >&6
8570 else
8571   if test -n "$GCJ_FOR_TARGET"; then
8572   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8573 else
8574 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8575 for as_dir in $PATH
8576 do
8577   IFS=$as_save_IFS
8578   test -z "$as_dir" && as_dir=.
8579   for ac_exec_ext in '' $ac_executable_extensions; do
8580   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8581     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8582     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8583     break 2
8584   fi
8585 done
8586 done
8587
8588 fi
8589 fi
8590 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8591 if test -n "$GCJ_FOR_TARGET"; then
8592   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8593 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8594 else
8595   echo "$as_me:$LINENO: result: no" >&5
8596 echo "${ECHO_T}no" >&6
8597 fi
8598
8599   done
8600 fi
8601
8602 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8603   for ncn_progname in gcj; do
8604     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8605 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8606     if test -x $with_build_time_tools/${ncn_progname}; then
8607       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8608       echo "$as_me:$LINENO: result: yes" >&5
8609 echo "${ECHO_T}yes" >&6
8610       break
8611     else
8612       echo "$as_me:$LINENO: result: no" >&5
8613 echo "${ECHO_T}no" >&6
8614     fi
8615   done
8616 fi
8617
8618 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8619   for ncn_progname in gcj; do
8620     if test -n "$ncn_target_tool_prefix"; then
8621       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8622 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8623 echo "$as_me:$LINENO: checking for $ac_word" >&5
8624 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8625 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8626   echo $ECHO_N "(cached) $ECHO_C" >&6
8627 else
8628   if test -n "$GCJ_FOR_TARGET"; then
8629   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8630 else
8631 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8632 for as_dir in $PATH
8633 do
8634   IFS=$as_save_IFS
8635   test -z "$as_dir" && as_dir=.
8636   for ac_exec_ext in '' $ac_executable_extensions; do
8637   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8638     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8639     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8640     break 2
8641   fi
8642 done
8643 done
8644
8645 fi
8646 fi
8647 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8648 if test -n "$GCJ_FOR_TARGET"; then
8649   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8650 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8651 else
8652   echo "$as_me:$LINENO: result: no" >&5
8653 echo "${ECHO_T}no" >&6
8654 fi
8655
8656     fi
8657     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8658       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8659 set dummy ${ncn_progname}; ac_word=$2
8660 echo "$as_me:$LINENO: checking for $ac_word" >&5
8661 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8662 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8663   echo $ECHO_N "(cached) $ECHO_C" >&6
8664 else
8665   if test -n "$GCJ_FOR_TARGET"; then
8666   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8667 else
8668 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8669 for as_dir in $PATH
8670 do
8671   IFS=$as_save_IFS
8672   test -z "$as_dir" && as_dir=.
8673   for ac_exec_ext in '' $ac_executable_extensions; do
8674   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8675     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8676     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8677     break 2
8678   fi
8679 done
8680 done
8681
8682 fi
8683 fi
8684 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8685 if test -n "$GCJ_FOR_TARGET"; then
8686   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8687 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8688 else
8689   echo "$as_me:$LINENO: result: no" >&5
8690 echo "${ECHO_T}no" >&6
8691 fi
8692
8693     fi
8694     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8695   done
8696 fi
8697
8698 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8699   set dummy gcj
8700   if test $build = $target ; then
8701     GCJ_FOR_TARGET="$2"
8702   else
8703     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8704   fi
8705 else
8706   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8707 fi
8708
8709
8710
8711 if test -n "$GFORTRAN_FOR_TARGET"; then
8712   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8713 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8714   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8715 fi
8716
8717 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8718   for ncn_progname in gfortran; do
8719     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8720 set dummy ${ncn_progname}; ac_word=$2
8721 echo "$as_me:$LINENO: checking for $ac_word" >&5
8722 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8723 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8724   echo $ECHO_N "(cached) $ECHO_C" >&6
8725 else
8726   if test -n "$GFORTRAN_FOR_TARGET"; then
8727   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8728 else
8729 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8730 for as_dir in $PATH
8731 do
8732   IFS=$as_save_IFS
8733   test -z "$as_dir" && as_dir=.
8734   for ac_exec_ext in '' $ac_executable_extensions; do
8735   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8736     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8737     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8738     break 2
8739   fi
8740 done
8741 done
8742
8743 fi
8744 fi
8745 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8746 if test -n "$GFORTRAN_FOR_TARGET"; then
8747   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8748 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8749 else
8750   echo "$as_me:$LINENO: result: no" >&5
8751 echo "${ECHO_T}no" >&6
8752 fi
8753
8754   done
8755 fi
8756
8757 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8758   for ncn_progname in gfortran; do
8759     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8760 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8761     if test -x $with_build_time_tools/${ncn_progname}; then
8762       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8763       echo "$as_me:$LINENO: result: yes" >&5
8764 echo "${ECHO_T}yes" >&6
8765       break
8766     else
8767       echo "$as_me:$LINENO: result: no" >&5
8768 echo "${ECHO_T}no" >&6
8769     fi
8770   done
8771 fi
8772
8773 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8774   for ncn_progname in gfortran; do
8775     if test -n "$ncn_target_tool_prefix"; then
8776       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8777 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8778 echo "$as_me:$LINENO: checking for $ac_word" >&5
8779 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8780 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8781   echo $ECHO_N "(cached) $ECHO_C" >&6
8782 else
8783   if test -n "$GFORTRAN_FOR_TARGET"; then
8784   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8785 else
8786 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8787 for as_dir in $PATH
8788 do
8789   IFS=$as_save_IFS
8790   test -z "$as_dir" && as_dir=.
8791   for ac_exec_ext in '' $ac_executable_extensions; do
8792   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8793     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8794     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8795     break 2
8796   fi
8797 done
8798 done
8799
8800 fi
8801 fi
8802 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8803 if test -n "$GFORTRAN_FOR_TARGET"; then
8804   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8805 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8806 else
8807   echo "$as_me:$LINENO: result: no" >&5
8808 echo "${ECHO_T}no" >&6
8809 fi
8810
8811     fi
8812     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8813       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8814 set dummy ${ncn_progname}; ac_word=$2
8815 echo "$as_me:$LINENO: checking for $ac_word" >&5
8816 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8817 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8818   echo $ECHO_N "(cached) $ECHO_C" >&6
8819 else
8820   if test -n "$GFORTRAN_FOR_TARGET"; then
8821   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8822 else
8823 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8824 for as_dir in $PATH
8825 do
8826   IFS=$as_save_IFS
8827   test -z "$as_dir" && as_dir=.
8828   for ac_exec_ext in '' $ac_executable_extensions; do
8829   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8830     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8831     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8832     break 2
8833   fi
8834 done
8835 done
8836
8837 fi
8838 fi
8839 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8840 if test -n "$GFORTRAN_FOR_TARGET"; then
8841   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8842 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8843 else
8844   echo "$as_me:$LINENO: result: no" >&5
8845 echo "${ECHO_T}no" >&6
8846 fi
8847
8848     fi
8849     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8850   done
8851 fi
8852
8853 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8854   set dummy gfortran
8855   if test $build = $target ; then
8856     GFORTRAN_FOR_TARGET="$2"
8857   else
8858     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8859   fi
8860 else
8861   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8862 fi
8863
8864
8865
8866 cat > conftest.c << \EOF
8867 #ifdef __GNUC__
8868   gcc_yay;
8869 #endif
8870 EOF
8871 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8872   have_gcc_for_target=yes
8873 else
8874   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8875   have_gcc_for_target=no
8876 fi
8877 rm conftest.c
8878
8879
8880
8881
8882 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8883   if test -n "$with_build_time_tools"; then
8884     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8885 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8886     if test -x $with_build_time_tools/ar; then
8887       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8888       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8889       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8890 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8891     else
8892       echo "$as_me:$LINENO: result: no" >&5
8893 echo "${ECHO_T}no" >&6
8894     fi
8895   elif test $build != $host && test $have_gcc_for_target = yes; then
8896     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8897     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8898     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8899   fi
8900 fi
8901 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8902   # Extract the first word of "ar", so it can be a program name with args.
8903 set dummy ar; ac_word=$2
8904 echo "$as_me:$LINENO: checking for $ac_word" >&5
8905 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8906 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8907   echo $ECHO_N "(cached) $ECHO_C" >&6
8908 else
8909   case $AR_FOR_TARGET in
8910   [\\/]* | ?:[\\/]*)
8911   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8912   ;;
8913   *)
8914   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8915 for as_dir in $gcc_cv_tool_dirs
8916 do
8917   IFS=$as_save_IFS
8918   test -z "$as_dir" && as_dir=.
8919   for ac_exec_ext in '' $ac_executable_extensions; do
8920   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8921     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8922     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8923     break 2
8924   fi
8925 done
8926 done
8927
8928   ;;
8929 esac
8930 fi
8931 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8932
8933 if test -n "$AR_FOR_TARGET"; then
8934   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8935 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8936 else
8937   echo "$as_me:$LINENO: result: no" >&5
8938 echo "${ECHO_T}no" >&6
8939 fi
8940
8941 fi
8942 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8943
8944
8945 if test -n "$AR_FOR_TARGET"; then
8946   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8947 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8948   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8949 fi
8950
8951 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8952   for ncn_progname in ar; do
8953     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8954 set dummy ${ncn_progname}; ac_word=$2
8955 echo "$as_me:$LINENO: checking for $ac_word" >&5
8956 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8957 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8958   echo $ECHO_N "(cached) $ECHO_C" >&6
8959 else
8960   if test -n "$AR_FOR_TARGET"; then
8961   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8962 else
8963 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8964 for as_dir in $PATH
8965 do
8966   IFS=$as_save_IFS
8967   test -z "$as_dir" && as_dir=.
8968   for ac_exec_ext in '' $ac_executable_extensions; do
8969   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8970     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8971     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8972     break 2
8973   fi
8974 done
8975 done
8976
8977 fi
8978 fi
8979 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8980 if test -n "$AR_FOR_TARGET"; then
8981   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8982 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8983 else
8984   echo "$as_me:$LINENO: result: no" >&5
8985 echo "${ECHO_T}no" >&6
8986 fi
8987
8988   done
8989 fi
8990
8991 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8992   for ncn_progname in ar; do
8993     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8994 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8995     if test -x $with_build_time_tools/${ncn_progname}; then
8996       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8997       echo "$as_me:$LINENO: result: yes" >&5
8998 echo "${ECHO_T}yes" >&6
8999       break
9000     else
9001       echo "$as_me:$LINENO: result: no" >&5
9002 echo "${ECHO_T}no" >&6
9003     fi
9004   done
9005 fi
9006
9007 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9008   for ncn_progname in ar; do
9009     if test -n "$ncn_target_tool_prefix"; then
9010       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9011 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9012 echo "$as_me:$LINENO: checking for $ac_word" >&5
9013 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9014 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9015   echo $ECHO_N "(cached) $ECHO_C" >&6
9016 else
9017   if test -n "$AR_FOR_TARGET"; then
9018   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9019 else
9020 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9021 for as_dir in $PATH
9022 do
9023   IFS=$as_save_IFS
9024   test -z "$as_dir" && as_dir=.
9025   for ac_exec_ext in '' $ac_executable_extensions; do
9026   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9027     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9028     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9029     break 2
9030   fi
9031 done
9032 done
9033
9034 fi
9035 fi
9036 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9037 if test -n "$AR_FOR_TARGET"; then
9038   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9039 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9040 else
9041   echo "$as_me:$LINENO: result: no" >&5
9042 echo "${ECHO_T}no" >&6
9043 fi
9044
9045     fi
9046     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9047       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9048 set dummy ${ncn_progname}; ac_word=$2
9049 echo "$as_me:$LINENO: checking for $ac_word" >&5
9050 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9051 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9052   echo $ECHO_N "(cached) $ECHO_C" >&6
9053 else
9054   if test -n "$AR_FOR_TARGET"; then
9055   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9056 else
9057 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9058 for as_dir in $PATH
9059 do
9060   IFS=$as_save_IFS
9061   test -z "$as_dir" && as_dir=.
9062   for ac_exec_ext in '' $ac_executable_extensions; do
9063   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9064     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9065     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9066     break 2
9067   fi
9068 done
9069 done
9070
9071 fi
9072 fi
9073 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9074 if test -n "$AR_FOR_TARGET"; then
9075   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9076 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9077 else
9078   echo "$as_me:$LINENO: result: no" >&5
9079 echo "${ECHO_T}no" >&6
9080 fi
9081
9082     fi
9083     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9084   done
9085 fi
9086
9087 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9088   set dummy ar
9089   if test $build = $target ; then
9090     AR_FOR_TARGET="$2"
9091   else
9092     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9093   fi
9094 else
9095   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9096 fi
9097
9098 else
9099   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9100 fi
9101
9102
9103
9104
9105 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9106   if test -n "$with_build_time_tools"; then
9107     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9108 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9109     if test -x $with_build_time_tools/as; then
9110       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9111       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9112       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9113 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9114     else
9115       echo "$as_me:$LINENO: result: no" >&5
9116 echo "${ECHO_T}no" >&6
9117     fi
9118   elif test $build != $host && test $have_gcc_for_target = yes; then
9119     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9120     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9121     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9122   fi
9123 fi
9124 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9125   # Extract the first word of "as", so it can be a program name with args.
9126 set dummy as; ac_word=$2
9127 echo "$as_me:$LINENO: checking for $ac_word" >&5
9128 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9129 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9130   echo $ECHO_N "(cached) $ECHO_C" >&6
9131 else
9132   case $AS_FOR_TARGET in
9133   [\\/]* | ?:[\\/]*)
9134   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9135   ;;
9136   *)
9137   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9138 for as_dir in $gcc_cv_tool_dirs
9139 do
9140   IFS=$as_save_IFS
9141   test -z "$as_dir" && as_dir=.
9142   for ac_exec_ext in '' $ac_executable_extensions; do
9143   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9144     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9145     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9146     break 2
9147   fi
9148 done
9149 done
9150
9151   ;;
9152 esac
9153 fi
9154 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9155
9156 if test -n "$AS_FOR_TARGET"; then
9157   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9158 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9159 else
9160   echo "$as_me:$LINENO: result: no" >&5
9161 echo "${ECHO_T}no" >&6
9162 fi
9163
9164 fi
9165 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9166
9167
9168 if test -n "$AS_FOR_TARGET"; then
9169   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9170 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9171   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9172 fi
9173
9174 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9175   for ncn_progname in as; do
9176     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9177 set dummy ${ncn_progname}; ac_word=$2
9178 echo "$as_me:$LINENO: checking for $ac_word" >&5
9179 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9180 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9181   echo $ECHO_N "(cached) $ECHO_C" >&6
9182 else
9183   if test -n "$AS_FOR_TARGET"; then
9184   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9185 else
9186 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9187 for as_dir in $PATH
9188 do
9189   IFS=$as_save_IFS
9190   test -z "$as_dir" && as_dir=.
9191   for ac_exec_ext in '' $ac_executable_extensions; do
9192   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9193     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9194     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9195     break 2
9196   fi
9197 done
9198 done
9199
9200 fi
9201 fi
9202 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9203 if test -n "$AS_FOR_TARGET"; then
9204   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9205 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9206 else
9207   echo "$as_me:$LINENO: result: no" >&5
9208 echo "${ECHO_T}no" >&6
9209 fi
9210
9211   done
9212 fi
9213
9214 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9215   for ncn_progname in as; do
9216     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9217 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9218     if test -x $with_build_time_tools/${ncn_progname}; then
9219       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9220       echo "$as_me:$LINENO: result: yes" >&5
9221 echo "${ECHO_T}yes" >&6
9222       break
9223     else
9224       echo "$as_me:$LINENO: result: no" >&5
9225 echo "${ECHO_T}no" >&6
9226     fi
9227   done
9228 fi
9229
9230 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9231   for ncn_progname in as; do
9232     if test -n "$ncn_target_tool_prefix"; then
9233       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9234 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9235 echo "$as_me:$LINENO: checking for $ac_word" >&5
9236 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9237 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9238   echo $ECHO_N "(cached) $ECHO_C" >&6
9239 else
9240   if test -n "$AS_FOR_TARGET"; then
9241   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9242 else
9243 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9244 for as_dir in $PATH
9245 do
9246   IFS=$as_save_IFS
9247   test -z "$as_dir" && as_dir=.
9248   for ac_exec_ext in '' $ac_executable_extensions; do
9249   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9250     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9251     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9252     break 2
9253   fi
9254 done
9255 done
9256
9257 fi
9258 fi
9259 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9260 if test -n "$AS_FOR_TARGET"; then
9261   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9262 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9263 else
9264   echo "$as_me:$LINENO: result: no" >&5
9265 echo "${ECHO_T}no" >&6
9266 fi
9267
9268     fi
9269     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9270       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9271 set dummy ${ncn_progname}; ac_word=$2
9272 echo "$as_me:$LINENO: checking for $ac_word" >&5
9273 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9274 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9275   echo $ECHO_N "(cached) $ECHO_C" >&6
9276 else
9277   if test -n "$AS_FOR_TARGET"; then
9278   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9279 else
9280 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9281 for as_dir in $PATH
9282 do
9283   IFS=$as_save_IFS
9284   test -z "$as_dir" && as_dir=.
9285   for ac_exec_ext in '' $ac_executable_extensions; do
9286   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9287     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9288     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9289     break 2
9290   fi
9291 done
9292 done
9293
9294 fi
9295 fi
9296 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9297 if test -n "$AS_FOR_TARGET"; then
9298   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9299 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9300 else
9301   echo "$as_me:$LINENO: result: no" >&5
9302 echo "${ECHO_T}no" >&6
9303 fi
9304
9305     fi
9306     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9307   done
9308 fi
9309
9310 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9311   set dummy as
9312   if test $build = $target ; then
9313     AS_FOR_TARGET="$2"
9314   else
9315     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9316   fi
9317 else
9318   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9319 fi
9320
9321 else
9322   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9323 fi
9324
9325
9326
9327
9328 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9329   if test -n "$with_build_time_tools"; then
9330     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9331 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9332     if test -x $with_build_time_tools/dlltool; then
9333       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9334       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9335       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9336 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9337     else
9338       echo "$as_me:$LINENO: result: no" >&5
9339 echo "${ECHO_T}no" >&6
9340     fi
9341   elif test $build != $host && test $have_gcc_for_target = yes; then
9342     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9343     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9344     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9345   fi
9346 fi
9347 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9348   # Extract the first word of "dlltool", so it can be a program name with args.
9349 set dummy dlltool; ac_word=$2
9350 echo "$as_me:$LINENO: checking for $ac_word" >&5
9351 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9352 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9353   echo $ECHO_N "(cached) $ECHO_C" >&6
9354 else
9355   case $DLLTOOL_FOR_TARGET in
9356   [\\/]* | ?:[\\/]*)
9357   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9358   ;;
9359   *)
9360   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9361 for as_dir in $gcc_cv_tool_dirs
9362 do
9363   IFS=$as_save_IFS
9364   test -z "$as_dir" && as_dir=.
9365   for ac_exec_ext in '' $ac_executable_extensions; do
9366   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9367     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9368     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9369     break 2
9370   fi
9371 done
9372 done
9373
9374   ;;
9375 esac
9376 fi
9377 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9378
9379 if test -n "$DLLTOOL_FOR_TARGET"; then
9380   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9381 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9382 else
9383   echo "$as_me:$LINENO: result: no" >&5
9384 echo "${ECHO_T}no" >&6
9385 fi
9386
9387 fi
9388 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9389
9390
9391 if test -n "$DLLTOOL_FOR_TARGET"; then
9392   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9393 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9394   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9395 fi
9396
9397 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9398   for ncn_progname in dlltool; do
9399     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9400 set dummy ${ncn_progname}; ac_word=$2
9401 echo "$as_me:$LINENO: checking for $ac_word" >&5
9402 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9403 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9404   echo $ECHO_N "(cached) $ECHO_C" >&6
9405 else
9406   if test -n "$DLLTOOL_FOR_TARGET"; then
9407   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9408 else
9409 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9410 for as_dir in $PATH
9411 do
9412   IFS=$as_save_IFS
9413   test -z "$as_dir" && as_dir=.
9414   for ac_exec_ext in '' $ac_executable_extensions; do
9415   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9416     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9417     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9418     break 2
9419   fi
9420 done
9421 done
9422
9423 fi
9424 fi
9425 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9426 if test -n "$DLLTOOL_FOR_TARGET"; then
9427   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9428 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9429 else
9430   echo "$as_me:$LINENO: result: no" >&5
9431 echo "${ECHO_T}no" >&6
9432 fi
9433
9434   done
9435 fi
9436
9437 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9438   for ncn_progname in dlltool; do
9439     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9440 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9441     if test -x $with_build_time_tools/${ncn_progname}; then
9442       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9443       echo "$as_me:$LINENO: result: yes" >&5
9444 echo "${ECHO_T}yes" >&6
9445       break
9446     else
9447       echo "$as_me:$LINENO: result: no" >&5
9448 echo "${ECHO_T}no" >&6
9449     fi
9450   done
9451 fi
9452
9453 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9454   for ncn_progname in dlltool; do
9455     if test -n "$ncn_target_tool_prefix"; then
9456       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9457 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9458 echo "$as_me:$LINENO: checking for $ac_word" >&5
9459 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9460 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9461   echo $ECHO_N "(cached) $ECHO_C" >&6
9462 else
9463   if test -n "$DLLTOOL_FOR_TARGET"; then
9464   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9465 else
9466 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9467 for as_dir in $PATH
9468 do
9469   IFS=$as_save_IFS
9470   test -z "$as_dir" && as_dir=.
9471   for ac_exec_ext in '' $ac_executable_extensions; do
9472   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9473     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9474     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9475     break 2
9476   fi
9477 done
9478 done
9479
9480 fi
9481 fi
9482 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9483 if test -n "$DLLTOOL_FOR_TARGET"; then
9484   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9485 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9486 else
9487   echo "$as_me:$LINENO: result: no" >&5
9488 echo "${ECHO_T}no" >&6
9489 fi
9490
9491     fi
9492     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9493       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9494 set dummy ${ncn_progname}; ac_word=$2
9495 echo "$as_me:$LINENO: checking for $ac_word" >&5
9496 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9497 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9498   echo $ECHO_N "(cached) $ECHO_C" >&6
9499 else
9500   if test -n "$DLLTOOL_FOR_TARGET"; then
9501   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9502 else
9503 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9504 for as_dir in $PATH
9505 do
9506   IFS=$as_save_IFS
9507   test -z "$as_dir" && as_dir=.
9508   for ac_exec_ext in '' $ac_executable_extensions; do
9509   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9510     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9511     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9512     break 2
9513   fi
9514 done
9515 done
9516
9517 fi
9518 fi
9519 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9520 if test -n "$DLLTOOL_FOR_TARGET"; then
9521   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9522 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9523 else
9524   echo "$as_me:$LINENO: result: no" >&5
9525 echo "${ECHO_T}no" >&6
9526 fi
9527
9528     fi
9529     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9530   done
9531 fi
9532
9533 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9534   set dummy dlltool
9535   if test $build = $target ; then
9536     DLLTOOL_FOR_TARGET="$2"
9537   else
9538     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9539   fi
9540 else
9541   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9542 fi
9543
9544 else
9545   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9546 fi
9547
9548
9549
9550
9551 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9552   if test -n "$with_build_time_tools"; then
9553     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9554 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9555     if test -x $with_build_time_tools/ld; then
9556       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9557       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9558       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9559 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9560     else
9561       echo "$as_me:$LINENO: result: no" >&5
9562 echo "${ECHO_T}no" >&6
9563     fi
9564   elif test $build != $host && test $have_gcc_for_target = yes; then
9565     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9566     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9567     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9568   fi
9569 fi
9570 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9571   # Extract the first word of "ld", so it can be a program name with args.
9572 set dummy ld; ac_word=$2
9573 echo "$as_me:$LINENO: checking for $ac_word" >&5
9574 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9575 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9576   echo $ECHO_N "(cached) $ECHO_C" >&6
9577 else
9578   case $LD_FOR_TARGET in
9579   [\\/]* | ?:[\\/]*)
9580   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9581   ;;
9582   *)
9583   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9584 for as_dir in $gcc_cv_tool_dirs
9585 do
9586   IFS=$as_save_IFS
9587   test -z "$as_dir" && as_dir=.
9588   for ac_exec_ext in '' $ac_executable_extensions; do
9589   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9590     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9591     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9592     break 2
9593   fi
9594 done
9595 done
9596
9597   ;;
9598 esac
9599 fi
9600 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9601
9602 if test -n "$LD_FOR_TARGET"; then
9603   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9604 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9605 else
9606   echo "$as_me:$LINENO: result: no" >&5
9607 echo "${ECHO_T}no" >&6
9608 fi
9609
9610 fi
9611 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9612
9613
9614 if test -n "$LD_FOR_TARGET"; then
9615   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9616 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9617   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9618 fi
9619
9620 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9621   for ncn_progname in ld; do
9622     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9623 set dummy ${ncn_progname}; ac_word=$2
9624 echo "$as_me:$LINENO: checking for $ac_word" >&5
9625 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9626 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9627   echo $ECHO_N "(cached) $ECHO_C" >&6
9628 else
9629   if test -n "$LD_FOR_TARGET"; then
9630   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9631 else
9632 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9633 for as_dir in $PATH
9634 do
9635   IFS=$as_save_IFS
9636   test -z "$as_dir" && as_dir=.
9637   for ac_exec_ext in '' $ac_executable_extensions; do
9638   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9639     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9640     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9641     break 2
9642   fi
9643 done
9644 done
9645
9646 fi
9647 fi
9648 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9649 if test -n "$LD_FOR_TARGET"; then
9650   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9651 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9652 else
9653   echo "$as_me:$LINENO: result: no" >&5
9654 echo "${ECHO_T}no" >&6
9655 fi
9656
9657   done
9658 fi
9659
9660 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9661   for ncn_progname in ld; do
9662     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9663 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9664     if test -x $with_build_time_tools/${ncn_progname}; then
9665       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9666       echo "$as_me:$LINENO: result: yes" >&5
9667 echo "${ECHO_T}yes" >&6
9668       break
9669     else
9670       echo "$as_me:$LINENO: result: no" >&5
9671 echo "${ECHO_T}no" >&6
9672     fi
9673   done
9674 fi
9675
9676 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9677   for ncn_progname in ld; do
9678     if test -n "$ncn_target_tool_prefix"; then
9679       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9680 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9681 echo "$as_me:$LINENO: checking for $ac_word" >&5
9682 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9683 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9684   echo $ECHO_N "(cached) $ECHO_C" >&6
9685 else
9686   if test -n "$LD_FOR_TARGET"; then
9687   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9688 else
9689 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9690 for as_dir in $PATH
9691 do
9692   IFS=$as_save_IFS
9693   test -z "$as_dir" && as_dir=.
9694   for ac_exec_ext in '' $ac_executable_extensions; do
9695   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9696     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9697     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9698     break 2
9699   fi
9700 done
9701 done
9702
9703 fi
9704 fi
9705 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9706 if test -n "$LD_FOR_TARGET"; then
9707   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9708 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9709 else
9710   echo "$as_me:$LINENO: result: no" >&5
9711 echo "${ECHO_T}no" >&6
9712 fi
9713
9714     fi
9715     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9716       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9717 set dummy ${ncn_progname}; ac_word=$2
9718 echo "$as_me:$LINENO: checking for $ac_word" >&5
9719 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9720 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9721   echo $ECHO_N "(cached) $ECHO_C" >&6
9722 else
9723   if test -n "$LD_FOR_TARGET"; then
9724   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9725 else
9726 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9727 for as_dir in $PATH
9728 do
9729   IFS=$as_save_IFS
9730   test -z "$as_dir" && as_dir=.
9731   for ac_exec_ext in '' $ac_executable_extensions; do
9732   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9733     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9734     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9735     break 2
9736   fi
9737 done
9738 done
9739
9740 fi
9741 fi
9742 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9743 if test -n "$LD_FOR_TARGET"; then
9744   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9745 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9746 else
9747   echo "$as_me:$LINENO: result: no" >&5
9748 echo "${ECHO_T}no" >&6
9749 fi
9750
9751     fi
9752     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9753   done
9754 fi
9755
9756 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9757   set dummy ld
9758   if test $build = $target ; then
9759     LD_FOR_TARGET="$2"
9760   else
9761     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9762   fi
9763 else
9764   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9765 fi
9766
9767 else
9768   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9769 fi
9770
9771
9772
9773
9774 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9775   if test -n "$with_build_time_tools"; then
9776     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9777 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9778     if test -x $with_build_time_tools/lipo; then
9779       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9780       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9781       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9782 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9783     else
9784       echo "$as_me:$LINENO: result: no" >&5
9785 echo "${ECHO_T}no" >&6
9786     fi
9787   elif test $build != $host && test $have_gcc_for_target = yes; then
9788     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9789     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9790     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9791   fi
9792 fi
9793 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9794   # Extract the first word of "lipo", so it can be a program name with args.
9795 set dummy lipo; ac_word=$2
9796 echo "$as_me:$LINENO: checking for $ac_word" >&5
9797 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9798 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9799   echo $ECHO_N "(cached) $ECHO_C" >&6
9800 else
9801   case $LIPO_FOR_TARGET in
9802   [\\/]* | ?:[\\/]*)
9803   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9804   ;;
9805   *)
9806   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9807 for as_dir in $gcc_cv_tool_dirs
9808 do
9809   IFS=$as_save_IFS
9810   test -z "$as_dir" && as_dir=.
9811   for ac_exec_ext in '' $ac_executable_extensions; do
9812   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9813     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9814     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9815     break 2
9816   fi
9817 done
9818 done
9819
9820   ;;
9821 esac
9822 fi
9823 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9824
9825 if test -n "$LIPO_FOR_TARGET"; then
9826   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9827 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9828 else
9829   echo "$as_me:$LINENO: result: no" >&5
9830 echo "${ECHO_T}no" >&6
9831 fi
9832
9833 fi
9834 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9835
9836
9837 if test -n "$LIPO_FOR_TARGET"; then
9838   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9839 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9840   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9841 fi
9842
9843 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9844   for ncn_progname in lipo; do
9845     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9846 set dummy ${ncn_progname}; ac_word=$2
9847 echo "$as_me:$LINENO: checking for $ac_word" >&5
9848 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9849 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9850   echo $ECHO_N "(cached) $ECHO_C" >&6
9851 else
9852   if test -n "$LIPO_FOR_TARGET"; then
9853   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9854 else
9855 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9856 for as_dir in $PATH
9857 do
9858   IFS=$as_save_IFS
9859   test -z "$as_dir" && as_dir=.
9860   for ac_exec_ext in '' $ac_executable_extensions; do
9861   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9862     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9863     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9864     break 2
9865   fi
9866 done
9867 done
9868
9869 fi
9870 fi
9871 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9872 if test -n "$LIPO_FOR_TARGET"; then
9873   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9874 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9875 else
9876   echo "$as_me:$LINENO: result: no" >&5
9877 echo "${ECHO_T}no" >&6
9878 fi
9879
9880   done
9881 fi
9882
9883 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9884   for ncn_progname in lipo; do
9885     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9886 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9887     if test -x $with_build_time_tools/${ncn_progname}; then
9888       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9889       echo "$as_me:$LINENO: result: yes" >&5
9890 echo "${ECHO_T}yes" >&6
9891       break
9892     else
9893       echo "$as_me:$LINENO: result: no" >&5
9894 echo "${ECHO_T}no" >&6
9895     fi
9896   done
9897 fi
9898
9899 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9900   for ncn_progname in lipo; do
9901     if test -n "$ncn_target_tool_prefix"; then
9902       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9903 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9904 echo "$as_me:$LINENO: checking for $ac_word" >&5
9905 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9906 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9907   echo $ECHO_N "(cached) $ECHO_C" >&6
9908 else
9909   if test -n "$LIPO_FOR_TARGET"; then
9910   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9911 else
9912 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9913 for as_dir in $PATH
9914 do
9915   IFS=$as_save_IFS
9916   test -z "$as_dir" && as_dir=.
9917   for ac_exec_ext in '' $ac_executable_extensions; do
9918   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9919     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9920     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9921     break 2
9922   fi
9923 done
9924 done
9925
9926 fi
9927 fi
9928 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9929 if test -n "$LIPO_FOR_TARGET"; then
9930   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9931 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9932 else
9933   echo "$as_me:$LINENO: result: no" >&5
9934 echo "${ECHO_T}no" >&6
9935 fi
9936
9937     fi
9938     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9939       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9940 set dummy ${ncn_progname}; ac_word=$2
9941 echo "$as_me:$LINENO: checking for $ac_word" >&5
9942 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9943 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9944   echo $ECHO_N "(cached) $ECHO_C" >&6
9945 else
9946   if test -n "$LIPO_FOR_TARGET"; then
9947   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9948 else
9949 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9950 for as_dir in $PATH
9951 do
9952   IFS=$as_save_IFS
9953   test -z "$as_dir" && as_dir=.
9954   for ac_exec_ext in '' $ac_executable_extensions; do
9955   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9956     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9957     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9958     break 2
9959   fi
9960 done
9961 done
9962
9963 fi
9964 fi
9965 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9966 if test -n "$LIPO_FOR_TARGET"; then
9967   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9968 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9969 else
9970   echo "$as_me:$LINENO: result: no" >&5
9971 echo "${ECHO_T}no" >&6
9972 fi
9973
9974     fi
9975     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9976   done
9977 fi
9978
9979 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9980   set dummy lipo
9981   if test $build = $target ; then
9982     LIPO_FOR_TARGET="$2"
9983   else
9984     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9985   fi
9986 else
9987   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9988 fi
9989
9990 else
9991   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9992 fi
9993
9994
9995
9996
9997 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9998   if test -n "$with_build_time_tools"; then
9999     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10000 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10001     if test -x $with_build_time_tools/nm; then
10002       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10003       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10004       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10005 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10006     else
10007       echo "$as_me:$LINENO: result: no" >&5
10008 echo "${ECHO_T}no" >&6
10009     fi
10010   elif test $build != $host && test $have_gcc_for_target = yes; then
10011     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10012     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10013     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10014   fi
10015 fi
10016 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10017   # Extract the first word of "nm", so it can be a program name with args.
10018 set dummy nm; ac_word=$2
10019 echo "$as_me:$LINENO: checking for $ac_word" >&5
10020 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10021 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10022   echo $ECHO_N "(cached) $ECHO_C" >&6
10023 else
10024   case $NM_FOR_TARGET in
10025   [\\/]* | ?:[\\/]*)
10026   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10027   ;;
10028   *)
10029   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10030 for as_dir in $gcc_cv_tool_dirs
10031 do
10032   IFS=$as_save_IFS
10033   test -z "$as_dir" && as_dir=.
10034   for ac_exec_ext in '' $ac_executable_extensions; do
10035   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10036     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10037     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10038     break 2
10039   fi
10040 done
10041 done
10042
10043   ;;
10044 esac
10045 fi
10046 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10047
10048 if test -n "$NM_FOR_TARGET"; then
10049   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10050 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10051 else
10052   echo "$as_me:$LINENO: result: no" >&5
10053 echo "${ECHO_T}no" >&6
10054 fi
10055
10056 fi
10057 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10058
10059
10060 if test -n "$NM_FOR_TARGET"; then
10061   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10062 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10063   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10064 fi
10065
10066 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10067   for ncn_progname in nm; do
10068     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10069 set dummy ${ncn_progname}; ac_word=$2
10070 echo "$as_me:$LINENO: checking for $ac_word" >&5
10071 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10072 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10073   echo $ECHO_N "(cached) $ECHO_C" >&6
10074 else
10075   if test -n "$NM_FOR_TARGET"; then
10076   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10077 else
10078 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10079 for as_dir in $PATH
10080 do
10081   IFS=$as_save_IFS
10082   test -z "$as_dir" && as_dir=.
10083   for ac_exec_ext in '' $ac_executable_extensions; do
10084   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10085     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10086     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10087     break 2
10088   fi
10089 done
10090 done
10091
10092 fi
10093 fi
10094 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10095 if test -n "$NM_FOR_TARGET"; then
10096   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10097 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10098 else
10099   echo "$as_me:$LINENO: result: no" >&5
10100 echo "${ECHO_T}no" >&6
10101 fi
10102
10103   done
10104 fi
10105
10106 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10107   for ncn_progname in nm; do
10108     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10109 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10110     if test -x $with_build_time_tools/${ncn_progname}; then
10111       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10112       echo "$as_me:$LINENO: result: yes" >&5
10113 echo "${ECHO_T}yes" >&6
10114       break
10115     else
10116       echo "$as_me:$LINENO: result: no" >&5
10117 echo "${ECHO_T}no" >&6
10118     fi
10119   done
10120 fi
10121
10122 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10123   for ncn_progname in nm; do
10124     if test -n "$ncn_target_tool_prefix"; then
10125       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10126 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10127 echo "$as_me:$LINENO: checking for $ac_word" >&5
10128 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10129 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10130   echo $ECHO_N "(cached) $ECHO_C" >&6
10131 else
10132   if test -n "$NM_FOR_TARGET"; then
10133   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10134 else
10135 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10136 for as_dir in $PATH
10137 do
10138   IFS=$as_save_IFS
10139   test -z "$as_dir" && as_dir=.
10140   for ac_exec_ext in '' $ac_executable_extensions; do
10141   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10142     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10143     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10144     break 2
10145   fi
10146 done
10147 done
10148
10149 fi
10150 fi
10151 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10152 if test -n "$NM_FOR_TARGET"; then
10153   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10154 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10155 else
10156   echo "$as_me:$LINENO: result: no" >&5
10157 echo "${ECHO_T}no" >&6
10158 fi
10159
10160     fi
10161     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10162       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10163 set dummy ${ncn_progname}; ac_word=$2
10164 echo "$as_me:$LINENO: checking for $ac_word" >&5
10165 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10166 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10167   echo $ECHO_N "(cached) $ECHO_C" >&6
10168 else
10169   if test -n "$NM_FOR_TARGET"; then
10170   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10171 else
10172 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10173 for as_dir in $PATH
10174 do
10175   IFS=$as_save_IFS
10176   test -z "$as_dir" && as_dir=.
10177   for ac_exec_ext in '' $ac_executable_extensions; do
10178   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10179     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10180     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10181     break 2
10182   fi
10183 done
10184 done
10185
10186 fi
10187 fi
10188 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10189 if test -n "$NM_FOR_TARGET"; then
10190   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10191 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10192 else
10193   echo "$as_me:$LINENO: result: no" >&5
10194 echo "${ECHO_T}no" >&6
10195 fi
10196
10197     fi
10198     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10199   done
10200 fi
10201
10202 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10203   set dummy nm
10204   if test $build = $target ; then
10205     NM_FOR_TARGET="$2"
10206   else
10207     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10208   fi
10209 else
10210   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10211 fi
10212
10213 else
10214   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10215 fi
10216
10217
10218
10219
10220 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10221   if test -n "$with_build_time_tools"; then
10222     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10223 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10224     if test -x $with_build_time_tools/objdump; then
10225       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10226       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10227       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10228 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10229     else
10230       echo "$as_me:$LINENO: result: no" >&5
10231 echo "${ECHO_T}no" >&6
10232     fi
10233   elif test $build != $host && test $have_gcc_for_target = yes; then
10234     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10235     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10236     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10237   fi
10238 fi
10239 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10240   # Extract the first word of "objdump", so it can be a program name with args.
10241 set dummy objdump; ac_word=$2
10242 echo "$as_me:$LINENO: checking for $ac_word" >&5
10243 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10244 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10245   echo $ECHO_N "(cached) $ECHO_C" >&6
10246 else
10247   case $OBJDUMP_FOR_TARGET in
10248   [\\/]* | ?:[\\/]*)
10249   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10250   ;;
10251   *)
10252   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10253 for as_dir in $gcc_cv_tool_dirs
10254 do
10255   IFS=$as_save_IFS
10256   test -z "$as_dir" && as_dir=.
10257   for ac_exec_ext in '' $ac_executable_extensions; do
10258   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10259     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10260     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10261     break 2
10262   fi
10263 done
10264 done
10265
10266   ;;
10267 esac
10268 fi
10269 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10270
10271 if test -n "$OBJDUMP_FOR_TARGET"; then
10272   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10273 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10274 else
10275   echo "$as_me:$LINENO: result: no" >&5
10276 echo "${ECHO_T}no" >&6
10277 fi
10278
10279 fi
10280 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10281
10282
10283 if test -n "$OBJDUMP_FOR_TARGET"; then
10284   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10285 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10286   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10287 fi
10288
10289 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10290   for ncn_progname in objdump; do
10291     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10292 set dummy ${ncn_progname}; ac_word=$2
10293 echo "$as_me:$LINENO: checking for $ac_word" >&5
10294 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10295 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10296   echo $ECHO_N "(cached) $ECHO_C" >&6
10297 else
10298   if test -n "$OBJDUMP_FOR_TARGET"; then
10299   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10300 else
10301 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10302 for as_dir in $PATH
10303 do
10304   IFS=$as_save_IFS
10305   test -z "$as_dir" && as_dir=.
10306   for ac_exec_ext in '' $ac_executable_extensions; do
10307   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10308     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10309     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10310     break 2
10311   fi
10312 done
10313 done
10314
10315 fi
10316 fi
10317 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10318 if test -n "$OBJDUMP_FOR_TARGET"; then
10319   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10320 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10321 else
10322   echo "$as_me:$LINENO: result: no" >&5
10323 echo "${ECHO_T}no" >&6
10324 fi
10325
10326   done
10327 fi
10328
10329 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10330   for ncn_progname in objdump; do
10331     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10332 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10333     if test -x $with_build_time_tools/${ncn_progname}; then
10334       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10335       echo "$as_me:$LINENO: result: yes" >&5
10336 echo "${ECHO_T}yes" >&6
10337       break
10338     else
10339       echo "$as_me:$LINENO: result: no" >&5
10340 echo "${ECHO_T}no" >&6
10341     fi
10342   done
10343 fi
10344
10345 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10346   for ncn_progname in objdump; do
10347     if test -n "$ncn_target_tool_prefix"; then
10348       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10349 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10350 echo "$as_me:$LINENO: checking for $ac_word" >&5
10351 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10352 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10353   echo $ECHO_N "(cached) $ECHO_C" >&6
10354 else
10355   if test -n "$OBJDUMP_FOR_TARGET"; then
10356   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10357 else
10358 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10359 for as_dir in $PATH
10360 do
10361   IFS=$as_save_IFS
10362   test -z "$as_dir" && as_dir=.
10363   for ac_exec_ext in '' $ac_executable_extensions; do
10364   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10365     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10366     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10367     break 2
10368   fi
10369 done
10370 done
10371
10372 fi
10373 fi
10374 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10375 if test -n "$OBJDUMP_FOR_TARGET"; then
10376   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10377 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10378 else
10379   echo "$as_me:$LINENO: result: no" >&5
10380 echo "${ECHO_T}no" >&6
10381 fi
10382
10383     fi
10384     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10385       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10386 set dummy ${ncn_progname}; ac_word=$2
10387 echo "$as_me:$LINENO: checking for $ac_word" >&5
10388 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10389 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10390   echo $ECHO_N "(cached) $ECHO_C" >&6
10391 else
10392   if test -n "$OBJDUMP_FOR_TARGET"; then
10393   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10394 else
10395 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10396 for as_dir in $PATH
10397 do
10398   IFS=$as_save_IFS
10399   test -z "$as_dir" && as_dir=.
10400   for ac_exec_ext in '' $ac_executable_extensions; do
10401   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10402     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10403     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10404     break 2
10405   fi
10406 done
10407 done
10408
10409 fi
10410 fi
10411 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10412 if test -n "$OBJDUMP_FOR_TARGET"; then
10413   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10414 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10415 else
10416   echo "$as_me:$LINENO: result: no" >&5
10417 echo "${ECHO_T}no" >&6
10418 fi
10419
10420     fi
10421     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10422   done
10423 fi
10424
10425 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10426   set dummy objdump
10427   if test $build = $target ; then
10428     OBJDUMP_FOR_TARGET="$2"
10429   else
10430     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10431   fi
10432 else
10433   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10434 fi
10435
10436 else
10437   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10438 fi
10439
10440
10441
10442
10443 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10444   if test -n "$with_build_time_tools"; then
10445     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10446 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10447     if test -x $with_build_time_tools/ranlib; then
10448       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10449       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10450       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10451 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10452     else
10453       echo "$as_me:$LINENO: result: no" >&5
10454 echo "${ECHO_T}no" >&6
10455     fi
10456   elif test $build != $host && test $have_gcc_for_target = yes; then
10457     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10458     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10459     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10460   fi
10461 fi
10462 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10463   # Extract the first word of "ranlib", so it can be a program name with args.
10464 set dummy ranlib; ac_word=$2
10465 echo "$as_me:$LINENO: checking for $ac_word" >&5
10466 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10467 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10468   echo $ECHO_N "(cached) $ECHO_C" >&6
10469 else
10470   case $RANLIB_FOR_TARGET in
10471   [\\/]* | ?:[\\/]*)
10472   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10473   ;;
10474   *)
10475   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10476 for as_dir in $gcc_cv_tool_dirs
10477 do
10478   IFS=$as_save_IFS
10479   test -z "$as_dir" && as_dir=.
10480   for ac_exec_ext in '' $ac_executable_extensions; do
10481   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10482     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10483     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10484     break 2
10485   fi
10486 done
10487 done
10488
10489   ;;
10490 esac
10491 fi
10492 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10493
10494 if test -n "$RANLIB_FOR_TARGET"; then
10495   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10496 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10497 else
10498   echo "$as_me:$LINENO: result: no" >&5
10499 echo "${ECHO_T}no" >&6
10500 fi
10501
10502 fi
10503 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10504
10505
10506 if test -n "$RANLIB_FOR_TARGET"; then
10507   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10508 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10509   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10510 fi
10511
10512 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10513   for ncn_progname in ranlib; do
10514     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10515 set dummy ${ncn_progname}; ac_word=$2
10516 echo "$as_me:$LINENO: checking for $ac_word" >&5
10517 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10518 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10519   echo $ECHO_N "(cached) $ECHO_C" >&6
10520 else
10521   if test -n "$RANLIB_FOR_TARGET"; then
10522   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10523 else
10524 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10525 for as_dir in $PATH
10526 do
10527   IFS=$as_save_IFS
10528   test -z "$as_dir" && as_dir=.
10529   for ac_exec_ext in '' $ac_executable_extensions; do
10530   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10531     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10532     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10533     break 2
10534   fi
10535 done
10536 done
10537
10538 fi
10539 fi
10540 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10541 if test -n "$RANLIB_FOR_TARGET"; then
10542   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10543 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10544 else
10545   echo "$as_me:$LINENO: result: no" >&5
10546 echo "${ECHO_T}no" >&6
10547 fi
10548
10549   done
10550 fi
10551
10552 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10553   for ncn_progname in ranlib; do
10554     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10555 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10556     if test -x $with_build_time_tools/${ncn_progname}; then
10557       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10558       echo "$as_me:$LINENO: result: yes" >&5
10559 echo "${ECHO_T}yes" >&6
10560       break
10561     else
10562       echo "$as_me:$LINENO: result: no" >&5
10563 echo "${ECHO_T}no" >&6
10564     fi
10565   done
10566 fi
10567
10568 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10569   for ncn_progname in ranlib; do
10570     if test -n "$ncn_target_tool_prefix"; then
10571       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10572 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10573 echo "$as_me:$LINENO: checking for $ac_word" >&5
10574 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10575 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10576   echo $ECHO_N "(cached) $ECHO_C" >&6
10577 else
10578   if test -n "$RANLIB_FOR_TARGET"; then
10579   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10580 else
10581 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10582 for as_dir in $PATH
10583 do
10584   IFS=$as_save_IFS
10585   test -z "$as_dir" && as_dir=.
10586   for ac_exec_ext in '' $ac_executable_extensions; do
10587   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10588     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10589     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10590     break 2
10591   fi
10592 done
10593 done
10594
10595 fi
10596 fi
10597 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10598 if test -n "$RANLIB_FOR_TARGET"; then
10599   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10600 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10601 else
10602   echo "$as_me:$LINENO: result: no" >&5
10603 echo "${ECHO_T}no" >&6
10604 fi
10605
10606     fi
10607     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10608       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10609 set dummy ${ncn_progname}; ac_word=$2
10610 echo "$as_me:$LINENO: checking for $ac_word" >&5
10611 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10612 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10613   echo $ECHO_N "(cached) $ECHO_C" >&6
10614 else
10615   if test -n "$RANLIB_FOR_TARGET"; then
10616   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10617 else
10618 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10619 for as_dir in $PATH
10620 do
10621   IFS=$as_save_IFS
10622   test -z "$as_dir" && as_dir=.
10623   for ac_exec_ext in '' $ac_executable_extensions; do
10624   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10625     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10626     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10627     break 2
10628   fi
10629 done
10630 done
10631
10632 fi
10633 fi
10634 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10635 if test -n "$RANLIB_FOR_TARGET"; then
10636   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10637 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10638 else
10639   echo "$as_me:$LINENO: result: no" >&5
10640 echo "${ECHO_T}no" >&6
10641 fi
10642
10643     fi
10644     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10645   done
10646 fi
10647
10648 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10649   set dummy ranlib
10650   if test $build = $target ; then
10651     RANLIB_FOR_TARGET="$2"
10652   else
10653     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10654   fi
10655 else
10656   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10657 fi
10658
10659 else
10660   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10661 fi
10662
10663
10664
10665
10666 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10667   if test -n "$with_build_time_tools"; then
10668     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10669 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10670     if test -x $with_build_time_tools/strip; then
10671       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10672       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10673       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10674 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10675     else
10676       echo "$as_me:$LINENO: result: no" >&5
10677 echo "${ECHO_T}no" >&6
10678     fi
10679   elif test $build != $host && test $have_gcc_for_target = yes; then
10680     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10681     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10682     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10683   fi
10684 fi
10685 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10686   # Extract the first word of "strip", so it can be a program name with args.
10687 set dummy strip; ac_word=$2
10688 echo "$as_me:$LINENO: checking for $ac_word" >&5
10689 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10690 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10691   echo $ECHO_N "(cached) $ECHO_C" >&6
10692 else
10693   case $STRIP_FOR_TARGET in
10694   [\\/]* | ?:[\\/]*)
10695   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10696   ;;
10697   *)
10698   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10699 for as_dir in $gcc_cv_tool_dirs
10700 do
10701   IFS=$as_save_IFS
10702   test -z "$as_dir" && as_dir=.
10703   for ac_exec_ext in '' $ac_executable_extensions; do
10704   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10705     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10706     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10707     break 2
10708   fi
10709 done
10710 done
10711
10712   ;;
10713 esac
10714 fi
10715 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10716
10717 if test -n "$STRIP_FOR_TARGET"; then
10718   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10719 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10720 else
10721   echo "$as_me:$LINENO: result: no" >&5
10722 echo "${ECHO_T}no" >&6
10723 fi
10724
10725 fi
10726 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10727
10728
10729 if test -n "$STRIP_FOR_TARGET"; then
10730   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10731 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10732   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10733 fi
10734
10735 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10736   for ncn_progname in strip; do
10737     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10738 set dummy ${ncn_progname}; ac_word=$2
10739 echo "$as_me:$LINENO: checking for $ac_word" >&5
10740 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10741 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10742   echo $ECHO_N "(cached) $ECHO_C" >&6
10743 else
10744   if test -n "$STRIP_FOR_TARGET"; then
10745   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10746 else
10747 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10748 for as_dir in $PATH
10749 do
10750   IFS=$as_save_IFS
10751   test -z "$as_dir" && as_dir=.
10752   for ac_exec_ext in '' $ac_executable_extensions; do
10753   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10754     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10755     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10756     break 2
10757   fi
10758 done
10759 done
10760
10761 fi
10762 fi
10763 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10764 if test -n "$STRIP_FOR_TARGET"; then
10765   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10766 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10767 else
10768   echo "$as_me:$LINENO: result: no" >&5
10769 echo "${ECHO_T}no" >&6
10770 fi
10771
10772   done
10773 fi
10774
10775 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10776   for ncn_progname in strip; do
10777     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10778 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10779     if test -x $with_build_time_tools/${ncn_progname}; then
10780       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10781       echo "$as_me:$LINENO: result: yes" >&5
10782 echo "${ECHO_T}yes" >&6
10783       break
10784     else
10785       echo "$as_me:$LINENO: result: no" >&5
10786 echo "${ECHO_T}no" >&6
10787     fi
10788   done
10789 fi
10790
10791 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10792   for ncn_progname in strip; do
10793     if test -n "$ncn_target_tool_prefix"; then
10794       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10795 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10796 echo "$as_me:$LINENO: checking for $ac_word" >&5
10797 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10798 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10799   echo $ECHO_N "(cached) $ECHO_C" >&6
10800 else
10801   if test -n "$STRIP_FOR_TARGET"; then
10802   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10803 else
10804 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10805 for as_dir in $PATH
10806 do
10807   IFS=$as_save_IFS
10808   test -z "$as_dir" && as_dir=.
10809   for ac_exec_ext in '' $ac_executable_extensions; do
10810   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10811     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10812     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10813     break 2
10814   fi
10815 done
10816 done
10817
10818 fi
10819 fi
10820 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10821 if test -n "$STRIP_FOR_TARGET"; then
10822   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10823 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10824 else
10825   echo "$as_me:$LINENO: result: no" >&5
10826 echo "${ECHO_T}no" >&6
10827 fi
10828
10829     fi
10830     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10831       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10832 set dummy ${ncn_progname}; ac_word=$2
10833 echo "$as_me:$LINENO: checking for $ac_word" >&5
10834 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10835 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10836   echo $ECHO_N "(cached) $ECHO_C" >&6
10837 else
10838   if test -n "$STRIP_FOR_TARGET"; then
10839   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10840 else
10841 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10842 for as_dir in $PATH
10843 do
10844   IFS=$as_save_IFS
10845   test -z "$as_dir" && as_dir=.
10846   for ac_exec_ext in '' $ac_executable_extensions; do
10847   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10848     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10849     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10850     break 2
10851   fi
10852 done
10853 done
10854
10855 fi
10856 fi
10857 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10858 if test -n "$STRIP_FOR_TARGET"; then
10859   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10860 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10861 else
10862   echo "$as_me:$LINENO: result: no" >&5
10863 echo "${ECHO_T}no" >&6
10864 fi
10865
10866     fi
10867     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10868   done
10869 fi
10870
10871 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10872   set dummy strip
10873   if test $build = $target ; then
10874     STRIP_FOR_TARGET="$2"
10875   else
10876     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10877   fi
10878 else
10879   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10880 fi
10881
10882 else
10883   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10884 fi
10885
10886
10887
10888
10889 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10890   if test -n "$with_build_time_tools"; then
10891     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10892 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10893     if test -x $with_build_time_tools/windres; then
10894       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10895       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10896       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10897 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10898     else
10899       echo "$as_me:$LINENO: result: no" >&5
10900 echo "${ECHO_T}no" >&6
10901     fi
10902   elif test $build != $host && test $have_gcc_for_target = yes; then
10903     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10904     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10905     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10906   fi
10907 fi
10908 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10909   # Extract the first word of "windres", so it can be a program name with args.
10910 set dummy windres; ac_word=$2
10911 echo "$as_me:$LINENO: checking for $ac_word" >&5
10912 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10913 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10914   echo $ECHO_N "(cached) $ECHO_C" >&6
10915 else
10916   case $WINDRES_FOR_TARGET in
10917   [\\/]* | ?:[\\/]*)
10918   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10919   ;;
10920   *)
10921   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10922 for as_dir in $gcc_cv_tool_dirs
10923 do
10924   IFS=$as_save_IFS
10925   test -z "$as_dir" && as_dir=.
10926   for ac_exec_ext in '' $ac_executable_extensions; do
10927   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10928     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10929     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10930     break 2
10931   fi
10932 done
10933 done
10934
10935   ;;
10936 esac
10937 fi
10938 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10939
10940 if test -n "$WINDRES_FOR_TARGET"; then
10941   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10942 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10943 else
10944   echo "$as_me:$LINENO: result: no" >&5
10945 echo "${ECHO_T}no" >&6
10946 fi
10947
10948 fi
10949 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10950
10951
10952 if test -n "$WINDRES_FOR_TARGET"; then
10953   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10954 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10955   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10956 fi
10957
10958 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10959   for ncn_progname in windres; do
10960     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10961 set dummy ${ncn_progname}; ac_word=$2
10962 echo "$as_me:$LINENO: checking for $ac_word" >&5
10963 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10964 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10965   echo $ECHO_N "(cached) $ECHO_C" >&6
10966 else
10967   if test -n "$WINDRES_FOR_TARGET"; then
10968   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10969 else
10970 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10971 for as_dir in $PATH
10972 do
10973   IFS=$as_save_IFS
10974   test -z "$as_dir" && as_dir=.
10975   for ac_exec_ext in '' $ac_executable_extensions; do
10976   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10977     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10978     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10979     break 2
10980   fi
10981 done
10982 done
10983
10984 fi
10985 fi
10986 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10987 if test -n "$WINDRES_FOR_TARGET"; then
10988   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10989 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10990 else
10991   echo "$as_me:$LINENO: result: no" >&5
10992 echo "${ECHO_T}no" >&6
10993 fi
10994
10995   done
10996 fi
10997
10998 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10999   for ncn_progname in windres; do
11000     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11001 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11002     if test -x $with_build_time_tools/${ncn_progname}; then
11003       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11004       echo "$as_me:$LINENO: result: yes" >&5
11005 echo "${ECHO_T}yes" >&6
11006       break
11007     else
11008       echo "$as_me:$LINENO: result: no" >&5
11009 echo "${ECHO_T}no" >&6
11010     fi
11011   done
11012 fi
11013
11014 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11015   for ncn_progname in windres; do
11016     if test -n "$ncn_target_tool_prefix"; then
11017       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11018 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11019 echo "$as_me:$LINENO: checking for $ac_word" >&5
11020 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11021 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11022   echo $ECHO_N "(cached) $ECHO_C" >&6
11023 else
11024   if test -n "$WINDRES_FOR_TARGET"; then
11025   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11026 else
11027 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11028 for as_dir in $PATH
11029 do
11030   IFS=$as_save_IFS
11031   test -z "$as_dir" && as_dir=.
11032   for ac_exec_ext in '' $ac_executable_extensions; do
11033   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11034     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11035     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11036     break 2
11037   fi
11038 done
11039 done
11040
11041 fi
11042 fi
11043 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11044 if test -n "$WINDRES_FOR_TARGET"; then
11045   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11046 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11047 else
11048   echo "$as_me:$LINENO: result: no" >&5
11049 echo "${ECHO_T}no" >&6
11050 fi
11051
11052     fi
11053     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11054       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11055 set dummy ${ncn_progname}; ac_word=$2
11056 echo "$as_me:$LINENO: checking for $ac_word" >&5
11057 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11058 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11059   echo $ECHO_N "(cached) $ECHO_C" >&6
11060 else
11061   if test -n "$WINDRES_FOR_TARGET"; then
11062   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11063 else
11064 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11065 for as_dir in $PATH
11066 do
11067   IFS=$as_save_IFS
11068   test -z "$as_dir" && as_dir=.
11069   for ac_exec_ext in '' $ac_executable_extensions; do
11070   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11071     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11072     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11073     break 2
11074   fi
11075 done
11076 done
11077
11078 fi
11079 fi
11080 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11081 if test -n "$WINDRES_FOR_TARGET"; then
11082   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11083 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11084 else
11085   echo "$as_me:$LINENO: result: no" >&5
11086 echo "${ECHO_T}no" >&6
11087 fi
11088
11089     fi
11090     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11091   done
11092 fi
11093
11094 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11095   set dummy windres
11096   if test $build = $target ; then
11097     WINDRES_FOR_TARGET="$2"
11098   else
11099     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11100   fi
11101 else
11102   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11103 fi
11104
11105 else
11106   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11107 fi
11108
11109
11110
11111
11112 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11113   if test -n "$with_build_time_tools"; then
11114     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11115 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11116     if test -x $with_build_time_tools/windmc; then
11117       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11118       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11119       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11120 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11121     else
11122       echo "$as_me:$LINENO: result: no" >&5
11123 echo "${ECHO_T}no" >&6
11124     fi
11125   elif test $build != $host && test $have_gcc_for_target = yes; then
11126     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11127     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11128     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11129   fi
11130 fi
11131 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11132   # Extract the first word of "windmc", so it can be a program name with args.
11133 set dummy windmc; ac_word=$2
11134 echo "$as_me:$LINENO: checking for $ac_word" >&5
11135 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11136 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11137   echo $ECHO_N "(cached) $ECHO_C" >&6
11138 else
11139   case $WINDMC_FOR_TARGET in
11140   [\\/]* | ?:[\\/]*)
11141   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11142   ;;
11143   *)
11144   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11145 for as_dir in $gcc_cv_tool_dirs
11146 do
11147   IFS=$as_save_IFS
11148   test -z "$as_dir" && as_dir=.
11149   for ac_exec_ext in '' $ac_executable_extensions; do
11150   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11151     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11152     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11153     break 2
11154   fi
11155 done
11156 done
11157
11158   ;;
11159 esac
11160 fi
11161 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11162
11163 if test -n "$WINDMC_FOR_TARGET"; then
11164   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11165 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11166 else
11167   echo "$as_me:$LINENO: result: no" >&5
11168 echo "${ECHO_T}no" >&6
11169 fi
11170
11171 fi
11172 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11173
11174
11175 if test -n "$WINDMC_FOR_TARGET"; then
11176   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11177 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11178   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11179 fi
11180
11181 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11182   for ncn_progname in windmc; do
11183     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11184 set dummy ${ncn_progname}; ac_word=$2
11185 echo "$as_me:$LINENO: checking for $ac_word" >&5
11186 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11187 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11188   echo $ECHO_N "(cached) $ECHO_C" >&6
11189 else
11190   if test -n "$WINDMC_FOR_TARGET"; then
11191   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11192 else
11193 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11194 for as_dir in $PATH
11195 do
11196   IFS=$as_save_IFS
11197   test -z "$as_dir" && as_dir=.
11198   for ac_exec_ext in '' $ac_executable_extensions; do
11199   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11200     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11201     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11202     break 2
11203   fi
11204 done
11205 done
11206
11207 fi
11208 fi
11209 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11210 if test -n "$WINDMC_FOR_TARGET"; then
11211   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11212 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11213 else
11214   echo "$as_me:$LINENO: result: no" >&5
11215 echo "${ECHO_T}no" >&6
11216 fi
11217
11218   done
11219 fi
11220
11221 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11222   for ncn_progname in windmc; do
11223     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11224 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11225     if test -x $with_build_time_tools/${ncn_progname}; then
11226       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11227       echo "$as_me:$LINENO: result: yes" >&5
11228 echo "${ECHO_T}yes" >&6
11229       break
11230     else
11231       echo "$as_me:$LINENO: result: no" >&5
11232 echo "${ECHO_T}no" >&6
11233     fi
11234   done
11235 fi
11236
11237 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11238   for ncn_progname in windmc; do
11239     if test -n "$ncn_target_tool_prefix"; then
11240       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11241 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11242 echo "$as_me:$LINENO: checking for $ac_word" >&5
11243 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11244 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11245   echo $ECHO_N "(cached) $ECHO_C" >&6
11246 else
11247   if test -n "$WINDMC_FOR_TARGET"; then
11248   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11249 else
11250 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11251 for as_dir in $PATH
11252 do
11253   IFS=$as_save_IFS
11254   test -z "$as_dir" && as_dir=.
11255   for ac_exec_ext in '' $ac_executable_extensions; do
11256   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11257     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11258     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11259     break 2
11260   fi
11261 done
11262 done
11263
11264 fi
11265 fi
11266 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11267 if test -n "$WINDMC_FOR_TARGET"; then
11268   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11269 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11270 else
11271   echo "$as_me:$LINENO: result: no" >&5
11272 echo "${ECHO_T}no" >&6
11273 fi
11274
11275     fi
11276     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11277       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11278 set dummy ${ncn_progname}; ac_word=$2
11279 echo "$as_me:$LINENO: checking for $ac_word" >&5
11280 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11281 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11282   echo $ECHO_N "(cached) $ECHO_C" >&6
11283 else
11284   if test -n "$WINDMC_FOR_TARGET"; then
11285   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11286 else
11287 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11288 for as_dir in $PATH
11289 do
11290   IFS=$as_save_IFS
11291   test -z "$as_dir" && as_dir=.
11292   for ac_exec_ext in '' $ac_executable_extensions; do
11293   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11294     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11295     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11296     break 2
11297   fi
11298 done
11299 done
11300
11301 fi
11302 fi
11303 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11304 if test -n "$WINDMC_FOR_TARGET"; then
11305   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11306 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11307 else
11308   echo "$as_me:$LINENO: result: no" >&5
11309 echo "${ECHO_T}no" >&6
11310 fi
11311
11312     fi
11313     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11314   done
11315 fi
11316
11317 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11318   set dummy windmc
11319   if test $build = $target ; then
11320     WINDMC_FOR_TARGET="$2"
11321   else
11322     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11323   fi
11324 else
11325   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11326 fi
11327
11328 else
11329   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11330 fi
11331
11332
11333 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11334
11335 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11336 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11337 if test "x${build}" != "x${host}" ; then
11338   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11339     # We already found the complete path
11340     ac_dir=`dirname $AR_FOR_TARGET`
11341     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11342 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11343   else
11344     # Canadian cross, just use what we found
11345     echo "$as_me:$LINENO: result: pre-installed" >&5
11346 echo "${ECHO_T}pre-installed" >&6
11347   fi
11348 else
11349   ok=yes
11350   case " ${configdirs} " in
11351     *" binutils "*) ;;
11352     *) ok=no ;;
11353   esac
11354
11355   if test $ok = yes; then
11356     # An in-tree tool is available and we can use it
11357     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11358     echo "$as_me:$LINENO: result: just compiled" >&5
11359 echo "${ECHO_T}just compiled" >&6
11360   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11361     # We already found the complete path
11362     ac_dir=`dirname $AR_FOR_TARGET`
11363     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11364 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11365   elif test "x$target" = "x$host"; then
11366     # We can use an host tool
11367     AR_FOR_TARGET='$(AR)'
11368     echo "$as_me:$LINENO: result: host tool" >&5
11369 echo "${ECHO_T}host tool" >&6
11370   else
11371     # We need a cross tool
11372     echo "$as_me:$LINENO: result: pre-installed" >&5
11373 echo "${ECHO_T}pre-installed" >&6
11374   fi
11375 fi
11376
11377 echo "$as_me:$LINENO: checking where to find the target as" >&5
11378 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11379 if test "x${build}" != "x${host}" ; then
11380   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11381     # We already found the complete path
11382     ac_dir=`dirname $AS_FOR_TARGET`
11383     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11384 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11385   else
11386     # Canadian cross, just use what we found
11387     echo "$as_me:$LINENO: result: pre-installed" >&5
11388 echo "${ECHO_T}pre-installed" >&6
11389   fi
11390 else
11391   ok=yes
11392   case " ${configdirs} " in
11393     *" gas "*) ;;
11394     *) ok=no ;;
11395   esac
11396
11397   if test $ok = yes; then
11398     # An in-tree tool is available and we can use it
11399     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11400     echo "$as_me:$LINENO: result: just compiled" >&5
11401 echo "${ECHO_T}just compiled" >&6
11402   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11403     # We already found the complete path
11404     ac_dir=`dirname $AS_FOR_TARGET`
11405     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11406 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11407   elif test "x$target" = "x$host"; then
11408     # We can use an host tool
11409     AS_FOR_TARGET='$(AS)'
11410     echo "$as_me:$LINENO: result: host tool" >&5
11411 echo "${ECHO_T}host tool" >&6
11412   else
11413     # We need a cross tool
11414     echo "$as_me:$LINENO: result: pre-installed" >&5
11415 echo "${ECHO_T}pre-installed" >&6
11416   fi
11417 fi
11418
11419 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11420 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11421 if test "x${build}" != "x${host}" ; then
11422   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11423     # We already found the complete path
11424     ac_dir=`dirname $CC_FOR_TARGET`
11425     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11426 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11427   else
11428     # Canadian cross, just use what we found
11429     echo "$as_me:$LINENO: result: pre-installed" >&5
11430 echo "${ECHO_T}pre-installed" >&6
11431   fi
11432 else
11433   ok=yes
11434   case " ${configdirs} " in
11435     *" gcc "*) ;;
11436     *) ok=no ;;
11437   esac
11438
11439   if test $ok = yes; then
11440     # An in-tree tool is available and we can use it
11441     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11442     echo "$as_me:$LINENO: result: just compiled" >&5
11443 echo "${ECHO_T}just compiled" >&6
11444   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11445     # We already found the complete path
11446     ac_dir=`dirname $CC_FOR_TARGET`
11447     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11448 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11449   elif test "x$target" = "x$host"; then
11450     # We can use an host tool
11451     CC_FOR_TARGET='$(CC)'
11452     echo "$as_me:$LINENO: result: host tool" >&5
11453 echo "${ECHO_T}host tool" >&6
11454   else
11455     # We need a cross tool
11456     echo "$as_me:$LINENO: result: pre-installed" >&5
11457 echo "${ECHO_T}pre-installed" >&6
11458   fi
11459 fi
11460
11461 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11462 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11463 if test "x${build}" != "x${host}" ; then
11464   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11465     # We already found the complete path
11466     ac_dir=`dirname $CXX_FOR_TARGET`
11467     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11468 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11469   else
11470     # Canadian cross, just use what we found
11471     echo "$as_me:$LINENO: result: pre-installed" >&5
11472 echo "${ECHO_T}pre-installed" >&6
11473   fi
11474 else
11475   ok=yes
11476   case " ${configdirs} " in
11477     *" gcc "*) ;;
11478     *) ok=no ;;
11479   esac
11480   case ,${enable_languages}, in
11481     *,c++,*) ;;
11482     *) ok=no ;;
11483   esac
11484   if test $ok = yes; then
11485     # An in-tree tool is available and we can use it
11486     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'
11487     echo "$as_me:$LINENO: result: just compiled" >&5
11488 echo "${ECHO_T}just compiled" >&6
11489   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11490     # We already found the complete path
11491     ac_dir=`dirname $CXX_FOR_TARGET`
11492     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11493 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11494   elif test "x$target" = "x$host"; then
11495     # We can use an host tool
11496     CXX_FOR_TARGET='$(CXX)'
11497     echo "$as_me:$LINENO: result: host tool" >&5
11498 echo "${ECHO_T}host tool" >&6
11499   else
11500     # We need a cross tool
11501     echo "$as_me:$LINENO: result: pre-installed" >&5
11502 echo "${ECHO_T}pre-installed" >&6
11503   fi
11504 fi
11505
11506 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11507 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11508 if test "x${build}" != "x${host}" ; then
11509   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11510     # We already found the complete path
11511     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11512     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11513 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11514   else
11515     # Canadian cross, just use what we found
11516     echo "$as_me:$LINENO: result: pre-installed" >&5
11517 echo "${ECHO_T}pre-installed" >&6
11518   fi
11519 else
11520   ok=yes
11521   case " ${configdirs} " in
11522     *" gcc "*) ;;
11523     *) ok=no ;;
11524   esac
11525   case ,${enable_languages}, in
11526     *,c++,*) ;;
11527     *) ok=no ;;
11528   esac
11529   if test $ok = yes; then
11530     # An in-tree tool is available and we can use it
11531     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'
11532     echo "$as_me:$LINENO: result: just compiled" >&5
11533 echo "${ECHO_T}just compiled" >&6
11534   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11535     # We already found the complete path
11536     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11537     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11538 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11539   elif test "x$target" = "x$host"; then
11540     # We can use an host tool
11541     RAW_CXX_FOR_TARGET='$(CXX)'
11542     echo "$as_me:$LINENO: result: host tool" >&5
11543 echo "${ECHO_T}host tool" >&6
11544   else
11545     # We need a cross tool
11546     echo "$as_me:$LINENO: result: pre-installed" >&5
11547 echo "${ECHO_T}pre-installed" >&6
11548   fi
11549 fi
11550
11551 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11552 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11553 if test "x${build}" != "x${host}" ; then
11554   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11555     # We already found the complete path
11556     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11557     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11558 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11559   else
11560     # Canadian cross, just use what we found
11561     echo "$as_me:$LINENO: result: pre-installed" >&5
11562 echo "${ECHO_T}pre-installed" >&6
11563   fi
11564 else
11565   ok=yes
11566   case " ${configdirs} " in
11567     *" binutils "*) ;;
11568     *) ok=no ;;
11569   esac
11570
11571   if test $ok = yes; then
11572     # An in-tree tool is available and we can use it
11573     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11574     echo "$as_me:$LINENO: result: just compiled" >&5
11575 echo "${ECHO_T}just compiled" >&6
11576   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11577     # We already found the complete path
11578     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11579     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11580 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11581   elif test "x$target" = "x$host"; then
11582     # We can use an host tool
11583     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11584     echo "$as_me:$LINENO: result: host tool" >&5
11585 echo "${ECHO_T}host tool" >&6
11586   else
11587     # We need a cross tool
11588     echo "$as_me:$LINENO: result: pre-installed" >&5
11589 echo "${ECHO_T}pre-installed" >&6
11590   fi
11591 fi
11592
11593 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11594 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11595 if test "x${build}" != "x${host}" ; then
11596   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11597     # We already found the complete path
11598     ac_dir=`dirname $GCC_FOR_TARGET`
11599     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11600 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11601   else
11602     # Canadian cross, just use what we found
11603     echo "$as_me:$LINENO: result: pre-installed" >&5
11604 echo "${ECHO_T}pre-installed" >&6
11605   fi
11606 else
11607   ok=yes
11608   case " ${configdirs} " in
11609     *" gcc "*) ;;
11610     *) ok=no ;;
11611   esac
11612
11613   if test $ok = yes; then
11614     # An in-tree tool is available and we can use it
11615     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11616     echo "$as_me:$LINENO: result: just compiled" >&5
11617 echo "${ECHO_T}just compiled" >&6
11618   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11619     # We already found the complete path
11620     ac_dir=`dirname $GCC_FOR_TARGET`
11621     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11622 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11623   elif test "x$target" = "x$host"; then
11624     # We can use an host tool
11625     GCC_FOR_TARGET='$()'
11626     echo "$as_me:$LINENO: result: host tool" >&5
11627 echo "${ECHO_T}host tool" >&6
11628   else
11629     # We need a cross tool
11630     echo "$as_me:$LINENO: result: pre-installed" >&5
11631 echo "${ECHO_T}pre-installed" >&6
11632   fi
11633 fi
11634
11635 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11636 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11637 if test "x${build}" != "x${host}" ; then
11638   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11639     # We already found the complete path
11640     ac_dir=`dirname $GCJ_FOR_TARGET`
11641     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11642 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11643   else
11644     # Canadian cross, just use what we found
11645     echo "$as_me:$LINENO: result: pre-installed" >&5
11646 echo "${ECHO_T}pre-installed" >&6
11647   fi
11648 else
11649   ok=yes
11650   case " ${configdirs} " in
11651     *" gcc "*) ;;
11652     *) ok=no ;;
11653   esac
11654   case ,${enable_languages}, in
11655     *,java,*) ;;
11656     *) ok=no ;;
11657   esac
11658   if test $ok = yes; then
11659     # An in-tree tool is available and we can use it
11660     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11661     echo "$as_me:$LINENO: result: just compiled" >&5
11662 echo "${ECHO_T}just compiled" >&6
11663   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11664     # We already found the complete path
11665     ac_dir=`dirname $GCJ_FOR_TARGET`
11666     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11667 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11668   elif test "x$target" = "x$host"; then
11669     # We can use an host tool
11670     GCJ_FOR_TARGET='$(GCJ)'
11671     echo "$as_me:$LINENO: result: host tool" >&5
11672 echo "${ECHO_T}host tool" >&6
11673   else
11674     # We need a cross tool
11675     echo "$as_me:$LINENO: result: pre-installed" >&5
11676 echo "${ECHO_T}pre-installed" >&6
11677   fi
11678 fi
11679
11680 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11681 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11682 if test "x${build}" != "x${host}" ; then
11683   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11684     # We already found the complete path
11685     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11686     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11687 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11688   else
11689     # Canadian cross, just use what we found
11690     echo "$as_me:$LINENO: result: pre-installed" >&5
11691 echo "${ECHO_T}pre-installed" >&6
11692   fi
11693 else
11694   ok=yes
11695   case " ${configdirs} " in
11696     *" gcc "*) ;;
11697     *) ok=no ;;
11698   esac
11699   case ,${enable_languages}, in
11700     *,fortran,*) ;;
11701     *) ok=no ;;
11702   esac
11703   if test $ok = yes; then
11704     # An in-tree tool is available and we can use it
11705     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11706     echo "$as_me:$LINENO: result: just compiled" >&5
11707 echo "${ECHO_T}just compiled" >&6
11708   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11709     # We already found the complete path
11710     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11711     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11712 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11713   elif test "x$target" = "x$host"; then
11714     # We can use an host tool
11715     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11716     echo "$as_me:$LINENO: result: host tool" >&5
11717 echo "${ECHO_T}host tool" >&6
11718   else
11719     # We need a cross tool
11720     echo "$as_me:$LINENO: result: pre-installed" >&5
11721 echo "${ECHO_T}pre-installed" >&6
11722   fi
11723 fi
11724
11725 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11726 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11727 if test "x${build}" != "x${host}" ; then
11728   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11729     # We already found the complete path
11730     ac_dir=`dirname $LD_FOR_TARGET`
11731     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11732 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11733   else
11734     # Canadian cross, just use what we found
11735     echo "$as_me:$LINENO: result: pre-installed" >&5
11736 echo "${ECHO_T}pre-installed" >&6
11737   fi
11738 else
11739   ok=yes
11740   case " ${configdirs} " in
11741     *" ld "*) ;;
11742     *) ok=no ;;
11743   esac
11744
11745   if test $ok = yes; then
11746     # An in-tree tool is available and we can use it
11747     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11748     echo "$as_me:$LINENO: result: just compiled" >&5
11749 echo "${ECHO_T}just compiled" >&6
11750   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11751     # We already found the complete path
11752     ac_dir=`dirname $LD_FOR_TARGET`
11753     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11754 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11755   elif test "x$target" = "x$host"; then
11756     # We can use an host tool
11757     LD_FOR_TARGET='$(LD)'
11758     echo "$as_me:$LINENO: result: host tool" >&5
11759 echo "${ECHO_T}host tool" >&6
11760   else
11761     # We need a cross tool
11762     echo "$as_me:$LINENO: result: pre-installed" >&5
11763 echo "${ECHO_T}pre-installed" >&6
11764   fi
11765 fi
11766
11767 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11768 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11769 if test "x${build}" != "x${host}" ; then
11770   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11771     # We already found the complete path
11772     ac_dir=`dirname $LIPO_FOR_TARGET`
11773     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11774 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11775   else
11776     # Canadian cross, just use what we found
11777     echo "$as_me:$LINENO: result: pre-installed" >&5
11778 echo "${ECHO_T}pre-installed" >&6
11779   fi
11780 else
11781   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11782     # We already found the complete path
11783     ac_dir=`dirname $LIPO_FOR_TARGET`
11784     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11785 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11786   elif test "x$target" = "x$host"; then
11787     # We can use an host tool
11788     LIPO_FOR_TARGET='$(LIPO)'
11789     echo "$as_me:$LINENO: result: host tool" >&5
11790 echo "${ECHO_T}host tool" >&6
11791   else
11792     # We need a cross tool
11793     echo "$as_me:$LINENO: result: pre-installed" >&5
11794 echo "${ECHO_T}pre-installed" >&6
11795   fi
11796 fi
11797
11798 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11799 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11800 if test "x${build}" != "x${host}" ; then
11801   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11802     # We already found the complete path
11803     ac_dir=`dirname $NM_FOR_TARGET`
11804     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11805 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11806   else
11807     # Canadian cross, just use what we found
11808     echo "$as_me:$LINENO: result: pre-installed" >&5
11809 echo "${ECHO_T}pre-installed" >&6
11810   fi
11811 else
11812   ok=yes
11813   case " ${configdirs} " in
11814     *" binutils "*) ;;
11815     *) ok=no ;;
11816   esac
11817
11818   if test $ok = yes; then
11819     # An in-tree tool is available and we can use it
11820     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11821     echo "$as_me:$LINENO: result: just compiled" >&5
11822 echo "${ECHO_T}just compiled" >&6
11823   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11824     # We already found the complete path
11825     ac_dir=`dirname $NM_FOR_TARGET`
11826     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11827 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11828   elif test "x$target" = "x$host"; then
11829     # We can use an host tool
11830     NM_FOR_TARGET='$(NM)'
11831     echo "$as_me:$LINENO: result: host tool" >&5
11832 echo "${ECHO_T}host tool" >&6
11833   else
11834     # We need a cross tool
11835     echo "$as_me:$LINENO: result: pre-installed" >&5
11836 echo "${ECHO_T}pre-installed" >&6
11837   fi
11838 fi
11839
11840 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11841 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11842 if test "x${build}" != "x${host}" ; then
11843   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11844     # We already found the complete path
11845     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11846     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11847 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11848   else
11849     # Canadian cross, just use what we found
11850     echo "$as_me:$LINENO: result: pre-installed" >&5
11851 echo "${ECHO_T}pre-installed" >&6
11852   fi
11853 else
11854   ok=yes
11855   case " ${configdirs} " in
11856     *" binutils "*) ;;
11857     *) ok=no ;;
11858   esac
11859
11860   if test $ok = yes; then
11861     # An in-tree tool is available and we can use it
11862     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11863     echo "$as_me:$LINENO: result: just compiled" >&5
11864 echo "${ECHO_T}just compiled" >&6
11865   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11866     # We already found the complete path
11867     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11868     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11869 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11870   elif test "x$target" = "x$host"; then
11871     # We can use an host tool
11872     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11873     echo "$as_me:$LINENO: result: host tool" >&5
11874 echo "${ECHO_T}host tool" >&6
11875   else
11876     # We need a cross tool
11877     echo "$as_me:$LINENO: result: pre-installed" >&5
11878 echo "${ECHO_T}pre-installed" >&6
11879   fi
11880 fi
11881
11882 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11883 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11884 if test "x${build}" != "x${host}" ; then
11885   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11886     # We already found the complete path
11887     ac_dir=`dirname $RANLIB_FOR_TARGET`
11888     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11889 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11890   else
11891     # Canadian cross, just use what we found
11892     echo "$as_me:$LINENO: result: pre-installed" >&5
11893 echo "${ECHO_T}pre-installed" >&6
11894   fi
11895 else
11896   ok=yes
11897   case " ${configdirs} " in
11898     *" binutils "*) ;;
11899     *) ok=no ;;
11900   esac
11901
11902   if test $ok = yes; then
11903     # An in-tree tool is available and we can use it
11904     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11905     echo "$as_me:$LINENO: result: just compiled" >&5
11906 echo "${ECHO_T}just compiled" >&6
11907   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11908     # We already found the complete path
11909     ac_dir=`dirname $RANLIB_FOR_TARGET`
11910     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11911 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11912   elif test "x$target" = "x$host"; then
11913     # We can use an host tool
11914     RANLIB_FOR_TARGET='$(RANLIB)'
11915     echo "$as_me:$LINENO: result: host tool" >&5
11916 echo "${ECHO_T}host tool" >&6
11917   else
11918     # We need a cross tool
11919     echo "$as_me:$LINENO: result: pre-installed" >&5
11920 echo "${ECHO_T}pre-installed" >&6
11921   fi
11922 fi
11923
11924 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11925 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11926 if test "x${build}" != "x${host}" ; then
11927   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11928     # We already found the complete path
11929     ac_dir=`dirname $STRIP_FOR_TARGET`
11930     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11931 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11932   else
11933     # Canadian cross, just use what we found
11934     echo "$as_me:$LINENO: result: pre-installed" >&5
11935 echo "${ECHO_T}pre-installed" >&6
11936   fi
11937 else
11938   ok=yes
11939   case " ${configdirs} " in
11940     *" binutils "*) ;;
11941     *) ok=no ;;
11942   esac
11943
11944   if test $ok = yes; then
11945     # An in-tree tool is available and we can use it
11946     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11947     echo "$as_me:$LINENO: result: just compiled" >&5
11948 echo "${ECHO_T}just compiled" >&6
11949   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11950     # We already found the complete path
11951     ac_dir=`dirname $STRIP_FOR_TARGET`
11952     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11953 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11954   elif test "x$target" = "x$host"; then
11955     # We can use an host tool
11956     STRIP_FOR_TARGET='$(STRIP)'
11957     echo "$as_me:$LINENO: result: host tool" >&5
11958 echo "${ECHO_T}host tool" >&6
11959   else
11960     # We need a cross tool
11961     echo "$as_me:$LINENO: result: pre-installed" >&5
11962 echo "${ECHO_T}pre-installed" >&6
11963   fi
11964 fi
11965
11966 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11967 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11968 if test "x${build}" != "x${host}" ; then
11969   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11970     # We already found the complete path
11971     ac_dir=`dirname $WINDRES_FOR_TARGET`
11972     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11973 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11974   else
11975     # Canadian cross, just use what we found
11976     echo "$as_me:$LINENO: result: pre-installed" >&5
11977 echo "${ECHO_T}pre-installed" >&6
11978   fi
11979 else
11980   ok=yes
11981   case " ${configdirs} " in
11982     *" binutils "*) ;;
11983     *) ok=no ;;
11984   esac
11985
11986   if test $ok = yes; then
11987     # An in-tree tool is available and we can use it
11988     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11989     echo "$as_me:$LINENO: result: just compiled" >&5
11990 echo "${ECHO_T}just compiled" >&6
11991   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11992     # We already found the complete path
11993     ac_dir=`dirname $WINDRES_FOR_TARGET`
11994     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11995 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11996   elif test "x$target" = "x$host"; then
11997     # We can use an host tool
11998     WINDRES_FOR_TARGET='$(WINDRES)'
11999     echo "$as_me:$LINENO: result: host tool" >&5
12000 echo "${ECHO_T}host tool" >&6
12001   else
12002     # We need a cross tool
12003     echo "$as_me:$LINENO: result: pre-installed" >&5
12004 echo "${ECHO_T}pre-installed" >&6
12005   fi
12006 fi
12007
12008 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12009 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12010 if test "x${build}" != "x${host}" ; then
12011   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12012     # We already found the complete path
12013     ac_dir=`dirname $WINDMC_FOR_TARGET`
12014     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12015 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12016   else
12017     # Canadian cross, just use what we found
12018     echo "$as_me:$LINENO: result: pre-installed" >&5
12019 echo "${ECHO_T}pre-installed" >&6
12020   fi
12021 else
12022   ok=yes
12023   case " ${configdirs} " in
12024     *" binutils "*) ;;
12025     *) ok=no ;;
12026   esac
12027
12028   if test $ok = yes; then
12029     # An in-tree tool is available and we can use it
12030     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12031     echo "$as_me:$LINENO: result: just compiled" >&5
12032 echo "${ECHO_T}just compiled" >&6
12033   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12034     # We already found the complete path
12035     ac_dir=`dirname $WINDMC_FOR_TARGET`
12036     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12037 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12038   elif test "x$target" = "x$host"; then
12039     # We can use an host tool
12040     WINDMC_FOR_TARGET='$(WINDMC)'
12041     echo "$as_me:$LINENO: result: host tool" >&5
12042 echo "${ECHO_T}host tool" >&6
12043   else
12044     # We need a cross tool
12045     echo "$as_me:$LINENO: result: pre-installed" >&5
12046 echo "${ECHO_T}pre-installed" >&6
12047   fi
12048 fi
12049
12050
12051
12052
12053
12054 # Certain tools may need extra flags.
12055 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12056 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12057 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12058
12059 # When building target libraries, except in a Canadian cross, we use
12060 # the same toolchain as the compiler we just built.
12061 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12062 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12063 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12064 if test $host = $build; then
12065   case " $configdirs " in
12066     *" gcc "*)
12067       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12068       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12069       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12070       ;;
12071   esac
12072 fi
12073
12074
12075
12076
12077
12078 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12079 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12080 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12081 if test "${enable_maintainer_mode+set}" = set; then
12082   enableval="$enable_maintainer_mode"
12083   USE_MAINTAINER_MODE=$enableval
12084 else
12085   USE_MAINTAINER_MODE=no
12086 fi;
12087 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12088 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12089
12090
12091 if test "$USE_MAINTAINER_MODE" = yes; then
12092   MAINTAINER_MODE_TRUE=
12093   MAINTAINER_MODE_FALSE='#'
12094 else
12095   MAINTAINER_MODE_TRUE='#'
12096   MAINTAINER_MODE_FALSE=
12097 fi
12098 MAINT=$MAINTAINER_MODE_TRUE
12099
12100 # ---------------------
12101 # GCC bootstrap support
12102 # ---------------------
12103
12104 # Stage specific cflags for build.
12105 stage1_cflags="-g"
12106 case $build in
12107   vax-*-*)
12108     case ${GCC} in
12109       yes) stage1_cflags="-g -Wa,-J" ;;
12110       *) stage1_cflags="-g -J" ;;
12111     esac ;;
12112 esac
12113
12114 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12115 if test "$GCC" = yes; then
12116   saved_CFLAGS="$CFLAGS"
12117
12118   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12119   CFLAGS="$CFLAGS -fkeep-inline-functions"
12120   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12121 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12122   cat >conftest.$ac_ext <<_ACEOF
12123 /* confdefs.h.  */
12124 _ACEOF
12125 cat confdefs.h >>conftest.$ac_ext
12126 cat >>conftest.$ac_ext <<_ACEOF
12127 /* end confdefs.h.  */
12128
12129 #if (__GNUC__ < 3) \
12130     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12131                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12132 #error http://gcc.gnu.org/PR29382
12133 #endif
12134
12135 int
12136 main ()
12137 {
12138
12139   ;
12140   return 0;
12141 }
12142 _ACEOF
12143 rm -f conftest.$ac_objext
12144 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12145   (eval $ac_compile) 2>conftest.er1
12146   ac_status=$?
12147   grep -v '^ *+' conftest.er1 >conftest.err
12148   rm -f conftest.er1
12149   cat conftest.err >&5
12150   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12151   (exit $ac_status); } &&
12152          { ac_try='test -z "$ac_c_werror_flag"
12153                          || test ! -s conftest.err'
12154   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12155   (eval $ac_try) 2>&5
12156   ac_status=$?
12157   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12158   (exit $ac_status); }; } &&
12159          { ac_try='test -s conftest.$ac_objext'
12160   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12161   (eval $ac_try) 2>&5
12162   ac_status=$?
12163   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12164   (exit $ac_status); }; }; then
12165   echo "$as_me:$LINENO: result: yes" >&5
12166 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12167 else
12168   echo "$as_me: failed program was:" >&5
12169 sed 's/^/| /' conftest.$ac_ext >&5
12170
12171 echo "$as_me:$LINENO: result: no" >&5
12172 echo "${ECHO_T}no" >&6
12173 fi
12174 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12175
12176   CFLAGS="$saved_CFLAGS"
12177 fi
12178
12179
12180
12181 # Enable --enable-checking in stage1 of the compiler.
12182 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12183 if test "${enable_stage1_checking+set}" = set; then
12184   enableval="$enable_stage1_checking"
12185   stage1_checking=--enable-checking=${enable_stage1_checking}
12186 else
12187   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12188   stage1_checking=--enable-checking=yes,types
12189 else
12190   stage1_checking=--enable-checking=$enable_checking,types
12191 fi
12192 fi;
12193
12194
12195 # Enable -Werror in bootstrap stage2 and later.
12196 # Check whether --enable-werror or --disable-werror was given.
12197 if test "${enable_werror+set}" = set; then
12198   enableval="$enable_werror"
12199
12200 else
12201   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12202   enable_werror=yes
12203 else
12204   enable_werror=no
12205 fi
12206 fi;
12207 case ${enable_werror} in
12208   yes) stage2_werror_flag="--enable-werror-always" ;;
12209   *) stage2_werror_flag="" ;;
12210 esac
12211
12212
12213 # Flags needed to enable html installing and building
12214
12215 # Check whether --with-datarootdir or --without-datarootdir was given.
12216 if test "${with_datarootdir+set}" = set; then
12217   withval="$with_datarootdir"
12218   datarootdir="\${prefix}/${withval}"
12219 else
12220   datarootdir="\${prefix}/share"
12221 fi;
12222
12223
12224 # Check whether --with-docdir or --without-docdir was given.
12225 if test "${with_docdir+set}" = set; then
12226   withval="$with_docdir"
12227   docdir="\${prefix}/${withval}"
12228 else
12229   docdir="\${datarootdir}/doc"
12230 fi;
12231
12232
12233 # Check whether --with-pdfdir or --without-pdfdir was given.
12234 if test "${with_pdfdir+set}" = set; then
12235   withval="$with_pdfdir"
12236   pdfdir="\${prefix}/${withval}"
12237 else
12238   pdfdir="\${docdir}"
12239 fi;
12240
12241
12242 # Check whether --with-htmldir or --without-htmldir was given.
12243 if test "${with_htmldir+set}" = set; then
12244   withval="$with_htmldir"
12245   htmldir="\${prefix}/${withval}"
12246 else
12247   htmldir="\${docdir}"
12248 fi;
12249
12250
12251
12252
12253
12254
12255           ac_config_files="$ac_config_files Makefile"
12256 cat >confcache <<\_ACEOF
12257 # This file is a shell script that caches the results of configure
12258 # tests run on this system so they can be shared between configure
12259 # scripts and configure runs, see configure's option --config-cache.
12260 # It is not useful on other systems.  If it contains results you don't
12261 # want to keep, you may remove or edit it.
12262 #
12263 # config.status only pays attention to the cache file if you give it
12264 # the --recheck option to rerun configure.
12265 #
12266 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12267 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12268 # following values.
12269
12270 _ACEOF
12271
12272 # The following way of writing the cache mishandles newlines in values,
12273 # but we know of no workaround that is simple, portable, and efficient.
12274 # So, don't put newlines in cache variables' values.
12275 # Ultrix sh set writes to stderr and can't be redirected directly,
12276 # and sets the high bit in the cache file unless we assign to the vars.
12277 {
12278   (set) 2>&1 |
12279     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12280     *ac_space=\ *)
12281       # `set' does not quote correctly, so add quotes (double-quote
12282       # substitution turns \\\\ into \\, and sed turns \\ into \).
12283       sed -n \
12284         "s/'/'\\\\''/g;
12285           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12286       ;;
12287     *)
12288       # `set' quotes correctly as required by POSIX, so do not add quotes.
12289       sed -n \
12290         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12291       ;;
12292     esac;
12293 } |
12294   sed '
12295      t clear
12296      : clear
12297      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12298      t end
12299      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12300      : end' >>confcache
12301 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12302   if test -w $cache_file; then
12303     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12304     cat confcache >$cache_file
12305   else
12306     echo "not updating unwritable cache $cache_file"
12307   fi
12308 fi
12309 rm -f confcache
12310
12311 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12312 # Let make expand exec_prefix.
12313 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12314
12315 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12316 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12317 # trailing colons and then remove the whole line if VPATH becomes empty
12318 # (actually we leave an empty line to preserve line numbers).
12319 if test "x$srcdir" = x.; then
12320   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12321 s/:*\$(srcdir):*/:/;
12322 s/:*\${srcdir}:*/:/;
12323 s/:*@srcdir@:*/:/;
12324 s/^\([^=]*=[     ]*\):*/\1/;
12325 s/:*$//;
12326 s/^[^=]*=[       ]*$//;
12327 }'
12328 fi
12329
12330 # Transform confdefs.h into DEFS.
12331 # Protect against shell expansion while executing Makefile rules.
12332 # Protect against Makefile macro expansion.
12333 #
12334 # If the first sed substitution is executed (which looks for macros that
12335 # take arguments), then we branch to the quote section.  Otherwise,
12336 # look for a macro that doesn't take arguments.
12337 cat >confdef2opt.sed <<\_ACEOF
12338 t clear
12339 : clear
12340 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12341 t quote
12342 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12343 t quote
12344 d
12345 : quote
12346 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12347 s,\[,\\&,g
12348 s,\],\\&,g
12349 s,\$,$$,g
12350 p
12351 _ACEOF
12352 # We use echo to avoid assuming a particular line-breaking character.
12353 # The extra dot is to prevent the shell from consuming trailing
12354 # line-breaks from the sub-command output.  A line-break within
12355 # single-quotes doesn't work because, if this script is created in a
12356 # platform that uses two characters for line-breaks (e.g., DOS), tr
12357 # would break.
12358 ac_LF_and_DOT=`echo; echo .`
12359 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12360 rm -f confdef2opt.sed
12361
12362
12363 ac_libobjs=
12364 ac_ltlibobjs=
12365 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12366   # 1. Remove the extension, and $U if already installed.
12367   ac_i=`echo "$ac_i" |
12368          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12369   # 2. Add them.
12370   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12371   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12372 done
12373 LIBOBJS=$ac_libobjs
12374
12375 LTLIBOBJS=$ac_ltlibobjs
12376
12377
12378
12379 : ${CONFIG_STATUS=./config.status}
12380 ac_clean_files_save=$ac_clean_files
12381 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12382 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12383 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12384 cat >$CONFIG_STATUS <<_ACEOF
12385 #! $SHELL
12386 # Generated by $as_me.
12387 # Run this file to recreate the current configuration.
12388 # Compiler output produced by configure, useful for debugging
12389 # configure, is in config.log if it exists.
12390
12391 debug=false
12392 ac_cs_recheck=false
12393 ac_cs_silent=false
12394 SHELL=\${CONFIG_SHELL-$SHELL}
12395 _ACEOF
12396
12397 cat >>$CONFIG_STATUS <<\_ACEOF
12398 ## --------------------- ##
12399 ## M4sh Initialization.  ##
12400 ## --------------------- ##
12401
12402 # Be Bourne compatible
12403 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12404   emulate sh
12405   NULLCMD=:
12406   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12407   # is contrary to our usage.  Disable this feature.
12408   alias -g '${1+"$@"}'='"$@"'
12409 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12410   set -o posix
12411 fi
12412 DUALCASE=1; export DUALCASE # for MKS sh
12413
12414 # Support unset when possible.
12415 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12416   as_unset=unset
12417 else
12418   as_unset=false
12419 fi
12420
12421
12422 # Work around bugs in pre-3.0 UWIN ksh.
12423 $as_unset ENV MAIL MAILPATH
12424 PS1='$ '
12425 PS2='> '
12426 PS4='+ '
12427
12428 # NLS nuisances.
12429 for as_var in \
12430   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12431   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12432   LC_TELEPHONE LC_TIME
12433 do
12434   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12435     eval $as_var=C; export $as_var
12436   else
12437     $as_unset $as_var
12438   fi
12439 done
12440
12441 # Required to use basename.
12442 if expr a : '\(a\)' >/dev/null 2>&1; then
12443   as_expr=expr
12444 else
12445   as_expr=false
12446 fi
12447
12448 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12449   as_basename=basename
12450 else
12451   as_basename=false
12452 fi
12453
12454
12455 # Name of the executable.
12456 as_me=`$as_basename "$0" ||
12457 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12458          X"$0" : 'X\(//\)$' \| \
12459          X"$0" : 'X\(/\)$' \| \
12460          .     : '\(.\)' 2>/dev/null ||
12461 echo X/"$0" |
12462     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12463           /^X\/\(\/\/\)$/{ s//\1/; q; }
12464           /^X\/\(\/\).*/{ s//\1/; q; }
12465           s/.*/./; q'`
12466
12467
12468 # PATH needs CR, and LINENO needs CR and PATH.
12469 # Avoid depending upon Character Ranges.
12470 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12471 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12472 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12473 as_cr_digits='0123456789'
12474 as_cr_alnum=$as_cr_Letters$as_cr_digits
12475
12476 # The user is always right.
12477 if test "${PATH_SEPARATOR+set}" != set; then
12478   echo "#! /bin/sh" >conf$$.sh
12479   echo  "exit 0"   >>conf$$.sh
12480   chmod +x conf$$.sh
12481   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12482     PATH_SEPARATOR=';'
12483   else
12484     PATH_SEPARATOR=:
12485   fi
12486   rm -f conf$$.sh
12487 fi
12488
12489
12490   as_lineno_1=$LINENO
12491   as_lineno_2=$LINENO
12492   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12493   test "x$as_lineno_1" != "x$as_lineno_2" &&
12494   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12495   # Find who we are.  Look in the path if we contain no path at all
12496   # relative or not.
12497   case $0 in
12498     *[\\/]* ) as_myself=$0 ;;
12499     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12500 for as_dir in $PATH
12501 do
12502   IFS=$as_save_IFS
12503   test -z "$as_dir" && as_dir=.
12504   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12505 done
12506
12507        ;;
12508   esac
12509   # We did not find ourselves, most probably we were run as `sh COMMAND'
12510   # in which case we are not to be found in the path.
12511   if test "x$as_myself" = x; then
12512     as_myself=$0
12513   fi
12514   if test ! -f "$as_myself"; then
12515     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12516 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12517    { (exit 1); exit 1; }; }
12518   fi
12519   case $CONFIG_SHELL in
12520   '')
12521     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12522 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12523 do
12524   IFS=$as_save_IFS
12525   test -z "$as_dir" && as_dir=.
12526   for as_base in sh bash ksh sh5; do
12527          case $as_dir in
12528          /*)
12529            if ("$as_dir/$as_base" -c '
12530   as_lineno_1=$LINENO
12531   as_lineno_2=$LINENO
12532   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12533   test "x$as_lineno_1" != "x$as_lineno_2" &&
12534   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12535              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12536              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12537              CONFIG_SHELL=$as_dir/$as_base
12538              export CONFIG_SHELL
12539              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12540            fi;;
12541          esac
12542        done
12543 done
12544 ;;
12545   esac
12546
12547   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12548   # uniformly replaced by the line number.  The first 'sed' inserts a
12549   # line-number line before each line; the second 'sed' does the real
12550   # work.  The second script uses 'N' to pair each line-number line
12551   # with the numbered line, and appends trailing '-' during
12552   # substitution so that $LINENO is not a special case at line end.
12553   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12554   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12555   sed '=' <$as_myself |
12556     sed '
12557       N
12558       s,$,-,
12559       : loop
12560       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12561       t loop
12562       s,-$,,
12563       s,^['$as_cr_digits']*\n,,
12564     ' >$as_me.lineno &&
12565   chmod +x $as_me.lineno ||
12566     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12567 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12568    { (exit 1); exit 1; }; }
12569
12570   # Don't try to exec as it changes $[0], causing all sort of problems
12571   # (the dirname of $[0] is not the place where we might find the
12572   # original and so on.  Autoconf is especially sensible to this).
12573   . ./$as_me.lineno
12574   # Exit status is that of the last command.
12575   exit
12576 }
12577
12578
12579 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12580   *c*,-n*) ECHO_N= ECHO_C='
12581 ' ECHO_T='      ' ;;
12582   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12583   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12584 esac
12585
12586 if expr a : '\(a\)' >/dev/null 2>&1; then
12587   as_expr=expr
12588 else
12589   as_expr=false
12590 fi
12591
12592 rm -f conf$$ conf$$.exe conf$$.file
12593 echo >conf$$.file
12594 if ln -s conf$$.file conf$$ 2>/dev/null; then
12595   # We could just check for DJGPP; but this test a) works b) is more generic
12596   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12597   if test -f conf$$.exe; then
12598     # Don't use ln at all; we don't have any links
12599     as_ln_s='cp -p'
12600   else
12601     as_ln_s='ln -s'
12602   fi
12603 elif ln conf$$.file conf$$ 2>/dev/null; then
12604   as_ln_s=ln
12605 else
12606   as_ln_s='cp -p'
12607 fi
12608 rm -f conf$$ conf$$.exe conf$$.file
12609
12610 if mkdir -p . 2>/dev/null; then
12611   as_mkdir_p=:
12612 else
12613   test -d ./-p && rmdir ./-p
12614   as_mkdir_p=false
12615 fi
12616
12617 as_executable_p="test -f"
12618
12619 # Sed expression to map a string onto a valid CPP name.
12620 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12621
12622 # Sed expression to map a string onto a valid variable name.
12623 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12624
12625
12626 # IFS
12627 # We need space, tab and new line, in precisely that order.
12628 as_nl='
12629 '
12630 IFS="   $as_nl"
12631
12632 # CDPATH.
12633 $as_unset CDPATH
12634
12635 exec 6>&1
12636
12637 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12638 # report actual input values of CONFIG_FILES etc. instead of their
12639 # values after options handling.  Logging --version etc. is OK.
12640 exec 5>>config.log
12641 {
12642   echo
12643   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12644 ## Running $as_me. ##
12645 _ASBOX
12646 } >&5
12647 cat >&5 <<_CSEOF
12648
12649 This file was extended by $as_me, which was
12650 generated by GNU Autoconf 2.59.  Invocation command line was
12651
12652   CONFIG_FILES    = $CONFIG_FILES
12653   CONFIG_HEADERS  = $CONFIG_HEADERS
12654   CONFIG_LINKS    = $CONFIG_LINKS
12655   CONFIG_COMMANDS = $CONFIG_COMMANDS
12656   $ $0 $@
12657
12658 _CSEOF
12659 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12660 echo >&5
12661 _ACEOF
12662
12663 # Files that config.status was made for.
12664 if test -n "$ac_config_files"; then
12665   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12666 fi
12667
12668 if test -n "$ac_config_headers"; then
12669   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12670 fi
12671
12672 if test -n "$ac_config_links"; then
12673   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12674 fi
12675
12676 if test -n "$ac_config_commands"; then
12677   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12678 fi
12679
12680 cat >>$CONFIG_STATUS <<\_ACEOF
12681
12682 ac_cs_usage="\
12683 \`$as_me' instantiates files from templates according to the
12684 current configuration.
12685
12686 Usage: $0 [OPTIONS] [FILE]...
12687
12688   -h, --help       print this help, then exit
12689   -V, --version    print version number, then exit
12690   -q, --quiet      do not print progress messages
12691   -d, --debug      don't remove temporary files
12692       --recheck    update $as_me by reconfiguring in the same conditions
12693   --file=FILE[:TEMPLATE]
12694                    instantiate the configuration file FILE
12695
12696 Configuration files:
12697 $config_files
12698
12699 Report bugs to <bug-autoconf@gnu.org>."
12700 _ACEOF
12701
12702 cat >>$CONFIG_STATUS <<_ACEOF
12703 ac_cs_version="\\
12704 config.status
12705 configured by $0, generated by GNU Autoconf 2.59,
12706   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12707
12708 Copyright (C) 2003 Free Software Foundation, Inc.
12709 This config.status script is free software; the Free Software Foundation
12710 gives unlimited permission to copy, distribute and modify it."
12711 srcdir=$srcdir
12712 INSTALL="$INSTALL"
12713 _ACEOF
12714
12715 cat >>$CONFIG_STATUS <<\_ACEOF
12716 # If no file are specified by the user, then we need to provide default
12717 # value.  By we need to know if files were specified by the user.
12718 ac_need_defaults=:
12719 while test $# != 0
12720 do
12721   case $1 in
12722   --*=*)
12723     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12724     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12725     ac_shift=:
12726     ;;
12727   -*)
12728     ac_option=$1
12729     ac_optarg=$2
12730     ac_shift=shift
12731     ;;
12732   *) # This is not an option, so the user has probably given explicit
12733      # arguments.
12734      ac_option=$1
12735      ac_need_defaults=false;;
12736   esac
12737
12738   case $ac_option in
12739   # Handling of the options.
12740 _ACEOF
12741 cat >>$CONFIG_STATUS <<\_ACEOF
12742   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12743     ac_cs_recheck=: ;;
12744   --version | --vers* | -V )
12745     echo "$ac_cs_version"; exit 0 ;;
12746   --he | --h)
12747     # Conflict between --help and --header
12748     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12749 Try \`$0 --help' for more information." >&5
12750 echo "$as_me: error: ambiguous option: $1
12751 Try \`$0 --help' for more information." >&2;}
12752    { (exit 1); exit 1; }; };;
12753   --help | --hel | -h )
12754     echo "$ac_cs_usage"; exit 0 ;;
12755   --debug | --d* | -d )
12756     debug=: ;;
12757   --file | --fil | --fi | --f )
12758     $ac_shift
12759     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12760     ac_need_defaults=false;;
12761   --header | --heade | --head | --hea )
12762     $ac_shift
12763     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12764     ac_need_defaults=false;;
12765   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12766   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12767     ac_cs_silent=: ;;
12768
12769   # This is an error.
12770   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12771 Try \`$0 --help' for more information." >&5
12772 echo "$as_me: error: unrecognized option: $1
12773 Try \`$0 --help' for more information." >&2;}
12774    { (exit 1); exit 1; }; } ;;
12775
12776   *) ac_config_targets="$ac_config_targets $1" ;;
12777
12778   esac
12779   shift
12780 done
12781
12782 ac_configure_extra_args=
12783
12784 if $ac_cs_silent; then
12785   exec 6>/dev/null
12786   ac_configure_extra_args="$ac_configure_extra_args --silent"
12787 fi
12788
12789 _ACEOF
12790 cat >>$CONFIG_STATUS <<_ACEOF
12791 if \$ac_cs_recheck; then
12792   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12793   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12794 fi
12795
12796 _ACEOF
12797
12798
12799
12800
12801
12802 cat >>$CONFIG_STATUS <<\_ACEOF
12803 for ac_config_target in $ac_config_targets
12804 do
12805   case "$ac_config_target" in
12806   # Handling of arguments.
12807   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12808   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12809 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12810    { (exit 1); exit 1; }; };;
12811   esac
12812 done
12813
12814 # If the user did not use the arguments to specify the items to instantiate,
12815 # then the envvar interface is used.  Set only those that are not.
12816 # We use the long form for the default assignment because of an extremely
12817 # bizarre bug on SunOS 4.1.3.
12818 if $ac_need_defaults; then
12819   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12820 fi
12821
12822 # Have a temporary directory for convenience.  Make it in the build tree
12823 # simply because there is no reason to put it here, and in addition,
12824 # creating and moving files from /tmp can sometimes cause problems.
12825 # Create a temporary directory, and hook for its removal unless debugging.
12826 $debug ||
12827 {
12828   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12829   trap '{ (exit 1); exit 1; }' 1 2 13 15
12830 }
12831
12832 # Create a (secure) tmp directory for tmp files.
12833
12834 {
12835   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12836   test -n "$tmp" && test -d "$tmp"
12837 }  ||
12838 {
12839   tmp=./confstat$$-$RANDOM
12840   (umask 077 && mkdir $tmp)
12841 } ||
12842 {
12843    echo "$me: cannot create a temporary directory in ." >&2
12844    { (exit 1); exit 1; }
12845 }
12846
12847 _ACEOF
12848
12849 cat >>$CONFIG_STATUS <<_ACEOF
12850
12851 #
12852 # CONFIG_FILES section.
12853 #
12854
12855 # No need to generate the scripts if there are no CONFIG_FILES.
12856 # This happens for instance when ./config.status config.h
12857 if test -n "\$CONFIG_FILES"; then
12858   # Protect against being on the right side of a sed subst in config.status.
12859   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12860    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12861 s,@SHELL@,$SHELL,;t t
12862 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12863 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12864 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12865 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12866 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12867 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12868 s,@exec_prefix@,$exec_prefix,;t t
12869 s,@prefix@,$prefix,;t t
12870 s,@program_transform_name@,$program_transform_name,;t t
12871 s,@bindir@,$bindir,;t t
12872 s,@sbindir@,$sbindir,;t t
12873 s,@libexecdir@,$libexecdir,;t t
12874 s,@datadir@,$datadir,;t t
12875 s,@sysconfdir@,$sysconfdir,;t t
12876 s,@sharedstatedir@,$sharedstatedir,;t t
12877 s,@localstatedir@,$localstatedir,;t t
12878 s,@libdir@,$libdir,;t t
12879 s,@includedir@,$includedir,;t t
12880 s,@oldincludedir@,$oldincludedir,;t t
12881 s,@infodir@,$infodir,;t t
12882 s,@mandir@,$mandir,;t t
12883 s,@build_alias@,$build_alias,;t t
12884 s,@host_alias@,$host_alias,;t t
12885 s,@target_alias@,$target_alias,;t t
12886 s,@DEFS@,$DEFS,;t t
12887 s,@ECHO_C@,$ECHO_C,;t t
12888 s,@ECHO_N@,$ECHO_N,;t t
12889 s,@ECHO_T@,$ECHO_T,;t t
12890 s,@LIBS@,$LIBS,;t t
12891 s,@build@,$build,;t t
12892 s,@build_cpu@,$build_cpu,;t t
12893 s,@build_vendor@,$build_vendor,;t t
12894 s,@build_os@,$build_os,;t t
12895 s,@build_noncanonical@,$build_noncanonical,;t t
12896 s,@host_noncanonical@,$host_noncanonical,;t t
12897 s,@target_noncanonical@,$target_noncanonical,;t t
12898 s,@host@,$host,;t t
12899 s,@host_cpu@,$host_cpu,;t t
12900 s,@host_vendor@,$host_vendor,;t t
12901 s,@host_os@,$host_os,;t t
12902 s,@target@,$target,;t t
12903 s,@target_cpu@,$target_cpu,;t t
12904 s,@target_vendor@,$target_vendor,;t t
12905 s,@target_os@,$target_os,;t t
12906 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12907 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12908 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12909 s,@LN@,$LN,;t t
12910 s,@LN_S@,$LN_S,;t t
12911 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12912 s,@build_libsubdir@,$build_libsubdir,;t t
12913 s,@build_subdir@,$build_subdir,;t t
12914 s,@host_subdir@,$host_subdir,;t t
12915 s,@target_subdir@,$target_subdir,;t t
12916 s,@CC@,$CC,;t t
12917 s,@CFLAGS@,$CFLAGS,;t t
12918 s,@LDFLAGS@,$LDFLAGS,;t t
12919 s,@CPPFLAGS@,$CPPFLAGS,;t t
12920 s,@ac_ct_CC@,$ac_ct_CC,;t t
12921 s,@EXEEXT@,$EXEEXT,;t t
12922 s,@OBJEXT@,$OBJEXT,;t t
12923 s,@CXX@,$CXX,;t t
12924 s,@CXXFLAGS@,$CXXFLAGS,;t t
12925 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12926 s,@GNATBIND@,$GNATBIND,;t t
12927 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12928 s,@GNATMAKE@,$GNATMAKE,;t t
12929 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12930 s,@do_compare@,$do_compare,;t t
12931 s,@gmplibs@,$gmplibs,;t t
12932 s,@gmpinc@,$gmpinc,;t t
12933 s,@stage1_languages@,$stage1_languages,;t t
12934 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12935 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12936 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
12937 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
12938 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12939 s,@tooldir@,$tooldir,;t t
12940 s,@build_tooldir@,$build_tooldir,;t t
12941 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12942 s,@GDB_TK@,$GDB_TK,;t t
12943 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12944 s,@build_configargs@,$build_configargs,;t t
12945 s,@build_configdirs@,$build_configdirs,;t t
12946 s,@host_configargs@,$host_configargs,;t t
12947 s,@configdirs@,$configdirs,;t t
12948 s,@target_configargs@,$target_configargs,;t t
12949 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
12950 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
12951 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12952 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12953 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
12954 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
12955 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
12956 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
12957 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
12958 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
12959 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
12960 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
12961 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
12962 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
12963 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
12964 s,@config_shell@,$config_shell,;t t
12965 s,@YACC@,$YACC,;t t
12966 s,@BISON@,$BISON,;t t
12967 s,@M4@,$M4,;t t
12968 s,@LEX@,$LEX,;t t
12969 s,@FLEX@,$FLEX,;t t
12970 s,@MAKEINFO@,$MAKEINFO,;t t
12971 s,@EXPECT@,$EXPECT,;t t
12972 s,@RUNTEST@,$RUNTEST,;t t
12973 s,@AR@,$AR,;t t
12974 s,@AS@,$AS,;t t
12975 s,@DLLTOOL@,$DLLTOOL,;t t
12976 s,@LD@,$LD,;t t
12977 s,@LIPO@,$LIPO,;t t
12978 s,@NM@,$NM,;t t
12979 s,@RANLIB@,$RANLIB,;t t
12980 s,@STRIP@,$STRIP,;t t
12981 s,@WINDRES@,$WINDRES,;t t
12982 s,@WINDMC@,$WINDMC,;t t
12983 s,@OBJCOPY@,$OBJCOPY,;t t
12984 s,@OBJDUMP@,$OBJDUMP,;t t
12985 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12986 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12987 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12988 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12989 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12990 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12991 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12992 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12993 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12994 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12995 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12996 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12997 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12998 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12999 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13000 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13001 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13002 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13003 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13004 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13005 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13006 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13007 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13008 s,@MAINT@,$MAINT,;t t
13009 s,@stage1_cflags@,$stage1_cflags,;t t
13010 s,@stage1_checking@,$stage1_checking,;t t
13011 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13012 s,@datarootdir@,$datarootdir,;t t
13013 s,@docdir@,$docdir,;t t
13014 s,@pdfdir@,$pdfdir,;t t
13015 s,@htmldir@,$htmldir,;t t
13016 s,@LIBOBJS@,$LIBOBJS,;t t
13017 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13018 /@serialization_dependencies@/r $serialization_dependencies
13019 s,@serialization_dependencies@,,;t t
13020 /@host_makefile_frag@/r $host_makefile_frag
13021 s,@host_makefile_frag@,,;t t
13022 /@target_makefile_frag@/r $target_makefile_frag
13023 s,@target_makefile_frag@,,;t t
13024 /@alphaieee_frag@/r $alphaieee_frag
13025 s,@alphaieee_frag@,,;t t
13026 /@ospace_frag@/r $ospace_frag
13027 s,@ospace_frag@,,;t t
13028 CEOF
13029
13030 _ACEOF
13031
13032   cat >>$CONFIG_STATUS <<\_ACEOF
13033   # Split the substitutions into bite-sized pieces for seds with
13034   # small command number limits, like on Digital OSF/1 and HP-UX.
13035   ac_max_sed_lines=48
13036   ac_sed_frag=1 # Number of current file.
13037   ac_beg=1 # First line for current file.
13038   ac_end=$ac_max_sed_lines # Line after last line for current file.
13039   ac_more_lines=:
13040   ac_sed_cmds=
13041   while $ac_more_lines; do
13042     if test $ac_beg -gt 1; then
13043       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13044     else
13045       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13046     fi
13047     if test ! -s $tmp/subs.frag; then
13048       ac_more_lines=false
13049     else
13050       # The purpose of the label and of the branching condition is to
13051       # speed up the sed processing (if there are no `@' at all, there
13052       # is no need to browse any of the substitutions).
13053       # These are the two extra sed commands mentioned above.
13054       (echo ':t
13055   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13056       if test -z "$ac_sed_cmds"; then
13057         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13058       else
13059         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13060       fi
13061       ac_sed_frag=`expr $ac_sed_frag + 1`
13062       ac_beg=$ac_end
13063       ac_end=`expr $ac_end + $ac_max_sed_lines`
13064     fi
13065   done
13066   if test -z "$ac_sed_cmds"; then
13067     ac_sed_cmds=cat
13068   fi
13069 fi # test -n "$CONFIG_FILES"
13070
13071 _ACEOF
13072 cat >>$CONFIG_STATUS <<\_ACEOF
13073 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13074   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13075   case $ac_file in
13076   - | *:- | *:-:* ) # input from stdin
13077         cat >$tmp/stdin
13078         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13079         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13080   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13081         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13082   * )   ac_file_in=$ac_file.in ;;
13083   esac
13084
13085   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13086   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13087 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13088          X"$ac_file" : 'X\(//\)[^/]' \| \
13089          X"$ac_file" : 'X\(//\)$' \| \
13090          X"$ac_file" : 'X\(/\)' \| \
13091          .     : '\(.\)' 2>/dev/null ||
13092 echo X"$ac_file" |
13093     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13094           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13095           /^X\(\/\/\)$/{ s//\1/; q; }
13096           /^X\(\/\).*/{ s//\1/; q; }
13097           s/.*/./; q'`
13098   { if $as_mkdir_p; then
13099     mkdir -p "$ac_dir"
13100   else
13101     as_dir="$ac_dir"
13102     as_dirs=
13103     while test ! -d "$as_dir"; do
13104       as_dirs="$as_dir $as_dirs"
13105       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13106 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13107          X"$as_dir" : 'X\(//\)[^/]' \| \
13108          X"$as_dir" : 'X\(//\)$' \| \
13109          X"$as_dir" : 'X\(/\)' \| \
13110          .     : '\(.\)' 2>/dev/null ||
13111 echo X"$as_dir" |
13112     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13113           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13114           /^X\(\/\/\)$/{ s//\1/; q; }
13115           /^X\(\/\).*/{ s//\1/; q; }
13116           s/.*/./; q'`
13117     done
13118     test ! -n "$as_dirs" || mkdir $as_dirs
13119   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13120 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13121    { (exit 1); exit 1; }; }; }
13122
13123   ac_builddir=.
13124
13125 if test "$ac_dir" != .; then
13126   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13127   # A "../" for each directory in $ac_dir_suffix.
13128   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13129 else
13130   ac_dir_suffix= ac_top_builddir=
13131 fi
13132
13133 case $srcdir in
13134   .)  # No --srcdir option.  We are building in place.
13135     ac_srcdir=.
13136     if test -z "$ac_top_builddir"; then
13137        ac_top_srcdir=.
13138     else
13139        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13140     fi ;;
13141   [\\/]* | ?:[\\/]* )  # Absolute path.
13142     ac_srcdir=$srcdir$ac_dir_suffix;
13143     ac_top_srcdir=$srcdir ;;
13144   *) # Relative path.
13145     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13146     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13147 esac
13148
13149 # Do not use `cd foo && pwd` to compute absolute paths, because
13150 # the directories may not exist.
13151 case `pwd` in
13152 .) ac_abs_builddir="$ac_dir";;
13153 *)
13154   case "$ac_dir" in
13155   .) ac_abs_builddir=`pwd`;;
13156   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13157   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13158   esac;;
13159 esac
13160 case $ac_abs_builddir in
13161 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13162 *)
13163   case ${ac_top_builddir}. in
13164   .) ac_abs_top_builddir=$ac_abs_builddir;;
13165   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13166   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13167   esac;;
13168 esac
13169 case $ac_abs_builddir in
13170 .) ac_abs_srcdir=$ac_srcdir;;
13171 *)
13172   case $ac_srcdir in
13173   .) ac_abs_srcdir=$ac_abs_builddir;;
13174   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13175   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13176   esac;;
13177 esac
13178 case $ac_abs_builddir in
13179 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13180 *)
13181   case $ac_top_srcdir in
13182   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13183   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13184   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13185   esac;;
13186 esac
13187
13188
13189   case $INSTALL in
13190   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13191   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13192   esac
13193
13194   if test x"$ac_file" != x-; then
13195     { echo "$as_me:$LINENO: creating $ac_file" >&5
13196 echo "$as_me: creating $ac_file" >&6;}
13197     rm -f "$ac_file"
13198   fi
13199   # Let's still pretend it is `configure' which instantiates (i.e., don't
13200   # use $as_me), people would be surprised to read:
13201   #    /* config.h.  Generated by config.status.  */
13202   if test x"$ac_file" = x-; then
13203     configure_input=
13204   else
13205     configure_input="$ac_file.  "
13206   fi
13207   configure_input=$configure_input"Generated from `echo $ac_file_in |
13208                                      sed 's,.*/,,'` by configure."
13209
13210   # First look for the input files in the build tree, otherwise in the
13211   # src tree.
13212   ac_file_inputs=`IFS=:
13213     for f in $ac_file_in; do
13214       case $f in
13215       -) echo $tmp/stdin ;;
13216       [\\/$]*)
13217          # Absolute (can't be DOS-style, as IFS=:)
13218          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13219 echo "$as_me: error: cannot find input file: $f" >&2;}
13220    { (exit 1); exit 1; }; }
13221          echo "$f";;
13222       *) # Relative
13223          if test -f "$f"; then
13224            # Build tree
13225            echo "$f"
13226          elif test -f "$srcdir/$f"; then
13227            # Source tree
13228            echo "$srcdir/$f"
13229          else
13230            # /dev/null tree
13231            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13232 echo "$as_me: error: cannot find input file: $f" >&2;}
13233    { (exit 1); exit 1; }; }
13234          fi;;
13235       esac
13236     done` || { (exit 1); exit 1; }
13237 _ACEOF
13238 cat >>$CONFIG_STATUS <<_ACEOF
13239   sed "$ac_vpsub
13240 $extrasub
13241 _ACEOF
13242 cat >>$CONFIG_STATUS <<\_ACEOF
13243 :t
13244 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13245 s,@configure_input@,$configure_input,;t t
13246 s,@srcdir@,$ac_srcdir,;t t
13247 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13248 s,@top_srcdir@,$ac_top_srcdir,;t t
13249 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13250 s,@builddir@,$ac_builddir,;t t
13251 s,@abs_builddir@,$ac_abs_builddir,;t t
13252 s,@top_builddir@,$ac_top_builddir,;t t
13253 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13254 s,@INSTALL@,$ac_INSTALL,;t t
13255 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13256   rm -f $tmp/stdin
13257   if test x"$ac_file" != x-; then
13258     mv $tmp/out $ac_file
13259   else
13260     cat $tmp/out
13261     rm -f $tmp/out
13262   fi
13263
13264 done
13265 _ACEOF
13266
13267 cat >>$CONFIG_STATUS <<\_ACEOF
13268
13269 { (exit 0); exit 0; }
13270 _ACEOF
13271 chmod +x $CONFIG_STATUS
13272 ac_clean_files=$ac_clean_files_save
13273
13274
13275 # configure is writing to config.log, and then calls config.status.
13276 # config.status does its own redirection, appending to config.log.
13277 # Unfortunately, on DOS this fails, as config.log is still kept open
13278 # by configure, so config.status won't be able to write to it; its
13279 # output is simply discarded.  So we exec the FD to /dev/null,
13280 # effectively closing config.log, so it can be properly (re)opened and
13281 # appended to by config.status.  When coming back to configure, we
13282 # need to make the FD available again.
13283 if test "$no_create" != yes; then
13284   ac_cs_success=:
13285   ac_config_status_args=
13286   test "$silent" = yes &&
13287     ac_config_status_args="$ac_config_status_args --quiet"
13288   exec 5>/dev/null
13289   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13290   exec 5>>config.log
13291   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13292   # would make configure fail if this is the last instruction.
13293   $ac_cs_success || { (exit 1); exit 1; }
13294 fi
13295