generic-library/libzmq
1
0
Fork 0
mirror of https://github.com/zeromq/libzmq.git synced 2024-12-12 18:40:27 +01:00
Code Issues Projects Releases Wiki Activity

Prefix variables with "ac_zmq_"

Browse Source 
- Added a macro for checking clang compiler
 - Moved basic compiler checks to a macro
 - Added a macro for checking if compiler supports a flag
 - Added --enable-debug flag
 - Added a macro for running normal autoconf check with compiler flags
 - Added a macro for checking for verbose flag for different compilers (-Wall)
 - Added a macro for turning on strict standards compliance
 - Added a macro for turning warnings to errors
 - Added a macro for checking if compiler supports given pragma
 - Most of the flags now go through checks if the compilers supports them
   rather than enumerating different compilers
 - Added DSO symbol visibility for sun compiler
 - Enabled verbose mode for sun compiler
 - Fixed build for ICC 12.x by adding -wd279 to size_t checks
 - Removed pkg-config checks as those don't seem to be used anywhere

Signed-off-by: Mikko Koppanen <mkoppanen@php.net>
This commit is contained in:
Mikko Koppanen 2010-12-01 10:33:07 +01:00 committed by Martin Sustrik
parent 17d7e6ede0
commit 5bb0a339be
5 changed files with 532 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

461
acinclude.m4
View File

