Annotation of embedaddon/pcre/m4/ax_pthread.m4, revision 1.1

1.1     ! misho       1: # ===========================================================================
        !             2: #        http://www.gnu.org/software/autoconf-archive/ax_pthread.html
        !             3: # ===========================================================================
        !             4: #
        !             5: # SYNOPSIS
        !             6: #
        !             7: #   AX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
        !             8: #
        !             9: # DESCRIPTION
        !            10: #
        !            11: #   This macro figures out how to build C programs using POSIX threads. It
        !            12: #   sets the PTHREAD_LIBS output variable to the threads library and linker
        !            13: #   flags, and the PTHREAD_CFLAGS output variable to any special C compiler
        !            14: #   flags that are needed. (The user can also force certain compiler
        !            15: #   flags/libs to be tested by setting these environment variables.)
        !            16: #
        !            17: #   Also sets PTHREAD_CC to any special C compiler that is needed for
        !            18: #   multi-threaded programs (defaults to the value of CC otherwise). (This
        !            19: #   is necessary on AIX to use the special cc_r compiler alias.)
        !            20: #
        !            21: #   NOTE: You are assumed to not only compile your program with these flags,
        !            22: #   but also link it with them as well. e.g. you should link with
        !            23: #   $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS
        !            24: #
        !            25: #   If you are only building threads programs, you may wish to use these
        !            26: #   variables in your default LIBS, CFLAGS, and CC:
        !            27: #
        !            28: #     LIBS="$PTHREAD_LIBS $LIBS"
        !            29: #     CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
        !            30: #     CC="$PTHREAD_CC"
        !            31: #
        !            32: #   In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute constant
        !            33: #   has a nonstandard name, defines PTHREAD_CREATE_JOINABLE to that name
        !            34: #   (e.g. PTHREAD_CREATE_UNDETACHED on AIX).
        !            35: #
        !            36: #   Also HAVE_PTHREAD_PRIO_INHERIT is defined if pthread is found and the
        !            37: #   PTHREAD_PRIO_INHERIT symbol is defined when compiling with
        !            38: #   PTHREAD_CFLAGS.
        !            39: #
        !            40: #   ACTION-IF-FOUND is a list of shell commands to run if a threads library
        !            41: #   is found, and ACTION-IF-NOT-FOUND is a list of commands to run it if it
        !            42: #   is not found. If ACTION-IF-FOUND is not specified, the default action
        !            43: #   will define HAVE_PTHREAD.
        !            44: #
        !            45: #   Please let the authors know if this macro fails on any platform, or if
        !            46: #   you have any other suggestions or comments. This macro was based on work
        !            47: #   by SGJ on autoconf scripts for FFTW (http://www.fftw.org/) (with help
        !            48: #   from M. Frigo), as well as ac_pthread and hb_pthread macros posted by
        !            49: #   Alejandro Forero Cuervo to the autoconf macro repository. We are also
        !            50: #   grateful for the helpful feedback of numerous users.
        !            51: #
        !            52: #   Updated for Autoconf 2.68 by Daniel Richard G.
        !            53: #
        !            54: # LICENSE
        !            55: #
        !            56: #   Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
        !            57: #   Copyright (c) 2011 Daniel Richard G. <skunk@iSKUNK.ORG>
        !            58: #
        !            59: #   This program is free software: you can redistribute it and/or modify it
        !            60: #   under the terms of the GNU General Public License as published by the
        !            61: #   Free Software Foundation, either version 3 of the License, or (at your
        !            62: #   option) any later version.
        !            63: #
        !            64: #   This program is distributed in the hope that it will be useful, but
        !            65: #   WITHOUT ANY WARRANTY; without even the implied warranty of
        !            66: #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
        !            67: #   Public License for more details.
        !            68: #
        !            69: #   You should have received a copy of the GNU General Public License along
        !            70: #   with this program. If not, see <http://www.gnu.org/licenses/>.
        !            71: #
        !            72: #   As a special exception, the respective Autoconf Macro's copyright owner
        !            73: #   gives unlimited permission to copy, distribute and modify the configure
        !            74: #   scripts that are the output of Autoconf when processing the Macro. You
        !            75: #   need not follow the terms of the GNU General Public License when using
        !            76: #   or distributing such scripts, even though portions of the text of the
        !            77: #   Macro appear in them. The GNU General Public License (GPL) does govern
        !            78: #   all other use of the material that constitutes the Autoconf Macro.
        !            79: #
        !            80: #   This special exception to the GPL applies to versions of the Autoconf
        !            81: #   Macro released by the Autoconf Archive. When you make and distribute a
        !            82: #   modified version of the Autoconf Macro, you may extend this special
        !            83: #   exception to the GPL to apply to your modified version as well.
        !            84: 
        !            85: #serial 18
        !            86: 
        !            87: AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD])
        !            88: AC_DEFUN([AX_PTHREAD], [
        !            89: AC_REQUIRE([AC_CANONICAL_HOST])
        !            90: AC_LANG_PUSH([C])
        !            91: ax_pthread_ok=no
        !            92: 
        !            93: # We used to check for pthread.h first, but this fails if pthread.h
        !            94: # requires special compiler flags (e.g. on True64 or Sequent).
        !            95: # It gets checked for in the link test anyway.
        !            96: 
        !            97: # First of all, check if the user has set any of the PTHREAD_LIBS,
        !            98: # etcetera environment variables, and if threads linking works using
        !            99: # them:
        !           100: if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then
        !           101:         save_CFLAGS="$CFLAGS"
        !           102:         CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
        !           103:         save_LIBS="$LIBS"
        !           104:         LIBS="$PTHREAD_LIBS $LIBS"
        !           105:         AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS])
        !           106:         AC_TRY_LINK_FUNC(pthread_join, ax_pthread_ok=yes)
        !           107:         AC_MSG_RESULT($ax_pthread_ok)
        !           108:         if test x"$ax_pthread_ok" = xno; then
        !           109:                 PTHREAD_LIBS=""
        !           110:                 PTHREAD_CFLAGS=""
        !           111:         fi
        !           112:         LIBS="$save_LIBS"
        !           113:         CFLAGS="$save_CFLAGS"
        !           114: fi
        !           115: 
        !           116: # We must check for the threads library under a number of different
        !           117: # names; the ordering is very important because some systems
        !           118: # (e.g. DEC) have both -lpthread and -lpthreads, where one of the
        !           119: # libraries is broken (non-POSIX).
        !           120: 
        !           121: # Create a list of thread flags to try.  Items starting with a "-" are
        !           122: # C compiler flags, and other items are library names, except for "none"
        !           123: # which indicates that we try without any flags at all, and "pthread-config"
        !           124: # which is a program returning the flags for the Pth emulation library.
        !           125: 
        !           126: ax_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"
        !           127: 
        !           128: # The ordering *is* (sometimes) important.  Some notes on the
        !           129: # individual items follow:
        !           130: 
        !           131: # pthreads: AIX (must check this before -lpthread)
        !           132: # none: in case threads are in libc; should be tried before -Kthread and
        !           133: #       other compiler flags to prevent continual compiler warnings
        !           134: # -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
        !           135: # -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
        !           136: # lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
        !           137: # -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)
        !           138: # -pthreads: Solaris/gcc
        !           139: # -mthreads: Mingw32/gcc, Lynx/gcc
        !           140: # -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
        !           141: #      doesn't hurt to check since this sometimes defines pthreads too;
        !           142: #      also defines -D_REENTRANT)
        !           143: #      ... -mt is also the pthreads flag for HP/aCC
        !           144: # pthread: Linux, etcetera
        !           145: # --thread-safe: KAI C++
        !           146: # pthread-config: use pthread-config program (for GNU Pth library)
        !           147: 
        !           148: case ${host_os} in
        !           149:         solaris*)
        !           150: 
        !           151:         # On Solaris (at least, for some versions), libc contains stubbed
        !           152:         # (non-functional) versions of the pthreads routines, so link-based
        !           153:         # tests will erroneously succeed.  (We need to link with -pthreads/-mt/
        !           154:         # -lpthread.)  (The stubs are missing pthread_cleanup_push, or rather
        !           155:         # a function called by this macro, so we could check for that, but
        !           156:         # who knows whether they'll stub that too in a future libc.)  So,
        !           157:         # we'll just look for -pthreads and -lpthread first:
        !           158: 
        !           159:         ax_pthread_flags="-pthreads pthread -mt -pthread $ax_pthread_flags"
        !           160:         ;;
        !           161: 
        !           162:         darwin*)
        !           163:         ax_pthread_flags="-pthread $ax_pthread_flags"
        !           164:         ;;
        !           165: esac
        !           166: 
        !           167: if test x"$ax_pthread_ok" = xno; then
        !           168: for flag in $ax_pthread_flags; do
        !           169: 
        !           170:         case $flag in
        !           171:                 none)
        !           172:                 AC_MSG_CHECKING([whether pthreads work without any flags])
        !           173:                 ;;
        !           174: 
        !           175:                 -*)
        !           176:                 AC_MSG_CHECKING([whether pthreads work with $flag])
        !           177:                 PTHREAD_CFLAGS="$flag"
        !           178:                 ;;
        !           179: 
        !           180:                 pthread-config)
        !           181:                 AC_CHECK_PROG(ax_pthread_config, pthread-config, yes, no)
        !           182:                 if test x"$ax_pthread_config" = xno; then continue; fi
        !           183:                 PTHREAD_CFLAGS="`pthread-config --cflags`"
        !           184:                 PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"
        !           185:                 ;;
        !           186: 
        !           187:                 *)
        !           188:                 AC_MSG_CHECKING([for the pthreads library -l$flag])
        !           189:                 PTHREAD_LIBS="-l$flag"
        !           190:                 ;;
        !           191:         esac
        !           192: 
        !           193:         save_LIBS="$LIBS"
        !           194:         save_CFLAGS="$CFLAGS"
        !           195:         LIBS="$PTHREAD_LIBS $LIBS"
        !           196:         CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
        !           197: 
        !           198:         # Check for various functions.  We must include pthread.h,
        !           199:         # since some functions may be macros.  (On the Sequent, we
        !           200:         # need a special flag -Kthread to make this header compile.)
        !           201:         # We check for pthread_join because it is in -lpthread on IRIX
        !           202:         # while pthread_create is in libc.  We check for pthread_attr_init
        !           203:         # due to DEC craziness with -lpthreads.  We check for
        !           204:         # pthread_cleanup_push because it is one of the few pthread
        !           205:         # functions on Solaris that doesn't have a non-functional libc stub.
        !           206:         # We try pthread_create on general principles.
        !           207:         AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>
        !           208:                         static void routine(void *a) { a = 0; }
        !           209:                         static void *start_routine(void *a) { return a; }],
        !           210:                        [pthread_t th; pthread_attr_t attr;
        !           211:                         pthread_create(&th, 0, start_routine, 0);
        !           212:                         pthread_join(th, 0);
        !           213:                         pthread_attr_init(&attr);
        !           214:                         pthread_cleanup_push(routine, 0);
        !           215:                         pthread_cleanup_pop(0) /* ; */])],
        !           216:                 [ax_pthread_ok=yes],
        !           217:                 [])
        !           218: 
        !           219:         LIBS="$save_LIBS"
        !           220:         CFLAGS="$save_CFLAGS"
        !           221: 
        !           222:         AC_MSG_RESULT($ax_pthread_ok)
        !           223:         if test "x$ax_pthread_ok" = xyes; then
        !           224:                 break;
        !           225:         fi
        !           226: 
        !           227:         PTHREAD_LIBS=""
        !           228:         PTHREAD_CFLAGS=""
        !           229: done
        !           230: fi
        !           231: 
        !           232: # Various other checks:
        !           233: if test "x$ax_pthread_ok" = xyes; then
        !           234:         save_LIBS="$LIBS"
        !           235:         LIBS="$PTHREAD_LIBS $LIBS"
        !           236:         save_CFLAGS="$CFLAGS"
        !           237:         CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
        !           238: 
        !           239:         # Detect AIX lossage: JOINABLE attribute is called UNDETACHED.
        !           240:         AC_MSG_CHECKING([for joinable pthread attribute])
        !           241:         attr_name=unknown
        !           242:         for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do
        !           243:             AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>],
        !           244:                            [int attr = $attr; return attr /* ; */])],
        !           245:                 [attr_name=$attr; break],
        !           246:                 [])
        !           247:         done
        !           248:         AC_MSG_RESULT($attr_name)
        !           249:         if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then
        !           250:             AC_DEFINE_UNQUOTED(PTHREAD_CREATE_JOINABLE, $attr_name,
        !           251:                                [Define to necessary symbol if this constant
        !           252:                                 uses a non-standard name on your system.])
        !           253:         fi
        !           254: 
        !           255:         AC_MSG_CHECKING([if more special flags are required for pthreads])
        !           256:         flag=no
        !           257:         case ${host_os} in
        !           258:             aix* | freebsd* | darwin*) flag="-D_THREAD_SAFE";;
        !           259:             osf* | hpux*) flag="-D_REENTRANT";;
        !           260:             solaris*)
        !           261:             if test "$GCC" = "yes"; then
        !           262:                 flag="-D_REENTRANT"
        !           263:             else
        !           264:                 flag="-mt -D_REENTRANT"
        !           265:             fi
        !           266:             ;;
        !           267:         esac
        !           268:         AC_MSG_RESULT(${flag})
        !           269:         if test "x$flag" != xno; then
        !           270:             PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"
        !           271:         fi
        !           272: 
        !           273:         AC_CACHE_CHECK([for PTHREAD_PRIO_INHERIT],
        !           274:             ax_cv_PTHREAD_PRIO_INHERIT, [
        !           275:                 AC_LINK_IFELSE([
        !           276:                     AC_LANG_PROGRAM([[#include <pthread.h>]], [[int i = PTHREAD_PRIO_INHERIT;]])],
        !           277:                     [ax_cv_PTHREAD_PRIO_INHERIT=yes],
        !           278:                     [ax_cv_PTHREAD_PRIO_INHERIT=no])
        !           279:             ])
        !           280:         AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes"],
        !           281:             AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], 1, [Have PTHREAD_PRIO_INHERIT.]))
        !           282: 
        !           283:         LIBS="$save_LIBS"
        !           284:         CFLAGS="$save_CFLAGS"
        !           285: 
        !           286:         # More AIX lossage: must compile with xlc_r or cc_r
        !           287:         if test x"$GCC" != xyes; then
        !           288:           AC_CHECK_PROGS(PTHREAD_CC, xlc_r cc_r, ${CC})
        !           289:         else
        !           290:           PTHREAD_CC=$CC
        !           291:         fi
        !           292: else
        !           293:         PTHREAD_CC="$CC"
        !           294: fi
        !           295: 
        !           296: AC_SUBST(PTHREAD_LIBS)
        !           297: AC_SUBST(PTHREAD_CFLAGS)
        !           298: AC_SUBST(PTHREAD_CC)
        !           299: 
        !           300: # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
        !           301: if test x"$ax_pthread_ok" = xyes; then
        !           302:         ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1])
        !           303:         :
        !           304: else
        !           305:         ax_pthread_ok=no
        !           306:         $2
        !           307: fi
        !           308: AC_LANG_POP
        !           309: ])dnl AX_PTHREAD

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>