configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S TOPLEVEL_CONFIGURE_ARGUMENTS build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET RPATH_ENVVAR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs CC_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CFLAGS_FOR_BUILD CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277
 278 # Initialize some variables set by options.
 279 ac_init_help=
 280 ac_init_version=false
 281 # The variables have the same names as the options, with
 282 # dashes changed to underlines.
 283 cache_file=/dev/null
 284 exec_prefix=NONE
 285 no_create=
 286 no_recursion=
 287 prefix=NONE
 288 program_prefix=NONE
 289 program_suffix=NONE
 290 program_transform_name=s,x,x,
 291 silent=
 292 site=
 293 srcdir=
 294 verbose=
 295 x_includes=NONE
 296 x_libraries=NONE
 297
 298 # Installation directory options.
 299 # These are left unexpanded so users can "make install exec_prefix=/foo"
 300 # and all the variables that are supposed to be based on exec_prefix
 301 # by default will actually change.
 302 # Use braces instead of parens because sh, perl, etc. also accept them.
 303 bindir='${exec_prefix}/bin'
 304 sbindir='${exec_prefix}/sbin'
 305 libexecdir='${exec_prefix}/libexec'
 306 datadir='${prefix}/share'
 307 sysconfdir='${prefix}/etc'
 308 sharedstatedir='${prefix}/com'
 309 localstatedir='${prefix}/var'
 310 libdir='${exec_prefix}/lib'
 311 includedir='${prefix}/include'
 312 oldincludedir='/usr/include'
 313 infodir='${prefix}/info'
 314 mandir='${prefix}/man'
 315
 316 ac_prev=
 317 for ac_option
 318 do
 319   # If the previous option needs an argument, assign it.
 320   if test -n "$ac_prev"; then
 321     eval "$ac_prev=\$ac_option"
 322     ac_prev=
 323     continue
 324   fi
 325
 326   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 327
 328   # Accept the important Cygnus configure options, so we can diagnose typos.
 329
 330   case $ac_option in
 331
 332   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 333     ac_prev=bindir ;;
 334   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 335     bindir=$ac_optarg ;;
 336
 337   -build | --build | --buil | --bui | --bu)
 338     ac_prev=build_alias ;;
 339   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 340     build_alias=$ac_optarg ;;
 341
 342   -cache-file | --cache-file | --cache-fil | --cache-fi \
 343   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 344     ac_prev=cache_file ;;
 345   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 346   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 347     cache_file=$ac_optarg ;;
 348
 349   --config-cache | -C)
 350     cache_file=config.cache ;;
 351
 352   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 353     ac_prev=datadir ;;
 354   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 355   | --da=*)
 356     datadir=$ac_optarg ;;
 357
 358   -disable-* | --disable-*)
 359     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 360     # Reject names that are not valid shell variable names.
 361     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 362       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 363    { (exit 1); exit 1; }; }
 364     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 365     eval "enable_$ac_feature=no" ;;
 366
 367   -enable-* | --enable-*)
 368     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 369     # Reject names that are not valid shell variable names.
 370     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 371       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 372    { (exit 1); exit 1; }; }
 373     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 374     case $ac_option in
 375       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 376       *) ac_optarg=yes ;;
 377     esac
 378     eval "enable_$ac_feature='$ac_optarg'" ;;
 379
 380   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 381   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 382   | --exec | --exe | --ex)
 383     ac_prev=exec_prefix ;;
 384   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 385   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 386   | --exec=* | --exe=* | --ex=*)
 387     exec_prefix=$ac_optarg ;;
 388
 389   -gas | --gas | --ga | --g)
 390     # Obsolete; use --with-gas.
 391     with_gas=yes ;;
 392
 393   -help | --help | --hel | --he | -h)
 394     ac_init_help=long ;;
 395   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 396     ac_init_help=recursive ;;
 397   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 398     ac_init_help=short ;;
 399
 400   -host | --host | --hos | --ho)
 401     ac_prev=host_alias ;;
 402   -host=* | --host=* | --hos=* | --ho=*)
 403     host_alias=$ac_optarg ;;
 404
 405   -includedir | --includedir | --includedi | --included | --include \
 406   | --includ | --inclu | --incl | --inc)
 407     ac_prev=includedir ;;
 408   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 409   | --includ=* | --inclu=* | --incl=* | --inc=*)
 410     includedir=$ac_optarg ;;
 411
 412   -infodir | --infodir | --infodi | --infod | --info | --inf)
 413     ac_prev=infodir ;;
 414   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 415     infodir=$ac_optarg ;;
 416
 417   -libdir | --libdir | --libdi | --libd)
 418     ac_prev=libdir ;;
 419   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 420     libdir=$ac_optarg ;;
 421
 422   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 423   | --libexe | --libex | --libe)
 424     ac_prev=libexecdir ;;
 425   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 426   | --libexe=* | --libex=* | --libe=*)
 427     libexecdir=$ac_optarg ;;
 428
 429   -localstatedir | --localstatedir | --localstatedi | --localstated \
 430   | --localstate | --localstat | --localsta | --localst \
 431   | --locals | --local | --loca | --loc | --lo)
 432     ac_prev=localstatedir ;;
 433   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 434   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 435   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 436     localstatedir=$ac_optarg ;;
 437
 438   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 439     ac_prev=mandir ;;
 440   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 441     mandir=$ac_optarg ;;
 442
 443   -nfp | --nfp | --nf)
 444     # Obsolete; use --without-fp.
 445     with_fp=no ;;
 446
 447   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 448   | --no-cr | --no-c | -n)
 449     no_create=yes ;;
 450
 451   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 452   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 453     no_recursion=yes ;;
 454
 455   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 456   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 457   | --oldin | --oldi | --old | --ol | --o)
 458     ac_prev=oldincludedir ;;
 459   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 460   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 461   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 462     oldincludedir=$ac_optarg ;;
 463
 464   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 465     ac_prev=prefix ;;
 466   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 467     prefix=$ac_optarg ;;
 468
 469   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 470   | --program-pre | --program-pr | --program-p)
 471     ac_prev=program_prefix ;;
 472   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 473   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 474     program_prefix=$ac_optarg ;;
 475
 476   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 477   | --program-suf | --program-su | --program-s)
 478     ac_prev=program_suffix ;;
 479   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 480   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 481     program_suffix=$ac_optarg ;;
 482
 483   -program-transform-name | --program-transform-name \
 484   | --program-transform-nam | --program-transform-na \
 485   | --program-transform-n | --program-transform- \
 486   | --program-transform | --program-transfor \
 487   | --program-transfo | --program-transf \
 488   | --program-trans | --program-tran \
 489   | --progr-tra | --program-tr | --program-t)
 490     ac_prev=program_transform_name ;;
 491   -program-transform-name=* | --program-transform-name=* \
 492   | --program-transform-nam=* | --program-transform-na=* \
 493   | --program-transform-n=* | --program-transform-=* \
 494   | --program-transform=* | --program-transfor=* \
 495   | --program-transfo=* | --program-transf=* \
 496   | --program-trans=* | --program-tran=* \
 497   | --progr-tra=* | --program-tr=* | --program-t=*)
 498     program_transform_name=$ac_optarg ;;
 499
 500   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 501   | -silent | --silent | --silen | --sile | --sil)
 502     silent=yes ;;
 503
 504   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 505     ac_prev=sbindir ;;
 506   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 507   | --sbi=* | --sb=*)
 508     sbindir=$ac_optarg ;;
 509
 510   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 511   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 512   | --sharedst | --shareds | --shared | --share | --shar \
 513   | --sha | --sh)
 514     ac_prev=sharedstatedir ;;
 515   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 516   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 517   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 518   | --sha=* | --sh=*)
 519     sharedstatedir=$ac_optarg ;;
 520
 521   -site | --site | --sit)
 522     ac_prev=site ;;
 523   -site=* | --site=* | --sit=*)
 524     site=$ac_optarg ;;
 525
 526   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 527     ac_prev=srcdir ;;
 528   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 529     srcdir=$ac_optarg ;;
 530
 531   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 532   | --syscon | --sysco | --sysc | --sys | --sy)
 533     ac_prev=sysconfdir ;;
 534   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 535   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 536     sysconfdir=$ac_optarg ;;
 537
 538   -target | --target | --targe | --targ | --tar | --ta | --t)
 539     ac_prev=target_alias ;;
 540   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 541     target_alias=$ac_optarg ;;
 542
 543   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 544     verbose=yes ;;
 545
 546   -version | --version | --versio | --versi | --vers | -V)
 547     ac_init_version=: ;;
 548
 549   -with-* | --with-*)
 550     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 551     # Reject names that are not valid shell variable names.
 552     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 553       { echo "$as_me: error: invalid package name: $ac_package" >&2
 554    { (exit 1); exit 1; }; }
 555     ac_package=`echo $ac_package| sed 's/-/_/g'`
 556     case $ac_option in
 557       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 558       *) ac_optarg=yes ;;
 559     esac
 560     eval "with_$ac_package='$ac_optarg'" ;;
 561
 562   -without-* | --without-*)
 563     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 564     # Reject names that are not valid shell variable names.
 565     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 566       { echo "$as_me: error: invalid package name: $ac_package" >&2
 567    { (exit 1); exit 1; }; }
 568     ac_package=`echo $ac_package | sed 's/-/_/g'`
 569     eval "with_$ac_package=no" ;;
 570
 571   --x)
 572     # Obsolete; use --with-x.
 573     with_x=yes ;;
 574
 575   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 576   | --x-incl | --x-inc | --x-in | --x-i)
 577     ac_prev=x_includes ;;
 578   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 579   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 580     x_includes=$ac_optarg ;;
 581
 582   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 583   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 584     ac_prev=x_libraries ;;
 585   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 586   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 587     x_libraries=$ac_optarg ;;
 588
 589   -*) { echo "$as_me: error: unrecognized option: $ac_option
 590 Try \`$0 --help' for more information." >&2
 591    { (exit 1); exit 1; }; }
 592     ;;
 593
 594   *=*)
 595     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 596     # Reject names that are not valid shell variable names.
 597     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 598       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 599    { (exit 1); exit 1; }; }
 600     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 601     eval "$ac_envvar='$ac_optarg'"
 602     export $ac_envvar ;;
 603
 604   *)
 605     # FIXME: should be removed in autoconf 3.0.
 606     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 607     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 608       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 609     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 610     ;;
 611
 612   esac
 613 done
 614
 615 if test -n "$ac_prev"; then
 616   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 617   { echo "$as_me: error: missing argument to $ac_option" >&2
 618    { (exit 1); exit 1; }; }
 619 fi
 620
 621 # Be sure to have absolute paths.
 622 for ac_var in exec_prefix prefix
 623 do
 624   eval ac_val=$`echo $ac_var`
 625   case $ac_val in
 626     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 627     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 628    { (exit 1); exit 1; }; };;
 629   esac
 630 done
 631
 632 # Be sure to have absolute paths.
 633 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 634               localstatedir libdir includedir oldincludedir infodir mandir
 635 do
 636   eval ac_val=$`echo $ac_var`
 637   case $ac_val in
 638     [\\/$]* | ?:[\\/]* ) ;;
 639     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 640    { (exit 1); exit 1; }; };;
 641   esac
 642 done
 643
 644 # There might be people who depend on the old broken behavior: `$host'
 645 # used to hold the argument of --host etc.
 646 # FIXME: To remove some day.
 647 build=$build_alias
 648 host=$host_alias
 649 target=$target_alias
 650
 651 # FIXME: To remove some day.
 652 if test "x$host_alias" != x; then
 653   if test "x$build_alias" = x; then
 654     cross_compiling=maybe
 655     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 656     If a cross compiler is detected then cross compile mode will be used." >&2
 657   elif test "x$build_alias" != "x$host_alias"; then
 658     cross_compiling=yes
 659   fi
 660 fi
 661
 662 ac_tool_prefix=
 663 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 664
 665 test "$silent" = yes && exec 6>/dev/null
 666
 667
 668 # Find the source files, if location was not specified.
 669 if test -z "$srcdir"; then
 670   ac_srcdir_defaulted=yes
 671   # Try the directory containing this script, then its parent.
 672   ac_confdir=`(dirname "$0") 2>/dev/null ||
 673 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 674          X"$0" : 'X\(//\)[^/]' \| \
 675          X"$0" : 'X\(//\)$' \| \
 676          X"$0" : 'X\(/\)' \| \
 677          .     : '\(.\)' 2>/dev/null ||
 678 echo X"$0" |
 679     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 680           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 681           /^X\(\/\/\)$/{ s//\1/; q; }
 682           /^X\(\/\).*/{ s//\1/; q; }
 683           s/.*/./; q'`
 684   srcdir=$ac_confdir
 685   if test ! -r $srcdir/$ac_unique_file; then
 686     srcdir=..
 687   fi
 688 else
 689   ac_srcdir_defaulted=no
 690 fi
 691 if test ! -r $srcdir/$ac_unique_file; then
 692   if test "$ac_srcdir_defaulted" = yes; then
 693     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 694    { (exit 1); exit 1; }; }
 695   else
 696     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 697    { (exit 1); exit 1; }; }
 698   fi
 699 fi
 700 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 701   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 702    { (exit 1); exit 1; }; }
 703 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 704 ac_env_build_alias_set=${build_alias+set}
 705 ac_env_build_alias_value=$build_alias
 706 ac_cv_env_build_alias_set=${build_alias+set}
 707 ac_cv_env_build_alias_value=$build_alias
 708 ac_env_host_alias_set=${host_alias+set}
 709 ac_env_host_alias_value=$host_alias
 710 ac_cv_env_host_alias_set=${host_alias+set}
 711 ac_cv_env_host_alias_value=$host_alias
 712 ac_env_target_alias_set=${target_alias+set}
 713 ac_env_target_alias_value=$target_alias
 714 ac_cv_env_target_alias_set=${target_alias+set}
 715 ac_cv_env_target_alias_value=$target_alias
 716 ac_env_CC_set=${CC+set}
 717 ac_env_CC_value=$CC
 718 ac_cv_env_CC_set=${CC+set}
 719 ac_cv_env_CC_value=$CC
 720 ac_env_CFLAGS_set=${CFLAGS+set}
 721 ac_env_CFLAGS_value=$CFLAGS
 722 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 723 ac_cv_env_CFLAGS_value=$CFLAGS
 724 ac_env_LDFLAGS_set=${LDFLAGS+set}
 725 ac_env_LDFLAGS_value=$LDFLAGS
 726 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 727 ac_cv_env_LDFLAGS_value=$LDFLAGS
 728 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 729 ac_env_CPPFLAGS_value=$CPPFLAGS
 730 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 731 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 732 ac_env_CXX_set=${CXX+set}
 733 ac_env_CXX_value=$CXX
 734 ac_cv_env_CXX_set=${CXX+set}
 735 ac_cv_env_CXX_value=$CXX
 736 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 737 ac_env_CXXFLAGS_value=$CXXFLAGS
 738 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 739 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 740 ac_env_AR_set=${AR+set}
 741 ac_env_AR_value=$AR
 742 ac_cv_env_AR_set=${AR+set}
 743 ac_cv_env_AR_value=$AR
 744 ac_env_AS_set=${AS+set}
 745 ac_env_AS_value=$AS
 746 ac_cv_env_AS_set=${AS+set}
 747 ac_cv_env_AS_value=$AS
 748 ac_env_DLLTOOL_set=${DLLTOOL+set}
 749 ac_env_DLLTOOL_value=$DLLTOOL
 750 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 751 ac_cv_env_DLLTOOL_value=$DLLTOOL
 752 ac_env_LD_set=${LD+set}
 753 ac_env_LD_value=$LD
 754 ac_cv_env_LD_set=${LD+set}
 755 ac_cv_env_LD_value=$LD
 756 ac_env_LIPO_set=${LIPO+set}
 757 ac_env_LIPO_value=$LIPO
 758 ac_cv_env_LIPO_set=${LIPO+set}
 759 ac_cv_env_LIPO_value=$LIPO
 760 ac_env_NM_set=${NM+set}
 761 ac_env_NM_value=$NM
 762 ac_cv_env_NM_set=${NM+set}
 763 ac_cv_env_NM_value=$NM
 764 ac_env_RANLIB_set=${RANLIB+set}
 765 ac_env_RANLIB_value=$RANLIB
 766 ac_cv_env_RANLIB_set=${RANLIB+set}
 767 ac_cv_env_RANLIB_value=$RANLIB
 768 ac_env_STRIP_set=${STRIP+set}
 769 ac_env_STRIP_value=$STRIP
 770 ac_cv_env_STRIP_set=${STRIP+set}
 771 ac_cv_env_STRIP_value=$STRIP
 772 ac_env_WINDRES_set=${WINDRES+set}
 773 ac_env_WINDRES_value=$WINDRES
 774 ac_cv_env_WINDRES_set=${WINDRES+set}
 775 ac_cv_env_WINDRES_value=$WINDRES
 776 ac_env_WINDMC_set=${WINDMC+set}
 777 ac_env_WINDMC_value=$WINDMC
 778 ac_cv_env_WINDMC_set=${WINDMC+set}
 779 ac_cv_env_WINDMC_value=$WINDMC
 780 ac_env_OBJCOPY_set=${OBJCOPY+set}
 781 ac_env_OBJCOPY_value=$OBJCOPY
 782 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 783 ac_cv_env_OBJCOPY_value=$OBJCOPY
 784 ac_env_OBJDUMP_set=${OBJDUMP+set}
 785 ac_env_OBJDUMP_value=$OBJDUMP
 786 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 787 ac_cv_env_OBJDUMP_value=$OBJDUMP
 788 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 789 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 790 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 791 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 792 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 793 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 794 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 795 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 796 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 797 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 798 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 799 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 800 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 801 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 802 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 803 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 804 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 805 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 806 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 807 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 808 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 809 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 810 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 811 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 812 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 813 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 814 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 815 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 816 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 817 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 818 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 819 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 820 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 821 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 822 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 823 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 824 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 825 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 826 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 827 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 828 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 829 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 830 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 831 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 832 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 833 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 834 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 835 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 836 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 837 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 838 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 839 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 840 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 841 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 842 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 843 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 844 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 845 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 846 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 847 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 848 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 849 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 850 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 851 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 852
 853 #
 854 # Report the --help message.
 855 #
 856 if test "$ac_init_help" = "long"; then
 857   # Omit some internal or obsolete options to make the list less imposing.
 858   # This message is too long to be a string in the A/UX 3.1 sh.
 859   cat <<_ACEOF
 860 \`configure' configures this package to adapt to many kinds of systems.
 861
 862 Usage: $0 [OPTION]... [VAR=VALUE]...
 863
 864 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 865 VAR=VALUE.  See below for descriptions of some of the useful variables.
 866
 867 Defaults for the options are specified in brackets.
 868
 869 Configuration:
 870   -h, --help              display this help and exit
 871       --help=short        display options specific to this package
 872       --help=recursive    display the short help of all the included packages
 873   -V, --version           display version information and exit
 874   -q, --quiet, --silent   do not print \`checking...' messages
 875       --cache-file=FILE   cache test results in FILE [disabled]
 876   -C, --config-cache      alias for \`--cache-file=config.cache'
 877   -n, --no-create         do not create output files
 878       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 879
 880 _ACEOF
 881
 882   cat <<_ACEOF
 883 Installation directories:
 884   --prefix=PREFIX         install architecture-independent files in PREFIX
 885                           [$ac_default_prefix]
 886   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 887                           [PREFIX]
 888
 889 By default, \`make install' will install all the files in
 890 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 891 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 892 for instance \`--prefix=\$HOME'.
 893
 894 For better control, use the options below.
 895
 896 Fine tuning of the installation directories:
 897   --bindir=DIR           user executables [EPREFIX/bin]
 898   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 899   --libexecdir=DIR       program executables [EPREFIX/libexec]
 900   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 901   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 902   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 903   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 904   --libdir=DIR           object code libraries [EPREFIX/lib]
 905   --includedir=DIR       C header files [PREFIX/include]
 906   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 907   --infodir=DIR          info documentation [PREFIX/info]
 908   --mandir=DIR           man documentation [PREFIX/man]
 909 _ACEOF
 910
 911   cat <<\_ACEOF
 912
 913 Program names:
 914   --program-prefix=PREFIX            prepend PREFIX to installed program names
 915   --program-suffix=SUFFIX            append SUFFIX to installed program names
 916   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 917
 918 System types:
 919   --build=BUILD     configure for building on BUILD [guessed]
 920   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 921   --target=TARGET   configure for building compilers for TARGET [HOST]
 922 _ACEOF
 923 fi
 924
 925 if test -n "$ac_init_help"; then
 926
 927   cat <<\_ACEOF
 928
 929 Optional Features:
 930   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 931   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 932   --enable-libada         build libada directory
 933   --enable-libssp         build libssp directory
 934   --enable-stage1-languages[=all]   choose additional languages to build during
 935                           stage1.  Mostly useful for compiler development.
 936   --enable-objc-gc        enable use of Boehm's garbage collector with the
 937                           GNU Objective-C runtime
 938   --enable-bootstrap      enable bootstrapping [yes if native build]
 939   --enable-serial-[{host,target,build}-]configure
 940                           force sequential configuration of
 941                           sub-packages for the host, target or build
 942                           machine, or all sub-packages
 943   --enable-maintainer-mode enable make rules and dependencies not useful
 944                           (and sometimes confusing) to the casual installer
 945   --enable-stage1-checking[=all]   choose additional checking for stage1
 946                           of the compiler
 947   --enable-werror         enable -Werror in bootstrap stage2 and later
 948
 949 Optional Packages:
 950   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 951   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 952   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 953   --with-mpfr-dir=PATH    this option has been REMOVED
 954   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 955                           Equivalent to --with-mpfr-include=PATH/include
 956                           plus --with-mpfr-lib=PATH/lib
 957   --with-mpfr-include=PATH
 958                           specify directory for installed MPFR include files
 959   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 960   --with-gmp-dir=PATH     this option has been REMOVED
 961   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 962                           Equivalent to --with-gmp-include=PATH/include
 963                           plus --with-gmp-lib=PATH/lib
 964   --with-gmp-include=PATH specify directory for installed GMP include files
 965   --with-gmp-lib=PATH     specify directory for the installed GMP library
 966   --with-build-sysroot=SYSROOT
 967                           use sysroot as the system root during the build
 968   --with-debug-prefix-map='A=B C=D ...'
 969                              map A to B, C to D ... in debug information
 970   --with-build-time-tools=PATH
 971                           use given path to find target tools during the build
 972   --with-datarootdir      use datarootdir as the data root directory.
 973   --with-docdir           install documentation in this directory.
 974   --with-pdfdir           install pdf in this directory.
 975   --with-htmldir          install html in this directory.
 976
 977 Some influential environment variables:
 978   CC          C compiler command
 979   CFLAGS      C compiler flags
 980   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 981               nonstandard directory <lib dir>
 982   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 983               headers in a nonstandard directory <include dir>
 984   CXX         C++ compiler command
 985   CXXFLAGS    C++ compiler flags
 986   AR          AR for the host
 987   AS          AS for the host
 988   DLLTOOL     DLLTOOL for the host
 989   LD          LD for the host
 990   LIPO        LIPO for the host
 991   NM          NM for the host
 992   RANLIB      RANLIB for the host
 993   STRIP       STRIP for the host
 994   WINDRES     WINDRES for the host
 995   WINDMC      WINDMC for the host
 996   OBJCOPY     OBJCOPY for the host
 997   OBJDUMP     OBJDUMP for the host
 998   CC_FOR_TARGET
 999               CC for the target
1000   CXX_FOR_TARGET
1001               CXX for the target
1002   GCC_FOR_TARGET
1003               GCC for the target
1004   GCJ_FOR_TARGET
1005               GCJ for the target
1006   GFORTRAN_FOR_TARGET
1007               GFORTRAN for the target
1008   AR_FOR_TARGET
1009               AR for the target
1010   AS_FOR_TARGET
1011               AS for the target
1012   DLLTOOL_FOR_TARGET
1013               DLLTOOL for the target
1014   LD_FOR_TARGET
1015               LD for the target
1016   LIPO_FOR_TARGET
1017               LIPO for the target
1018   NM_FOR_TARGET
1019               NM for the target
1020   OBJDUMP_FOR_TARGET
1021               OBJDUMP for the target
1022   RANLIB_FOR_TARGET
1023               RANLIB for the target
1024   STRIP_FOR_TARGET
1025               STRIP for the target
1026   WINDRES_FOR_TARGET
1027               WINDRES for the target
1028   WINDMC_FOR_TARGET
1029               WINDMC for the target
1030
1031 Use these variables to override the choices made by `configure' or to help
1032 it to find libraries and programs with nonstandard names/locations.
1033
1034 _ACEOF
1035 fi
1036
1037 if test "$ac_init_help" = "recursive"; then
1038   # If there are subdirs, report their specific --help.
1039   ac_popdir=`pwd`
1040   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1041     test -d $ac_dir || continue
1042     ac_builddir=.
1043
1044 if test "$ac_dir" != .; then
1045   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1046   # A "../" for each directory in $ac_dir_suffix.
1047   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1048 else
1049   ac_dir_suffix= ac_top_builddir=
1050 fi
1051
1052 case $srcdir in
1053   .)  # No --srcdir option.  We are building in place.
1054     ac_srcdir=.
1055     if test -z "$ac_top_builddir"; then
1056        ac_top_srcdir=.
1057     else
1058        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1059     fi ;;
1060   [\\/]* | ?:[\\/]* )  # Absolute path.
1061     ac_srcdir=$srcdir$ac_dir_suffix;
1062     ac_top_srcdir=$srcdir ;;
1063   *) # Relative path.
1064     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1065     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1066 esac
1067
1068 # Do not use `cd foo && pwd` to compute absolute paths, because
1069 # the directories may not exist.
1070 case `pwd` in
1071 .) ac_abs_builddir="$ac_dir";;
1072 *)
1073   case "$ac_dir" in
1074   .) ac_abs_builddir=`pwd`;;
1075   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1076   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1077   esac;;
1078 esac
1079 case $ac_abs_builddir in
1080 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1081 *)
1082   case ${ac_top_builddir}. in
1083   .) ac_abs_top_builddir=$ac_abs_builddir;;
1084   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1085   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1086   esac;;
1087 esac
1088 case $ac_abs_builddir in
1089 .) ac_abs_srcdir=$ac_srcdir;;
1090 *)
1091   case $ac_srcdir in
1092   .) ac_abs_srcdir=$ac_abs_builddir;;
1093   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1094   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1095   esac;;
1096 esac
1097 case $ac_abs_builddir in
1098 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1099 *)
1100   case $ac_top_srcdir in
1101   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1102   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1103   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1104   esac;;
1105 esac
1106
1107     cd $ac_dir
1108     # Check for guested configure; otherwise get Cygnus style configure.
1109     if test -f $ac_srcdir/configure.gnu; then
1110       echo
1111       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1112     elif test -f $ac_srcdir/configure; then
1113       echo
1114       $SHELL $ac_srcdir/configure  --help=recursive
1115     elif test -f $ac_srcdir/configure.ac ||
1116            test -f $ac_srcdir/configure.in; then
1117       echo
1118       $ac_configure --help
1119     else
1120       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1121     fi
1122     cd $ac_popdir
1123   done
1124 fi
1125
1126 test -n "$ac_init_help" && exit 0
1127 if $ac_init_version; then
1128   cat <<\_ACEOF
1129
1130 Copyright (C) 2003 Free Software Foundation, Inc.
1131 This configure script is free software; the Free Software Foundation
1132 gives unlimited permission to copy, distribute and modify it.
1133 _ACEOF
1134   exit 0
1135 fi
1136 exec 5>config.log
1137 cat >&5 <<_ACEOF
1138 This file contains any messages produced by compilers while
1139 running configure, to aid debugging if configure makes a mistake.
1140
1141 It was created by $as_me, which was
1142 generated by GNU Autoconf 2.59.  Invocation command line was
1143
1144   $ $0 $@
1145
1146 _ACEOF
1147 {
1148 cat <<_ASUNAME
1149 ## --------- ##
1150 ## Platform. ##
1151 ## --------- ##
1152
1153 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1154 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1155 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1156 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1157 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1158
1159 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1160 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1161
1162 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1163 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1164 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1165 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1166 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1167 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1168 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1169
1170 _ASUNAME
1171
1172 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1173 for as_dir in $PATH
1174 do
1175   IFS=$as_save_IFS
1176   test -z "$as_dir" && as_dir=.
1177   echo "PATH: $as_dir"
1178 done
1179
1180 } >&5
1181
1182 cat >&5 <<_ACEOF
1183
1184
1185 ## ----------- ##
1186 ## Core tests. ##
1187 ## ----------- ##
1188
1189 _ACEOF
1190
1191
1192 # Keep a trace of the command line.
1193 # Strip out --no-create and --no-recursion so they do not pile up.
1194 # Strip out --silent because we don't want to record it for future runs.
1195 # Also quote any args containing shell meta-characters.
1196 # Make two passes to allow for proper duplicate-argument suppression.
1197 ac_configure_args=
1198 ac_configure_args0=
1199 ac_configure_args1=
1200 ac_sep=
1201 ac_must_keep_next=false
1202 for ac_pass in 1 2
1203 do
1204   for ac_arg
1205   do
1206     case $ac_arg in
1207     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1208     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1209     | -silent | --silent | --silen | --sile | --sil)
1210       continue ;;
1211     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1212       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1213     esac
1214     case $ac_pass in
1215     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1216     2)
1217       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1218       if test $ac_must_keep_next = true; then
1219         ac_must_keep_next=false # Got value, back to normal.
1220       else
1221         case $ac_arg in
1222           *=* | --config-cache | -C | -disable-* | --disable-* \
1223           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1224           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1225           | -with-* | --with-* | -without-* | --without-* | --x)
1226             case "$ac_configure_args0 " in
1227               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1228             esac
1229             ;;
1230           -* ) ac_must_keep_next=true ;;
1231         esac
1232       fi
1233       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1234       # Get rid of the leading space.
1235       ac_sep=" "
1236       ;;
1237     esac
1238   done
1239 done
1240 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1241 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1242
1243 # When interrupted or exit'd, cleanup temporary files, and complete
1244 # config.log.  We remove comments because anyway the quotes in there
1245 # would cause problems or look ugly.
1246 # WARNING: Be sure not to use single quotes in there, as some shells,
1247 # such as our DU 5.0 friend, will then `close' the trap.
1248 trap 'exit_status=$?
1249   # Save into config.log some information that might help in debugging.
1250   {
1251     echo
1252
1253     cat <<\_ASBOX
1254 ## ---------------- ##
1255 ## Cache variables. ##
1256 ## ---------------- ##
1257 _ASBOX
1258     echo
1259     # The following way of writing the cache mishandles newlines in values,
1260 {
1261   (set) 2>&1 |
1262     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1263     *ac_space=\ *)
1264       sed -n \
1265         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1266           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1267       ;;
1268     *)
1269       sed -n \
1270         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1271       ;;
1272     esac;
1273 }
1274     echo
1275
1276     cat <<\_ASBOX
1277 ## ----------------- ##
1278 ## Output variables. ##
1279 ## ----------------- ##
1280 _ASBOX
1281     echo
1282     for ac_var in $ac_subst_vars
1283     do
1284       eval ac_val=$`echo $ac_var`
1285       echo "$ac_var='"'"'$ac_val'"'"'"
1286     done | sort
1287     echo
1288
1289     if test -n "$ac_subst_files"; then
1290       cat <<\_ASBOX
1291 ## ------------- ##
1292 ## Output files. ##
1293 ## ------------- ##
1294 _ASBOX
1295       echo
1296       for ac_var in $ac_subst_files
1297       do
1298         eval ac_val=$`echo $ac_var`
1299         echo "$ac_var='"'"'$ac_val'"'"'"
1300       done | sort
1301       echo
1302     fi
1303
1304     if test -s confdefs.h; then
1305       cat <<\_ASBOX
1306 ## ----------- ##
1307 ## confdefs.h. ##
1308 ## ----------- ##
1309 _ASBOX
1310       echo
1311       sed "/^$/d" confdefs.h | sort
1312       echo
1313     fi
1314     test "$ac_signal" != 0 &&
1315       echo "$as_me: caught signal $ac_signal"
1316     echo "$as_me: exit $exit_status"
1317   } >&5
1318   rm -f core *.core &&
1319   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1320     exit $exit_status
1321      ' 0
1322 for ac_signal in 1 2 13 15; do
1323   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1324 done
1325 ac_signal=0
1326
1327 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1328 rm -rf conftest* confdefs.h
1329 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1330 echo >confdefs.h
1331
1332 # Predefined preprocessor variables.
1333
1334 cat >>confdefs.h <<_ACEOF
1335 #define PACKAGE_NAME "$PACKAGE_NAME"
1336 _ACEOF
1337
1338
1339 cat >>confdefs.h <<_ACEOF
1340 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1341 _ACEOF
1342
1343
1344 cat >>confdefs.h <<_ACEOF
1345 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1346 _ACEOF
1347
1348
1349 cat >>confdefs.h <<_ACEOF
1350 #define PACKAGE_STRING "$PACKAGE_STRING"
1351 _ACEOF
1352
1353
1354 cat >>confdefs.h <<_ACEOF
1355 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1356 _ACEOF
1357
1358
1359 # Let the site file select an alternate cache file if it wants to.
1360 # Prefer explicitly selected file to automatically selected ones.
1361 if test -z "$CONFIG_SITE"; then
1362   if test "x$prefix" != xNONE; then
1363     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1364   else
1365     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1366   fi
1367 fi
1368 for ac_site_file in $CONFIG_SITE; do
1369   if test -r "$ac_site_file"; then
1370     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1371 echo "$as_me: loading site script $ac_site_file" >&6;}
1372     sed 's/^/| /' "$ac_site_file" >&5
1373     . "$ac_site_file"
1374   fi
1375 done
1376
1377 if test -r "$cache_file"; then
1378   # Some versions of bash will fail to source /dev/null (special
1379   # files actually), so we avoid doing that.
1380   if test -f "$cache_file"; then
1381     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1382 echo "$as_me: loading cache $cache_file" >&6;}
1383     case $cache_file in
1384       [\\/]* | ?:[\\/]* ) . $cache_file;;
1385       *)                      . ./$cache_file;;
1386     esac
1387   fi
1388 else
1389   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1390 echo "$as_me: creating cache $cache_file" >&6;}
1391   >$cache_file
1392 fi
1393
1394 # Check that the precious variables saved in the cache have kept the same
1395 # value.
1396 ac_cache_corrupted=false
1397 for ac_var in `(set) 2>&1 |
1398                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1399   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1400   eval ac_new_set=\$ac_env_${ac_var}_set
1401   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1402   eval ac_new_val="\$ac_env_${ac_var}_value"
1403   case $ac_old_set,$ac_new_set in
1404     set,)
1405       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1406 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1407       ac_cache_corrupted=: ;;
1408     ,set)
1409       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1410 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1411       ac_cache_corrupted=: ;;
1412     ,);;
1413     *)
1414       if test "x$ac_old_val" != "x$ac_new_val"; then
1415         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1416 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1417         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1418 echo "$as_me:   former value:  $ac_old_val" >&2;}
1419         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1420 echo "$as_me:   current value: $ac_new_val" >&2;}
1421         ac_cache_corrupted=:
1422       fi;;
1423   esac
1424   # Pass precious variables to config.status.
1425   if test "$ac_new_set" = set; then
1426     case $ac_new_val in
1427     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1428       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1429     *) ac_arg=$ac_var=$ac_new_val ;;
1430     esac
1431     case " $ac_configure_args " in
1432       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1433       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1434     esac
1435   fi
1436 done
1437 if $ac_cache_corrupted; then
1438   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1439 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1440   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1441 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1442    { (exit 1); exit 1; }; }
1443 fi
1444
1445 ac_ext=c
1446 ac_cpp='$CPP $CPPFLAGS'
1447 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1448 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1449 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471 # Find the build, host, and target systems.
1472 ac_aux_dir=
1473 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1474   if test -f $ac_dir/install-sh; then
1475     ac_aux_dir=$ac_dir
1476     ac_install_sh="$ac_aux_dir/install-sh -c"
1477     break
1478   elif test -f $ac_dir/install.sh; then
1479     ac_aux_dir=$ac_dir
1480     ac_install_sh="$ac_aux_dir/install.sh -c"
1481     break
1482   elif test -f $ac_dir/shtool; then
1483     ac_aux_dir=$ac_dir
1484     ac_install_sh="$ac_aux_dir/shtool install -c"
1485     break
1486   fi
1487 done
1488 if test -z "$ac_aux_dir"; then
1489   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1490 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1491    { (exit 1); exit 1; }; }
1492 fi
1493 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1494 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1495 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1496
1497 # Make sure we can run config.sub.
1498 $ac_config_sub sun4 >/dev/null 2>&1 ||
1499   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1500 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1501    { (exit 1); exit 1; }; }
1502
1503 echo "$as_me:$LINENO: checking build system type" >&5
1504 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1505 if test "${ac_cv_build+set}" = set; then
1506   echo $ECHO_N "(cached) $ECHO_C" >&6
1507 else
1508   ac_cv_build_alias=$build_alias
1509 test -z "$ac_cv_build_alias" &&
1510   ac_cv_build_alias=`$ac_config_guess`
1511 test -z "$ac_cv_build_alias" &&
1512   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1513 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1514    { (exit 1); exit 1; }; }
1515 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1516   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1517 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1518    { (exit 1); exit 1; }; }
1519
1520 fi
1521 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1522 echo "${ECHO_T}$ac_cv_build" >&6
1523 build=$ac_cv_build
1524 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1525 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1526 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1527
1528
1529  case ${build_alias} in
1530   "") build_noncanonical=${build} ;;
1531   *) build_noncanonical=${build_alias} ;;
1532 esac
1533
1534
1535
1536  case ${host_alias} in
1537   "") host_noncanonical=${build_noncanonical} ;;
1538   *) host_noncanonical=${host_alias} ;;
1539 esac
1540
1541
1542
1543  case ${target_alias} in
1544   "") target_noncanonical=${host_noncanonical} ;;
1545   *) target_noncanonical=${target_alias} ;;
1546 esac
1547
1548
1549
1550
1551 test "$host_noncanonical" = "$target_noncanonical" &&
1552   test "$program_prefix$program_suffix$program_transform_name" = \
1553     NONENONEs,x,x, &&
1554   program_transform_name=s,y,y,
1555
1556 echo "$as_me:$LINENO: checking host system type" >&5
1557 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1558 if test "${ac_cv_host+set}" = set; then
1559   echo $ECHO_N "(cached) $ECHO_C" >&6
1560 else
1561   ac_cv_host_alias=$host_alias
1562 test -z "$ac_cv_host_alias" &&
1563   ac_cv_host_alias=$ac_cv_build_alias
1564 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1565   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1566 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1567    { (exit 1); exit 1; }; }
1568
1569 fi
1570 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1571 echo "${ECHO_T}$ac_cv_host" >&6
1572 host=$ac_cv_host
1573 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1574 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1575 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1576
1577
1578 echo "$as_me:$LINENO: checking target system type" >&5
1579 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1580 if test "${ac_cv_target+set}" = set; then
1581   echo $ECHO_N "(cached) $ECHO_C" >&6
1582 else
1583   ac_cv_target_alias=$target_alias
1584 test "x$ac_cv_target_alias" = "x" &&
1585   ac_cv_target_alias=$ac_cv_host_alias
1586 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1587   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1588 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1589    { (exit 1); exit 1; }; }
1590
1591 fi
1592 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1593 echo "${ECHO_T}$ac_cv_target" >&6
1594 target=$ac_cv_target
1595 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1596 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1597 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1598
1599
1600 # The aliases save the names the user supplied, while $host etc.
1601 # will get canonicalized.
1602 test -n "$target_alias" &&
1603   test "$program_prefix$program_suffix$program_transform_name" = \
1604     NONENONEs,x,x, &&
1605   program_prefix=${target_alias}-
1606 test "$program_prefix" != NONE &&
1607   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1608 # Use a double $ so make ignores it.
1609 test "$program_suffix" != NONE &&
1610   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1611 # Double any \ or $.  echo might interpret backslashes.
1612 # By default was `s,x,x', remove it if useless.
1613 cat <<\_ACEOF >conftest.sed
1614 s/[\\$]/&&/g;s/;s,x,x,$//
1615 _ACEOF
1616 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1617 rm conftest.sed
1618
1619
1620
1621 # Get 'install' or 'install-sh' and its variants.
1622 # Find a good install program.  We prefer a C program (faster),
1623 # so one script is as good as another.  But avoid the broken or
1624 # incompatible versions:
1625 # SysV /etc/install, /usr/sbin/install
1626 # SunOS /usr/etc/install
1627 # IRIX /sbin/install
1628 # AIX /bin/install
1629 # AmigaOS /C/install, which installs bootblocks on floppy discs
1630 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1631 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1632 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1633 # OS/2's system install, which has a completely different semantic
1634 # ./install, which can be erroneously created by make from ./install.sh.
1635 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1636 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1637 if test -z "$INSTALL"; then
1638 if test "${ac_cv_path_install+set}" = set; then
1639   echo $ECHO_N "(cached) $ECHO_C" >&6
1640 else
1641   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1642 for as_dir in $PATH
1643 do
1644   IFS=$as_save_IFS
1645   test -z "$as_dir" && as_dir=.
1646   # Account for people who put trailing slashes in PATH elements.
1647 case $as_dir/ in
1648   ./ | .// | /cC/* | \
1649   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1650   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1651   /usr/ucb/* ) ;;
1652   *)
1653     # OSF1 and SCO ODT 3.0 have their own names for install.
1654     # Don't use installbsd from OSF since it installs stuff as root
1655     # by default.
1656     for ac_prog in ginstall scoinst install; do
1657       for ac_exec_ext in '' $ac_executable_extensions; do
1658         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1659           if test $ac_prog = install &&
1660             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1661             # AIX install.  It has an incompatible calling convention.
1662             :
1663           elif test $ac_prog = install &&
1664             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1665             # program-specific install script used by HP pwplus--don't use.
1666             :
1667           else
1668             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1669             break 3
1670           fi
1671         fi
1672       done
1673     done
1674     ;;
1675 esac
1676 done
1677
1678
1679 fi
1680   if test "${ac_cv_path_install+set}" = set; then
1681     INSTALL=$ac_cv_path_install
1682   else
1683     # As a last resort, use the slow shell script.  We don't cache a
1684     # path for INSTALL within a source directory, because that will
1685     # break other packages using the cache if that directory is
1686     # removed, or if the path is relative.
1687     INSTALL=$ac_install_sh
1688   fi
1689 fi
1690 echo "$as_me:$LINENO: result: $INSTALL" >&5
1691 echo "${ECHO_T}$INSTALL" >&6
1692
1693 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1694 # It thinks the first close brace ends the variable substitution.
1695 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1696
1697 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1698
1699 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1700
1701 echo "$as_me:$LINENO: checking whether ln works" >&5
1702 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1703 if test "${acx_cv_prog_LN+set}" = set; then
1704   echo $ECHO_N "(cached) $ECHO_C" >&6
1705 else
1706   rm -f conftestdata_t
1707 echo >conftestdata_f
1708 if ln conftestdata_f conftestdata_t 2>/dev/null
1709 then
1710   acx_cv_prog_LN=ln
1711 else
1712   acx_cv_prog_LN=no
1713 fi
1714 rm -f conftestdata_f conftestdata_t
1715
1716 fi
1717 if test $acx_cv_prog_LN = no; then
1718   LN="cp"
1719   echo "$as_me:$LINENO: result: no, using $LN" >&5
1720 echo "${ECHO_T}no, using $LN" >&6
1721 else
1722   LN="$acx_cv_prog_LN"
1723   echo "$as_me:$LINENO: result: yes" >&5
1724 echo "${ECHO_T}yes" >&6
1725 fi
1726
1727 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1728 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1729 LN_S=$as_ln_s
1730 if test "$LN_S" = "ln -s"; then
1731   echo "$as_me:$LINENO: result: yes" >&5
1732 echo "${ECHO_T}yes" >&6
1733 else
1734   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1735 echo "${ECHO_T}no, using $LN_S" >&6
1736 fi
1737
1738
1739 ### we might need to use some other shell than /bin/sh for running subshells
1740 ### If we are on Windows, search for the shell.  This will permit people
1741 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1742 ### without also having to set CONFIG_SHELL.  This code will work when
1743 ### using bash, which sets OSTYPE.
1744 case "${OSTYPE}" in
1745 *win32*)
1746   if test x${CONFIG_SHELL} = x ; then
1747     if test ! -f /bin/sh ; then
1748       if test x${SHELL} != x && test -f ${SHELL} ; then
1749         CONFIG_SHELL=${SHELL}
1750         export CONFIG_SHELL
1751       else
1752         for prog in sh sh.exe bash bash.exe; do
1753           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1754           for dir in $PATH; do
1755             test -z "$dir" && dir=.
1756             if test -f $dir/$prog; then
1757               CONFIG_SHELL=$dir/$prog
1758               export CONFIG_SHELL
1759               break
1760             fi
1761           done
1762           IFS="$save_ifs"
1763           test -n "${CONFIG_SHELL}" && break
1764         done
1765       fi
1766     fi
1767   fi
1768   ;;
1769 esac
1770
1771 config_shell=${CONFIG_SHELL-/bin/sh}
1772
1773 progname=$0
1774 # if PWD already has a value, it is probably wrong.
1775 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1776
1777 # Export original configure arguments for use by sub-configures.
1778 # Quote arguments with shell meta charatcers.
1779 TOPLEVEL_CONFIGURE_ARGUMENTS=
1780 set -- "$progname" "$@"
1781 for ac_arg
1782 do
1783   case "$ac_arg" in
1784   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1785     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1786     # if the argument is of the form -foo=baz, quote the baz part only
1787     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1788   *) ;;
1789   esac
1790   # Add the quoted argument to the list.
1791   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1792 done
1793 if test "$silent" = yes; then
1794   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1795 fi
1796 # Remove the initial space we just introduced and, as these will be
1797 # expanded by make, quote '$'.
1798 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1799
1800
1801 moveifchange=${srcdir}/move-if-change
1802
1803 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1804
1805 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1806 # a relative path.
1807 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1808   INSTALL="${srcpwd}/install-sh -c"
1809 fi
1810
1811 # Set srcdir to "." if that's what it is.
1812 # This is important for multilib support.
1813 pwd=`${PWDCMD-pwd}`
1814 if test "${pwd}" = "${srcpwd}" ; then
1815   srcdir=.
1816 fi
1817
1818 topsrcdir=$srcpwd
1819
1820 extra_host_args=
1821
1822 ### To add a new directory to the tree, first choose whether it is a target
1823 ### or a host dependent tool.  Then put it into the appropriate list
1824 ### (library or tools, host or target), doing a dependency sort.
1825
1826 # Subdirs will be configured in the order listed in build_configdirs,
1827 # configdirs, or target_configdirs; see the serialization section below.
1828
1829 # Dependency sorting is only needed when *configuration* must be done in
1830 # a particular order.  In all cases a dependency should be specified in
1831 # the Makefile, whether or not it's implicitly specified here.
1832
1833 # Double entries in build_configdirs, configdirs, or target_configdirs may
1834 # cause circular dependencies and break everything horribly.
1835
1836 # these library is used by various programs built for the build
1837 # environment
1838 #
1839 build_libs="build-libiberty"
1840
1841 # these tools are built for the build environment
1842 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1843
1844 # these libraries are used by various programs built for the host environment
1845 #
1846 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1847
1848 # these tools are built for the host environment
1849 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1850 # know that we are building the simulator.
1851 # binutils, gas and ld appear in that order because it makes sense to run
1852 # "make check" in that particular order.
1853 host_tools="texinfo byacc flex bison binutils gas ld fixincludes gcc sid sim gdb make patch prms send-pr gprof etc expect dejagnu ash bash bzip2 m4 autoconf automake libtool diff rcs fileutils shellutils time textutils wdiff find uudecode hello tar gzip indent recode release sed utils guile perl gawk findutils gettext zip fastjar gnattools"
1854
1855 # libgcj represents the runtime libraries only used by gcj.
1856 libgcj="target-libffi \
1857         target-zlib \
1858         target-qthreads \
1859         target-libjava"
1860
1861 # these libraries are built for the target environment, and are built after
1862 # the host libraries and the host tools (which may be a cross compiler)
1863 #
1864 target_libraries="target-libgcc \
1865                 target-libiberty \
1866                 target-libgloss \
1867                 target-newlib \
1868                 target-libstdc++-v3 \
1869                 target-libmudflap \
1870                 target-libssp \
1871                 target-libgfortran \
1872                 target-boehm-gc \
1873                 ${libgcj} \
1874                 target-libobjc \
1875                 target-libada \
1876                 target-libgomp"
1877
1878 # these tools are built using the target libraries, and are intended to
1879 # run only in the target environment
1880 #
1881 # note: any program that *uses* libraries that are in the "target_libraries"
1882 # list belongs in this list.  those programs are also very likely
1883 # candidates for the "native_only" list which follows
1884 #
1885 target_tools="target-examples target-groff target-gperf target-rda"
1886
1887 ################################################################################
1888
1889 ## All tools belong in one of the four categories, and are assigned above
1890 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1891 ## is important because configure will choke if they ever get through.
1892 ## ${configdirs} is directories we build using the host tools.
1893 ## ${target_configdirs} is directories we build using the target tools.
1894 configdirs=`echo ${host_libs} ${host_tools}`
1895 target_configdirs=`echo ${target_libraries} ${target_tools}`
1896 build_configdirs=`echo ${build_libs} ${build_tools}`
1897
1898 ################################################################################
1899
1900 srcname="gnu development package"
1901
1902 # This gets set non-empty for some net releases of packages.
1903 appdirs=""
1904
1905 # Define is_cross_compiler to save on calls to 'test'.
1906 is_cross_compiler=
1907 if test x"${host}" = x"${target}" ; then
1908   is_cross_compiler=no
1909 else
1910   is_cross_compiler=yes
1911 fi
1912
1913 # Find the build and target subdir names.
1914
1915 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1916 # have matching libraries, they should use host libraries: Makefile.tpl
1917 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1918 # However, they still use the build modules, because the corresponding
1919 # host modules (e.g. bison) are only built for the host when bootstrap
1920 # finishes. So:
1921 # - build_subdir is where we find build modules, and never changes.
1922 # - build_libsubdir is where we find build libraries, and can be overridden.
1923
1924 # Prefix 'build-' so this never conflicts with target_subdir.
1925 build_subdir="build-${build_noncanonical}"
1926
1927 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1928 if test "${with_build_libsubdir+set}" = set; then
1929   withval="$with_build_libsubdir"
1930   build_libsubdir="$withval"
1931 else
1932   build_libsubdir="$build_subdir"
1933 fi;
1934 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1935 if ( test $srcdir = . && test -d gcc ) \
1936    || test -d $srcdir/../host-${host_noncanonical}; then
1937   host_subdir="host-${host_noncanonical}"
1938 else
1939   host_subdir=.
1940 fi
1941 # No prefix.
1942 target_subdir=${target_noncanonical}
1943
1944
1945 # Skipdirs are removed silently.
1946 skipdirs=
1947 # Noconfigdirs are removed loudly.
1948 noconfigdirs=""
1949
1950 use_gnu_ld=
1951 # Make sure we don't let GNU ld be added if we didn't want it.
1952 if test x$with_gnu_ld = xno ; then
1953   use_gnu_ld=no
1954   noconfigdirs="$noconfigdirs ld"
1955 fi
1956
1957 use_gnu_as=
1958 # Make sure we don't let GNU as be added if we didn't want it.
1959 if test x$with_gnu_as = xno ; then
1960   use_gnu_as=no
1961   noconfigdirs="$noconfigdirs gas"
1962 fi
1963
1964 # some tools are so dependent upon X11 that if we're not building with X,
1965 # it's not even worth trying to configure, much less build, that tool.
1966
1967 case ${with_x} in
1968   yes | "") ;; # the default value for this tree is that X11 is available
1969   no)
1970     skipdirs="${skipdirs} tk itcl libgui"
1971     # We won't be able to build gdbtk without X.
1972     enable_gdbtk=no
1973     ;;
1974   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1975 esac
1976
1977 # Some tools are only suitable for building in a "native" situation.
1978 # Remove these if host!=target.
1979 native_only="autoconf automake libtool fileutils find gawk gettext gzip hello indent m4 rcs recode sed shellutils tar textutils uudecode wdiff target-groff guile perl time ash bash bzip2 prms gnuserv target-gperf"
1980
1981 # Similarly, some are only suitable for cross toolchains.
1982 # Remove these if host=target.
1983 cross_only="target-libgloss target-newlib target-opcodes"
1984
1985 case $is_cross_compiler in
1986   no) skipdirs="${skipdirs} ${cross_only}" ;;
1987   yes) skipdirs="${skipdirs} ${native_only}" ;;
1988 esac
1989
1990 # If both --with-headers and --with-libs are specified, default to
1991 # --without-newlib.
1992 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
1993    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
1994   if test x"${with_newlib}" = x ; then
1995     with_newlib=no
1996   fi
1997 fi
1998
1999 # Recognize --with-newlib/--without-newlib.
2000 case ${with_newlib} in
2001   no) skipdirs="${skipdirs} target-newlib" ;;
2002   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2003 esac
2004
2005 # Configure extra directories which are host specific
2006
2007 case "${host}" in
2008   *-cygwin*)
2009     configdirs="$configdirs libtermcap" ;;
2010 esac
2011
2012 # A target can indicate whether a language isn't supported for some reason.
2013 # Only spaces may be used in this macro; not newlines or tabs.
2014 unsupported_languages=
2015
2016 # Remove more programs from consideration, based on the host or
2017 # target this usually means that a port of the program doesn't
2018 # exist yet.
2019
2020 case "${host}" in
2021   hppa*64*-*-*)
2022     noconfigdirs="$noconfigdirs byacc"
2023     ;;
2024   i[3456789]86-*-vsta)
2025     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2026     ;;
2027   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2028     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2029     ;;
2030   x86_64-*-mingw*)
2031     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2032     ;;
2033   i[3456789]86-*-mingw32*)
2034     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2035     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2036     ;;
2037   i[3456789]86-*-beos*)
2038     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2039     ;;
2040   *-*-cygwin*)
2041     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2042     ;;
2043   *-*-netbsd*)
2044     noconfigdirs="$noconfigdirs rcs"
2045     ;;
2046   ppc*-*-pe)
2047     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2048     ;;
2049   powerpc-*-beos*)
2050     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2051     ;;
2052 esac
2053
2054
2055 # Check whether --enable-libada or --disable-libada was given.
2056 if test "${enable_libada+set}" = set; then
2057   enableval="$enable_libada"
2058   ENABLE_LIBADA=$enableval
2059 else
2060   ENABLE_LIBADA=yes
2061 fi;
2062 if test "${ENABLE_LIBADA}" != "yes" ; then
2063   noconfigdirs="$noconfigdirs gnattools"
2064 fi
2065
2066 # Check whether --enable-libssp or --disable-libssp was given.
2067 if test "${enable_libssp+set}" = set; then
2068   enableval="$enable_libssp"
2069   ENABLE_LIBSSP=$enableval
2070 else
2071   ENABLE_LIBSSP=yes
2072 fi;
2073
2074 # Save it here so that, even in case of --enable-libgcj, if the Java
2075 # front-end isn't enabled, we still get libgcj disabled.
2076 libgcj_saved=$libgcj
2077 case $enable_libgcj in
2078 yes)
2079   # If we reset it here, it won't get added to noconfigdirs in the
2080   # target-specific build rules, so it will be forcibly enabled
2081   # (unless the Java language itself isn't enabled).
2082   libgcj=
2083   ;;
2084 no)
2085   # Make sure we get it printed in the list of not supported target libs.
2086   noconfigdirs="$noconfigdirs ${libgcj}"
2087   ;;
2088 esac
2089
2090
2091 # Disable libmudflap on some systems.
2092 if test x$enable_libmudflap = x ; then
2093     case "${target}" in
2094     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2095         # Enable libmudflap by default in GNU and friends.
2096         ;;
2097     *-*-freebsd*)
2098         # Enable libmudflap by default in FreeBSD.
2099         ;;
2100     *)
2101         # Disable it by default everywhere else.
2102         noconfigdirs="$noconfigdirs target-libmudflap"
2103         ;;
2104     esac
2105 fi
2106
2107 # Disable libgomp on non POSIX hosted systems.
2108 if test x$enable_libgomp = x ; then
2109     # Enable libgomp by default on hosted POSIX systems.
2110     case "${target}" in
2111     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2112         ;;
2113     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2114         ;;
2115     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2116         ;;
2117     *-*-darwin* | *-*-aix*)
2118         ;;
2119     *)
2120         noconfigdirs="$noconfigdirs target-libgomp"
2121         ;;
2122     esac
2123 fi
2124
2125 # Default libgloss CPU subdirectory.
2126 libgloss_dir="$target_cpu"
2127
2128 case "${target}" in
2129   *-*-chorusos)
2130     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2131     ;;
2132   powerpc-*-darwin* | i[3456789]86-*-darwin*)
2133     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2134     noconfigdirs="$noconfigdirs sim target-rda"
2135     ;;
2136   *-*-darwin*)
2137     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2138     noconfigdirs="$noconfigdirs sim target-rda"
2139     noconfigdirs="$noconfigdirs ${libgcj}"
2140     ;;
2141   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2142     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2143     ;;
2144   *-*-freebsd*)
2145     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2146     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2147         && test -f /usr/local/include/gmp.h; then
2148       with_gmp=/usr/local
2149     fi
2150
2151     # Skip some stuff that's unsupported on some FreeBSD configurations.
2152     case "${target}" in
2153       i*86-*-*) ;;
2154       alpha*-*-*) ;;
2155       *)
2156         noconfigdirs="$noconfigdirs ${libgcj}"
2157         ;;
2158     esac
2159     ;;
2160   *-*-kaos*)
2161     # Remove unsupported stuff on all kaOS configurations.
2162     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2163     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2164     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2165     noconfigdirs="$noconfigdirs target-libgloss"
2166     ;;
2167   *-*-netbsd*)
2168     # Skip some stuff on all NetBSD configurations.
2169     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2170
2171     # Skip some stuff that's unsupported on some NetBSD configurations.
2172     case "${target}" in
2173       i*86-*-netbsdelf*) ;;
2174       arm*-*-netbsdelf*) ;;
2175       *)
2176         noconfigdirs="$noconfigdirs ${libgcj}"
2177         ;;
2178     esac
2179     ;;
2180   *-*-netware*)
2181     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2182     ;;
2183   *-*-rtems*)
2184     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2185     ;;
2186     # The tpf target doesn't support gdb yet.
2187   *-*-tpf*)
2188     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2189     ;;
2190   *-*-uclinux*)
2191     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2192     ;;
2193   *-*-vxworks*)
2194     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2195     ;;
2196   alpha*-dec-osf*)
2197     # ld works, but does not support shared libraries.
2198     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2199     # gas doesn't generate exception information.
2200     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2201     ;;
2202   alpha*-*-*vms*)
2203     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2204     ;;
2205   alpha*-*-linux*)
2206     # newlib is not 64 bit ready
2207     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2208     ;;
2209   alpha*-*-*)
2210     # newlib is not 64 bit ready
2211     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2212     ;;
2213   am33_2.0-*-linux*)
2214     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2215     ;;
2216   sh-*-linux*)
2217     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2218     ;;
2219   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2220     noconfigdirs="$noconfigdirs ${libgcj}"
2221     noconfigdirs="$noconfigdirs target-examples"
2222     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2223     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2224     noconfigdirs="$noconfigdirs expect dejagnu"
2225     # the C++ libraries don't build on top of CE's C libraries
2226     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2227     noconfigdirs="$noconfigdirs target-newlib"
2228     case "${host}" in
2229       *-*-cygwin*) ;; # keep gdb and readline
2230       *) noconfigdirs="$noconfigdirs gdb readline"
2231          ;;
2232     esac
2233     libgloss_dir=wince
2234     ;;
2235   arc-*-*)
2236     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2237     ;;
2238   arm-semi-aof )
2239     ;;
2240   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2241     noconfigdirs="$noconfigdirs ${libgcj}"
2242     libgloss_dir=arm
2243     ;;
2244   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2245     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2246     libgloss_dir=arm
2247     ;;
2248   arm*-*-linux-gnueabi)
2249     noconfigdirs="$noconfigdirs target-qthreads"
2250     noconfigdirs="$noconfigdirs target-libobjc"
2251     case ${with_newlib} in
2252       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2253     esac
2254     libgloss_dir=arm
2255     ;;
2256   arm*-*-symbianelf*)
2257     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2258     libgloss_dir=arm
2259     ;;
2260   arm-*-pe*)
2261     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2262     ;;
2263   thumb-*-coff)
2264     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2265     ;;
2266   thumb-*-elf)
2267     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2268     ;;
2269   thumb-*-pe)
2270     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2271     ;;
2272   arm-*-riscix*)
2273     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2274     ;;
2275   avr-*-*)
2276     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2277     ;;
2278   bfin-*-*)
2279     noconfigdirs="$noconfigdirs gdb"
2280     if test x${is_cross_compiler} != xno ; then
2281       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2282     fi
2283     ;;
2284   c4x-*-* | tic4x-*-*)
2285     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2286     ;;
2287   c54x*-*-* | tic54x-*-*)
2288     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2289     ;;
2290   cris-*-* | crisv32-*-*)
2291     unsupported_languages="$unsupported_languages java"
2292     case "${target}" in
2293       *-*-aout)
2294         unsupported_languages="$unsupported_languages fortran"
2295         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2296       *-*-elf)
2297         unsupported_languages="$unsupported_languages fortran"
2298         noconfigdirs="$noconfigdirs target-boehm-gc";;
2299       *-*-linux*)
2300         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2301       *)
2302         unsupported_languages="$unsupported_languages fortran"
2303         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2304     esac
2305     libgloss_dir=cris
2306     ;;
2307   crx-*-*)
2308     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2309     ;;
2310   d10v-*-*)
2311     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2312     ;;
2313   d30v-*-*)
2314     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2315     ;;
2316   ep9312-*-elf | ep9312-*-coff)
2317     libgloss_dir=arm
2318     ;;
2319   fr30-*-elf*)
2320     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2321     ;;
2322   frv-*-*)
2323     noconfigdirs="$noconfigdirs ${libgcj}"
2324     ;;
2325   h8300*-*-*)
2326     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2327     ;;
2328   h8500-*-*)
2329     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2330     ;;
2331   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2332     ;;
2333   hppa*64*-*-linux* | parisc*64*-*-linux*)
2334     # In this case, it's because the hppa64-linux target is for
2335     # the kernel only at this point and has no libc, and thus no
2336     # headers, crt*.o, etc., all of which are needed by these.
2337     noconfigdirs="$noconfigdirs target-zlib"
2338     ;;
2339   parisc*-*-linux* | hppa*-*-linux*)
2340     ;;
2341   hppa*-*-*elf* | \
2342   hppa*-*-lites* | \
2343   hppa*-*-openbsd* | \
2344   hppa*64*-*-*)
2345     noconfigdirs="$noconfigdirs ${libgcj}"
2346     ;;
2347   hppa*-hp-hpux11*)
2348     noconfigdirs="$noconfigdirs ld shellutils"
2349     ;;
2350   hppa*-*-pro*)
2351     libgloss_dir=pa
2352     ;;
2353   hppa*-*-*)
2354     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2355     # build on HP-UX 10.20.
2356     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2357     ;;
2358   i960-*-*)
2359     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2360     ;;
2361   ia64*-*-elf*)
2362     # No gdb support yet.
2363     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2364     ;;
2365   ia64*-**-hpux*)
2366     # No gdb or ld support yet.
2367     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2368     ;;
2369   i370-*-opened*)
2370     ;;
2371   i[3456789]86-*-coff | i[3456789]86-*-elf)
2372     noconfigdirs="$noconfigdirs ${libgcj}"
2373     libgloss_dir=i386
2374     ;;
2375   i[3456789]86-*-linux*)
2376     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2377     # not build java stuff by default.
2378     case "${target}" in
2379       *-*-*libc1*)
2380         noconfigdirs="$noconfigdirs ${libgcj}";;
2381     esac
2382
2383     # This section makes it possible to build newlib natively on linux.
2384     # If we are using a cross compiler then don't configure newlib.
2385     if test x${is_cross_compiler} != xno ; then
2386       noconfigdirs="$noconfigdirs target-newlib"
2387     fi
2388     noconfigdirs="$noconfigdirs target-libgloss"
2389     # If we are not using a cross compiler, do configure newlib.
2390     # Note however, that newlib will only be configured in this situation
2391     # if the --with-newlib option has been given, because otherwise
2392     # 'target-newlib' will appear in skipdirs.
2393     ;;
2394   i[3456789]86-*-mingw32*)
2395     target_configdirs="$target_configdirs target-winsup"
2396     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2397     ;;
2398   x86_64-*-mingw*)
2399     target_configdirs="$target_configdirs target-winsup"
2400     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2401     ;;
2402   *-*-cygwin*)
2403     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2404     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2405     # always build newlib if winsup directory is present.
2406     if test -d "$srcdir/winsup/cygwin"; then
2407       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2408     elif test -d "$srcdir/newlib"; then
2409       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2410     fi
2411     ;;
2412   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2413   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2414     ;;
2415   i[3456789]86-*-pe)
2416     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2417     ;;
2418   i[3456789]86-*-sco3.2v5*)
2419     # The linker does not yet know about weak symbols in COFF,
2420     # and is not configured to handle mixed ELF and COFF.
2421     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2422     ;;
2423   i[3456789]86-*-sco*)
2424     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2425     ;;
2426   i[3456789]86-*-solaris2*)
2427     noconfigdirs="$noconfigdirs target-libgloss"
2428     ;;
2429   i[3456789]86-*-sysv4*)
2430     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2431     ;;
2432   i[3456789]86-*-beos*)
2433     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2434     ;;
2435   i[3456789]86-*-rdos*)
2436     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2437     ;;
2438   m32r-*-*)
2439     noconfigdirs="$noconfigdirs ${libgcj}"
2440     ;;
2441   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2442     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2443     libgloss_dir=m68hc11
2444     ;;
2445   m68k-*-elf*)
2446     noconfigdirs="$noconfigdirs ${libgcj}"
2447     ;;
2448   m68k-*-coff*)
2449     noconfigdirs="$noconfigdirs ${libgcj}"
2450     ;;
2451   m68*-*-* | fido-*-*)
2452     libgloss_dir=m68k
2453     ;;
2454   mcore-*-pe*)
2455   # The EPOC C++ environment does not support exceptions or rtti,
2456   # and so building libstdc++-v3 tends not to always work.
2457     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2458     ;;
2459   mmix-*-*)
2460     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2461     unsupported_languages="$unsupported_languages fortran java"
2462     ;;
2463   mn10200-*-*)
2464     noconfigdirs="$noconfigdirs ${libgcj}"
2465     ;;
2466   mn10300-*-*)
2467     noconfigdirs="$noconfigdirs ${libgcj}"
2468     ;;
2469   mt-*-*)
2470     noconfigdirs="$noconfigdirs sim"
2471     ;;
2472   powerpc-*-aix*)
2473     # copied from rs6000-*-* entry
2474     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2475     ;;
2476   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2477     target_configdirs="$target_configdirs target-winsup"
2478     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2479     # always build newlib.
2480     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2481     ;;
2482     # This is temporary until we can link against shared libraries
2483   powerpcle-*-solaris*)
2484     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2485     libgloss_dir=rs6000
2486     ;;
2487   powerpc-*-beos*)
2488     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2489     ;;
2490   powerpc-*-eabi)
2491     noconfigdirs="$noconfigdirs ${libgcj}"
2492     libgloss_dir=rs6000
2493     ;;
2494   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2495     libgloss_dir=rs6000
2496     ;;
2497   rs6000-*-lynxos*)
2498     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2499     ;;
2500   rs6000-*-aix*)
2501     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2502     ;;
2503   rs6000-*-*)
2504     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2505     ;;
2506   m68k-apollo-*)
2507     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2508     ;;
2509   mips*-*-irix5*)
2510     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2511     ;;
2512   mips*-*-irix6*)
2513     # Linking libjava exceeds command-line length limits on at least
2514     # IRIX 6.2, but not on IRIX 6.5.
2515     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2516     # <oldham@codesourcery.com>
2517     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2518     ;;
2519   mips*-*-bsd*)
2520     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2521     ;;
2522   mips*-*-linux*)
2523     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2524     ;;
2525   mips*-*-*)
2526     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2527     libgloss_dir=mips
2528     ;;
2529   romp-*-*)
2530     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2531     ;;
2532   sh-*-* | sh64-*-*)
2533     case "${host}" in
2534       i[3456789]86-*-vsta) ;; # don't add gprof back in
2535       i[3456789]86-*-go32*) ;; # don't add gprof back in
2536       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2537       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2538     esac
2539     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2540     ;;
2541   sparclet-*-aout* | sparc86x-*-*)
2542     libgloss_dir=sparc
2543     ;;
2544   sparc-*-elf*)
2545     noconfigdirs="$noconfigdirs ${libgcj}"
2546     ;;
2547   sparc64-*-elf*)
2548     noconfigdirs="$noconfigdirs ${libgcj}"
2549     libgloss_dir=sparc
2550     ;;
2551   sparclite-*-*)
2552     noconfigdirs="$noconfigdirs ${libgcj}"
2553     libgloss_dir=sparc
2554     ;;
2555   sparc-*-sunos4*)
2556     noconfigdirs="$noconfigdirs ${libgcj}"
2557     if test x${is_cross_compiler} != xno ; then
2558            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2559     else
2560            use_gnu_ld=no
2561     fi
2562     ;;
2563   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2564     noconfigdirs="$noconfigdirs ${libgcj}"
2565     ;;
2566   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2567     ;;
2568   spu-*-*)
2569     skipdirs="target-libssp"
2570     ;;
2571   v810-*-*)
2572     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2573     ;;
2574   v850-*-*)
2575     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2576     ;;
2577   v850e-*-*)
2578     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2579     ;;
2580   v850ea-*-*)
2581     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2582     ;;
2583   vax-*-vms)
2584     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2585     ;;
2586   vax-*-*)
2587     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2588     ;;
2589   xtensa-*-*)
2590     noconfigdirs="$noconfigdirs ${libgcj}"
2591     ;;
2592   ip2k-*-*)
2593     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2594     ;;
2595   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2596     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2597     ;;
2598   *-*-lynxos*)
2599     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2600     ;;
2601   *-*-*)
2602     noconfigdirs="$noconfigdirs ${libgcj}"
2603     ;;
2604 esac
2605
2606 # If we aren't building newlib, then don't build libgloss, since libgloss
2607 # depends upon some newlib header files.
2608 case "${noconfigdirs}" in
2609   *target-libgloss*) ;;
2610   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2611 esac
2612
2613 # Work in distributions that contain no compiler tools, like Autoconf.
2614 tentative_cc=""
2615 host_makefile_frag=/dev/null
2616 if test -d ${srcdir}/config ; then
2617 case "${host}" in
2618   m68k-hp-hpux*)
2619     # Avoid "too much defining" errors from HPUX compiler.
2620     tentative_cc="cc -Wp,-H256000"
2621     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2622     # If it's HP/UX ar, this should be harmless.
2623     RANLIB="ar ts"
2624     ;;
2625   m68k-apollo-sysv*)
2626     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2627     ;;
2628   m68k-apollo-bsd*)
2629     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2630     # chokes on bfd, the compiler won't let you assign integers to enums, and
2631     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2632     # the apollo compiler" (the preferred version of GCC could be called cc,
2633     # or whatever), but I'm not sure leaving CC as cc is any better...
2634     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2635     # Used to have BISON=yacc.
2636     tentative_cc=gcc
2637     ;;
2638   m88k-dg-dgux*)
2639     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2640     ;;
2641   m88k-harris-cxux*)
2642     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2643     tentative_cc="cc -Xa"
2644     host_makefile_frag="config/mh-cxux"
2645     ;;
2646   m88k-motorola-sysv*)
2647     ;;
2648   mips*-dec-ultrix*)
2649     tentative_cc="cc -Wf,-XNg1000"
2650     host_makefile_frag="config/mh-decstation"
2651     ;;
2652   mips*-nec-sysv4*)
2653     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2654     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2655     host_makefile_frag="config/mh-necv4"
2656     ;;
2657   mips*-sgi-irix4*)
2658     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2659     # environment.  Also bump switch table size so that cp-parse will
2660     # compile.  Bump string length limit so linker builds.
2661     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2662     ;;
2663   mips*-*-sysv4*)
2664     host_makefile_frag="config/mh-sysv4"
2665     ;;
2666   mips*-*-sysv*)
2667     # This is for a MIPS running RISC/os 4.52C.
2668
2669     # This is needed for GDB, but needs to be in the top-level make because
2670     # if a library is compiled with the bsd headers and gets linked with the
2671     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2672     # a different size).
2673     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2674     # known except to select the sysv environment.  Could we use /proc instead?
2675     # These "sysv environments" and "bsd environments" often end up being a pain.
2676     #
2677     # This is not part of CFLAGS because perhaps not all C compilers have this
2678     # option.
2679     tentative_cc="cc -systype sysv"
2680     ;;
2681   i370-ibm-opened*)
2682     tentative_cc="c89"
2683     ;;
2684   i[3456789]86-*-sysv5*)
2685     host_makefile_frag="config/mh-sysv5"
2686     ;;
2687   i[3456789]86-*-dgux*)
2688     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2689     host_makefile_frag="config/mh-dgux386"
2690     ;;
2691   i[3456789]86-ncr-sysv4.3*)
2692     # The MetaWare compiler will generate a copyright message unless you
2693     # turn it off by adding the -Hnocopyr flag.
2694     tentative_cc="cc -Hnocopyr"
2695     ;;
2696   i[3456789]86-ncr-sysv4*)
2697     # for an NCR 3000 (i486/SVR4) system.
2698     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2699     # This compiler not only emits obnoxious copyright messages every time
2700     # you run it, but it chokes and dies on a whole bunch of GNU source
2701     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2702     tentative_cc="/usr/ccs/ATT/cc"
2703     host_makefile_frag="config/mh-ncr3000"
2704     ;;
2705   i[3456789]86-*-sco3.2v5*)
2706     ;;
2707   i[3456789]86-*-sco*)
2708     # The native C compiler botches some simple uses of const.  Unfortunately,
2709     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2710     tentative_cc="cc -Dconst="
2711     host_makefile_frag="config/mh-sco"
2712     ;;
2713   i[3456789]86-*-udk*)
2714     host_makefile_frag="config/mh-sysv5"
2715     ;;
2716   i[3456789]86-*-solaris2*)
2717     host_makefile_frag="config/mh-sysv4"
2718     ;;
2719   i[3456789]86-*-msdosdjgpp*)
2720     host_makefile_frag="config/mh-djgpp"
2721     ;;
2722   *-cygwin*)
2723     host_makefile_frag="config/mh-cygwin"
2724     ;;
2725   *-mingw32*)
2726     host_makefile_frag="config/mh-mingw"
2727     ;;
2728   *-mingw64*)
2729     host_makefile_frag="config/mh-mingw"
2730     ;;
2731   *-interix*)
2732     host_makefile_frag="config/mh-interix"
2733     ;;
2734   vax-*-ultrix2*)
2735     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2736     tentative_cc=gcc
2737     ;;
2738   *-*-solaris2*)
2739     host_makefile_frag="config/mh-solaris"
2740     ;;
2741   m68k-sun-sunos*)
2742     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2743     # without overflowing the jump tables (-J says to use a 32 bit table)
2744     tentative_cc="cc -J"
2745     ;;
2746   *-hp-hpux*)
2747     tentative_cc="cc -Wp,-H256000"
2748     ;;
2749   *-*-hiux*)
2750     tentative_cc="cc -Wp,-H256000"
2751     ;;
2752   rs6000-*-lynxos*)
2753     # /bin/cc is less than useful for our purposes.  Always use GCC
2754     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2755     host_makefile_frag="config/mh-lynxrs6k"
2756     ;;
2757   powerpc-*-darwin*)
2758     host_makefile_frag="config/mh-ppc-darwin"
2759     ;;
2760   powerpc-*-aix*)
2761     host_makefile_frag="config/mh-ppc-aix"
2762     ;;
2763   rs6000-*-aix*)
2764     host_makefile_frag="config/mh-ppc-aix"
2765     ;;
2766   *-*-lynxos*)
2767     # /bin/cc is less than useful for our purposes.  Always use GCC
2768     tentative_cc="/bin/gcc"
2769     ;;
2770   *-*-sysv4*)
2771     host_makefile_frag="config/mh-sysv4"
2772     ;;
2773   # This is placed last to prevent interfering with the cases above.
2774   i[3456789]86-*-*)
2775     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2776     host_makefile_frag="config/mh-x86omitfp"
2777     ;;
2778 esac
2779 fi
2780
2781 # If we aren't going to be using gcc, see if we can extract a definition
2782 # of CC from the fragment.
2783 # Actually, use the 'pre-extracted' version above.
2784 if test -z "${CC}" && test "${build}" = "${host}" ; then
2785   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2786   found=
2787   for dir in $PATH; do
2788     test -z "$dir" && dir=.
2789     if test -f $dir/gcc; then
2790       found=yes
2791       break
2792     fi
2793   done
2794   IFS="$save_ifs"
2795   if test -z "${found}" && test -n "${tentative_cc}" ; then
2796     CC=$tentative_cc
2797   fi
2798 fi
2799
2800 if test "${build}" != "${host}" ; then
2801   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2802 else
2803   CC_FOR_BUILD="\$(CC)"
2804 fi
2805
2806 ac_ext=c
2807 ac_cpp='$CPP $CPPFLAGS'
2808 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2809 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2810 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2811 if test -n "$ac_tool_prefix"; then
2812   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2813 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2814 echo "$as_me:$LINENO: checking for $ac_word" >&5
2815 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2816 if test "${ac_cv_prog_CC+set}" = set; then
2817   echo $ECHO_N "(cached) $ECHO_C" >&6
2818 else
2819   if test -n "$CC"; then
2820   ac_cv_prog_CC="$CC" # Let the user override the test.
2821 else
2822 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2823 for as_dir in $PATH
2824 do
2825   IFS=$as_save_IFS
2826   test -z "$as_dir" && as_dir=.
2827   for ac_exec_ext in '' $ac_executable_extensions; do
2828   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2829     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2830     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2831     break 2
2832   fi
2833 done
2834 done
2835
2836 fi
2837 fi
2838 CC=$ac_cv_prog_CC
2839 if test -n "$CC"; then
2840   echo "$as_me:$LINENO: result: $CC" >&5
2841 echo "${ECHO_T}$CC" >&6
2842 else
2843   echo "$as_me:$LINENO: result: no" >&5
2844 echo "${ECHO_T}no" >&6
2845 fi
2846
2847 fi
2848 if test -z "$ac_cv_prog_CC"; then
2849   ac_ct_CC=$CC
2850   # Extract the first word of "gcc", so it can be a program name with args.
2851 set dummy gcc; ac_word=$2
2852 echo "$as_me:$LINENO: checking for $ac_word" >&5
2853 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2854 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2855   echo $ECHO_N "(cached) $ECHO_C" >&6
2856 else
2857   if test -n "$ac_ct_CC"; then
2858   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2859 else
2860 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2861 for as_dir in $PATH
2862 do
2863   IFS=$as_save_IFS
2864   test -z "$as_dir" && as_dir=.
2865   for ac_exec_ext in '' $ac_executable_extensions; do
2866   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2867     ac_cv_prog_ac_ct_CC="gcc"
2868     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2869     break 2
2870   fi
2871 done
2872 done
2873
2874 fi
2875 fi
2876 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2877 if test -n "$ac_ct_CC"; then
2878   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2879 echo "${ECHO_T}$ac_ct_CC" >&6
2880 else
2881   echo "$as_me:$LINENO: result: no" >&5
2882 echo "${ECHO_T}no" >&6
2883 fi
2884
2885   CC=$ac_ct_CC
2886 else
2887   CC="$ac_cv_prog_CC"
2888 fi
2889
2890 if test -z "$CC"; then
2891   if test -n "$ac_tool_prefix"; then
2892   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2893 set dummy ${ac_tool_prefix}cc; ac_word=$2
2894 echo "$as_me:$LINENO: checking for $ac_word" >&5
2895 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2896 if test "${ac_cv_prog_CC+set}" = set; then
2897   echo $ECHO_N "(cached) $ECHO_C" >&6
2898 else
2899   if test -n "$CC"; then
2900   ac_cv_prog_CC="$CC" # Let the user override the test.
2901 else
2902 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2903 for as_dir in $PATH
2904 do
2905   IFS=$as_save_IFS
2906   test -z "$as_dir" && as_dir=.
2907   for ac_exec_ext in '' $ac_executable_extensions; do
2908   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2909     ac_cv_prog_CC="${ac_tool_prefix}cc"
2910     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2911     break 2
2912   fi
2913 done
2914 done
2915
2916 fi
2917 fi
2918 CC=$ac_cv_prog_CC
2919 if test -n "$CC"; then
2920   echo "$as_me:$LINENO: result: $CC" >&5
2921 echo "${ECHO_T}$CC" >&6
2922 else
2923   echo "$as_me:$LINENO: result: no" >&5
2924 echo "${ECHO_T}no" >&6
2925 fi
2926
2927 fi
2928 if test -z "$ac_cv_prog_CC"; then
2929   ac_ct_CC=$CC
2930   # Extract the first word of "cc", so it can be a program name with args.
2931 set dummy cc; ac_word=$2
2932 echo "$as_me:$LINENO: checking for $ac_word" >&5
2933 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2934 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2935   echo $ECHO_N "(cached) $ECHO_C" >&6
2936 else
2937   if test -n "$ac_ct_CC"; then
2938   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2939 else
2940 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2941 for as_dir in $PATH
2942 do
2943   IFS=$as_save_IFS
2944   test -z "$as_dir" && as_dir=.
2945   for ac_exec_ext in '' $ac_executable_extensions; do
2946   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2947     ac_cv_prog_ac_ct_CC="cc"
2948     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2949     break 2
2950   fi
2951 done
2952 done
2953
2954 fi
2955 fi
2956 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2957 if test -n "$ac_ct_CC"; then
2958   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2959 echo "${ECHO_T}$ac_ct_CC" >&6
2960 else
2961   echo "$as_me:$LINENO: result: no" >&5
2962 echo "${ECHO_T}no" >&6
2963 fi
2964
2965   CC=$ac_ct_CC
2966 else
2967   CC="$ac_cv_prog_CC"
2968 fi
2969
2970 fi
2971 if test -z "$CC"; then
2972   # Extract the first word of "cc", so it can be a program name with args.
2973 set dummy cc; ac_word=$2
2974 echo "$as_me:$LINENO: checking for $ac_word" >&5
2975 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2976 if test "${ac_cv_prog_CC+set}" = set; then
2977   echo $ECHO_N "(cached) $ECHO_C" >&6
2978 else
2979   if test -n "$CC"; then
2980   ac_cv_prog_CC="$CC" # Let the user override the test.
2981 else
2982   ac_prog_rejected=no
2983 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2984 for as_dir in $PATH
2985 do
2986   IFS=$as_save_IFS
2987   test -z "$as_dir" && as_dir=.
2988   for ac_exec_ext in '' $ac_executable_extensions; do
2989   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2990     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2991        ac_prog_rejected=yes
2992        continue
2993      fi
2994     ac_cv_prog_CC="cc"
2995     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2996     break 2
2997   fi
2998 done
2999 done
3000
3001 if test $ac_prog_rejected = yes; then
3002   # We found a bogon in the path, so make sure we never use it.
3003   set dummy $ac_cv_prog_CC
3004   shift
3005   if test $# != 0; then
3006     # We chose a different compiler from the bogus one.
3007     # However, it has the same basename, so the bogon will be chosen
3008     # first if we set CC to just the basename; use the full file name.
3009     shift
3010     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3011   fi
3012 fi
3013 fi
3014 fi
3015 CC=$ac_cv_prog_CC
3016 if test -n "$CC"; then
3017   echo "$as_me:$LINENO: result: $CC" >&5
3018 echo "${ECHO_T}$CC" >&6
3019 else
3020   echo "$as_me:$LINENO: result: no" >&5
3021 echo "${ECHO_T}no" >&6
3022 fi
3023
3024 fi
3025 if test -z "$CC"; then
3026   if test -n "$ac_tool_prefix"; then
3027   for ac_prog in cl
3028   do
3029     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3030 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3031 echo "$as_me:$LINENO: checking for $ac_word" >&5
3032 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3033 if test "${ac_cv_prog_CC+set}" = set; then
3034   echo $ECHO_N "(cached) $ECHO_C" >&6
3035 else
3036   if test -n "$CC"; then
3037   ac_cv_prog_CC="$CC" # Let the user override the test.
3038 else
3039 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3040 for as_dir in $PATH
3041 do
3042   IFS=$as_save_IFS
3043   test -z "$as_dir" && as_dir=.
3044   for ac_exec_ext in '' $ac_executable_extensions; do
3045   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3046     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3047     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3048     break 2
3049   fi
3050 done
3051 done
3052
3053 fi
3054 fi
3055 CC=$ac_cv_prog_CC
3056 if test -n "$CC"; then
3057   echo "$as_me:$LINENO: result: $CC" >&5
3058 echo "${ECHO_T}$CC" >&6
3059 else
3060   echo "$as_me:$LINENO: result: no" >&5
3061 echo "${ECHO_T}no" >&6
3062 fi
3063
3064     test -n "$CC" && break
3065   done
3066 fi
3067 if test -z "$CC"; then
3068   ac_ct_CC=$CC
3069   for ac_prog in cl
3070 do
3071   # Extract the first word of "$ac_prog", so it can be a program name with args.
3072 set dummy $ac_prog; ac_word=$2
3073 echo "$as_me:$LINENO: checking for $ac_word" >&5
3074 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3075 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3076   echo $ECHO_N "(cached) $ECHO_C" >&6
3077 else
3078   if test -n "$ac_ct_CC"; then
3079   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3080 else
3081 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3082 for as_dir in $PATH
3083 do
3084   IFS=$as_save_IFS
3085   test -z "$as_dir" && as_dir=.
3086   for ac_exec_ext in '' $ac_executable_extensions; do
3087   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3088     ac_cv_prog_ac_ct_CC="$ac_prog"
3089     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3090     break 2
3091   fi
3092 done
3093 done
3094
3095 fi
3096 fi
3097 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3098 if test -n "$ac_ct_CC"; then
3099   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3100 echo "${ECHO_T}$ac_ct_CC" >&6
3101 else
3102   echo "$as_me:$LINENO: result: no" >&5
3103 echo "${ECHO_T}no" >&6
3104 fi
3105
3106   test -n "$ac_ct_CC" && break
3107 done
3108
3109   CC=$ac_ct_CC
3110 fi
3111
3112 fi
3113
3114
3115 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3116 See \`config.log' for more details." >&5
3117 echo "$as_me: error: no acceptable C compiler found in \$PATH
3118 See \`config.log' for more details." >&2;}
3119    { (exit 1); exit 1; }; }
3120
3121 # Provide some information about the compiler.
3122 echo "$as_me:$LINENO:" \
3123      "checking for C compiler version" >&5
3124 ac_compiler=`set X $ac_compile; echo $2`
3125 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3126   (eval $ac_compiler --version </dev/null >&5) 2>&5
3127   ac_status=$?
3128   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3129   (exit $ac_status); }
3130 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3131   (eval $ac_compiler -v </dev/null >&5) 2>&5
3132   ac_status=$?
3133   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3134   (exit $ac_status); }
3135 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3136   (eval $ac_compiler -V </dev/null >&5) 2>&5
3137   ac_status=$?
3138   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3139   (exit $ac_status); }
3140
3141 cat >conftest.$ac_ext <<_ACEOF
3142 /* confdefs.h.  */
3143 _ACEOF
3144 cat confdefs.h >>conftest.$ac_ext
3145 cat >>conftest.$ac_ext <<_ACEOF
3146 /* end confdefs.h.  */
3147
3148 int
3149 main ()
3150 {
3151
3152   ;
3153   return 0;
3154 }
3155 _ACEOF
3156 ac_clean_files_save=$ac_clean_files
3157 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3158 # Try to create an executable without -o first, disregard a.out.
3159 # It will help us diagnose broken compilers, and finding out an intuition
3160 # of exeext.
3161 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3162 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3163 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3164 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3165   (eval $ac_link_default) 2>&5
3166   ac_status=$?
3167   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3168   (exit $ac_status); }; then
3169   # Find the output, starting from the most likely.  This scheme is
3170 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3171 # resort.
3172
3173 # Be careful to initialize this variable, since it used to be cached.
3174 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3175 ac_cv_exeext=
3176 # b.out is created by i960 compilers.
3177 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3178 do
3179   test -f "$ac_file" || continue
3180   case $ac_file in
3181     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3182         ;;
3183     conftest.$ac_ext )
3184         # This is the source file.
3185         ;;
3186     [ab].out )
3187         # We found the default executable, but exeext='' is most
3188         # certainly right.
3189         break;;
3190     *.* )
3191         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3192         # FIXME: I believe we export ac_cv_exeext for Libtool,
3193         # but it would be cool to find out if it's true.  Does anybody
3194         # maintain Libtool? --akim.
3195         export ac_cv_exeext
3196         break;;
3197     * )
3198         break;;
3199   esac
3200 done
3201 else
3202   echo "$as_me: failed program was:" >&5
3203 sed 's/^/| /' conftest.$ac_ext >&5
3204
3205 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3206 See \`config.log' for more details." >&5
3207 echo "$as_me: error: C compiler cannot create executables
3208 See \`config.log' for more details." >&2;}
3209    { (exit 77); exit 77; }; }
3210 fi
3211
3212 ac_exeext=$ac_cv_exeext
3213 echo "$as_me:$LINENO: result: $ac_file" >&5
3214 echo "${ECHO_T}$ac_file" >&6
3215
3216 # Check the compiler produces executables we can run.  If not, either
3217 # the compiler is broken, or we cross compile.
3218 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3219 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3220 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3221 # If not cross compiling, check that we can run a simple program.
3222 if test "$cross_compiling" != yes; then
3223   if { ac_try='./$ac_file'
3224   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3225   (eval $ac_try) 2>&5
3226   ac_status=$?
3227   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3228   (exit $ac_status); }; }; then
3229     cross_compiling=no
3230   else
3231     if test "$cross_compiling" = maybe; then
3232         cross_compiling=yes
3233     else
3234         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3235 If you meant to cross compile, use \`--host'.
3236 See \`config.log' for more details." >&5
3237 echo "$as_me: error: cannot run C compiled programs.
3238 If you meant to cross compile, use \`--host'.
3239 See \`config.log' for more details." >&2;}
3240    { (exit 1); exit 1; }; }
3241     fi
3242   fi
3243 fi
3244 echo "$as_me:$LINENO: result: yes" >&5
3245 echo "${ECHO_T}yes" >&6
3246
3247 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3248 ac_clean_files=$ac_clean_files_save
3249 # Check the compiler produces executables we can run.  If not, either
3250 # the compiler is broken, or we cross compile.
3251 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3252 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3253 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3254 echo "${ECHO_T}$cross_compiling" >&6
3255
3256 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3257 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3258 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3259   (eval $ac_link) 2>&5
3260   ac_status=$?
3261   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3262   (exit $ac_status); }; then
3263   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3264 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3265 # work properly (i.e., refer to `conftest.exe'), while it won't with
3266 # `rm'.
3267 for ac_file in conftest.exe conftest conftest.*; do
3268   test -f "$ac_file" || continue
3269   case $ac_file in
3270     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3271     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3272           export ac_cv_exeext
3273           break;;
3274     * ) break;;
3275   esac
3276 done
3277 else
3278   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3279 See \`config.log' for more details." >&5
3280 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3281 See \`config.log' for more details." >&2;}
3282    { (exit 1); exit 1; }; }
3283 fi
3284
3285 rm -f conftest$ac_cv_exeext
3286 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3287 echo "${ECHO_T}$ac_cv_exeext" >&6
3288
3289 rm -f conftest.$ac_ext
3290 EXEEXT=$ac_cv_exeext
3291 ac_exeext=$EXEEXT
3292 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3293 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3294 if test "${ac_cv_objext+set}" = set; then
3295   echo $ECHO_N "(cached) $ECHO_C" >&6
3296 else
3297   cat >conftest.$ac_ext <<_ACEOF
3298 /* confdefs.h.  */
3299 _ACEOF
3300 cat confdefs.h >>conftest.$ac_ext
3301 cat >>conftest.$ac_ext <<_ACEOF
3302 /* end confdefs.h.  */
3303
3304 int
3305 main ()
3306 {
3307
3308   ;
3309   return 0;
3310 }
3311 _ACEOF
3312 rm -f conftest.o conftest.obj
3313 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3314   (eval $ac_compile) 2>&5
3315   ac_status=$?
3316   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3317   (exit $ac_status); }; then
3318   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3319   case $ac_file in
3320     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3321     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3322        break;;
3323   esac
3324 done
3325 else
3326   echo "$as_me: failed program was:" >&5
3327 sed 's/^/| /' conftest.$ac_ext >&5
3328
3329 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3330 See \`config.log' for more details." >&5
3331 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3332 See \`config.log' for more details." >&2;}
3333    { (exit 1); exit 1; }; }
3334 fi
3335
3336 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3337 fi
3338 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3339 echo "${ECHO_T}$ac_cv_objext" >&6
3340 OBJEXT=$ac_cv_objext
3341 ac_objext=$OBJEXT
3342 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3343 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3344 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3345   echo $ECHO_N "(cached) $ECHO_C" >&6
3346 else
3347   cat >conftest.$ac_ext <<_ACEOF
3348 /* confdefs.h.  */
3349 _ACEOF
3350 cat confdefs.h >>conftest.$ac_ext
3351 cat >>conftest.$ac_ext <<_ACEOF
3352 /* end confdefs.h.  */
3353
3354 int
3355 main ()
3356 {
3357 #ifndef __GNUC__
3358        choke me
3359 #endif
3360
3361   ;
3362   return 0;
3363 }
3364 _ACEOF
3365 rm -f conftest.$ac_objext
3366 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3367   (eval $ac_compile) 2>conftest.er1
3368   ac_status=$?
3369   grep -v '^ *+' conftest.er1 >conftest.err
3370   rm -f conftest.er1
3371   cat conftest.err >&5
3372   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3373   (exit $ac_status); } &&
3374          { ac_try='test -z "$ac_c_werror_flag"
3375                          || test ! -s conftest.err'
3376   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3377   (eval $ac_try) 2>&5
3378   ac_status=$?
3379   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3380   (exit $ac_status); }; } &&
3381          { ac_try='test -s conftest.$ac_objext'
3382   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3383   (eval $ac_try) 2>&5
3384   ac_status=$?
3385   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3386   (exit $ac_status); }; }; then
3387   ac_compiler_gnu=yes
3388 else
3389   echo "$as_me: failed program was:" >&5
3390 sed 's/^/| /' conftest.$ac_ext >&5
3391
3392 ac_compiler_gnu=no
3393 fi
3394 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3395 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3396
3397 fi
3398 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3399 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3400 GCC=`test $ac_compiler_gnu = yes && echo yes`
3401 ac_test_CFLAGS=${CFLAGS+set}
3402 ac_save_CFLAGS=$CFLAGS
3403 CFLAGS="-g"
3404 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3405 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3406 if test "${ac_cv_prog_cc_g+set}" = set; then
3407   echo $ECHO_N "(cached) $ECHO_C" >&6
3408 else
3409   cat >conftest.$ac_ext <<_ACEOF
3410 /* confdefs.h.  */
3411 _ACEOF
3412 cat confdefs.h >>conftest.$ac_ext
3413 cat >>conftest.$ac_ext <<_ACEOF
3414 /* end confdefs.h.  */
3415
3416 int
3417 main ()
3418 {
3419
3420   ;
3421   return 0;
3422 }
3423 _ACEOF
3424 rm -f conftest.$ac_objext
3425 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3426   (eval $ac_compile) 2>conftest.er1
3427   ac_status=$?
3428   grep -v '^ *+' conftest.er1 >conftest.err
3429   rm -f conftest.er1
3430   cat conftest.err >&5
3431   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3432   (exit $ac_status); } &&
3433          { ac_try='test -z "$ac_c_werror_flag"
3434                          || test ! -s conftest.err'
3435   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3436   (eval $ac_try) 2>&5
3437   ac_status=$?
3438   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3439   (exit $ac_status); }; } &&
3440          { ac_try='test -s conftest.$ac_objext'
3441   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3442   (eval $ac_try) 2>&5
3443   ac_status=$?
3444   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3445   (exit $ac_status); }; }; then
3446   ac_cv_prog_cc_g=yes
3447 else
3448   echo "$as_me: failed program was:" >&5
3449 sed 's/^/| /' conftest.$ac_ext >&5
3450
3451 ac_cv_prog_cc_g=no
3452 fi
3453 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3454 fi
3455 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3456 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3457 if test "$ac_test_CFLAGS" = set; then
3458   CFLAGS=$ac_save_CFLAGS
3459 elif test $ac_cv_prog_cc_g = yes; then
3460   if test "$GCC" = yes; then
3461     CFLAGS="-g -O2"
3462   else
3463     CFLAGS="-g"
3464   fi
3465 else
3466   if test "$GCC" = yes; then
3467     CFLAGS="-O2"
3468   else
3469     CFLAGS=
3470   fi
3471 fi
3472 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3473 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3474 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3475   echo $ECHO_N "(cached) $ECHO_C" >&6
3476 else
3477   ac_cv_prog_cc_stdc=no
3478 ac_save_CC=$CC
3479 cat >conftest.$ac_ext <<_ACEOF
3480 /* confdefs.h.  */
3481 _ACEOF
3482 cat confdefs.h >>conftest.$ac_ext
3483 cat >>conftest.$ac_ext <<_ACEOF
3484 /* end confdefs.h.  */
3485 #include <stdarg.h>
3486 #include <stdio.h>
3487 #include <sys/types.h>
3488 #include <sys/stat.h>
3489 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3490 struct buf { int x; };
3491 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3492 static char *e (p, i)
3493      char **p;
3494      int i;
3495 {
3496   return p[i];
3497 }
3498 static char *f (char * (*g) (char **, int), char **p, ...)
3499 {
3500   char *s;
3501   va_list v;
3502   va_start (v,p);
3503   s = g (p, va_arg (v,int));
3504   va_end (v);
3505   return s;
3506 }
3507
3508 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3509    function prototypes and stuff, but not '\xHH' hex character constants.
3510    These don't provoke an error unfortunately, instead are silently treated
3511    as 'x'.  The following induces an error, until -std1 is added to get
3512    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3513    array size at least.  It's necessary to write '\x00'==0 to get something
3514    that's true only with -std1.  */
3515 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3516
3517 int test (int i, double x);
3518 struct s1 {int (*f) (int a);};
3519 struct s2 {int (*f) (double a);};
3520 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3521 int argc;
3522 char **argv;
3523 int
3524 main ()
3525 {
3526 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3527   ;
3528   return 0;
3529 }
3530 _ACEOF
3531 # Don't try gcc -ansi; that turns off useful extensions and
3532 # breaks some systems' header files.
3533 # AIX                   -qlanglvl=ansi
3534 # Ultrix and OSF/1      -std1
3535 # HP-UX 10.20 and later -Ae
3536 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3537 # SVR4                  -Xc -D__EXTENSIONS__
3538 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3539 do
3540   CC="$ac_save_CC $ac_arg"
3541   rm -f conftest.$ac_objext
3542 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3543   (eval $ac_compile) 2>conftest.er1
3544   ac_status=$?
3545   grep -v '^ *+' conftest.er1 >conftest.err
3546   rm -f conftest.er1
3547   cat conftest.err >&5
3548   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3549   (exit $ac_status); } &&
3550          { ac_try='test -z "$ac_c_werror_flag"
3551                          || test ! -s conftest.err'
3552   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3553   (eval $ac_try) 2>&5
3554   ac_status=$?
3555   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3556   (exit $ac_status); }; } &&
3557          { ac_try='test -s conftest.$ac_objext'
3558   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3559   (eval $ac_try) 2>&5
3560   ac_status=$?
3561   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3562   (exit $ac_status); }; }; then
3563   ac_cv_prog_cc_stdc=$ac_arg
3564 break
3565 else
3566   echo "$as_me: failed program was:" >&5
3567 sed 's/^/| /' conftest.$ac_ext >&5
3568
3569 fi
3570 rm -f conftest.err conftest.$ac_objext
3571 done
3572 rm -f conftest.$ac_ext conftest.$ac_objext
3573 CC=$ac_save_CC
3574
3575 fi
3576
3577 case "x$ac_cv_prog_cc_stdc" in
3578   x|xno)
3579     echo "$as_me:$LINENO: result: none needed" >&5
3580 echo "${ECHO_T}none needed" >&6 ;;
3581   *)
3582     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3583 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3584     CC="$CC $ac_cv_prog_cc_stdc" ;;
3585 esac
3586
3587 # Some people use a C++ compiler to compile C.  Since we use `exit',
3588 # in C++ we need to declare it.  In case someone uses the same compiler
3589 # for both compiling C and C++ we need to have the C++ compiler decide
3590 # the declaration of exit, since it's the most demanding environment.
3591 cat >conftest.$ac_ext <<_ACEOF
3592 #ifndef __cplusplus
3593   choke me
3594 #endif
3595 _ACEOF
3596 rm -f conftest.$ac_objext
3597 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3598   (eval $ac_compile) 2>conftest.er1
3599   ac_status=$?
3600   grep -v '^ *+' conftest.er1 >conftest.err
3601   rm -f conftest.er1
3602   cat conftest.err >&5
3603   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3604   (exit $ac_status); } &&
3605          { ac_try='test -z "$ac_c_werror_flag"
3606                          || test ! -s conftest.err'
3607   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3608   (eval $ac_try) 2>&5
3609   ac_status=$?
3610   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3611   (exit $ac_status); }; } &&
3612          { ac_try='test -s conftest.$ac_objext'
3613   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3614   (eval $ac_try) 2>&5
3615   ac_status=$?
3616   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3617   (exit $ac_status); }; }; then
3618   for ac_declaration in \
3619    '' \
3620    'extern "C" void std::exit (int) throw (); using std::exit;' \
3621    'extern "C" void std::exit (int); using std::exit;' \
3622    'extern "C" void exit (int) throw ();' \
3623    'extern "C" void exit (int);' \
3624    'void exit (int);'
3625 do
3626   cat >conftest.$ac_ext <<_ACEOF
3627 /* confdefs.h.  */
3628 _ACEOF
3629 cat confdefs.h >>conftest.$ac_ext
3630 cat >>conftest.$ac_ext <<_ACEOF
3631 /* end confdefs.h.  */
3632 $ac_declaration
3633 #include <stdlib.h>
3634 int
3635 main ()
3636 {
3637 exit (42);
3638   ;
3639   return 0;
3640 }
3641 _ACEOF
3642 rm -f conftest.$ac_objext
3643 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3644   (eval $ac_compile) 2>conftest.er1
3645   ac_status=$?
3646   grep -v '^ *+' conftest.er1 >conftest.err
3647   rm -f conftest.er1
3648   cat conftest.err >&5
3649   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3650   (exit $ac_status); } &&
3651          { ac_try='test -z "$ac_c_werror_flag"
3652                          || test ! -s conftest.err'
3653   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3654   (eval $ac_try) 2>&5
3655   ac_status=$?
3656   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3657   (exit $ac_status); }; } &&
3658          { ac_try='test -s conftest.$ac_objext'
3659   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3660   (eval $ac_try) 2>&5
3661   ac_status=$?
3662   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3663   (exit $ac_status); }; }; then
3664   :
3665 else
3666   echo "$as_me: failed program was:" >&5
3667 sed 's/^/| /' conftest.$ac_ext >&5
3668
3669 continue
3670 fi
3671 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3672   cat >conftest.$ac_ext <<_ACEOF
3673 /* confdefs.h.  */
3674 _ACEOF
3675 cat confdefs.h >>conftest.$ac_ext
3676 cat >>conftest.$ac_ext <<_ACEOF
3677 /* end confdefs.h.  */
3678 $ac_declaration
3679 int
3680 main ()
3681 {
3682 exit (42);
3683   ;
3684   return 0;
3685 }
3686 _ACEOF
3687 rm -f conftest.$ac_objext
3688 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3689   (eval $ac_compile) 2>conftest.er1
3690   ac_status=$?
3691   grep -v '^ *+' conftest.er1 >conftest.err
3692   rm -f conftest.er1
3693   cat conftest.err >&5
3694   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3695   (exit $ac_status); } &&
3696          { ac_try='test -z "$ac_c_werror_flag"
3697                          || test ! -s conftest.err'
3698   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3699   (eval $ac_try) 2>&5
3700   ac_status=$?
3701   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3702   (exit $ac_status); }; } &&
3703          { ac_try='test -s conftest.$ac_objext'
3704   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3705   (eval $ac_try) 2>&5
3706   ac_status=$?
3707   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3708   (exit $ac_status); }; }; then
3709   break
3710 else
3711   echo "$as_me: failed program was:" >&5
3712 sed 's/^/| /' conftest.$ac_ext >&5
3713
3714 fi
3715 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3716 done
3717 rm -f conftest*
3718 if test -n "$ac_declaration"; then
3719   echo '#ifdef __cplusplus' >>confdefs.h
3720   echo $ac_declaration      >>confdefs.h
3721   echo '#endif'             >>confdefs.h
3722 fi
3723
3724 else
3725   echo "$as_me: failed program was:" >&5
3726 sed 's/^/| /' conftest.$ac_ext >&5
3727
3728 fi
3729 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3730 ac_ext=c
3731 ac_cpp='$CPP $CPPFLAGS'
3732 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3733 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3734 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3735
3736 ac_ext=cc
3737 ac_cpp='$CXXCPP $CPPFLAGS'
3738 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3739 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3740 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3741 if test -n "$ac_tool_prefix"; then
3742   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3743   do
3744     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3745 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3746 echo "$as_me:$LINENO: checking for $ac_word" >&5
3747 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3748 if test "${ac_cv_prog_CXX+set}" = set; then
3749   echo $ECHO_N "(cached) $ECHO_C" >&6
3750 else
3751   if test -n "$CXX"; then
3752   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3753 else
3754 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3755 for as_dir in $PATH
3756 do
3757   IFS=$as_save_IFS
3758   test -z "$as_dir" && as_dir=.
3759   for ac_exec_ext in '' $ac_executable_extensions; do
3760   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3761     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3762     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3763     break 2
3764   fi
3765 done
3766 done
3767
3768 fi
3769 fi
3770 CXX=$ac_cv_prog_CXX
3771 if test -n "$CXX"; then
3772   echo "$as_me:$LINENO: result: $CXX" >&5
3773 echo "${ECHO_T}$CXX" >&6
3774 else
3775   echo "$as_me:$LINENO: result: no" >&5
3776 echo "${ECHO_T}no" >&6
3777 fi
3778
3779     test -n "$CXX" && break
3780   done
3781 fi
3782 if test -z "$CXX"; then
3783   ac_ct_CXX=$CXX
3784   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3785 do
3786   # Extract the first word of "$ac_prog", so it can be a program name with args.
3787 set dummy $ac_prog; ac_word=$2
3788 echo "$as_me:$LINENO: checking for $ac_word" >&5
3789 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3790 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3791   echo $ECHO_N "(cached) $ECHO_C" >&6
3792 else
3793   if test -n "$ac_ct_CXX"; then
3794   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3795 else
3796 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3797 for as_dir in $PATH
3798 do
3799   IFS=$as_save_IFS
3800   test -z "$as_dir" && as_dir=.
3801   for ac_exec_ext in '' $ac_executable_extensions; do
3802   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3803     ac_cv_prog_ac_ct_CXX="$ac_prog"
3804     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3805     break 2
3806   fi
3807 done
3808 done
3809
3810 fi
3811 fi
3812 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3813 if test -n "$ac_ct_CXX"; then
3814   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3815 echo "${ECHO_T}$ac_ct_CXX" >&6
3816 else
3817   echo "$as_me:$LINENO: result: no" >&5
3818 echo "${ECHO_T}no" >&6
3819 fi
3820
3821   test -n "$ac_ct_CXX" && break
3822 done
3823 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3824
3825   CXX=$ac_ct_CXX
3826 fi
3827
3828
3829 # Provide some information about the compiler.
3830 echo "$as_me:$LINENO:" \
3831      "checking for C++ compiler version" >&5
3832 ac_compiler=`set X $ac_compile; echo $2`
3833 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3834   (eval $ac_compiler --version </dev/null >&5) 2>&5
3835   ac_status=$?
3836   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3837   (exit $ac_status); }
3838 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3839   (eval $ac_compiler -v </dev/null >&5) 2>&5
3840   ac_status=$?
3841   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3842   (exit $ac_status); }
3843 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3844   (eval $ac_compiler -V </dev/null >&5) 2>&5
3845   ac_status=$?
3846   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3847   (exit $ac_status); }
3848
3849 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3850 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3851 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3852   echo $ECHO_N "(cached) $ECHO_C" >&6
3853 else
3854   cat >conftest.$ac_ext <<_ACEOF
3855 /* confdefs.h.  */
3856 _ACEOF
3857 cat confdefs.h >>conftest.$ac_ext
3858 cat >>conftest.$ac_ext <<_ACEOF
3859 /* end confdefs.h.  */
3860
3861 int
3862 main ()
3863 {
3864 #ifndef __GNUC__
3865        choke me
3866 #endif
3867
3868   ;
3869   return 0;
3870 }
3871 _ACEOF
3872 rm -f conftest.$ac_objext
3873 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3874   (eval $ac_compile) 2>conftest.er1
3875   ac_status=$?
3876   grep -v '^ *+' conftest.er1 >conftest.err
3877   rm -f conftest.er1
3878   cat conftest.err >&5
3879   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3880   (exit $ac_status); } &&
3881          { ac_try='test -z "$ac_cxx_werror_flag"
3882                          || test ! -s conftest.err'
3883   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3884   (eval $ac_try) 2>&5
3885   ac_status=$?
3886   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3887   (exit $ac_status); }; } &&
3888          { ac_try='test -s conftest.$ac_objext'
3889   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3890   (eval $ac_try) 2>&5
3891   ac_status=$?
3892   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3893   (exit $ac_status); }; }; then
3894   ac_compiler_gnu=yes
3895 else
3896   echo "$as_me: failed program was:" >&5
3897 sed 's/^/| /' conftest.$ac_ext >&5
3898
3899 ac_compiler_gnu=no
3900 fi
3901 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3902 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3903
3904 fi
3905 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3906 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3907 GXX=`test $ac_compiler_gnu = yes && echo yes`
3908 ac_test_CXXFLAGS=${CXXFLAGS+set}
3909 ac_save_CXXFLAGS=$CXXFLAGS
3910 CXXFLAGS="-g"
3911 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3912 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3913 if test "${ac_cv_prog_cxx_g+set}" = set; then
3914   echo $ECHO_N "(cached) $ECHO_C" >&6
3915 else
3916   cat >conftest.$ac_ext <<_ACEOF
3917 /* confdefs.h.  */
3918 _ACEOF
3919 cat confdefs.h >>conftest.$ac_ext
3920 cat >>conftest.$ac_ext <<_ACEOF
3921 /* end confdefs.h.  */
3922
3923 int
3924 main ()
3925 {
3926
3927   ;
3928   return 0;
3929 }
3930 _ACEOF
3931 rm -f conftest.$ac_objext
3932 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3933   (eval $ac_compile) 2>conftest.er1
3934   ac_status=$?
3935   grep -v '^ *+' conftest.er1 >conftest.err
3936   rm -f conftest.er1
3937   cat conftest.err >&5
3938   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3939   (exit $ac_status); } &&
3940          { ac_try='test -z "$ac_cxx_werror_flag"
3941                          || test ! -s conftest.err'
3942   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3943   (eval $ac_try) 2>&5
3944   ac_status=$?
3945   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3946   (exit $ac_status); }; } &&
3947          { ac_try='test -s conftest.$ac_objext'
3948   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3949   (eval $ac_try) 2>&5
3950   ac_status=$?
3951   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3952   (exit $ac_status); }; }; then
3953   ac_cv_prog_cxx_g=yes
3954 else
3955   echo "$as_me: failed program was:" >&5
3956 sed 's/^/| /' conftest.$ac_ext >&5
3957
3958 ac_cv_prog_cxx_g=no
3959 fi
3960 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3961 fi
3962 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3963 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
3964 if test "$ac_test_CXXFLAGS" = set; then
3965   CXXFLAGS=$ac_save_CXXFLAGS
3966 elif test $ac_cv_prog_cxx_g = yes; then
3967   if test "$GXX" = yes; then
3968     CXXFLAGS="-g -O2"
3969   else
3970     CXXFLAGS="-g"
3971   fi
3972 else
3973   if test "$GXX" = yes; then
3974     CXXFLAGS="-O2"
3975   else
3976     CXXFLAGS=
3977   fi
3978 fi
3979 for ac_declaration in \
3980    '' \
3981    'extern "C" void std::exit (int) throw (); using std::exit;' \
3982    'extern "C" void std::exit (int); using std::exit;' \
3983    'extern "C" void exit (int) throw ();' \
3984    'extern "C" void exit (int);' \
3985    'void exit (int);'
3986 do
3987   cat >conftest.$ac_ext <<_ACEOF
3988 /* confdefs.h.  */
3989 _ACEOF
3990 cat confdefs.h >>conftest.$ac_ext
3991 cat >>conftest.$ac_ext <<_ACEOF
3992 /* end confdefs.h.  */
3993 $ac_declaration
3994 #include <stdlib.h>
3995 int
3996 main ()
3997 {
3998 exit (42);
3999   ;
4000   return 0;
4001 }
4002 _ACEOF
4003 rm -f conftest.$ac_objext
4004 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4005   (eval $ac_compile) 2>conftest.er1
4006   ac_status=$?
4007   grep -v '^ *+' conftest.er1 >conftest.err
4008   rm -f conftest.er1
4009   cat conftest.err >&5
4010   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4011   (exit $ac_status); } &&
4012          { ac_try='test -z "$ac_cxx_werror_flag"
4013                          || test ! -s conftest.err'
4014   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4015   (eval $ac_try) 2>&5
4016   ac_status=$?
4017   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4018   (exit $ac_status); }; } &&
4019          { ac_try='test -s conftest.$ac_objext'
4020   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4021   (eval $ac_try) 2>&5
4022   ac_status=$?
4023   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4024   (exit $ac_status); }; }; then
4025   :
4026 else
4027   echo "$as_me: failed program was:" >&5
4028 sed 's/^/| /' conftest.$ac_ext >&5
4029
4030 continue
4031 fi
4032 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4033   cat >conftest.$ac_ext <<_ACEOF
4034 /* confdefs.h.  */
4035 _ACEOF
4036 cat confdefs.h >>conftest.$ac_ext
4037 cat >>conftest.$ac_ext <<_ACEOF
4038 /* end confdefs.h.  */
4039 $ac_declaration
4040 int
4041 main ()
4042 {
4043 exit (42);
4044   ;
4045   return 0;
4046 }
4047 _ACEOF
4048 rm -f conftest.$ac_objext
4049 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4050   (eval $ac_compile) 2>conftest.er1
4051   ac_status=$?
4052   grep -v '^ *+' conftest.er1 >conftest.err
4053   rm -f conftest.er1
4054   cat conftest.err >&5
4055   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4056   (exit $ac_status); } &&
4057          { ac_try='test -z "$ac_cxx_werror_flag"
4058                          || test ! -s conftest.err'
4059   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4060   (eval $ac_try) 2>&5
4061   ac_status=$?
4062   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4063   (exit $ac_status); }; } &&
4064          { ac_try='test -s conftest.$ac_objext'
4065   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4066   (eval $ac_try) 2>&5
4067   ac_status=$?
4068   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4069   (exit $ac_status); }; }; then
4070   break
4071 else
4072   echo "$as_me: failed program was:" >&5
4073 sed 's/^/| /' conftest.$ac_ext >&5
4074
4075 fi
4076 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4077 done
4078 rm -f conftest*
4079 if test -n "$ac_declaration"; then
4080   echo '#ifdef __cplusplus' >>confdefs.h
4081   echo $ac_declaration      >>confdefs.h
4082   echo '#endif'             >>confdefs.h
4083 fi
4084
4085 ac_ext=c
4086 ac_cpp='$CPP $CPPFLAGS'
4087 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4088 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4089 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4090
4091
4092 # We must set the default linker to the linker used by gcc for the correct
4093 # operation of libtool.  If LD is not defined and we are using gcc, try to
4094 # set the LD default to the ld used by gcc.
4095 if test -z "$LD"; then
4096   if test "$GCC" = yes; then
4097     case $build in
4098     *-*-mingw*)
4099       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4100     *)
4101       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4102     esac
4103     case $gcc_prog_ld in
4104     # Accept absolute paths.
4105     [\\/]* | [A-Za-z]:[\\/]*)
4106       LD="$gcc_prog_ld" ;;
4107     esac
4108   fi
4109 fi
4110
4111
4112
4113
4114 if test -n "$ac_tool_prefix"; then
4115   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4116 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4117 echo "$as_me:$LINENO: checking for $ac_word" >&5
4118 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4119 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4120   echo $ECHO_N "(cached) $ECHO_C" >&6
4121 else
4122   if test -n "$GNATBIND"; then
4123   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4124 else
4125 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4126 for as_dir in $PATH
4127 do
4128   IFS=$as_save_IFS
4129   test -z "$as_dir" && as_dir=.
4130   for ac_exec_ext in '' $ac_executable_extensions; do
4131   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4132     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4133     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4134     break 2
4135   fi
4136 done
4137 done
4138
4139 fi
4140 fi
4141 GNATBIND=$ac_cv_prog_GNATBIND
4142 if test -n "$GNATBIND"; then
4143   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4144 echo "${ECHO_T}$GNATBIND" >&6
4145 else
4146   echo "$as_me:$LINENO: result: no" >&5
4147 echo "${ECHO_T}no" >&6
4148 fi
4149
4150 fi
4151 if test -z "$ac_cv_prog_GNATBIND"; then
4152   ac_ct_GNATBIND=$GNATBIND
4153   # Extract the first word of "gnatbind", so it can be a program name with args.
4154 set dummy gnatbind; ac_word=$2
4155 echo "$as_me:$LINENO: checking for $ac_word" >&5
4156 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4157 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4158   echo $ECHO_N "(cached) $ECHO_C" >&6
4159 else
4160   if test -n "$ac_ct_GNATBIND"; then
4161   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4162 else
4163 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4164 for as_dir in $PATH
4165 do
4166   IFS=$as_save_IFS
4167   test -z "$as_dir" && as_dir=.
4168   for ac_exec_ext in '' $ac_executable_extensions; do
4169   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4170     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4171     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4172     break 2
4173   fi
4174 done
4175 done
4176
4177   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4178 fi
4179 fi
4180 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4181 if test -n "$ac_ct_GNATBIND"; then
4182   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4183 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4184 else
4185   echo "$as_me:$LINENO: result: no" >&5
4186 echo "${ECHO_T}no" >&6
4187 fi
4188
4189   GNATBIND=$ac_ct_GNATBIND
4190 else
4191   GNATBIND="$ac_cv_prog_GNATBIND"
4192 fi
4193
4194 if test -n "$ac_tool_prefix"; then
4195   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4196 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4197 echo "$as_me:$LINENO: checking for $ac_word" >&5
4198 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4199 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4200   echo $ECHO_N "(cached) $ECHO_C" >&6
4201 else
4202   if test -n "$GNATMAKE"; then
4203   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4204 else
4205 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4206 for as_dir in $PATH
4207 do
4208   IFS=$as_save_IFS
4209   test -z "$as_dir" && as_dir=.
4210   for ac_exec_ext in '' $ac_executable_extensions; do
4211   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4212     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4213     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4214     break 2
4215   fi
4216 done
4217 done
4218
4219 fi
4220 fi
4221 GNATMAKE=$ac_cv_prog_GNATMAKE
4222 if test -n "$GNATMAKE"; then
4223   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4224 echo "${ECHO_T}$GNATMAKE" >&6
4225 else
4226   echo "$as_me:$LINENO: result: no" >&5
4227 echo "${ECHO_T}no" >&6
4228 fi
4229
4230 fi
4231 if test -z "$ac_cv_prog_GNATMAKE"; then
4232   ac_ct_GNATMAKE=$GNATMAKE
4233   # Extract the first word of "gnatmake", so it can be a program name with args.
4234 set dummy gnatmake; ac_word=$2
4235 echo "$as_me:$LINENO: checking for $ac_word" >&5
4236 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4237 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4238   echo $ECHO_N "(cached) $ECHO_C" >&6
4239 else
4240   if test -n "$ac_ct_GNATMAKE"; then
4241   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4242 else
4243 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4244 for as_dir in $PATH
4245 do
4246   IFS=$as_save_IFS
4247   test -z "$as_dir" && as_dir=.
4248   for ac_exec_ext in '' $ac_executable_extensions; do
4249   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4250     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4251     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4252     break 2
4253   fi
4254 done
4255 done
4256
4257   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4258 fi
4259 fi
4260 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4261 if test -n "$ac_ct_GNATMAKE"; then
4262   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4263 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4264 else
4265   echo "$as_me:$LINENO: result: no" >&5
4266 echo "${ECHO_T}no" >&6
4267 fi
4268
4269   GNATMAKE=$ac_ct_GNATMAKE
4270 else
4271   GNATMAKE="$ac_cv_prog_GNATMAKE"
4272 fi
4273
4274 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4275 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4276 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4277   echo $ECHO_N "(cached) $ECHO_C" >&6
4278 else
4279   cat >conftest.adb <<EOF
4280 procedure conftest is begin null; end conftest;
4281 EOF
4282 acx_cv_cc_gcc_supports_ada=no
4283 # There is a bug in old released versions of GCC which causes the
4284 # driver to exit successfully when the appropriate language module
4285 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4286 # Therefore we must check for the error message as well as an
4287 # unsuccessful exit.
4288 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4289 # given a .adb file, but produce no object file.  So we must check
4290 # if an object file was really produced to guard against this.
4291 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4292 if test x"$errors" = x && test -f conftest.$ac_objext; then
4293   acx_cv_cc_gcc_supports_ada=yes
4294 fi
4295 rm -f conftest.*
4296 fi
4297 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4298 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4299
4300 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4301   have_gnat=yes
4302 else
4303   have_gnat=no
4304 fi
4305
4306 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4307 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4308 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4309   echo $ECHO_N "(cached) $ECHO_C" >&6
4310 else
4311    echo abfoo >t1
4312   echo cdfoo >t2
4313   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4314   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4315     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4316       :
4317     else
4318       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4319     fi
4320   fi
4321   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4322     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4323       :
4324     else
4325       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4326     fi
4327   fi
4328   rm t1 t2
4329
4330 fi
4331 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4332 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4333 do_compare="$gcc_cv_prog_cmp_skip"
4334
4335
4336
4337 # Check for GMP and MPFR
4338 gmplibs="-lmpfr -lgmp"
4339 gmpinc=
4340 have_gmp=no
4341
4342 # Specify a location for mpfr
4343 # check for this first so it ends up on the link line before gmp.
4344
4345 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4346 if test "${with_mpfr_dir+set}" = set; then
4347   withval="$with_mpfr_dir"
4348   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4349 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4350 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4351 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4352    { (exit 1); exit 1; }; }
4353 fi;
4354
4355
4356 # Check whether --with-mpfr or --without-mpfr was given.
4357 if test "${with_mpfr+set}" = set; then
4358   withval="$with_mpfr"
4359
4360 fi;
4361
4362 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4363 if test "${with_mpfr_include+set}" = set; then
4364   withval="$with_mpfr_include"
4365
4366 fi;
4367
4368 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4369 if test "${with_mpfr_lib+set}" = set; then
4370   withval="$with_mpfr_lib"
4371
4372 fi;
4373
4374 if test "x$with_mpfr" != x; then
4375   gmplibs="-L$with_mpfr/lib $gmplibs"
4376   gmpinc="-I$with_mpfr/include"
4377 fi
4378 if test "x$with_mpfr_include" != x; then
4379   gmpinc="-I$with_mpfr_include"
4380 fi
4381 if test "x$with_mpfr_lib" != x; then
4382   gmplibs="-L$with_mpfr_lib $gmplibs"
4383 fi
4384 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4385   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4386   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4387   # Do not test the mpfr version.  Assume that it is sufficient, since
4388   # it is in the source tree, and the library has not been built yet
4389   # but it would be included on the link line in the version check below
4390   # hence making the test fail.
4391   have_gmp=yes
4392 fi
4393
4394 # Specify a location for gmp
4395
4396 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4397 if test "${with_gmp_dir+set}" = set; then
4398   withval="$with_gmp_dir"
4399   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4400 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4401 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4402 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4403    { (exit 1); exit 1; }; }
4404 fi;
4405
4406
4407 # Check whether --with-gmp or --without-gmp was given.
4408 if test "${with_gmp+set}" = set; then
4409   withval="$with_gmp"
4410
4411 fi;
4412
4413 # Check whether --with-gmp_include or --without-gmp_include was given.
4414 if test "${with_gmp_include+set}" = set; then
4415   withval="$with_gmp_include"
4416
4417 fi;
4418
4419 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4420 if test "${with_gmp_lib+set}" = set; then
4421   withval="$with_gmp_lib"
4422
4423 fi;
4424
4425
4426 if test "x$with_gmp" != x; then
4427   gmplibs="-L$with_gmp/lib $gmplibs"
4428   gmpinc="-I$with_gmp/include $gmpinc"
4429 fi
4430 if test "x$with_gmp_include" != x; then
4431   gmpinc="-I$with_gmp_include $gmpinc"
4432 fi
4433 if test "x$with_gmp_lib" != x; then
4434   gmplibs="-L$with_gmp_lib $gmplibs"
4435 fi
4436 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4437   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4438   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4439   # Do not test the gmp version.  Assume that it is sufficient, since
4440   # it is in the source tree, and the library has not been built yet
4441   # but it would be included on the link line in the version check below
4442   # hence making the test fail.
4443   have_gmp=yes
4444 fi
4445
4446 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4447   have_gmp=yes
4448   saved_CFLAGS="$CFLAGS"
4449   CFLAGS="$CFLAGS $gmpinc"
4450   # Check GMP actually works
4451   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4452 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4453
4454 cat >conftest.$ac_ext <<_ACEOF
4455 /* confdefs.h.  */
4456 _ACEOF
4457 cat confdefs.h >>conftest.$ac_ext
4458 cat >>conftest.$ac_ext <<_ACEOF
4459 /* end confdefs.h.  */
4460 #include "gmp.h"
4461 int
4462 main ()
4463 {
4464
4465   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4466   choke me
4467   #endif
4468
4469   ;
4470   return 0;
4471 }
4472 _ACEOF
4473 rm -f conftest.$ac_objext
4474 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4475   (eval $ac_compile) 2>conftest.er1
4476   ac_status=$?
4477   grep -v '^ *+' conftest.er1 >conftest.err
4478   rm -f conftest.er1
4479   cat conftest.err >&5
4480   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4481   (exit $ac_status); } &&
4482          { ac_try='test -z "$ac_c_werror_flag"
4483                          || test ! -s conftest.err'
4484   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4485   (eval $ac_try) 2>&5
4486   ac_status=$?
4487   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4488   (exit $ac_status); }; } &&
4489          { ac_try='test -s conftest.$ac_objext'
4490   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4491   (eval $ac_try) 2>&5
4492   ac_status=$?
4493   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4494   (exit $ac_status); }; }; then
4495   echo "$as_me:$LINENO: result: yes" >&5
4496 echo "${ECHO_T}yes" >&6
4497 else
4498   echo "$as_me: failed program was:" >&5
4499 sed 's/^/| /' conftest.$ac_ext >&5
4500
4501 echo "$as_me:$LINENO: result: no" >&5
4502 echo "${ECHO_T}no" >&6; have_gmp=no
4503 fi
4504 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4505
4506   if test x"$have_gmp" = xyes; then
4507     saved_LIBS="$LIBS"
4508     LIBS="$LIBS $gmplibs"
4509         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4510 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4511     cat >conftest.$ac_ext <<_ACEOF
4512 /* confdefs.h.  */
4513 _ACEOF
4514 cat confdefs.h >>conftest.$ac_ext
4515 cat >>conftest.$ac_ext <<_ACEOF
4516 /* end confdefs.h.  */
4517 #include <gmp.h>
4518     #include <mpfr.h>
4519 int
4520 main ()
4521 {
4522
4523     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,0)
4524     choke me
4525     #endif
4526     mpfr_t n;
4527     mpfr_t x;
4528     int t;
4529     mpfr_init (n);
4530     mpfr_init (x);
4531     mpfr_atan2 (n, n, x, GMP_RNDN);
4532     mpfr_erfc (n, x, GMP_RNDN);
4533     mpfr_subnormalize (x, t, GMP_RNDN);
4534
4535   ;
4536   return 0;
4537 }
4538 _ACEOF
4539 rm -f conftest.$ac_objext conftest$ac_exeext
4540 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4541   (eval $ac_link) 2>conftest.er1
4542   ac_status=$?
4543   grep -v '^ *+' conftest.er1 >conftest.err
4544   rm -f conftest.er1
4545   cat conftest.err >&5
4546   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4547   (exit $ac_status); } &&
4548          { ac_try='test -z "$ac_c_werror_flag"
4549                          || test ! -s conftest.err'
4550   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4551   (eval $ac_try) 2>&5
4552   ac_status=$?
4553   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4554   (exit $ac_status); }; } &&
4555          { ac_try='test -s conftest$ac_exeext'
4556   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4557   (eval $ac_try) 2>&5
4558   ac_status=$?
4559   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4560   (exit $ac_status); }; }; then
4561   cat >conftest.$ac_ext <<_ACEOF
4562 /* confdefs.h.  */
4563 _ACEOF
4564 cat confdefs.h >>conftest.$ac_ext
4565 cat >>conftest.$ac_ext <<_ACEOF
4566 /* end confdefs.h.  */
4567 #include <gmp.h>
4568     #include <mpfr.h>
4569 int
4570 main ()
4571 {
4572
4573     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4574     choke me
4575     #endif
4576     mpfr_t n; mpfr_init(n);
4577
4578   ;
4579   return 0;
4580 }
4581 _ACEOF
4582 rm -f conftest.$ac_objext conftest$ac_exeext
4583 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4584   (eval $ac_link) 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_exeext'
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: buggy but acceptable" >&5
4611 echo "${ECHO_T}buggy but acceptable" >&6
4612 fi
4613 rm -f conftest.err conftest.$ac_objext \
4614       conftest$ac_exeext conftest.$ac_ext
4615 else
4616   echo "$as_me: failed program was:" >&5
4617 sed 's/^/| /' conftest.$ac_ext >&5
4618
4619 echo "$as_me:$LINENO: result: no" >&5
4620 echo "${ECHO_T}no" >&6; have_gmp=no
4621 fi
4622 rm -f conftest.err conftest.$ac_objext \
4623       conftest$ac_exeext conftest.$ac_ext
4624       LIBS="$saved_LIBS"
4625   fi
4626   CFLAGS="$saved_CFLAGS"
4627
4628   if test x$have_gmp != xyes; then
4629     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4630 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4631 Copies of these libraries' source code can be found at their respective
4632 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4633 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4634 If you obtained GMP and/or MPFR from a vendor distribution package, make
4635 sure that you have installed both the libraries and the header files.
4636 They may be located in separate packages." >&5
4637 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4638 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4639 Copies of these libraries' source code can be found at their respective
4640 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4641 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4642 If you obtained GMP and/or MPFR from a vendor distribution package, make
4643 sure that you have installed both the libraries and the header files.
4644 They may be located in separate packages." >&2;}
4645    { (exit 1); exit 1; }; }
4646   fi
4647 fi
4648
4649 # Flags needed for both GMP and/or MPFR
4650
4651
4652
4653 # By default, C is the only stage 1 language.
4654 stage1_languages=,c,
4655
4656 # Figure out what language subdirectories are present.
4657 # Look if the user specified --enable-languages="..."; if not, use
4658 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4659 # go away some day.
4660 # NB:  embedded tabs in this IF block -- do not untabify
4661 if test -d ${srcdir}/gcc; then
4662   if test x"${enable_languages+set}" != xset; then
4663     if test x"${LANGUAGES+set}" = xset; then
4664       enable_languages="${LANGUAGES}"
4665         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4666     else
4667       enable_languages=all
4668     fi
4669   else
4670     if test x"${enable_languages}" = x ||
4671        test x"${enable_languages}" = xyes;
4672        then
4673       echo configure.in: --enable-languages needs at least one language argument 1>&2
4674       exit 1
4675     fi
4676   fi
4677   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4678
4679   # 'f95' is the old name for the 'fortran' language. We issue a warning
4680   # and make the substitution.
4681   case ,${enable_languages}, in
4682     *,f95,*)
4683       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4684       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4685       ;;
4686   esac
4687
4688   # First scan to see if an enabled language requires some other language.
4689   # We assume that a given config-lang.in will list all the language
4690   # front ends it requires, even if some are required indirectly.
4691   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4692     case ${lang_frag} in
4693       ..) ;;
4694       # The odd quoting in the next line works around
4695       # an apparent bug in bash 1.12 on linux.
4696       ${srcdir}/gcc/[*]/config-lang.in) ;;
4697       *)
4698         # From the config-lang.in, get $language, $lang_requires
4699         language=
4700         lang_requires=
4701         . ${lang_frag}
4702         for other in ${lang_requires} ; do
4703           case ,${enable_languages}, in
4704             *,$other,*) ;;
4705             *,all,*) ;;
4706             *,$language,*)
4707               echo " \`$other' language required by \`$language'; enabling" 1>&2
4708               enable_languages="${enable_languages},${other}"
4709               ;;
4710           esac
4711         done
4712         ;;
4713     esac
4714   done
4715
4716   new_enable_languages=,c,
4717   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4718   potential_languages=,c,
4719
4720   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4721     case ${lang_frag} in
4722       ..) ;;
4723       # The odd quoting in the next line works around
4724       # an apparent bug in bash 1.12 on linux.
4725       ${srcdir}/gcc/[*]/config-lang.in) ;;
4726       *)
4727         # From the config-lang.in, get $language, $target_libs,
4728         # $lang_dirs, $boot_language, and $build_by_default
4729         language=
4730         target_libs=
4731         lang_dirs=
4732         subdir_requires=
4733         boot_language=no
4734         build_by_default=yes
4735         . ${lang_frag}
4736         if test x${language} = x; then
4737           echo "${lang_frag} doesn't set \$language." 1>&2
4738           exit 1
4739         fi
4740
4741         case ,${enable_languages}, in
4742           *,${language},*)
4743             # Language was explicitly selected; include it.
4744             add_this_lang=yes
4745             ;;
4746           *,all,*)
4747             # 'all' was selected, select it if it is a default language
4748             add_this_lang=${build_by_default}
4749             ;;
4750           *)
4751             add_this_lang=no
4752             ;;
4753         esac
4754
4755         # Disable languages that need other directories if these aren't available.
4756         for i in $subdir_requires; do
4757           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4758           case ,${enable_languages}, in
4759             *,${language},*)
4760               # Specifically requested language; tell them.
4761               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4762 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4763    { (exit 1); exit 1; }; }
4764               ;;
4765             *)
4766               # Silently disable.
4767               add_this_lang=unsupported
4768               ;;
4769           esac
4770         done
4771
4772         # Disable Ada if no preexisting GNAT is available.
4773         case ,${enable_languages},:${language}:${have_gnat} in
4774           *,${language},*:ada:no)
4775             # Specifically requested language; tell them.
4776             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4777 echo "$as_me: error: GNAT is required to build $language" >&2;}
4778    { (exit 1); exit 1; }; }
4779             ;;
4780           *:ada:no)
4781             # Silently disable.
4782             add_this_lang=unsupported
4783             ;;
4784         esac
4785
4786         # Disable a language that is unsupported by the target.
4787         case " $unsupported_languages " in
4788           *" $language "*)
4789             add_this_lang=unsupported
4790             ;;
4791         esac
4792
4793         case $add_this_lang in
4794           unsupported)
4795             # Remove language-dependent dirs.
4796             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4797             ;;
4798           no)
4799             # Remove language-dependent dirs; still show language as supported.
4800             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4801             potential_languages="${potential_languages}${language},"
4802             ;;
4803           yes)
4804             new_enable_languages="${new_enable_languages}${language},"
4805             potential_languages="${potential_languages}${language},"
4806             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4807             case ${boot_language} in
4808               yes)
4809                 # Add to (comma-separated) list of stage 1 languages.
4810                 stage1_languages="${stage1_languages}${language},"
4811                 ;;
4812             esac
4813             ;;
4814         esac
4815         ;;
4816     esac
4817   done
4818
4819   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4820 if test "${enable_stage1_languages+set}" = set; then
4821   enableval="$enable_stage1_languages"
4822   case ,${enable_stage1_languages}, in
4823     ,no,|,,)
4824       # Set it to something that will have no effect in the loop below
4825       enable_stage1_languages=c ;;
4826     ,yes,)
4827       enable_stage1_languages=`echo $new_enable_languages | \
4828         sed -e "s/^,//" -e "s/,$//" ` ;;
4829     *,all,*)
4830       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4831         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4832   esac
4833
4834   # Add "good" languages from enable_stage1_languages to stage1_languages,
4835   # while "bad" languages go in missing_languages.  Leave no duplicates.
4836   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4837     case $potential_languages in
4838       *,$i,*)
4839         case $stage1_languages in
4840           *,$i,*) ;;
4841           *) stage1_languages="$stage1_languages$i," ;;
4842         esac ;;
4843       *)
4844         case $missing_languages in
4845           *,$i,*) ;;
4846           *) missing_languages="$missing_languages$i," ;;
4847         esac ;;
4848      esac
4849   done
4850 fi;
4851
4852   # Remove leading/trailing commas that were added for simplicity
4853   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4854   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4855   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4856   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4857
4858   if test "x$missing_languages" != x; then
4859     { { echo "$as_me:$LINENO: error:
4860 The following requested languages could not be built: ${missing_languages}
4861 Supported languages are: ${potential_languages}" >&5
4862 echo "$as_me: error:
4863 The following requested languages could not be built: ${missing_languages}
4864 Supported languages are: ${potential_languages}" >&2;}
4865    { (exit 1); exit 1; }; }
4866   fi
4867   if test "x$new_enable_languages" != "x$enable_languages"; then
4868     echo The following languages will be built: ${new_enable_languages}
4869     enable_languages="$new_enable_languages"
4870   fi
4871
4872
4873   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4874 fi
4875
4876 # Handle --disable-<component> generically.
4877 for dir in $configdirs $build_configdirs $target_configdirs ; do
4878   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4879   if eval test x\${enable_${dirname}} "=" xno ; then
4880     noconfigdirs="$noconfigdirs $dir"
4881   fi
4882 done
4883
4884 # Check for Boehm's garbage collector
4885 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4886 if test "${enable_objc_gc+set}" = set; then
4887   enableval="$enable_objc_gc"
4888   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4889   *,objc,*:*:yes:*target-boehm-gc*)
4890     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4891 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4892    { (exit 1); exit 1; }; }
4893     ;;
4894 esac
4895 fi;
4896
4897 # Make sure we only build Boehm's garbage collector if required.
4898 case ,${enable_languages},:${enable_objc_gc} in
4899   *,objc,*:yes)
4900     # Keep target-boehm-gc if requested for Objective-C.
4901     ;;
4902   *)
4903     # Otherwise remove target-boehm-gc depending on target-libjava.
4904     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4905       noconfigdirs="$noconfigdirs target-boehm-gc"
4906     fi
4907     ;;
4908 esac
4909
4910 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4911 # $build_configdirs and $target_configdirs.
4912 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4913
4914 notsupp=""
4915 for dir in . $skipdirs $noconfigdirs ; do
4916   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4917   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4918     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4919     if test -r $srcdir/$dirname/configure ; then
4920       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4921         true
4922       else
4923         notsupp="$notsupp $dir"
4924       fi
4925     fi
4926   fi
4927   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4928     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
4929     if test -r $srcdir/$dirname/configure ; then
4930       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4931         true
4932       else
4933         notsupp="$notsupp $dir"
4934       fi
4935     fi
4936   fi
4937   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4938     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
4939     if test -r $srcdir/$dirname/configure ; then
4940       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4941         true
4942       else
4943         notsupp="$notsupp $dir"
4944       fi
4945     fi
4946   fi
4947 done
4948
4949 # Sometimes the tools are distributed with libiberty but with no other
4950 # libraries.  In that case, we don't want to build target-libiberty.
4951 # Don't let libgcc imply libiberty either.
4952 if test -n "${target_configdirs}" ; then
4953   libgcc=
4954   others=
4955   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
4956     if test "$i" = "libgcc"; then
4957       libgcc=target-libgcc
4958     elif test "$i" != "libiberty" ; then
4959       if test -r $srcdir/$i/configure ; then
4960         others=yes;
4961         break;
4962       fi
4963     fi
4964   done
4965   if test -z "${others}" ; then
4966     target_configdirs=$libgcc
4967   fi
4968 fi
4969
4970 # Quietly strip out all directories which aren't configurable in this tree.
4971 # This relies on all configurable subdirectories being autoconfiscated, which
4972 # is now the case.
4973 build_configdirs_all="$build_configdirs"
4974 build_configdirs=
4975 for i in ${build_configdirs_all} ; do
4976   j=`echo $i | sed -e s/build-//g`
4977   if test -f ${srcdir}/$j/configure ; then
4978     build_configdirs="${build_configdirs} $i"
4979   fi
4980 done
4981
4982 configdirs_all="$configdirs"
4983 configdirs=
4984 for i in ${configdirs_all} ; do
4985   if test -f ${srcdir}/$i/configure ; then
4986     configdirs="${configdirs} $i"
4987   fi
4988 done
4989
4990 target_configdirs_all="$target_configdirs"
4991 target_configdirs=
4992 for i in ${target_configdirs_all} ; do
4993   j=`echo $i | sed -e s/target-//g`
4994   if test -f ${srcdir}/$j/configure ; then
4995     target_configdirs="${target_configdirs} $i"
4996   fi
4997 done
4998
4999 # Produce a warning message for the subdirs we can't configure.
5000 # This isn't especially interesting in the Cygnus tree, but in the individual
5001 # FSF releases, it's important to let people know when their machine isn't
5002 # supported by the one or two programs in a package.
5003
5004 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5005   # If $appdirs is non-empty, at least one of those directories must still
5006   # be configured, or we error out.  (E.g., if the gas release supports a
5007   # specified target in some subdirs but not the gas subdir, we shouldn't
5008   # pretend that all is well.)
5009   if test -n "$appdirs" ; then
5010     for dir in $appdirs ; do
5011       if test -r $dir/Makefile.in ; then
5012         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5013           appdirs=""
5014           break
5015         fi
5016         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5017           appdirs=""
5018           break
5019         fi
5020       fi
5021     done
5022     if test -n "$appdirs" ; then
5023       echo "*** This configuration is not supported by this package." 1>&2
5024       exit 1
5025     fi
5026   fi
5027   # Okay, some application will build, or we don't care to check.  Still
5028   # notify of subdirs not getting built.
5029   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5030   echo "    ${notsupp}" 1>&2
5031   echo "    (Any other directories should still work fine.)" 1>&2
5032 fi
5033
5034 case "$host" in
5035   *msdosdjgpp*)
5036     enable_gdbtk=no ;;
5037 esac
5038
5039 # To find our prefix, in gcc_cv_tool_prefix.
5040
5041 # The user is always right.
5042 if test "${PATH_SEPARATOR+set}" != set; then
5043   echo "#! /bin/sh" >conf$$.sh
5044   echo  "exit 0"   >>conf$$.sh
5045   chmod +x conf$$.sh
5046   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5047     PATH_SEPARATOR=';'
5048   else
5049     PATH_SEPARATOR=:
5050   fi
5051   rm -f conf$$.sh
5052 fi
5053
5054
5055
5056 if test "x$exec_prefix" = xNONE; then
5057         if test "x$prefix" = xNONE; then
5058                 gcc_cv_tool_prefix=$ac_default_prefix
5059         else
5060                 gcc_cv_tool_prefix=$prefix
5061         fi
5062 else
5063         gcc_cv_tool_prefix=$exec_prefix
5064 fi
5065
5066 # If there is no compiler in the tree, use the PATH only.  In any
5067 # case, if there is no compiler in the tree nobody should use
5068 # AS_FOR_TARGET and LD_FOR_TARGET.
5069 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5070     gcc_version=`cat $srcdir/gcc/BASE-VER`
5071     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5072     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5073     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5074     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5075     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5076     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5077 else
5078     gcc_cv_tool_dirs=
5079 fi
5080
5081 if test x$build = x$target && test -n "$md_exec_prefix"; then
5082         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5083 fi
5084
5085
5086
5087 copy_dirs=
5088
5089
5090 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5091 if test "${with_build_sysroot+set}" = set; then
5092   withval="$with_build_sysroot"
5093   if test x"$withval" != x ; then
5094      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5095    fi
5096 else
5097   SYSROOT_CFLAGS_FOR_TARGET=
5098 fi;
5099
5100
5101
5102 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5103 if test "${with_debug_prefix_map+set}" = set; then
5104   withval="$with_debug_prefix_map"
5105   if test x"$withval" != x; then
5106      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5107      for debug_map in $withval; do
5108        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5109      done
5110    fi
5111 else
5112   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5113 fi;
5114
5115
5116 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5117 # the named directory are copied to $(tooldir)/sys-include.
5118 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5119   if test x${is_cross_compiler} = xno ; then
5120     echo 1>&2 '***' --with-headers is only supported when cross compiling
5121     exit 1
5122   fi
5123   if test x"${with_headers}" != xyes ; then
5124     x=${gcc_cv_tool_prefix}
5125     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5126   fi
5127 fi
5128
5129 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5130 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5131 # are permitted.
5132 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5133   if test x${is_cross_compiler} = xno ; then
5134     echo 1>&2 '***' --with-libs is only supported when cross compiling
5135     exit 1
5136   fi
5137   if test x"${with_libs}" != xyes ; then
5138     # Copy the libraries in reverse order, so that files in the first named
5139     # library override files in subsequent libraries.
5140     x=${gcc_cv_tool_prefix}
5141     for l in ${with_libs}; do
5142       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5143     done
5144   fi
5145 fi
5146
5147 # Set with_gnu_as and with_gnu_ld as appropriate.
5148 #
5149 # This is done by determining whether or not the appropriate directory
5150 # is available, and by checking whether or not specific configurations
5151 # have requested that this magic not happen.
5152 #
5153 # The command line options always override the explicit settings in
5154 # configure.in, and the settings in configure.in override this magic.
5155 #
5156 # If the default for a toolchain is to use GNU as and ld, and you don't
5157 # want to do that, then you should use the --without-gnu-as and
5158 # --without-gnu-ld options for the configure script.
5159
5160 if test x${use_gnu_as} = x &&
5161    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5162   with_gnu_as=yes
5163   extra_host_args="$extra_host_args --with-gnu-as"
5164 fi
5165
5166 if test x${use_gnu_ld} = x &&
5167    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
5168   with_gnu_ld=yes
5169   extra_host_args="$extra_host_args --with-gnu-ld"
5170 fi
5171
5172 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5173 # can detect this case.
5174
5175 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5176   with_newlib=yes
5177   extra_host_args="$extra_host_args --with-newlib"
5178 fi
5179
5180 # Handle ${copy_dirs}
5181 set fnord ${copy_dirs}
5182 shift
5183 while test $# != 0 ; do
5184   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5185     :
5186   else
5187     echo Copying $1 to $2
5188
5189     # Use the install script to create the directory and all required
5190     # parent directories.
5191     if test -d $2 ; then
5192       :
5193     else
5194       echo >config.temp
5195       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5196     fi
5197
5198     # Copy the directory, assuming we have tar.
5199     # FIXME: Should we use B in the second tar?  Not all systems support it.
5200     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5201
5202     # It is the responsibility of the user to correctly adjust all
5203     # symlinks.  If somebody can figure out how to handle them correctly
5204     # here, feel free to add the code.
5205
5206     echo $1 > $2/COPIED
5207   fi
5208   shift; shift
5209 done
5210
5211 # Determine a target-dependent exec_prefix that the installed
5212 # gcc will search in.  Keep this list sorted by triplet, with
5213 # the *-*-osname triplets last.
5214 md_exec_prefix=
5215 case "${target}" in
5216   alpha*-*-*vms*)
5217     md_exec_prefix=/gnu/lib/gcc-lib
5218     ;;
5219   i[34567]86-pc-msdosdjgpp*)
5220     md_exec_prefix=/dev/env/DJDIR/bin
5221     ;;
5222   i[34567]86-*-sco3.2v5*)
5223     if test $with_gnu_as = yes; then
5224       md_exec_prefix=/usr/gnu/bin
5225     else
5226       md_exec_prefix=/usr/ccs/bin/elf
5227     fi
5228     ;;
5229
5230   mn10300-*-* | \
5231   powerpc-*-chorusos* | \
5232   powerpc*-*-eabi* | \
5233   powerpc*-*-sysv* | \
5234   powerpc*-*-kaos* | \
5235   s390x-ibm-tpf*)
5236     md_exec_prefix=/usr/ccs/bin
5237     ;;
5238   sparc64-*-elf*)
5239     ;;
5240   v850*-*-*)
5241     md_exec_prefix=/usr/ccs/bin
5242     ;;
5243   xtensa-*-elf*)
5244     ;;
5245
5246   *-*-beos* | \
5247   *-*-elf* | \
5248   *-*-hpux* | \
5249   *-*-netware* | \
5250   *-*-nto-qnx* | \
5251   *-*-rtems* | \
5252   *-*-solaris2* | \
5253   *-*-sysv[45]* | \
5254   *-*-vxworks* | \
5255   *-wrs-windiss)
5256     md_exec_prefix=/usr/ccs/bin
5257     ;;
5258 esac
5259
5260 extra_arflags_for_target=
5261 extra_nmflags_for_target=
5262 extra_ranlibflags_for_target=
5263 target_makefile_frag=/dev/null
5264 case "${target}" in
5265   mep*-*-*)
5266     target_makefile_frag="config/mt-mep"
5267     ;;
5268   spu-*-*)
5269     target_makefile_frag="config/mt-spu"
5270     ;;
5271   mips*-sde-elf*)
5272     target_makefile_frag="config/mt-sde"
5273     ;;
5274   *-*-netware*)
5275     target_makefile_frag="config/mt-netware"
5276     ;;
5277   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5278     target_makefile_frag="config/mt-gnu"
5279     ;;
5280   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5281     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5282     # commands to handle both 32-bit and 64-bit objects.  These flags are
5283     # harmless if we're using GNU nm or ar.
5284     extra_arflags_for_target=" -X32_64"
5285     extra_nmflags_for_target=" -B -X32_64"
5286     ;;
5287   *-*-darwin*)
5288     # ranlib from Darwin requires the -c flag to look at common symbols.
5289     extra_ranlibflags_for_target=" -c"
5290     ;;
5291   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5292     target_makefile_frag="config/mt-wince"
5293     ;;
5294 esac
5295
5296 alphaieee_frag=/dev/null
5297 case $target in
5298   alpha*-*-*)
5299     # This just makes sure to use the -mieee option to build target libs.
5300     # This should probably be set individually by each library.
5301     alphaieee_frag="config/mt-alphaieee"
5302     ;;
5303 esac
5304
5305 # If --enable-target-optspace always use -Os instead of -O2 to build
5306 # the target libraries, similarly if it is not specified, use -Os
5307 # on selected platforms.
5308 ospace_frag=/dev/null
5309 case "${enable_target_optspace}:${target}" in
5310   yes:*)
5311     ospace_frag="config/mt-ospace"
5312     ;;
5313   :d30v-*)
5314     ospace_frag="config/mt-d30v"
5315     ;;
5316   :m32r-* | :d10v-* | :fr30-*)
5317     ospace_frag="config/mt-ospace"
5318     ;;
5319   no:* | :*)
5320     ;;
5321   *)
5322     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5323     ;;
5324 esac
5325
5326 # Default to using --with-stabs for certain targets.
5327 if test x${with_stabs} = x ; then
5328   case "${target}" in
5329   mips*-*-irix[56]*)
5330     ;;
5331   mips*-*-* | alpha*-*-osf*)
5332     with_stabs=yes;
5333     extra_host_args="${extra_host_args} --with-stabs"
5334     ;;
5335   esac
5336 fi
5337
5338 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5339 # them automatically.
5340 case "${host}" in
5341   hppa*64*-*-hpux11*)
5342     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5343     ;;
5344 esac
5345
5346 # Some systems (e.g., one of the i386-aix systems the gas testers are
5347 # using) don't handle "\$" correctly, so don't use it here.
5348 tooldir='${exec_prefix}'/${target_noncanonical}
5349 build_tooldir=${tooldir}
5350
5351 # Create a .gdbinit file which runs the one in srcdir
5352 # and tells GDB to look there for source files.
5353
5354 if test -r ${srcdir}/.gdbinit ; then
5355   case ${srcdir} in
5356     .) ;;
5357     *) cat > ./.gdbinit <<EOF
5358 # ${NO_EDIT}
5359 dir ${srcdir}
5360 dir .
5361 source ${srcdir}/.gdbinit
5362 EOF
5363     ;;
5364   esac
5365 fi
5366
5367 # Make sure that the compiler is able to generate an executable.  If it
5368 # can't, we are probably in trouble.  We don't care whether we can run the
5369 # executable--we might be using a cross compiler--we only care whether it
5370 # can be created.  At this point the main configure script has set CC.
5371 we_are_ok=no
5372 echo "int main () { return 0; }" > conftest.c
5373 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5374 if test $? = 0 ; then
5375   if test -s conftest || test -s conftest.exe ; then
5376     we_are_ok=yes
5377   fi
5378 fi
5379 case $we_are_ok in
5380   no)
5381     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5382     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5383     rm -f conftest*
5384     exit 1
5385     ;;
5386 esac
5387 rm -f conftest*
5388
5389 # The Solaris /usr/ucb/cc compiler does not appear to work.
5390 case "${host}" in
5391   sparc-sun-solaris2*)
5392       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5393       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5394           could_use=
5395           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5396           if test -d /opt/cygnus/bin ; then
5397               if test "$could_use" = "" ; then
5398                   could_use="/opt/cygnus/bin"
5399               else
5400                   could_use="$could_use or /opt/cygnus/bin"
5401               fi
5402           fi
5403         if test "$could_use" = "" ; then
5404             echo "Warning: compilation may fail because you're using"
5405             echo "/usr/ucb/cc.  You should change your PATH or CC "
5406             echo "variable and rerun configure."
5407         else
5408             echo "Warning: compilation may fail because you're using"
5409             echo "/usr/ucb/cc, when you should use the C compiler from"
5410             echo "$could_use.  You should change your"
5411             echo "PATH or CC variable and rerun configure."
5412         fi
5413       fi
5414   ;;
5415 esac
5416
5417 case "${host}" in
5418   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5419   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5420   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5421 esac
5422
5423 # Record target_configdirs and the configure arguments for target and
5424 # build configuration in Makefile.
5425 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5426 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5427
5428 # Determine whether gdb needs tk/tcl or not.
5429 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5430 # and in that case we want gdb to be built without tk.  Ugh!
5431 # In fact I believe gdb is the *only* package directly dependent on tk,
5432 # so we should be able to put the 'maybe's in unconditionally and
5433 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5434 # 100% sure that that's safe though.
5435
5436 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5437 case "$enable_gdbtk" in
5438   no)
5439     GDB_TK="" ;;
5440   yes)
5441     GDB_TK="${gdb_tk}" ;;
5442   *)
5443     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5444     # distro.  Eventually someone will fix this and move Insight, nee
5445     # gdbtk to a separate directory.
5446     if test -d ${srcdir}/gdb/gdbtk ; then
5447       GDB_TK="${gdb_tk}"
5448     else
5449       GDB_TK=""
5450     fi
5451     ;;
5452 esac
5453 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5454 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5455
5456 # Strip out unwanted targets.
5457
5458 # While at that, we remove Makefiles if we were started for recursive
5459 # configuration, so that the top-level Makefile reconfigures them,
5460 # like we used to do when configure itself was recursive.
5461
5462 # Loop over modules.  $extrasub must be used with care, limiting as
5463 # much as possible the usage of range addresses.  That's because autoconf
5464 # splits the sed script to overcome limits in the number of commands,
5465 # and relying on carefully-timed sed passes may turn out to be very hard
5466 # to maintain later.  In this particular case, you just have to be careful
5467 # not to nest @if/@endif pairs, because configure will not warn you at all.
5468
5469 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5470 if test "${enable_bootstrap+set}" = set; then
5471   enableval="$enable_bootstrap"
5472
5473 else
5474   enable_bootstrap=default
5475 fi;
5476
5477 # Issue errors and warnings for invalid/strange bootstrap combinations.
5478 case "$configdirs" in
5479   *gcc*) have_compiler=yes ;;
5480   *) have_compiler=no ;;
5481 esac
5482
5483 case "$have_compiler:$host:$target:$enable_bootstrap" in
5484   *:*:*:no) ;;
5485
5486   # Default behavior.  Enable bootstrap if we have a compiler
5487   # and we are in a native configuration.
5488   yes:$build:$build:default)
5489     enable_bootstrap=yes ;;
5490
5491   *:*:*:default)
5492     enable_bootstrap=no ;;
5493
5494   # We have a compiler and we are in a native configuration, bootstrap is ok
5495   yes:$build:$build:yes)
5496     ;;
5497
5498   # Other configurations, but we have a compiler.  Assume the user knows
5499   # what he's doing.
5500   yes:*:*:yes)
5501     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5502 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5503     ;;
5504
5505   # No compiler: if they passed --enable-bootstrap explicitly, fail
5506   no:*:*:yes)
5507     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5508 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5509    { (exit 1); exit 1; }; } ;;
5510
5511   # Fail if wrong command line
5512   *)
5513     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5514 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5515    { (exit 1); exit 1; }; }
5516     ;;
5517 esac
5518
5519 # Adjust the toplevel makefile according to whether bootstrap was selected.
5520 case "$enable_bootstrap" in
5521   yes)
5522     bootstrap_suffix=bootstrap ;;
5523   no)
5524     bootstrap_suffix=no-bootstrap ;;
5525 esac
5526
5527 for module in ${build_configdirs} ; do
5528   if test -z "${no_recursion}" \
5529      && test -f ${build_subdir}/${module}/Makefile; then
5530     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5531     rm -f ${build_subdir}/${module}/Makefile
5532   fi
5533   extrasub="$extrasub
5534 /^@if build-$module\$/d
5535 /^@endif build-$module\$/d
5536 /^@if build-$module-$bootstrap_suffix\$/d
5537 /^@endif build-$module-$bootstrap_suffix\$/d"
5538 done
5539 for module in ${configdirs} ; do
5540   if test -z "${no_recursion}"; then
5541     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5542       if test -f ${file}; then
5543         echo 1>&2 "*** removing ${file} to force reconfigure"
5544         rm -f ${file}
5545       fi
5546     done
5547   fi
5548   extrasub="$extrasub
5549 /^@if $module\$/d
5550 /^@endif $module\$/d
5551 /^@if $module-$bootstrap_suffix\$/d
5552 /^@endif $module-$bootstrap_suffix\$/d"
5553 done
5554 for module in ${target_configdirs} ; do
5555   if test -z "${no_recursion}" \
5556      && test -f ${target_subdir}/${module}/Makefile; then
5557     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5558     rm -f ${target_subdir}/${module}/Makefile
5559   fi
5560   extrasub="$extrasub
5561 /^@if target-$module\$/d
5562 /^@endif target-$module\$/d
5563 /^@if target-$module-$bootstrap_suffix\$/d
5564 /^@endif target-$module-$bootstrap_suffix\$/d"
5565 done
5566
5567 extrasub="$extrasub
5568 /^@if /,/^@endif /d"
5569
5570 # Create the serialization dependencies.  This uses a temporary file.
5571
5572 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5573 if test "${enable_serial_configure+set}" = set; then
5574   enableval="$enable_serial_configure"
5575
5576 fi;
5577
5578 case ${enable_serial_configure} in
5579   yes)
5580     enable_serial_build_configure=yes
5581     enable_serial_host_configure=yes
5582     enable_serial_target_configure=yes
5583     ;;
5584 esac
5585
5586 # These force 'configure's to be done one at a time, to avoid problems
5587 # with contention over a shared config.cache.
5588 rm -f serdep.tmp
5589 echo '# serdep.tmp' > serdep.tmp
5590 olditem=
5591 test "x${enable_serial_build_configure}" = xyes &&
5592 for item in ${build_configdirs} ; do
5593   case ${olditem} in
5594     "") ;;
5595     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5596   esac
5597   olditem=${item}
5598 done
5599 olditem=
5600 test "x${enable_serial_host_configure}" = xyes &&
5601 for item in ${configdirs} ; do
5602   case ${olditem} in
5603     "") ;;
5604     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5605   esac
5606   olditem=${item}
5607 done
5608 olditem=
5609 test "x${enable_serial_target_configure}" = xyes &&
5610 for item in ${target_configdirs} ; do
5611   case ${olditem} in
5612     "") ;;
5613     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5614   esac
5615   olditem=${item}
5616 done
5617 serialization_dependencies=serdep.tmp
5618
5619
5620 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5621 # target, nonopt, and variable assignments.  These are the ones we
5622 # might not want to pass down to subconfigures.  Also strip
5623 # program-prefix, program-suffix, and program-transform-name, so that
5624 # we can pass down a consistent program-transform-name.
5625 baseargs=
5626 keep_next=no
5627 skip_next=no
5628 eval "set -- $ac_configure_args"
5629 for ac_arg
5630 do
5631   if test X"$skip_next" = X"yes"; then
5632     skip_next=no
5633     continue
5634   fi
5635   if test X"$keep_next" = X"yes"; then
5636     case $ac_arg in
5637       *\'*)
5638         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5639     esac
5640     baseargs="$baseargs '$ac_arg'"
5641     keep_next=no
5642     continue
5643   fi
5644
5645   # Handle separated arguments.  Based on the logic generated by
5646   # autoconf 2.59.
5647   case $ac_arg in
5648     *=* | --config-cache | -C | -disable-* | --disable-* \
5649       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5650       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5651       | -with-* | --with-* | -without-* | --without-* | --x)
5652       separate_arg=no
5653       ;;
5654     -*)
5655       separate_arg=yes
5656       ;;
5657     *)
5658       separate_arg=no
5659       ;;
5660   esac
5661
5662   case "$ac_arg" in
5663     --no*)
5664       continue
5665       ;;
5666     --c* | \
5667     --sr* | \
5668     --ho* | \
5669     --bu* | \
5670     --t* | \
5671     --program-* | \
5672     -cache_file* | \
5673     -srcdir* | \
5674     -host* | \
5675     -build* | \
5676     -target* | \
5677     -program-prefix* | \
5678     -program-suffix* | \
5679     -program-transform-name* )
5680       skip_next=$separate_arg
5681       continue
5682       ;;
5683     -*)
5684       # An option.  Add it.
5685       case $ac_arg in
5686         *\'*)
5687           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5688       esac
5689       baseargs="$baseargs '$ac_arg'"
5690       keep_next=$separate_arg
5691       ;;
5692     *)
5693       # Either a variable assignment, or a nonopt (triplet).  Don't
5694       # pass it down; let the Makefile handle this.
5695       continue
5696       ;;
5697   esac
5698 done
5699 # Remove the initial space we just introduced and, as these will be
5700 # expanded by make, quote '$'.
5701 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5702
5703 # Add in --program-transform-name, after --program-prefix and
5704 # --program-suffix have been applied to it.  Autoconf has already
5705 # doubled dollar signs and backslashes in program_transform_name; we want
5706 # the backslashes un-doubled, and then the entire thing wrapped in single
5707 # quotes, because this will be expanded first by make and then by the shell.
5708 # Also, because we want to override the logic in subdir configure scripts to
5709 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5710 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5711 ${program_transform_name}
5712 EOF_SED
5713 gcc_transform_name=`cat conftestsed.out`
5714 rm -f conftestsed.out
5715 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5716 if test "$silent" = yes; then
5717   baseargs="$baseargs --silent"
5718 fi
5719
5720 # For the build-side libraries, we just need to pretend we're native,
5721 # and not use the same cache file.  Multilibs are neither needed nor
5722 # desired.
5723 build_configargs="--cache-file=../config.cache ${baseargs}"
5724
5725 # For host modules, accept cache file option, or specification as blank.
5726 case "${cache_file}" in
5727 "") # empty
5728   cache_file_option="" ;;
5729 /* | [A-Za-z]:[\\/]* ) # absolute path
5730   cache_file_option="--cache-file=${cache_file}" ;;
5731 *) # relative path
5732   cache_file_option="--cache-file=../${cache_file}" ;;
5733 esac
5734
5735 # Host dirs don't like to share a cache file either, horribly enough.
5736 # This seems to be due to autoconf 2.5x stupidity.
5737 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5738
5739 target_configargs=${baseargs}
5740
5741 # Passing a --with-cross-host argument lets the target libraries know
5742 # whether they are being built with a cross-compiler or being built
5743 # native.  However, it would be better to use other mechanisms to make the
5744 # sorts of decisions they want to make on this basis.  Please consider
5745 # this option to be deprecated.  FIXME.
5746 if test x${is_cross_compiler} = xyes ; then
5747   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5748 fi
5749
5750 # Default to --enable-multilib.
5751 if test x${enable_multilib} = x ; then
5752   target_configargs="--enable-multilib ${target_configargs}"
5753 fi
5754
5755 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5756 # changed from the earlier setting of with_newlib.
5757 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5758   target_configargs="--with-newlib ${target_configargs}"
5759 fi
5760
5761 # Different target subdirs use different values of certain variables
5762 # (notably CXX).  Worse, multilibs use *lots* of different values.
5763 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5764 # it doesn't automatically accept command-line overrides of them.
5765 # This means it's not safe for target subdirs to share a cache file,
5766 # which is disgusting, but there you have it.  Hopefully this can be
5767 # fixed in future.  It's still worthwhile to use a cache file for each
5768 # directory.  I think.
5769
5770 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5771 # We need to pass --target, as newer autoconf's requires consistency
5772 # for target_alias and gcc doesn't manage it consistently.
5773 target_configargs="--cache-file=./config.cache ${target_configargs}"
5774
5775 FLAGS_FOR_TARGET=
5776 case " $target_configdirs " in
5777  *" newlib "*)
5778   case " $target_configargs " in
5779   *" --with-newlib "*)
5780    case "$target" in
5781    *-cygwin*)
5782      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' ;;
5783    esac
5784
5785    # If we're not building GCC, don't discard standard headers.
5786    if test -d ${srcdir}/gcc; then
5787      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5788
5789      if test "${build}" != "${host}"; then
5790        # On Canadian crosses, CC_FOR_TARGET will have already been set
5791        # by `configure', so we won't have an opportunity to add -Bgcc/
5792        # to it.  This is right: we don't want to search that directory
5793        # for binaries, but we want the header files in there, so add
5794        # them explicitly.
5795        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5796
5797        # Someone might think of using the pre-installed headers on
5798        # Canadian crosses, in case the installed compiler is not fully
5799        # compatible with the compiler being built.  In this case, it
5800        # would be better to flag an error than risking having
5801        # incompatible object files being constructed.  We can't
5802        # guarantee that an error will be flagged, but let's hope the
5803        # compiler will do it, when presented with incompatible header
5804        # files.
5805      fi
5806    fi
5807
5808    case "${target}-${is_cross_compiler}" in
5809    i[3456789]86-*-linux*-no)
5810       # Here host == target, so we don't need to build gcc,
5811       # so we don't want to discard standard headers.
5812       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5813       ;;
5814    *)
5815       # If we're building newlib, use its generic headers last, but search
5816       # for any libc-related directories first (so make it the last -B
5817       # switch).
5818       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5819
5820       # If we're building libgloss, find the startup file, simulator library
5821       # and linker script.
5822       case " $target_configdirs " in
5823         *" libgloss "*)
5824         # Look for startup file, simulator library and maybe linker script.
5825         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
5826         # Look for libnosys.a in case the target needs it.
5827         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5828         # Most targets have the linker script in the source directory.
5829         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
5830         ;;
5831       esac
5832       ;;
5833    esac
5834    ;;
5835   esac
5836   ;;
5837 esac
5838 case "$target" in
5839 *-mingw*)
5840   # Can't be handled as Cygwin above since Mingw does not use newlib.
5841   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' ;;
5842 esac
5843
5844 # Allow the user to override the flags for
5845 # our build compiler if desired.
5846 CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5847
5848 # On Canadian crosses, we'll be searching the right directories for
5849 # the previously-installed cross compiler, so don't bother to add
5850 # flags for directories within the install tree of the compiler
5851 # being built; programs in there won't even run.
5852 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5853   # Search for pre-installed headers if nothing else fits.
5854   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5855 fi
5856
5857 if test "x${use_gnu_ld}" = x &&
5858    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5859   # Arrange for us to find uninstalled linker scripts.
5860   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5861 fi
5862
5863 # Search for other target-specific linker scripts and such.
5864 case "${target}" in
5865   mep*)
5866     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5867     ;;
5868 esac
5869
5870 # Makefile fragments.
5871 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5872 do
5873   eval fragval=\$$frag
5874   if test $fragval != /dev/null; then
5875     eval $frag=${srcdir}/$fragval
5876   fi
5877 done
5878
5879
5880
5881
5882
5883 # Miscellanea: directories, flags, etc.
5884
5885
5886
5887
5888
5889
5890
5891 # Build module lists & subconfigure args.
5892
5893
5894
5895 # Host module lists & subconfigure args.
5896
5897
5898
5899 # Target module lists & subconfigure args.
5900
5901
5902
5903 # Build tools.
5904
5905
5906
5907 # Generate default definitions for YACC, M4, LEX and other programs that run
5908 # on the build machine.  These are used if the Makefile can't locate these
5909 # programs in objdir.
5910 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5911
5912 for ac_prog in 'bison -y' byacc yacc
5913 do
5914   # Extract the first word of "$ac_prog", so it can be a program name with args.
5915 set dummy $ac_prog; ac_word=$2
5916 echo "$as_me:$LINENO: checking for $ac_word" >&5
5917 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5918 if test "${ac_cv_prog_YACC+set}" = set; then
5919   echo $ECHO_N "(cached) $ECHO_C" >&6
5920 else
5921   if test -n "$YACC"; then
5922   ac_cv_prog_YACC="$YACC" # Let the user override the test.
5923 else
5924 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5925 for as_dir in $PATH
5926 do
5927   IFS=$as_save_IFS
5928   test -z "$as_dir" && as_dir=.
5929   for ac_exec_ext in '' $ac_executable_extensions; do
5930   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5931     ac_cv_prog_YACC="$ac_prog"
5932     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5933     break 2
5934   fi
5935 done
5936 done
5937
5938 fi
5939 fi
5940 YACC=$ac_cv_prog_YACC
5941 if test -n "$YACC"; then
5942   echo "$as_me:$LINENO: result: $YACC" >&5
5943 echo "${ECHO_T}$YACC" >&6
5944 else
5945   echo "$as_me:$LINENO: result: no" >&5
5946 echo "${ECHO_T}no" >&6
5947 fi
5948
5949   test -n "$YACC" && break
5950 done
5951 test -n "$YACC" || YACC="$MISSING bison -y"
5952
5953 case " $build_configdirs " in
5954   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
5955   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
5956 esac
5957
5958 for ac_prog in bison
5959 do
5960   # Extract the first word of "$ac_prog", so it can be a program name with args.
5961 set dummy $ac_prog; ac_word=$2
5962 echo "$as_me:$LINENO: checking for $ac_word" >&5
5963 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5964 if test "${ac_cv_prog_BISON+set}" = set; then
5965   echo $ECHO_N "(cached) $ECHO_C" >&6
5966 else
5967   if test -n "$BISON"; then
5968   ac_cv_prog_BISON="$BISON" # Let the user override the test.
5969 else
5970 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5971 for as_dir in $PATH
5972 do
5973   IFS=$as_save_IFS
5974   test -z "$as_dir" && as_dir=.
5975   for ac_exec_ext in '' $ac_executable_extensions; do
5976   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5977     ac_cv_prog_BISON="$ac_prog"
5978     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5979     break 2
5980   fi
5981 done
5982 done
5983
5984 fi
5985 fi
5986 BISON=$ac_cv_prog_BISON
5987 if test -n "$BISON"; then
5988   echo "$as_me:$LINENO: result: $BISON" >&5
5989 echo "${ECHO_T}$BISON" >&6
5990 else
5991   echo "$as_me:$LINENO: result: no" >&5
5992 echo "${ECHO_T}no" >&6
5993 fi
5994
5995   test -n "$BISON" && break
5996 done
5997 test -n "$BISON" || BISON="$MISSING bison"
5998
5999 case " $build_configdirs " in
6000   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6001 esac
6002
6003 for ac_prog in gm4 gnum4 m4
6004 do
6005   # Extract the first word of "$ac_prog", so it can be a program name with args.
6006 set dummy $ac_prog; ac_word=$2
6007 echo "$as_me:$LINENO: checking for $ac_word" >&5
6008 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6009 if test "${ac_cv_prog_M4+set}" = set; then
6010   echo $ECHO_N "(cached) $ECHO_C" >&6
6011 else
6012   if test -n "$M4"; then
6013   ac_cv_prog_M4="$M4" # Let the user override the test.
6014 else
6015 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6016 for as_dir in $PATH
6017 do
6018   IFS=$as_save_IFS
6019   test -z "$as_dir" && as_dir=.
6020   for ac_exec_ext in '' $ac_executable_extensions; do
6021   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6022     ac_cv_prog_M4="$ac_prog"
6023     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6024     break 2
6025   fi
6026 done
6027 done
6028
6029 fi
6030 fi
6031 M4=$ac_cv_prog_M4
6032 if test -n "$M4"; then
6033   echo "$as_me:$LINENO: result: $M4" >&5
6034 echo "${ECHO_T}$M4" >&6
6035 else
6036   echo "$as_me:$LINENO: result: no" >&5
6037 echo "${ECHO_T}no" >&6
6038 fi
6039
6040   test -n "$M4" && break
6041 done
6042 test -n "$M4" || M4="$MISSING m4"
6043
6044 case " $build_configdirs " in
6045   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6046 esac
6047
6048 for ac_prog in flex lex
6049 do
6050   # Extract the first word of "$ac_prog", so it can be a program name with args.
6051 set dummy $ac_prog; ac_word=$2
6052 echo "$as_me:$LINENO: checking for $ac_word" >&5
6053 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6054 if test "${ac_cv_prog_LEX+set}" = set; then
6055   echo $ECHO_N "(cached) $ECHO_C" >&6
6056 else
6057   if test -n "$LEX"; then
6058   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6059 else
6060 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6061 for as_dir in $PATH
6062 do
6063   IFS=$as_save_IFS
6064   test -z "$as_dir" && as_dir=.
6065   for ac_exec_ext in '' $ac_executable_extensions; do
6066   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6067     ac_cv_prog_LEX="$ac_prog"
6068     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6069     break 2
6070   fi
6071 done
6072 done
6073
6074 fi
6075 fi
6076 LEX=$ac_cv_prog_LEX
6077 if test -n "$LEX"; then
6078   echo "$as_me:$LINENO: result: $LEX" >&5
6079 echo "${ECHO_T}$LEX" >&6
6080 else
6081   echo "$as_me:$LINENO: result: no" >&5
6082 echo "${ECHO_T}no" >&6
6083 fi
6084
6085   test -n "$LEX" && break
6086 done
6087 test -n "$LEX" || LEX="$MISSING flex"
6088
6089 case " $build_configdirs " in
6090   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6091   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6092 esac
6093
6094 for ac_prog in flex
6095 do
6096   # Extract the first word of "$ac_prog", so it can be a program name with args.
6097 set dummy $ac_prog; ac_word=$2
6098 echo "$as_me:$LINENO: checking for $ac_word" >&5
6099 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6100 if test "${ac_cv_prog_FLEX+set}" = set; then
6101   echo $ECHO_N "(cached) $ECHO_C" >&6
6102 else
6103   if test -n "$FLEX"; then
6104   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6105 else
6106 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6107 for as_dir in $PATH
6108 do
6109   IFS=$as_save_IFS
6110   test -z "$as_dir" && as_dir=.
6111   for ac_exec_ext in '' $ac_executable_extensions; do
6112   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6113     ac_cv_prog_FLEX="$ac_prog"
6114     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6115     break 2
6116   fi
6117 done
6118 done
6119
6120 fi
6121 fi
6122 FLEX=$ac_cv_prog_FLEX
6123 if test -n "$FLEX"; then
6124   echo "$as_me:$LINENO: result: $FLEX" >&5
6125 echo "${ECHO_T}$FLEX" >&6
6126 else
6127   echo "$as_me:$LINENO: result: no" >&5
6128 echo "${ECHO_T}no" >&6
6129 fi
6130
6131   test -n "$FLEX" && break
6132 done
6133 test -n "$FLEX" || FLEX="$MISSING flex"
6134
6135 case " $build_configdirs " in
6136   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6137 esac
6138
6139 for ac_prog in makeinfo
6140 do
6141   # Extract the first word of "$ac_prog", so it can be a program name with args.
6142 set dummy $ac_prog; ac_word=$2
6143 echo "$as_me:$LINENO: checking for $ac_word" >&5
6144 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6145 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6146   echo $ECHO_N "(cached) $ECHO_C" >&6
6147 else
6148   if test -n "$MAKEINFO"; then
6149   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6150 else
6151 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6152 for as_dir in $PATH
6153 do
6154   IFS=$as_save_IFS
6155   test -z "$as_dir" && as_dir=.
6156   for ac_exec_ext in '' $ac_executable_extensions; do
6157   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6158     ac_cv_prog_MAKEINFO="$ac_prog"
6159     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6160     break 2
6161   fi
6162 done
6163 done
6164
6165 fi
6166 fi
6167 MAKEINFO=$ac_cv_prog_MAKEINFO
6168 if test -n "$MAKEINFO"; then
6169   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6170 echo "${ECHO_T}$MAKEINFO" >&6
6171 else
6172   echo "$as_me:$LINENO: result: no" >&5
6173 echo "${ECHO_T}no" >&6
6174 fi
6175
6176   test -n "$MAKEINFO" && break
6177 done
6178 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6179
6180 case " $build_configdirs " in
6181   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6182   *)
6183
6184     # For an installed makeinfo, we require it to be from texinfo 4.4 or
6185     # higher, else we use the "missing" dummy.
6186     if ${MAKEINFO} --version \
6187        | egrep 'texinfo[^0-9]*([1-3][0-9]|4\.[4-9]|[5-9])' >/dev/null 2>&1; then
6188       :
6189     else
6190       MAKEINFO="$MISSING makeinfo"
6191     fi
6192     ;;
6193
6194 esac
6195
6196 # FIXME: expect and dejagnu may become build tools?
6197
6198 for ac_prog in expect
6199 do
6200   # Extract the first word of "$ac_prog", so it can be a program name with args.
6201 set dummy $ac_prog; ac_word=$2
6202 echo "$as_me:$LINENO: checking for $ac_word" >&5
6203 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6204 if test "${ac_cv_prog_EXPECT+set}" = set; then
6205   echo $ECHO_N "(cached) $ECHO_C" >&6
6206 else
6207   if test -n "$EXPECT"; then
6208   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6209 else
6210 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6211 for as_dir in $PATH
6212 do
6213   IFS=$as_save_IFS
6214   test -z "$as_dir" && as_dir=.
6215   for ac_exec_ext in '' $ac_executable_extensions; do
6216   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6217     ac_cv_prog_EXPECT="$ac_prog"
6218     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6219     break 2
6220   fi
6221 done
6222 done
6223
6224 fi
6225 fi
6226 EXPECT=$ac_cv_prog_EXPECT
6227 if test -n "$EXPECT"; then
6228   echo "$as_me:$LINENO: result: $EXPECT" >&5
6229 echo "${ECHO_T}$EXPECT" >&6
6230 else
6231   echo "$as_me:$LINENO: result: no" >&5
6232 echo "${ECHO_T}no" >&6
6233 fi
6234
6235   test -n "$EXPECT" && break
6236 done
6237 test -n "$EXPECT" || EXPECT="expect"
6238
6239 case " $configdirs " in
6240   *" expect "*)
6241     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6242     ;;
6243 esac
6244
6245 for ac_prog in runtest
6246 do
6247   # Extract the first word of "$ac_prog", so it can be a program name with args.
6248 set dummy $ac_prog; ac_word=$2
6249 echo "$as_me:$LINENO: checking for $ac_word" >&5
6250 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6251 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6252   echo $ECHO_N "(cached) $ECHO_C" >&6
6253 else
6254   if test -n "$RUNTEST"; then
6255   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6256 else
6257 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6258 for as_dir in $PATH
6259 do
6260   IFS=$as_save_IFS
6261   test -z "$as_dir" && as_dir=.
6262   for ac_exec_ext in '' $ac_executable_extensions; do
6263   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6264     ac_cv_prog_RUNTEST="$ac_prog"
6265     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6266     break 2
6267   fi
6268 done
6269 done
6270
6271 fi
6272 fi
6273 RUNTEST=$ac_cv_prog_RUNTEST
6274 if test -n "$RUNTEST"; then
6275   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6276 echo "${ECHO_T}$RUNTEST" >&6
6277 else
6278   echo "$as_me:$LINENO: result: no" >&5
6279 echo "${ECHO_T}no" >&6
6280 fi
6281
6282   test -n "$RUNTEST" && break
6283 done
6284 test -n "$RUNTEST" || RUNTEST="runtest"
6285
6286 case " $configdirs " in
6287   *" dejagnu "*)
6288     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6289     ;;
6290 esac
6291
6292
6293 # Host tools.
6294 ncn_tool_prefix=
6295 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6296 ncn_target_tool_prefix=
6297 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6298
6299
6300
6301 if test -n "$AR"; then
6302   ac_cv_prog_AR=$AR
6303 elif test -n "$ac_cv_prog_AR"; then
6304   AR=$ac_cv_prog_AR
6305 fi
6306
6307 if test -n "$ac_cv_prog_AR"; then
6308   for ncn_progname in ar; do
6309     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6310 set dummy ${ncn_progname}; ac_word=$2
6311 echo "$as_me:$LINENO: checking for $ac_word" >&5
6312 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6313 if test "${ac_cv_prog_AR+set}" = set; then
6314   echo $ECHO_N "(cached) $ECHO_C" >&6
6315 else
6316   if test -n "$AR"; then
6317   ac_cv_prog_AR="$AR" # Let the user override the test.
6318 else
6319 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6320 for as_dir in $PATH
6321 do
6322   IFS=$as_save_IFS
6323   test -z "$as_dir" && as_dir=.
6324   for ac_exec_ext in '' $ac_executable_extensions; do
6325   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6326     ac_cv_prog_AR="${ncn_progname}"
6327     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6328     break 2
6329   fi
6330 done
6331 done
6332
6333 fi
6334 fi
6335 AR=$ac_cv_prog_AR
6336 if test -n "$AR"; then
6337   echo "$as_me:$LINENO: result: $AR" >&5
6338 echo "${ECHO_T}$AR" >&6
6339 else
6340   echo "$as_me:$LINENO: result: no" >&5
6341 echo "${ECHO_T}no" >&6
6342 fi
6343
6344   done
6345 fi
6346
6347 for ncn_progname in ar; do
6348   if test -n "$ncn_tool_prefix"; then
6349     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6350 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6351 echo "$as_me:$LINENO: checking for $ac_word" >&5
6352 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6353 if test "${ac_cv_prog_AR+set}" = set; then
6354   echo $ECHO_N "(cached) $ECHO_C" >&6
6355 else
6356   if test -n "$AR"; then
6357   ac_cv_prog_AR="$AR" # Let the user override the test.
6358 else
6359 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6360 for as_dir in $PATH
6361 do
6362   IFS=$as_save_IFS
6363   test -z "$as_dir" && as_dir=.
6364   for ac_exec_ext in '' $ac_executable_extensions; do
6365   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6366     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6367     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6368     break 2
6369   fi
6370 done
6371 done
6372
6373 fi
6374 fi
6375 AR=$ac_cv_prog_AR
6376 if test -n "$AR"; then
6377   echo "$as_me:$LINENO: result: $AR" >&5
6378 echo "${ECHO_T}$AR" >&6
6379 else
6380   echo "$as_me:$LINENO: result: no" >&5
6381 echo "${ECHO_T}no" >&6
6382 fi
6383
6384   fi
6385   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6386     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6387 set dummy ${ncn_progname}; ac_word=$2
6388 echo "$as_me:$LINENO: checking for $ac_word" >&5
6389 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6390 if test "${ac_cv_prog_AR+set}" = set; then
6391   echo $ECHO_N "(cached) $ECHO_C" >&6
6392 else
6393   if test -n "$AR"; then
6394   ac_cv_prog_AR="$AR" # Let the user override the test.
6395 else
6396 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6397 for as_dir in $PATH
6398 do
6399   IFS=$as_save_IFS
6400   test -z "$as_dir" && as_dir=.
6401   for ac_exec_ext in '' $ac_executable_extensions; do
6402   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6403     ac_cv_prog_AR="${ncn_progname}"
6404     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6405     break 2
6406   fi
6407 done
6408 done
6409
6410 fi
6411 fi
6412 AR=$ac_cv_prog_AR
6413 if test -n "$AR"; then
6414   echo "$as_me:$LINENO: result: $AR" >&5
6415 echo "${ECHO_T}$AR" >&6
6416 else
6417   echo "$as_me:$LINENO: result: no" >&5
6418 echo "${ECHO_T}no" >&6
6419 fi
6420
6421   fi
6422   test -n "$ac_cv_prog_AR" && break
6423 done
6424
6425 if test -z "$ac_cv_prog_AR" ; then
6426   set dummy ar
6427   if test $build = $host ; then
6428     AR="$2"
6429   else
6430     AR="${ncn_tool_prefix}$2"
6431   fi
6432 fi
6433
6434
6435
6436 if test -n "$AS"; then
6437   ac_cv_prog_AS=$AS
6438 elif test -n "$ac_cv_prog_AS"; then
6439   AS=$ac_cv_prog_AS
6440 fi
6441
6442 if test -n "$ac_cv_prog_AS"; then
6443   for ncn_progname in as; do
6444     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6445 set dummy ${ncn_progname}; ac_word=$2
6446 echo "$as_me:$LINENO: checking for $ac_word" >&5
6447 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6448 if test "${ac_cv_prog_AS+set}" = set; then
6449   echo $ECHO_N "(cached) $ECHO_C" >&6
6450 else
6451   if test -n "$AS"; then
6452   ac_cv_prog_AS="$AS" # Let the user override the test.
6453 else
6454 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6455 for as_dir in $PATH
6456 do
6457   IFS=$as_save_IFS
6458   test -z "$as_dir" && as_dir=.
6459   for ac_exec_ext in '' $ac_executable_extensions; do
6460   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6461     ac_cv_prog_AS="${ncn_progname}"
6462     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6463     break 2
6464   fi
6465 done
6466 done
6467
6468 fi
6469 fi
6470 AS=$ac_cv_prog_AS
6471 if test -n "$AS"; then
6472   echo "$as_me:$LINENO: result: $AS" >&5
6473 echo "${ECHO_T}$AS" >&6
6474 else
6475   echo "$as_me:$LINENO: result: no" >&5
6476 echo "${ECHO_T}no" >&6
6477 fi
6478
6479   done
6480 fi
6481
6482 for ncn_progname in as; do
6483   if test -n "$ncn_tool_prefix"; then
6484     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6485 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6486 echo "$as_me:$LINENO: checking for $ac_word" >&5
6487 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6488 if test "${ac_cv_prog_AS+set}" = set; then
6489   echo $ECHO_N "(cached) $ECHO_C" >&6
6490 else
6491   if test -n "$AS"; then
6492   ac_cv_prog_AS="$AS" # Let the user override the test.
6493 else
6494 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6495 for as_dir in $PATH
6496 do
6497   IFS=$as_save_IFS
6498   test -z "$as_dir" && as_dir=.
6499   for ac_exec_ext in '' $ac_executable_extensions; do
6500   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6501     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6502     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6503     break 2
6504   fi
6505 done
6506 done
6507
6508 fi
6509 fi
6510 AS=$ac_cv_prog_AS
6511 if test -n "$AS"; then
6512   echo "$as_me:$LINENO: result: $AS" >&5
6513 echo "${ECHO_T}$AS" >&6
6514 else
6515   echo "$as_me:$LINENO: result: no" >&5
6516 echo "${ECHO_T}no" >&6
6517 fi
6518
6519   fi
6520   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6521     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6522 set dummy ${ncn_progname}; ac_word=$2
6523 echo "$as_me:$LINENO: checking for $ac_word" >&5
6524 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6525 if test "${ac_cv_prog_AS+set}" = set; then
6526   echo $ECHO_N "(cached) $ECHO_C" >&6
6527 else
6528   if test -n "$AS"; then
6529   ac_cv_prog_AS="$AS" # Let the user override the test.
6530 else
6531 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6532 for as_dir in $PATH
6533 do
6534   IFS=$as_save_IFS
6535   test -z "$as_dir" && as_dir=.
6536   for ac_exec_ext in '' $ac_executable_extensions; do
6537   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6538     ac_cv_prog_AS="${ncn_progname}"
6539     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6540     break 2
6541   fi
6542 done
6543 done
6544
6545 fi
6546 fi
6547 AS=$ac_cv_prog_AS
6548 if test -n "$AS"; then
6549   echo "$as_me:$LINENO: result: $AS" >&5
6550 echo "${ECHO_T}$AS" >&6
6551 else
6552   echo "$as_me:$LINENO: result: no" >&5
6553 echo "${ECHO_T}no" >&6
6554 fi
6555
6556   fi
6557   test -n "$ac_cv_prog_AS" && break
6558 done
6559
6560 if test -z "$ac_cv_prog_AS" ; then
6561   set dummy as
6562   if test $build = $host ; then
6563     AS="$2"
6564   else
6565     AS="${ncn_tool_prefix}$2"
6566   fi
6567 fi
6568
6569
6570
6571 if test -n "$DLLTOOL"; then
6572   ac_cv_prog_DLLTOOL=$DLLTOOL
6573 elif test -n "$ac_cv_prog_DLLTOOL"; then
6574   DLLTOOL=$ac_cv_prog_DLLTOOL
6575 fi
6576
6577 if test -n "$ac_cv_prog_DLLTOOL"; then
6578   for ncn_progname in dlltool; do
6579     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6580 set dummy ${ncn_progname}; ac_word=$2
6581 echo "$as_me:$LINENO: checking for $ac_word" >&5
6582 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6583 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6584   echo $ECHO_N "(cached) $ECHO_C" >&6
6585 else
6586   if test -n "$DLLTOOL"; then
6587   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6588 else
6589 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6590 for as_dir in $PATH
6591 do
6592   IFS=$as_save_IFS
6593   test -z "$as_dir" && as_dir=.
6594   for ac_exec_ext in '' $ac_executable_extensions; do
6595   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6596     ac_cv_prog_DLLTOOL="${ncn_progname}"
6597     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6598     break 2
6599   fi
6600 done
6601 done
6602
6603 fi
6604 fi
6605 DLLTOOL=$ac_cv_prog_DLLTOOL
6606 if test -n "$DLLTOOL"; then
6607   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6608 echo "${ECHO_T}$DLLTOOL" >&6
6609 else
6610   echo "$as_me:$LINENO: result: no" >&5
6611 echo "${ECHO_T}no" >&6
6612 fi
6613
6614   done
6615 fi
6616
6617 for ncn_progname in dlltool; do
6618   if test -n "$ncn_tool_prefix"; then
6619     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6620 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6621 echo "$as_me:$LINENO: checking for $ac_word" >&5
6622 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6623 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6624   echo $ECHO_N "(cached) $ECHO_C" >&6
6625 else
6626   if test -n "$DLLTOOL"; then
6627   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6628 else
6629 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6630 for as_dir in $PATH
6631 do
6632   IFS=$as_save_IFS
6633   test -z "$as_dir" && as_dir=.
6634   for ac_exec_ext in '' $ac_executable_extensions; do
6635   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6636     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6637     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6638     break 2
6639   fi
6640 done
6641 done
6642
6643 fi
6644 fi
6645 DLLTOOL=$ac_cv_prog_DLLTOOL
6646 if test -n "$DLLTOOL"; then
6647   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6648 echo "${ECHO_T}$DLLTOOL" >&6
6649 else
6650   echo "$as_me:$LINENO: result: no" >&5
6651 echo "${ECHO_T}no" >&6
6652 fi
6653
6654   fi
6655   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6656     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6657 set dummy ${ncn_progname}; ac_word=$2
6658 echo "$as_me:$LINENO: checking for $ac_word" >&5
6659 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6660 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6661   echo $ECHO_N "(cached) $ECHO_C" >&6
6662 else
6663   if test -n "$DLLTOOL"; then
6664   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6665 else
6666 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6667 for as_dir in $PATH
6668 do
6669   IFS=$as_save_IFS
6670   test -z "$as_dir" && as_dir=.
6671   for ac_exec_ext in '' $ac_executable_extensions; do
6672   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6673     ac_cv_prog_DLLTOOL="${ncn_progname}"
6674     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6675     break 2
6676   fi
6677 done
6678 done
6679
6680 fi
6681 fi
6682 DLLTOOL=$ac_cv_prog_DLLTOOL
6683 if test -n "$DLLTOOL"; then
6684   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6685 echo "${ECHO_T}$DLLTOOL" >&6
6686 else
6687   echo "$as_me:$LINENO: result: no" >&5
6688 echo "${ECHO_T}no" >&6
6689 fi
6690
6691   fi
6692   test -n "$ac_cv_prog_DLLTOOL" && break
6693 done
6694
6695 if test -z "$ac_cv_prog_DLLTOOL" ; then
6696   set dummy dlltool
6697   if test $build = $host ; then
6698     DLLTOOL="$2"
6699   else
6700     DLLTOOL="${ncn_tool_prefix}$2"
6701   fi
6702 fi
6703
6704
6705
6706 if test -n "$LD"; then
6707   ac_cv_prog_LD=$LD
6708 elif test -n "$ac_cv_prog_LD"; then
6709   LD=$ac_cv_prog_LD
6710 fi
6711
6712 if test -n "$ac_cv_prog_LD"; then
6713   for ncn_progname in ld; do
6714     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6715 set dummy ${ncn_progname}; ac_word=$2
6716 echo "$as_me:$LINENO: checking for $ac_word" >&5
6717 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6718 if test "${ac_cv_prog_LD+set}" = set; then
6719   echo $ECHO_N "(cached) $ECHO_C" >&6
6720 else
6721   if test -n "$LD"; then
6722   ac_cv_prog_LD="$LD" # Let the user override the test.
6723 else
6724 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6725 for as_dir in $PATH
6726 do
6727   IFS=$as_save_IFS
6728   test -z "$as_dir" && as_dir=.
6729   for ac_exec_ext in '' $ac_executable_extensions; do
6730   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6731     ac_cv_prog_LD="${ncn_progname}"
6732     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6733     break 2
6734   fi
6735 done
6736 done
6737
6738 fi
6739 fi
6740 LD=$ac_cv_prog_LD
6741 if test -n "$LD"; then
6742   echo "$as_me:$LINENO: result: $LD" >&5
6743 echo "${ECHO_T}$LD" >&6
6744 else
6745   echo "$as_me:$LINENO: result: no" >&5
6746 echo "${ECHO_T}no" >&6
6747 fi
6748
6749   done
6750 fi
6751
6752 for ncn_progname in ld; do
6753   if test -n "$ncn_tool_prefix"; then
6754     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6755 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6756 echo "$as_me:$LINENO: checking for $ac_word" >&5
6757 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6758 if test "${ac_cv_prog_LD+set}" = set; then
6759   echo $ECHO_N "(cached) $ECHO_C" >&6
6760 else
6761   if test -n "$LD"; then
6762   ac_cv_prog_LD="$LD" # Let the user override the test.
6763 else
6764 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6765 for as_dir in $PATH
6766 do
6767   IFS=$as_save_IFS
6768   test -z "$as_dir" && as_dir=.
6769   for ac_exec_ext in '' $ac_executable_extensions; do
6770   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6771     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6772     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6773     break 2
6774   fi
6775 done
6776 done
6777
6778 fi
6779 fi
6780 LD=$ac_cv_prog_LD
6781 if test -n "$LD"; then
6782   echo "$as_me:$LINENO: result: $LD" >&5
6783 echo "${ECHO_T}$LD" >&6
6784 else
6785   echo "$as_me:$LINENO: result: no" >&5
6786 echo "${ECHO_T}no" >&6
6787 fi
6788
6789   fi
6790   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6791     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6792 set dummy ${ncn_progname}; ac_word=$2
6793 echo "$as_me:$LINENO: checking for $ac_word" >&5
6794 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6795 if test "${ac_cv_prog_LD+set}" = set; then
6796   echo $ECHO_N "(cached) $ECHO_C" >&6
6797 else
6798   if test -n "$LD"; then
6799   ac_cv_prog_LD="$LD" # Let the user override the test.
6800 else
6801 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6802 for as_dir in $PATH
6803 do
6804   IFS=$as_save_IFS
6805   test -z "$as_dir" && as_dir=.
6806   for ac_exec_ext in '' $ac_executable_extensions; do
6807   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6808     ac_cv_prog_LD="${ncn_progname}"
6809     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6810     break 2
6811   fi
6812 done
6813 done
6814
6815 fi
6816 fi
6817 LD=$ac_cv_prog_LD
6818 if test -n "$LD"; then
6819   echo "$as_me:$LINENO: result: $LD" >&5
6820 echo "${ECHO_T}$LD" >&6
6821 else
6822   echo "$as_me:$LINENO: result: no" >&5
6823 echo "${ECHO_T}no" >&6
6824 fi
6825
6826   fi
6827   test -n "$ac_cv_prog_LD" && break
6828 done
6829
6830 if test -z "$ac_cv_prog_LD" ; then
6831   set dummy ld
6832   if test $build = $host ; then
6833     LD="$2"
6834   else
6835     LD="${ncn_tool_prefix}$2"
6836   fi
6837 fi
6838
6839
6840
6841 if test -n "$LIPO"; then
6842   ac_cv_prog_LIPO=$LIPO
6843 elif test -n "$ac_cv_prog_LIPO"; then
6844   LIPO=$ac_cv_prog_LIPO
6845 fi
6846
6847 if test -n "$ac_cv_prog_LIPO"; then
6848   for ncn_progname in lipo; do
6849     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6850 set dummy ${ncn_progname}; ac_word=$2
6851 echo "$as_me:$LINENO: checking for $ac_word" >&5
6852 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6853 if test "${ac_cv_prog_LIPO+set}" = set; then
6854   echo $ECHO_N "(cached) $ECHO_C" >&6
6855 else
6856   if test -n "$LIPO"; then
6857   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6858 else
6859 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6860 for as_dir in $PATH
6861 do
6862   IFS=$as_save_IFS
6863   test -z "$as_dir" && as_dir=.
6864   for ac_exec_ext in '' $ac_executable_extensions; do
6865   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6866     ac_cv_prog_LIPO="${ncn_progname}"
6867     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6868     break 2
6869   fi
6870 done
6871 done
6872
6873 fi
6874 fi
6875 LIPO=$ac_cv_prog_LIPO
6876 if test -n "$LIPO"; then
6877   echo "$as_me:$LINENO: result: $LIPO" >&5
6878 echo "${ECHO_T}$LIPO" >&6
6879 else
6880   echo "$as_me:$LINENO: result: no" >&5
6881 echo "${ECHO_T}no" >&6
6882 fi
6883
6884   done
6885 fi
6886
6887 for ncn_progname in lipo; do
6888   if test -n "$ncn_tool_prefix"; then
6889     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6890 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6891 echo "$as_me:$LINENO: checking for $ac_word" >&5
6892 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6893 if test "${ac_cv_prog_LIPO+set}" = set; then
6894   echo $ECHO_N "(cached) $ECHO_C" >&6
6895 else
6896   if test -n "$LIPO"; then
6897   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6898 else
6899 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6900 for as_dir in $PATH
6901 do
6902   IFS=$as_save_IFS
6903   test -z "$as_dir" && as_dir=.
6904   for ac_exec_ext in '' $ac_executable_extensions; do
6905   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6906     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6907     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6908     break 2
6909   fi
6910 done
6911 done
6912
6913 fi
6914 fi
6915 LIPO=$ac_cv_prog_LIPO
6916 if test -n "$LIPO"; then
6917   echo "$as_me:$LINENO: result: $LIPO" >&5
6918 echo "${ECHO_T}$LIPO" >&6
6919 else
6920   echo "$as_me:$LINENO: result: no" >&5
6921 echo "${ECHO_T}no" >&6
6922 fi
6923
6924   fi
6925   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
6926     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6927 set dummy ${ncn_progname}; ac_word=$2
6928 echo "$as_me:$LINENO: checking for $ac_word" >&5
6929 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6930 if test "${ac_cv_prog_LIPO+set}" = set; then
6931   echo $ECHO_N "(cached) $ECHO_C" >&6
6932 else
6933   if test -n "$LIPO"; then
6934   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6935 else
6936 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6937 for as_dir in $PATH
6938 do
6939   IFS=$as_save_IFS
6940   test -z "$as_dir" && as_dir=.
6941   for ac_exec_ext in '' $ac_executable_extensions; do
6942   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6943     ac_cv_prog_LIPO="${ncn_progname}"
6944     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6945     break 2
6946   fi
6947 done
6948 done
6949
6950 fi
6951 fi
6952 LIPO=$ac_cv_prog_LIPO
6953 if test -n "$LIPO"; then
6954   echo "$as_me:$LINENO: result: $LIPO" >&5
6955 echo "${ECHO_T}$LIPO" >&6
6956 else
6957   echo "$as_me:$LINENO: result: no" >&5
6958 echo "${ECHO_T}no" >&6
6959 fi
6960
6961   fi
6962   test -n "$ac_cv_prog_LIPO" && break
6963 done
6964
6965 if test -z "$ac_cv_prog_LIPO" ; then
6966   set dummy lipo
6967   if test $build = $host ; then
6968     LIPO="$2"
6969   else
6970     LIPO="${ncn_tool_prefix}$2"
6971   fi
6972 fi
6973
6974
6975
6976 if test -n "$NM"; then
6977   ac_cv_prog_NM=$NM
6978 elif test -n "$ac_cv_prog_NM"; then
6979   NM=$ac_cv_prog_NM
6980 fi
6981
6982 if test -n "$ac_cv_prog_NM"; then
6983   for ncn_progname in nm; do
6984     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6985 set dummy ${ncn_progname}; ac_word=$2
6986 echo "$as_me:$LINENO: checking for $ac_word" >&5
6987 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6988 if test "${ac_cv_prog_NM+set}" = set; then
6989   echo $ECHO_N "(cached) $ECHO_C" >&6
6990 else
6991   if test -n "$NM"; then
6992   ac_cv_prog_NM="$NM" # Let the user override the test.
6993 else
6994 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6995 for as_dir in $PATH
6996 do
6997   IFS=$as_save_IFS
6998   test -z "$as_dir" && as_dir=.
6999   for ac_exec_ext in '' $ac_executable_extensions; do
7000   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7001     ac_cv_prog_NM="${ncn_progname}"
7002     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7003     break 2
7004   fi
7005 done
7006 done
7007
7008 fi
7009 fi
7010 NM=$ac_cv_prog_NM
7011 if test -n "$NM"; then
7012   echo "$as_me:$LINENO: result: $NM" >&5
7013 echo "${ECHO_T}$NM" >&6
7014 else
7015   echo "$as_me:$LINENO: result: no" >&5
7016 echo "${ECHO_T}no" >&6
7017 fi
7018
7019   done
7020 fi
7021
7022 for ncn_progname in nm; do
7023   if test -n "$ncn_tool_prefix"; then
7024     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7025 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7026 echo "$as_me:$LINENO: checking for $ac_word" >&5
7027 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7028 if test "${ac_cv_prog_NM+set}" = set; then
7029   echo $ECHO_N "(cached) $ECHO_C" >&6
7030 else
7031   if test -n "$NM"; then
7032   ac_cv_prog_NM="$NM" # Let the user override the test.
7033 else
7034 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7035 for as_dir in $PATH
7036 do
7037   IFS=$as_save_IFS
7038   test -z "$as_dir" && as_dir=.
7039   for ac_exec_ext in '' $ac_executable_extensions; do
7040   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7041     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7042     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7043     break 2
7044   fi
7045 done
7046 done
7047
7048 fi
7049 fi
7050 NM=$ac_cv_prog_NM
7051 if test -n "$NM"; then
7052   echo "$as_me:$LINENO: result: $NM" >&5
7053 echo "${ECHO_T}$NM" >&6
7054 else
7055   echo "$as_me:$LINENO: result: no" >&5
7056 echo "${ECHO_T}no" >&6
7057 fi
7058
7059   fi
7060   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7061     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7062 set dummy ${ncn_progname}; ac_word=$2
7063 echo "$as_me:$LINENO: checking for $ac_word" >&5
7064 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7065 if test "${ac_cv_prog_NM+set}" = set; then
7066   echo $ECHO_N "(cached) $ECHO_C" >&6
7067 else
7068   if test -n "$NM"; then
7069   ac_cv_prog_NM="$NM" # Let the user override the test.
7070 else
7071 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7072 for as_dir in $PATH
7073 do
7074   IFS=$as_save_IFS
7075   test -z "$as_dir" && as_dir=.
7076   for ac_exec_ext in '' $ac_executable_extensions; do
7077   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7078     ac_cv_prog_NM="${ncn_progname}"
7079     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7080     break 2
7081   fi
7082 done
7083 done
7084
7085 fi
7086 fi
7087 NM=$ac_cv_prog_NM
7088 if test -n "$NM"; then
7089   echo "$as_me:$LINENO: result: $NM" >&5
7090 echo "${ECHO_T}$NM" >&6
7091 else
7092   echo "$as_me:$LINENO: result: no" >&5
7093 echo "${ECHO_T}no" >&6
7094 fi
7095
7096   fi
7097   test -n "$ac_cv_prog_NM" && break
7098 done
7099
7100 if test -z "$ac_cv_prog_NM" ; then
7101   set dummy nm
7102   if test $build = $host ; then
7103     NM="$2"
7104   else
7105     NM="${ncn_tool_prefix}$2"
7106   fi
7107 fi
7108
7109
7110
7111 if test -n "$RANLIB"; then
7112   ac_cv_prog_RANLIB=$RANLIB
7113 elif test -n "$ac_cv_prog_RANLIB"; then
7114   RANLIB=$ac_cv_prog_RANLIB
7115 fi
7116
7117 if test -n "$ac_cv_prog_RANLIB"; then
7118   for ncn_progname in ranlib; do
7119     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7120 set dummy ${ncn_progname}; ac_word=$2
7121 echo "$as_me:$LINENO: checking for $ac_word" >&5
7122 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7123 if test "${ac_cv_prog_RANLIB+set}" = set; then
7124   echo $ECHO_N "(cached) $ECHO_C" >&6
7125 else
7126   if test -n "$RANLIB"; then
7127   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7128 else
7129 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7130 for as_dir in $PATH
7131 do
7132   IFS=$as_save_IFS
7133   test -z "$as_dir" && as_dir=.
7134   for ac_exec_ext in '' $ac_executable_extensions; do
7135   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7136     ac_cv_prog_RANLIB="${ncn_progname}"
7137     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7138     break 2
7139   fi
7140 done
7141 done
7142
7143 fi
7144 fi
7145 RANLIB=$ac_cv_prog_RANLIB
7146 if test -n "$RANLIB"; then
7147   echo "$as_me:$LINENO: result: $RANLIB" >&5
7148 echo "${ECHO_T}$RANLIB" >&6
7149 else
7150   echo "$as_me:$LINENO: result: no" >&5
7151 echo "${ECHO_T}no" >&6
7152 fi
7153
7154   done
7155 fi
7156
7157 for ncn_progname in ranlib; do
7158   if test -n "$ncn_tool_prefix"; then
7159     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7160 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7161 echo "$as_me:$LINENO: checking for $ac_word" >&5
7162 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7163 if test "${ac_cv_prog_RANLIB+set}" = set; then
7164   echo $ECHO_N "(cached) $ECHO_C" >&6
7165 else
7166   if test -n "$RANLIB"; then
7167   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7168 else
7169 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7170 for as_dir in $PATH
7171 do
7172   IFS=$as_save_IFS
7173   test -z "$as_dir" && as_dir=.
7174   for ac_exec_ext in '' $ac_executable_extensions; do
7175   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7176     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7177     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7178     break 2
7179   fi
7180 done
7181 done
7182
7183 fi
7184 fi
7185 RANLIB=$ac_cv_prog_RANLIB
7186 if test -n "$RANLIB"; then
7187   echo "$as_me:$LINENO: result: $RANLIB" >&5
7188 echo "${ECHO_T}$RANLIB" >&6
7189 else
7190   echo "$as_me:$LINENO: result: no" >&5
7191 echo "${ECHO_T}no" >&6
7192 fi
7193
7194   fi
7195   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7196     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7197 set dummy ${ncn_progname}; ac_word=$2
7198 echo "$as_me:$LINENO: checking for $ac_word" >&5
7199 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7200 if test "${ac_cv_prog_RANLIB+set}" = set; then
7201   echo $ECHO_N "(cached) $ECHO_C" >&6
7202 else
7203   if test -n "$RANLIB"; then
7204   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7205 else
7206 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7207 for as_dir in $PATH
7208 do
7209   IFS=$as_save_IFS
7210   test -z "$as_dir" && as_dir=.
7211   for ac_exec_ext in '' $ac_executable_extensions; do
7212   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7213     ac_cv_prog_RANLIB="${ncn_progname}"
7214     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7215     break 2
7216   fi
7217 done
7218 done
7219
7220 fi
7221 fi
7222 RANLIB=$ac_cv_prog_RANLIB
7223 if test -n "$RANLIB"; then
7224   echo "$as_me:$LINENO: result: $RANLIB" >&5
7225 echo "${ECHO_T}$RANLIB" >&6
7226 else
7227   echo "$as_me:$LINENO: result: no" >&5
7228 echo "${ECHO_T}no" >&6
7229 fi
7230
7231   fi
7232   test -n "$ac_cv_prog_RANLIB" && break
7233 done
7234
7235 if test -z "$ac_cv_prog_RANLIB" ; then
7236   RANLIB=":"
7237 fi
7238
7239
7240
7241 if test -n "$STRIP"; then
7242   ac_cv_prog_STRIP=$STRIP
7243 elif test -n "$ac_cv_prog_STRIP"; then
7244   STRIP=$ac_cv_prog_STRIP
7245 fi
7246
7247 if test -n "$ac_cv_prog_STRIP"; then
7248   for ncn_progname in strip; do
7249     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7250 set dummy ${ncn_progname}; ac_word=$2
7251 echo "$as_me:$LINENO: checking for $ac_word" >&5
7252 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7253 if test "${ac_cv_prog_STRIP+set}" = set; then
7254   echo $ECHO_N "(cached) $ECHO_C" >&6
7255 else
7256   if test -n "$STRIP"; then
7257   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7258 else
7259 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7260 for as_dir in $PATH
7261 do
7262   IFS=$as_save_IFS
7263   test -z "$as_dir" && as_dir=.
7264   for ac_exec_ext in '' $ac_executable_extensions; do
7265   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7266     ac_cv_prog_STRIP="${ncn_progname}"
7267     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7268     break 2
7269   fi
7270 done
7271 done
7272
7273 fi
7274 fi
7275 STRIP=$ac_cv_prog_STRIP
7276 if test -n "$STRIP"; then
7277   echo "$as_me:$LINENO: result: $STRIP" >&5
7278 echo "${ECHO_T}$STRIP" >&6
7279 else
7280   echo "$as_me:$LINENO: result: no" >&5
7281 echo "${ECHO_T}no" >&6
7282 fi
7283
7284   done
7285 fi
7286
7287 for ncn_progname in strip; do
7288   if test -n "$ncn_tool_prefix"; then
7289     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7290 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7291 echo "$as_me:$LINENO: checking for $ac_word" >&5
7292 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7293 if test "${ac_cv_prog_STRIP+set}" = set; then
7294   echo $ECHO_N "(cached) $ECHO_C" >&6
7295 else
7296   if test -n "$STRIP"; then
7297   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7298 else
7299 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7300 for as_dir in $PATH
7301 do
7302   IFS=$as_save_IFS
7303   test -z "$as_dir" && as_dir=.
7304   for ac_exec_ext in '' $ac_executable_extensions; do
7305   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7306     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7307     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7308     break 2
7309   fi
7310 done
7311 done
7312
7313 fi
7314 fi
7315 STRIP=$ac_cv_prog_STRIP
7316 if test -n "$STRIP"; then
7317   echo "$as_me:$LINENO: result: $STRIP" >&5
7318 echo "${ECHO_T}$STRIP" >&6
7319 else
7320   echo "$as_me:$LINENO: result: no" >&5
7321 echo "${ECHO_T}no" >&6
7322 fi
7323
7324   fi
7325   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7326     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7327 set dummy ${ncn_progname}; ac_word=$2
7328 echo "$as_me:$LINENO: checking for $ac_word" >&5
7329 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7330 if test "${ac_cv_prog_STRIP+set}" = set; then
7331   echo $ECHO_N "(cached) $ECHO_C" >&6
7332 else
7333   if test -n "$STRIP"; then
7334   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7335 else
7336 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7337 for as_dir in $PATH
7338 do
7339   IFS=$as_save_IFS
7340   test -z "$as_dir" && as_dir=.
7341   for ac_exec_ext in '' $ac_executable_extensions; do
7342   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7343     ac_cv_prog_STRIP="${ncn_progname}"
7344     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7345     break 2
7346   fi
7347 done
7348 done
7349
7350 fi
7351 fi
7352 STRIP=$ac_cv_prog_STRIP
7353 if test -n "$STRIP"; then
7354   echo "$as_me:$LINENO: result: $STRIP" >&5
7355 echo "${ECHO_T}$STRIP" >&6
7356 else
7357   echo "$as_me:$LINENO: result: no" >&5
7358 echo "${ECHO_T}no" >&6
7359 fi
7360
7361   fi
7362   test -n "$ac_cv_prog_STRIP" && break
7363 done
7364
7365 if test -z "$ac_cv_prog_STRIP" ; then
7366   STRIP=":"
7367 fi
7368
7369
7370
7371 if test -n "$WINDRES"; then
7372   ac_cv_prog_WINDRES=$WINDRES
7373 elif test -n "$ac_cv_prog_WINDRES"; then
7374   WINDRES=$ac_cv_prog_WINDRES
7375 fi
7376
7377 if test -n "$ac_cv_prog_WINDRES"; then
7378   for ncn_progname in windres; do
7379     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7380 set dummy ${ncn_progname}; ac_word=$2
7381 echo "$as_me:$LINENO: checking for $ac_word" >&5
7382 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7383 if test "${ac_cv_prog_WINDRES+set}" = set; then
7384   echo $ECHO_N "(cached) $ECHO_C" >&6
7385 else
7386   if test -n "$WINDRES"; then
7387   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7388 else
7389 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7390 for as_dir in $PATH
7391 do
7392   IFS=$as_save_IFS
7393   test -z "$as_dir" && as_dir=.
7394   for ac_exec_ext in '' $ac_executable_extensions; do
7395   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7396     ac_cv_prog_WINDRES="${ncn_progname}"
7397     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7398     break 2
7399   fi
7400 done
7401 done
7402
7403 fi
7404 fi
7405 WINDRES=$ac_cv_prog_WINDRES
7406 if test -n "$WINDRES"; then
7407   echo "$as_me:$LINENO: result: $WINDRES" >&5
7408 echo "${ECHO_T}$WINDRES" >&6
7409 else
7410   echo "$as_me:$LINENO: result: no" >&5
7411 echo "${ECHO_T}no" >&6
7412 fi
7413
7414   done
7415 fi
7416
7417 for ncn_progname in windres; do
7418   if test -n "$ncn_tool_prefix"; then
7419     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7420 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7421 echo "$as_me:$LINENO: checking for $ac_word" >&5
7422 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7423 if test "${ac_cv_prog_WINDRES+set}" = set; then
7424   echo $ECHO_N "(cached) $ECHO_C" >&6
7425 else
7426   if test -n "$WINDRES"; then
7427   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7428 else
7429 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7430 for as_dir in $PATH
7431 do
7432   IFS=$as_save_IFS
7433   test -z "$as_dir" && as_dir=.
7434   for ac_exec_ext in '' $ac_executable_extensions; do
7435   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7436     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7437     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7438     break 2
7439   fi
7440 done
7441 done
7442
7443 fi
7444 fi
7445 WINDRES=$ac_cv_prog_WINDRES
7446 if test -n "$WINDRES"; then
7447   echo "$as_me:$LINENO: result: $WINDRES" >&5
7448 echo "${ECHO_T}$WINDRES" >&6
7449 else
7450   echo "$as_me:$LINENO: result: no" >&5
7451 echo "${ECHO_T}no" >&6
7452 fi
7453
7454   fi
7455   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7456     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7457 set dummy ${ncn_progname}; ac_word=$2
7458 echo "$as_me:$LINENO: checking for $ac_word" >&5
7459 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7460 if test "${ac_cv_prog_WINDRES+set}" = set; then
7461   echo $ECHO_N "(cached) $ECHO_C" >&6
7462 else
7463   if test -n "$WINDRES"; then
7464   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7465 else
7466 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7467 for as_dir in $PATH
7468 do
7469   IFS=$as_save_IFS
7470   test -z "$as_dir" && as_dir=.
7471   for ac_exec_ext in '' $ac_executable_extensions; do
7472   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7473     ac_cv_prog_WINDRES="${ncn_progname}"
7474     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7475     break 2
7476   fi
7477 done
7478 done
7479
7480 fi
7481 fi
7482 WINDRES=$ac_cv_prog_WINDRES
7483 if test -n "$WINDRES"; then
7484   echo "$as_me:$LINENO: result: $WINDRES" >&5
7485 echo "${ECHO_T}$WINDRES" >&6
7486 else
7487   echo "$as_me:$LINENO: result: no" >&5
7488 echo "${ECHO_T}no" >&6
7489 fi
7490
7491   fi
7492   test -n "$ac_cv_prog_WINDRES" && break
7493 done
7494
7495 if test -z "$ac_cv_prog_WINDRES" ; then
7496   set dummy windres
7497   if test $build = $host ; then
7498     WINDRES="$2"
7499   else
7500     WINDRES="${ncn_tool_prefix}$2"
7501   fi
7502 fi
7503
7504
7505
7506 if test -n "$WINDMC"; then
7507   ac_cv_prog_WINDMC=$WINDMC
7508 elif test -n "$ac_cv_prog_WINDMC"; then
7509   WINDMC=$ac_cv_prog_WINDMC
7510 fi
7511
7512 if test -n "$ac_cv_prog_WINDMC"; then
7513   for ncn_progname in windmc; do
7514     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7515 set dummy ${ncn_progname}; ac_word=$2
7516 echo "$as_me:$LINENO: checking for $ac_word" >&5
7517 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7518 if test "${ac_cv_prog_WINDMC+set}" = set; then
7519   echo $ECHO_N "(cached) $ECHO_C" >&6
7520 else
7521   if test -n "$WINDMC"; then
7522   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7523 else
7524 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7525 for as_dir in $PATH
7526 do
7527   IFS=$as_save_IFS
7528   test -z "$as_dir" && as_dir=.
7529   for ac_exec_ext in '' $ac_executable_extensions; do
7530   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7531     ac_cv_prog_WINDMC="${ncn_progname}"
7532     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7533     break 2
7534   fi
7535 done
7536 done
7537
7538 fi
7539 fi
7540 WINDMC=$ac_cv_prog_WINDMC
7541 if test -n "$WINDMC"; then
7542   echo "$as_me:$LINENO: result: $WINDMC" >&5
7543 echo "${ECHO_T}$WINDMC" >&6
7544 else
7545   echo "$as_me:$LINENO: result: no" >&5
7546 echo "${ECHO_T}no" >&6
7547 fi
7548
7549   done
7550 fi
7551
7552 for ncn_progname in windmc; do
7553   if test -n "$ncn_tool_prefix"; then
7554     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7555 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7556 echo "$as_me:$LINENO: checking for $ac_word" >&5
7557 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7558 if test "${ac_cv_prog_WINDMC+set}" = set; then
7559   echo $ECHO_N "(cached) $ECHO_C" >&6
7560 else
7561   if test -n "$WINDMC"; then
7562   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7563 else
7564 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7565 for as_dir in $PATH
7566 do
7567   IFS=$as_save_IFS
7568   test -z "$as_dir" && as_dir=.
7569   for ac_exec_ext in '' $ac_executable_extensions; do
7570   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7571     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7572     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7573     break 2
7574   fi
7575 done
7576 done
7577
7578 fi
7579 fi
7580 WINDMC=$ac_cv_prog_WINDMC
7581 if test -n "$WINDMC"; then
7582   echo "$as_me:$LINENO: result: $WINDMC" >&5
7583 echo "${ECHO_T}$WINDMC" >&6
7584 else
7585   echo "$as_me:$LINENO: result: no" >&5
7586 echo "${ECHO_T}no" >&6
7587 fi
7588
7589   fi
7590   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7591     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7592 set dummy ${ncn_progname}; ac_word=$2
7593 echo "$as_me:$LINENO: checking for $ac_word" >&5
7594 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7595 if test "${ac_cv_prog_WINDMC+set}" = set; then
7596   echo $ECHO_N "(cached) $ECHO_C" >&6
7597 else
7598   if test -n "$WINDMC"; then
7599   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7600 else
7601 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7602 for as_dir in $PATH
7603 do
7604   IFS=$as_save_IFS
7605   test -z "$as_dir" && as_dir=.
7606   for ac_exec_ext in '' $ac_executable_extensions; do
7607   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7608     ac_cv_prog_WINDMC="${ncn_progname}"
7609     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7610     break 2
7611   fi
7612 done
7613 done
7614
7615 fi
7616 fi
7617 WINDMC=$ac_cv_prog_WINDMC
7618 if test -n "$WINDMC"; then
7619   echo "$as_me:$LINENO: result: $WINDMC" >&5
7620 echo "${ECHO_T}$WINDMC" >&6
7621 else
7622   echo "$as_me:$LINENO: result: no" >&5
7623 echo "${ECHO_T}no" >&6
7624 fi
7625
7626   fi
7627   test -n "$ac_cv_prog_WINDMC" && break
7628 done
7629
7630 if test -z "$ac_cv_prog_WINDMC" ; then
7631   set dummy windmc
7632   if test $build = $host ; then
7633     WINDMC="$2"
7634   else
7635     WINDMC="${ncn_tool_prefix}$2"
7636   fi
7637 fi
7638
7639
7640
7641 if test -n "$OBJCOPY"; then
7642   ac_cv_prog_OBJCOPY=$OBJCOPY
7643 elif test -n "$ac_cv_prog_OBJCOPY"; then
7644   OBJCOPY=$ac_cv_prog_OBJCOPY
7645 fi
7646
7647 if test -n "$ac_cv_prog_OBJCOPY"; then
7648   for ncn_progname in objcopy; do
7649     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7650 set dummy ${ncn_progname}; ac_word=$2
7651 echo "$as_me:$LINENO: checking for $ac_word" >&5
7652 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7653 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7654   echo $ECHO_N "(cached) $ECHO_C" >&6
7655 else
7656   if test -n "$OBJCOPY"; then
7657   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7658 else
7659 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7660 for as_dir in $PATH
7661 do
7662   IFS=$as_save_IFS
7663   test -z "$as_dir" && as_dir=.
7664   for ac_exec_ext in '' $ac_executable_extensions; do
7665   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7666     ac_cv_prog_OBJCOPY="${ncn_progname}"
7667     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7668     break 2
7669   fi
7670 done
7671 done
7672
7673 fi
7674 fi
7675 OBJCOPY=$ac_cv_prog_OBJCOPY
7676 if test -n "$OBJCOPY"; then
7677   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7678 echo "${ECHO_T}$OBJCOPY" >&6
7679 else
7680   echo "$as_me:$LINENO: result: no" >&5
7681 echo "${ECHO_T}no" >&6
7682 fi
7683
7684   done
7685 fi
7686
7687 for ncn_progname in objcopy; do
7688   if test -n "$ncn_tool_prefix"; then
7689     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7690 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7691 echo "$as_me:$LINENO: checking for $ac_word" >&5
7692 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7693 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7694   echo $ECHO_N "(cached) $ECHO_C" >&6
7695 else
7696   if test -n "$OBJCOPY"; then
7697   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7698 else
7699 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7700 for as_dir in $PATH
7701 do
7702   IFS=$as_save_IFS
7703   test -z "$as_dir" && as_dir=.
7704   for ac_exec_ext in '' $ac_executable_extensions; do
7705   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7706     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7707     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7708     break 2
7709   fi
7710 done
7711 done
7712
7713 fi
7714 fi
7715 OBJCOPY=$ac_cv_prog_OBJCOPY
7716 if test -n "$OBJCOPY"; then
7717   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7718 echo "${ECHO_T}$OBJCOPY" >&6
7719 else
7720   echo "$as_me:$LINENO: result: no" >&5
7721 echo "${ECHO_T}no" >&6
7722 fi
7723
7724   fi
7725   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7726     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7727 set dummy ${ncn_progname}; ac_word=$2
7728 echo "$as_me:$LINENO: checking for $ac_word" >&5
7729 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7730 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7731   echo $ECHO_N "(cached) $ECHO_C" >&6
7732 else
7733   if test -n "$OBJCOPY"; then
7734   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7735 else
7736 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7737 for as_dir in $PATH
7738 do
7739   IFS=$as_save_IFS
7740   test -z "$as_dir" && as_dir=.
7741   for ac_exec_ext in '' $ac_executable_extensions; do
7742   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7743     ac_cv_prog_OBJCOPY="${ncn_progname}"
7744     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7745     break 2
7746   fi
7747 done
7748 done
7749
7750 fi
7751 fi
7752 OBJCOPY=$ac_cv_prog_OBJCOPY
7753 if test -n "$OBJCOPY"; then
7754   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7755 echo "${ECHO_T}$OBJCOPY" >&6
7756 else
7757   echo "$as_me:$LINENO: result: no" >&5
7758 echo "${ECHO_T}no" >&6
7759 fi
7760
7761   fi
7762   test -n "$ac_cv_prog_OBJCOPY" && break
7763 done
7764
7765 if test -z "$ac_cv_prog_OBJCOPY" ; then
7766   set dummy objcopy
7767   if test $build = $host ; then
7768     OBJCOPY="$2"
7769   else
7770     OBJCOPY="${ncn_tool_prefix}$2"
7771   fi
7772 fi
7773
7774
7775
7776 if test -n "$OBJDUMP"; then
7777   ac_cv_prog_OBJDUMP=$OBJDUMP
7778 elif test -n "$ac_cv_prog_OBJDUMP"; then
7779   OBJDUMP=$ac_cv_prog_OBJDUMP
7780 fi
7781
7782 if test -n "$ac_cv_prog_OBJDUMP"; then
7783   for ncn_progname in objdump; do
7784     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7785 set dummy ${ncn_progname}; ac_word=$2
7786 echo "$as_me:$LINENO: checking for $ac_word" >&5
7787 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7788 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7789   echo $ECHO_N "(cached) $ECHO_C" >&6
7790 else
7791   if test -n "$OBJDUMP"; then
7792   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7793 else
7794 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7795 for as_dir in $PATH
7796 do
7797   IFS=$as_save_IFS
7798   test -z "$as_dir" && as_dir=.
7799   for ac_exec_ext in '' $ac_executable_extensions; do
7800   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7801     ac_cv_prog_OBJDUMP="${ncn_progname}"
7802     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7803     break 2
7804   fi
7805 done
7806 done
7807
7808 fi
7809 fi
7810 OBJDUMP=$ac_cv_prog_OBJDUMP
7811 if test -n "$OBJDUMP"; then
7812   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7813 echo "${ECHO_T}$OBJDUMP" >&6
7814 else
7815   echo "$as_me:$LINENO: result: no" >&5
7816 echo "${ECHO_T}no" >&6
7817 fi
7818
7819   done
7820 fi
7821
7822 for ncn_progname in objdump; do
7823   if test -n "$ncn_tool_prefix"; then
7824     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7825 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7826 echo "$as_me:$LINENO: checking for $ac_word" >&5
7827 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7828 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7829   echo $ECHO_N "(cached) $ECHO_C" >&6
7830 else
7831   if test -n "$OBJDUMP"; then
7832   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7833 else
7834 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7835 for as_dir in $PATH
7836 do
7837   IFS=$as_save_IFS
7838   test -z "$as_dir" && as_dir=.
7839   for ac_exec_ext in '' $ac_executable_extensions; do
7840   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7841     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7842     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7843     break 2
7844   fi
7845 done
7846 done
7847
7848 fi
7849 fi
7850 OBJDUMP=$ac_cv_prog_OBJDUMP
7851 if test -n "$OBJDUMP"; then
7852   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7853 echo "${ECHO_T}$OBJDUMP" >&6
7854 else
7855   echo "$as_me:$LINENO: result: no" >&5
7856 echo "${ECHO_T}no" >&6
7857 fi
7858
7859   fi
7860   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7861     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7862 set dummy ${ncn_progname}; ac_word=$2
7863 echo "$as_me:$LINENO: checking for $ac_word" >&5
7864 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7865 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7866   echo $ECHO_N "(cached) $ECHO_C" >&6
7867 else
7868   if test -n "$OBJDUMP"; then
7869   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7870 else
7871 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7872 for as_dir in $PATH
7873 do
7874   IFS=$as_save_IFS
7875   test -z "$as_dir" && as_dir=.
7876   for ac_exec_ext in '' $ac_executable_extensions; do
7877   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7878     ac_cv_prog_OBJDUMP="${ncn_progname}"
7879     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7880     break 2
7881   fi
7882 done
7883 done
7884
7885 fi
7886 fi
7887 OBJDUMP=$ac_cv_prog_OBJDUMP
7888 if test -n "$OBJDUMP"; then
7889   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7890 echo "${ECHO_T}$OBJDUMP" >&6
7891 else
7892   echo "$as_me:$LINENO: result: no" >&5
7893 echo "${ECHO_T}no" >&6
7894 fi
7895
7896   fi
7897   test -n "$ac_cv_prog_OBJDUMP" && break
7898 done
7899
7900 if test -z "$ac_cv_prog_OBJDUMP" ; then
7901   set dummy objdump
7902   if test $build = $host ; then
7903     OBJDUMP="$2"
7904   else
7905     OBJDUMP="${ncn_tool_prefix}$2"
7906   fi
7907 fi
7908
7909
7910
7911
7912
7913
7914
7915 # Target tools.
7916
7917 # Check whether --with-build-time-tools or --without-build-time-tools was given.
7918 if test "${with_build_time_tools+set}" = set; then
7919   withval="$with_build_time_tools"
7920   case x"$withval" in
7921      x/*) ;;
7922      *)
7923        with_build_time_tools=
7924        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
7925 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
7926        ;;
7927    esac
7928 else
7929   with_build_time_tools=
7930 fi;
7931
7932
7933
7934 if test -n "$CC_FOR_TARGET"; then
7935   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
7936 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7937   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7938 fi
7939
7940 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7941   for ncn_progname in cc gcc; do
7942     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7943 set dummy ${ncn_progname}; ac_word=$2
7944 echo "$as_me:$LINENO: checking for $ac_word" >&5
7945 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7946 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7947   echo $ECHO_N "(cached) $ECHO_C" >&6
7948 else
7949   if test -n "$CC_FOR_TARGET"; then
7950   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7951 else
7952 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7953 for as_dir in $PATH
7954 do
7955   IFS=$as_save_IFS
7956   test -z "$as_dir" && as_dir=.
7957   for ac_exec_ext in '' $ac_executable_extensions; do
7958   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7959     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7960     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7961     break 2
7962   fi
7963 done
7964 done
7965
7966 fi
7967 fi
7968 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7969 if test -n "$CC_FOR_TARGET"; then
7970   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7971 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7972 else
7973   echo "$as_me:$LINENO: result: no" >&5
7974 echo "${ECHO_T}no" >&6
7975 fi
7976
7977   done
7978 fi
7979
7980 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
7981   for ncn_progname in cc gcc; do
7982     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7983 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7984     if test -x $with_build_time_tools/${ncn_progname}; then
7985       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7986       echo "$as_me:$LINENO: result: yes" >&5
7987 echo "${ECHO_T}yes" >&6
7988       break
7989     else
7990       echo "$as_me:$LINENO: result: no" >&5
7991 echo "${ECHO_T}no" >&6
7992     fi
7993   done
7994 fi
7995
7996 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
7997   for ncn_progname in cc gcc; do
7998     if test -n "$ncn_target_tool_prefix"; then
7999       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8000 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8001 echo "$as_me:$LINENO: checking for $ac_word" >&5
8002 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8003 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8004   echo $ECHO_N "(cached) $ECHO_C" >&6
8005 else
8006   if test -n "$CC_FOR_TARGET"; then
8007   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8008 else
8009 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8010 for as_dir in $PATH
8011 do
8012   IFS=$as_save_IFS
8013   test -z "$as_dir" && as_dir=.
8014   for ac_exec_ext in '' $ac_executable_extensions; do
8015   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8016     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8017     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8018     break 2
8019   fi
8020 done
8021 done
8022
8023 fi
8024 fi
8025 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8026 if test -n "$CC_FOR_TARGET"; then
8027   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8028 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8029 else
8030   echo "$as_me:$LINENO: result: no" >&5
8031 echo "${ECHO_T}no" >&6
8032 fi
8033
8034     fi
8035     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8036       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8037 set dummy ${ncn_progname}; ac_word=$2
8038 echo "$as_me:$LINENO: checking for $ac_word" >&5
8039 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8040 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8041   echo $ECHO_N "(cached) $ECHO_C" >&6
8042 else
8043   if test -n "$CC_FOR_TARGET"; then
8044   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8045 else
8046 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8047 for as_dir in $PATH
8048 do
8049   IFS=$as_save_IFS
8050   test -z "$as_dir" && as_dir=.
8051   for ac_exec_ext in '' $ac_executable_extensions; do
8052   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8053     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8054     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8055     break 2
8056   fi
8057 done
8058 done
8059
8060 fi
8061 fi
8062 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8063 if test -n "$CC_FOR_TARGET"; then
8064   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8065 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8066 else
8067   echo "$as_me:$LINENO: result: no" >&5
8068 echo "${ECHO_T}no" >&6
8069 fi
8070
8071     fi
8072     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8073   done
8074 fi
8075
8076 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8077   set dummy cc gcc
8078   if test $build = $target ; then
8079     CC_FOR_TARGET="$2"
8080   else
8081     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8082   fi
8083 else
8084   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8085 fi
8086
8087
8088
8089 if test -n "$CXX_FOR_TARGET"; then
8090   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8091 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8092   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8093 fi
8094
8095 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8096   for ncn_progname in c++ g++ cxx gxx; do
8097     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8098 set dummy ${ncn_progname}; ac_word=$2
8099 echo "$as_me:$LINENO: checking for $ac_word" >&5
8100 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8101 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8102   echo $ECHO_N "(cached) $ECHO_C" >&6
8103 else
8104   if test -n "$CXX_FOR_TARGET"; then
8105   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8106 else
8107 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8108 for as_dir in $PATH
8109 do
8110   IFS=$as_save_IFS
8111   test -z "$as_dir" && as_dir=.
8112   for ac_exec_ext in '' $ac_executable_extensions; do
8113   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8114     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8115     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8116     break 2
8117   fi
8118 done
8119 done
8120
8121 fi
8122 fi
8123 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8124 if test -n "$CXX_FOR_TARGET"; then
8125   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8126 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8127 else
8128   echo "$as_me:$LINENO: result: no" >&5
8129 echo "${ECHO_T}no" >&6
8130 fi
8131
8132   done
8133 fi
8134
8135 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8136   for ncn_progname in c++ g++ cxx gxx; do
8137     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8138 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8139     if test -x $with_build_time_tools/${ncn_progname}; then
8140       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8141       echo "$as_me:$LINENO: result: yes" >&5
8142 echo "${ECHO_T}yes" >&6
8143       break
8144     else
8145       echo "$as_me:$LINENO: result: no" >&5
8146 echo "${ECHO_T}no" >&6
8147     fi
8148   done
8149 fi
8150
8151 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8152   for ncn_progname in c++ g++ cxx gxx; do
8153     if test -n "$ncn_target_tool_prefix"; then
8154       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8155 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8156 echo "$as_me:$LINENO: checking for $ac_word" >&5
8157 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8158 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8159   echo $ECHO_N "(cached) $ECHO_C" >&6
8160 else
8161   if test -n "$CXX_FOR_TARGET"; then
8162   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8163 else
8164 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8165 for as_dir in $PATH
8166 do
8167   IFS=$as_save_IFS
8168   test -z "$as_dir" && as_dir=.
8169   for ac_exec_ext in '' $ac_executable_extensions; do
8170   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8171     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8172     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8173     break 2
8174   fi
8175 done
8176 done
8177
8178 fi
8179 fi
8180 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8181 if test -n "$CXX_FOR_TARGET"; then
8182   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8183 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8184 else
8185   echo "$as_me:$LINENO: result: no" >&5
8186 echo "${ECHO_T}no" >&6
8187 fi
8188
8189     fi
8190     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8191       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8192 set dummy ${ncn_progname}; ac_word=$2
8193 echo "$as_me:$LINENO: checking for $ac_word" >&5
8194 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8195 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8196   echo $ECHO_N "(cached) $ECHO_C" >&6
8197 else
8198   if test -n "$CXX_FOR_TARGET"; then
8199   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8200 else
8201 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8202 for as_dir in $PATH
8203 do
8204   IFS=$as_save_IFS
8205   test -z "$as_dir" && as_dir=.
8206   for ac_exec_ext in '' $ac_executable_extensions; do
8207   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8208     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8209     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8210     break 2
8211   fi
8212 done
8213 done
8214
8215 fi
8216 fi
8217 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8218 if test -n "$CXX_FOR_TARGET"; then
8219   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8220 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8221 else
8222   echo "$as_me:$LINENO: result: no" >&5
8223 echo "${ECHO_T}no" >&6
8224 fi
8225
8226     fi
8227     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8228   done
8229 fi
8230
8231 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8232   set dummy c++ g++ cxx gxx
8233   if test $build = $target ; then
8234     CXX_FOR_TARGET="$2"
8235   else
8236     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8237   fi
8238 else
8239   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8240 fi
8241
8242
8243
8244 if test -n "$GCC_FOR_TARGET"; then
8245   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8246 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8247   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8248 fi
8249
8250 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8251   for ncn_progname in gcc; do
8252     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8253 set dummy ${ncn_progname}; ac_word=$2
8254 echo "$as_me:$LINENO: checking for $ac_word" >&5
8255 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8256 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8257   echo $ECHO_N "(cached) $ECHO_C" >&6
8258 else
8259   if test -n "$GCC_FOR_TARGET"; then
8260   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8261 else
8262 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8263 for as_dir in $PATH
8264 do
8265   IFS=$as_save_IFS
8266   test -z "$as_dir" && as_dir=.
8267   for ac_exec_ext in '' $ac_executable_extensions; do
8268   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8269     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8270     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8271     break 2
8272   fi
8273 done
8274 done
8275
8276 fi
8277 fi
8278 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8279 if test -n "$GCC_FOR_TARGET"; then
8280   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8281 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8282 else
8283   echo "$as_me:$LINENO: result: no" >&5
8284 echo "${ECHO_T}no" >&6
8285 fi
8286
8287   done
8288 fi
8289
8290 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8291   for ncn_progname in gcc; do
8292     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8293 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8294     if test -x $with_build_time_tools/${ncn_progname}; then
8295       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8296       echo "$as_me:$LINENO: result: yes" >&5
8297 echo "${ECHO_T}yes" >&6
8298       break
8299     else
8300       echo "$as_me:$LINENO: result: no" >&5
8301 echo "${ECHO_T}no" >&6
8302     fi
8303   done
8304 fi
8305
8306 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8307   for ncn_progname in gcc; do
8308     if test -n "$ncn_target_tool_prefix"; then
8309       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8310 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8311 echo "$as_me:$LINENO: checking for $ac_word" >&5
8312 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8313 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8314   echo $ECHO_N "(cached) $ECHO_C" >&6
8315 else
8316   if test -n "$GCC_FOR_TARGET"; then
8317   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8318 else
8319 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8320 for as_dir in $PATH
8321 do
8322   IFS=$as_save_IFS
8323   test -z "$as_dir" && as_dir=.
8324   for ac_exec_ext in '' $ac_executable_extensions; do
8325   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8326     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8327     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8328     break 2
8329   fi
8330 done
8331 done
8332
8333 fi
8334 fi
8335 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8336 if test -n "$GCC_FOR_TARGET"; then
8337   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8338 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8339 else
8340   echo "$as_me:$LINENO: result: no" >&5
8341 echo "${ECHO_T}no" >&6
8342 fi
8343
8344     fi
8345     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8346       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8347 set dummy ${ncn_progname}; ac_word=$2
8348 echo "$as_me:$LINENO: checking for $ac_word" >&5
8349 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8350 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8351   echo $ECHO_N "(cached) $ECHO_C" >&6
8352 else
8353   if test -n "$GCC_FOR_TARGET"; then
8354   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8355 else
8356 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8357 for as_dir in $PATH
8358 do
8359   IFS=$as_save_IFS
8360   test -z "$as_dir" && as_dir=.
8361   for ac_exec_ext in '' $ac_executable_extensions; do
8362   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8363     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8364     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8365     break 2
8366   fi
8367 done
8368 done
8369
8370 fi
8371 fi
8372 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8373 if test -n "$GCC_FOR_TARGET"; then
8374   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8375 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8376 else
8377   echo "$as_me:$LINENO: result: no" >&5
8378 echo "${ECHO_T}no" >&6
8379 fi
8380
8381     fi
8382     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8383   done
8384 fi
8385
8386 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8387   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8388 else
8389   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8390 fi
8391
8392
8393
8394 if test -n "$GCJ_FOR_TARGET"; then
8395   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8396 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8397   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8398 fi
8399
8400 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8401   for ncn_progname in gcj; do
8402     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8403 set dummy ${ncn_progname}; ac_word=$2
8404 echo "$as_me:$LINENO: checking for $ac_word" >&5
8405 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8406 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8407   echo $ECHO_N "(cached) $ECHO_C" >&6
8408 else
8409   if test -n "$GCJ_FOR_TARGET"; then
8410   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8411 else
8412 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8413 for as_dir in $PATH
8414 do
8415   IFS=$as_save_IFS
8416   test -z "$as_dir" && as_dir=.
8417   for ac_exec_ext in '' $ac_executable_extensions; do
8418   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8419     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8420     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8421     break 2
8422   fi
8423 done
8424 done
8425
8426 fi
8427 fi
8428 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8429 if test -n "$GCJ_FOR_TARGET"; then
8430   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8431 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8432 else
8433   echo "$as_me:$LINENO: result: no" >&5
8434 echo "${ECHO_T}no" >&6
8435 fi
8436
8437   done
8438 fi
8439
8440 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8441   for ncn_progname in gcj; do
8442     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8443 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8444     if test -x $with_build_time_tools/${ncn_progname}; then
8445       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8446       echo "$as_me:$LINENO: result: yes" >&5
8447 echo "${ECHO_T}yes" >&6
8448       break
8449     else
8450       echo "$as_me:$LINENO: result: no" >&5
8451 echo "${ECHO_T}no" >&6
8452     fi
8453   done
8454 fi
8455
8456 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8457   for ncn_progname in gcj; do
8458     if test -n "$ncn_target_tool_prefix"; then
8459       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8460 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8461 echo "$as_me:$LINENO: checking for $ac_word" >&5
8462 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8463 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8464   echo $ECHO_N "(cached) $ECHO_C" >&6
8465 else
8466   if test -n "$GCJ_FOR_TARGET"; then
8467   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8468 else
8469 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8470 for as_dir in $PATH
8471 do
8472   IFS=$as_save_IFS
8473   test -z "$as_dir" && as_dir=.
8474   for ac_exec_ext in '' $ac_executable_extensions; do
8475   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8476     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8477     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8478     break 2
8479   fi
8480 done
8481 done
8482
8483 fi
8484 fi
8485 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8486 if test -n "$GCJ_FOR_TARGET"; then
8487   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8488 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8489 else
8490   echo "$as_me:$LINENO: result: no" >&5
8491 echo "${ECHO_T}no" >&6
8492 fi
8493
8494     fi
8495     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8496       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8497 set dummy ${ncn_progname}; ac_word=$2
8498 echo "$as_me:$LINENO: checking for $ac_word" >&5
8499 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8500 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8501   echo $ECHO_N "(cached) $ECHO_C" >&6
8502 else
8503   if test -n "$GCJ_FOR_TARGET"; then
8504   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8505 else
8506 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8507 for as_dir in $PATH
8508 do
8509   IFS=$as_save_IFS
8510   test -z "$as_dir" && as_dir=.
8511   for ac_exec_ext in '' $ac_executable_extensions; do
8512   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8513     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8514     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8515     break 2
8516   fi
8517 done
8518 done
8519
8520 fi
8521 fi
8522 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8523 if test -n "$GCJ_FOR_TARGET"; then
8524   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8525 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8526 else
8527   echo "$as_me:$LINENO: result: no" >&5
8528 echo "${ECHO_T}no" >&6
8529 fi
8530
8531     fi
8532     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8533   done
8534 fi
8535
8536 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8537   set dummy gcj
8538   if test $build = $target ; then
8539     GCJ_FOR_TARGET="$2"
8540   else
8541     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8542   fi
8543 else
8544   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8545 fi
8546
8547
8548
8549 if test -n "$GFORTRAN_FOR_TARGET"; then
8550   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8551 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8552   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8553 fi
8554
8555 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8556   for ncn_progname in gfortran; do
8557     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8558 set dummy ${ncn_progname}; ac_word=$2
8559 echo "$as_me:$LINENO: checking for $ac_word" >&5
8560 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8561 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8562   echo $ECHO_N "(cached) $ECHO_C" >&6
8563 else
8564   if test -n "$GFORTRAN_FOR_TARGET"; then
8565   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8566 else
8567 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8568 for as_dir in $PATH
8569 do
8570   IFS=$as_save_IFS
8571   test -z "$as_dir" && as_dir=.
8572   for ac_exec_ext in '' $ac_executable_extensions; do
8573   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8574     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8575     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8576     break 2
8577   fi
8578 done
8579 done
8580
8581 fi
8582 fi
8583 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8584 if test -n "$GFORTRAN_FOR_TARGET"; then
8585   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8586 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8587 else
8588   echo "$as_me:$LINENO: result: no" >&5
8589 echo "${ECHO_T}no" >&6
8590 fi
8591
8592   done
8593 fi
8594
8595 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8596   for ncn_progname in gfortran; do
8597     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8598 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8599     if test -x $with_build_time_tools/${ncn_progname}; then
8600       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8601       echo "$as_me:$LINENO: result: yes" >&5
8602 echo "${ECHO_T}yes" >&6
8603       break
8604     else
8605       echo "$as_me:$LINENO: result: no" >&5
8606 echo "${ECHO_T}no" >&6
8607     fi
8608   done
8609 fi
8610
8611 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8612   for ncn_progname in gfortran; do
8613     if test -n "$ncn_target_tool_prefix"; then
8614       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8615 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8616 echo "$as_me:$LINENO: checking for $ac_word" >&5
8617 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8618 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8619   echo $ECHO_N "(cached) $ECHO_C" >&6
8620 else
8621   if test -n "$GFORTRAN_FOR_TARGET"; then
8622   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8623 else
8624 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8625 for as_dir in $PATH
8626 do
8627   IFS=$as_save_IFS
8628   test -z "$as_dir" && as_dir=.
8629   for ac_exec_ext in '' $ac_executable_extensions; do
8630   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8631     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8632     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8633     break 2
8634   fi
8635 done
8636 done
8637
8638 fi
8639 fi
8640 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8641 if test -n "$GFORTRAN_FOR_TARGET"; then
8642   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8643 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8644 else
8645   echo "$as_me:$LINENO: result: no" >&5
8646 echo "${ECHO_T}no" >&6
8647 fi
8648
8649     fi
8650     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8651       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8652 set dummy ${ncn_progname}; ac_word=$2
8653 echo "$as_me:$LINENO: checking for $ac_word" >&5
8654 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8655 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8656   echo $ECHO_N "(cached) $ECHO_C" >&6
8657 else
8658   if test -n "$GFORTRAN_FOR_TARGET"; then
8659   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8660 else
8661 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8662 for as_dir in $PATH
8663 do
8664   IFS=$as_save_IFS
8665   test -z "$as_dir" && as_dir=.
8666   for ac_exec_ext in '' $ac_executable_extensions; do
8667   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8668     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8669     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8670     break 2
8671   fi
8672 done
8673 done
8674
8675 fi
8676 fi
8677 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8678 if test -n "$GFORTRAN_FOR_TARGET"; then
8679   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8680 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8681 else
8682   echo "$as_me:$LINENO: result: no" >&5
8683 echo "${ECHO_T}no" >&6
8684 fi
8685
8686     fi
8687     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8688   done
8689 fi
8690
8691 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8692   set dummy gfortran
8693   if test $build = $target ; then
8694     GFORTRAN_FOR_TARGET="$2"
8695   else
8696     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8697   fi
8698 else
8699   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8700 fi
8701
8702
8703
8704 cat > conftest.c << \EOF
8705 #ifdef __GNUC__
8706   gcc_yay;
8707 #endif
8708 EOF
8709 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8710   have_gcc_for_target=yes
8711 else
8712   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8713   have_gcc_for_target=no
8714 fi
8715 rm conftest.c
8716
8717
8718
8719
8720 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8721   if test -n "$with_build_time_tools"; then
8722     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8723 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8724     if test -x $with_build_time_tools/ar; then
8725       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8726       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8727       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8728 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8729     else
8730       echo "$as_me:$LINENO: result: no" >&5
8731 echo "${ECHO_T}no" >&6
8732     fi
8733   elif test $build != $host && test $have_gcc_for_target = yes; then
8734     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8735     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8736     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8737   fi
8738 fi
8739 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8740   # Extract the first word of "ar", so it can be a program name with args.
8741 set dummy ar; ac_word=$2
8742 echo "$as_me:$LINENO: checking for $ac_word" >&5
8743 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8744 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8745   echo $ECHO_N "(cached) $ECHO_C" >&6
8746 else
8747   case $AR_FOR_TARGET in
8748   [\\/]* | ?:[\\/]*)
8749   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8750   ;;
8751   *)
8752   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8753 for as_dir in $gcc_cv_tool_dirs
8754 do
8755   IFS=$as_save_IFS
8756   test -z "$as_dir" && as_dir=.
8757   for ac_exec_ext in '' $ac_executable_extensions; do
8758   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8759     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8760     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8761     break 2
8762   fi
8763 done
8764 done
8765
8766   ;;
8767 esac
8768 fi
8769 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8770
8771 if test -n "$AR_FOR_TARGET"; then
8772   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8773 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8774 else
8775   echo "$as_me:$LINENO: result: no" >&5
8776 echo "${ECHO_T}no" >&6
8777 fi
8778
8779 fi
8780 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8781
8782
8783 if test -n "$AR_FOR_TARGET"; then
8784   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8785 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8786   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8787 fi
8788
8789 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8790   for ncn_progname in ar; do
8791     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8792 set dummy ${ncn_progname}; ac_word=$2
8793 echo "$as_me:$LINENO: checking for $ac_word" >&5
8794 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8795 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8796   echo $ECHO_N "(cached) $ECHO_C" >&6
8797 else
8798   if test -n "$AR_FOR_TARGET"; then
8799   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8800 else
8801 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8802 for as_dir in $PATH
8803 do
8804   IFS=$as_save_IFS
8805   test -z "$as_dir" && as_dir=.
8806   for ac_exec_ext in '' $ac_executable_extensions; do
8807   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8808     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8809     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8810     break 2
8811   fi
8812 done
8813 done
8814
8815 fi
8816 fi
8817 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8818 if test -n "$AR_FOR_TARGET"; then
8819   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8820 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8821 else
8822   echo "$as_me:$LINENO: result: no" >&5
8823 echo "${ECHO_T}no" >&6
8824 fi
8825
8826   done
8827 fi
8828
8829 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8830   for ncn_progname in ar; do
8831     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8832 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8833     if test -x $with_build_time_tools/${ncn_progname}; then
8834       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8835       echo "$as_me:$LINENO: result: yes" >&5
8836 echo "${ECHO_T}yes" >&6
8837       break
8838     else
8839       echo "$as_me:$LINENO: result: no" >&5
8840 echo "${ECHO_T}no" >&6
8841     fi
8842   done
8843 fi
8844
8845 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8846   for ncn_progname in ar; do
8847     if test -n "$ncn_target_tool_prefix"; then
8848       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8849 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8850 echo "$as_me:$LINENO: checking for $ac_word" >&5
8851 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8852 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8853   echo $ECHO_N "(cached) $ECHO_C" >&6
8854 else
8855   if test -n "$AR_FOR_TARGET"; then
8856   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8857 else
8858 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8859 for as_dir in $PATH
8860 do
8861   IFS=$as_save_IFS
8862   test -z "$as_dir" && as_dir=.
8863   for ac_exec_ext in '' $ac_executable_extensions; do
8864   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8865     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8866     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8867     break 2
8868   fi
8869 done
8870 done
8871
8872 fi
8873 fi
8874 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8875 if test -n "$AR_FOR_TARGET"; then
8876   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8877 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8878 else
8879   echo "$as_me:$LINENO: result: no" >&5
8880 echo "${ECHO_T}no" >&6
8881 fi
8882
8883     fi
8884     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8885       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8886 set dummy ${ncn_progname}; ac_word=$2
8887 echo "$as_me:$LINENO: checking for $ac_word" >&5
8888 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8889 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8890   echo $ECHO_N "(cached) $ECHO_C" >&6
8891 else
8892   if test -n "$AR_FOR_TARGET"; then
8893   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8894 else
8895 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8896 for as_dir in $PATH
8897 do
8898   IFS=$as_save_IFS
8899   test -z "$as_dir" && as_dir=.
8900   for ac_exec_ext in '' $ac_executable_extensions; do
8901   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8902     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8903     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8904     break 2
8905   fi
8906 done
8907 done
8908
8909 fi
8910 fi
8911 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8912 if test -n "$AR_FOR_TARGET"; then
8913   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8914 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8915 else
8916   echo "$as_me:$LINENO: result: no" >&5
8917 echo "${ECHO_T}no" >&6
8918 fi
8919
8920     fi
8921     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
8922   done
8923 fi
8924
8925 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
8926   set dummy ar
8927   if test $build = $target ; then
8928     AR_FOR_TARGET="$2"
8929   else
8930     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
8931   fi
8932 else
8933   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
8934 fi
8935
8936 else
8937   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8938 fi
8939
8940
8941
8942
8943 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8944   if test -n "$with_build_time_tools"; then
8945     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
8946 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
8947     if test -x $with_build_time_tools/as; then
8948       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
8949       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8950       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
8951 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
8952     else
8953       echo "$as_me:$LINENO: result: no" >&5
8954 echo "${ECHO_T}no" >&6
8955     fi
8956   elif test $build != $host && test $have_gcc_for_target = yes; then
8957     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
8958     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
8959     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8960   fi
8961 fi
8962 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8963   # Extract the first word of "as", so it can be a program name with args.
8964 set dummy as; ac_word=$2
8965 echo "$as_me:$LINENO: checking for $ac_word" >&5
8966 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8967 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
8968   echo $ECHO_N "(cached) $ECHO_C" >&6
8969 else
8970   case $AS_FOR_TARGET in
8971   [\\/]* | ?:[\\/]*)
8972   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
8973   ;;
8974   *)
8975   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8976 for as_dir in $gcc_cv_tool_dirs
8977 do
8978   IFS=$as_save_IFS
8979   test -z "$as_dir" && as_dir=.
8980   for ac_exec_ext in '' $ac_executable_extensions; do
8981   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8982     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8983     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8984     break 2
8985   fi
8986 done
8987 done
8988
8989   ;;
8990 esac
8991 fi
8992 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
8993
8994 if test -n "$AS_FOR_TARGET"; then
8995   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8996 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8997 else
8998   echo "$as_me:$LINENO: result: no" >&5
8999 echo "${ECHO_T}no" >&6
9000 fi
9001
9002 fi
9003 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9004
9005
9006 if test -n "$AS_FOR_TARGET"; then
9007   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9008 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9009   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9010 fi
9011
9012 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9013   for ncn_progname in as; do
9014     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9015 set dummy ${ncn_progname}; ac_word=$2
9016 echo "$as_me:$LINENO: checking for $ac_word" >&5
9017 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9018 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9019   echo $ECHO_N "(cached) $ECHO_C" >&6
9020 else
9021   if test -n "$AS_FOR_TARGET"; then
9022   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9023 else
9024 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9025 for as_dir in $PATH
9026 do
9027   IFS=$as_save_IFS
9028   test -z "$as_dir" && as_dir=.
9029   for ac_exec_ext in '' $ac_executable_extensions; do
9030   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9031     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9032     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9033     break 2
9034   fi
9035 done
9036 done
9037
9038 fi
9039 fi
9040 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9041 if test -n "$AS_FOR_TARGET"; then
9042   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9043 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9044 else
9045   echo "$as_me:$LINENO: result: no" >&5
9046 echo "${ECHO_T}no" >&6
9047 fi
9048
9049   done
9050 fi
9051
9052 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9053   for ncn_progname in as; do
9054     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9055 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9056     if test -x $with_build_time_tools/${ncn_progname}; then
9057       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9058       echo "$as_me:$LINENO: result: yes" >&5
9059 echo "${ECHO_T}yes" >&6
9060       break
9061     else
9062       echo "$as_me:$LINENO: result: no" >&5
9063 echo "${ECHO_T}no" >&6
9064     fi
9065   done
9066 fi
9067
9068 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9069   for ncn_progname in as; do
9070     if test -n "$ncn_target_tool_prefix"; then
9071       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9072 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9073 echo "$as_me:$LINENO: checking for $ac_word" >&5
9074 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9075 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9076   echo $ECHO_N "(cached) $ECHO_C" >&6
9077 else
9078   if test -n "$AS_FOR_TARGET"; then
9079   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9080 else
9081 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9082 for as_dir in $PATH
9083 do
9084   IFS=$as_save_IFS
9085   test -z "$as_dir" && as_dir=.
9086   for ac_exec_ext in '' $ac_executable_extensions; do
9087   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9088     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9089     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9090     break 2
9091   fi
9092 done
9093 done
9094
9095 fi
9096 fi
9097 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9098 if test -n "$AS_FOR_TARGET"; then
9099   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9100 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9101 else
9102   echo "$as_me:$LINENO: result: no" >&5
9103 echo "${ECHO_T}no" >&6
9104 fi
9105
9106     fi
9107     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9108       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9109 set dummy ${ncn_progname}; ac_word=$2
9110 echo "$as_me:$LINENO: checking for $ac_word" >&5
9111 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9112 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9113   echo $ECHO_N "(cached) $ECHO_C" >&6
9114 else
9115   if test -n "$AS_FOR_TARGET"; then
9116   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9117 else
9118 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9119 for as_dir in $PATH
9120 do
9121   IFS=$as_save_IFS
9122   test -z "$as_dir" && as_dir=.
9123   for ac_exec_ext in '' $ac_executable_extensions; do
9124   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9125     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9126     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9127     break 2
9128   fi
9129 done
9130 done
9131
9132 fi
9133 fi
9134 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9135 if test -n "$AS_FOR_TARGET"; then
9136   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9137 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9138 else
9139   echo "$as_me:$LINENO: result: no" >&5
9140 echo "${ECHO_T}no" >&6
9141 fi
9142
9143     fi
9144     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9145   done
9146 fi
9147
9148 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9149   set dummy as
9150   if test $build = $target ; then
9151     AS_FOR_TARGET="$2"
9152   else
9153     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9154   fi
9155 else
9156   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9157 fi
9158
9159 else
9160   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9161 fi
9162
9163
9164
9165
9166 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9167   if test -n "$with_build_time_tools"; then
9168     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9169 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9170     if test -x $with_build_time_tools/dlltool; then
9171       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9172       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9173       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9174 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9175     else
9176       echo "$as_me:$LINENO: result: no" >&5
9177 echo "${ECHO_T}no" >&6
9178     fi
9179   elif test $build != $host && test $have_gcc_for_target = yes; then
9180     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9181     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9182     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9183   fi
9184 fi
9185 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9186   # Extract the first word of "dlltool", so it can be a program name with args.
9187 set dummy dlltool; ac_word=$2
9188 echo "$as_me:$LINENO: checking for $ac_word" >&5
9189 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9190 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9191   echo $ECHO_N "(cached) $ECHO_C" >&6
9192 else
9193   case $DLLTOOL_FOR_TARGET in
9194   [\\/]* | ?:[\\/]*)
9195   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9196   ;;
9197   *)
9198   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9199 for as_dir in $gcc_cv_tool_dirs
9200 do
9201   IFS=$as_save_IFS
9202   test -z "$as_dir" && as_dir=.
9203   for ac_exec_ext in '' $ac_executable_extensions; do
9204   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9205     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9206     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9207     break 2
9208   fi
9209 done
9210 done
9211
9212   ;;
9213 esac
9214 fi
9215 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9216
9217 if test -n "$DLLTOOL_FOR_TARGET"; then
9218   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9219 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9220 else
9221   echo "$as_me:$LINENO: result: no" >&5
9222 echo "${ECHO_T}no" >&6
9223 fi
9224
9225 fi
9226 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9227
9228
9229 if test -n "$DLLTOOL_FOR_TARGET"; then
9230   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9231 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9232   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9233 fi
9234
9235 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9236   for ncn_progname in dlltool; do
9237     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9238 set dummy ${ncn_progname}; ac_word=$2
9239 echo "$as_me:$LINENO: checking for $ac_word" >&5
9240 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9241 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9242   echo $ECHO_N "(cached) $ECHO_C" >&6
9243 else
9244   if test -n "$DLLTOOL_FOR_TARGET"; then
9245   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9246 else
9247 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9248 for as_dir in $PATH
9249 do
9250   IFS=$as_save_IFS
9251   test -z "$as_dir" && as_dir=.
9252   for ac_exec_ext in '' $ac_executable_extensions; do
9253   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9254     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9255     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9256     break 2
9257   fi
9258 done
9259 done
9260
9261 fi
9262 fi
9263 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9264 if test -n "$DLLTOOL_FOR_TARGET"; then
9265   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9266 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9267 else
9268   echo "$as_me:$LINENO: result: no" >&5
9269 echo "${ECHO_T}no" >&6
9270 fi
9271
9272   done
9273 fi
9274
9275 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9276   for ncn_progname in dlltool; do
9277     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9278 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9279     if test -x $with_build_time_tools/${ncn_progname}; then
9280       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9281       echo "$as_me:$LINENO: result: yes" >&5
9282 echo "${ECHO_T}yes" >&6
9283       break
9284     else
9285       echo "$as_me:$LINENO: result: no" >&5
9286 echo "${ECHO_T}no" >&6
9287     fi
9288   done
9289 fi
9290
9291 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9292   for ncn_progname in dlltool; do
9293     if test -n "$ncn_target_tool_prefix"; then
9294       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9295 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9296 echo "$as_me:$LINENO: checking for $ac_word" >&5
9297 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9298 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9299   echo $ECHO_N "(cached) $ECHO_C" >&6
9300 else
9301   if test -n "$DLLTOOL_FOR_TARGET"; then
9302   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9303 else
9304 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9305 for as_dir in $PATH
9306 do
9307   IFS=$as_save_IFS
9308   test -z "$as_dir" && as_dir=.
9309   for ac_exec_ext in '' $ac_executable_extensions; do
9310   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9311     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9312     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9313     break 2
9314   fi
9315 done
9316 done
9317
9318 fi
9319 fi
9320 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9321 if test -n "$DLLTOOL_FOR_TARGET"; then
9322   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9323 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9324 else
9325   echo "$as_me:$LINENO: result: no" >&5
9326 echo "${ECHO_T}no" >&6
9327 fi
9328
9329     fi
9330     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9331       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9332 set dummy ${ncn_progname}; ac_word=$2
9333 echo "$as_me:$LINENO: checking for $ac_word" >&5
9334 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9335 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9336   echo $ECHO_N "(cached) $ECHO_C" >&6
9337 else
9338   if test -n "$DLLTOOL_FOR_TARGET"; then
9339   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9340 else
9341 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9342 for as_dir in $PATH
9343 do
9344   IFS=$as_save_IFS
9345   test -z "$as_dir" && as_dir=.
9346   for ac_exec_ext in '' $ac_executable_extensions; do
9347   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9348     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9349     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9350     break 2
9351   fi
9352 done
9353 done
9354
9355 fi
9356 fi
9357 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9358 if test -n "$DLLTOOL_FOR_TARGET"; then
9359   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9360 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9361 else
9362   echo "$as_me:$LINENO: result: no" >&5
9363 echo "${ECHO_T}no" >&6
9364 fi
9365
9366     fi
9367     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9368   done
9369 fi
9370
9371 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9372   set dummy dlltool
9373   if test $build = $target ; then
9374     DLLTOOL_FOR_TARGET="$2"
9375   else
9376     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9377   fi
9378 else
9379   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9380 fi
9381
9382 else
9383   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9384 fi
9385
9386
9387
9388
9389 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9390   if test -n "$with_build_time_tools"; then
9391     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9392 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9393     if test -x $with_build_time_tools/ld; then
9394       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9395       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9396       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9397 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9398     else
9399       echo "$as_me:$LINENO: result: no" >&5
9400 echo "${ECHO_T}no" >&6
9401     fi
9402   elif test $build != $host && test $have_gcc_for_target = yes; then
9403     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9404     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9405     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9406   fi
9407 fi
9408 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9409   # Extract the first word of "ld", so it can be a program name with args.
9410 set dummy ld; ac_word=$2
9411 echo "$as_me:$LINENO: checking for $ac_word" >&5
9412 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9413 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9414   echo $ECHO_N "(cached) $ECHO_C" >&6
9415 else
9416   case $LD_FOR_TARGET in
9417   [\\/]* | ?:[\\/]*)
9418   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9419   ;;
9420   *)
9421   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9422 for as_dir in $gcc_cv_tool_dirs
9423 do
9424   IFS=$as_save_IFS
9425   test -z "$as_dir" && as_dir=.
9426   for ac_exec_ext in '' $ac_executable_extensions; do
9427   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9428     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9429     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9430     break 2
9431   fi
9432 done
9433 done
9434
9435   ;;
9436 esac
9437 fi
9438 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9439
9440 if test -n "$LD_FOR_TARGET"; then
9441   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9442 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9443 else
9444   echo "$as_me:$LINENO: result: no" >&5
9445 echo "${ECHO_T}no" >&6
9446 fi
9447
9448 fi
9449 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9450
9451
9452 if test -n "$LD_FOR_TARGET"; then
9453   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9454 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9455   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9456 fi
9457
9458 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9459   for ncn_progname in ld; do
9460     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9461 set dummy ${ncn_progname}; ac_word=$2
9462 echo "$as_me:$LINENO: checking for $ac_word" >&5
9463 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9464 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9465   echo $ECHO_N "(cached) $ECHO_C" >&6
9466 else
9467   if test -n "$LD_FOR_TARGET"; then
9468   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9469 else
9470 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9471 for as_dir in $PATH
9472 do
9473   IFS=$as_save_IFS
9474   test -z "$as_dir" && as_dir=.
9475   for ac_exec_ext in '' $ac_executable_extensions; do
9476   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9477     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9478     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9479     break 2
9480   fi
9481 done
9482 done
9483
9484 fi
9485 fi
9486 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9487 if test -n "$LD_FOR_TARGET"; then
9488   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9489 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9490 else
9491   echo "$as_me:$LINENO: result: no" >&5
9492 echo "${ECHO_T}no" >&6
9493 fi
9494
9495   done
9496 fi
9497
9498 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9499   for ncn_progname in ld; do
9500     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9501 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9502     if test -x $with_build_time_tools/${ncn_progname}; then
9503       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9504       echo "$as_me:$LINENO: result: yes" >&5
9505 echo "${ECHO_T}yes" >&6
9506       break
9507     else
9508       echo "$as_me:$LINENO: result: no" >&5
9509 echo "${ECHO_T}no" >&6
9510     fi
9511   done
9512 fi
9513
9514 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9515   for ncn_progname in ld; do
9516     if test -n "$ncn_target_tool_prefix"; then
9517       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9518 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9519 echo "$as_me:$LINENO: checking for $ac_word" >&5
9520 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9521 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9522   echo $ECHO_N "(cached) $ECHO_C" >&6
9523 else
9524   if test -n "$LD_FOR_TARGET"; then
9525   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9526 else
9527 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9528 for as_dir in $PATH
9529 do
9530   IFS=$as_save_IFS
9531   test -z "$as_dir" && as_dir=.
9532   for ac_exec_ext in '' $ac_executable_extensions; do
9533   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9534     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9535     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9536     break 2
9537   fi
9538 done
9539 done
9540
9541 fi
9542 fi
9543 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9544 if test -n "$LD_FOR_TARGET"; then
9545   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9546 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9547 else
9548   echo "$as_me:$LINENO: result: no" >&5
9549 echo "${ECHO_T}no" >&6
9550 fi
9551
9552     fi
9553     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9554       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9555 set dummy ${ncn_progname}; ac_word=$2
9556 echo "$as_me:$LINENO: checking for $ac_word" >&5
9557 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9558 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9559   echo $ECHO_N "(cached) $ECHO_C" >&6
9560 else
9561   if test -n "$LD_FOR_TARGET"; then
9562   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9563 else
9564 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9565 for as_dir in $PATH
9566 do
9567   IFS=$as_save_IFS
9568   test -z "$as_dir" && as_dir=.
9569   for ac_exec_ext in '' $ac_executable_extensions; do
9570   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9571     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9572     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9573     break 2
9574   fi
9575 done
9576 done
9577
9578 fi
9579 fi
9580 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9581 if test -n "$LD_FOR_TARGET"; then
9582   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9583 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9584 else
9585   echo "$as_me:$LINENO: result: no" >&5
9586 echo "${ECHO_T}no" >&6
9587 fi
9588
9589     fi
9590     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9591   done
9592 fi
9593
9594 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9595   set dummy ld
9596   if test $build = $target ; then
9597     LD_FOR_TARGET="$2"
9598   else
9599     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9600   fi
9601 else
9602   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9603 fi
9604
9605 else
9606   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9607 fi
9608
9609
9610
9611
9612 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9613   if test -n "$with_build_time_tools"; then
9614     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9615 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9616     if test -x $with_build_time_tools/lipo; then
9617       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9618       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9619       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9620 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9621     else
9622       echo "$as_me:$LINENO: result: no" >&5
9623 echo "${ECHO_T}no" >&6
9624     fi
9625   elif test $build != $host && test $have_gcc_for_target = yes; then
9626     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9627     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9628     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9629   fi
9630 fi
9631 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9632   # Extract the first word of "lipo", so it can be a program name with args.
9633 set dummy lipo; ac_word=$2
9634 echo "$as_me:$LINENO: checking for $ac_word" >&5
9635 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9636 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9637   echo $ECHO_N "(cached) $ECHO_C" >&6
9638 else
9639   case $LIPO_FOR_TARGET in
9640   [\\/]* | ?:[\\/]*)
9641   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9642   ;;
9643   *)
9644   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9645 for as_dir in $gcc_cv_tool_dirs
9646 do
9647   IFS=$as_save_IFS
9648   test -z "$as_dir" && as_dir=.
9649   for ac_exec_ext in '' $ac_executable_extensions; do
9650   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9651     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9652     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9653     break 2
9654   fi
9655 done
9656 done
9657
9658   ;;
9659 esac
9660 fi
9661 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9662
9663 if test -n "$LIPO_FOR_TARGET"; then
9664   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9665 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9666 else
9667   echo "$as_me:$LINENO: result: no" >&5
9668 echo "${ECHO_T}no" >&6
9669 fi
9670
9671 fi
9672 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9673
9674
9675 if test -n "$LIPO_FOR_TARGET"; then
9676   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9677 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9678   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9679 fi
9680
9681 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9682   for ncn_progname in lipo; do
9683     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9684 set dummy ${ncn_progname}; ac_word=$2
9685 echo "$as_me:$LINENO: checking for $ac_word" >&5
9686 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9687 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9688   echo $ECHO_N "(cached) $ECHO_C" >&6
9689 else
9690   if test -n "$LIPO_FOR_TARGET"; then
9691   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9692 else
9693 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9694 for as_dir in $PATH
9695 do
9696   IFS=$as_save_IFS
9697   test -z "$as_dir" && as_dir=.
9698   for ac_exec_ext in '' $ac_executable_extensions; do
9699   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9700     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9701     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9702     break 2
9703   fi
9704 done
9705 done
9706
9707 fi
9708 fi
9709 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9710 if test -n "$LIPO_FOR_TARGET"; then
9711   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9712 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9713 else
9714   echo "$as_me:$LINENO: result: no" >&5
9715 echo "${ECHO_T}no" >&6
9716 fi
9717
9718   done
9719 fi
9720
9721 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9722   for ncn_progname in lipo; do
9723     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9724 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9725     if test -x $with_build_time_tools/${ncn_progname}; then
9726       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9727       echo "$as_me:$LINENO: result: yes" >&5
9728 echo "${ECHO_T}yes" >&6
9729       break
9730     else
9731       echo "$as_me:$LINENO: result: no" >&5
9732 echo "${ECHO_T}no" >&6
9733     fi
9734   done
9735 fi
9736
9737 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9738   for ncn_progname in lipo; do
9739     if test -n "$ncn_target_tool_prefix"; then
9740       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9741 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9742 echo "$as_me:$LINENO: checking for $ac_word" >&5
9743 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9744 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9745   echo $ECHO_N "(cached) $ECHO_C" >&6
9746 else
9747   if test -n "$LIPO_FOR_TARGET"; then
9748   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9749 else
9750 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9751 for as_dir in $PATH
9752 do
9753   IFS=$as_save_IFS
9754   test -z "$as_dir" && as_dir=.
9755   for ac_exec_ext in '' $ac_executable_extensions; do
9756   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9757     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9758     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9759     break 2
9760   fi
9761 done
9762 done
9763
9764 fi
9765 fi
9766 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9767 if test -n "$LIPO_FOR_TARGET"; then
9768   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9769 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9770 else
9771   echo "$as_me:$LINENO: result: no" >&5
9772 echo "${ECHO_T}no" >&6
9773 fi
9774
9775     fi
9776     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9777       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9778 set dummy ${ncn_progname}; ac_word=$2
9779 echo "$as_me:$LINENO: checking for $ac_word" >&5
9780 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9781 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9782   echo $ECHO_N "(cached) $ECHO_C" >&6
9783 else
9784   if test -n "$LIPO_FOR_TARGET"; then
9785   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9786 else
9787 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9788 for as_dir in $PATH
9789 do
9790   IFS=$as_save_IFS
9791   test -z "$as_dir" && as_dir=.
9792   for ac_exec_ext in '' $ac_executable_extensions; do
9793   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9794     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9795     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9796     break 2
9797   fi
9798 done
9799 done
9800
9801 fi
9802 fi
9803 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9804 if test -n "$LIPO_FOR_TARGET"; then
9805   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9806 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9807 else
9808   echo "$as_me:$LINENO: result: no" >&5
9809 echo "${ECHO_T}no" >&6
9810 fi
9811
9812     fi
9813     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9814   done
9815 fi
9816
9817 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9818   set dummy lipo
9819   if test $build = $target ; then
9820     LIPO_FOR_TARGET="$2"
9821   else
9822     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9823   fi
9824 else
9825   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9826 fi
9827
9828 else
9829   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9830 fi
9831
9832
9833
9834
9835 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9836   if test -n "$with_build_time_tools"; then
9837     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9838 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9839     if test -x $with_build_time_tools/nm; then
9840       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9841       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9842       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9843 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9844     else
9845       echo "$as_me:$LINENO: result: no" >&5
9846 echo "${ECHO_T}no" >&6
9847     fi
9848   elif test $build != $host && test $have_gcc_for_target = yes; then
9849     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9850     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
9851     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9852   fi
9853 fi
9854 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9855   # Extract the first word of "nm", so it can be a program name with args.
9856 set dummy nm; ac_word=$2
9857 echo "$as_me:$LINENO: checking for $ac_word" >&5
9858 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9859 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9860   echo $ECHO_N "(cached) $ECHO_C" >&6
9861 else
9862   case $NM_FOR_TARGET in
9863   [\\/]* | ?:[\\/]*)
9864   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9865   ;;
9866   *)
9867   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9868 for as_dir in $gcc_cv_tool_dirs
9869 do
9870   IFS=$as_save_IFS
9871   test -z "$as_dir" && as_dir=.
9872   for ac_exec_ext in '' $ac_executable_extensions; do
9873   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9874     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9875     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9876     break 2
9877   fi
9878 done
9879 done
9880
9881   ;;
9882 esac
9883 fi
9884 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9885
9886 if test -n "$NM_FOR_TARGET"; then
9887   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9888 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9889 else
9890   echo "$as_me:$LINENO: result: no" >&5
9891 echo "${ECHO_T}no" >&6
9892 fi
9893
9894 fi
9895 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9896
9897
9898 if test -n "$NM_FOR_TARGET"; then
9899   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9900 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9901   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9902 fi
9903
9904 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9905   for ncn_progname in nm; do
9906     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9907 set dummy ${ncn_progname}; ac_word=$2
9908 echo "$as_me:$LINENO: checking for $ac_word" >&5
9909 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9910 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9911   echo $ECHO_N "(cached) $ECHO_C" >&6
9912 else
9913   if test -n "$NM_FOR_TARGET"; then
9914   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9915 else
9916 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9917 for as_dir in $PATH
9918 do
9919   IFS=$as_save_IFS
9920   test -z "$as_dir" && as_dir=.
9921   for ac_exec_ext in '' $ac_executable_extensions; do
9922   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9923     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9924     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9925     break 2
9926   fi
9927 done
9928 done
9929
9930 fi
9931 fi
9932 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9933 if test -n "$NM_FOR_TARGET"; then
9934   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9935 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9936 else
9937   echo "$as_me:$LINENO: result: no" >&5
9938 echo "${ECHO_T}no" >&6
9939 fi
9940
9941   done
9942 fi
9943
9944 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
9945   for ncn_progname in nm; do
9946     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9947 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9948     if test -x $with_build_time_tools/${ncn_progname}; then
9949       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9950       echo "$as_me:$LINENO: result: yes" >&5
9951 echo "${ECHO_T}yes" >&6
9952       break
9953     else
9954       echo "$as_me:$LINENO: result: no" >&5
9955 echo "${ECHO_T}no" >&6
9956     fi
9957   done
9958 fi
9959
9960 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
9961   for ncn_progname in nm; do
9962     if test -n "$ncn_target_tool_prefix"; then
9963       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9964 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9965 echo "$as_me:$LINENO: checking for $ac_word" >&5
9966 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9967 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9968   echo $ECHO_N "(cached) $ECHO_C" >&6
9969 else
9970   if test -n "$NM_FOR_TARGET"; then
9971   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9972 else
9973 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9974 for as_dir in $PATH
9975 do
9976   IFS=$as_save_IFS
9977   test -z "$as_dir" && as_dir=.
9978   for ac_exec_ext in '' $ac_executable_extensions; do
9979   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9980     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9981     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9982     break 2
9983   fi
9984 done
9985 done
9986
9987 fi
9988 fi
9989 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9990 if test -n "$NM_FOR_TARGET"; then
9991   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9992 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9993 else
9994   echo "$as_me:$LINENO: result: no" >&5
9995 echo "${ECHO_T}no" >&6
9996 fi
9997
9998     fi
9999     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10000       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10001 set dummy ${ncn_progname}; ac_word=$2
10002 echo "$as_me:$LINENO: checking for $ac_word" >&5
10003 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10004 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10005   echo $ECHO_N "(cached) $ECHO_C" >&6
10006 else
10007   if test -n "$NM_FOR_TARGET"; then
10008   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10009 else
10010 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10011 for as_dir in $PATH
10012 do
10013   IFS=$as_save_IFS
10014   test -z "$as_dir" && as_dir=.
10015   for ac_exec_ext in '' $ac_executable_extensions; do
10016   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10017     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10018     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10019     break 2
10020   fi
10021 done
10022 done
10023
10024 fi
10025 fi
10026 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10027 if test -n "$NM_FOR_TARGET"; then
10028   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10029 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10030 else
10031   echo "$as_me:$LINENO: result: no" >&5
10032 echo "${ECHO_T}no" >&6
10033 fi
10034
10035     fi
10036     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10037   done
10038 fi
10039
10040 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10041   set dummy nm
10042   if test $build = $target ; then
10043     NM_FOR_TARGET="$2"
10044   else
10045     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10046   fi
10047 else
10048   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10049 fi
10050
10051 else
10052   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10053 fi
10054
10055
10056
10057
10058 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10059   if test -n "$with_build_time_tools"; then
10060     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10061 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10062     if test -x $with_build_time_tools/objdump; then
10063       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10064       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10065       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10066 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10067     else
10068       echo "$as_me:$LINENO: result: no" >&5
10069 echo "${ECHO_T}no" >&6
10070     fi
10071   elif test $build != $host && test $have_gcc_for_target = yes; then
10072     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10073     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10074     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10075   fi
10076 fi
10077 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10078   # Extract the first word of "objdump", so it can be a program name with args.
10079 set dummy objdump; ac_word=$2
10080 echo "$as_me:$LINENO: checking for $ac_word" >&5
10081 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10082 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10083   echo $ECHO_N "(cached) $ECHO_C" >&6
10084 else
10085   case $OBJDUMP_FOR_TARGET in
10086   [\\/]* | ?:[\\/]*)
10087   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10088   ;;
10089   *)
10090   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10091 for as_dir in $gcc_cv_tool_dirs
10092 do
10093   IFS=$as_save_IFS
10094   test -z "$as_dir" && as_dir=.
10095   for ac_exec_ext in '' $ac_executable_extensions; do
10096   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10097     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10098     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10099     break 2
10100   fi
10101 done
10102 done
10103
10104   ;;
10105 esac
10106 fi
10107 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10108
10109 if test -n "$OBJDUMP_FOR_TARGET"; then
10110   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10111 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10112 else
10113   echo "$as_me:$LINENO: result: no" >&5
10114 echo "${ECHO_T}no" >&6
10115 fi
10116
10117 fi
10118 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10119
10120
10121 if test -n "$OBJDUMP_FOR_TARGET"; then
10122   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10123 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10124   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10125 fi
10126
10127 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10128   for ncn_progname in objdump; do
10129     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10130 set dummy ${ncn_progname}; ac_word=$2
10131 echo "$as_me:$LINENO: checking for $ac_word" >&5
10132 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10133 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10134   echo $ECHO_N "(cached) $ECHO_C" >&6
10135 else
10136   if test -n "$OBJDUMP_FOR_TARGET"; then
10137   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10138 else
10139 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10140 for as_dir in $PATH
10141 do
10142   IFS=$as_save_IFS
10143   test -z "$as_dir" && as_dir=.
10144   for ac_exec_ext in '' $ac_executable_extensions; do
10145   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10146     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10147     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10148     break 2
10149   fi
10150 done
10151 done
10152
10153 fi
10154 fi
10155 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10156 if test -n "$OBJDUMP_FOR_TARGET"; then
10157   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10158 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10159 else
10160   echo "$as_me:$LINENO: result: no" >&5
10161 echo "${ECHO_T}no" >&6
10162 fi
10163
10164   done
10165 fi
10166
10167 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10168   for ncn_progname in objdump; do
10169     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10170 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10171     if test -x $with_build_time_tools/${ncn_progname}; then
10172       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10173       echo "$as_me:$LINENO: result: yes" >&5
10174 echo "${ECHO_T}yes" >&6
10175       break
10176     else
10177       echo "$as_me:$LINENO: result: no" >&5
10178 echo "${ECHO_T}no" >&6
10179     fi
10180   done
10181 fi
10182
10183 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10184   for ncn_progname in objdump; do
10185     if test -n "$ncn_target_tool_prefix"; then
10186       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10187 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10188 echo "$as_me:$LINENO: checking for $ac_word" >&5
10189 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10190 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10191   echo $ECHO_N "(cached) $ECHO_C" >&6
10192 else
10193   if test -n "$OBJDUMP_FOR_TARGET"; then
10194   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10195 else
10196 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10197 for as_dir in $PATH
10198 do
10199   IFS=$as_save_IFS
10200   test -z "$as_dir" && as_dir=.
10201   for ac_exec_ext in '' $ac_executable_extensions; do
10202   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10203     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10204     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10205     break 2
10206   fi
10207 done
10208 done
10209
10210 fi
10211 fi
10212 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10213 if test -n "$OBJDUMP_FOR_TARGET"; then
10214   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10215 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10216 else
10217   echo "$as_me:$LINENO: result: no" >&5
10218 echo "${ECHO_T}no" >&6
10219 fi
10220
10221     fi
10222     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10223       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10224 set dummy ${ncn_progname}; ac_word=$2
10225 echo "$as_me:$LINENO: checking for $ac_word" >&5
10226 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10227 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10228   echo $ECHO_N "(cached) $ECHO_C" >&6
10229 else
10230   if test -n "$OBJDUMP_FOR_TARGET"; then
10231   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10232 else
10233 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10234 for as_dir in $PATH
10235 do
10236   IFS=$as_save_IFS
10237   test -z "$as_dir" && as_dir=.
10238   for ac_exec_ext in '' $ac_executable_extensions; do
10239   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10240     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10241     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10242     break 2
10243   fi
10244 done
10245 done
10246
10247 fi
10248 fi
10249 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10250 if test -n "$OBJDUMP_FOR_TARGET"; then
10251   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10252 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10253 else
10254   echo "$as_me:$LINENO: result: no" >&5
10255 echo "${ECHO_T}no" >&6
10256 fi
10257
10258     fi
10259     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10260   done
10261 fi
10262
10263 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10264   set dummy objdump
10265   if test $build = $target ; then
10266     OBJDUMP_FOR_TARGET="$2"
10267   else
10268     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10269   fi
10270 else
10271   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10272 fi
10273
10274 else
10275   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10276 fi
10277
10278
10279
10280
10281 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10282   if test -n "$with_build_time_tools"; then
10283     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10284 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10285     if test -x $with_build_time_tools/ranlib; then
10286       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10287       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10288       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10289 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10290     else
10291       echo "$as_me:$LINENO: result: no" >&5
10292 echo "${ECHO_T}no" >&6
10293     fi
10294   elif test $build != $host && test $have_gcc_for_target = yes; then
10295     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10296     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10297     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10298   fi
10299 fi
10300 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10301   # Extract the first word of "ranlib", so it can be a program name with args.
10302 set dummy ranlib; ac_word=$2
10303 echo "$as_me:$LINENO: checking for $ac_word" >&5
10304 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10305 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10306   echo $ECHO_N "(cached) $ECHO_C" >&6
10307 else
10308   case $RANLIB_FOR_TARGET in
10309   [\\/]* | ?:[\\/]*)
10310   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10311   ;;
10312   *)
10313   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10314 for as_dir in $gcc_cv_tool_dirs
10315 do
10316   IFS=$as_save_IFS
10317   test -z "$as_dir" && as_dir=.
10318   for ac_exec_ext in '' $ac_executable_extensions; do
10319   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10320     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10321     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10322     break 2
10323   fi
10324 done
10325 done
10326
10327   ;;
10328 esac
10329 fi
10330 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10331
10332 if test -n "$RANLIB_FOR_TARGET"; then
10333   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10334 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10335 else
10336   echo "$as_me:$LINENO: result: no" >&5
10337 echo "${ECHO_T}no" >&6
10338 fi
10339
10340 fi
10341 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10342
10343
10344 if test -n "$RANLIB_FOR_TARGET"; then
10345   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10346 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10347   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10348 fi
10349
10350 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10351   for ncn_progname in ranlib; do
10352     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10353 set dummy ${ncn_progname}; ac_word=$2
10354 echo "$as_me:$LINENO: checking for $ac_word" >&5
10355 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10356 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10357   echo $ECHO_N "(cached) $ECHO_C" >&6
10358 else
10359   if test -n "$RANLIB_FOR_TARGET"; then
10360   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10361 else
10362 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10363 for as_dir in $PATH
10364 do
10365   IFS=$as_save_IFS
10366   test -z "$as_dir" && as_dir=.
10367   for ac_exec_ext in '' $ac_executable_extensions; do
10368   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10369     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10370     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10371     break 2
10372   fi
10373 done
10374 done
10375
10376 fi
10377 fi
10378 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10379 if test -n "$RANLIB_FOR_TARGET"; then
10380   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10381 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10382 else
10383   echo "$as_me:$LINENO: result: no" >&5
10384 echo "${ECHO_T}no" >&6
10385 fi
10386
10387   done
10388 fi
10389
10390 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10391   for ncn_progname in ranlib; do
10392     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10393 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10394     if test -x $with_build_time_tools/${ncn_progname}; then
10395       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10396       echo "$as_me:$LINENO: result: yes" >&5
10397 echo "${ECHO_T}yes" >&6
10398       break
10399     else
10400       echo "$as_me:$LINENO: result: no" >&5
10401 echo "${ECHO_T}no" >&6
10402     fi
10403   done
10404 fi
10405
10406 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10407   for ncn_progname in ranlib; do
10408     if test -n "$ncn_target_tool_prefix"; then
10409       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10410 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10411 echo "$as_me:$LINENO: checking for $ac_word" >&5
10412 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10413 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10414   echo $ECHO_N "(cached) $ECHO_C" >&6
10415 else
10416   if test -n "$RANLIB_FOR_TARGET"; then
10417   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10418 else
10419 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10420 for as_dir in $PATH
10421 do
10422   IFS=$as_save_IFS
10423   test -z "$as_dir" && as_dir=.
10424   for ac_exec_ext in '' $ac_executable_extensions; do
10425   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10426     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10427     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10428     break 2
10429   fi
10430 done
10431 done
10432
10433 fi
10434 fi
10435 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10436 if test -n "$RANLIB_FOR_TARGET"; then
10437   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10438 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10439 else
10440   echo "$as_me:$LINENO: result: no" >&5
10441 echo "${ECHO_T}no" >&6
10442 fi
10443
10444     fi
10445     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10446       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10447 set dummy ${ncn_progname}; ac_word=$2
10448 echo "$as_me:$LINENO: checking for $ac_word" >&5
10449 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10450 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10451   echo $ECHO_N "(cached) $ECHO_C" >&6
10452 else
10453   if test -n "$RANLIB_FOR_TARGET"; then
10454   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10455 else
10456 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10457 for as_dir in $PATH
10458 do
10459   IFS=$as_save_IFS
10460   test -z "$as_dir" && as_dir=.
10461   for ac_exec_ext in '' $ac_executable_extensions; do
10462   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10463     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10464     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10465     break 2
10466   fi
10467 done
10468 done
10469
10470 fi
10471 fi
10472 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10473 if test -n "$RANLIB_FOR_TARGET"; then
10474   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10475 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10476 else
10477   echo "$as_me:$LINENO: result: no" >&5
10478 echo "${ECHO_T}no" >&6
10479 fi
10480
10481     fi
10482     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10483   done
10484 fi
10485
10486 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10487   set dummy ranlib
10488   if test $build = $target ; then
10489     RANLIB_FOR_TARGET="$2"
10490   else
10491     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10492   fi
10493 else
10494   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10495 fi
10496
10497 else
10498   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10499 fi
10500
10501
10502
10503
10504 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10505   if test -n "$with_build_time_tools"; then
10506     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10507 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10508     if test -x $with_build_time_tools/strip; then
10509       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10510       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10511       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10512 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10513     else
10514       echo "$as_me:$LINENO: result: no" >&5
10515 echo "${ECHO_T}no" >&6
10516     fi
10517   elif test $build != $host && test $have_gcc_for_target = yes; then
10518     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10519     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10520     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10521   fi
10522 fi
10523 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10524   # Extract the first word of "strip", so it can be a program name with args.
10525 set dummy strip; ac_word=$2
10526 echo "$as_me:$LINENO: checking for $ac_word" >&5
10527 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10528 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10529   echo $ECHO_N "(cached) $ECHO_C" >&6
10530 else
10531   case $STRIP_FOR_TARGET in
10532   [\\/]* | ?:[\\/]*)
10533   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10534   ;;
10535   *)
10536   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10537 for as_dir in $gcc_cv_tool_dirs
10538 do
10539   IFS=$as_save_IFS
10540   test -z "$as_dir" && as_dir=.
10541   for ac_exec_ext in '' $ac_executable_extensions; do
10542   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10543     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10544     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10545     break 2
10546   fi
10547 done
10548 done
10549
10550   ;;
10551 esac
10552 fi
10553 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10554
10555 if test -n "$STRIP_FOR_TARGET"; then
10556   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10557 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10558 else
10559   echo "$as_me:$LINENO: result: no" >&5
10560 echo "${ECHO_T}no" >&6
10561 fi
10562
10563 fi
10564 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10565
10566
10567 if test -n "$STRIP_FOR_TARGET"; then
10568   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10569 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10570   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10571 fi
10572
10573 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10574   for ncn_progname in strip; do
10575     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10576 set dummy ${ncn_progname}; ac_word=$2
10577 echo "$as_me:$LINENO: checking for $ac_word" >&5
10578 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10579 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10580   echo $ECHO_N "(cached) $ECHO_C" >&6
10581 else
10582   if test -n "$STRIP_FOR_TARGET"; then
10583   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10584 else
10585 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10586 for as_dir in $PATH
10587 do
10588   IFS=$as_save_IFS
10589   test -z "$as_dir" && as_dir=.
10590   for ac_exec_ext in '' $ac_executable_extensions; do
10591   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10592     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10593     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10594     break 2
10595   fi
10596 done
10597 done
10598
10599 fi
10600 fi
10601 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10602 if test -n "$STRIP_FOR_TARGET"; then
10603   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10604 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10605 else
10606   echo "$as_me:$LINENO: result: no" >&5
10607 echo "${ECHO_T}no" >&6
10608 fi
10609
10610   done
10611 fi
10612
10613 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10614   for ncn_progname in strip; do
10615     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10616 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10617     if test -x $with_build_time_tools/${ncn_progname}; then
10618       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10619       echo "$as_me:$LINENO: result: yes" >&5
10620 echo "${ECHO_T}yes" >&6
10621       break
10622     else
10623       echo "$as_me:$LINENO: result: no" >&5
10624 echo "${ECHO_T}no" >&6
10625     fi
10626   done
10627 fi
10628
10629 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10630   for ncn_progname in strip; do
10631     if test -n "$ncn_target_tool_prefix"; then
10632       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10633 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10634 echo "$as_me:$LINENO: checking for $ac_word" >&5
10635 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10636 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10637   echo $ECHO_N "(cached) $ECHO_C" >&6
10638 else
10639   if test -n "$STRIP_FOR_TARGET"; then
10640   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10641 else
10642 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10643 for as_dir in $PATH
10644 do
10645   IFS=$as_save_IFS
10646   test -z "$as_dir" && as_dir=.
10647   for ac_exec_ext in '' $ac_executable_extensions; do
10648   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10649     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10650     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10651     break 2
10652   fi
10653 done
10654 done
10655
10656 fi
10657 fi
10658 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10659 if test -n "$STRIP_FOR_TARGET"; then
10660   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10661 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10662 else
10663   echo "$as_me:$LINENO: result: no" >&5
10664 echo "${ECHO_T}no" >&6
10665 fi
10666
10667     fi
10668     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10669       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10670 set dummy ${ncn_progname}; ac_word=$2
10671 echo "$as_me:$LINENO: checking for $ac_word" >&5
10672 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10673 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10674   echo $ECHO_N "(cached) $ECHO_C" >&6
10675 else
10676   if test -n "$STRIP_FOR_TARGET"; then
10677   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10678 else
10679 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10680 for as_dir in $PATH
10681 do
10682   IFS=$as_save_IFS
10683   test -z "$as_dir" && as_dir=.
10684   for ac_exec_ext in '' $ac_executable_extensions; do
10685   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10686     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10687     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10688     break 2
10689   fi
10690 done
10691 done
10692
10693 fi
10694 fi
10695 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10696 if test -n "$STRIP_FOR_TARGET"; then
10697   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10698 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10699 else
10700   echo "$as_me:$LINENO: result: no" >&5
10701 echo "${ECHO_T}no" >&6
10702 fi
10703
10704     fi
10705     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10706   done
10707 fi
10708
10709 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10710   set dummy strip
10711   if test $build = $target ; then
10712     STRIP_FOR_TARGET="$2"
10713   else
10714     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10715   fi
10716 else
10717   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10718 fi
10719
10720 else
10721   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10722 fi
10723
10724
10725
10726
10727 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10728   if test -n "$with_build_time_tools"; then
10729     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10730 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10731     if test -x $with_build_time_tools/windres; then
10732       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10733       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10734       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10735 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10736     else
10737       echo "$as_me:$LINENO: result: no" >&5
10738 echo "${ECHO_T}no" >&6
10739     fi
10740   elif test $build != $host && test $have_gcc_for_target = yes; then
10741     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10742     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10743     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10744   fi
10745 fi
10746 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10747   # Extract the first word of "windres", so it can be a program name with args.
10748 set dummy windres; ac_word=$2
10749 echo "$as_me:$LINENO: checking for $ac_word" >&5
10750 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10751 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10752   echo $ECHO_N "(cached) $ECHO_C" >&6
10753 else
10754   case $WINDRES_FOR_TARGET in
10755   [\\/]* | ?:[\\/]*)
10756   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10757   ;;
10758   *)
10759   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10760 for as_dir in $gcc_cv_tool_dirs
10761 do
10762   IFS=$as_save_IFS
10763   test -z "$as_dir" && as_dir=.
10764   for ac_exec_ext in '' $ac_executable_extensions; do
10765   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10766     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10767     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10768     break 2
10769   fi
10770 done
10771 done
10772
10773   ;;
10774 esac
10775 fi
10776 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10777
10778 if test -n "$WINDRES_FOR_TARGET"; then
10779   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10780 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10781 else
10782   echo "$as_me:$LINENO: result: no" >&5
10783 echo "${ECHO_T}no" >&6
10784 fi
10785
10786 fi
10787 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10788
10789
10790 if test -n "$WINDRES_FOR_TARGET"; then
10791   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10792 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10793   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10794 fi
10795
10796 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10797   for ncn_progname in windres; do
10798     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10799 set dummy ${ncn_progname}; ac_word=$2
10800 echo "$as_me:$LINENO: checking for $ac_word" >&5
10801 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10802 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10803   echo $ECHO_N "(cached) $ECHO_C" >&6
10804 else
10805   if test -n "$WINDRES_FOR_TARGET"; then
10806   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10807 else
10808 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10809 for as_dir in $PATH
10810 do
10811   IFS=$as_save_IFS
10812   test -z "$as_dir" && as_dir=.
10813   for ac_exec_ext in '' $ac_executable_extensions; do
10814   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10815     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10816     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10817     break 2
10818   fi
10819 done
10820 done
10821
10822 fi
10823 fi
10824 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10825 if test -n "$WINDRES_FOR_TARGET"; then
10826   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10827 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10828 else
10829   echo "$as_me:$LINENO: result: no" >&5
10830 echo "${ECHO_T}no" >&6
10831 fi
10832
10833   done
10834 fi
10835
10836 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10837   for ncn_progname in windres; do
10838     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10839 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10840     if test -x $with_build_time_tools/${ncn_progname}; then
10841       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10842       echo "$as_me:$LINENO: result: yes" >&5
10843 echo "${ECHO_T}yes" >&6
10844       break
10845     else
10846       echo "$as_me:$LINENO: result: no" >&5
10847 echo "${ECHO_T}no" >&6
10848     fi
10849   done
10850 fi
10851
10852 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10853   for ncn_progname in windres; do
10854     if test -n "$ncn_target_tool_prefix"; then
10855       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10856 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10857 echo "$as_me:$LINENO: checking for $ac_word" >&5
10858 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10859 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10860   echo $ECHO_N "(cached) $ECHO_C" >&6
10861 else
10862   if test -n "$WINDRES_FOR_TARGET"; then
10863   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10864 else
10865 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10866 for as_dir in $PATH
10867 do
10868   IFS=$as_save_IFS
10869   test -z "$as_dir" && as_dir=.
10870   for ac_exec_ext in '' $ac_executable_extensions; do
10871   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10872     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10873     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10874     break 2
10875   fi
10876 done
10877 done
10878
10879 fi
10880 fi
10881 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10882 if test -n "$WINDRES_FOR_TARGET"; then
10883   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10884 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10885 else
10886   echo "$as_me:$LINENO: result: no" >&5
10887 echo "${ECHO_T}no" >&6
10888 fi
10889
10890     fi
10891     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10892       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10893 set dummy ${ncn_progname}; ac_word=$2
10894 echo "$as_me:$LINENO: checking for $ac_word" >&5
10895 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10896 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10897   echo $ECHO_N "(cached) $ECHO_C" >&6
10898 else
10899   if test -n "$WINDRES_FOR_TARGET"; then
10900   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10901 else
10902 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10903 for as_dir in $PATH
10904 do
10905   IFS=$as_save_IFS
10906   test -z "$as_dir" && as_dir=.
10907   for ac_exec_ext in '' $ac_executable_extensions; do
10908   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10909     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10910     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10911     break 2
10912   fi
10913 done
10914 done
10915
10916 fi
10917 fi
10918 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10919 if test -n "$WINDRES_FOR_TARGET"; then
10920   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10921 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10922 else
10923   echo "$as_me:$LINENO: result: no" >&5
10924 echo "${ECHO_T}no" >&6
10925 fi
10926
10927     fi
10928     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
10929   done
10930 fi
10931
10932 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
10933   set dummy windres
10934   if test $build = $target ; then
10935     WINDRES_FOR_TARGET="$2"
10936   else
10937     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
10938   fi
10939 else
10940   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
10941 fi
10942
10943 else
10944   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10945 fi
10946
10947
10948
10949
10950 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
10951   if test -n "$with_build_time_tools"; then
10952     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
10953 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
10954     if test -x $with_build_time_tools/windmc; then
10955       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
10956       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10957       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
10958 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
10959     else
10960       echo "$as_me:$LINENO: result: no" >&5
10961 echo "${ECHO_T}no" >&6
10962     fi
10963   elif test $build != $host && test $have_gcc_for_target = yes; then
10964     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
10965     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
10966     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10967   fi
10968 fi
10969 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10970   # Extract the first word of "windmc", so it can be a program name with args.
10971 set dummy windmc; ac_word=$2
10972 echo "$as_me:$LINENO: checking for $ac_word" >&5
10973 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10974 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
10975   echo $ECHO_N "(cached) $ECHO_C" >&6
10976 else
10977   case $WINDMC_FOR_TARGET in
10978   [\\/]* | ?:[\\/]*)
10979   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
10980   ;;
10981   *)
10982   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10983 for as_dir in $gcc_cv_tool_dirs
10984 do
10985   IFS=$as_save_IFS
10986   test -z "$as_dir" && as_dir=.
10987   for ac_exec_ext in '' $ac_executable_extensions; do
10988   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10989     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10990     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10991     break 2
10992   fi
10993 done
10994 done
10995
10996   ;;
10997 esac
10998 fi
10999 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11000
11001 if test -n "$WINDMC_FOR_TARGET"; then
11002   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11003 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11004 else
11005   echo "$as_me:$LINENO: result: no" >&5
11006 echo "${ECHO_T}no" >&6
11007 fi
11008
11009 fi
11010 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11011
11012
11013 if test -n "$WINDMC_FOR_TARGET"; then
11014   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11015 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11016   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11017 fi
11018
11019 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11020   for ncn_progname in windmc; do
11021     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11022 set dummy ${ncn_progname}; ac_word=$2
11023 echo "$as_me:$LINENO: checking for $ac_word" >&5
11024 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11025 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11026   echo $ECHO_N "(cached) $ECHO_C" >&6
11027 else
11028   if test -n "$WINDMC_FOR_TARGET"; then
11029   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11030 else
11031 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11032 for as_dir in $PATH
11033 do
11034   IFS=$as_save_IFS
11035   test -z "$as_dir" && as_dir=.
11036   for ac_exec_ext in '' $ac_executable_extensions; do
11037   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11038     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11039     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11040     break 2
11041   fi
11042 done
11043 done
11044
11045 fi
11046 fi
11047 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11048 if test -n "$WINDMC_FOR_TARGET"; then
11049   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11050 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11051 else
11052   echo "$as_me:$LINENO: result: no" >&5
11053 echo "${ECHO_T}no" >&6
11054 fi
11055
11056   done
11057 fi
11058
11059 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11060   for ncn_progname in windmc; do
11061     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11062 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11063     if test -x $with_build_time_tools/${ncn_progname}; then
11064       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11065       echo "$as_me:$LINENO: result: yes" >&5
11066 echo "${ECHO_T}yes" >&6
11067       break
11068     else
11069       echo "$as_me:$LINENO: result: no" >&5
11070 echo "${ECHO_T}no" >&6
11071     fi
11072   done
11073 fi
11074
11075 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11076   for ncn_progname in windmc; do
11077     if test -n "$ncn_target_tool_prefix"; then
11078       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11079 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11080 echo "$as_me:$LINENO: checking for $ac_word" >&5
11081 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11082 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11083   echo $ECHO_N "(cached) $ECHO_C" >&6
11084 else
11085   if test -n "$WINDMC_FOR_TARGET"; then
11086   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11087 else
11088 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11089 for as_dir in $PATH
11090 do
11091   IFS=$as_save_IFS
11092   test -z "$as_dir" && as_dir=.
11093   for ac_exec_ext in '' $ac_executable_extensions; do
11094   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11095     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11096     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11097     break 2
11098   fi
11099 done
11100 done
11101
11102 fi
11103 fi
11104 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11105 if test -n "$WINDMC_FOR_TARGET"; then
11106   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11107 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11108 else
11109   echo "$as_me:$LINENO: result: no" >&5
11110 echo "${ECHO_T}no" >&6
11111 fi
11112
11113     fi
11114     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11115       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11116 set dummy ${ncn_progname}; ac_word=$2
11117 echo "$as_me:$LINENO: checking for $ac_word" >&5
11118 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11119 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11120   echo $ECHO_N "(cached) $ECHO_C" >&6
11121 else
11122   if test -n "$WINDMC_FOR_TARGET"; then
11123   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11124 else
11125 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11126 for as_dir in $PATH
11127 do
11128   IFS=$as_save_IFS
11129   test -z "$as_dir" && as_dir=.
11130   for ac_exec_ext in '' $ac_executable_extensions; do
11131   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11132     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11133     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11134     break 2
11135   fi
11136 done
11137 done
11138
11139 fi
11140 fi
11141 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11142 if test -n "$WINDMC_FOR_TARGET"; then
11143   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11144 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11145 else
11146   echo "$as_me:$LINENO: result: no" >&5
11147 echo "${ECHO_T}no" >&6
11148 fi
11149
11150     fi
11151     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11152   done
11153 fi
11154
11155 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11156   set dummy windmc
11157   if test $build = $target ; then
11158     WINDMC_FOR_TARGET="$2"
11159   else
11160     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11161   fi
11162 else
11163   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11164 fi
11165
11166 else
11167   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11168 fi
11169
11170
11171 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11172
11173 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11174 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11175 if test "x${build}" != "x${host}" ; then
11176   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11177     # We already found the complete path
11178     ac_dir=`dirname $AR_FOR_TARGET`
11179     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11180 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11181   else
11182     # Canadian cross, just use what we found
11183     echo "$as_me:$LINENO: result: pre-installed" >&5
11184 echo "${ECHO_T}pre-installed" >&6
11185   fi
11186 else
11187   ok=yes
11188   case " ${configdirs} " in
11189     *" binutils "*) ;;
11190     *) ok=no ;;
11191   esac
11192
11193   if test $ok = yes; then
11194     # An in-tree tool is available and we can use it
11195     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11196     echo "$as_me:$LINENO: result: just compiled" >&5
11197 echo "${ECHO_T}just compiled" >&6
11198   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11199     # We already found the complete path
11200     ac_dir=`dirname $AR_FOR_TARGET`
11201     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11202 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11203   elif test "x$target" = "x$host"; then
11204     # We can use an host tool
11205     AR_FOR_TARGET='$(AR)'
11206     echo "$as_me:$LINENO: result: host tool" >&5
11207 echo "${ECHO_T}host tool" >&6
11208   else
11209     # We need a cross tool
11210     echo "$as_me:$LINENO: result: pre-installed" >&5
11211 echo "${ECHO_T}pre-installed" >&6
11212   fi
11213 fi
11214
11215 echo "$as_me:$LINENO: checking where to find the target as" >&5
11216 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11217 if test "x${build}" != "x${host}" ; then
11218   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11219     # We already found the complete path
11220     ac_dir=`dirname $AS_FOR_TARGET`
11221     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11222 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11223   else
11224     # Canadian cross, just use what we found
11225     echo "$as_me:$LINENO: result: pre-installed" >&5
11226 echo "${ECHO_T}pre-installed" >&6
11227   fi
11228 else
11229   ok=yes
11230   case " ${configdirs} " in
11231     *" gas "*) ;;
11232     *) ok=no ;;
11233   esac
11234
11235   if test $ok = yes; then
11236     # An in-tree tool is available and we can use it
11237     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11238     echo "$as_me:$LINENO: result: just compiled" >&5
11239 echo "${ECHO_T}just compiled" >&6
11240   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11241     # We already found the complete path
11242     ac_dir=`dirname $AS_FOR_TARGET`
11243     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11244 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11245   elif test "x$target" = "x$host"; then
11246     # We can use an host tool
11247     AS_FOR_TARGET='$(AS)'
11248     echo "$as_me:$LINENO: result: host tool" >&5
11249 echo "${ECHO_T}host tool" >&6
11250   else
11251     # We need a cross tool
11252     echo "$as_me:$LINENO: result: pre-installed" >&5
11253 echo "${ECHO_T}pre-installed" >&6
11254   fi
11255 fi
11256
11257 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11258 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11259 if test "x${build}" != "x${host}" ; then
11260   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11261     # We already found the complete path
11262     ac_dir=`dirname $CC_FOR_TARGET`
11263     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11264 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11265   else
11266     # Canadian cross, just use what we found
11267     echo "$as_me:$LINENO: result: pre-installed" >&5
11268 echo "${ECHO_T}pre-installed" >&6
11269   fi
11270 else
11271   ok=yes
11272   case " ${configdirs} " in
11273     *" gcc "*) ;;
11274     *) ok=no ;;
11275   esac
11276
11277   if test $ok = yes; then
11278     # An in-tree tool is available and we can use it
11279     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11280     echo "$as_me:$LINENO: result: just compiled" >&5
11281 echo "${ECHO_T}just compiled" >&6
11282   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11283     # We already found the complete path
11284     ac_dir=`dirname $CC_FOR_TARGET`
11285     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11286 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11287   elif test "x$target" = "x$host"; then
11288     # We can use an host tool
11289     CC_FOR_TARGET='$(CC)'
11290     echo "$as_me:$LINENO: result: host tool" >&5
11291 echo "${ECHO_T}host tool" >&6
11292   else
11293     # We need a cross tool
11294     echo "$as_me:$LINENO: result: pre-installed" >&5
11295 echo "${ECHO_T}pre-installed" >&6
11296   fi
11297 fi
11298
11299 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11300 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11301 if test "x${build}" != "x${host}" ; then
11302   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11303     # We already found the complete path
11304     ac_dir=`dirname $CXX_FOR_TARGET`
11305     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11306 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11307   else
11308     # Canadian cross, just use what we found
11309     echo "$as_me:$LINENO: result: pre-installed" >&5
11310 echo "${ECHO_T}pre-installed" >&6
11311   fi
11312 else
11313   ok=yes
11314   case " ${configdirs} " in
11315     *" gcc "*) ;;
11316     *) ok=no ;;
11317   esac
11318   case ,${enable_languages}, in
11319     *,c++,*) ;;
11320     *) ok=no ;;
11321   esac
11322   if test $ok = yes; then
11323     # An in-tree tool is available and we can use it
11324     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'
11325     echo "$as_me:$LINENO: result: just compiled" >&5
11326 echo "${ECHO_T}just compiled" >&6
11327   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11328     # We already found the complete path
11329     ac_dir=`dirname $CXX_FOR_TARGET`
11330     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11331 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11332   elif test "x$target" = "x$host"; then
11333     # We can use an host tool
11334     CXX_FOR_TARGET='$(CXX)'
11335     echo "$as_me:$LINENO: result: host tool" >&5
11336 echo "${ECHO_T}host tool" >&6
11337   else
11338     # We need a cross tool
11339     echo "$as_me:$LINENO: result: pre-installed" >&5
11340 echo "${ECHO_T}pre-installed" >&6
11341   fi
11342 fi
11343
11344 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11345 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11346 if test "x${build}" != "x${host}" ; then
11347   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11348     # We already found the complete path
11349     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11350     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11351 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11352   else
11353     # Canadian cross, just use what we found
11354     echo "$as_me:$LINENO: result: pre-installed" >&5
11355 echo "${ECHO_T}pre-installed" >&6
11356   fi
11357 else
11358   ok=yes
11359   case " ${configdirs} " in
11360     *" gcc "*) ;;
11361     *) ok=no ;;
11362   esac
11363   case ,${enable_languages}, in
11364     *,c++,*) ;;
11365     *) ok=no ;;
11366   esac
11367   if test $ok = yes; then
11368     # An in-tree tool is available and we can use it
11369     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'
11370     echo "$as_me:$LINENO: result: just compiled" >&5
11371 echo "${ECHO_T}just compiled" >&6
11372   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11373     # We already found the complete path
11374     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11375     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11376 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11377   elif test "x$target" = "x$host"; then
11378     # We can use an host tool
11379     RAW_CXX_FOR_TARGET='$(CXX)'
11380     echo "$as_me:$LINENO: result: host tool" >&5
11381 echo "${ECHO_T}host tool" >&6
11382   else
11383     # We need a cross tool
11384     echo "$as_me:$LINENO: result: pre-installed" >&5
11385 echo "${ECHO_T}pre-installed" >&6
11386   fi
11387 fi
11388
11389 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11390 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11391 if test "x${build}" != "x${host}" ; then
11392   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11393     # We already found the complete path
11394     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11395     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11396 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11397   else
11398     # Canadian cross, just use what we found
11399     echo "$as_me:$LINENO: result: pre-installed" >&5
11400 echo "${ECHO_T}pre-installed" >&6
11401   fi
11402 else
11403   ok=yes
11404   case " ${configdirs} " in
11405     *" binutils "*) ;;
11406     *) ok=no ;;
11407   esac
11408
11409   if test $ok = yes; then
11410     # An in-tree tool is available and we can use it
11411     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11412     echo "$as_me:$LINENO: result: just compiled" >&5
11413 echo "${ECHO_T}just compiled" >&6
11414   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11415     # We already found the complete path
11416     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11417     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11418 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11419   elif test "x$target" = "x$host"; then
11420     # We can use an host tool
11421     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11422     echo "$as_me:$LINENO: result: host tool" >&5
11423 echo "${ECHO_T}host tool" >&6
11424   else
11425     # We need a cross tool
11426     echo "$as_me:$LINENO: result: pre-installed" >&5
11427 echo "${ECHO_T}pre-installed" >&6
11428   fi
11429 fi
11430
11431 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11432 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11433 if test "x${build}" != "x${host}" ; then
11434   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11435     # We already found the complete path
11436     ac_dir=`dirname $GCC_FOR_TARGET`
11437     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11438 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11439   else
11440     # Canadian cross, just use what we found
11441     echo "$as_me:$LINENO: result: pre-installed" >&5
11442 echo "${ECHO_T}pre-installed" >&6
11443   fi
11444 else
11445   ok=yes
11446   case " ${configdirs} " in
11447     *" gcc "*) ;;
11448     *) ok=no ;;
11449   esac
11450
11451   if test $ok = yes; then
11452     # An in-tree tool is available and we can use it
11453     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11454     echo "$as_me:$LINENO: result: just compiled" >&5
11455 echo "${ECHO_T}just compiled" >&6
11456   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11457     # We already found the complete path
11458     ac_dir=`dirname $GCC_FOR_TARGET`
11459     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11460 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11461   elif test "x$target" = "x$host"; then
11462     # We can use an host tool
11463     GCC_FOR_TARGET='$()'
11464     echo "$as_me:$LINENO: result: host tool" >&5
11465 echo "${ECHO_T}host tool" >&6
11466   else
11467     # We need a cross tool
11468     echo "$as_me:$LINENO: result: pre-installed" >&5
11469 echo "${ECHO_T}pre-installed" >&6
11470   fi
11471 fi
11472
11473 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11474 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11475 if test "x${build}" != "x${host}" ; then
11476   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11477     # We already found the complete path
11478     ac_dir=`dirname $GCJ_FOR_TARGET`
11479     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11480 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11481   else
11482     # Canadian cross, just use what we found
11483     echo "$as_me:$LINENO: result: pre-installed" >&5
11484 echo "${ECHO_T}pre-installed" >&6
11485   fi
11486 else
11487   ok=yes
11488   case " ${configdirs} " in
11489     *" gcc "*) ;;
11490     *) ok=no ;;
11491   esac
11492   case ,${enable_languages}, in
11493     *,java,*) ;;
11494     *) ok=no ;;
11495   esac
11496   if test $ok = yes; then
11497     # An in-tree tool is available and we can use it
11498     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11499     echo "$as_me:$LINENO: result: just compiled" >&5
11500 echo "${ECHO_T}just compiled" >&6
11501   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11502     # We already found the complete path
11503     ac_dir=`dirname $GCJ_FOR_TARGET`
11504     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11505 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11506   elif test "x$target" = "x$host"; then
11507     # We can use an host tool
11508     GCJ_FOR_TARGET='$(GCJ)'
11509     echo "$as_me:$LINENO: result: host tool" >&5
11510 echo "${ECHO_T}host tool" >&6
11511   else
11512     # We need a cross tool
11513     echo "$as_me:$LINENO: result: pre-installed" >&5
11514 echo "${ECHO_T}pre-installed" >&6
11515   fi
11516 fi
11517
11518 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11519 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11520 if test "x${build}" != "x${host}" ; then
11521   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11522     # We already found the complete path
11523     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11524     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11525 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11526   else
11527     # Canadian cross, just use what we found
11528     echo "$as_me:$LINENO: result: pre-installed" >&5
11529 echo "${ECHO_T}pre-installed" >&6
11530   fi
11531 else
11532   ok=yes
11533   case " ${configdirs} " in
11534     *" gcc "*) ;;
11535     *) ok=no ;;
11536   esac
11537   case ,${enable_languages}, in
11538     *,fortran,*) ;;
11539     *) ok=no ;;
11540   esac
11541   if test $ok = yes; then
11542     # An in-tree tool is available and we can use it
11543     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11544     echo "$as_me:$LINENO: result: just compiled" >&5
11545 echo "${ECHO_T}just compiled" >&6
11546   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11547     # We already found the complete path
11548     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11549     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11550 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11551   elif test "x$target" = "x$host"; then
11552     # We can use an host tool
11553     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11554     echo "$as_me:$LINENO: result: host tool" >&5
11555 echo "${ECHO_T}host tool" >&6
11556   else
11557     # We need a cross tool
11558     echo "$as_me:$LINENO: result: pre-installed" >&5
11559 echo "${ECHO_T}pre-installed" >&6
11560   fi
11561 fi
11562
11563 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11564 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11565 if test "x${build}" != "x${host}" ; then
11566   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11567     # We already found the complete path
11568     ac_dir=`dirname $LD_FOR_TARGET`
11569     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11570 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11571   else
11572     # Canadian cross, just use what we found
11573     echo "$as_me:$LINENO: result: pre-installed" >&5
11574 echo "${ECHO_T}pre-installed" >&6
11575   fi
11576 else
11577   ok=yes
11578   case " ${configdirs} " in
11579     *" ld "*) ;;
11580     *) ok=no ;;
11581   esac
11582
11583   if test $ok = yes; then
11584     # An in-tree tool is available and we can use it
11585     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11586     echo "$as_me:$LINENO: result: just compiled" >&5
11587 echo "${ECHO_T}just compiled" >&6
11588   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11589     # We already found the complete path
11590     ac_dir=`dirname $LD_FOR_TARGET`
11591     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11592 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11593   elif test "x$target" = "x$host"; then
11594     # We can use an host tool
11595     LD_FOR_TARGET='$(LD)'
11596     echo "$as_me:$LINENO: result: host tool" >&5
11597 echo "${ECHO_T}host tool" >&6
11598   else
11599     # We need a cross tool
11600     echo "$as_me:$LINENO: result: pre-installed" >&5
11601 echo "${ECHO_T}pre-installed" >&6
11602   fi
11603 fi
11604
11605 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11606 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11607 if test "x${build}" != "x${host}" ; then
11608   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11609     # We already found the complete path
11610     ac_dir=`dirname $LIPO_FOR_TARGET`
11611     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11612 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11613   else
11614     # Canadian cross, just use what we found
11615     echo "$as_me:$LINENO: result: pre-installed" >&5
11616 echo "${ECHO_T}pre-installed" >&6
11617   fi
11618 else
11619   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11620     # We already found the complete path
11621     ac_dir=`dirname $LIPO_FOR_TARGET`
11622     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11623 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11624   elif test "x$target" = "x$host"; then
11625     # We can use an host tool
11626     LIPO_FOR_TARGET='$(LIPO)'
11627     echo "$as_me:$LINENO: result: host tool" >&5
11628 echo "${ECHO_T}host tool" >&6
11629   else
11630     # We need a cross tool
11631     echo "$as_me:$LINENO: result: pre-installed" >&5
11632 echo "${ECHO_T}pre-installed" >&6
11633   fi
11634 fi
11635
11636 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11637 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11638 if test "x${build}" != "x${host}" ; then
11639   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11640     # We already found the complete path
11641     ac_dir=`dirname $NM_FOR_TARGET`
11642     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11643 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11644   else
11645     # Canadian cross, just use what we found
11646     echo "$as_me:$LINENO: result: pre-installed" >&5
11647 echo "${ECHO_T}pre-installed" >&6
11648   fi
11649 else
11650   ok=yes
11651   case " ${configdirs} " in
11652     *" binutils "*) ;;
11653     *) ok=no ;;
11654   esac
11655
11656   if test $ok = yes; then
11657     # An in-tree tool is available and we can use it
11658     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11659     echo "$as_me:$LINENO: result: just compiled" >&5
11660 echo "${ECHO_T}just compiled" >&6
11661   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11662     # We already found the complete path
11663     ac_dir=`dirname $NM_FOR_TARGET`
11664     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11665 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11666   elif test "x$target" = "x$host"; then
11667     # We can use an host tool
11668     NM_FOR_TARGET='$(NM)'
11669     echo "$as_me:$LINENO: result: host tool" >&5
11670 echo "${ECHO_T}host tool" >&6
11671   else
11672     # We need a cross tool
11673     echo "$as_me:$LINENO: result: pre-installed" >&5
11674 echo "${ECHO_T}pre-installed" >&6
11675   fi
11676 fi
11677
11678 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11679 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11680 if test "x${build}" != "x${host}" ; then
11681   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11682     # We already found the complete path
11683     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11684     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11685 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11686   else
11687     # Canadian cross, just use what we found
11688     echo "$as_me:$LINENO: result: pre-installed" >&5
11689 echo "${ECHO_T}pre-installed" >&6
11690   fi
11691 else
11692   ok=yes
11693   case " ${configdirs} " in
11694     *" binutils "*) ;;
11695     *) ok=no ;;
11696   esac
11697
11698   if test $ok = yes; then
11699     # An in-tree tool is available and we can use it
11700     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11701     echo "$as_me:$LINENO: result: just compiled" >&5
11702 echo "${ECHO_T}just compiled" >&6
11703   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11704     # We already found the complete path
11705     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11706     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11707 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11708   elif test "x$target" = "x$host"; then
11709     # We can use an host tool
11710     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11711     echo "$as_me:$LINENO: result: host tool" >&5
11712 echo "${ECHO_T}host tool" >&6
11713   else
11714     # We need a cross tool
11715     echo "$as_me:$LINENO: result: pre-installed" >&5
11716 echo "${ECHO_T}pre-installed" >&6
11717   fi
11718 fi
11719
11720 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11721 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11722 if test "x${build}" != "x${host}" ; then
11723   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11724     # We already found the complete path
11725     ac_dir=`dirname $RANLIB_FOR_TARGET`
11726     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11727 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11728   else
11729     # Canadian cross, just use what we found
11730     echo "$as_me:$LINENO: result: pre-installed" >&5
11731 echo "${ECHO_T}pre-installed" >&6
11732   fi
11733 else
11734   ok=yes
11735   case " ${configdirs} " in
11736     *" binutils "*) ;;
11737     *) ok=no ;;
11738   esac
11739
11740   if test $ok = yes; then
11741     # An in-tree tool is available and we can use it
11742     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11743     echo "$as_me:$LINENO: result: just compiled" >&5
11744 echo "${ECHO_T}just compiled" >&6
11745   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11746     # We already found the complete path
11747     ac_dir=`dirname $RANLIB_FOR_TARGET`
11748     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11749 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11750   elif test "x$target" = "x$host"; then
11751     # We can use an host tool
11752     RANLIB_FOR_TARGET='$(RANLIB)'
11753     echo "$as_me:$LINENO: result: host tool" >&5
11754 echo "${ECHO_T}host tool" >&6
11755   else
11756     # We need a cross tool
11757     echo "$as_me:$LINENO: result: pre-installed" >&5
11758 echo "${ECHO_T}pre-installed" >&6
11759   fi
11760 fi
11761
11762 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11763 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11764 if test "x${build}" != "x${host}" ; then
11765   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11766     # We already found the complete path
11767     ac_dir=`dirname $STRIP_FOR_TARGET`
11768     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11769 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11770   else
11771     # Canadian cross, just use what we found
11772     echo "$as_me:$LINENO: result: pre-installed" >&5
11773 echo "${ECHO_T}pre-installed" >&6
11774   fi
11775 else
11776   ok=yes
11777   case " ${configdirs} " in
11778     *" binutils "*) ;;
11779     *) ok=no ;;
11780   esac
11781
11782   if test $ok = yes; then
11783     # An in-tree tool is available and we can use it
11784     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11785     echo "$as_me:$LINENO: result: just compiled" >&5
11786 echo "${ECHO_T}just compiled" >&6
11787   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11788     # We already found the complete path
11789     ac_dir=`dirname $STRIP_FOR_TARGET`
11790     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11791 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11792   elif test "x$target" = "x$host"; then
11793     # We can use an host tool
11794     STRIP_FOR_TARGET='$(STRIP)'
11795     echo "$as_me:$LINENO: result: host tool" >&5
11796 echo "${ECHO_T}host tool" >&6
11797   else
11798     # We need a cross tool
11799     echo "$as_me:$LINENO: result: pre-installed" >&5
11800 echo "${ECHO_T}pre-installed" >&6
11801   fi
11802 fi
11803
11804 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11805 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11806 if test "x${build}" != "x${host}" ; then
11807   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11808     # We already found the complete path
11809     ac_dir=`dirname $WINDRES_FOR_TARGET`
11810     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11811 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11812   else
11813     # Canadian cross, just use what we found
11814     echo "$as_me:$LINENO: result: pre-installed" >&5
11815 echo "${ECHO_T}pre-installed" >&6
11816   fi
11817 else
11818   ok=yes
11819   case " ${configdirs} " in
11820     *" binutils "*) ;;
11821     *) ok=no ;;
11822   esac
11823
11824   if test $ok = yes; then
11825     # An in-tree tool is available and we can use it
11826     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11827     echo "$as_me:$LINENO: result: just compiled" >&5
11828 echo "${ECHO_T}just compiled" >&6
11829   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11830     # We already found the complete path
11831     ac_dir=`dirname $WINDRES_FOR_TARGET`
11832     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11833 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11834   elif test "x$target" = "x$host"; then
11835     # We can use an host tool
11836     WINDRES_FOR_TARGET='$(WINDRES)'
11837     echo "$as_me:$LINENO: result: host tool" >&5
11838 echo "${ECHO_T}host tool" >&6
11839   else
11840     # We need a cross tool
11841     echo "$as_me:$LINENO: result: pre-installed" >&5
11842 echo "${ECHO_T}pre-installed" >&6
11843   fi
11844 fi
11845
11846 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
11847 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
11848 if test "x${build}" != "x${host}" ; then
11849   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11850     # We already found the complete path
11851     ac_dir=`dirname $WINDMC_FOR_TARGET`
11852     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11853 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11854   else
11855     # Canadian cross, just use what we found
11856     echo "$as_me:$LINENO: result: pre-installed" >&5
11857 echo "${ECHO_T}pre-installed" >&6
11858   fi
11859 else
11860   ok=yes
11861   case " ${configdirs} " in
11862     *" binutils "*) ;;
11863     *) ok=no ;;
11864   esac
11865
11866   if test $ok = yes; then
11867     # An in-tree tool is available and we can use it
11868     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
11869     echo "$as_me:$LINENO: result: just compiled" >&5
11870 echo "${ECHO_T}just compiled" >&6
11871   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11872     # We already found the complete path
11873     ac_dir=`dirname $WINDMC_FOR_TARGET`
11874     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11875 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11876   elif test "x$target" = "x$host"; then
11877     # We can use an host tool
11878     WINDMC_FOR_TARGET='$(WINDMC)'
11879     echo "$as_me:$LINENO: result: host tool" >&5
11880 echo "${ECHO_T}host tool" >&6
11881   else
11882     # We need a cross tool
11883     echo "$as_me:$LINENO: result: pre-installed" >&5
11884 echo "${ECHO_T}pre-installed" >&6
11885   fi
11886 fi
11887
11888
11889
11890
11891
11892 # Certain tools may need extra flags.
11893 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11894 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11895 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11896
11897 # When building target libraries, except in a Canadian cross, we use
11898 # the same toolchain as the compiler we just built.
11899 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11900 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11901 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11902 if test $host = $build; then
11903   case " $configdirs " in
11904     *" gcc "*)
11905       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11906       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11907       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11908       ;;
11909   esac
11910 fi
11911
11912
11913
11914
11915
11916 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
11917 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
11918 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
11919 if test "${enable_maintainer_mode+set}" = set; then
11920   enableval="$enable_maintainer_mode"
11921   USE_MAINTAINER_MODE=$enableval
11922 else
11923   USE_MAINTAINER_MODE=no
11924 fi;
11925 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
11926 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
11927
11928
11929 if test "$USE_MAINTAINER_MODE" = yes; then
11930   MAINTAINER_MODE_TRUE=
11931   MAINTAINER_MODE_FALSE='#'
11932 else
11933   MAINTAINER_MODE_TRUE='#'
11934   MAINTAINER_MODE_FALSE=
11935 fi
11936 MAINT=$MAINTAINER_MODE_TRUE
11937
11938 # ---------------------
11939 # GCC bootstrap support
11940 # ---------------------
11941
11942 # Stage specific cflags for build.
11943 stage1_cflags="-g"
11944 case $build in
11945   vax-*-*)
11946     case ${GCC} in
11947       yes) stage1_cflags="-g -Wa,-J" ;;
11948       *) stage1_cflags="-g -J" ;;
11949     esac ;;
11950 esac
11951
11952 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
11953 if test "$GCC" = yes; then
11954   saved_CFLAGS="$CFLAGS"
11955
11956   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
11957   CFLAGS="$CFLAGS -fkeep-inline-functions"
11958   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
11959 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
11960   cat >conftest.$ac_ext <<_ACEOF
11961 /* confdefs.h.  */
11962 _ACEOF
11963 cat confdefs.h >>conftest.$ac_ext
11964 cat >>conftest.$ac_ext <<_ACEOF
11965 /* end confdefs.h.  */
11966
11967 #if (__GNUC__ < 3) \
11968     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
11969                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
11970 #error http://gcc.gnu.org/PR29382
11971 #endif
11972
11973 int
11974 main ()
11975 {
11976
11977   ;
11978   return 0;
11979 }
11980 _ACEOF
11981 rm -f conftest.$ac_objext
11982 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11983   (eval $ac_compile) 2>conftest.er1
11984   ac_status=$?
11985   grep -v '^ *+' conftest.er1 >conftest.err
11986   rm -f conftest.er1
11987   cat conftest.err >&5
11988   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11989   (exit $ac_status); } &&
11990          { ac_try='test -z "$ac_c_werror_flag"
11991                          || test ! -s conftest.err'
11992   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11993   (eval $ac_try) 2>&5
11994   ac_status=$?
11995   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11996   (exit $ac_status); }; } &&
11997          { ac_try='test -s conftest.$ac_objext'
11998   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11999   (eval $ac_try) 2>&5
12000   ac_status=$?
12001   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12002   (exit $ac_status); }; }; then
12003   echo "$as_me:$LINENO: result: yes" >&5
12004 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12005 else
12006   echo "$as_me: failed program was:" >&5
12007 sed 's/^/| /' conftest.$ac_ext >&5
12008
12009 echo "$as_me:$LINENO: result: no" >&5
12010 echo "${ECHO_T}no" >&6
12011 fi
12012 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12013
12014   CFLAGS="$saved_CFLAGS"
12015 fi
12016
12017
12018
12019 # Enable --enable-checking in stage1 of the compiler.
12020 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12021 if test "${enable_stage1_checking+set}" = set; then
12022   enableval="$enable_stage1_checking"
12023   stage1_checking=--enable-checking=${enable_stage1_checking}
12024 else
12025   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12026   stage1_checking=--enable-checking=yes,types
12027 else
12028   stage1_checking=--enable-checking=$enable_checking,types
12029 fi
12030 fi;
12031
12032
12033 # Enable -Werror in bootstrap stage2 and later.
12034 # Check whether --enable-werror or --disable-werror was given.
12035 if test "${enable_werror+set}" = set; then
12036   enableval="$enable_werror"
12037
12038 else
12039   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12040   enable_werror=yes
12041 else
12042   enable_werror=no
12043 fi
12044 fi;
12045 case ${enable_werror} in
12046   yes) stage2_werror_flag="--enable-werror-always" ;;
12047   *) stage2_werror_flag="" ;;
12048 esac
12049
12050
12051 # Flags needed to enable html installing and building
12052
12053 # Check whether --with-datarootdir or --without-datarootdir was given.
12054 if test "${with_datarootdir+set}" = set; then
12055   withval="$with_datarootdir"
12056   datarootdir="\${prefix}/${withval}"
12057 else
12058   datarootdir="\${prefix}/share"
12059 fi;
12060
12061
12062 # Check whether --with-docdir or --without-docdir was given.
12063 if test "${with_docdir+set}" = set; then
12064   withval="$with_docdir"
12065   docdir="\${prefix}/${withval}"
12066 else
12067   docdir="\${datarootdir}/doc"
12068 fi;
12069
12070
12071 # Check whether --with-pdfdir or --without-pdfdir was given.
12072 if test "${with_pdfdir+set}" = set; then
12073   withval="$with_pdfdir"
12074   pdfdir="\${prefix}/${withval}"
12075 else
12076   pdfdir="\${docdir}"
12077 fi;
12078
12079
12080 # Check whether --with-htmldir or --without-htmldir was given.
12081 if test "${with_htmldir+set}" = set; then
12082   withval="$with_htmldir"
12083   htmldir="\${prefix}/${withval}"
12084 else
12085   htmldir="\${docdir}"
12086 fi;
12087
12088
12089
12090
12091
12092
12093           ac_config_files="$ac_config_files Makefile"
12094 cat >confcache <<\_ACEOF
12095 # This file is a shell script that caches the results of configure
12096 # tests run on this system so they can be shared between configure
12097 # scripts and configure runs, see configure's option --config-cache.
12098 # It is not useful on other systems.  If it contains results you don't
12099 # want to keep, you may remove or edit it.
12100 #
12101 # config.status only pays attention to the cache file if you give it
12102 # the --recheck option to rerun configure.
12103 #
12104 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12105 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12106 # following values.
12107
12108 _ACEOF
12109
12110 # The following way of writing the cache mishandles newlines in values,
12111 # but we know of no workaround that is simple, portable, and efficient.
12112 # So, don't put newlines in cache variables' values.
12113 # Ultrix sh set writes to stderr and can't be redirected directly,
12114 # and sets the high bit in the cache file unless we assign to the vars.
12115 {
12116   (set) 2>&1 |
12117     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12118     *ac_space=\ *)
12119       # `set' does not quote correctly, so add quotes (double-quote
12120       # substitution turns \\\\ into \\, and sed turns \\ into \).
12121       sed -n \
12122         "s/'/'\\\\''/g;
12123           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12124       ;;
12125     *)
12126       # `set' quotes correctly as required by POSIX, so do not add quotes.
12127       sed -n \
12128         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12129       ;;
12130     esac;
12131 } |
12132   sed '
12133      t clear
12134      : clear
12135      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12136      t end
12137      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12138      : end' >>confcache
12139 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12140   if test -w $cache_file; then
12141     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12142     cat confcache >$cache_file
12143   else
12144     echo "not updating unwritable cache $cache_file"
12145   fi
12146 fi
12147 rm -f confcache
12148
12149 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12150 # Let make expand exec_prefix.
12151 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12152
12153 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12154 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12155 # trailing colons and then remove the whole line if VPATH becomes empty
12156 # (actually we leave an empty line to preserve line numbers).
12157 if test "x$srcdir" = x.; then
12158   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12159 s/:*\$(srcdir):*/:/;
12160 s/:*\${srcdir}:*/:/;
12161 s/:*@srcdir@:*/:/;
12162 s/^\([^=]*=[     ]*\):*/\1/;
12163 s/:*$//;
12164 s/^[^=]*=[       ]*$//;
12165 }'
12166 fi
12167
12168 # Transform confdefs.h into DEFS.
12169 # Protect against shell expansion while executing Makefile rules.
12170 # Protect against Makefile macro expansion.
12171 #
12172 # If the first sed substitution is executed (which looks for macros that
12173 # take arguments), then we branch to the quote section.  Otherwise,
12174 # look for a macro that doesn't take arguments.
12175 cat >confdef2opt.sed <<\_ACEOF
12176 t clear
12177 : clear
12178 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12179 t quote
12180 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12181 t quote
12182 d
12183 : quote
12184 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12185 s,\[,\\&,g
12186 s,\],\\&,g
12187 s,\$,$$,g
12188 p
12189 _ACEOF
12190 # We use echo to avoid assuming a particular line-breaking character.
12191 # The extra dot is to prevent the shell from consuming trailing
12192 # line-breaks from the sub-command output.  A line-break within
12193 # single-quotes doesn't work because, if this script is created in a
12194 # platform that uses two characters for line-breaks (e.g., DOS), tr
12195 # would break.
12196 ac_LF_and_DOT=`echo; echo .`
12197 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12198 rm -f confdef2opt.sed
12199
12200
12201 ac_libobjs=
12202 ac_ltlibobjs=
12203 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12204   # 1. Remove the extension, and $U if already installed.
12205   ac_i=`echo "$ac_i" |
12206          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12207   # 2. Add them.
12208   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12209   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12210 done
12211 LIBOBJS=$ac_libobjs
12212
12213 LTLIBOBJS=$ac_ltlibobjs
12214
12215
12216
12217 : ${CONFIG_STATUS=./config.status}
12218 ac_clean_files_save=$ac_clean_files
12219 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12220 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12221 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12222 cat >$CONFIG_STATUS <<_ACEOF
12223 #! $SHELL
12224 # Generated by $as_me.
12225 # Run this file to recreate the current configuration.
12226 # Compiler output produced by configure, useful for debugging
12227 # configure, is in config.log if it exists.
12228
12229 debug=false
12230 ac_cs_recheck=false
12231 ac_cs_silent=false
12232 SHELL=\${CONFIG_SHELL-$SHELL}
12233 _ACEOF
12234
12235 cat >>$CONFIG_STATUS <<\_ACEOF
12236 ## --------------------- ##
12237 ## M4sh Initialization.  ##
12238 ## --------------------- ##
12239
12240 # Be Bourne compatible
12241 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12242   emulate sh
12243   NULLCMD=:
12244   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12245   # is contrary to our usage.  Disable this feature.
12246   alias -g '${1+"$@"}'='"$@"'
12247 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12248   set -o posix
12249 fi
12250 DUALCASE=1; export DUALCASE # for MKS sh
12251
12252 # Support unset when possible.
12253 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12254   as_unset=unset
12255 else
12256   as_unset=false
12257 fi
12258
12259
12260 # Work around bugs in pre-3.0 UWIN ksh.
12261 $as_unset ENV MAIL MAILPATH
12262 PS1='$ '
12263 PS2='> '
12264 PS4='+ '
12265
12266 # NLS nuisances.
12267 for as_var in \
12268   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12269   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12270   LC_TELEPHONE LC_TIME
12271 do
12272   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12273     eval $as_var=C; export $as_var
12274   else
12275     $as_unset $as_var
12276   fi
12277 done
12278
12279 # Required to use basename.
12280 if expr a : '\(a\)' >/dev/null 2>&1; then
12281   as_expr=expr
12282 else
12283   as_expr=false
12284 fi
12285
12286 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12287   as_basename=basename
12288 else
12289   as_basename=false
12290 fi
12291
12292
12293 # Name of the executable.
12294 as_me=`$as_basename "$0" ||
12295 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12296          X"$0" : 'X\(//\)$' \| \
12297          X"$0" : 'X\(/\)$' \| \
12298          .     : '\(.\)' 2>/dev/null ||
12299 echo X/"$0" |
12300     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12301           /^X\/\(\/\/\)$/{ s//\1/; q; }
12302           /^X\/\(\/\).*/{ s//\1/; q; }
12303           s/.*/./; q'`
12304
12305
12306 # PATH needs CR, and LINENO needs CR and PATH.
12307 # Avoid depending upon Character Ranges.
12308 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12309 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12310 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12311 as_cr_digits='0123456789'
12312 as_cr_alnum=$as_cr_Letters$as_cr_digits
12313
12314 # The user is always right.
12315 if test "${PATH_SEPARATOR+set}" != set; then
12316   echo "#! /bin/sh" >conf$$.sh
12317   echo  "exit 0"   >>conf$$.sh
12318   chmod +x conf$$.sh
12319   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12320     PATH_SEPARATOR=';'
12321   else
12322     PATH_SEPARATOR=:
12323   fi
12324   rm -f conf$$.sh
12325 fi
12326
12327
12328   as_lineno_1=$LINENO
12329   as_lineno_2=$LINENO
12330   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12331   test "x$as_lineno_1" != "x$as_lineno_2" &&
12332   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12333   # Find who we are.  Look in the path if we contain no path at all
12334   # relative or not.
12335   case $0 in
12336     *[\\/]* ) as_myself=$0 ;;
12337     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12338 for as_dir in $PATH
12339 do
12340   IFS=$as_save_IFS
12341   test -z "$as_dir" && as_dir=.
12342   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12343 done
12344
12345        ;;
12346   esac
12347   # We did not find ourselves, most probably we were run as `sh COMMAND'
12348   # in which case we are not to be found in the path.
12349   if test "x$as_myself" = x; then
12350     as_myself=$0
12351   fi
12352   if test ! -f "$as_myself"; then
12353     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12354 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12355    { (exit 1); exit 1; }; }
12356   fi
12357   case $CONFIG_SHELL in
12358   '')
12359     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12360 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12361 do
12362   IFS=$as_save_IFS
12363   test -z "$as_dir" && as_dir=.
12364   for as_base in sh bash ksh sh5; do
12365          case $as_dir in
12366          /*)
12367            if ("$as_dir/$as_base" -c '
12368   as_lineno_1=$LINENO
12369   as_lineno_2=$LINENO
12370   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12371   test "x$as_lineno_1" != "x$as_lineno_2" &&
12372   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12373              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12374              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12375              CONFIG_SHELL=$as_dir/$as_base
12376              export CONFIG_SHELL
12377              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12378            fi;;
12379          esac
12380        done
12381 done
12382 ;;
12383   esac
12384
12385   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12386   # uniformly replaced by the line number.  The first 'sed' inserts a
12387   # line-number line before each line; the second 'sed' does the real
12388   # work.  The second script uses 'N' to pair each line-number line
12389   # with the numbered line, and appends trailing '-' during
12390   # substitution so that $LINENO is not a special case at line end.
12391   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12392   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12393   sed '=' <$as_myself |
12394     sed '
12395       N
12396       s,$,-,
12397       : loop
12398       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12399       t loop
12400       s,-$,,
12401       s,^['$as_cr_digits']*\n,,
12402     ' >$as_me.lineno &&
12403   chmod +x $as_me.lineno ||
12404     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12405 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12406    { (exit 1); exit 1; }; }
12407
12408   # Don't try to exec as it changes $[0], causing all sort of problems
12409   # (the dirname of $[0] is not the place where we might find the
12410   # original and so on.  Autoconf is especially sensible to this).
12411   . ./$as_me.lineno
12412   # Exit status is that of the last command.
12413   exit
12414 }
12415
12416
12417 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12418   *c*,-n*) ECHO_N= ECHO_C='
12419 ' ECHO_T='      ' ;;
12420   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12421   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12422 esac
12423
12424 if expr a : '\(a\)' >/dev/null 2>&1; then
12425   as_expr=expr
12426 else
12427   as_expr=false
12428 fi
12429
12430 rm -f conf$$ conf$$.exe conf$$.file
12431 echo >conf$$.file
12432 if ln -s conf$$.file conf$$ 2>/dev/null; then
12433   # We could just check for DJGPP; but this test a) works b) is more generic
12434   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12435   if test -f conf$$.exe; then
12436     # Don't use ln at all; we don't have any links
12437     as_ln_s='cp -p'
12438   else
12439     as_ln_s='ln -s'
12440   fi
12441 elif ln conf$$.file conf$$ 2>/dev/null; then
12442   as_ln_s=ln
12443 else
12444   as_ln_s='cp -p'
12445 fi
12446 rm -f conf$$ conf$$.exe conf$$.file
12447
12448 if mkdir -p . 2>/dev/null; then
12449   as_mkdir_p=:
12450 else
12451   test -d ./-p && rmdir ./-p
12452   as_mkdir_p=false
12453 fi
12454
12455 as_executable_p="test -f"
12456
12457 # Sed expression to map a string onto a valid CPP name.
12458 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12459
12460 # Sed expression to map a string onto a valid variable name.
12461 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12462
12463
12464 # IFS
12465 # We need space, tab and new line, in precisely that order.
12466 as_nl='
12467 '
12468 IFS="   $as_nl"
12469
12470 # CDPATH.
12471 $as_unset CDPATH
12472
12473 exec 6>&1
12474
12475 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12476 # report actual input values of CONFIG_FILES etc. instead of their
12477 # values after options handling.  Logging --version etc. is OK.
12478 exec 5>>config.log
12479 {
12480   echo
12481   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12482 ## Running $as_me. ##
12483 _ASBOX
12484 } >&5
12485 cat >&5 <<_CSEOF
12486
12487 This file was extended by $as_me, which was
12488 generated by GNU Autoconf 2.59.  Invocation command line was
12489
12490   CONFIG_FILES    = $CONFIG_FILES
12491   CONFIG_HEADERS  = $CONFIG_HEADERS
12492   CONFIG_LINKS    = $CONFIG_LINKS
12493   CONFIG_COMMANDS = $CONFIG_COMMANDS
12494   $ $0 $@
12495
12496 _CSEOF
12497 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12498 echo >&5
12499 _ACEOF
12500
12501 # Files that config.status was made for.
12502 if test -n "$ac_config_files"; then
12503   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12504 fi
12505
12506 if test -n "$ac_config_headers"; then
12507   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12508 fi
12509
12510 if test -n "$ac_config_links"; then
12511   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12512 fi
12513
12514 if test -n "$ac_config_commands"; then
12515   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12516 fi
12517
12518 cat >>$CONFIG_STATUS <<\_ACEOF
12519
12520 ac_cs_usage="\
12521 \`$as_me' instantiates files from templates according to the
12522 current configuration.
12523
12524 Usage: $0 [OPTIONS] [FILE]...
12525
12526   -h, --help       print this help, then exit
12527   -V, --version    print version number, then exit
12528   -q, --quiet      do not print progress messages
12529   -d, --debug      don't remove temporary files
12530       --recheck    update $as_me by reconfiguring in the same conditions
12531   --file=FILE[:TEMPLATE]
12532                    instantiate the configuration file FILE
12533
12534 Configuration files:
12535 $config_files
12536
12537 Report bugs to <bug-autoconf@gnu.org>."
12538 _ACEOF
12539
12540 cat >>$CONFIG_STATUS <<_ACEOF
12541 ac_cs_version="\\
12542 config.status
12543 configured by $0, generated by GNU Autoconf 2.59,
12544   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12545
12546 Copyright (C) 2003 Free Software Foundation, Inc.
12547 This config.status script is free software; the Free Software Foundation
12548 gives unlimited permission to copy, distribute and modify it."
12549 srcdir=$srcdir
12550 INSTALL="$INSTALL"
12551 _ACEOF
12552
12553 cat >>$CONFIG_STATUS <<\_ACEOF
12554 # If no file are specified by the user, then we need to provide default
12555 # value.  By we need to know if files were specified by the user.
12556 ac_need_defaults=:
12557 while test $# != 0
12558 do
12559   case $1 in
12560   --*=*)
12561     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12562     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12563     ac_shift=:
12564     ;;
12565   -*)
12566     ac_option=$1
12567     ac_optarg=$2
12568     ac_shift=shift
12569     ;;
12570   *) # This is not an option, so the user has probably given explicit
12571      # arguments.
12572      ac_option=$1
12573      ac_need_defaults=false;;
12574   esac
12575
12576   case $ac_option in
12577   # Handling of the options.
12578 _ACEOF
12579 cat >>$CONFIG_STATUS <<\_ACEOF
12580   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12581     ac_cs_recheck=: ;;
12582   --version | --vers* | -V )
12583     echo "$ac_cs_version"; exit 0 ;;
12584   --he | --h)
12585     # Conflict between --help and --header
12586     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12587 Try \`$0 --help' for more information." >&5
12588 echo "$as_me: error: ambiguous option: $1
12589 Try \`$0 --help' for more information." >&2;}
12590    { (exit 1); exit 1; }; };;
12591   --help | --hel | -h )
12592     echo "$ac_cs_usage"; exit 0 ;;
12593   --debug | --d* | -d )
12594     debug=: ;;
12595   --file | --fil | --fi | --f )
12596     $ac_shift
12597     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12598     ac_need_defaults=false;;
12599   --header | --heade | --head | --hea )
12600     $ac_shift
12601     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12602     ac_need_defaults=false;;
12603   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12604   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12605     ac_cs_silent=: ;;
12606
12607   # This is an error.
12608   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12609 Try \`$0 --help' for more information." >&5
12610 echo "$as_me: error: unrecognized option: $1
12611 Try \`$0 --help' for more information." >&2;}
12612    { (exit 1); exit 1; }; } ;;
12613
12614   *) ac_config_targets="$ac_config_targets $1" ;;
12615
12616   esac
12617   shift
12618 done
12619
12620 ac_configure_extra_args=
12621
12622 if $ac_cs_silent; then
12623   exec 6>/dev/null
12624   ac_configure_extra_args="$ac_configure_extra_args --silent"
12625 fi
12626
12627 _ACEOF
12628 cat >>$CONFIG_STATUS <<_ACEOF
12629 if \$ac_cs_recheck; then
12630   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12631   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12632 fi
12633
12634 _ACEOF
12635
12636
12637
12638
12639
12640 cat >>$CONFIG_STATUS <<\_ACEOF
12641 for ac_config_target in $ac_config_targets
12642 do
12643   case "$ac_config_target" in
12644   # Handling of arguments.
12645   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12646   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12647 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12648    { (exit 1); exit 1; }; };;
12649   esac
12650 done
12651
12652 # If the user did not use the arguments to specify the items to instantiate,
12653 # then the envvar interface is used.  Set only those that are not.
12654 # We use the long form for the default assignment because of an extremely
12655 # bizarre bug on SunOS 4.1.3.
12656 if $ac_need_defaults; then
12657   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12658 fi
12659
12660 # Have a temporary directory for convenience.  Make it in the build tree
12661 # simply because there is no reason to put it here, and in addition,
12662 # creating and moving files from /tmp can sometimes cause problems.
12663 # Create a temporary directory, and hook for its removal unless debugging.
12664 $debug ||
12665 {
12666   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12667   trap '{ (exit 1); exit 1; }' 1 2 13 15
12668 }
12669
12670 # Create a (secure) tmp directory for tmp files.
12671
12672 {
12673   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12674   test -n "$tmp" && test -d "$tmp"
12675 }  ||
12676 {
12677   tmp=./confstat$$-$RANDOM
12678   (umask 077 && mkdir $tmp)
12679 } ||
12680 {
12681    echo "$me: cannot create a temporary directory in ." >&2
12682    { (exit 1); exit 1; }
12683 }
12684
12685 _ACEOF
12686
12687 cat >>$CONFIG_STATUS <<_ACEOF
12688
12689 #
12690 # CONFIG_FILES section.
12691 #
12692
12693 # No need to generate the scripts if there are no CONFIG_FILES.
12694 # This happens for instance when ./config.status config.h
12695 if test -n "\$CONFIG_FILES"; then
12696   # Protect against being on the right side of a sed subst in config.status.
12697   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12698    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12699 s,@SHELL@,$SHELL,;t t
12700 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12701 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12702 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12703 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12704 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12705 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12706 s,@exec_prefix@,$exec_prefix,;t t
12707 s,@prefix@,$prefix,;t t
12708 s,@program_transform_name@,$program_transform_name,;t t
12709 s,@bindir@,$bindir,;t t
12710 s,@sbindir@,$sbindir,;t t
12711 s,@libexecdir@,$libexecdir,;t t
12712 s,@datadir@,$datadir,;t t
12713 s,@sysconfdir@,$sysconfdir,;t t
12714 s,@sharedstatedir@,$sharedstatedir,;t t
12715 s,@localstatedir@,$localstatedir,;t t
12716 s,@libdir@,$libdir,;t t
12717 s,@includedir@,$includedir,;t t
12718 s,@oldincludedir@,$oldincludedir,;t t
12719 s,@infodir@,$infodir,;t t
12720 s,@mandir@,$mandir,;t t
12721 s,@build_alias@,$build_alias,;t t
12722 s,@host_alias@,$host_alias,;t t
12723 s,@target_alias@,$target_alias,;t t
12724 s,@DEFS@,$DEFS,;t t
12725 s,@ECHO_C@,$ECHO_C,;t t
12726 s,@ECHO_N@,$ECHO_N,;t t
12727 s,@ECHO_T@,$ECHO_T,;t t
12728 s,@LIBS@,$LIBS,;t t
12729 s,@build@,$build,;t t
12730 s,@build_cpu@,$build_cpu,;t t
12731 s,@build_vendor@,$build_vendor,;t t
12732 s,@build_os@,$build_os,;t t
12733 s,@build_noncanonical@,$build_noncanonical,;t t
12734 s,@host_noncanonical@,$host_noncanonical,;t t
12735 s,@target_noncanonical@,$target_noncanonical,;t t
12736 s,@host@,$host,;t t
12737 s,@host_cpu@,$host_cpu,;t t
12738 s,@host_vendor@,$host_vendor,;t t
12739 s,@host_os@,$host_os,;t t
12740 s,@target@,$target,;t t
12741 s,@target_cpu@,$target_cpu,;t t
12742 s,@target_vendor@,$target_vendor,;t t
12743 s,@target_os@,$target_os,;t t
12744 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12745 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12746 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12747 s,@LN@,$LN,;t t
12748 s,@LN_S@,$LN_S,;t t
12749 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12750 s,@build_libsubdir@,$build_libsubdir,;t t
12751 s,@build_subdir@,$build_subdir,;t t
12752 s,@host_subdir@,$host_subdir,;t t
12753 s,@target_subdir@,$target_subdir,;t t
12754 s,@CC@,$CC,;t t
12755 s,@CFLAGS@,$CFLAGS,;t t
12756 s,@LDFLAGS@,$LDFLAGS,;t t
12757 s,@CPPFLAGS@,$CPPFLAGS,;t t
12758 s,@ac_ct_CC@,$ac_ct_CC,;t t
12759 s,@EXEEXT@,$EXEEXT,;t t
12760 s,@OBJEXT@,$OBJEXT,;t t
12761 s,@CXX@,$CXX,;t t
12762 s,@CXXFLAGS@,$CXXFLAGS,;t t
12763 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12764 s,@GNATBIND@,$GNATBIND,;t t
12765 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12766 s,@GNATMAKE@,$GNATMAKE,;t t
12767 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12768 s,@do_compare@,$do_compare,;t t
12769 s,@gmplibs@,$gmplibs,;t t
12770 s,@gmpinc@,$gmpinc,;t t
12771 s,@stage1_languages@,$stage1_languages,;t t
12772 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12773 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12774 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12775 s,@tooldir@,$tooldir,;t t
12776 s,@build_tooldir@,$build_tooldir,;t t
12777 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12778 s,@GDB_TK@,$GDB_TK,;t t
12779 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12780 s,@build_configargs@,$build_configargs,;t t
12781 s,@build_configdirs@,$build_configdirs,;t t
12782 s,@host_configargs@,$host_configargs,;t t
12783 s,@configdirs@,$configdirs,;t t
12784 s,@target_configargs@,$target_configargs,;t t
12785 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12786 s,@config_shell@,$config_shell,;t t
12787 s,@YACC@,$YACC,;t t
12788 s,@BISON@,$BISON,;t t
12789 s,@M4@,$M4,;t t
12790 s,@LEX@,$LEX,;t t
12791 s,@FLEX@,$FLEX,;t t
12792 s,@MAKEINFO@,$MAKEINFO,;t t
12793 s,@EXPECT@,$EXPECT,;t t
12794 s,@RUNTEST@,$RUNTEST,;t t
12795 s,@AR@,$AR,;t t
12796 s,@AS@,$AS,;t t
12797 s,@DLLTOOL@,$DLLTOOL,;t t
12798 s,@LD@,$LD,;t t
12799 s,@LIPO@,$LIPO,;t t
12800 s,@NM@,$NM,;t t
12801 s,@RANLIB@,$RANLIB,;t t
12802 s,@STRIP@,$STRIP,;t t
12803 s,@WINDRES@,$WINDRES,;t t
12804 s,@WINDMC@,$WINDMC,;t t
12805 s,@OBJCOPY@,$OBJCOPY,;t t
12806 s,@OBJDUMP@,$OBJDUMP,;t t
12807 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12808 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12809 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12810 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12811 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12812 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12813 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12814 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12815 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12816 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12817 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12818 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12819 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12820 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12821 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12822 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12823 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
12824 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12825 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12826 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12827 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12828 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12829 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12830 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12831 s,@MAINT@,$MAINT,;t t
12832 s,@stage1_cflags@,$stage1_cflags,;t t
12833 s,@stage1_checking@,$stage1_checking,;t t
12834 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12835 s,@datarootdir@,$datarootdir,;t t
12836 s,@docdir@,$docdir,;t t
12837 s,@pdfdir@,$pdfdir,;t t
12838 s,@htmldir@,$htmldir,;t t
12839 s,@LIBOBJS@,$LIBOBJS,;t t
12840 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12841 /@serialization_dependencies@/r $serialization_dependencies
12842 s,@serialization_dependencies@,,;t t
12843 /@host_makefile_frag@/r $host_makefile_frag
12844 s,@host_makefile_frag@,,;t t
12845 /@target_makefile_frag@/r $target_makefile_frag
12846 s,@target_makefile_frag@,,;t t
12847 /@alphaieee_frag@/r $alphaieee_frag
12848 s,@alphaieee_frag@,,;t t
12849 /@ospace_frag@/r $ospace_frag
12850 s,@ospace_frag@,,;t t
12851 CEOF
12852
12853 _ACEOF
12854
12855   cat >>$CONFIG_STATUS <<\_ACEOF
12856   # Split the substitutions into bite-sized pieces for seds with
12857   # small command number limits, like on Digital OSF/1 and HP-UX.
12858   ac_max_sed_lines=48
12859   ac_sed_frag=1 # Number of current file.
12860   ac_beg=1 # First line for current file.
12861   ac_end=$ac_max_sed_lines # Line after last line for current file.
12862   ac_more_lines=:
12863   ac_sed_cmds=
12864   while $ac_more_lines; do
12865     if test $ac_beg -gt 1; then
12866       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12867     else
12868       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12869     fi
12870     if test ! -s $tmp/subs.frag; then
12871       ac_more_lines=false
12872     else
12873       # The purpose of the label and of the branching condition is to
12874       # speed up the sed processing (if there are no `@' at all, there
12875       # is no need to browse any of the substitutions).
12876       # These are the two extra sed commands mentioned above.
12877       (echo ':t
12878   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12879       if test -z "$ac_sed_cmds"; then
12880         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12881       else
12882         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12883       fi
12884       ac_sed_frag=`expr $ac_sed_frag + 1`
12885       ac_beg=$ac_end
12886       ac_end=`expr $ac_end + $ac_max_sed_lines`
12887     fi
12888   done
12889   if test -z "$ac_sed_cmds"; then
12890     ac_sed_cmds=cat
12891   fi
12892 fi # test -n "$CONFIG_FILES"
12893
12894 _ACEOF
12895 cat >>$CONFIG_STATUS <<\_ACEOF
12896 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12897   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12898   case $ac_file in
12899   - | *:- | *:-:* ) # input from stdin
12900         cat >$tmp/stdin
12901         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12902         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12903   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12904         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12905   * )   ac_file_in=$ac_file.in ;;
12906   esac
12907
12908   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
12909   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
12910 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12911          X"$ac_file" : 'X\(//\)[^/]' \| \
12912          X"$ac_file" : 'X\(//\)$' \| \
12913          X"$ac_file" : 'X\(/\)' \| \
12914          .     : '\(.\)' 2>/dev/null ||
12915 echo X"$ac_file" |
12916     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12917           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12918           /^X\(\/\/\)$/{ s//\1/; q; }
12919           /^X\(\/\).*/{ s//\1/; q; }
12920           s/.*/./; q'`
12921   { if $as_mkdir_p; then
12922     mkdir -p "$ac_dir"
12923   else
12924     as_dir="$ac_dir"
12925     as_dirs=
12926     while test ! -d "$as_dir"; do
12927       as_dirs="$as_dir $as_dirs"
12928       as_dir=`(dirname "$as_dir") 2>/dev/null ||
12929 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12930          X"$as_dir" : 'X\(//\)[^/]' \| \
12931          X"$as_dir" : 'X\(//\)$' \| \
12932          X"$as_dir" : 'X\(/\)' \| \
12933          .     : '\(.\)' 2>/dev/null ||
12934 echo X"$as_dir" |
12935     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12936           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12937           /^X\(\/\/\)$/{ s//\1/; q; }
12938           /^X\(\/\).*/{ s//\1/; q; }
12939           s/.*/./; q'`
12940     done
12941     test ! -n "$as_dirs" || mkdir $as_dirs
12942   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
12943 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
12944    { (exit 1); exit 1; }; }; }
12945
12946   ac_builddir=.
12947
12948 if test "$ac_dir" != .; then
12949   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
12950   # A "../" for each directory in $ac_dir_suffix.
12951   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
12952 else
12953   ac_dir_suffix= ac_top_builddir=
12954 fi
12955
12956 case $srcdir in
12957   .)  # No --srcdir option.  We are building in place.
12958     ac_srcdir=.
12959     if test -z "$ac_top_builddir"; then
12960        ac_top_srcdir=.
12961     else
12962        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
12963     fi ;;
12964   [\\/]* | ?:[\\/]* )  # Absolute path.
12965     ac_srcdir=$srcdir$ac_dir_suffix;
12966     ac_top_srcdir=$srcdir ;;
12967   *) # Relative path.
12968     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
12969     ac_top_srcdir=$ac_top_builddir$srcdir ;;
12970 esac
12971
12972 # Do not use `cd foo && pwd` to compute absolute paths, because
12973 # the directories may not exist.
12974 case `pwd` in
12975 .) ac_abs_builddir="$ac_dir";;
12976 *)
12977   case "$ac_dir" in
12978   .) ac_abs_builddir=`pwd`;;
12979   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
12980   *) ac_abs_builddir=`pwd`/"$ac_dir";;
12981   esac;;
12982 esac
12983 case $ac_abs_builddir in
12984 .) ac_abs_top_builddir=${ac_top_builddir}.;;
12985 *)
12986   case ${ac_top_builddir}. in
12987   .) ac_abs_top_builddir=$ac_abs_builddir;;
12988   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
12989   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
12990   esac;;
12991 esac
12992 case $ac_abs_builddir in
12993 .) ac_abs_srcdir=$ac_srcdir;;
12994 *)
12995   case $ac_srcdir in
12996   .) ac_abs_srcdir=$ac_abs_builddir;;
12997   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
12998   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
12999   esac;;
13000 esac
13001 case $ac_abs_builddir in
13002 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13003 *)
13004   case $ac_top_srcdir in
13005   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13006   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13007   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13008   esac;;
13009 esac
13010
13011
13012   case $INSTALL in
13013   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13014   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13015   esac
13016
13017   if test x"$ac_file" != x-; then
13018     { echo "$as_me:$LINENO: creating $ac_file" >&5
13019 echo "$as_me: creating $ac_file" >&6;}
13020     rm -f "$ac_file"
13021   fi
13022   # Let's still pretend it is `configure' which instantiates (i.e., don't
13023   # use $as_me), people would be surprised to read:
13024   #    /* config.h.  Generated by config.status.  */
13025   if test x"$ac_file" = x-; then
13026     configure_input=
13027   else
13028     configure_input="$ac_file.  "
13029   fi
13030   configure_input=$configure_input"Generated from `echo $ac_file_in |
13031                                      sed 's,.*/,,'` by configure."
13032
13033   # First look for the input files in the build tree, otherwise in the
13034   # src tree.
13035   ac_file_inputs=`IFS=:
13036     for f in $ac_file_in; do
13037       case $f in
13038       -) echo $tmp/stdin ;;
13039       [\\/$]*)
13040          # Absolute (can't be DOS-style, as IFS=:)
13041          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13042 echo "$as_me: error: cannot find input file: $f" >&2;}
13043    { (exit 1); exit 1; }; }
13044          echo "$f";;
13045       *) # Relative
13046          if test -f "$f"; then
13047            # Build tree
13048            echo "$f"
13049          elif test -f "$srcdir/$f"; then
13050            # Source tree
13051            echo "$srcdir/$f"
13052          else
13053            # /dev/null tree
13054            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13055 echo "$as_me: error: cannot find input file: $f" >&2;}
13056    { (exit 1); exit 1; }; }
13057          fi;;
13058       esac
13059     done` || { (exit 1); exit 1; }
13060 _ACEOF
13061 cat >>$CONFIG_STATUS <<_ACEOF
13062   sed "$ac_vpsub
13063 $extrasub
13064 _ACEOF
13065 cat >>$CONFIG_STATUS <<\_ACEOF
13066 :t
13067 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13068 s,@configure_input@,$configure_input,;t t
13069 s,@srcdir@,$ac_srcdir,;t t
13070 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13071 s,@top_srcdir@,$ac_top_srcdir,;t t
13072 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13073 s,@builddir@,$ac_builddir,;t t
13074 s,@abs_builddir@,$ac_abs_builddir,;t t
13075 s,@top_builddir@,$ac_top_builddir,;t t
13076 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13077 s,@INSTALL@,$ac_INSTALL,;t t
13078 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13079   rm -f $tmp/stdin
13080   if test x"$ac_file" != x-; then
13081     mv $tmp/out $ac_file
13082   else
13083     cat $tmp/out
13084     rm -f $tmp/out
13085   fi
13086
13087 done
13088 _ACEOF
13089
13090 cat >>$CONFIG_STATUS <<\_ACEOF
13091
13092 { (exit 0); exit 0; }
13093 _ACEOF
13094 chmod +x $CONFIG_STATUS
13095 ac_clean_files=$ac_clean_files_save
13096
13097
13098 # configure is writing to config.log, and then calls config.status.
13099 # config.status does its own redirection, appending to config.log.
13100 # Unfortunately, on DOS this fails, as config.log is still kept open
13101 # by configure, so config.status won't be able to write to it; its
13102 # output is simply discarded.  So we exec the FD to /dev/null,
13103 # effectively closing config.log, so it can be properly (re)opened and
13104 # appended to by config.status.  When coming back to configure, we
13105 # need to make the FD available again.
13106 if test "$no_create" != yes; then
13107   ac_cs_success=:
13108   ac_config_status_args=
13109   test "$silent" = yes &&
13110     ac_config_status_args="$ac_config_status_args --quiet"
13111   exec 5>/dev/null
13112   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13113   exec 5>>config.log
13114   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13115   # would make configure fail if this is the last instruction.
13116   $ac_cs_success || { (exit 1); exit 1; }
13117 fi
13118