@ -1,12 +1,9 @@
dnl ############################################################################## dnl ##############################################################################
dnl # AC_CONFIG_LIBTOOL # dnl # AC_ZMQ_CONFIG_LIBTOOL #
dnl # Configure libtool. $host_os needs to be set before calling this macro # dnl # Configure libtool. Requires AC_CANONICAL_HOST #
dnl ############################################################################## dnl ##############################################################################
AC_DEFUN([AC_CONFIG_LIBTOOL], [{ AC_DEFUN([AC_ZMQ_CONFIG_LIBTOOL], [{
AC_REQUIRE([AC_CANONICAL_HOST])
if test "x${host_os}" = "x"; then
AC_MSG_ERROR([AC@&t@_CANONICAL_HOST not called before calling AC@&t@_CONFIG_LIBTOOL])
fi
# Libtool configuration for different targets # Libtool configuration for different targets
case "${host_os}" in case "${host_os}" in
@ -21,101 +18,479 @@ AC_DEFUN([AC_CONFIG_LIBTOOL], [{
esac esac
}]) }])
dnl ############################################################################## dnl ##############################################################################
dnl # AC_CHECK_LANG_ICC # dnl # AC_ZMQ_CHECK_LANG_ICC([action-if-found], [action-if-not-found]) #
dnl # Check if the current language is compiled using ICC # dnl # Check if the current language is compiled using ICC #
dnl # Adapted from http://software.intel.com/en-us/forums/showthread.php?t=67984 # dnl # Adapted from http://software.intel.com/en-us/forums/showthread.php?t=67984 #
dnl ############################################################################## dnl ##############################################################################
AC_DEFUN([AC_CHECK_LANG_ICC], AC_DEFUN([AC_ZMQ_CHECK_LANG_ICC],
[AC_CACHE_CHECK([whether we are using Intel _AC_LANG compiler], [AC_CACHE_CHECK([whether we are using Intel _AC_LANG compiler],
[ac_cv_[]_AC_LANG_ABBREV[]_intel_compiler], [ac_zmq_cv_[]_AC_LANG_ABBREV[]_intel_compiler],
[_AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [_AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
[[#ifndef __INTEL_COMPILER [[#ifndef __INTEL_COMPILER
error if not ICC error if not ICC
#endif #endif
]])], ]])],
[is_icc=yes], [ac_zmq_cv_[]_AC_LANG_ABBREV[]_intel_compiler="yes" ; $1],
[is_icc=no]) [ac_zmq_cv_[]_AC_LANG_ABBREV[]_intel_compiler="no" ; $2])
ac_cv_[]_AC_LANG_ABBREV[]_intel_compiler=$is_icc
])]) ])])
dnl ############################################################################## dnl ##############################################################################
dnl # AC_CHECK_LANG_SUN_STUDIO # dnl # AC_ZMQ_CHECK_LANG_SUN_STUDIO([action-if-found], [action-if-not-found]) #
dnl # Check if the current language is compiled using Sun Studio # dnl # Check if the current language is compiled using Sun Studio #
dnl ############################################################################## dnl ##############################################################################
AC_DEFUN([AC_CHECK_LANG_SUN_STUDIO], AC_DEFUN([AC_ZMQ_CHECK_LANG_SUN_STUDIO],
[AC_CACHE_CHECK([whether we are using Sun Studio _AC_LANG compiler], [AC_CACHE_CHECK([whether we are using Sun Studio _AC_LANG compiler],
[ac_cv_[]_AC_LANG_ABBREV[]_sun_studio_compiler], [ac_zmq_cv_[]_AC_LANG_ABBREV[]_sun_studio_compiler],
[_AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [_AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
[[#if !defined(__SUNPRO_CC) && !defined(__SUNPRO_C) [[#if !defined(__SUNPRO_CC) && !defined(__SUNPRO_C)
error if not sun studio error if not sun studio
#endif #endif
]])], ]])],
[is_sun_studio=yes], [ac_zmq_cv_[]_AC_LANG_ABBREV[]_sun_studio_compiler="yes" ; $1],
[is_sun_studio=no]) [ac_zmq_cv_[]_AC_LANG_ABBREV[]_sun_studio_compiler="no" ; $2])
ac_cv_[]_AC_LANG_ABBREV[]_sun_studio_compiler=$is_sun_studio
])]) ])])
dnl ############################################################################## dnl ##############################################################################
dnl # AC_CHECK_DOC_BUILD # dnl # AC_ZMQ_CHECK_LANG_CLANG([action-if-found], [action-if-not-found]) #
dnl # Check if the current language is compiled using clang #
dnl ##############################################################################
AC_DEFUN([AC_ZMQ_CHECK_LANG_CLANG],
[AC_CACHE_CHECK([whether we are using clang _AC_LANG compiler],
[ac_zmq_cv_[]_AC_LANG_ABBREV[]_clang_compiler],
[_AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
[[#ifndef __clang__
error if not clang
#endif
]])],
[ac_zmq_cv_[]_AC_LANG_ABBREV[]_clang_compiler="yes" ; $1],
[ac_zmq_cv_[]_AC_LANG_ABBREV[]_clang_compiler="no" ; $2])
])])
dnl ##############################################################################
dnl # AC_ZMQ_CHECK_DOC_BUILD #
dnl # Check whether to build documentation and install man-pages # dnl # Check whether to build documentation and install man-pages #
dnl ############################################################################## dnl ##############################################################################
AC_DEFUN([AC_CHECK_DOC_BUILD], [{ AC_DEFUN([AC_ZMQ_CHECK_DOC_BUILD], [{
# Allow user to disable doc build # Allow user to disable doc build
AC_ARG_WITH([documentation], [AS_HELP_STRING([--without-documentation], AC_ARG_WITH([documentation], [AS_HELP_STRING([--without-documentation],
[disable documentation build even if asciidoc and xmlto are present [default=no]])]) [disable documentation build even if asciidoc and xmlto are present [default=no]])])
if test "x$with_documentation" = "xno"; then if test "x$with_documentation" = "xno"; then
build_doc="no" ac_zmq_build_doc="no"
install_man="no" ac_zmq_install_man="no"
else else
# Determine whether or not documentation should be built and installed. # Determine whether or not documentation should be built and installed.
build_doc="yes" ac_zmq_build_doc="yes"
install_man="yes" ac_zmq_install_man="yes"
# Check for asciidoc and xmlto and don't build the docs if these are not installed. # Check for asciidoc and xmlto and don't build the docs if these are not installed.
AC_CHECK_PROG(have_asciidoc, asciidoc, yes, no) AC_CHECK_PROG(ac_zmq_have_asciidoc, asciidoc, yes, no)
AC_CHECK_PROG(have_xmlto, xmlto, yes, no) AC_CHECK_PROG(ac_zmq_have_xmlto, xmlto, yes, no)
if test "x$have_asciidoc" = "xno" -o "x$have_xmlto" = "xno"; then if test "x$ac_zmq_have_asciidoc" = "xno" -o "x$ac_zmq_have_xmlto" = "xno"; then
build_doc="no" ac_zmq_build_doc="no"
# Tarballs built with 'make dist' ship with prebuilt documentation. # Tarballs built with 'make dist' ship with prebuilt documentation.
if ! test -f doc/zmq.7; then if ! test -f doc/zmq.7; then
install_man="no" ac_zmq_install_man="no"
AC_MSG_WARN([You are building an unreleased version of 0MQ and asciidoc or xmlto are not installed.]) AC_MSG_WARN([You are building an unreleased version of 0MQ and asciidoc or xmlto are not installed.])
AC_MSG_WARN([Documentation will not be built and manual pages will not be installed.]) AC_MSG_WARN([Documentation will not be built and manual pages will not be installed.])
fi fi
fi fi
# Do not install man pages if on mingw # Do not install man pages if on mingw
if test "x$on_mingw32" = "xyes"; then if test "x$ac_zmq_on_mingw32" = "xyes"; then
install_man="no" ac_zmq_install_man="no"
fi fi
fi fi
AC_MSG_CHECKING([whether to build documentation]) AC_MSG_CHECKING([whether to build documentation])
AC_MSG_RESULT([$build_doc]) AC_MSG_RESULT([$ac_zmq_build_doc])
AC_MSG_CHECKING([whether to install manpages]) AC_MSG_CHECKING([whether to install manpages])
AC_MSG_RESULT([$install_man]) AC_MSG_RESULT([$ac_zmq_install_man])
AM_CONDITIONAL(BUILD_DOC, test "x$build_doc" = "xyes") AM_CONDITIONAL(BUILD_DOC, test "x$ac_zmq_build_doc" = "xyes")
AM_CONDITIONAL(INSTALL_MAN, test "x$install_man" = "xyes") AM_CONDITIONAL(INSTALL_MAN, test "x$ac_zmq_install_man" = "xyes")
}]) }])
dnl ############################################################################## dnl ##############################################################################
dnl # AC_CHECK_LANG_COMPILER # dnl # AC_ZMQ_CHECK_LANG_COMPILER([action-if-found], [action-if-not-found]) #
dnl # Check that compiler for the current language actually works # dnl # Check that compiler for the current language actually works #
dnl ############################################################################## dnl ##############################################################################
AC_DEFUN([AC_CHECK_LANG_COMPILER], [{ AC_DEFUN([AC_ZMQ_CHECK_LANG_COMPILER], [{
# Test that compiler for the current language actually works # Test that compiler for the current language actually works
AC_CACHE_CHECK([whether the _AC_LANG compiler works], AC_CACHE_CHECK([whether the _AC_LANG compiler works],
[ac_cv_[]_AC_LANG_ABBREV[]_compiler_works], [ac_zmq_cv_[]_AC_LANG_ABBREV[]_compiler_works],
[AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])], [AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])],
[ac_cv_[]_AC_LANG_ABBREV[]_compiler_works=yes], [ac_zmq_cv_[]_AC_LANG_ABBREV[]_compiler_works="yes" ; $1],
[ac_cv_[]_AC_LANG_ABBREV[]_compiler_works=no]) [ac_zmq_cv_[]_AC_LANG_ABBREV[]_compiler_works="no" ; $2])
]) ])
if test "x$ac_cv_[]_AC_LANG_ABBREV[]_compiler_works" != "xyes"; then if test "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_compiler_works" != "xyes"; then
AC_MSG_ERROR([Unable to find a working _AC_LANG compiler]) AC_MSG_ERROR([Unable to find a working _AC_LANG compiler])
fi fi
}]) }])
dnl ##############################################################################
dnl # AC_ZMQ_CHECK_COMPILERS #
dnl # Check compiler characteristics. This is so that we can AC_REQUIRE checks #
dnl ##############################################################################
AC_DEFUN([AC_ZMQ_CHECK_COMPILERS], [{
# For that the compiler works and try to come up with the type
AC_LANG_PUSH([C])
AC_ZMQ_CHECK_LANG_COMPILER
AC_ZMQ_CHECK_LANG_ICC
AC_ZMQ_CHECK_LANG_SUN_STUDIO
AC_ZMQ_CHECK_LANG_CLANG
AC_LANG_POP([C])
AC_LANG_PUSH(C++)
AC_ZMQ_CHECK_LANG_COMPILER
AC_ZMQ_CHECK_LANG_ICC
AC_ZMQ_CHECK_LANG_SUN_STUDIO
AC_ZMQ_CHECK_LANG_CLANG
AC_LANG_POP([C++])
# Set GCC and GXX variables correctly
if test "x$GCC" = "xyes"; then
if test "xyes" = "x$ac_zmq_cv_c_intel_compiler"; then
GCC="no"
fi
fi
if test "x$GXX" = "xyes"; then
if test "xyes" = "x$ac_zmq_cv_cxx_intel_compiler"; then
GXX="no"
fi
fi
}])
dnl ############################################################################
dnl # AC_ZMQ_CHECK_LANG_FLAG([flag], [action-if-found], [action-if-not-found]) #
dnl # Check if the compiler supports given flag. Works for C and C++ #
dnl # Sets ac_zmq_cv_[]_AC_LANG_ABBREV[]_supports_flag_[FLAG]=yes/no #
dnl ############################################################################
AC_DEFUN([AC_ZMQ_CHECK_LANG_FLAG], [{
AC_MSG_CHECKING([whether _AC_LANG compiler supports $1])
ac_zmq_cv_[]_AC_LANG_ABBREV[]_werror_flag_save=$ac_c_werror_flag
ac_[]_AC_LANG_ABBREV[]_werror_flag="yes"
case "x[]_AC_LANG_ABBREV" in
xc)
ac_zmq_cv_check_lang_flag_save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $1"
;;
xcxx)
ac_zmq_cv_check_lang_flag_save_CPPFLAGS="$CPPFLAGS"
CPPFLAGS="$CPPFLAGS $1"
;;
*)
AC_MSG_WARN([testing compiler characteristic on an unknown language])
;;
esac
AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
# This hack exist for ICC, which outputs unknown options as remarks
# Remarks are not turned into errors even with -Werror on
[if (grep 'ignoring unknown' conftest.err ||
grep 'not supported' conftest.err) >/dev/null 2>&1; then
eval AS_TR_SH(ac_zmq_cv_[]_AC_LANG_ABBREV[]_supports_flag_$1)="no"
else
eval AS_TR_SH(ac_zmq_cv_[]_AC_LANG_ABBREV[]_supports_flag_$1)="yes"
fi],
[eval AS_TR_SH(ac_zmq_cv_[]_AC_LANG_ABBREV[]_supports_flag_$1)="no"])
case "x[]_AC_LANG_ABBREV" in
xc)
CFLAGS="$ac_zmq_cv_check_lang_flag_save_CFLAGS"
;;
xcxx)
CPPFLAGS="$ac_zmq_cv_check_lang_flag_save_CPPFLAGS"
;;
*)
# nothing to restore
;;
esac
# Restore the werror flag
ac_[]_AC_LANG_ABBREV[]_werror_flag=$ac_zmq_cv_[]_AC_LANG_ABBREV[]_werror_flag_save
# Call the action as the flags are restored
AS_IF([eval test x$]AS_TR_SH(ac_zmq_cv_[]_AC_LANG_ABBREV[]_supports_flag_$1)[ = "xyes"],
[AC_MSG_RESULT(yes) ; $2], [AC_MSG_RESULT(no) ; $3])
}])
dnl ####################################################################################
dnl # AC_ZMQ_CHECK_LANG_FLAG_PREPEND([flag], [action-if-found], [action-if-not-found]) #
dnl # Check if the compiler supports given flag. Works for C and C++ #
dnl # This macro prepends the flag to CFLAGS or CPPFLAGS accordingly #
dnl # Sets ac_zmq_cv_[]_AC_LANG_ABBREV[]_supports_flag_[FLAG]=yes/no #
dnl ####################################################################################
AC_DEFUN([AC_ZMQ_CHECK_LANG_FLAG_PREPEND], [{
AC_ZMQ_CHECK_LANG_FLAG([$1])
case "x[]_AC_LANG_ABBREV" in
xc)
AS_IF([eval test x$]AS_TR_SH(ac_zmq_cv_[]_AC_LANG_ABBREV[]_supports_flag_$1)[ = "xyes"],
[CFLAGS="$1 $CFLAGS"; $2], $3)
;;
xcxx)
AS_IF([eval test x$]AS_TR_SH(ac_zmq_cv_[]_AC_LANG_ABBREV[]_supports_flag_$1)[ = "xyes"],
[CPPFLAGS="$1 $CPPFLAGS"; $2], $3)
;;
esac
}])
dnl ##############################################################################
dnl # AC_ZMQ_CHECK_ENABLE_DEBUG([action-if-found], [action-if-not-found]) #
dnl # Check whether to enable debug build and set compiler flags accordingly #
dnl ##############################################################################
AC_DEFUN([AC_ZMQ_CHECK_ENABLE_DEBUG], [{
# Require compiler specifics
AC_REQUIRE([AC_ZMQ_CHECK_COMPILERS])
# This flag is checked also in
AC_ARG_ENABLE([debug], [AS_HELP_STRING([--enable-debug],
[Enable debugging information [default=no]])])
AC_MSG_CHECKING(whether to enable debugging information)
if test "x$enable_debug" = "xyes"; then
# GCC, clang and ICC
if test "x$GCC" = "xyes" -o \
"x$ac_zmq_cv_c_intel_compiler" = "xyes" -o \
"x$ac_zmq_cv_c_clang_compiler" = "xyes"; then
CFLAGS="-g -O0 "
elif test "x$ac_zmq_cv_c_sun_studio_compiler" = "xyes"; then
CFLAGS="-g0 "
fi
# GCC, clang and ICC
if test "x$GXX" = "xyes" -o \
"x$ac_zmq_cv_cxx_intel_compiler" = "xyes" -o \
"x$ac_zmq_cv_cxx_clang_compiler" = "xyes"; then
CPPFLAGS="-g -O0 "
CXXFLAGS="-g -O0 "
# Sun studio
elif test "x$ac_zmq_cv_cxx_sun_studio_compiler" = "xyes"; then
CPPFLAGS="-g0 "
CXXFLAGS="-g0 "
fi
if test "x$LOCAL_CFLAGS" != "xnone"; then
CFLAGS="${CFLAGS} ${LOCAL_CFLAGS}"
fi
if test "x$LOCAL_CPPFLAGS" != "xnone"; then
CPPFLAGS="${CPPFLAGS} ${LOCAL_CPPFLAGS}"
fi
if test "x$LOCAL_CXXFLAGS" != "xnone"; then
CXXFLAGS="${CXXFLAGS} ${LOCAL_CXXFLAGS}"
fi
AC_MSG_RESULT(yes)
else
AC_MSG_RESULT(no)
fi
}])
dnl ##############################################################################
dnl # AC_ZMQ_CHECK_WITH_FLAG([flags], [macro]) #
dnl # Runs a normal autoconf check with compiler flags #
dnl ##############################################################################
AC_DEFUN([AC_ZMQ_CHECK_WITH_FLAG], [{
ac_zmq_check_with_flag_save_CFLAGS="$CFLAGS"
ac_zmq_check_with_flag_save_CPPFLAGS="$CPPFLAGS"
CFLAGS="$CFLAGS $1"
CPPFLAGS="$CPPFLAGS $1"
# Execute the macro
$2
CFLAGS="$ac_zmq_check_with_flag_save_CFLAGS"
CPPFLAGS="$ac_zmq_check_with_flag_save_CPPFLAGS"
}])
dnl ##############################################################################
dnl # AC_ZMQ_LANG_WALL([action-if-found], [action-if-not-found]) #
dnl # How to define -Wall for the current compiler #
dnl # Sets ac_zmq_cv_[]_AC_LANG_ABBREV[]__wall_flag variable to found style #
dnl ##############################################################################
AC_DEFUN([AC_ZMQ_LANG_WALL], [{
AC_MSG_CHECKING([how to enable additional warnings for _AC_LANG compiler])
ac_zmq_cv_[]_AC_LANG_ABBREV[]_wall_flag=""
# C compilers
case "x[]_AC_LANG_ABBREV" in
xc)
# GCC, clang and ICC
if test "x$GCC" = "xyes" -o \
"x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_intel_compiler" = "xyes" -o \
"x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_clang_compiler" = "xyes"; then
ac_zmq_cv_[]_AC_LANG_ABBREV[]_wall_flag="-Wall"
# Sun studio
elif test "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_sun_studio_compiler" = "xyes"; then
ac_zmq_cv_[]_AC_LANG_ABBREV[]_wall_flag="-v"
fi
;;
xcxx)
# GCC, clang and ICC
if test "x$GXX" = "xyes" -o \
"x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_intel_compiler" = "xyes" -o \
"x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_clang_compiler" = "xyes"; then
ac_zmq_cv_[]_AC_LANG_ABBREV[]_wall_flag="-Wall"
# Sun studio
elif test "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_sun_studio_compiler" = "xyes"; then
ac_zmq_cv_[]_AC_LANG_ABBREV[]_wall_flag="+w"
fi
;;
*)
;;
esac
# Call the action
if test "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_wall_flag" != "x"; then
AC_MSG_RESULT([$ac_zmq_cv_[]_AC_LANG_ABBREV[]_wall_flag])
$1
else
AC_MSG_RESULT([not found])
$2
fi
}])
dnl ####################################################################
dnl # AC_ZMQ_LANG_STRICT([action-if-found], [action-if-not-found]) #
dnl # Check how to turn on strict standards compliance #
dnl ####################################################################
AC_DEFUN([AC_ZMQ_LANG_STRICT], [{
AC_MSG_CHECKING([how to enable strict standards compliance in _AC_LANG compiler])
ac_zmq_cv_[]_AC_LANG_ABBREV[]_strict_flag=""
# C compilers
case "x[]_AC_LANG_ABBREV" in
xc)
# GCC, clang and ICC
if test "x$GCC" = "xyes" -o "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_clang_compiler" = "xyes"; then
ac_zmq_cv_[]_AC_LANG_ABBREV[]_strict_flag="-pedantic"
elif test "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_intel_compiler" = "xyes"; then
ac_zmq_cv_[]_AC_LANG_ABBREV[]_strict_flag="-strict-ansi"
# Sun studio
elif test "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_sun_studio_compiler" = "xyes"; then
ac_zmq_cv_[]_AC_LANG_ABBREV[]_strict_flag="-Xc"
fi
;;
xcxx)
# GCC, clang and ICC
if test "x$GXX" = "xyes" -o "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_clang_compiler" = "xyes"; then
ac_zmq_cv_[]_AC_LANG_ABBREV[]_strict_flag="-pedantic"
elif test "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_intel_compiler" = "xyes"; then
ac_zmq_cv_[]_AC_LANG_ABBREV[]_strict_flag="-strict-ansi"
# Sun studio
elif test "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_sun_studio_compiler" = "xyes"; then
ac_zmq_cv_[]_AC_LANG_ABBREV[]_strict_flag="-compat=5"
fi
;;
*)
;;
esac
# Call the action
if test "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_strict_flag" != "x"; then
AC_MSG_RESULT([$ac_zmq_cv_[]_AC_LANG_ABBREV[]_strict_flag])
$1
else
AC_MSG_RESULT([not found])
$2
fi
}])
dnl ########################################################################
dnl # AC_ZMQ_LANG_WERROR([action-if-found], [action-if-not-found]) #
dnl # Check how to turn warnings to errors #
dnl ########################################################################
AC_DEFUN([AC_ZMQ_LANG_WERROR], [{
AC_MSG_CHECKING([how to turn warnings to errors in _AC_LANG compiler])
ac_zmq_cv_[]_AC_LANG_ABBREV[]_werror_flag=""
# C compilers
case "x[]_AC_LANG_ABBREV" in
xc)
# GCC, clang and ICC
if test "x$GCC" = "xyes" -o "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_intel_compiler" = "xyes"; then
ac_zmq_cv_[]_AC_LANG_ABBREV[]_werror_flag="-Werror"
# Sun studio
elif test "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_sun_studio_compiler" = "xyes"; then
ac_zmq_cv_[]_AC_LANG_ABBREV[]_werror_flag="-errwarn=%all"
fi
;;
xcxx)
# GCC, clang and ICC
if test "x$GXX" = "xyes" -o "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_intel_compiler" = "xyes"; then
ac_zmq_cv_[]_AC_LANG_ABBREV[]_werror_flag="-Werror"
# Sun studio
elif test "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_sun_studio_compiler" = "xyes"; then
ac_zmq_cv_[]_AC_LANG_ABBREV[]_werror_flag="-errwarn=%all"
fi
;;
*)
;;
esac
# Call the action
if test "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_werror_flag" != "x"; then
AC_MSG_RESULT([$ac_zmq_cv_[]_AC_LANG_ABBREV[]_werror_flag])
$1
else
AC_MSG_RESULT([not found])
$2
fi
}])
dnl ################################################################################
dnl # AC_ZMQ_CHECK_LANG_PRAGMA([pragma], [action-if-found], [action-if-not-found]) #
dnl # Check if the compiler supports given pragma #
dnl ################################################################################
AC_DEFUN([AC_ZMQ_CHECK_LANG_PRAGMA], [{
# Need to know how to enable all warnings
AC_ZMQ_LANG_WALL
AC_MSG_CHECKING([whether _AC_LANG compiler supports pragma $1])
# Save flags
ac_zmq_cv_[]_AC_LANG_ABBREV[]_werror_flag_save=$ac_[]_AC_LANG_ABBREV[]_werror_flag
ac_[]_AC_LANG_ABBREV[]_werror_flag="yes"
if test "x[]_AC_LANG_ABBREV" = "xc"; then
ac_zmq_cv_check_lang_pragma_save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $ac_zmq_cv_[]_AC_LANG_ABBREV[]_wall_flag"
elif test "x[]_AC_LANG_ABBREV" = "xcxx"; then
ac_zmq_cv_check_lang_pragma_save_CPPFLAGS="$CPPFLAGS"
CPPFLAGS="$CPPFLAGS $ac_zmq_cv_[]_AC_LANG_ABBREV[]_wall_flag"
else
AC_MSG_WARN([testing compiler characteristic on an unknown language])
fi
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[#pragma $1]])],
[eval AS_TR_SH(ac_zmq_cv_[]_AC_LANG_ABBREV[]_supports_pragma_$1)="yes" ; AC_MSG_RESULT(yes)],
[eval AS_TR_SH(ac_zmq_cv_[]_AC_LANG_ABBREV[]_supports_pragma_$1)="no" ; AC_MSG_RESULT(no)])
if test "x[]_AC_LANG_ABBREV" = "xc"; then
CFLAGS="$ac_zmq_cv_check_lang_pragma_save_CFLAGS"
elif test "x[]_AC_LANG_ABBREV" = "xcxx"; then
CPPFLAGS="$ac_zmq_cv_check_lang_pragma_save_CPPFLAGS"
fi
ac_[]_AC_LANG_ABBREV[]_werror_flag=$ac_zmq_cv_[]_AC_LANG_ABBREV[]_werror_flag_save
# Call the action as the flags are restored
AS_IF([eval test x$]AS_TR_SH(ac_zmq_cv_[]_AC_LANG_ABBREV[]_supports_pragma_$1)[ = "xyes"],
[$2], [$3])
}])

