fixincludes/aclocal.m4

   1 sinclude(../config/acx.m4)
   2 sinclude(../config/gettext.m4)
   3 sinclude(../config/progtest.m4)
   4 sinclude(../config/warnings.m4)
   5
   6 dnl See whether we need a declaration for a function.
   7 dnl The result is highly dependent on the INCLUDES passed in, so make sure
   8 dnl to use a different cache variable name in this macro if it is invoked
   9 dnl in a different context somewhere else.
  10 dnl gcc_AC_CHECK_DECL(SYMBOL,
  11 dnl     [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND [, INCLUDES]]])
  12 AC_DEFUN([gcc_AC_CHECK_DECL],
  13 [AC_MSG_CHECKING([whether $1 is declared])
  14 AC_CACHE_VAL(gcc_cv_have_decl_$1,
  15 [AC_TRY_COMPILE([$4],
  16 [#ifndef $1
  17 char *(*pfn) = (char *(*)) $1 ;
  18 #endif], eval "gcc_cv_have_decl_$1=yes", eval "gcc_cv_have_decl_$1=no")])
  19 if eval "test \"`echo '$gcc_cv_have_decl_'$1`\" = yes"; then
  20   AC_MSG_RESULT(yes) ; ifelse([$2], , :, [$2])
  21 else
  22   AC_MSG_RESULT(no) ; ifelse([$3], , :, [$3])
  23 fi
  24 ])dnl
  25
  26 dnl Check multiple functions to see whether each needs a declaration.
  27 dnl Arrange to define HAVE_DECL_<FUNCTION> to 0 or 1 as appropriate.
  28 dnl gcc_AC_CHECK_DECLS(SYMBOLS,
  29 dnl     [ACTION-IF-NEEDED [, ACTION-IF-NOT-NEEDED [, INCLUDES]]])
  30 AC_DEFUN([gcc_AC_CHECK_DECLS],
  31 [AC_FOREACH([gcc_AC_Func], [$1],
  32   [AH_TEMPLATE(AS_TR_CPP(HAVE_DECL_[]gcc_AC_Func),
  33   [Define to 1 if we found a declaration for ']gcc_AC_Func[', otherwise
  34    define to 0.])])dnl
  35 for ac_func in $1
  36 do
  37   ac_tr_decl=AS_TR_CPP([HAVE_DECL_$ac_func])
  38 gcc_AC_CHECK_DECL($ac_func,
  39   [AC_DEFINE_UNQUOTED($ac_tr_decl, 1) $2],
  40   [AC_DEFINE_UNQUOTED($ac_tr_decl, 0) $3],
  41 dnl It is possible that the include files passed in here are local headers
  42 dnl which supply a backup declaration for the relevant prototype based on
  43 dnl the definition of (or lack of) the HAVE_DECL_ macro.  If so, this test
  44 dnl will always return success.  E.g. see libiberty.h's handling of
  45 dnl `basename'.  To avoid this, we define the relevant HAVE_DECL_ macro to
  46 dnl 1 so that any local headers used do not provide their own prototype
  47 dnl during this test.
  48 #undef $ac_tr_decl
  49 #define $ac_tr_decl 1
  50   $4
  51 )
  52 done
  53 ])
  54
  55 dnl 'make compare' can be significantly faster, if cmp itself can
  56 dnl skip bytes instead of using tail.  The test being performed is
  57 dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
  58 dnl but we need to sink errors and handle broken shells.  We also test
  59 dnl for the parameter format "cmp file1 file2 skip1 skip2" which is
  60 dnl accepted by cmp on some systems.
  61 AC_DEFUN([gcc_AC_PROG_CMP_IGNORE_INITIAL],
  62 [AC_CACHE_CHECK([for cmp's capabilities], gcc_cv_prog_cmp_skip,
  63 [ echo abfoo >t1
  64   echo cdfoo >t2
  65   gcc_cv_prog_cmp_skip=slowcompare
  66   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
  67     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
  68       :
  69     else
  70       gcc_cv_prog_cmp_skip=gnucompare
  71     fi
  72   fi
  73   if test $gcc_cv_prog_cmp_skip = slowcompare ; then
  74     if cmp t1 t2 2 2 > /dev/null 2>&1; then
  75       if cmp t1 t2 1 1 > /dev/null 2>&1; then
  76         :
  77       else
  78         gcc_cv_prog_cmp_skip=fastcompare
  79       fi
  80     fi
  81   fi
  82   rm t1 t2
  83 ])
  84 make_compare_target=$gcc_cv_prog_cmp_skip
  85 AC_SUBST(make_compare_target)
  86 ])
  87
  88 dnl See if the printf functions in libc support %p in format strings.
  89 AC_DEFUN([gcc_AC_FUNC_PRINTF_PTR],
  90 [AC_CACHE_CHECK(whether the printf functions support %p,
  91   gcc_cv_func_printf_ptr,
  92 [AC_TRY_RUN([#include <stdio.h>
  93
  94 int main()
  95 {
  96   char buf[64];
  97   char *p = buf, *q = NULL;
  98   sprintf(buf, "%p", p);
  99   sscanf(buf, "%p", &q);
 100   return (p != q);
 101 }], gcc_cv_func_printf_ptr=yes, gcc_cv_func_printf_ptr=no,
 102         gcc_cv_func_printf_ptr=no)
 103 rm -f core core.* *.core])
 104 if test $gcc_cv_func_printf_ptr = yes ; then
 105   AC_DEFINE(HAVE_PRINTF_PTR, 1, [Define if printf supports "%p".])
 106 fi
 107 ])
 108
 109 dnl See if symbolic links work and if not, try to substitute either hard links or simple copy.
 110 AC_DEFUN([gcc_AC_PROG_LN_S],
 111 [AC_MSG_CHECKING(whether ln -s works)
 112 AC_CACHE_VAL(gcc_cv_prog_LN_S,
 113 [rm -f conftestdata_t
 114 echo >conftestdata_f
 115 if ln -s conftestdata_f conftestdata_t 2>/dev/null
 116 then
 117   gcc_cv_prog_LN_S="ln -s"
 118 else
 119   if ln conftestdata_f conftestdata_t 2>/dev/null
 120   then
 121     gcc_cv_prog_LN_S=ln
 122   else
 123     gcc_cv_prog_LN_S=cp
 124   fi
 125 fi
 126 rm -f conftestdata_f conftestdata_t
 127 ])dnl
 128 LN_S="$gcc_cv_prog_LN_S"
 129 if test "$gcc_cv_prog_LN_S" = "ln -s"; then
 130   AC_MSG_RESULT(yes)
 131 else
 132   if test "$gcc_cv_prog_LN_S" = "ln"; then
 133     AC_MSG_RESULT([no, using ln])
 134   else
 135     AC_MSG_RESULT([no, and neither does ln, so using cp])
 136   fi
 137 fi
 138 AC_SUBST(LN_S)dnl
 139 ])
 140
 141 dnl Define MKDIR_TAKES_ONE_ARG if mkdir accepts only one argument instead
 142 dnl of the usual 2.
 143 AC_DEFUN([gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG],
 144 [AC_CACHE_CHECK([if mkdir takes one argument], gcc_cv_mkdir_takes_one_arg,
 145 [AC_TRY_COMPILE([
 146 #include <sys/types.h>
 147 #ifdef HAVE_SYS_STAT_H
 148 # include <sys/stat.h>
 149 #endif
 150 #ifdef HAVE_UNISTD_H
 151 # include <unistd.h>
 152 #endif
 153 #ifdef HAVE_DIRECT_H
 154 # include <direct.h>
 155 #endif], [mkdir ("foo", 0);],
 156         gcc_cv_mkdir_takes_one_arg=no, gcc_cv_mkdir_takes_one_arg=yes)])
 157 if test $gcc_cv_mkdir_takes_one_arg = yes ; then
 158   AC_DEFINE(MKDIR_TAKES_ONE_ARG, 1, [Define if host mkdir takes a single argument.])
 159 fi
 160 ])
 161
 162 AC_DEFUN([gcc_AC_PROG_INSTALL],
 163 [AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
 164 # Find a good install program.  We prefer a C program (faster),
 165 # so one script is as good as another.  But avoid the broken or
 166 # incompatible versions:
 167 # SysV /etc/install, /usr/sbin/install
 168 # SunOS /usr/etc/install
 169 # IRIX /sbin/install
 170 # AIX /bin/install
 171 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
 172 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 173 # ./install, which can be erroneously created by make from ./install.sh.
 174 AC_MSG_CHECKING(for a BSD compatible install)
 175 if test -z "$INSTALL"; then
 176 AC_CACHE_VAL(ac_cv_path_install,
 177 [  IFS="${IFS=  }"; ac_save_IFS="$IFS"; IFS="${IFS}:"
 178   for ac_dir in $PATH; do
 179     # Account for people who put trailing slashes in PATH elements.
 180     case "$ac_dir/" in
 181     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
 182     *)
 183       # OSF1 and SCO ODT 3.0 have their own names for install.
 184       for ac_prog in ginstall scoinst install; do
 185         if test -f $ac_dir/$ac_prog; then
 186           if test $ac_prog = install &&
 187             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
 188             # AIX install.  It has an incompatible calling convention.
 189             # OSF/1 installbsd also uses dspmsg, but is usable.
 190             :
 191           else
 192             ac_cv_path_install="$ac_dir/$ac_prog -c"
 193             break 2
 194           fi
 195         fi
 196       done
 197       ;;
 198     esac
 199   done
 200   IFS="$ac_save_IFS"
 201 ])dnl
 202   if test "${ac_cv_path_install+set}" = set; then
 203     INSTALL="$ac_cv_path_install"
 204   else
 205     # As a last resort, use the slow shell script.  We don't cache a
 206     # path for INSTALL within a source directory, because that will
 207     # break other packages using the cache if that directory is
 208     # removed, or if the path is relative.
 209     INSTALL="$ac_install_sh"
 210   fi
 211 fi
 212 dnl We do special magic for INSTALL instead of AC_SUBST, to get
 213 dnl relative paths right.
 214 AC_MSG_RESULT($INSTALL)
 215 AC_SUBST(INSTALL)dnl
 216
 217 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
 218 # It thinks the first close brace ends the variable substitution.
 219 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 220 AC_SUBST(INSTALL_PROGRAM)dnl
 221
 222 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 223 AC_SUBST(INSTALL_DATA)dnl
 224 ])
 225
 226 dnl GCC_PATH_PROG(VARIABLE, PROG-TO-CHECK-FOR [, VALUE-IF-NOT-FOUND [, PATH]])
 227 dnl like AC_PATH_PROG but use other cache variables
 228 AC_DEFUN([GCC_PATH_PROG],
 229 [# Extract the first word of "$2", so it can be a program name with args.
 230 set dummy $2; ac_word=[$]2
 231 AC_MSG_CHECKING([for $ac_word])
 232 AC_CACHE_VAL(gcc_cv_path_$1,
 233 [case "[$]$1" in
 234   /*)
 235   gcc_cv_path_$1="[$]$1" # Let the user override the test with a path.
 236   ;;
 237   ?:/*)
 238   gcc_cv_path_$1="[$]$1" # Let the user override the test with a dos path.
 239   ;;
 240   *)
 241   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
 242 dnl $ac_dummy forces splitting on constant user-supplied paths.
 243 dnl POSIX.2 word splitting is done only on the output of word expansions,
 244 dnl not every word.  This closes a longstanding sh security hole.
 245   ac_dummy="ifelse([$4], , $PATH, [$4])"
 246   for ac_dir in $ac_dummy; do
 247     test -z "$ac_dir" && ac_dir=.
 248     if test -f $ac_dir/$ac_word; then
 249       gcc_cv_path_$1="$ac_dir/$ac_word"
 250       break
 251     fi
 252   done
 253   IFS="$ac_save_ifs"
 254 dnl If no 3rd arg is given, leave the cache variable unset,
 255 dnl so GCC_PATH_PROGS will keep looking.
 256 ifelse([$3], , , [  test -z "[$]gcc_cv_path_$1" && gcc_cv_path_$1="$3"
 257 ])dnl
 258   ;;
 259 esac])dnl
 260 $1="$gcc_cv_path_$1"
 261 if test -n "[$]$1"; then
 262   AC_MSG_RESULT([$]$1)
 263 else
 264   AC_MSG_RESULT(no)
 265 fi
 266 AC_SUBST($1)dnl
 267 ])
 268
 269 # mmap(2) blacklisting.  Some platforms provide the mmap library routine
 270 # but don't support all of the features we need from it.
 271 AC_DEFUN([gcc_AC_FUNC_MMAP_BLACKLIST],
 272 [
 273 AC_CHECK_HEADER([sys/mman.h],
 274                 [gcc_header_sys_mman_h=yes], [gcc_header_sys_mman_h=no])
 275 AC_CHECK_FUNC([mmap], [gcc_func_mmap=yes], [gcc_func_mmap=no])
 276 if test "$gcc_header_sys_mman_h" != yes \
 277  || test "$gcc_func_mmap" != yes; then
 278    gcc_cv_func_mmap_file=no
 279    gcc_cv_func_mmap_dev_zero=no
 280    gcc_cv_func_mmap_anon=no
 281 else
 282    AC_CACHE_CHECK([whether read-only mmap of a plain file works],
 283   gcc_cv_func_mmap_file,
 284   [# Add a system to this blacklist if
 285    # mmap(0, stat_size, PROT_READ, MAP_PRIVATE, fd, 0) doesn't return a
 286    # memory area containing the same data that you'd get if you applied
 287    # read() to the same fd.  The only system known to have a problem here
 288    # is VMS, where text files have record structure.
 289    case "$host_os" in
 290      vms* | ultrix*)
 291         gcc_cv_func_mmap_file=no ;;
 292      *)
 293         gcc_cv_func_mmap_file=yes;;
 294    esac])
 295    AC_CACHE_CHECK([whether mmap from /dev/zero works],
 296   gcc_cv_func_mmap_dev_zero,
 297   [# Add a system to this blacklist if it has mmap() but /dev/zero
 298    # does not exist, or if mmapping /dev/zero does not give anonymous
 299    # zeroed pages with both the following properties:
 300    # 1. If you map N consecutive pages in with one call, and then
 301    #    unmap any subset of those pages, the pages that were not
 302    #    explicitly unmapped remain accessible.
 303    # 2. If you map two adjacent blocks of memory and then unmap them
 304    #    both at once, they must both go away.
 305    # Systems known to be in this category are Windows (all variants),
 306    # VMS, and Darwin.
 307    case "$host_os" in
 308      vms* | cygwin* | pe | mingw* | darwin* | ultrix* | hpux10* | hpux11.00)
 309         gcc_cv_func_mmap_dev_zero=no ;;
 310      *)
 311         gcc_cv_func_mmap_dev_zero=yes;;
 312    esac])
 313
 314    # Unlike /dev/zero, the MAP_ANON(YMOUS) defines can be probed for.
 315    AC_CACHE_CHECK([for MAP_ANON(YMOUS)], gcc_cv_decl_map_anon,
 316     [AC_TRY_COMPILE(
 317 [#include <sys/types.h>
 318 #include <sys/mman.h>
 319 #include <unistd.h>
 320
 321 #ifndef MAP_ANONYMOUS
 322 #define MAP_ANONYMOUS MAP_ANON
 323 #endif
 324 ],
 325 [int n = MAP_ANONYMOUS;],
 326     gcc_cv_decl_map_anon=yes,
 327     gcc_cv_decl_map_anon=no)])
 328
 329    if test $gcc_cv_decl_map_anon = no; then
 330      gcc_cv_func_mmap_anon=no
 331    else
 332      AC_CACHE_CHECK([whether mmap with MAP_ANON(YMOUS) works],
 333      gcc_cv_func_mmap_anon,
 334   [# Add a system to this blacklist if it has mmap() and MAP_ANON or
 335    # MAP_ANONYMOUS, but using mmap(..., MAP_PRIVATE|MAP_ANONYMOUS, -1, 0)
 336    # doesn't give anonymous zeroed pages with the same properties listed
 337    # above for use of /dev/zero.
 338    # Systems known to be in this category are Windows, VMS, and SCO Unix.
 339    case "$host_os" in
 340      vms* | cygwin* | pe | mingw* | sco* | udk* )
 341         gcc_cv_func_mmap_anon=no ;;
 342      *)
 343         gcc_cv_func_mmap_anon=yes;;
 344    esac])
 345    fi
 346 fi
 347
 348 if test $gcc_cv_func_mmap_file = yes; then
 349   AC_DEFINE(HAVE_MMAP_FILE, 1,
 350             [Define if read-only mmap of a plain file works.])
 351 fi
 352 if test $gcc_cv_func_mmap_dev_zero = yes; then
 353   AC_DEFINE(HAVE_MMAP_DEV_ZERO, 1,
 354             [Define if mmap of /dev/zero works.])
 355 fi
 356 if test $gcc_cv_func_mmap_anon = yes; then
 357   AC_DEFINE(HAVE_MMAP_ANON, 1,
 358             [Define if mmap with MAP_ANON(YMOUS) works.])
 359 fi
 360 ])
 361
 362 dnl Locate a program and check that its version is acceptable.
 363 dnl AC_PROG_CHECK_VER(var, name, version-switch,
 364 dnl                  version-extract-regexp, version-glob)
 365 AC_DEFUN([gcc_AC_CHECK_PROG_VER],
 366 [AC_CHECK_PROG([$1], [$2], [$2])
 367 if test -n "[$]$1"; then
 368   # Found it, now check the version.
 369   AC_CACHE_CHECK(for modern $2, gcc_cv_prog_$2_modern,
 370 [changequote(<<,>>)dnl
 371   ac_prog_version=`<<$>>$1 $3 2>&1 |
 372                    sed -n 's/^.*patsubst(<<$4>>,/,\/).*$/\1/p'`
 373 changequote([,])dnl
 374   echo "configure:__oline__: version of $2 is $ac_prog_version" >&AC_FD_CC
 375 changequote(<<,>>)dnl
 376   case $ac_prog_version in
 377     '')     gcc_cv_prog_$2_modern=no;;
 378     <<$5>>)
 379             gcc_cv_prog_$2_modern=yes;;
 380     *)      gcc_cv_prog_$2_modern=no;;
 381   esac
 382 changequote([,])dnl
 383 ])
 384 else
 385   gcc_cv_prog_$2_modern=no
 386 fi
 387 ])
 388
 389 dnl Determine if enumerated bitfields are unsigned.   ISO C says they can
 390 dnl be either signed or unsigned.
 391 dnl
 392 AC_DEFUN([gcc_AC_C_ENUM_BF_UNSIGNED],
 393 [AC_CACHE_CHECK(for unsigned enumerated bitfields, gcc_cv_enum_bf_unsigned,
 394 [AC_TRY_RUN(#include <stdlib.h>
 395 enum t { BLAH = 128 } ;
 396 struct s_t { enum t member : 8; } s ;
 397 int main(void)
 398 {
 399         s.member = BLAH;
 400         if (s.member < 0) exit(1);
 401         exit(0);
 402
 403 }, gcc_cv_enum_bf_unsigned=yes, gcc_cv_enum_bf_unsigned=no, gcc_cv_enum_bf_unsigned=yes)])
 404 if test $gcc_cv_enum_bf_unsigned = yes; then
 405   AC_DEFINE(ENUM_BITFIELDS_ARE_UNSIGNED, 1,
 406     [Define if enumerated bitfields are treated as unsigned values.])
 407 fi])
 408
 409 dnl Probe number of bits in a byte.
 410 dnl Note C89 requires CHAR_BIT >= 8.
 411 dnl
 412 AC_DEFUN([gcc_AC_C_CHAR_BIT],
 413 [AC_CACHE_CHECK(for CHAR_BIT, gcc_cv_decl_char_bit,
 414 [AC_EGREP_CPP(found,
 415 [#ifdef HAVE_LIMITS_H
 416 #include <limits.h>
 417 #endif
 418 #ifdef CHAR_BIT
 419 found
 420 #endif], gcc_cv_decl_char_bit=yes, gcc_cv_decl_char_bit=no)
 421 ])
 422 if test $gcc_cv_decl_char_bit = no; then
 423   AC_CACHE_CHECK(number of bits in a byte, gcc_cv_c_nbby,
 424 [i=8
 425  gcc_cv_c_nbby=
 426  while test $i -lt 65; do
 427    AC_TRY_COMPILE(,
 428      [switch(0) {
 429   case (unsigned char)((unsigned long)1 << $i) == ((unsigned long)1 << $i):
 430   case (unsigned char)((unsigned long)1<<($i-1)) == ((unsigned long)1<<($i-1)):
 431   ; }],
 432      [gcc_cv_c_nbby=$i; break])
 433    i=`expr $i + 1`
 434  done
 435  test -z "$gcc_cv_c_nbby" && gcc_cv_c_nbby=failed
 436 ])
 437 if test $gcc_cv_c_nbby = failed; then
 438   AC_MSG_ERROR(cannot determine number of bits in a byte)
 439 else
 440   AC_DEFINE_UNQUOTED(CHAR_BIT, $gcc_cv_c_nbby,
 441   [Define as the number of bits in a byte, if \`limits.h' doesn't.])
 442 fi
 443 fi])
 444
 445 dnl Checking for long long.
 446 dnl By Caolan McNamara <caolan@skynet.ie>
 447 dnl Added check for __int64, Zack Weinberg <zackw@stanford.edu>
 448 dnl
 449 AC_DEFUN([gcc_AC_C_LONG_LONG],
 450 [AC_CACHE_CHECK(for long long int, ac_cv_c_long_long,
 451   [AC_TRY_COMPILE(,[long long int i;],
 452          ac_cv_c_long_long=yes,
 453          ac_cv_c_long_long=no)])
 454   if test $ac_cv_c_long_long = yes; then
 455     AC_DEFINE(HAVE_LONG_LONG, 1,
 456       [Define if your compiler supports the \`long long' type.])
 457   fi
 458 AC_CACHE_CHECK(for __int64, ac_cv_c___int64,
 459   [AC_TRY_COMPILE(,[__int64 i;],
 460         ac_cv_c___int64=yes,
 461         ac_cv_c___int64=no)])
 462   if test $ac_cv_c___int64 = yes; then
 463     AC_DEFINE(HAVE___INT64, 1,
 464       [Define if your compiler supports the \`__int64' type.])
 465   fi
 466 ])
 467
 468 #serial AM2
 469
 470 dnl From Bruno Haible.
 471
 472 AC_DEFUN([AM_ICONV],
 473 [
 474   dnl Some systems have iconv in libc, some have it in libiconv (OSF/1 and
 475   dnl those with the standalone portable GNU libiconv installed).
 476
 477   am_cv_lib_iconv_ldpath=
 478   AC_ARG_WITH([libiconv-prefix],
 479 [  --with-libiconv-prefix=DIR  search for libiconv in DIR/include and DIR/lib], [
 480     for dir in `echo "$withval" | tr : ' '`; do
 481       if test -d $dir/include; then CPPFLAGS="$CPPFLAGS -I$dir/include"; fi
 482       if test -d $dir/lib; then am_cv_lib_iconv_ldpath="-L$dir/lib"; fi
 483     done
 484    ])
 485
 486   AC_CHECK_HEADERS([iconv.h])
 487
 488   AC_CACHE_CHECK(for iconv, am_cv_func_iconv, [
 489     am_cv_func_iconv="no, consider installing GNU libiconv"
 490     am_cv_lib_iconv=no
 491     AC_TRY_LINK([#include <stdlib.h>
 492 #include <iconv.h>],
 493       [iconv_t cd = iconv_open("","");
 494        iconv(cd,NULL,NULL,NULL,NULL);
 495        iconv_close(cd);],
 496       am_cv_func_iconv=yes)
 497     if test "$am_cv_func_iconv" != yes; then
 498       am_save_LIBS="$LIBS"
 499       LIBS="$LIBS $am_cv_libiconv_ldpath -liconv"
 500       AC_TRY_LINK([#include <stdlib.h>
 501 #include <iconv.h>],
 502         [iconv_t cd = iconv_open("","");
 503          iconv(cd,NULL,NULL,NULL,NULL);
 504          iconv_close(cd);],
 505         am_cv_lib_iconv=yes
 506         am_cv_func_iconv=yes)
 507       LIBS="$am_save_LIBS"
 508     fi
 509   ])
 510   if test "$am_cv_func_iconv" = yes; then
 511     AC_DEFINE(HAVE_ICONV, 1, [Define if you have the iconv() function.])
 512     AC_MSG_CHECKING([for iconv declaration])
 513     AC_CACHE_VAL(am_cv_proto_iconv, [
 514       AC_TRY_COMPILE([
 515 #include <stdlib.h>
 516 #include <iconv.h>
 517 extern
 518 #ifdef __cplusplus
 519 "C"
 520 #endif
 521 #if defined(__STDC__) || defined(__cplusplus)
 522 size_t iconv (iconv_t cd, char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);
 523 #else
 524 size_t iconv();
 525 #endif
 526 ], [], am_cv_proto_iconv_arg1="", am_cv_proto_iconv_arg1="const")
 527       am_cv_proto_iconv="extern size_t iconv (iconv_t cd, $am_cv_proto_iconv_arg1 char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);"])
 528     am_cv_proto_iconv=`echo "[$]am_cv_proto_iconv" | tr -s ' ' | sed -e 's/( /(/'`
 529     AC_MSG_RESULT([$]{ac_t:-
 530          }[$]am_cv_proto_iconv)
 531     AC_DEFINE_UNQUOTED(ICONV_CONST, $am_cv_proto_iconv_arg1,
 532       [Define as const if the declaration of iconv() needs const.])
 533   fi
 534   LIBICONV=
 535   if test "$am_cv_lib_iconv" = yes; then
 536     LIBICONV="$am_cv_lib_iconv_ldpath -liconv"
 537   fi
 538   AC_SUBST(LIBICONV)
 539 ])
 540
 541 AC_DEFUN([gcc_AC_INITFINI_ARRAY],
 542 [AC_ARG_ENABLE(initfini-array,
 543         [  --enable-initfini-array      use .init_array/.fini_array sections],
 544         [], [
 545 AC_CACHE_CHECK(for .preinit_array/.init_array/.fini_array support,
 546                  gcc_cv_initfini_array, [dnl
 547   AC_TRY_RUN([
 548 static int x = -1;
 549 int main (void) { return x; }
 550 int foo (void) { x = 0; }
 551 int (*fp) (void) __attribute__ ((section (".init_array"))) = foo;],
 552              [gcc_cv_initfini_array=yes], [gcc_cv_initfini_array=no],
 553              [gcc_cv_initfini_array=no])])
 554   enable_initfini_array=$gcc_cv_initfini_array
 555 ])
 556 if test $enable_initfini_array = yes; then
 557   AC_DEFINE(HAVE_INITFINI_ARRAY, 1,
 558     [Define .init_array/.fini_array sections are available and working.])
 559 fi])
 560
 561 dnl # _gcc_COMPUTE_GAS_VERSION
 562 dnl # Used by gcc_GAS_VERSION_GTE_IFELSE
 563 dnl #
 564 dnl # WARNING:
 565 dnl # gcc_cv_as_gas_srcdir must be defined before this.
 566 dnl # This gross requirement will go away eventually.
 567 AC_DEFUN([_gcc_COMPUTE_GAS_VERSION],
 568 [gcc_cv_as_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
 569 for f in $gcc_cv_as_bfd_srcdir/configure \
 570          $gcc_cv_as_gas_srcdir/configure \
 571          $gcc_cv_as_gas_srcdir/configure.in \
 572          $gcc_cv_as_gas_srcdir/Makefile.in ; do
 573   gcc_cv_gas_version=`grep '^VERSION=[[0-9]]*\.[[0-9]]*' $f`
 574   if test x$gcc_cv_gas_version != x; then
 575     break
 576   fi
 577 done
 578 gcc_cv_gas_major_version=`expr "$gcc_cv_gas_version" : "VERSION=\([[0-9]]*\)"`
 579 gcc_cv_gas_minor_version=`expr "$gcc_cv_gas_version" : "VERSION=[[0-9]]*\.\([[0-9]]*\)"`
 580 gcc_cv_gas_patch_version=`expr "$gcc_cv_gas_version" : "VERSION=[[0-9]]*\.[[0-9]]*\.\([[0-9]]*\)"`
 581 case $gcc_cv_gas_patch_version in
 582   "") gcc_cv_gas_patch_version="0" ;;
 583 esac
 584 gcc_cv_gas_vers=`expr \( \( $gcc_cv_gas_major_version \* 1000 \) \
 585                             + $gcc_cv_gas_minor_version \) \* 1000 \
 586                             + $gcc_cv_gas_patch_version`
 587 ]) []dnl # _gcc_COMPUTE_GAS_VERSION
 588
 589 dnl # gcc_GAS_VERSION_GTE_IFELSE([elf,] major, minor, patchlevel,
 590 dnl #                     [command_if_true = :], [command_if_false = :])
 591 dnl # Check to see if the version of GAS is greater than or
 592 dnl # equal to the specified version.
 593 dnl #
 594 dnl # The first ifelse() shortens the shell code if the patchlevel
 595 dnl # is unimportant (the usual case).  The others handle missing
 596 dnl # commands.  Note that the tests are structured so that the most
 597 dnl # common version number cases are tested first.
 598 AC_DEFUN([_gcc_GAS_VERSION_GTE_IFELSE],
 599 [ifelse([$1], elf,
 600  [if test $in_tree_gas_is_elf = yes \
 601   &&],
 602  [if]) test $gcc_cv_gas_vers -ge `expr \( \( $2 \* 1000 \) + $3 \) \* 1000 + $4`
 603   then dnl
 604 ifelse([$5],,:,[$5])[]dnl
 605 ifelse([$6],,,[
 606   else $6])
 607 fi])
 608
 609 AC_DEFUN([gcc_GAS_VERSION_GTE_IFELSE],
 610 [AC_REQUIRE([_gcc_COMPUTE_GAS_VERSION])dnl
 611 ifelse([$1], elf, [_gcc_GAS_VERSION_GTE_IFELSE($@)],
 612                   [_gcc_GAS_VERSION_GTE_IFELSE(,$@)])])
 613
 614 dnl gcc_GAS_CHECK_FEATURE(description, cv, [[elf,]major,minor,patchlevel],
 615 dnl [extra switches to as], [assembler input],
 616 dnl [extra testing logic], [command if feature available])
 617 dnl
 618 dnl Checks for an assembler feature.  If we are building an in-tree
 619 dnl gas, the feature is available if the associated assembler version
 620 dnl is greater than or equal to major.minor.patchlevel.  If not, then
 621 dnl ASSEMBLER INPUT is fed to the assembler and the feature is available
 622 dnl if assembly succeeds.  If EXTRA TESTING LOGIC is not the empty string,
 623 dnl then it is run instead of simply setting CV to "yes" - it is responsible
 624 dnl for doing so, if appropriate.
 625 AC_DEFUN([gcc_GAS_CHECK_FEATURE],
 626 [AC_CACHE_CHECK([assembler for $1], [$2],
 627  [[$2]=no
 628   ifelse([$3],,,[dnl
 629   if test $in_tree_gas = yes; then
 630     gcc_GAS_VERSION_GTE_IFELSE($3, [[$2]=yes])
 631   el])if test x$gcc_cv_as != x; then
 632     echo ifelse(m4_substr([$5],0,1),[$], "[$5]", '[$5]') > conftest.s
 633     if AC_TRY_COMMAND([$gcc_cv_as $4 -o conftest.o conftest.s >&AC_FD_CC])
 634     then
 635         ifelse([$6],, [$2]=yes, [$6])
 636     else
 637       echo "configure: failed program was" >&AC_FD_CC
 638       cat conftest.s >&AC_FD_CC
 639     fi
 640     rm -f conftest.o conftest.s
 641   fi])
 642 ifelse([$7],,,[dnl
 643 if test $[$2] = yes; then
 644   $7
 645 fi])])
 646
 647 # lcmessage.m4 serial 3 (gettext-0.11.3)
 648 dnl Copyright (C) 1995-2002 Free Software Foundation, Inc.
 649 dnl This file is free software, distributed under the terms of the GNU
 650 dnl General Public License.  As a special exception to the GNU General
 651 dnl Public License, this file may be distributed as part of a program
 652 dnl that contains a configuration script generated by Autoconf, under
 653 dnl the same distribution terms as the rest of that program.
 654 dnl
 655 dnl This file can can be used in projects which are not available under
 656 dnl the GNU General Public License or the GNU Library General Public
 657 dnl License but which still want to provide support for the GNU gettext
 658 dnl functionality.
 659 dnl Please note that the actual code of the GNU gettext library is covered
 660 dnl by the GNU Library General Public License, and the rest of the GNU
 661 dnl gettext package package is covered by the GNU General Public License.
 662 dnl They are *not* in the public domain.
 663
 664 dnl Authors:
 665 dnl   Ulrich Drepper <drepper@cygnus.com>, 1995.
 666
 667 # Check whether LC_MESSAGES is available in <locale.h>.
 668
 669 AC_DEFUN([AM_LC_MESSAGES],
 670 [
 671   AC_CACHE_CHECK([for LC_MESSAGES], am_cv_val_LC_MESSAGES,
 672     [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
 673        am_cv_val_LC_MESSAGES=yes, am_cv_val_LC_MESSAGES=no)])
 674   if test $am_cv_val_LC_MESSAGES = yes; then
 675     AC_DEFINE(HAVE_LC_MESSAGES, 1,
 676       [Define if your <locale.h> file defines LC_MESSAGES.])
 677   fi
 678 ])