From: Jo-Philipp Wich Date: Wed, 22 Dec 2010 00:38:21 +0000 (+0000) Subject: missing-macros: add more m4 macros from gettext, ossp-js, libmikmod, libdnet X-Git-Url: http://git.lede-project.org./?a=commitdiff_plain;h=93cb309a059da73578a77cf81ff74b15064ef244;p=openwrt%2Fstaging%2Fldir.git missing-macros: add more m4 macros from gettext, ossp-js, libmikmod, libdnet SVN-Revision: 24757 --- diff --git a/tools/missing-macros/Makefile b/tools/missing-macros/Makefile index 6553c42945..d2da273fad 100644 --- a/tools/missing-macros/Makefile +++ b/tools/missing-macros/Makefile @@ -8,7 +8,7 @@ include $(TOPDIR)/rules.mk PKG_NAME:=missing-macros -PKG_VERSION:=2 +PKG_VERSION:=3 include $(INCLUDE_DIR)/host-build.mk diff --git a/tools/missing-macros/src/README b/tools/missing-macros/src/README index 18ba3e39e2..5ec7a86fe2 100644 --- a/tools/missing-macros/src/README +++ b/tools/missing-macros/src/README @@ -9,8 +9,51 @@ Library linking and rpath helper macros. lib-link.m4 lib-prefix.m4 +Integer data type test macros. + + intmax.m4 + wint_t.m4 + inttypes-pri.m4 + uintmax_t.m4 + stdint_h.m4 + intdiv0.m4 + inttypes_h.m4 + +Program test macro. + + progtest.m4 + +GNU libc version test macros. + + glibc2.m4 + glibc21.m4 + From UCL and LZO: Compiler ACC conformance testing macros. acc.m4 + + +From OSSP-JS: +Test macros for va_copy() implementations. + + va_copy.m4 + + +From libmikmod: +Feature test macros for the Enlightment Sound Daemon. + + esd.m4 + + +From libdnet: +Feature test macros for socket api implementations. + + dnet.m4 + + +From OpenWrt: +Always disable GTK docs. + + fake-gtk-doc-check.m4 diff --git a/tools/missing-macros/src/m4/dnet.m4 b/tools/missing-macros/src/m4/dnet.m4 new file mode 100644 index 0000000000..a186eabffb --- /dev/null +++ b/tools/missing-macros/src/m4/dnet.m4 @@ -0,0 +1,320 @@ +dnl +dnl Check for 4.4 BSD sa_len member in sockaddr struct +dnl +dnl usage: AC_DNET_SOCKADDR_SA_LEN +dnl results: HAVE_SOCKADDR_SA_LEN (defined) +dnl +AC_DEFUN(AC_DNET_SOCKADDR_SA_LEN, + [AC_MSG_CHECKING(for sa_len in sockaddr struct) + AC_CACHE_VAL(ac_cv_dnet_sockaddr_has_sa_len, + AC_TRY_COMPILE([ +# ifndef _SOCKADDR_LEN +# define _SOCKADDR_LEN 1 +# endif +# include +# include ], + [u_int i = sizeof(((struct sockaddr *)0)->sa_len)], + ac_cv_dnet_sockaddr_has_sa_len=yes, + ac_cv_dnet_sockaddr_has_sa_len=no)) + AC_MSG_RESULT($ac_cv_dnet_sockaddr_has_sa_len) + if test $ac_cv_dnet_sockaddr_has_sa_len = yes ; then + AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, + [Define if sockaddr struct has sa_len.]) + fi]) + +dnl +dnl Check for sockaddr_in6 struct in +dnl +dnl usage: AC_DNET_SOCKADDR_IN6 +dnl results: HAVE_SOCKADDR_IN6 +dnl +AC_DEFUN(AC_DNET_SOCKADDR_IN6, + [AC_MSG_CHECKING(for sockaddr_in6 struct in ) + AC_CACHE_VAL(ac_cv_dnet_netinet_in_h_has_sockaddr_in6, + AC_TRY_COMPILE([ +# include +# include +# include ], + [struct sockaddr_in6 sin6; sin6.sin6_family = AF_INET6;], + ac_cv_dnet_netinet_in_h_has_sockaddr_in6=yes, + ac_cv_dnet_netinet_in_h_has_sockaddr_in6=no)) + AC_MSG_RESULT($ac_cv_dnet_netinet_in_h_has_sockaddr_in6) + if test $ac_cv_dnet_netinet_in_h_has_sockaddr_in6 = yes ; then + AC_DEFINE(HAVE_SOCKADDR_IN6, 1, + [Define if has sockaddr_in6 struct.]) + fi]) + +dnl +dnl Check for arp_dev member in arpreq struct +dnl +dnl usage: AC_DNET_ARPREQ_ARP_DEV +dnl results: HAVE_ARPREQ_ARP_DEV (defined) +dnl +AC_DEFUN(AC_DNET_ARPREQ_ARP_DEV, + [AC_MSG_CHECKING(for arp_dev in arpreq struct) + AC_CACHE_VAL(ac_cv_dnet_arpreq_has_arp_dev, + AC_TRY_COMPILE([ +# include +# include +# include ], + [void *p = ((struct arpreq *)0)->arp_dev], + ac_cv_dnet_arpreq_has_arp_dev=yes, + ac_cv_dnet_arpreq_has_arp_dev=no)) + AC_MSG_RESULT($ac_cv_dnet_arpreq_has_arp_dev) + if test $ac_cv_dnet_arpreq_has_arp_dev = yes ; then + AC_DEFINE(HAVE_ARPREQ_ARP_DEV, 1, + [Define if arpreq struct has arp_dev.]) + fi]) + +dnl +dnl Check for rt_msghdr struct in +dnl +dnl usage: AC_DNET_ROUTE_RT_MSGHDR +dnl results: HAVE_ROUTE_RT_MSGHDR +dnl +AC_DEFUN(AC_DNET_ROUTE_RT_MSGHDR, + [AC_MSG_CHECKING(for rt_msghdr struct in ) + AC_CACHE_VAL(ac_cv_dnet_route_h_has_rt_msghdr, + AC_TRY_COMPILE([ +# include +# include +# include +# include ], + [struct rt_msghdr rtm; rtm.rtm_msglen = 0;], + ac_cv_dnet_route_h_has_rt_msghdr=yes, + ac_cv_dnet_route_h_has_rt_msghdr=no)) + AC_MSG_RESULT($ac_cv_dnet_route_h_has_rt_msghdr) + if test $ac_cv_dnet_route_h_has_rt_msghdr = yes ; then + AC_DEFINE(HAVE_ROUTE_RT_MSGHDR, 1, + [Define if has rt_msghdr struct.]) + fi]) + +dnl +dnl Check for the Berkeley Packet Filter +dnl +dnl usage: AC_DNET_BSD_BPF +dnl results: HAVE_BSD_BPF +dnl +AC_DEFUN(AC_DNET_BSD_BPF, + [AC_MSG_CHECKING(for Berkeley Packet Filter) + AC_CACHE_VAL(ac_cv_dnet_bsd_bpf, + if test -c /dev/bpf0 ; then + ac_cv_dnet_bsd_bpf=yes + else + ac_cv_dnet_bsd_bpf=no + fi) + AC_MSG_RESULT($ac_cv_dnet_bsd_bpf) + if test $ac_cv_dnet_bsd_bpf = yes ; then + AC_DEFINE(HAVE_BSD_BPF, 1, + [Define if you have the Berkeley Packet Filter.]) + fi]) + +dnl +dnl Check for the Linux /proc filesystem +dnl +dnl usage: AC_DNET_LINUX_PROCFS +dnl results: HAVE_LINUX_PROCFS +dnl +AC_DEFUN(AC_DNET_LINUX_PROCFS, + [AC_MSG_CHECKING(for Linux proc filesystem) + AC_CACHE_VAL(ac_cv_dnet_linux_procfs, + if test "x`cat /proc/sys/kernel/ostype 2>&-`" = "xLinux" ; then + ac_cv_dnet_linux_procfs=yes + else + ac_cv_dnet_linux_procfs=no + fi) + AC_MSG_RESULT($ac_cv_dnet_linux_procfs) + if test $ac_cv_dnet_linux_procfs = yes ; then + AC_DEFINE(HAVE_LINUX_PROCFS, 1, + [Define if you have the Linux /proc filesystem.]) + fi]) + +dnl +dnl Check for Linux PF_PACKET sockets +dnl +dnl usage: AC_DNET_LINUX_PF_PACKET +dnl results: HAVE_LINUX_PF_PACKET +dnl +AC_DEFUN(AC_DNET_LINUX_PF_PACKET, + [AC_MSG_CHECKING(for Linux PF_PACKET sockets) + AC_CACHE_VAL(ac_cv_dnet_linux_pf_packet, + if test -f /usr/include/netpacket/packet.h ; then + ac_cv_dnet_linux_pf_packet=yes + else + ac_cv_dnet_linux_pf_packet=no + fi) + AC_MSG_RESULT($ac_cv_dnet_linux_pf_packet) + if test $ac_cv_dnet_linux_pf_packet = yes ; then + AC_DEFINE(HAVE_LINUX_PF_PACKET, 1, + [Define if you have Linux PF_PACKET sockets.]) + fi]) + +dnl +dnl Check for SNMP MIB2 STREAMS (Solaris only?) +dnl +dnl usage: AC_DNET_STREAMS_MIB2 +dnl results: HAVE_STREAMS_MIB2 +dnl +AC_DEFUN(AC_DNET_STREAMS_MIB2, + [AC_MSG_CHECKING(for SNMP MIB2 STREAMS) + AC_CACHE_VAL(ac_cv_dnet_streams_mib2, + if test -f /usr/include/inet/mib2.h -a -c /dev/ip ; then + ac_cv_dnet_streams_mib2=yes + else + ac_cv_dnet_streams_mib2=no + fi) + AC_MSG_RESULT($ac_cv_dnet_streams_mib2) + if test $ac_cv_dnet_streams_mib2 = yes ; then + AC_DEFINE(HAVE_STREAMS_MIB2, 1, + [Define if you have SNMP MIB2 STREAMS.]) + fi]) + +dnl +dnl Check for route(7) STREAMS (UnixWare only?) +dnl +dnl usage: AC_DNET_STREAMS_ROUTE +dnl results: HAVE_STREAMS_ROUTE +dnl +AC_DEFUN(AC_DNET_STREAMS_ROUTE, + [AC_MSG_CHECKING(for route(7) STREAMS) + AC_CACHE_VAL(ac_cv_dnet_streams_route, + if grep RTSTR_SEND /usr/include/net/route.h >/dev/null 2>&1 ; then + ac_cv_dnet_streams_route=yes + else + ac_cv_dnet_streams_route=no + fi) + AC_MSG_RESULT($ac_cv_dnet_streams_route) + if test $ac_cv_dnet_streams_route = yes ; then + AC_DEFINE(HAVE_STREAMS_ROUTE, 1, + [Define if you have route(7) STREAMS.]) + fi]) + +dnl +dnl Check for arp(7) ioctls +dnl +dnl usage: AC_DNET_IOCTL_ARP +dnl results: HAVE_IOCTL_ARP +dnl +AC_DEFUN(AC_DNET_IOCTL_ARP, + [AC_MSG_CHECKING(for arp(7) ioctls) + AC_CACHE_VAL(ac_cv_dnet_ioctl_arp, + AC_EGREP_CPP(werd, [ +# include +# define BSD_COMP +# include +# ifdef SIOCGARP + werd +# endif], + ac_cv_dnet_ioctl_arp=yes, + ac_cv_dnet_ioctl_arp=no)) + case "$host_os" in + irix*) + ac_cv_dnet_ioctl_arp=no ;; + esac + AC_MSG_RESULT($ac_cv_dnet_ioctl_arp) + if test $ac_cv_dnet_ioctl_arp = yes ; then + AC_DEFINE(HAVE_IOCTL_ARP, 1, + [Define if you have arp(7) ioctls.]) + fi]) + +dnl +dnl Check for raw IP sockets ip_{len,off} host byte ordering +dnl +dnl usage: AC_DNET_RAWIP_HOST_OFFLEN +dnl results: HAVE_RAWIP_HOST_OFFLEN +dnl +AC_DEFUN(AC_DNET_RAWIP_HOST_OFFLEN, + [AC_MSG_CHECKING([for raw IP sockets ip_{len,off} host byte ordering]) + AC_CACHE_VAL(ac_cv_dnet_rawip_host_offlen, [ + case "$host_os" in + *openbsd*) + ac_cv_dnet_rawip_host_offlen=no ;; + *bsd*|*osf*|*unixware*) + ac_cv_dnet_rawip_host_offlen=yes ;; + *) + ac_cv_dnet_rawip_host_offlen=no ;; + esac]) + AC_MSG_RESULT($ac_cv_dnet_rawip_host_offlen) + if test $ac_cv_dnet_rawip_host_offlen = yes ; then + AC_DEFINE(HAVE_RAWIP_HOST_OFFLEN, 1, + [Define if raw IP sockets require host byte ordering for ip_off, ip_len.]) + fi]) + +dnl +dnl Check for cooked raw IP sockets +dnl +dnl usage: AC_DNET_RAWIP_COOKED +dnl results: HAVE_RAWIP_COOKED +dnl +AC_DEFUN(AC_DNET_RAWIP_COOKED, + [AC_MSG_CHECKING(for cooked raw IP sockets) + AC_CACHE_VAL(ac_cv_dnet_rawip_cooked, [ + case "$host_os" in + solaris*|irix*) + ac_cv_dnet_rawip_cooked=yes ;; + *) + ac_cv_dnet_rawip_cooked=no ;; + esac]) + AC_MSG_RESULT($ac_cv_dnet_rawip_cooked) + if test $ac_cv_dnet_rawip_cooked = yes ; then + AC_DEFINE(HAVE_RAWIP_COOKED, 1, + [Define if you have cooked raw IP sockets.]) + fi]) + +dnl +dnl AC_LBL_LIBRARY_NET +dnl +dnl This test is for network applications that need socket() and +dnl gethostbyname() -ish functions. Under Solaris, those applications +dnl need to link with "-lsocket -lnsl". Under IRIX, they need to link +dnl with "-lnsl" but should *not* link with "-lsocket" because +dnl libsocket.a breaks a number of things (for instance: +dnl gethostbyname() under IRIX 5.2, and snoop sockets under most +dnl versions of IRIX). +dnl +dnl Unfortunately, many application developers are not aware of this, +dnl and mistakenly write tests that cause -lsocket to be used under +dnl IRIX. It is also easy to write tests that cause -lnsl to be used +dnl under operating systems where neither are necessary (or useful), +dnl such as SunOS 4.1.4, which uses -lnsl for TLI. +dnl +dnl This test exists so that every application developer does not test +dnl this in a different, and subtly broken fashion. + +dnl It has been argued that this test should be broken up into two +dnl seperate tests, one for the resolver libraries, and one for the +dnl libraries necessary for using Sockets API. Unfortunately, the two +dnl are carefully intertwined and allowing the autoconf user to use +dnl them independantly potentially results in unfortunate ordering +dnl dependancies -- as such, such component macros would have to +dnl carefully use indirection and be aware if the other components were +dnl executed. Since other autoconf macros do not go to this trouble, +dnl and almost no applications use sockets without the resolver, this +dnl complexity has not been implemented. +dnl +dnl The check for libresolv is in case you are attempting to link +dnl statically and happen to have a libresolv.a lying around (and no +dnl libnsl.a). +dnl +AC_DEFUN(AC_LBL_LIBRARY_NET, [ + # Most operating systems have gethostbyname() in the default searched + # libraries (i.e. libc): + AC_CHECK_FUNC(gethostbyname, , + # Some OSes (eg. Solaris) place it in libnsl: + AC_CHECK_LIB(nsl, gethostbyname, , + # Some strange OSes (SINIX) have it in libsocket: + AC_CHECK_LIB(socket, gethostbyname, , + # Unfortunately libsocket sometimes depends on libnsl. + # AC_CHECK_LIB's API is essentially broken so the + # following ugliness is necessary: + AC_CHECK_LIB(socket, gethostbyname, + LIBS="-lsocket -lnsl $LIBS", + AC_CHECK_LIB(resolv, gethostbyname), + -lnsl)))) + AC_CHECK_FUNC(socket, , AC_CHECK_LIB(socket, socket, , + AC_CHECK_LIB(socket, socket, LIBS="-lsocket -lnsl $LIBS", , + -lnsl))) + # DLPI needs putmsg under HPUX so test for -lstr while we're at it + AC_CHECK_LIB(str, putmsg) + ]) + diff --git a/tools/missing-macros/src/m4/esd.m4 b/tools/missing-macros/src/m4/esd.m4 new file mode 100644 index 0000000000..2eaf971b36 --- /dev/null +++ b/tools/missing-macros/src/m4/esd.m4 @@ -0,0 +1,195 @@ +# Configure paths for ESD +# Manish Singh 98-9-30 +# stolen back from Frank Belew +# stolen from Manish Singh +# Shamelessly stolen from Owen Taylor + +dnl AM_PATH_ESD([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]]) +dnl Test for ESD, and define ESD_CFLAGS and ESD_LIBS +dnl +AC_DEFUN(AM_PATH_ESD, +[dnl +dnl Get the cflags and libraries from the esd-config script +dnl +AC_ARG_WITH(esd-prefix,[ --with-esd-prefix=PFX Prefix where ESD is installed (optional)], + esd_prefix="$withval", esd_prefix="") +AC_ARG_WITH(esd-exec-prefix,[ --with-esd-exec-prefix=PFX Exec prefix where ESD is installed (optional)], + esd_exec_prefix="$withval", esd_exec_prefix="") +AC_ARG_ENABLE(esdtest, [ --disable-esdtest Do not try to compile and run a test ESD program], + , enable_esdtest=yes) + + if test x$esd_exec_prefix != x ; then + esd_args="$esd_args --exec-prefix=$esd_exec_prefix" + if test x${ESD_CONFIG+set} != xset ; then + ESD_CONFIG=$esd_exec_prefix/bin/esd-config + fi + fi + if test x$esd_prefix != x ; then + esd_args="$esd_args --prefix=$esd_prefix" + if test x${ESD_CONFIG+set} != xset ; then + ESD_CONFIG=$esd_prefix/bin/esd-config + fi + fi + + AC_PATH_PROG(ESD_CONFIG, esd-config, no) + min_esd_version=ifelse([$1], ,0.2.7,$1) + AC_MSG_CHECKING(for ESD - version >= $min_esd_version) + no_esd="" + if test "$ESD_CONFIG" = "no" ; then + no_esd=yes + else + AC_LANG_SAVE + AC_LANG_C + ESD_CFLAGS=`$ESD_CONFIG $esdconf_args --cflags` + ESD_LIBS=`$ESD_CONFIG $esdconf_args --libs` + + esd_major_version=`$ESD_CONFIG $esd_args --version | \ + sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'` + esd_minor_version=`$ESD_CONFIG $esd_args --version | \ + sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'` + esd_micro_version=`$ESD_CONFIG $esd_config_args --version | \ + sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'` + if test "x$enable_esdtest" = "xyes" ; then + ac_save_CFLAGS="$CFLAGS" + ac_save_LIBS="$LIBS" + CFLAGS="$CFLAGS $ESD_CFLAGS" + LIBS="$LIBS $ESD_LIBS" +dnl +dnl Now check if the installed ESD is sufficiently new. (Also sanity +dnl checks the results of esd-config to some extent +dnl + rm -f conf.esdtest + AC_TRY_RUN([ +#include +#include +#include +#include + +char* +my_strdup (char *str) +{ + char *new_str; + + if (str) + { + new_str = malloc ((strlen (str) + 1) * sizeof(char)); + strcpy (new_str, str); + } + else + new_str = NULL; + + return new_str; +} + +int main () +{ + int major, minor, micro; + char *tmp_version; + + system ("touch conf.esdtest"); + + /* HP/UX 9 (%@#!) writes to sscanf strings */ + tmp_version = my_strdup("$min_esd_version"); + if (sscanf(tmp_version, "%d.%d.%d", &major, &minor, µ) != 3) { + printf("%s, bad version string\n", "$min_esd_version"); + exit(1); + } + + if (($esd_major_version > major) || + (($esd_major_version == major) && ($esd_minor_version > minor)) || + (($esd_major_version == major) && ($esd_minor_version == minor) && ($esd_micro_version >= micro))) + { + return 0; + } + else + { + printf("\n*** 'esd-config --version' returned %d.%d.%d, but the minimum version\n", $esd_major_version, $esd_minor_version, $esd_micro_version); + printf("*** of ESD required is %d.%d.%d. If esd-config is correct, then it is\n", major, minor, micro); + printf("*** best to upgrade to the required version.\n"); + printf("*** If esd-config was wrong, set the environment variable ESD_CONFIG\n"); + printf("*** to point to the correct copy of esd-config, and remove the file\n"); + printf("*** config.cache before re-running configure\n"); + return 1; + } +} + +],, no_esd=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"]) + CFLAGS="$ac_save_CFLAGS" + LIBS="$ac_save_LIBS" + AC_LANG_RESTORE + fi + fi + if test "x$no_esd" = x ; then + AC_MSG_RESULT(yes) + ifelse([$2], , :, [$2]) + else + AC_MSG_RESULT(no) + if test "$ESD_CONFIG" = "no" ; then + echo "*** The esd-config script installed by ESD could not be found" + echo "*** If ESD was installed in PREFIX, make sure PREFIX/bin is in" + echo "*** your path, or set the ESD_CONFIG environment variable to the" + echo "*** full path to esd-config." + else + if test -f conf.esdtest ; then + : + else + echo "*** Could not run ESD test program, checking why..." + CFLAGS="$CFLAGS $ESD_CFLAGS" + LIBS="$LIBS $ESD_LIBS" + AC_LANG_SAVE + AC_LANG_C + AC_TRY_LINK([ +#include +#include +], [ return 0; ], + [ echo "*** The test program compiled, but did not run. This usually means" + echo "*** that the run-time linker is not finding ESD or finding the wrong" + echo "*** version of ESD. If it is not finding ESD, you'll need to set your" + echo "*** LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf to point" + echo "*** to the installed location Also, make sure you have run ldconfig if that" + echo "*** is required on your system" + echo "***" + echo "*** If you have an old version installed, it is best to remove it, although" + echo "*** you may also be able to get things to work by modifying LD_LIBRARY_PATH"], + [ echo "*** The test program failed to compile or link. See the file config.log for the" + echo "*** exact error that occured. This usually means ESD was incorrectly installed" + echo "*** or that you have moved ESD since it was installed. In the latter case, you" + echo "*** may want to edit the esd-config script: $ESD_CONFIG" ]) + CFLAGS="$ac_save_CFLAGS" + LIBS="$ac_save_LIBS" + AC_LANG_RESTORE + fi + fi + ESD_CFLAGS="" + ESD_LIBS="" + ifelse([$3], , :, [$3]) + fi + AC_SUBST(ESD_CFLAGS) + AC_SUBST(ESD_LIBS) + rm -f conf.esdtest +]) + +dnl AM_ESD_SUPPORTS_MULTIPLE_RECORD([ACTION-IF-SUPPORTS [, ACTION-IF-NOT-SUPPORTS]]) +dnl Test, whether esd supports multiple recording clients (version >=0.2.21) +dnl +AC_DEFUN(AM_ESD_SUPPORTS_MULTIPLE_RECORD, +[dnl + AC_MSG_NOTICE([whether installed esd version supports multiple recording clients]) + ac_save_ESD_CFLAGS="$ESD_CFLAGS" + ac_save_ESD_LIBS="$ESD_LIBS" + AM_PATH_ESD(0.2.21, + ifelse([$1], , [ + AM_CONDITIONAL(ESD_SUPPORTS_MULTIPLE_RECORD, true) + AC_DEFINE(ESD_SUPPORTS_MULTIPLE_RECORD, 1, + [Define if you have esound with support of multiple recording clients.])], + [$1]), + ifelse([$2], , [AM_CONDITIONAL(ESD_SUPPORTS_MULTIPLE_RECORD, false)], [$2]) + if test "x$ac_save_ESD_CFLAGS" != x ; then + ESD_CFLAGS="$ac_save_ESD_CFLAGS" + fi + if test "x$ac_save_ESD_LIBS" != x ; then + ESD_LIBS="$ac_save_ESD_LIBS" + fi + ) +]) + diff --git a/tools/missing-macros/src/m4/fake-gtk-doc-check.m4 b/tools/missing-macros/src/m4/fake-gtk-doc-check.m4 new file mode 100644 index 0000000000..b4954dda00 --- /dev/null +++ b/tools/missing-macros/src/m4/fake-gtk-doc-check.m4 @@ -0,0 +1,5 @@ +dnl fake-gtk-doc-check.m4 serial 1 (OpenWrt) +dnl Provide a fake GTK_DOC_CHECK macros which +dnl always defines false. + +AC_DEFUN([GTK_DOC_CHECK],[AM_CONDITIONAL(ENABLE_GTK_DOC,false)]) diff --git a/tools/missing-macros/src/m4/glibc2.m4 b/tools/missing-macros/src/m4/glibc2.m4 new file mode 100644 index 0000000000..f148c12c45 --- /dev/null +++ b/tools/missing-macros/src/m4/glibc2.m4 @@ -0,0 +1,30 @@ +# glibc2.m4 serial 2 +dnl Copyright (C) 2000-2002, 2004, 2008-2010 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. + +# Test for the GNU C Library, version 2.0 or newer. +# From Bruno Haible. + +AC_DEFUN([gt_GLIBC2], + [ + AC_CACHE_CHECK([whether we are using the GNU C Library 2 or newer], + [ac_cv_gnu_library_2], + [AC_EGREP_CPP([Lucky GNU user], + [ +#include +#ifdef __GNU_LIBRARY__ + #if (__GLIBC__ >= 2) + Lucky GNU user + #endif +#endif + ], + [ac_cv_gnu_library_2=yes], + [ac_cv_gnu_library_2=no]) + ] + ) + AC_SUBST([GLIBC2]) + GLIBC2="$ac_cv_gnu_library_2" + ] +) diff --git a/tools/missing-macros/src/m4/glibc21.m4 b/tools/missing-macros/src/m4/glibc21.m4 new file mode 100644 index 0000000000..68ada9d4d5 --- /dev/null +++ b/tools/missing-macros/src/m4/glibc21.m4 @@ -0,0 +1,30 @@ +# glibc21.m4 serial 4 +dnl Copyright (C) 2000-2002, 2004, 2008-2010 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. + +# Test for the GNU C Library, version 2.1 or newer. +# From Bruno Haible. + +AC_DEFUN([gl_GLIBC21], + [ + AC_CACHE_CHECK([whether we are using the GNU C Library 2.1 or newer], + [ac_cv_gnu_library_2_1], + [AC_EGREP_CPP([Lucky GNU user], + [ +#include +#ifdef __GNU_LIBRARY__ + #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2) + Lucky GNU user + #endif +#endif + ], + [ac_cv_gnu_library_2_1=yes], + [ac_cv_gnu_library_2_1=no]) + ] + ) + AC_SUBST([GLIBC21]) + GLIBC21="$ac_cv_gnu_library_2_1" + ] +) diff --git a/tools/missing-macros/src/m4/intdiv0.m4 b/tools/missing-macros/src/m4/intdiv0.m4 new file mode 100644 index 0000000000..289c4df5ed --- /dev/null +++ b/tools/missing-macros/src/m4/intdiv0.m4 @@ -0,0 +1,84 @@ +# intdiv0.m4 serial 3 (gettext-0.18) +dnl Copyright (C) 2002, 2007-2010 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. + +dnl From Bruno Haible. + +AC_DEFUN([gt_INTDIV0], +[ + AC_REQUIRE([AC_PROG_CC])dnl + AC_REQUIRE([AC_CANONICAL_HOST])dnl + + AC_CACHE_CHECK([whether integer division by zero raises SIGFPE], + gt_cv_int_divbyzero_sigfpe, + [ + gt_cv_int_divbyzero_sigfpe= +changequote(,)dnl + case "$host_os" in + macos* | darwin[6-9]* | darwin[1-9][0-9]*) + # On MacOS X 10.2 or newer, just assume the same as when cross- + # compiling. If we were to perform the real test, 1 Crash Report + # dialog window would pop up. + case "$host_cpu" in + i[34567]86 | x86_64) + gt_cv_int_divbyzero_sigfpe="guessing yes" ;; + esac + ;; + esac +changequote([,])dnl + if test -z "$gt_cv_int_divbyzero_sigfpe"; then + AC_TRY_RUN([ +#include +#include + +static void +sigfpe_handler (int sig) +{ + /* Exit with code 0 if SIGFPE, with code 1 if any other signal. */ + exit (sig != SIGFPE); +} + +int x = 1; +int y = 0; +int z; +int nan; + +int main () +{ + signal (SIGFPE, sigfpe_handler); +/* IRIX and AIX (when "xlc -qcheck" is used) yield signal SIGTRAP. */ +#if (defined (__sgi) || defined (_AIX)) && defined (SIGTRAP) + signal (SIGTRAP, sigfpe_handler); +#endif +/* Linux/SPARC yields signal SIGILL. */ +#if defined (__sparc__) && defined (__linux__) + signal (SIGILL, sigfpe_handler); +#endif + + z = x / y; + nan = y / y; + exit (1); +} +], [gt_cv_int_divbyzero_sigfpe=yes], [gt_cv_int_divbyzero_sigfpe=no], + [ + # Guess based on the CPU. +changequote(,)dnl + case "$host_cpu" in + alpha* | i[34567]86 | x86_64 | m68k | s390*) + gt_cv_int_divbyzero_sigfpe="guessing yes";; + *) + gt_cv_int_divbyzero_sigfpe="guessing no";; + esac +changequote([,])dnl + ]) + fi + ]) + case "$gt_cv_int_divbyzero_sigfpe" in + *yes) value=1;; + *) value=0;; + esac + AC_DEFINE_UNQUOTED([INTDIV0_RAISES_SIGFPE], [$value], + [Define if integer division by zero raises signal SIGFPE.]) +]) diff --git a/tools/missing-macros/src/m4/intmax.m4 b/tools/missing-macros/src/m4/intmax.m4 new file mode 100644 index 0000000000..74aaaf5ed6 --- /dev/null +++ b/tools/missing-macros/src/m4/intmax.m4 @@ -0,0 +1,33 @@ +# intmax.m4 serial 5 (gettext-0.18) +dnl Copyright (C) 2002-2005, 2008-2010 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. + +dnl From Bruno Haible. +dnl Test whether the system has the 'intmax_t' type, but don't attempt to +dnl find a replacement if it is lacking. + +AC_DEFUN([gt_TYPE_INTMAX_T], +[ + AC_REQUIRE([gl_AC_HEADER_INTTYPES_H]) + AC_REQUIRE([gl_AC_HEADER_STDINT_H]) + AC_CACHE_CHECK([for intmax_t], [gt_cv_c_intmax_t], + [AC_TRY_COMPILE([ +#include +#include +#if HAVE_STDINT_H_WITH_UINTMAX +#include +#endif +#if HAVE_INTTYPES_H_WITH_UINTMAX +#include +#endif +], [intmax_t x = -1; + return !x;], + [gt_cv_c_intmax_t=yes], + [gt_cv_c_intmax_t=no])]) + if test $gt_cv_c_intmax_t = yes; then + AC_DEFINE([HAVE_INTMAX_T], [1], + [Define if you have the 'intmax_t' type in or .]) + fi +]) diff --git a/tools/missing-macros/src/m4/inttypes-pri.m4 b/tools/missing-macros/src/m4/inttypes-pri.m4 new file mode 100644 index 0000000000..718a4f4e19 --- /dev/null +++ b/tools/missing-macros/src/m4/inttypes-pri.m4 @@ -0,0 +1,36 @@ +# inttypes-pri.m4 serial 6 (gettext-0.18) +dnl Copyright (C) 1997-2002, 2006, 2008-2010 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. + +dnl From Bruno Haible. + +AC_PREREQ([2.52]) + +# Define PRI_MACROS_BROKEN if exists and defines the PRI* +# macros to non-string values. This is the case on AIX 4.3.3. + +AC_DEFUN([gt_INTTYPES_PRI], +[ + AC_CHECK_HEADERS([inttypes.h]) + if test $ac_cv_header_inttypes_h = yes; then + AC_CACHE_CHECK([whether the inttypes.h PRIxNN macros are broken], + [gt_cv_inttypes_pri_broken], + [ + AC_TRY_COMPILE([#include +#ifdef PRId32 +char *p = PRId32; +#endif +], [], [gt_cv_inttypes_pri_broken=no], [gt_cv_inttypes_pri_broken=yes]) + ]) + fi + if test "$gt_cv_inttypes_pri_broken" = yes; then + AC_DEFINE_UNQUOTED([PRI_MACROS_BROKEN], [1], + [Define if exists and defines unusable PRI* macros.]) + PRI_MACROS_BROKEN=1 + else + PRI_MACROS_BROKEN=0 + fi + AC_SUBST([PRI_MACROS_BROKEN]) +]) diff --git a/tools/missing-macros/src/m4/inttypes_h.m4 b/tools/missing-macros/src/m4/inttypes_h.m4 new file mode 100644 index 0000000000..782d77ed8b --- /dev/null +++ b/tools/missing-macros/src/m4/inttypes_h.m4 @@ -0,0 +1,26 @@ +# inttypes_h.m4 serial 9 +dnl Copyright (C) 1997-2004, 2006, 2008-2010 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. + +dnl From Paul Eggert. + +# Define HAVE_INTTYPES_H_WITH_UINTMAX if exists, +# doesn't clash with , and declares uintmax_t. + +AC_DEFUN([gl_AC_HEADER_INTTYPES_H], +[ + AC_CACHE_CHECK([for inttypes.h], [gl_cv_header_inttypes_h], + [AC_TRY_COMPILE( + [#include +#include ], + [uintmax_t i = (uintmax_t) -1; return !i;], + [gl_cv_header_inttypes_h=yes], + [gl_cv_header_inttypes_h=no])]) + if test $gl_cv_header_inttypes_h = yes; then + AC_DEFINE_UNQUOTED([HAVE_INTTYPES_H_WITH_UINTMAX], [1], + [Define if exists, doesn't clash with , + and declares uintmax_t. ]) + fi +]) diff --git a/tools/missing-macros/src/m4/progtest.m4 b/tools/missing-macros/src/m4/progtest.m4 new file mode 100644 index 0000000000..2d804ac99d --- /dev/null +++ b/tools/missing-macros/src/m4/progtest.m4 @@ -0,0 +1,92 @@ +# progtest.m4 serial 6 (gettext-0.18) +dnl Copyright (C) 1996-2003, 2005, 2008-2010 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. +dnl +dnl This file can can be used in projects which are not available under +dnl the GNU General Public License or the GNU Library General Public +dnl License but which still want to provide support for the GNU gettext +dnl functionality. +dnl Please note that the actual code of the GNU gettext library is covered +dnl by the GNU Library General Public License, and the rest of the GNU +dnl gettext package package is covered by the GNU General Public License. +dnl They are *not* in the public domain. + +dnl Authors: +dnl Ulrich Drepper , 1996. + +AC_PREREQ([2.50]) + +# Search path for a program which passes the given test. + +dnl AM_PATH_PROG_WITH_TEST(VARIABLE, PROG-TO-CHECK-FOR, +dnl TEST-PERFORMED-ON-FOUND_PROGRAM [, VALUE-IF-NOT-FOUND [, PATH]]) +AC_DEFUN([AM_PATH_PROG_WITH_TEST], +[ +# Prepare PATH_SEPARATOR. +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + echo "#! /bin/sh" >conf$$.sh + echo "exit 0" >>conf$$.sh + chmod +x conf$$.sh + if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then + PATH_SEPARATOR=';' + else + PATH_SEPARATOR=: + fi + rm -f conf$$.sh +fi + +# Find out how to test for executable files. Don't use a zero-byte file, +# as systems may use methods other than mode bits to determine executability. +cat >conf$$.file <<_ASEOF +#! /bin/sh +exit 0 +_ASEOF +chmod +x conf$$.file +if test -x conf$$.file >/dev/null 2>&1; then + ac_executable_p="test -x" +else + ac_executable_p="test -f" +fi +rm -f conf$$.file + +# Extract the first word of "$2", so it can be a program name with args. +set dummy $2; ac_word=[$]2 +AC_MSG_CHECKING([for $ac_word]) +AC_CACHE_VAL([ac_cv_path_$1], +[case "[$]$1" in + [[\\/]]* | ?:[[\\/]]*) + ac_cv_path_$1="[$]$1" # Let the user override the test with a path. + ;; + *) + ac_save_IFS="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in ifelse([$5], , $PATH, [$5]); do + IFS="$ac_save_IFS" + test -z "$ac_dir" && ac_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $ac_executable_p "$ac_dir/$ac_word$ac_exec_ext"; then + echo "$as_me: trying $ac_dir/$ac_word..." >&AS_MESSAGE_LOG_FD + if [$3]; then + ac_cv_path_$1="$ac_dir/$ac_word$ac_exec_ext" + break 2 + fi + fi + done + done + IFS="$ac_save_IFS" +dnl If no 4th arg is given, leave the cache variable unset, +dnl so AC_PATH_PROGS will keep looking. +ifelse([$4], , , [ test -z "[$]ac_cv_path_$1" && ac_cv_path_$1="$4" +])dnl + ;; +esac])dnl +$1="$ac_cv_path_$1" +if test ifelse([$4], , [-n "[$]$1"], ["[$]$1" != "$4"]); then + AC_MSG_RESULT([$][$1]) +else + AC_MSG_RESULT([no]) +fi +AC_SUBST([$1])dnl +]) diff --git a/tools/missing-macros/src/m4/stdint_h.m4 b/tools/missing-macros/src/m4/stdint_h.m4 new file mode 100644 index 0000000000..b8e3c6cc71 --- /dev/null +++ b/tools/missing-macros/src/m4/stdint_h.m4 @@ -0,0 +1,26 @@ +# stdint_h.m4 serial 8 +dnl Copyright (C) 1997-2004, 2006, 2008-2010 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. + +dnl From Paul Eggert. + +# Define HAVE_STDINT_H_WITH_UINTMAX if exists, +# doesn't clash with , and declares uintmax_t. + +AC_DEFUN([gl_AC_HEADER_STDINT_H], +[ + AC_CACHE_CHECK([for stdint.h], [gl_cv_header_stdint_h], + [AC_TRY_COMPILE( + [#include +#include ], + [uintmax_t i = (uintmax_t) -1; return !i;], + [gl_cv_header_stdint_h=yes], + [gl_cv_header_stdint_h=no])]) + if test $gl_cv_header_stdint_h = yes; then + AC_DEFINE_UNQUOTED([HAVE_STDINT_H_WITH_UINTMAX], [1], + [Define if exists, doesn't clash with , + and declares uintmax_t. ]) + fi +]) diff --git a/tools/missing-macros/src/m4/uintmax_t.m4 b/tools/missing-macros/src/m4/uintmax_t.m4 new file mode 100644 index 0000000000..03b51bcfe3 --- /dev/null +++ b/tools/missing-macros/src/m4/uintmax_t.m4 @@ -0,0 +1,30 @@ +# uintmax_t.m4 serial 12 +dnl Copyright (C) 1997-2004, 2007-2010 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. + +dnl From Paul Eggert. + +AC_PREREQ([2.13]) + +# Define uintmax_t to 'unsigned long' or 'unsigned long long' +# if it is not already defined in or . + +AC_DEFUN([gl_AC_TYPE_UINTMAX_T], +[ + AC_REQUIRE([gl_AC_HEADER_INTTYPES_H]) + AC_REQUIRE([gl_AC_HEADER_STDINT_H]) + if test $gl_cv_header_inttypes_h = no && test $gl_cv_header_stdint_h = no; then + AC_REQUIRE([AC_TYPE_UNSIGNED_LONG_LONG_INT]) + test $ac_cv_type_unsigned_long_long_int = yes \ + && ac_type='unsigned long long' \ + || ac_type='unsigned long' + AC_DEFINE_UNQUOTED([uintmax_t], [$ac_type], + [Define to unsigned long or unsigned long long + if and don't define.]) + else + AC_DEFINE([HAVE_UINTMAX_T], [1], + [Define if you have the 'uintmax_t' type in or .]) + fi +]) diff --git a/tools/missing-macros/src/m4/va_copy.m4 b/tools/missing-macros/src/m4/va_copy.m4 new file mode 100644 index 0000000000..b8fbf3685e --- /dev/null +++ b/tools/missing-macros/src/m4/va_copy.m4 @@ -0,0 +1,109 @@ +dnl ## +dnl ## Check for C99 va_copy() implementation +dnl ## (and provide fallback implementation if neccessary) +dnl ## +dnl ## configure.in: +dnl ## AC_CHECK_VA_COPY +dnl ## foo.c: +dnl ## #include "config.h" +dnl ## [...] +dnl ## va_copy(d,s) +dnl ## +dnl ## This check is rather complex: first because we really have to +dnl ## try various possible implementations in sequence and second, we +dnl ## cannot define a macro in config.h with parameters directly. +dnl ## + +dnl # test program for va_copy() implementation +changequote(<<,>>) +m4_define(__va_copy_test, <<[ +#include +#include +#include +#define DO_VA_COPY(d, s) $1 +void test(char *str, ...) +{ + va_list ap, ap2; + int i; + va_start(ap, str); + DO_VA_COPY(ap2, ap); + for (i = 1; i <= 9; i++) { + int k = (int)va_arg(ap, int); + if (k != i) + abort(); + } + DO_VA_COPY(ap, ap2); + for (i = 1; i <= 9; i++) { + int k = (int)va_arg(ap, int); + if (k != i) + abort(); + } + va_end(ap); +} +int main(int argc, char *argv[]) +{ + test("test", 1, 2, 3, 4, 5, 6, 7, 8, 9); + exit(0); +} +]>>) +changequote([,]) + +dnl # test driver for va_copy() implementation +m4_define(__va_copy_check, [ + AH_VERBATIM($1, +[/* Predefined possible va_copy() implementation (id: $1) */ +#define __VA_COPY_USE_$1(d, s) $2]) + if test ".$ac_cv_va_copy" = .; then + AC_TRY_RUN(__va_copy_test($2), [ac_cv_va_copy="$1"]) + fi +]) + +dnl # Autoconf check for va_copy() implementation checking +AC_DEFUN(AC_CHECK_VA_COPY,[ + dnl # provide Autoconf display check message + AC_MSG_CHECKING(for va_copy() function) + dnl # check for various implementations in priorized sequence + AC_CACHE_VAL(ac_cv_va_copy, [ + ac_cv_va_copy="" + dnl # 1. check for standardized C99 macro + __va_copy_check(C99, [va_copy((d), (s))]) + dnl # 2. check for alternative/deprecated GCC macro + __va_copy_check(GCM, [VA_COPY((d), (s))]) + dnl # 3. check for internal GCC macro (high-level define) + __va_copy_check(GCH, [__va_copy((d), (s))]) + dnl # 4. check for internal GCC macro (built-in function) + __va_copy_check(GCB, [__builtin_va_copy((d), (s))]) + dnl # 5. check for assignment approach (assuming va_list is a struct) + __va_copy_check(ASS, [do { (d) = (s); } while (0)]) + dnl # 6. check for assignment approach (assuming va_list is a pointer) + __va_copy_check(ASP, [do { *(d) = *(s); } while (0)]) + dnl # 7. check for memory copying approach (assuming va_list is a struct) + __va_copy_check(CPS, [memcpy((void *)&(d), (void *)&(s)), sizeof((s))]) + dnl # 8. check for memory copying approach (assuming va_list is a pointer) + __va_copy_check(CPP, [memcpy((void *)(d), (void *)(s)), sizeof(*(s))]) + if test ".$ac_cv_va_copy" = .; then + AC_ERROR([no working implementation found]) + fi + ]) + dnl # optionally activate the fallback implementation + if test ".$ac_cv_va_copy" = ".C99"; then + AC_DEFINE(HAVE_VA_COPY, 1, [Define if va_copy() macro exists (and no fallback implementation is required)]) + fi + dnl # declare which fallback implementation to actually use + AC_DEFINE_UNQUOTED([__VA_COPY_USE], [__VA_COPY_USE_$ac_cv_va_copy], + [Define to id of used va_copy() implementation]) + dnl # provide activation hook for fallback implementation + AH_VERBATIM([__VA_COPY_ACTIVATION], +[/* Optional va_copy() implementation activation */ +#ifndef HAVE_VA_COPY +#define va_copy(d, s) __VA_COPY_USE(d, s) +#endif +]) + dnl # provide Autoconf display result message + if test ".$ac_cv_va_copy" = ".C99"; then + AC_MSG_RESULT([yes]) + else + AC_MSG_RESULT([no (using fallback implementation)]) + fi +]) + diff --git a/tools/missing-macros/src/m4/wint_t.m4 b/tools/missing-macros/src/m4/wint_t.m4 new file mode 100644 index 0000000000..a6c7d15cb5 --- /dev/null +++ b/tools/missing-macros/src/m4/wint_t.m4 @@ -0,0 +1,28 @@ +# wint_t.m4 serial 4 (gettext-0.18) +dnl Copyright (C) 2003, 2007-2010 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. + +dnl From Bruno Haible. +dnl Test whether has the 'wint_t' type. +dnl Prerequisite: AC_PROG_CC + +AC_DEFUN([gt_TYPE_WINT_T], +[ + AC_CACHE_CHECK([for wint_t], [gt_cv_c_wint_t], + [AC_TRY_COMPILE([ +/* Tru64 with Desktop Toolkit C has a bug: must be included before + . + BSD/OS 4.0.1 has a bug: , and must be included + before . */ +#include +#include +#include +#include + wint_t foo = (wchar_t)'\0';], , + [gt_cv_c_wint_t=yes], [gt_cv_c_wint_t=no])]) + if test $gt_cv_c_wint_t = yes; then + AC_DEFINE([HAVE_WINT_T], [1], [Define if you have the 'wint_t' type.]) + fi +])