6
autogen.sh
View File

@ -18,12 +18,6 @@
# Script to generate all required files from fresh git checkout. # Script to generate all required files from fresh git checkout.
command -v pkg-config >/dev/null 2>&1
if [ $? -ne 0 ]; then
echo "autogen.sh: error: could not find pkg-config. pkg-config is required to run autogen.sh." 1>&2
exit 1
fi
command -v libtool >/dev/null 2>&1 command -v libtool >/dev/null 2>&1
if [ $? -ne 0 ]; then if [ $? -ne 0 ]; then
echo "autogen.sh: error: could not find libtool. libtool is required to run autogen.sh." 1>&2 echo "autogen.sh: error: could not find libtool. libtool is required to run autogen.sh." 1>&2

212
configure.in
View File

@ -6,7 +6,7 @@ AC_PREREQ(2.61)
# the version.sh script. Hence, it should be updated there. # the version.sh script. Hence, it should be updated there.
# The version in git should reflect the *next* version planned. # The version in git should reflect the *next* version planned.
# #
AC_INIT([zeromq],[m4_esyscmd(./version.sh | tr -d '\n')],[zeromq-dev@lists.zeromq.org]) AC_INIT([zeromq],[m4_esyscmd([./version.sh | tr -d '\n'])],[zeromq-dev@lists.zeromq.org])
AC_CONFIG_AUX_DIR(config) AC_CONFIG_AUX_DIR(config)
AC_CONFIG_MACRO_DIR(config) AC_CONFIG_MACRO_DIR(config)
@ -34,70 +34,37 @@ AM_PROG_CC_C_O
AC_PROG_SED AC_PROG_SED
AC_PROG_AWK AC_PROG_AWK
# Host specific checks
AC_CANONICAL_HOST
# Libtool configuration for different targets. See acinclude.m4 # Libtool configuration for different targets. See acinclude.m4
AC_CONFIG_LIBTOOL AC_ZMQ_CONFIG_LIBTOOL
AC_LIBTOOL_WIN32_DLL AC_LIBTOOL_WIN32_DLL
AC_PROG_LIBTOOL AC_PROG_LIBTOOL
# For that the compiler works and try to come up with the type # Check whether to build a with debug symbols
AC_LANG(C) AC_ZMQ_CHECK_ENABLE_DEBUG
AC_CHECK_LANG_COMPILER
AC_CHECK_LANG_ICC
AC_CHECK_LANG_SUN_STUDIO
AC_LANG(C++)
AC_CHECK_LANG_COMPILER
AC_CHECK_LANG_ICC
AC_CHECK_LANG_SUN_STUDIO
# Checks for libraries. # Checks for libraries.
AC_CHECK_LIB([pthread], [pthread_create]) AC_CHECK_LIB([pthread], [pthread_create])
# Extra CFLAGS are appended at the end of CFLAGS for pgm. # Set pedantic
LIBZMQ_EXTRA_CFLAGS="" ac_zmq_pedantic="yes"
# Extra CXXFLAGS are appended at the end of CXXFLAGS for libzmq.
LIBZMQ_EXTRA_CXXFLAGS=""
# Extra LDFLAGS are appended at the end of LDFLAGS for libzmq.
LIBZMQ_EXTRA_LDFLAGS=""
# Set a helper variable to indicate GNU C and C++ are in use
if test "x$GCC" = "xyes" -a "x$GXX" = "xyes"; then
gnu_compilers="yes"
# ICC is detected as GNU compiler, make sure that it's not being used as one
if test "xyes" = "x$ac_cv_c_intel_compiler" -o "xyes" = "x$ac_cv_cpp_intel_compiler"; then
gnu_compilers="no"
fi
else
gnu_compilers="no"
fi
# Set pedantic when using GNU compilers
if test "x$gnu_compilers" = "xyes"; then
pedantic="yes"
fi
# By default compiling with -Werror except OSX. # By default compiling with -Werror except OSX.
werror="yes" ac_zmq_werror="yes"
# Whether we are on mingw or not. # Whether we are on mingw or not.
on_mingw32="no" ac_zmq_on_mingw32="no"
# Set some default features required by 0MQ code. # Set some default features required by 0MQ code.
CPPFLAGS="-D_REENTRANT -D_THREAD_SAFE $CPPFLAGS" CPPFLAGS="-D_REENTRANT -D_THREAD_SAFE $CPPFLAGS"
# For host type checks
AC_CANONICAL_HOST
# OS-specific tests # OS-specific tests
case "${host_os}" in case "${host_os}" in
*linux*) *linux*)
# Define on Linux to enable all library features. Define if using a gnu compiler # Define on Linux to enable all library features. Define if using a gnu compiler
if test "x$gnu_compilers" = "xyes"; then if test "x$GXX" = "xyes"; then
CPPFLAGS="-D_GNU_SOURCE $CPPFLAGS" CPPFLAGS="-D_GNU_SOURCE $CPPFLAGS"
fi fi
AC_DEFINE(ZMQ_HAVE_LINUX, 1, [Have Linux OS]) AC_DEFINE(ZMQ_HAVE_LINUX, 1, [Have Linux OS])
@ -136,10 +103,12 @@ case "${host_os}" in
*darwin*) *darwin*)
# Define on Darwin to enable all library features # Define on Darwin to enable all library features
CPPFLAGS="-D_DARWIN_C_SOURCE $CPPFLAGS" CPPFLAGS="-D_DARWIN_C_SOURCE $CPPFLAGS"
pedantic="no" ac_zmq_pedantic="no"
werror="no" ac_zmq_werror="no"
AC_DEFINE(ZMQ_HAVE_OSX, 1, [Have DarwinOSX OS]) AC_DEFINE(ZMQ_HAVE_OSX, 1, [Have DarwinOSX OS])
LIBZMQ_EXTRA_CXXFLAGS+="-Wno-uninitialized" AC_LANG_PUSH([C++])
AC_ZMQ_CHECK_LANG_FLAG_PREPEND([-Wno-uninitialized])
AC_LANG_POP([C++])
;; ;;
*netbsd*) *netbsd*)
# Define on NetBSD to enable all library features # Define on NetBSD to enable all library features
@ -148,7 +117,7 @@ case "${host_os}" in
# NetBSD 5.0 and newer provides atomic operations but we can # NetBSD 5.0 and newer provides atomic operations but we can
# only use these on systems where PR #42842 has been fixed so # only use these on systems where PR #42842 has been fixed so
# we must try and link a test program using C++. # we must try and link a test program using C++.
netbsd_has_atomic=no ac_zmq_netbsd_has_atomic=no
AC_MSG_CHECKING([whether atomic operations can be used]) AC_MSG_CHECKING([whether atomic operations can be used])
AC_LANG_PUSH([C++]) AC_LANG_PUSH([C++])
AC_LINK_IFELSE([AC_LANG_PROGRAM( AC_LINK_IFELSE([AC_LANG_PROGRAM(
@ -156,11 +125,11 @@ case "${host_os}" in
[[uint32_t value; [[uint32_t value;
atomic_cas_32 (&value, 0, 0); atomic_cas_32 (&value, 0, 0);
return 0;]])], return 0;]])],
[netbsd_has_atomic=yes], [ac_zmq_netbsd_has_atomic=yes],
[netbsd_has_atomic=no]) [ac_zmq_netbsd_has_atomic=no])
AC_LANG_POP([C++]) AC_LANG_POP([C++])
AC_MSG_RESULT([$netbsd_has_atomic]) AC_MSG_RESULT([$ac_zmq_netbsd_has_atomic])
if test "x$netbsd_has_atomic" = "xno"; then if test "x$ac_zmq_netbsd_has_atomic" = "xno"; then
AC_DEFINE(ZMQ_FORCE_MUTEXES, 1, [Force to use mutexes]) AC_DEFINE(ZMQ_FORCE_MUTEXES, 1, [Force to use mutexes])
fi fi
;; ;;
@ -170,7 +139,7 @@ case "${host_os}" in
AC_DEFINE(ZMQ_HAVE_OPENBSD, 1, [Have OpenBSD OS]) AC_DEFINE(ZMQ_HAVE_OPENBSD, 1, [Have OpenBSD OS])
;; ;;
*nto-qnx*) *nto-qnx*)
pedantic="no" ac_zmq_pedantic="no"
AC_DEFINE(ZMQ_HAVE_QNXNTO, 1, [Have QNX Neutrino OS]) AC_DEFINE(ZMQ_HAVE_QNXNTO, 1, [Have QNX Neutrino OS])
AC_CHECK_LIB(socket, socket) AC_CHECK_LIB(socket, socket)
AC_CHECK_LIB(crypto, RAND_bytes) AC_CHECK_LIB(crypto, RAND_bytes)
@ -181,7 +150,7 @@ case "${host_os}" in
;; ;;
*hpux*) *hpux*)
# Define on HP-UX to enable all library features # Define on HP-UX to enable all library features
CPPFLAGS="-D_POSIX_C_SOURCE=200112L" CPPFLAGS="-D_POSIX_C_SOURCE=200112L $CPPFLAGS"
AC_DEFINE(ZMQ_HAVE_HPUX, 1, [Have HPUX OS]) AC_DEFINE(ZMQ_HAVE_HPUX, 1, [Have HPUX OS])
AC_CHECK_LIB(rt, sem_init) AC_CHECK_LIB(rt, sem_init)
AC_CHECK_LIB(crypto, RAND_bytes) AC_CHECK_LIB(crypto, RAND_bytes)
@ -197,8 +166,10 @@ case "${host_os}" in
AC_CHECK_LIB(iphlpapi, main, , AC_CHECK_LIB(iphlpapi, main, ,
[AC_MSG_ERROR([cannot link with iphlpapi.dll.])]) [AC_MSG_ERROR([cannot link with iphlpapi.dll.])])
# mingw32 defines __int64_t as long long # mingw32 defines __int64_t as long long
CPPFLAGS="-Wno-long-long ${CPPFLAGS} " AC_LANG_PUSH([C++])
on_mingw32="yes" AC_ZMQ_CHECK_LANG_FLAG_PREPEND([-Wno-long-long])
AC_LANG_POP([C++])
ac_zmq_on_mingw32="yes"
if test "x$enable_static" = "xyes"; then if test "x$enable_static" = "xyes"; then
AC_MSG_ERROR([Building static libraries is not supported under MinGW32]) AC_MSG_ERROR([Building static libraries is not supported under MinGW32])
@ -210,7 +181,7 @@ case "${host_os}" in
AC_DEFINE(ZMQ_HAVE_CYGWIN, 1, [Have Cygwin]) AC_DEFINE(ZMQ_HAVE_CYGWIN, 1, [Have Cygwin])
# Cygwin provides libuuid as part of the e2fsprogs package, and somewhat # Cygwin provides libuuid as part of the e2fsprogs package, and somewhat
# uselessly installs the library in /usr/lib/e2fsprogs # uselessly installs the library in /usr/lib/e2fsprogs
LDFLAGS="${LDFLAGS} -L/usr/lib/e2fsprogs" LDFLAGS="-L/usr/lib/e2fsprogs ${LDFLAGS}"
AC_CHECK_LIB(uuid, uuid_generate, , AC_CHECK_LIB(uuid, uuid_generate, ,
[AC_MSG_ERROR([cannot link with -luuid, install the e2fsprogs package.])]) [AC_MSG_ERROR([cannot link with -luuid, install the e2fsprogs package.])])
@ -223,31 +194,38 @@ case "${host_os}" in
;; ;;
esac esac
# Check if the compiler supports -fvisibility=hidden. If so, use it, but not #
# on MinGW32 where we use a separate mechanism (__declspec). # Check if the compiler supports -fvisibility=hidden flag. MinGW32 uses __declspec
_LT_COMPILER_OPTION([if $compiler supports -fvisibility=hidden], #
ac_cv_prog_compiler_visibility, if test "x$ac_zmq_on_mingw32" != "xyes"; then
[-fvisibility=hidden], AC_LANG_PUSH([C])
[], AC_ZMQ_CHECK_LANG_FLAG([-fvisibility=hidden],
[have_dso_visibility=yes]) [LIBZMQ_EXTRA_CFLAGS="-fvisibility=hidden ${LIBZMQ_EXTRA_CFLAGS}"],
if test "x$have_dso_visibility" = "xyes" -a "x$on_mingw32" = "xno"; then [AC_ZMQ_CHECK_LANG_FLAG([-xldscope=hidden],
LIBZMQ_EXTRA_CFLAGS="-fvisibility=hidden $LIBZMQ_EXTRA_CFLAGS" [LIBZMQ_EXTRA_CFLAGS="-xldscope=hidden ${LIBZMQ_EXTRA_CFLAGS}"])])
LIBZMQ_EXTRA_CXXFLAGS="-fvisibility=hidden $LIBZMQ_EXTRA_CXXFLAGS" AC_LANG_POP([C])
AC_LANG_PUSH([C++])
AC_ZMQ_CHECK_LANG_FLAG([-fvisibility=hidden],
[LIBZMQ_EXTRA_CXXFLAGS="-fvisibility=hidden ${LIBZMQ_EXTRA_CXXFLAGS}"],
[AC_ZMQ_CHECK_LANG_FLAG([-xldscope=hidden],
[LIBZMQ_EXTRA_CXXFLAGS="-xldscope=hidden ${LIBZMQ_EXTRA_CXXFLAGS}"])])
AC_LANG_POP([C++])
fi fi
# CPU-specific optimizations # CPU-specific optimizations
case "${host_cpu}" in case "${host_cpu}" in
*sparc*) *sparc*)
if test "x$gnu_compilers" = "xyes"; then AC_LANG_PUSH([C++])
CPPFLAGS="$CPPFLAGS -mcpu=v9" AC_ZMQ_CHECK_LANG_FLAG_PREPEND([-mcpu=v9])
fi AC_LANG_POP([C++])
;; ;;
*) *)
;; ;;
esac esac
# Check whether to build docs / install man pages # Check whether to build docs / install man pages
AC_CHECK_DOC_BUILD AC_ZMQ_CHECK_DOC_BUILD
# Checks for header files. # Checks for header files.
AC_HEADER_STDC AC_HEADER_STDC
@ -258,29 +236,27 @@ stdlib.h string.h sys/socket.h sys/time.h unistd.h limits.h)
AC_CHECK_HEADERS(ifaddrs.h, [AC_DEFINE(ZMQ_HAVE_IFADDRS, 1, [Have ifaddrs.h header.])]) AC_CHECK_HEADERS(ifaddrs.h, [AC_DEFINE(ZMQ_HAVE_IFADDRS, 1, [Have ifaddrs.h header.])])
# Use c++ in subsequent tests # Use c++ in subsequent tests
AC_LANG(C++) AC_LANG_PUSH(C++)
# pkg-config is used if found, however, we need to provide a way to disable it
# entirely when the user knows what she's doing and it's use is undesirable,
# such as when cross-compiling.
AC_ARG_WITH([pkg-config], [AS_HELP_STRING([--without-pkg-config],
[do not use pkg-config [default=no]])])
if test "x$with_pkg_config" != "xno"; then
AC_CHECK_PROG(have_pkg_config, pkg-config, yes, no)
fi
# Checks for typedefs, structures, and compiler characteristics.
AC_HEADER_STDBOOL AC_HEADER_STDBOOL
AC_C_CONST AC_C_CONST
AC_C_INLINE AC_C_INLINE
AC_TYPE_SIZE_T # Checks for typedefs, structures, and compiler characteristics.
AC_TYPE_SSIZE_T if test "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_intel_compiler" = "xyes"; then
dnl 279: controlling expression is constant
dnl Fixes build with ICC 12.x
AC_ZMQ_CHECK_WITH_FLAG([-wd279], [AC_TYPE_SIZE_T])
AC_ZMQ_CHECK_WITH_FLAG([-wd279], [AC_TYPE_SSIZE_T])
else
AC_TYPE_SIZE_T
AC_TYPE_SSIZE_T
fi
AC_HEADER_TIME AC_HEADER_TIME
AC_TYPE_UINT32_T AC_TYPE_UINT32_T
AC_C_VOLATILE AC_C_VOLATILE
# PGM extension # PGM extension
pgm_ext="no" ac_zmq_pgm_ext="no"
pgm_basename="libpgm-5.0.91~dfsg" pgm_basename="libpgm-5.0.91~dfsg"
@ -310,31 +286,38 @@ if test "x$with_pgm_ext" != "xno"; then
# ... and on Linux/Windows/Solaris/FreeBSD/OSX systems. # ... and on Linux/Windows/Solaris/FreeBSD/OSX systems.
case "${host_os}" in case "${host_os}" in
*linux*|*mingw32*|*solaris*|*freebsd*|*darwin*) *linux*|*mingw32*|*solaris*|*freebsd*|*darwin*)
if test "x$gnu_compilers" = "xyes"; then AC_MSG_RESULT([yes])
LIBZMQ_EXTRA_CXXFLAGS="${LIBZMQ_EXTRA_CXXFLAGS} -Wno-variadic-macros -Wno-long-long "
elif test "x$ac_cv_c_intel_compiler" = "xyes"; then AC_LANG_PUSH([C++])
LIBZMQ_EXTRA_CFLAGS="-strict-ansi -Dasm=__asm__ " AC_ZMQ_CHECK_LANG_FLAG([-Wno-variadic-macros], [LIBZMQ_EXTRA_CXXFLAGS="-Wno-variadic-macros $LIBZMQ_EXTRA_CXXFLAGS"])
elif test "x$ac_cv_c_sun_studio_compiler" = "xyes"; then AC_ZMQ_CHECK_LANG_FLAG([-Wno-long-long], [LIBZMQ_EXTRA_CXXFLAGS="-Wno-long-long $LIBZMQ_EXTRA_CXXFLAGS"])
LIBZMQ_EXTRA_CFLAGS="-Xc -Dasm=__asm__ " AC_LANG_POP([C++])
AC_LANG_PUSH([C])
AC_ZMQ_LANG_STRICT([LIBZMQ_EXTRA_CFLAGS="$ac_zmq_cv_[]_AC_LANG_ABBREV[]_strict_flag $LIBZMQ_EXTRA_CFLAGS"])
if test "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_intel_compiler" = "xyes" -o \
"x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_sun_studio_compiler" = "xyes"; then
LIBZMQ_EXTRA_CFLAGS="-Dasm=__asm__ $LIBZMQ_EXTRA_CFLAGS"
fi fi
AC_LANG_POP([C])
;; ;;
*) *)
AC_MSG_ERROR([the PGM extension is not supported on system ${host_os}.]) AC_MSG_ERROR([the PGM extension is not supported on system ${host_os}.])
;; ;;
esac esac
AC_MSG_RESULT([yes])
# Gzip, Perl and Python are required duing PGM build # Gzip, Perl and Python are required duing PGM build
AC_CHECK_PROG(have_gzip, gzip, yes, no) AC_CHECK_PROG(ac_zmq_have_gzip, gzip, yes, no)
if test "x$have_gzip" != "xyes"; then if test "x$ac_zmq_have_gzip" != "xyes"; then
AC_MSG_ERROR([gzip is required for building the PGM extension.]) AC_MSG_ERROR([gzip is required for building the PGM extension.])
fi fi
AC_CHECK_PROG(have_perl, perl, yes, no) AC_CHECK_PROG(ac_zmq_have_perl, perl, yes, no)
if test "x$have_perl" != "xyes"; then if test "x$ac_zmq_have_perl" != "xyes"; then
AC_MSG_ERROR([perl is required for building the PGM extension.]) AC_MSG_ERROR([perl is required for building the PGM extension.])
fi fi
AC_CHECK_PROG(have_python, python, yes, no) AC_CHECK_PROG(ac_zmq_have_python, python, yes, no)
if test "x$have_python" != "xyes"; then if test "x$ac_zmq_have_python" != "xyes"; then
AC_MSG_ERROR([python is required for building the PGM extension.]) AC_MSG_ERROR([python is required for building the PGM extension.])
fi fi
@ -346,25 +329,30 @@ if test "x$with_pgm_ext" != "xno"; then
# Success! # Success!
AC_DEFINE(ZMQ_HAVE_OPENPGM, 1, [Have OpenPGM extension]) AC_DEFINE(ZMQ_HAVE_OPENPGM, 1, [Have OpenPGM extension])
pgm_ext="yes" ac_zmq_pgm_ext="yes"
# these break OpenPGM so don't specify them if we are building with it.
ac_zmq_pedantic="no"
ac_zmq_werror="no"
fi fi
# -Wall, -Werror and -pedantic are GNU compiler specific. # Set -Wall, -Werror and -pedantic
# Also, these break OpenPGM so don't specify them if we are building with it. AC_LANG_PUSH([C++])
if test "x$gnu_compilers" = "xyes" -a "x$pgm_ext" = "xno"; then
CPPFLAGS="-Wall $CPPFLAGS"
if test "x$pedantic" = "xyes"; then # Check how to enable -Wall
CPPFLAGS="-pedantic $CPPFLAGS" AC_ZMQ_LANG_WALL([CPPFLAGS="$ac_zmq_cv_[]_AC_LANG_ABBREV[]_wall_flag $CPPFLAGS"])
fi
if test "x$werror" = "xyes"; then if test "x$ac_zmq_werror" = "xyes" -a "x$ac_zmq_cv_[]_AC_LANG_ABBREV[]_sun_studio_compiler" != "xyes"; then
CPPFLAGS="-Werror $CPPFLAGS" AC_ZMQ_LANG_WERROR([CPPFLAGS="$ac_zmq_cv_[]_AC_LANG_ABBREV[]_werror_flag $CPPFLAGS"])
fi
fi fi
AM_CONDITIONAL(BUILD_PGM, test "x$pgm_ext" = "xyes") if test "x$ac_zmq_pedantic" = "xyes"; then
AM_CONDITIONAL(ON_MINGW, test "x$on_mingw32" = "xyes") AC_ZMQ_LANG_STRICT([CPPFLAGS="$ac_zmq_cv_[]_AC_LANG_ABBREV[]_strict_flag $CPPFLAGS"])
fi
AC_LANG_POP([C++])
AM_CONDITIONAL(BUILD_PGM, test "x$ac_zmq_pgm_ext" = "xyes")
AM_CONDITIONAL(ON_MINGW, test "x$ac_zmq_on_mingw32" = "xyes")
# Subst LIBZMQ_EXTRA_CFLAGS & CXXFLAGS & LDFLAGS # Subst LIBZMQ_EXTRA_CFLAGS & CXXFLAGS & LDFLAGS
AC_SUBST(LIBZMQ_EXTRA_CFLAGS) AC_SUBST(LIBZMQ_EXTRA_CFLAGS)

