« back to all changes in this revision
Viewing changes to m4/lock.m4~
- browse files at revision 5
- compare with another revision
- download diff
- download tarball
- view history from revision 5
- Committer: Bazaar Package Importer
- Author(s): Matthias Klose
- Date: 2007-07-31 18:37:38 UTC
- Revision ID: james.westby@ubuntu.com-20070731183738-f4u1l3m69i05473u
Tags: 2.2.3pre1-2ubuntu1
debian/rules: explicitely use bash for the install.
- files added:
- config.rpath
- m4
- files modified:
- debian/changelog
added
removed
m4/lock.m4~
1
# lock.m4 serial 6 (gettext-0.16)
2
dnl Copyright (C) 2005-2006 Free Software Foundation, Inc.
3
dnl This file is free software; the Free Software Foundation
4
dnl gives unlimited permission to copy and/or distribute it,
5
dnl with or without modifications, as long as this notice is preserved.
6
7
dnl From Bruno Haible.
8
9
dnl Tests for a multithreading library to be used.
10
dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS,
11
dnl USE_PTH_THREADS, USE_WIN32_THREADS
12
dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
13
dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
14
dnl libtool).
15
dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
16
dnl programs that really need multithread functionality. The difference
17
dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
18
dnl symbols, typically LIBTHREAD="" whereas LIBMULTITHREAD="-lpthread".
19
dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
20
dnl multithread-safe programs.
21
22
AC_DEFUN([gl_LOCK_EARLY],
23
[
24
AC_REQUIRE([gl_LOCK_EARLY_BODY])
25
])
26
27
dnl The guts of gl_LOCK_EARLY. Needs to be expanded only once.
28
29
AC_DEFUN([gl_LOCK_EARLY_BODY],
30
[
31
dnl Ordering constraints: This macro modifies CPPFLAGS in a way that
32
dnl influences the result of the autoconf tests that test for *_unlocked
33
dnl declarations, on AIX 5 at least. Therefore it must come early.
34
AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl
35
AC_BEFORE([$0], [gl_ARGP])dnl
36
37
AC_REQUIRE([AC_CANONICAL_HOST])
38
AC_REQUIRE([AC_GNU_SOURCE]) dnl needed for pthread_rwlock_t on glibc systems
39
dnl Check for multithreading.
40
AC_ARG_ENABLE(threads,
41
AC_HELP_STRING([--enable-threads={posix|solaris|pth|win32}], [specify multithreading API])
42
AC_HELP_STRING([--disable-threads], [build without multithread safety]),
43
[gl_use_threads=$enableval],
44
[case "$host_os" in
45
dnl Disable multithreading by default on OSF/1, because it interferes
46
dnl with fork()/exec(): When msgexec is linked with -lpthread, its child
47
dnl process gets an endless segmentation fault inside execvp().
48
osf*) gl_use_threads=no ;;
49
*) gl_use_threads=yes ;;
50
esac
51
])
52
if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
53
# For using <pthread.h>:
54
case "$host_os" in
55
osf*)
56
# On OSF/1, the compiler needs the flag -D_REENTRANT so that it
57
# groks <pthread.h>. cc also understands the flag -pthread, but
58
# we don't use it because 1. gcc-2.95 doesn't understand -pthread,
59
# 2. putting a flag into CPPFLAGS that has an effect on the linker
60
# causes the AC_TRY_LINK test below to succeed unexpectedly,
61
# leading to wrong values of LIBTHREAD and LTLIBTHREAD.
62
CPPFLAGS="$CPPFLAGS -D_REENTRANT"
63
;;
64
esac
65
# Some systems optimize for single-threaded programs by default, and
66
# need special flags to disable these optimizations. For example, the
67
# definition of 'errno' in <errno.h>.
68
case "$host_os" in
69
aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
70
solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
71
esac
72
fi
73
])
74
75
dnl The guts of gl_LOCK. Needs to be expanded only once.
76
77
AC_DEFUN([gl_LOCK_BODY],
78
[
79
AC_REQUIRE([gl_LOCK_EARLY_BODY])
80
gl_threads_api=none
81
LIBTHREAD=
82
LTLIBTHREAD=
83
LIBMULTITHREAD=
84
LTLIBMULTITHREAD=
85
if test "$gl_use_threads" != no; then
86
dnl Check whether the compiler and linker support weak declarations.
87
AC_MSG_CHECKING([whether imported symbols can be declared weak])
88
gl_have_weak=no
89
AC_TRY_LINK([extern void xyzzy ();
90
#pragma weak xyzzy], [xyzzy();], [gl_have_weak=yes])
91
AC_MSG_RESULT([$gl_have_weak])
92
if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
93
# On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
94
# it groks <pthread.h>. It's added above, in gl_LOCK_EARLY_BODY.
95
AC_CHECK_HEADER(pthread.h, gl_have_pthread_h=yes, gl_have_pthread_h=no)
96
if test "$gl_have_pthread_h" = yes; then
97
# Other possible tests:
98
# -lpthreads (FSU threads, PCthreads)
99
# -lgthreads
100
gl_have_pthread=
101
# Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
102
# in libc. IRIX 6.5 has the first one in both libc and libpthread, but
103
# the second one only in libpthread, and lock.c needs it.
104
AC_TRY_LINK([#include <pthread.h>],
105
[pthread_mutex_lock((pthread_mutex_t*)0);
106
pthread_mutexattr_init((pthread_mutexattr_t*)0);],
107
[gl_have_pthread=yes])
108
# Test for libpthread by looking for pthread_kill. (Not pthread_self,
109
# since it is defined as a macro on OSF/1.)
110
if test -n "$gl_have_pthread"; then
111
# The program links fine without libpthread. But it may actually
112
# need to link with libpthread in order to create multiple threads.
113
AC_CHECK_LIB(pthread, pthread_kill,
114
[LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
115
# On Solaris and HP-UX, most pthread functions exist also in libc.
116
# Therefore pthread_in_use() needs to actually try to create a
117
# thread: pthread_create from libc will fail, whereas
118
# pthread_create will actually create a thread.
119
case "$host_os" in
120
solaris* | hpux*)
121
AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], 1,
122
[Define if the pthread_in_use() detection is hard.])
123
esac
124
])
125
else
126
# Some library is needed. Try libpthread and libc_r.
127
AC_CHECK_LIB(pthread, pthread_kill,
128
[gl_have_pthread=yes
129
LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
130
LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
131
if test -z "$gl_have_pthread"; then
132
# For FreeBSD 4.
133
AC_CHECK_LIB(c_r, pthread_kill,
134
[gl_have_pthread=yes
135
LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
136
LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
137
fi
138
fi
139
if test -n "$gl_have_pthread"; then
140
gl_threads_api=posix
141
AC_DEFINE([USE_POSIX_THREADS], 1,
142
[Define if the POSIX multithreading library can be used.])
143
if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
144
if test $gl_have_weak = yes; then
145
AC_DEFINE([USE_POSIX_THREADS_WEAK], 1,
146
[Define if references to the POSIX multithreading library should be made weak.])
147
LIBTHREAD=
148
LTLIBTHREAD=
149
fi
150
fi
151
# OSF/1 4.0 and MacOS X 10.1 lack the pthread_rwlock_t type and the
152
# pthread_rwlock_* functions.
153
AC_CHECK_TYPE([pthread_rwlock_t],
154
[AC_DEFINE([HAVE_PTHREAD_RWLOCK], 1,
155
[Define if the POSIX multithreading library has read/write locks.])],
156
[],
157
[#include <pthread.h>])
158
# glibc defines PTHREAD_MUTEX_RECURSIVE as enum, not as a macro.
159
AC_TRY_COMPILE([#include <pthread.h>],
160
[#if __FreeBSD__ == 4
161
error "No, in FreeBSD 4.0 recursive mutexes actually don't work."
162
#else
163
int x = (int)PTHREAD_MUTEX_RECURSIVE;
164
return !x;
165
#endif],
166
[AC_DEFINE([HAVE_PTHREAD_MUTEX_RECURSIVE], 1,
167
[Define if the <pthread.h> defines PTHREAD_MUTEX_RECURSIVE.])])
168
fi
169
fi
170
fi
171
if test -z "$gl_have_pthread"; then
172
if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
173
gl_have_solaristhread=
174
gl_save_LIBS="$LIBS"
175
LIBS="$LIBS -lthread"
176
AC_TRY_LINK([#include <thread.h>
177
#include <synch.h>],
178
[thr_self();],
179
[gl_have_solaristhread=yes])
180
LIBS="$gl_save_LIBS"
181
if test -n "$gl_have_solaristhread"; then
182
gl_threads_api=solaris
183
LIBTHREAD=-lthread
184
LTLIBTHREAD=-lthread
185
LIBMULTITHREAD="$LIBTHREAD"
186
LTLIBMULTITHREAD="$LTLIBTHREAD"
187
AC_DEFINE([USE_SOLARIS_THREADS], 1,
188
[Define if the old Solaris multithreading library can be used.])
189
if test $gl_have_weak = yes; then
190
AC_DEFINE([USE_SOLARIS_THREADS_WEAK], 1,
191
[Define if references to the old Solaris multithreading library should be made weak.])
192
LIBTHREAD=
193
LTLIBTHREAD=
194
fi
195
fi
196
fi
197
fi
198
if test "$gl_use_threads" = pth; then
199
gl_save_CPPFLAGS="$CPPFLAGS"
200
AC_LIB_LINKFLAGS(pth)
201
gl_have_pth=
202
gl_save_LIBS="$LIBS"
203
LIBS="$LIBS -lpth"
204
AC_TRY_LINK([#include <pth.h>], [pth_self();], gl_have_pth=yes)
205
LIBS="$gl_save_LIBS"
206
if test -n "$gl_have_pth"; then
207
gl_threads_api=pth
208
LIBTHREAD="$LIBPTH"
209
LTLIBTHREAD="$LTLIBPTH"
210
LIBMULTITHREAD="$LIBTHREAD"
211
LTLIBMULTITHREAD="$LTLIBTHREAD"
212
AC_DEFINE([USE_PTH_THREADS], 1,
213
[Define if the GNU Pth multithreading library can be used.])
214
if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
215
if test $gl_have_weak = yes; then
216
AC_DEFINE([USE_PTH_THREADS_WEAK], 1,
217
[Define if references to the GNU Pth multithreading library should be made weak.])
218
LIBTHREAD=
219
LTLIBTHREAD=
220
fi
221
fi
222
else
223
CPPFLAGS="$gl_save_CPPFLAGS"
224
fi
225
fi
226
if test -z "$gl_have_pthread"; then
227
if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then
228
if { case "$host_os" in
229
mingw*) true;;
230
*) false;;
231
esac
232
}; then
233
gl_threads_api=win32
234
AC_DEFINE([USE_WIN32_THREADS], 1,
235
[Define if the Win32 multithreading API can be used.])
236
fi
237
fi
238
fi
239
fi
240
AC_MSG_CHECKING([for multithread API to use])
241
AC_MSG_RESULT([$gl_threads_api])
242
AC_SUBST(LIBTHREAD)
243
AC_SUBST(LTLIBTHREAD)
244
AC_SUBST(LIBMULTITHREAD)
245
AC_SUBST(LTLIBMULTITHREAD)
246
])
247
248
AC_DEFUN([gl_LOCK],
249
[
250
AC_REQUIRE([gl_LOCK_EARLY])
251
AC_REQUIRE([gl_LOCK_BODY])
252
gl_PREREQ_LOCK
253
])
254
255
# Prerequisites of lib/lock.c.
256
AC_DEFUN([gl_PREREQ_LOCK], [
257
AC_REQUIRE([AC_C_INLINE])
258
])
259
260
dnl Survey of platforms:
261
dnl
262
dnl Platform Available Compiler Supports test-lock
263
dnl flavours option weak result
264
dnl --------------- --------- --------- -------- ---------
265
dnl Linux 2.4/glibc posix -lpthread Y OK
266
dnl
267
dnl GNU Hurd/glibc posix
268
dnl
269
dnl FreeBSD 5.3 posix -lc_r Y
270
dnl posix -lkse ? Y
271
dnl posix -lpthread ? Y
272
dnl posix -lthr Y
273
dnl
274
dnl FreeBSD 5.2 posix -lc_r Y
275
dnl posix -lkse Y
276
dnl posix -lthr Y
277
dnl
278
dnl FreeBSD 4.0,4.10 posix -lc_r Y OK
279
dnl
280
dnl NetBSD 1.6 --
281
dnl
282
dnl OpenBSD 3.4 posix -lpthread Y OK
283
dnl
284
dnl MacOS X 10.[123] posix -lpthread Y OK
285
dnl
286
dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK
287
dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK
288
dnl
289
dnl HP-UX 11 posix -lpthread N (cc) OK
290
dnl Y (gcc)
291
dnl
292
dnl IRIX 6.5 posix -lpthread Y 0.5
293
dnl
294
dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK
295
dnl
296
dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK
297
dnl -lpthread (gcc) Y
298
dnl
299
dnl Cygwin posix -lpthread Y OK
300
dnl
301
dnl Any of the above pth -lpth 0.0
302
dnl
303
dnl Mingw win32 N OK
304
dnl
305
dnl BeOS 5 --
306
dnl
307
dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
308
dnl turned off:
309
dnl OK if all three tests terminate OK,
310
dnl 0.5 if the first test terminates OK but the second one loops endlessly,
311
dnl 0.0 if the first test already loops endlessly.
Loggerhead is a web-based interface for Breezy
Version: 2.0.1