Annotation of embedaddon/curl/m4/curl-reentrant.m4, revision 1.1.1.1
1.1 misho 1: #***************************************************************************
2: # _ _ ____ _
3: # Project ___| | | | _ \| |
4: # / __| | | | |_) | |
5: # | (__| |_| | _ <| |___
6: # \___|\___/|_| \_\_____|
7: #
8: # Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
9: #
10: # This software is licensed as described in the file COPYING, which
11: # you should have received as part of this distribution. The terms
12: # are also available at https://curl.haxx.se/docs/copyright.html.
13: #
14: # You may opt to use, copy, modify, merge, publish, distribute and/or sell
15: # copies of the Software, and permit persons to whom the Software is
16: # furnished to do so, under the terms of the COPYING file.
17: #
18: # This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19: # KIND, either express or implied.
20: #
21: #***************************************************************************
22:
23: # File version for 'aclocal' use. Keep it a single number.
24: # serial 10
25:
26: dnl Note 1
27: dnl ------
28: dnl None of the CURL_CHECK_NEED_REENTRANT_* macros shall use HAVE_FOO_H to
29: dnl conditionally include header files. These macros are used early in the
30: dnl configure process much before header file availability is known.
31:
32:
33: dnl CURL_CHECK_NEED_REENTRANT_ERRNO
34: dnl -------------------------------------------------
35: dnl Checks if the preprocessor _REENTRANT definition
36: dnl makes errno available as a preprocessor macro.
37:
38: AC_DEFUN([CURL_CHECK_NEED_REENTRANT_ERRNO], [
39: AC_COMPILE_IFELSE([
40: AC_LANG_PROGRAM([[
41: #include <errno.h>
42: ]],[[
43: if(0 != errno)
44: return 1;
45: ]])
46: ],[
47: tmp_errno="yes"
48: ],[
49: tmp_errno="no"
50: ])
51: if test "$tmp_errno" = "yes"; then
52: AC_COMPILE_IFELSE([
53: AC_LANG_PROGRAM([[
54: #include <errno.h>
55: ]],[[
56: #ifdef errno
57: int dummy=1;
58: #else
59: force compilation error
60: #endif
61: ]])
62: ],[
63: tmp_errno="errno_macro_defined"
64: ],[
65: AC_COMPILE_IFELSE([
66: AC_LANG_PROGRAM([[
67: #define _REENTRANT
68: #include <errno.h>
69: ]],[[
70: #ifdef errno
71: int dummy=1;
72: #else
73: force compilation error
74: #endif
75: ]])
76: ],[
77: tmp_errno="errno_macro_needs_reentrant"
78: tmp_need_reentrant="yes"
79: ])
80: ])
81: fi
82: ])
83:
84:
85: dnl CURL_CHECK_NEED_REENTRANT_GMTIME_R
86: dnl -------------------------------------------------
87: dnl Checks if the preprocessor _REENTRANT definition
88: dnl makes function gmtime_r compiler visible.
89:
90: AC_DEFUN([CURL_CHECK_NEED_REENTRANT_GMTIME_R], [
91: AC_LINK_IFELSE([
92: AC_LANG_FUNC_LINK_TRY([gmtime_r])
93: ],[
94: tmp_gmtime_r="yes"
95: ],[
96: tmp_gmtime_r="no"
97: ])
98: if test "$tmp_gmtime_r" = "yes"; then
99: AC_EGREP_CPP([gmtime_r],[
100: #include <sys/types.h>
101: #include <time.h>
102: ],[
103: tmp_gmtime_r="proto_declared"
104: ],[
105: AC_EGREP_CPP([gmtime_r],[
106: #define _REENTRANT
107: #include <sys/types.h>
108: #include <time.h>
109: ],[
110: tmp_gmtime_r="proto_needs_reentrant"
111: tmp_need_reentrant="yes"
112: ])
113: ])
114: fi
115: ])
116:
117:
118: dnl CURL_CHECK_NEED_REENTRANT_LOCALTIME_R
119: dnl -------------------------------------------------
120: dnl Checks if the preprocessor _REENTRANT definition
121: dnl makes function localtime_r compiler visible.
122:
123: AC_DEFUN([CURL_CHECK_NEED_REENTRANT_LOCALTIME_R], [
124: AC_LINK_IFELSE([
125: AC_LANG_FUNC_LINK_TRY([localtime_r])
126: ],[
127: tmp_localtime_r="yes"
128: ],[
129: tmp_localtime_r="no"
130: ])
131: if test "$tmp_localtime_r" = "yes"; then
132: AC_EGREP_CPP([localtime_r],[
133: #include <sys/types.h>
134: #include <time.h>
135: ],[
136: tmp_localtime_r="proto_declared"
137: ],[
138: AC_EGREP_CPP([localtime_r],[
139: #define _REENTRANT
140: #include <sys/types.h>
141: #include <time.h>
142: ],[
143: tmp_localtime_r="proto_needs_reentrant"
144: tmp_need_reentrant="yes"
145: ])
146: ])
147: fi
148: ])
149:
150:
151: dnl CURL_CHECK_NEED_REENTRANT_STRERROR_R
152: dnl -------------------------------------------------
153: dnl Checks if the preprocessor _REENTRANT definition
154: dnl makes function strerror_r compiler visible.
155:
156: AC_DEFUN([CURL_CHECK_NEED_REENTRANT_STRERROR_R], [
157: AC_LINK_IFELSE([
158: AC_LANG_FUNC_LINK_TRY([strerror_r])
159: ],[
160: tmp_strerror_r="yes"
161: ],[
162: tmp_strerror_r="no"
163: ])
164: if test "$tmp_strerror_r" = "yes"; then
165: AC_EGREP_CPP([strerror_r],[
166: #include <sys/types.h>
167: #include <string.h>
168: ],[
169: tmp_strerror_r="proto_declared"
170: ],[
171: AC_EGREP_CPP([strerror_r],[
172: #define _REENTRANT
173: #include <sys/types.h>
174: #include <string.h>
175: ],[
176: tmp_strerror_r="proto_needs_reentrant"
177: tmp_need_reentrant="yes"
178: ])
179: ])
180: fi
181: ])
182:
183:
184: dnl CURL_CHECK_NEED_REENTRANT_STRTOK_R
185: dnl -------------------------------------------------
186: dnl Checks if the preprocessor _REENTRANT definition
187: dnl makes function strtok_r compiler visible.
188:
189: AC_DEFUN([CURL_CHECK_NEED_REENTRANT_STRTOK_R], [
190: AC_LINK_IFELSE([
191: AC_LANG_FUNC_LINK_TRY([strtok_r])
192: ],[
193: tmp_strtok_r="yes"
194: ],[
195: tmp_strtok_r="no"
196: ])
197: if test "$tmp_strtok_r" = "yes"; then
198: AC_EGREP_CPP([strtok_r],[
199: #include <sys/types.h>
200: #include <string.h>
201: ],[
202: tmp_strtok_r="proto_declared"
203: ],[
204: AC_EGREP_CPP([strtok_r],[
205: #define _REENTRANT
206: #include <sys/types.h>
207: #include <string.h>
208: ],[
209: tmp_strtok_r="proto_needs_reentrant"
210: tmp_need_reentrant="yes"
211: ])
212: ])
213: fi
214: ])
215:
216:
217: dnl CURL_CHECK_NEED_REENTRANT_INET_NTOA_R
218: dnl -------------------------------------------------
219: dnl Checks if the preprocessor _REENTRANT definition
220: dnl makes function inet_ntoa_r compiler visible.
221:
222: AC_DEFUN([CURL_CHECK_NEED_REENTRANT_INET_NTOA_R], [
223: AC_LINK_IFELSE([
224: AC_LANG_FUNC_LINK_TRY([inet_ntoa_r])
225: ],[
226: tmp_inet_ntoa_r="yes"
227: ],[
228: tmp_inet_ntoa_r="no"
229: ])
230: if test "$tmp_inet_ntoa_r" = "yes"; then
231: AC_EGREP_CPP([inet_ntoa_r],[
232: #include <sys/types.h>
233: #include <sys/socket.h>
234: #include <netinet/in.h>
235: #include <arpa/inet.h>
236: ],[
237: tmp_inet_ntoa_r="proto_declared"
238: ],[
239: AC_EGREP_CPP([inet_ntoa_r],[
240: #define _REENTRANT
241: #include <sys/types.h>
242: #include <sys/socket.h>
243: #include <netinet/in.h>
244: #include <arpa/inet.h>
245: ],[
246: tmp_inet_ntoa_r="proto_needs_reentrant"
247: tmp_need_reentrant="yes"
248: ])
249: ])
250: fi
251: ])
252:
253:
254: dnl CURL_CHECK_NEED_REENTRANT_GETHOSTBYADDR_R
255: dnl -------------------------------------------------
256: dnl Checks if the preprocessor _REENTRANT definition
257: dnl makes function gethostbyaddr_r compiler visible.
258:
259: AC_DEFUN([CURL_CHECK_NEED_REENTRANT_GETHOSTBYADDR_R], [
260: AC_LINK_IFELSE([
261: AC_LANG_FUNC_LINK_TRY([gethostbyaddr_r])
262: ],[
263: tmp_gethostbyaddr_r="yes"
264: ],[
265: tmp_gethostbyaddr_r="no"
266: ])
267: if test "$tmp_gethostbyaddr_r" = "yes"; then
268: AC_EGREP_CPP([gethostbyaddr_r],[
269: #include <sys/types.h>
270: #include <netdb.h>
271: ],[
272: tmp_gethostbyaddr_r="proto_declared"
273: ],[
274: AC_EGREP_CPP([gethostbyaddr_r],[
275: #define _REENTRANT
276: #include <sys/types.h>
277: #include <netdb.h>
278: ],[
279: tmp_gethostbyaddr_r="proto_needs_reentrant"
280: tmp_need_reentrant="yes"
281: ])
282: ])
283: fi
284: ])
285:
286:
287: dnl CURL_CHECK_NEED_REENTRANT_GETHOSTBYNAME_R
288: dnl -------------------------------------------------
289: dnl Checks if the preprocessor _REENTRANT definition
290: dnl makes function gethostbyname_r compiler visible.
291:
292: AC_DEFUN([CURL_CHECK_NEED_REENTRANT_GETHOSTBYNAME_R], [
293: AC_LINK_IFELSE([
294: AC_LANG_FUNC_LINK_TRY([gethostbyname_r])
295: ],[
296: tmp_gethostbyname_r="yes"
297: ],[
298: tmp_gethostbyname_r="no"
299: ])
300: if test "$tmp_gethostbyname_r" = "yes"; then
301: AC_EGREP_CPP([gethostbyname_r],[
302: #include <sys/types.h>
303: #include <netdb.h>
304: ],[
305: tmp_gethostbyname_r="proto_declared"
306: ],[
307: AC_EGREP_CPP([gethostbyname_r],[
308: #define _REENTRANT
309: #include <sys/types.h>
310: #include <netdb.h>
311: ],[
312: tmp_gethostbyname_r="proto_needs_reentrant"
313: tmp_need_reentrant="yes"
314: ])
315: ])
316: fi
317: ])
318:
319:
320: dnl CURL_CHECK_NEED_REENTRANT_GETPROTOBYNAME_R
321: dnl -------------------------------------------------
322: dnl Checks if the preprocessor _REENTRANT definition
323: dnl makes function getprotobyname_r compiler visible.
324:
325: AC_DEFUN([CURL_CHECK_NEED_REENTRANT_GETPROTOBYNAME_R], [
326: AC_LINK_IFELSE([
327: AC_LANG_FUNC_LINK_TRY([getprotobyname_r])
328: ],[
329: tmp_getprotobyname_r="yes"
330: ],[
331: tmp_getprotobyname_r="no"
332: ])
333: if test "$tmp_getprotobyname_r" = "yes"; then
334: AC_EGREP_CPP([getprotobyname_r],[
335: #include <sys/types.h>
336: #include <netdb.h>
337: ],[
338: tmp_getprotobyname_r="proto_declared"
339: ],[
340: AC_EGREP_CPP([getprotobyname_r],[
341: #define _REENTRANT
342: #include <sys/types.h>
343: #include <netdb.h>
344: ],[
345: tmp_getprotobyname_r="proto_needs_reentrant"
346: tmp_need_reentrant="yes"
347: ])
348: ])
349: fi
350: ])
351:
352:
353: dnl CURL_CHECK_NEED_REENTRANT_GETSERVBYPORT_R
354: dnl -------------------------------------------------
355: dnl Checks if the preprocessor _REENTRANT definition
356: dnl makes function getservbyport_r compiler visible.
357:
358: AC_DEFUN([CURL_CHECK_NEED_REENTRANT_GETSERVBYPORT_R], [
359: AC_LINK_IFELSE([
360: AC_LANG_FUNC_LINK_TRY([getservbyport_r])
361: ],[
362: tmp_getservbyport_r="yes"
363: ],[
364: tmp_getservbyport_r="no"
365: ])
366: if test "$tmp_getservbyport_r" = "yes"; then
367: AC_EGREP_CPP([getservbyport_r],[
368: #include <sys/types.h>
369: #include <netdb.h>
370: ],[
371: tmp_getservbyport_r="proto_declared"
372: ],[
373: AC_EGREP_CPP([getservbyport_r],[
374: #define _REENTRANT
375: #include <sys/types.h>
376: #include <netdb.h>
377: ],[
378: tmp_getservbyport_r="proto_needs_reentrant"
379: tmp_need_reentrant="yes"
380: ])
381: ])
382: fi
383: ])
384:
385:
386: dnl CURL_CHECK_NEED_REENTRANT_FUNCTIONS_R
387: dnl -------------------------------------------------
388: dnl Checks if the preprocessor _REENTRANT definition
389: dnl makes several _r functions compiler visible.
390: dnl Internal macro for CURL_CONFIGURE_REENTRANT.
391:
392: AC_DEFUN([CURL_CHECK_NEED_REENTRANT_FUNCTIONS_R], [
393: if test "$tmp_need_reentrant" = "no"; then
394: CURL_CHECK_NEED_REENTRANT_GMTIME_R
395: fi
396: if test "$tmp_need_reentrant" = "no"; then
397: CURL_CHECK_NEED_REENTRANT_LOCALTIME_R
398: fi
399: if test "$tmp_need_reentrant" = "no"; then
400: CURL_CHECK_NEED_REENTRANT_STRERROR_R
401: fi
402: if test "$tmp_need_reentrant" = "no"; then
403: CURL_CHECK_NEED_REENTRANT_STRTOK_R
404: fi
405: if test "$tmp_need_reentrant" = "no"; then
406: CURL_CHECK_NEED_REENTRANT_INET_NTOA_R
407: fi
408: if test "$tmp_need_reentrant" = "no"; then
409: CURL_CHECK_NEED_REENTRANT_GETHOSTBYADDR_R
410: fi
411: if test "$tmp_need_reentrant" = "no"; then
412: CURL_CHECK_NEED_REENTRANT_GETHOSTBYNAME_R
413: fi
414: if test "$tmp_need_reentrant" = "no"; then
415: CURL_CHECK_NEED_REENTRANT_GETPROTOBYNAME_R
416: fi
417: if test "$tmp_need_reentrant" = "no"; then
418: CURL_CHECK_NEED_REENTRANT_GETSERVBYPORT_R
419: fi
420: ])
421:
422:
423: dnl CURL_CHECK_NEED_REENTRANT_SYSTEM
424: dnl -------------------------------------------------
425: dnl Checks if the preprocessor _REENTRANT definition
426: dnl must be unconditionally done for this platform.
427: dnl Internal macro for CURL_CONFIGURE_REENTRANT.
428:
429: AC_DEFUN([CURL_CHECK_NEED_REENTRANT_SYSTEM], [
430: case $host_os in
431: solaris*)
432: tmp_need_reentrant="yes"
433: ;;
434: *)
435: tmp_need_reentrant="no"
436: ;;
437: esac
438: ])
439:
440:
441: dnl CURL_CHECK_NEED_THREAD_SAFE_SYSTEM
442: dnl -------------------------------------------------
443: dnl Checks if the preprocessor _THREAD_SAFE definition
444: dnl must be unconditionally done for this platform.
445: dnl Internal macro for CURL_CONFIGURE_THREAD_SAFE.
446:
447: AC_DEFUN([CURL_CHECK_NEED_THREAD_SAFE_SYSTEM], [
448: case $host_os in
449: aix[[123]].* | aix4.[[012]].*)
450: dnl aix 4.2 and older
451: tmp_need_thread_safe="no"
452: ;;
453: aix*)
454: dnl AIX 4.3 and newer
455: tmp_need_thread_safe="yes"
456: ;;
457: *)
458: tmp_need_thread_safe="no"
459: ;;
460: esac
461: ])
462:
463:
464: dnl CURL_CONFIGURE_FROM_NOW_ON_WITH_REENTRANT
465: dnl -------------------------------------------------
466: dnl This macro ensures that configuration tests done
467: dnl after this will execute with preprocessor symbol
468: dnl _REENTRANT defined. This macro also ensures that
469: dnl the generated config file defines NEED_REENTRANT
470: dnl and that in turn curl_setup.h will define _REENTRANT.
471: dnl Internal macro for CURL_CONFIGURE_REENTRANT.
472:
473: AC_DEFUN([CURL_CONFIGURE_FROM_NOW_ON_WITH_REENTRANT], [
474: AC_DEFINE(NEED_REENTRANT, 1,
475: [Define to 1 if _REENTRANT preprocessor symbol must be defined.])
476: cat >>confdefs.h <<_EOF
477: #ifndef _REENTRANT
478: # define _REENTRANT
479: #endif
480: _EOF
481: ])
482:
483:
484: dnl CURL_CONFIGURE_FROM_NOW_ON_WITH_THREAD_SAFE
485: dnl -------------------------------------------------
486: dnl This macro ensures that configuration tests done
487: dnl after this will execute with preprocessor symbol
488: dnl _THREAD_SAFE defined. This macro also ensures that
489: dnl the generated config file defines NEED_THREAD_SAFE
490: dnl and that in turn curl_setup.h will define _THREAD_SAFE.
491: dnl Internal macro for CURL_CONFIGURE_THREAD_SAFE.
492:
493: AC_DEFUN([CURL_CONFIGURE_FROM_NOW_ON_WITH_THREAD_SAFE], [
494: AC_DEFINE(NEED_THREAD_SAFE, 1,
495: [Define to 1 if _THREAD_SAFE preprocessor symbol must be defined.])
496: cat >>confdefs.h <<_EOF
497: #ifndef _THREAD_SAFE
498: # define _THREAD_SAFE
499: #endif
500: _EOF
501: ])
502:
503:
504: dnl CURL_CONFIGURE_REENTRANT
505: dnl -------------------------------------------------
506: dnl This first checks if the preprocessor _REENTRANT
507: dnl symbol is already defined. If it isn't currently
508: dnl defined a set of checks are performed to verify
509: dnl if its definition is required to make visible to
510: dnl the compiler a set of *_r functions. Finally, if
511: dnl _REENTRANT is already defined or needed it takes
512: dnl care of making adjustments necessary to ensure
513: dnl that it is defined equally for further configure
514: dnl tests and generated config file.
515:
516: AC_DEFUN([CURL_CONFIGURE_REENTRANT], [
517: AC_PREREQ([2.50])dnl
518: #
519: AC_MSG_CHECKING([if _REENTRANT is already defined])
520: AC_COMPILE_IFELSE([
521: AC_LANG_PROGRAM([[
522: ]],[[
523: #ifdef _REENTRANT
524: int dummy=1;
525: #else
526: force compilation error
527: #endif
528: ]])
529: ],[
530: AC_MSG_RESULT([yes])
531: tmp_reentrant_initially_defined="yes"
532: ],[
533: AC_MSG_RESULT([no])
534: tmp_reentrant_initially_defined="no"
535: ])
536: #
537: if test "$tmp_reentrant_initially_defined" = "no"; then
538: AC_MSG_CHECKING([if _REENTRANT is actually needed])
539: CURL_CHECK_NEED_REENTRANT_SYSTEM
540: if test "$tmp_need_reentrant" = "no"; then
541: CURL_CHECK_NEED_REENTRANT_ERRNO
542: fi
543: if test "$tmp_need_reentrant" = "no"; then
544: CURL_CHECK_NEED_REENTRANT_FUNCTIONS_R
545: fi
546: if test "$tmp_need_reentrant" = "yes"; then
547: AC_MSG_RESULT([yes])
548: else
549: AC_MSG_RESULT([no])
550: fi
551: fi
552: #
553: AC_MSG_CHECKING([if _REENTRANT is onwards defined])
554: if test "$tmp_reentrant_initially_defined" = "yes" ||
555: test "$tmp_need_reentrant" = "yes"; then
556: CURL_CONFIGURE_FROM_NOW_ON_WITH_REENTRANT
557: AC_MSG_RESULT([yes])
558: else
559: AC_MSG_RESULT([no])
560: fi
561: #
562: ])
563:
564:
565: dnl CURL_CONFIGURE_THREAD_SAFE
566: dnl -------------------------------------------------
567: dnl This first checks if the preprocessor _THREAD_SAFE
568: dnl symbol is already defined. If it isn't currently
569: dnl defined a set of checks are performed to verify
570: dnl if its definition is required. Finally, if
571: dnl _THREAD_SAFE is already defined or needed it takes
572: dnl care of making adjustments necessary to ensure
573: dnl that it is defined equally for further configure
574: dnl tests and generated config file.
575:
576: AC_DEFUN([CURL_CONFIGURE_THREAD_SAFE], [
577: AC_PREREQ([2.50])dnl
578: #
579: AC_MSG_CHECKING([if _THREAD_SAFE is already defined])
580: AC_COMPILE_IFELSE([
581: AC_LANG_PROGRAM([[
582: ]],[[
583: #ifdef _THREAD_SAFE
584: int dummy=1;
585: #else
586: force compilation error
587: #endif
588: ]])
589: ],[
590: AC_MSG_RESULT([yes])
591: tmp_thread_safe_initially_defined="yes"
592: ],[
593: AC_MSG_RESULT([no])
594: tmp_thread_safe_initially_defined="no"
595: ])
596: #
597: if test "$tmp_thread_safe_initially_defined" = "no"; then
598: AC_MSG_CHECKING([if _THREAD_SAFE is actually needed])
599: CURL_CHECK_NEED_THREAD_SAFE_SYSTEM
600: if test "$tmp_need_thread_safe" = "yes"; then
601: AC_MSG_RESULT([yes])
602: else
603: AC_MSG_RESULT([no])
604: fi
605: fi
606: #
607: AC_MSG_CHECKING([if _THREAD_SAFE is onwards defined])
608: if test "$tmp_thread_safe_initially_defined" = "yes" ||
609: test "$tmp_need_thread_safe" = "yes"; then
610: CURL_CONFIGURE_FROM_NOW_ON_WITH_THREAD_SAFE
611: AC_MSG_RESULT([yes])
612: else
613: AC_MSG_RESULT([no])
614: fi
615: #
616: ])
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to curl-reentrant.m4 CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / m4