12
include/zmq.h
View File

@ -30,7 +30,7 @@ extern "C" {
#include "winsock2.h" #include "winsock2.h"
#endif #endif
/* Win32 needs special handling for DLL exports */ /* Handle DSO symbol visibility */
#if defined _WIN32 #if defined _WIN32
# if defined DLL_EXPORT # if defined DLL_EXPORT
# define ZMQ_EXPORT __declspec(dllexport) # define ZMQ_EXPORT __declspec(dllexport)
@ -38,9 +38,12 @@ extern "C" {
# define ZMQ_EXPORT __declspec(dllimport) # define ZMQ_EXPORT __declspec(dllimport)
# endif # endif
#else #else
# if defined __SUNPRO_C || defined __SUNPRO_CC
# define ZMQ_EXPORT __global
# elif (defined __GNUC__ && __GNUC__ >= 4) || defined __INTEL_COMPILER
# define ZMQ_EXPORT __attribute__ ((visibility("default")))
# else
# define ZMQ_EXPORT # define ZMQ_EXPORT
# if defined __GNUC__ && __GNUC__ >= 4
# pragma GCC visibility push(default)
# endif # endif
#endif #endif
@ -246,9 +249,6 @@ ZMQ_EXPORT int zmq_poll (zmq_pollitem_t *items, int nitems, long timeout);
ZMQ_EXPORT int zmq_device (int device, void * insocket, void* outsocket); ZMQ_EXPORT int zmq_device (int device, void * insocket, void* outsocket);
#undef ZMQ_EXPORT #undef ZMQ_EXPORT
#if defined __GNUC__ && __GNUC__ >= 4 && !defined _WIN32
# pragma GCC visibility pop
#endif
#ifdef __cplusplus #ifdef __cplusplus
} }

12
include/zmq_utils.h
View File

@ -24,7 +24,7 @@
extern "C" { extern "C" {
#endif #endif
/* Win32 needs special handling for DLL exports */ /* Handle DSO symbol visibility */
#if defined _WIN32 #if defined _WIN32
# if defined DLL_EXPORT # if defined DLL_EXPORT
# define ZMQ_EXPORT __declspec(dllexport) # define ZMQ_EXPORT __declspec(dllexport)
@ -32,9 +32,12 @@ extern "C" {
# define ZMQ_EXPORT __declspec(dllimport) # define ZMQ_EXPORT __declspec(dllimport)
# endif # endif
#else #else
# if defined __SUNPRO_C || defined __SUNPRO_CC
# define ZMQ_EXPORT __global
# elif (defined __GNUC__ && __GNUC__ >= 4) || defined __INTEL_COMPILER
# define ZMQ_EXPORT __attribute__ ((visibility("default")))
# else
# define ZMQ_EXPORT # define ZMQ_EXPORT
# if defined __GNUC__ && __GNUC__ >= 4
# pragma GCC visibility push(default)
# endif # endif
#endif #endif
@ -52,9 +55,6 @@ ZMQ_EXPORT unsigned long zmq_stopwatch_stop (void *watch_);
ZMQ_EXPORT void zmq_sleep (int seconds_); ZMQ_EXPORT void zmq_sleep (int seconds_);
#undef ZMQ_EXPORT #undef ZMQ_EXPORT
#if defined __GNUC__ && __GNUC__ >= 4 && !defined _WIN32
# pragma GCC visibility pop
#endif
#ifdef __cplusplus #ifdef __cplusplus
} }