|
272
|
1 # printf.m4 serial 25
|
|
|
2 dnl Copyright (C) 2003, 2007-2008 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 Test whether the *printf family of functions supports the 'j', 'z', 't',
|
|
|
8 dnl 'L' size specifiers. (ISO C99, POSIX:2001)
|
|
|
9 dnl Result is gl_cv_func_printf_sizes_c99.
|
|
|
10
|
|
|
11 AC_DEFUN([gl_PRINTF_SIZES_C99],
|
|
|
12 [
|
|
|
13 AC_REQUIRE([AC_PROG_CC])
|
|
|
14 AC_REQUIRE([gl_AC_HEADER_STDINT_H])
|
|
|
15 AC_REQUIRE([gl_AC_HEADER_INTTYPES_H])
|
|
|
16 AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
|
|
|
17 AC_CACHE_CHECK([whether printf supports size specifiers as in C99],
|
|
|
18 [gl_cv_func_printf_sizes_c99],
|
|
|
19 [
|
|
|
20 AC_TRY_RUN([
|
|
|
21 #include <stddef.h>
|
|
|
22 #include <stdio.h>
|
|
|
23 #include <string.h>
|
|
|
24 #include <sys/types.h>
|
|
|
25 #if HAVE_STDINT_H_WITH_UINTMAX
|
|
|
26 # include <stdint.h>
|
|
|
27 #endif
|
|
|
28 #if HAVE_INTTYPES_H_WITH_UINTMAX
|
|
|
29 # include <inttypes.h>
|
|
|
30 #endif
|
|
|
31 static char buf[100];
|
|
|
32 int main ()
|
|
|
33 {
|
|
|
34 #if HAVE_STDINT_H_WITH_UINTMAX || HAVE_INTTYPES_H_WITH_UINTMAX
|
|
|
35 buf[0] = '\0';
|
|
|
36 if (sprintf (buf, "%ju %d", (uintmax_t) 12345671, 33, 44, 55) < 0
|
|
|
37 || strcmp (buf, "12345671 33") != 0)
|
|
|
38 return 1;
|
|
|
39 #endif
|
|
|
40 buf[0] = '\0';
|
|
|
41 if (sprintf (buf, "%zu %d", (size_t) 12345672, 33, 44, 55) < 0
|
|
|
42 || strcmp (buf, "12345672 33") != 0)
|
|
|
43 return 1;
|
|
|
44 buf[0] = '\0';
|
|
|
45 if (sprintf (buf, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55) < 0
|
|
|
46 || strcmp (buf, "12345673 33") != 0)
|
|
|
47 return 1;
|
|
|
48 buf[0] = '\0';
|
|
|
49 if (sprintf (buf, "%Lg %d", (long double) 1.5, 33, 44, 55) < 0
|
|
|
50 || strcmp (buf, "1.5 33") != 0)
|
|
|
51 return 1;
|
|
|
52 return 0;
|
|
|
53 }], [gl_cv_func_printf_sizes_c99=yes], [gl_cv_func_printf_sizes_c99=no],
|
|
|
54 [
|
|
|
55 changequote(,)dnl
|
|
|
56 case "$host_os" in
|
|
|
57 # Guess yes on glibc systems.
|
|
|
58 *-gnu*) gl_cv_func_printf_sizes_c99="guessing yes";;
|
|
|
59 # Guess yes on FreeBSD >= 5.
|
|
|
60 freebsd[1-4]*) gl_cv_func_printf_sizes_c99="guessing no";;
|
|
|
61 freebsd* | kfreebsd*) gl_cv_func_printf_sizes_c99="guessing yes";;
|
|
|
62 # Guess yes on MacOS X >= 10.3.
|
|
|
63 darwin[1-6].*) gl_cv_func_printf_sizes_c99="guessing no";;
|
|
|
64 darwin*) gl_cv_func_printf_sizes_c99="guessing yes";;
|
|
|
65 # Guess yes on OpenBSD >= 3.9.
|
|
|
66 openbsd[1-2].* | openbsd3.[0-8] | openbsd3.[0-8].*)
|
|
|
67 gl_cv_func_printf_sizes_c99="guessing no";;
|
|
|
68 openbsd*) gl_cv_func_printf_sizes_c99="guessing yes";;
|
|
|
69 # Guess yes on Solaris >= 2.10.
|
|
|
70 solaris2.[0-9]*) gl_cv_func_printf_sizes_c99="guessing no";;
|
|
|
71 solaris*) gl_cv_func_printf_sizes_c99="guessing yes";;
|
|
|
72 # Guess yes on NetBSD >= 3.
|
|
|
73 netbsd[1-2]* | netbsdelf[1-2]* | netbsdaout[1-2]* | netbsdcoff[1-2]*)
|
|
|
74 gl_cv_func_printf_sizes_c99="guessing no";;
|
|
|
75 netbsd*) gl_cv_func_printf_sizes_c99="guessing yes";;
|
|
|
76 # If we don't know, assume the worst.
|
|
|
77 *) gl_cv_func_printf_sizes_c99="guessing no";;
|
|
|
78 esac
|
|
|
79 changequote([,])dnl
|
|
|
80 ])
|
|
|
81 ])
|
|
|
82 ])
|
|
|
83
|
|
|
84 dnl Test whether the *printf family of functions supports 'long double'
|
|
|
85 dnl arguments together with the 'L' size specifier. (ISO C99, POSIX:2001)
|
|
|
86 dnl Result is gl_cv_func_printf_long_double.
|
|
|
87
|
|
|
88 AC_DEFUN([gl_PRINTF_LONG_DOUBLE],
|
|
|
89 [
|
|
|
90 AC_REQUIRE([AC_PROG_CC])
|
|
|
91 AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
|
|
|
92 AC_CACHE_CHECK([whether printf supports 'long double' arguments],
|
|
|
93 [gl_cv_func_printf_long_double],
|
|
|
94 [
|
|
|
95 AC_TRY_RUN([
|
|
|
96 #include <stdio.h>
|
|
|
97 #include <string.h>
|
|
|
98 static char buf[10000];
|
|
|
99 int main ()
|
|
|
100 {
|
|
|
101 buf[0] = '\0';
|
|
|
102 if (sprintf (buf, "%Lf %d", 1.75L, 33, 44, 55) < 0
|
|
|
103 || strcmp (buf, "1.750000 33") != 0)
|
|
|
104 return 1;
|
|
|
105 buf[0] = '\0';
|
|
|
106 if (sprintf (buf, "%Le %d", 1.75L, 33, 44, 55) < 0
|
|
|
107 || strcmp (buf, "1.750000e+00 33") != 0)
|
|
|
108 return 1;
|
|
|
109 buf[0] = '\0';
|
|
|
110 if (sprintf (buf, "%Lg %d", 1.75L, 33, 44, 55) < 0
|
|
|
111 || strcmp (buf, "1.75 33") != 0)
|
|
|
112 return 1;
|
|
|
113 return 0;
|
|
|
114 }], [gl_cv_func_printf_long_double=yes], [gl_cv_func_printf_long_double=no],
|
|
|
115 [
|
|
|
116 changequote(,)dnl
|
|
|
117 case "$host_os" in
|
|
|
118 beos*) gl_cv_func_printf_long_double="guessing no";;
|
|
|
119 mingw* | pw*) gl_cv_func_printf_long_double="guessing no";;
|
|
|
120 *) gl_cv_func_printf_long_double="guessing yes";;
|
|
|
121 esac
|
|
|
122 changequote([,])dnl
|
|
|
123 ])
|
|
|
124 ])
|
|
|
125 ])
|
|
|
126
|
|
|
127 dnl Test whether the *printf family of functions supports infinite and NaN
|
|
|
128 dnl 'double' arguments in the %f, %e, %g directives. (ISO C99, POSIX:2001)
|
|
|
129 dnl Result is gl_cv_func_printf_infinite.
|
|
|
130
|
|
|
131 AC_DEFUN([gl_PRINTF_INFINITE],
|
|
|
132 [
|
|
|
133 AC_REQUIRE([AC_PROG_CC])
|
|
|
134 AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
|
|
|
135 AC_CACHE_CHECK([whether printf supports infinite 'double' arguments],
|
|
|
136 [gl_cv_func_printf_infinite],
|
|
|
137 [
|
|
|
138 AC_TRY_RUN([
|
|
|
139 #include <stdio.h>
|
|
|
140 #include <string.h>
|
|
|
141 static int
|
|
|
142 strisnan (const char *string, size_t start_index, size_t end_index)
|
|
|
143 {
|
|
|
144 if (start_index < end_index)
|
|
|
145 {
|
|
|
146 if (string[start_index] == '-')
|
|
|
147 start_index++;
|
|
|
148 if (start_index + 3 <= end_index
|
|
|
149 && memcmp (string + start_index, "nan", 3) == 0)
|
|
|
150 {
|
|
|
151 start_index += 3;
|
|
|
152 if (start_index == end_index
|
|
|
153 || (string[start_index] == '(' && string[end_index - 1] == ')'))
|
|
|
154 return 1;
|
|
|
155 }
|
|
|
156 }
|
|
|
157 return 0;
|
|
|
158 }
|
|
|
159 static char buf[10000];
|
|
|
160 static double zero = 0.0;
|
|
|
161 int main ()
|
|
|
162 {
|
|
|
163 if (sprintf (buf, "%f", 1.0 / 0.0) < 0
|
|
|
164 || (strcmp (buf, "inf") != 0 && strcmp (buf, "infinity") != 0))
|
|
|
165 return 1;
|
|
|
166 if (sprintf (buf, "%f", -1.0 / 0.0) < 0
|
|
|
167 || (strcmp (buf, "-inf") != 0 && strcmp (buf, "-infinity") != 0))
|
|
|
168 return 1;
|
|
|
169 if (sprintf (buf, "%f", zero / zero) < 0
|
|
|
170 || !strisnan (buf, 0, strlen (buf)))
|
|
|
171 return 1;
|
|
|
172 if (sprintf (buf, "%e", 1.0 / 0.0) < 0
|
|
|
173 || (strcmp (buf, "inf") != 0 && strcmp (buf, "infinity") != 0))
|
|
|
174 return 1;
|
|
|
175 if (sprintf (buf, "%e", -1.0 / 0.0) < 0
|
|
|
176 || (strcmp (buf, "-inf") != 0 && strcmp (buf, "-infinity") != 0))
|
|
|
177 return 1;
|
|
|
178 if (sprintf (buf, "%e", zero / zero) < 0
|
|
|
179 || !strisnan (buf, 0, strlen (buf)))
|
|
|
180 return 1;
|
|
|
181 if (sprintf (buf, "%g", 1.0 / 0.0) < 0
|
|
|
182 || (strcmp (buf, "inf") != 0 && strcmp (buf, "infinity") != 0))
|
|
|
183 return 1;
|
|
|
184 if (sprintf (buf, "%g", -1.0 / 0.0) < 0
|
|
|
185 || (strcmp (buf, "-inf") != 0 && strcmp (buf, "-infinity") != 0))
|
|
|
186 return 1;
|
|
|
187 if (sprintf (buf, "%g", zero / zero) < 0
|
|
|
188 || !strisnan (buf, 0, strlen (buf)))
|
|
|
189 return 1;
|
|
|
190 return 0;
|
|
|
191 }], [gl_cv_func_printf_infinite=yes], [gl_cv_func_printf_infinite=no],
|
|
|
192 [
|
|
|
193 changequote(,)dnl
|
|
|
194 case "$host_os" in
|
|
|
195 # Guess yes on glibc systems.
|
|
|
196 *-gnu*) gl_cv_func_printf_infinite="guessing yes";;
|
|
|
197 # Guess yes on FreeBSD >= 6.
|
|
|
198 freebsd[1-5]*) gl_cv_func_printf_infinite="guessing no";;
|
|
|
199 freebsd* | kfreebsd*) gl_cv_func_printf_infinite="guessing yes";;
|
|
|
200 # Guess yes on MacOS X >= 10.3.
|
|
|
201 darwin[1-6].*) gl_cv_func_printf_infinite="guessing no";;
|
|
|
202 darwin*) gl_cv_func_printf_infinite="guessing yes";;
|
|
|
203 # Guess yes on HP-UX >= 11.
|
|
|
204 hpux[7-9]* | hpux10*) gl_cv_func_printf_infinite="guessing no";;
|
|
|
205 hpux*) gl_cv_func_printf_infinite="guessing yes";;
|
|
|
206 # Guess yes on NetBSD >= 3.
|
|
|
207 netbsd[1-2]* | netbsdelf[1-2]* | netbsdaout[1-2]* | netbsdcoff[1-2]*)
|
|
|
208 gl_cv_func_printf_infinite="guessing no";;
|
|
|
209 netbsd*) gl_cv_func_printf_infinite="guessing yes";;
|
|
|
210 # Guess yes on BeOS.
|
|
|
211 beos*) gl_cv_func_printf_infinite="guessing yes";;
|
|
|
212 # If we don't know, assume the worst.
|
|
|
213 *) gl_cv_func_printf_infinite="guessing no";;
|
|
|
214 esac
|
|
|
215 changequote([,])dnl
|
|
|
216 ])
|
|
|
217 ])
|
|
|
218 ])
|
|
|
219
|
|
|
220 dnl Test whether the *printf family of functions supports infinite and NaN
|
|
|
221 dnl 'long double' arguments in the %f, %e, %g directives. (ISO C99, POSIX:2001)
|
|
|
222 dnl Result is gl_cv_func_printf_infinite_long_double.
|
|
|
223
|
|
|
224 AC_DEFUN([gl_PRINTF_INFINITE_LONG_DOUBLE],
|
|
|
225 [
|
|
|
226 AC_REQUIRE([gl_PRINTF_LONG_DOUBLE])
|
|
|
227 AC_REQUIRE([AC_PROG_CC])
|
|
|
228 AC_REQUIRE([AC_C_BIGENDIAN])
|
|
|
229 AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
|
|
|
230 dnl The user can set or unset the variable gl_printf_safe to indicate
|
|
|
231 dnl that he wishes a safe handling of non-IEEE-754 'long double' values.
|
|
|
232 if test -n "$gl_printf_safe"; then
|
|
|
233 AC_DEFINE([CHECK_PRINTF_SAFE], 1,
|
|
|
234 [Define if you wish *printf() functions that have a safe handling of
|
|
|
235 non-IEEE-754 'long double' values.])
|
|
|
236 fi
|
|
|
237 case "$gl_cv_func_printf_long_double" in
|
|
|
238 *yes)
|
|
|
239 AC_CACHE_CHECK([whether printf supports infinite 'long double' arguments],
|
|
|
240 [gl_cv_func_printf_infinite_long_double],
|
|
|
241 [
|
|
|
242 AC_TRY_RUN([
|
|
|
243 ]GL_NOCRASH[
|
|
|
244 #include <float.h>
|
|
|
245 #include <stdio.h>
|
|
|
246 #include <string.h>
|
|
|
247 static int
|
|
|
248 strisnan (const char *string, size_t start_index, size_t end_index)
|
|
|
249 {
|
|
|
250 if (start_index < end_index)
|
|
|
251 {
|
|
|
252 if (string[start_index] == '-')
|
|
|
253 start_index++;
|
|
|
254 if (start_index + 3 <= end_index
|
|
|
255 && memcmp (string + start_index, "nan", 3) == 0)
|
|
|
256 {
|
|
|
257 start_index += 3;
|
|
|
258 if (start_index == end_index
|
|
|
259 || (string[start_index] == '(' && string[end_index - 1] == ')'))
|
|
|
260 return 1;
|
|
|
261 }
|
|
|
262 }
|
|
|
263 return 0;
|
|
|
264 }
|
|
|
265 static char buf[10000];
|
|
|
266 static long double zeroL = 0.0L;
|
|
|
267 int main ()
|
|
|
268 {
|
|
|
269 nocrash_init();
|
|
|
270 if (sprintf (buf, "%Lf", 1.0L / 0.0L) < 0
|
|
|
271 || (strcmp (buf, "inf") != 0 && strcmp (buf, "infinity") != 0))
|
|
|
272 return 1;
|
|
|
273 if (sprintf (buf, "%Lf", -1.0L / 0.0L) < 0
|
|
|
274 || (strcmp (buf, "-inf") != 0 && strcmp (buf, "-infinity") != 0))
|
|
|
275 return 1;
|
|
|
276 if (sprintf (buf, "%Lf", zeroL / zeroL) < 0
|
|
|
277 || !strisnan (buf, 0, strlen (buf)))
|
|
|
278 return 1;
|
|
|
279 if (sprintf (buf, "%Le", 1.0L / 0.0L) < 0
|
|
|
280 || (strcmp (buf, "inf") != 0 && strcmp (buf, "infinity") != 0))
|
|
|
281 return 1;
|
|
|
282 if (sprintf (buf, "%Le", -1.0L / 0.0L) < 0
|
|
|
283 || (strcmp (buf, "-inf") != 0 && strcmp (buf, "-infinity") != 0))
|
|
|
284 return 1;
|
|
|
285 if (sprintf (buf, "%Le", zeroL / zeroL) < 0
|
|
|
286 || !strisnan (buf, 0, strlen (buf)))
|
|
|
287 return 1;
|
|
|
288 if (sprintf (buf, "%Lg", 1.0L / 0.0L) < 0
|
|
|
289 || (strcmp (buf, "inf") != 0 && strcmp (buf, "infinity") != 0))
|
|
|
290 return 1;
|
|
|
291 if (sprintf (buf, "%Lg", -1.0L / 0.0L) < 0
|
|
|
292 || (strcmp (buf, "-inf") != 0 && strcmp (buf, "-infinity") != 0))
|
|
|
293 return 1;
|
|
|
294 if (sprintf (buf, "%Lg", zeroL / zeroL) < 0
|
|
|
295 || !strisnan (buf, 0, strlen (buf)))
|
|
|
296 return 1;
|
|
|
297 #if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_))
|
|
|
298 /* Representation of an 80-bit 'long double' as an initializer for a sequence
|
|
|
299 of 'unsigned int' words. */
|
|
|
300 # ifdef WORDS_BIGENDIAN
|
|
|
301 # define LDBL80_WORDS(exponent,manthi,mantlo) \
|
|
|
302 { ((unsigned int) (exponent) << 16) | ((unsigned int) (manthi) >> 16), \
|
|
|
303 ((unsigned int) (manthi) << 16) | (unsigned int) (mantlo) >> 16), \
|
|
|
304 (unsigned int) (mantlo) << 16 \
|
|
|
305 }
|
|
|
306 # else
|
|
|
307 # define LDBL80_WORDS(exponent,manthi,mantlo) \
|
|
|
308 { mantlo, manthi, exponent }
|
|
|
309 # endif
|
|
|
310 { /* Quiet NaN. */
|
|
|
311 static union { unsigned int word[4]; long double value; } x =
|
|
|
312 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
|
|
|
313 if (sprintf (buf, "%Lf", x.value) < 0
|
|
|
314 || !strisnan (buf, 0, strlen (buf)))
|
|
|
315 return 1;
|
|
|
316 if (sprintf (buf, "%Le", x.value) < 0
|
|
|
317 || !strisnan (buf, 0, strlen (buf)))
|
|
|
318 return 1;
|
|
|
319 if (sprintf (buf, "%Lg", x.value) < 0
|
|
|
320 || !strisnan (buf, 0, strlen (buf)))
|
|
|
321 return 1;
|
|
|
322 }
|
|
|
323 {
|
|
|
324 /* Signalling NaN. */
|
|
|
325 static union { unsigned int word[4]; long double value; } x =
|
|
|
326 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
|
|
|
327 if (sprintf (buf, "%Lf", x.value) < 0
|
|
|
328 || !strisnan (buf, 0, strlen (buf)))
|
|
|
329 return 1;
|
|
|
330 if (sprintf (buf, "%Le", x.value) < 0
|
|
|
331 || !strisnan (buf, 0, strlen (buf)))
|
|
|
332 return 1;
|
|
|
333 if (sprintf (buf, "%Lg", x.value) < 0
|
|
|
334 || !strisnan (buf, 0, strlen (buf)))
|
|
|
335 return 1;
|
|
|
336 }
|
|
|
337 { /* Pseudo-NaN. */
|
|
|
338 static union { unsigned int word[4]; long double value; } x =
|
|
|
339 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
|
|
|
340 if (sprintf (buf, "%Lf", x.value) < 0
|
|
|
341 || !strisnan (buf, 0, strlen (buf)))
|
|
|
342 return 1;
|
|
|
343 if (sprintf (buf, "%Le", x.value) < 0
|
|
|
344 || !strisnan (buf, 0, strlen (buf)))
|
|
|
345 return 1;
|
|
|
346 if (sprintf (buf, "%Lg", x.value) < 0
|
|
|
347 || !strisnan (buf, 0, strlen (buf)))
|
|
|
348 return 1;
|
|
|
349 }
|
|
|
350 { /* Pseudo-Infinity. */
|
|
|
351 static union { unsigned int word[4]; long double value; } x =
|
|
|
352 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
|
|
|
353 if (sprintf (buf, "%Lf", x.value) < 0
|
|
|
354 || !strisnan (buf, 0, strlen (buf)))
|
|
|
355 return 1;
|
|
|
356 if (sprintf (buf, "%Le", x.value) < 0
|
|
|
357 || !strisnan (buf, 0, strlen (buf)))
|
|
|
358 return 1;
|
|
|
359 if (sprintf (buf, "%Lg", x.value) < 0
|
|
|
360 || !strisnan (buf, 0, strlen (buf)))
|
|
|
361 return 1;
|
|
|
362 }
|
|
|
363 { /* Pseudo-Zero. */
|
|
|
364 static union { unsigned int word[4]; long double value; } x =
|
|
|
365 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
|
|
|
366 if (sprintf (buf, "%Lf", x.value) < 0
|
|
|
367 || !strisnan (buf, 0, strlen (buf)))
|
|
|
368 return 1;
|
|
|
369 if (sprintf (buf, "%Le", x.value) < 0
|
|
|
370 || !strisnan (buf, 0, strlen (buf)))
|
|
|
371 return 1;
|
|
|
372 if (sprintf (buf, "%Lg", x.value) < 0
|
|
|
373 || !strisnan (buf, 0, strlen (buf)))
|
|
|
374 return 1;
|
|
|
375 }
|
|
|
376 { /* Unnormalized number. */
|
|
|
377 static union { unsigned int word[4]; long double value; } x =
|
|
|
378 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
|
|
|
379 if (sprintf (buf, "%Lf", x.value) < 0
|
|
|
380 || !strisnan (buf, 0, strlen (buf)))
|
|
|
381 return 1;
|
|
|
382 if (sprintf (buf, "%Le", x.value) < 0
|
|
|
383 || !strisnan (buf, 0, strlen (buf)))
|
|
|
384 return 1;
|
|
|
385 if (sprintf (buf, "%Lg", x.value) < 0
|
|
|
386 || !strisnan (buf, 0, strlen (buf)))
|
|
|
387 return 1;
|
|
|
388 }
|
|
|
389 { /* Pseudo-Denormal. */
|
|
|
390 static union { unsigned int word[4]; long double value; } x =
|
|
|
391 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
|
|
|
392 if (sprintf (buf, "%Lf", x.value) < 0
|
|
|
393 || !strisnan (buf, 0, strlen (buf)))
|
|
|
394 return 1;
|
|
|
395 if (sprintf (buf, "%Le", x.value) < 0
|
|
|
396 || !strisnan (buf, 0, strlen (buf)))
|
|
|
397 return 1;
|
|
|
398 if (sprintf (buf, "%Lg", x.value) < 0
|
|
|
399 || !strisnan (buf, 0, strlen (buf)))
|
|
|
400 return 1;
|
|
|
401 }
|
|
|
402 #endif
|
|
|
403 return 0;
|
|
|
404 }],
|
|
|
405 [gl_cv_func_printf_infinite_long_double=yes],
|
|
|
406 [gl_cv_func_printf_infinite_long_double=no],
|
|
|
407 [
|
|
|
408 changequote(,)dnl
|
|
|
409 case "$host_cpu" in
|
|
|
410 # Guess no on ia64, x86_64, i386.
|
|
|
411 ia64 | x86_64 | i*86) gl_cv_func_printf_infinite_long_double="guessing no";;
|
|
|
412 *)
|
|
|
413 case "$host_os" in
|
|
|
414 # Guess yes on glibc systems.
|
|
|
415 *-gnu*) gl_cv_func_printf_infinite_long_double="guessing yes";;
|
|
|
416 # Guess yes on FreeBSD >= 6.
|
|
|
417 freebsd[1-5]*) gl_cv_func_printf_infinite_long_double="guessing no";;
|
|
|
418 freebsd* | kfreebsd*) gl_cv_func_printf_infinite_long_double="guessing yes";;
|
|
|
419 # Guess yes on MacOS X >= 10.3.
|
|
|
420 darwin[1-6].*) gl_cv_func_printf_infinite_long_double="guessing no";;
|
|
|
421 darwin*) gl_cv_func_printf_infinite_long_double="guessing yes";;
|
|
|
422 # Guess yes on HP-UX >= 11.
|
|
|
423 hpux[7-9]* | hpux10*) gl_cv_func_printf_infinite_long_double="guessing no";;
|
|
|
424 hpux*) gl_cv_func_printf_infinite_long_double="guessing yes";;
|
|
|
425 # Guess yes on NetBSD >= 3.
|
|
|
426 netbsd[1-2]* | netbsdelf[1-2]* | netbsdaout[1-2]* | netbsdcoff[1-2]*)
|
|
|
427 gl_cv_func_printf_infinite_long_double="guessing no";;
|
|
|
428 netbsd*) gl_cv_func_printf_infinite_long_double="guessing yes";;
|
|
|
429 # If we don't know, assume the worst.
|
|
|
430 *) gl_cv_func_printf_infinite_long_double="guessing no";;
|
|
|
431 esac
|
|
|
432 ;;
|
|
|
433 esac
|
|
|
434 changequote([,])dnl
|
|
|
435 ])
|
|
|
436 ])
|
|
|
437 ;;
|
|
|
438 *)
|
|
|
439 gl_cv_func_printf_infinite_long_double="irrelevant"
|
|
|
440 ;;
|
|
|
441 esac
|
|
|
442 ])
|
|
|
443
|
|
|
444 dnl Test whether the *printf family of functions supports the 'a' and 'A'
|
|
|
445 dnl conversion specifier for hexadecimal output of floating-point numbers.
|
|
|
446 dnl (ISO C99, POSIX:2001)
|
|
|
447 dnl Result is gl_cv_func_printf_directive_a.
|
|
|
448
|
|
|
449 AC_DEFUN([gl_PRINTF_DIRECTIVE_A],
|
|
|
450 [
|
|
|
451 AC_REQUIRE([AC_PROG_CC])
|
|
|
452 AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
|
|
|
453 AC_CACHE_CHECK([whether printf supports the 'a' and 'A' directives],
|
|
|
454 [gl_cv_func_printf_directive_a],
|
|
|
455 [
|
|
|
456 AC_TRY_RUN([
|
|
|
457 #include <stdio.h>
|
|
|
458 #include <string.h>
|
|
|
459 static char buf[100];
|
|
|
460 int main ()
|
|
|
461 {
|
|
|
462 if (sprintf (buf, "%a %d", 3.1416015625, 33, 44, 55) < 0
|
|
|
463 || (strcmp (buf, "0x1.922p+1 33") != 0
|
|
|
464 && strcmp (buf, "0x3.244p+0 33") != 0
|
|
|
465 && strcmp (buf, "0x6.488p-1 33") != 0
|
|
|
466 && strcmp (buf, "0xc.91p-2 33") != 0))
|
|
|
467 return 1;
|
|
|
468 if (sprintf (buf, "%A %d", -3.1416015625, 33, 44, 55) < 0
|
|
|
469 || (strcmp (buf, "-0X1.922P+1 33") != 0
|
|
|
470 && strcmp (buf, "-0X3.244P+0 33") != 0
|
|
|
471 && strcmp (buf, "-0X6.488P-1 33") != 0
|
|
|
472 && strcmp (buf, "-0XC.91P-2 33") != 0))
|
|
|
473 return 1;
|
|
|
474 /* This catches a FreeBSD 6.1 bug: it doesn't round. */
|
|
|
475 if (sprintf (buf, "%.2a %d", 1.51, 33, 44, 55) < 0
|
|
|
476 || (strcmp (buf, "0x1.83p+0 33") != 0
|
|
|
477 && strcmp (buf, "0x3.05p-1 33") != 0
|
|
|
478 && strcmp (buf, "0x6.0ap-2 33") != 0
|
|
|
479 && strcmp (buf, "0xc.14p-3 33") != 0))
|
|
|
480 return 1;
|
|
|
481 /* This catches a FreeBSD 6.1 bug. See
|
|
|
482 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
|
|
|
483 if (sprintf (buf, "%010a %d", 1.0 / 0.0, 33, 44, 55) < 0
|
|
|
484 || buf[0] == '0')
|
|
|
485 return 1;
|
|
|
486 /* This catches a MacOS X 10.3.9 (Darwin 7.9) bug. */
|
|
|
487 if (sprintf (buf, "%.1a", 1.999) < 0
|
|
|
488 || (strcmp (buf, "0x1.0p+1") != 0
|
|
|
489 && strcmp (buf, "0x2.0p+0") != 0
|
|
|
490 && strcmp (buf, "0x4.0p-1") != 0
|
|
|
491 && strcmp (buf, "0x8.0p-2") != 0))
|
|
|
492 return 1;
|
|
|
493 /* This catches the same MacOS X 10.3.9 (Darwin 7.9) bug and also a
|
|
|
494 glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>. */
|
|
|
495 if (sprintf (buf, "%.1La", 1.999L) < 0
|
|
|
496 || (strcmp (buf, "0x1.0p+1") != 0
|
|
|
497 && strcmp (buf, "0x2.0p+0") != 0
|
|
|
498 && strcmp (buf, "0x4.0p-1") != 0
|
|
|
499 && strcmp (buf, "0x8.0p-2") != 0))
|
|
|
500 return 1;
|
|
|
501 return 0;
|
|
|
502 }], [gl_cv_func_printf_directive_a=yes], [gl_cv_func_printf_directive_a=no],
|
|
|
503 [
|
|
|
504 case "$host_os" in
|
|
|
505 # Guess yes on glibc >= 2.5 systems.
|
|
|
506 *-gnu*)
|
|
|
507 AC_EGREP_CPP([BZ2908], [
|
|
|
508 #include <features.h>
|
|
|
509 #ifdef __GNU_LIBRARY__
|
|
|
510 #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 5) || (__GLIBC__ > 2)
|
|
|
511 BZ2908
|
|
|
512 #endif
|
|
|
513 #endif
|
|
|
514 ],
|
|
|
515 [gl_cv_func_printf_directive_a="guessing yes"],
|
|
|
516 [gl_cv_func_printf_directive_a="guessing no"])
|
|
|
517 ;;
|
|
|
518 # If we don't know, assume the worst.
|
|
|
519 *) gl_cv_func_printf_directive_a="guessing no";;
|
|
|
520 esac
|
|
|
521 ])
|
|
|
522 ])
|
|
|
523 ])
|
|
|
524
|
|
|
525 dnl Test whether the *printf family of functions supports the %F format
|
|
|
526 dnl directive. (ISO C99, POSIX:2001)
|
|
|
527 dnl Result is gl_cv_func_printf_directive_f.
|
|
|
528
|
|
|
529 AC_DEFUN([gl_PRINTF_DIRECTIVE_F],
|
|
|
530 [
|
|
|
531 AC_REQUIRE([AC_PROG_CC])
|
|
|
532 AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
|
|
|
533 AC_CACHE_CHECK([whether printf supports the 'F' directive],
|
|
|
534 [gl_cv_func_printf_directive_f],
|
|
|
535 [
|
|
|
536 AC_TRY_RUN([
|
|
|
537 #include <stdio.h>
|
|
|
538 #include <string.h>
|
|
|
539 static char buf[100];
|
|
|
540 int main ()
|
|
|
541 {
|
|
|
542 if (sprintf (buf, "%F %d", 1234567.0, 33, 44, 55) < 0
|
|
|
543 || strcmp (buf, "1234567.000000 33") != 0)
|
|
|
544 return 1;
|
|
|
545 if (sprintf (buf, "%F", 1.0 / 0.0) < 0
|
|
|
546 || (strcmp (buf, "INF") != 0 && strcmp (buf, "INFINITY") != 0))
|
|
|
547 return 1;
|
|
|
548 /* This catches a Cygwin 2007 bug. */
|
|
|
549 if (sprintf (buf, "%.F", 1234.0) < 0
|
|
|
550 || strcmp (buf, "1234") != 0)
|
|
|
551 return 1;
|
|
|
552 return 0;
|
|
|
553 }], [gl_cv_func_printf_directive_f=yes], [gl_cv_func_printf_directive_f=no],
|
|
|
554 [
|
|
|
555 changequote(,)dnl
|
|
|
556 case "$host_os" in
|
|
|
557 # Guess yes on glibc systems.
|
|
|
558 *-gnu*) gl_cv_func_printf_directive_f="guessing yes";;
|
|
|
559 # Guess yes on FreeBSD >= 6.
|
|
|
560 freebsd[1-5]*) gl_cv_func_printf_directive_f="guessing no";;
|
|
|
561 freebsd* | kfreebsd*) gl_cv_func_printf_directive_f="guessing yes";;
|
|
|
562 # Guess yes on MacOS X >= 10.3.
|
|
|
563 darwin[1-6].*) gl_cv_func_printf_directive_f="guessing no";;
|
|
|
564 darwin*) gl_cv_func_printf_directive_f="guessing yes";;
|
|
|
565 # Guess yes on Solaris >= 2.10.
|
|
|
566 solaris2.[0-9]*) gl_cv_func_printf_directive_f="guessing no";;
|
|
|
567 solaris*) gl_cv_func_printf_directive_f="guessing yes";;
|
|
|
568 # If we don't know, assume the worst.
|
|
|
569 *) gl_cv_func_printf_directive_f="guessing no";;
|
|
|
570 esac
|
|
|
571 changequote([,])dnl
|
|
|
572 ])
|
|
|
573 ])
|
|
|
574 ])
|
|
|
575
|
|
|
576 dnl Test whether the *printf family of functions supports the %n format
|
|
|
577 dnl directive. (ISO C99, POSIX:2001)
|
|
|
578 dnl Result is gl_cv_func_printf_directive_n.
|
|
|
579
|
|
|
580 AC_DEFUN([gl_PRINTF_DIRECTIVE_N],
|
|
|
581 [
|
|
|
582 AC_REQUIRE([AC_PROG_CC])
|
|
|
583 AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
|
|
|
584 AC_CACHE_CHECK([whether printf supports the 'n' directive],
|
|
|
585 [gl_cv_func_printf_directive_n],
|
|
|
586 [
|
|
|
587 AC_TRY_RUN([
|
|
|
588 #include <stdio.h>
|
|
|
589 #include <string.h>
|
|
|
590 static char fmtstring[10];
|
|
|
591 static char buf[100];
|
|
|
592 int main ()
|
|
|
593 {
|
|
|
594 int count = -1;
|
|
|
595 /* Copy the format string. Some systems (glibc with _FORTIFY_SOURCE=2)
|
|
|
596 support %n in format strings in read-only memory but not in writable
|
|
|
597 memory. */
|
|
|
598 strcpy (fmtstring, "%d %n");
|
|
|
599 if (sprintf (buf, fmtstring, 123, &count, 33, 44, 55) < 0
|
|
|
600 || strcmp (buf, "123 ") != 0
|
|
|
601 || count != 4)
|
|
|
602 return 1;
|
|
|
603 return 0;
|
|
|
604 }], [gl_cv_func_printf_directive_n=yes], [gl_cv_func_printf_directive_n=no],
|
|
|
605 [
|
|
|
606 changequote(,)dnl
|
|
|
607 case "$host_os" in
|
|
|
608 *) gl_cv_func_printf_directive_n="guessing yes";;
|
|
|
609 esac
|
|
|
610 changequote([,])dnl
|
|
|
611 ])
|
|
|
612 ])
|
|
|
613 ])
|
|
|
614
|
|
|
615 dnl Test whether the *printf family of functions supports POSIX/XSI format
|
|
|
616 dnl strings with positions. (POSIX:2001)
|
|
|
617 dnl Result is gl_cv_func_printf_positions.
|
|
|
618
|
|
|
619 AC_DEFUN([gl_PRINTF_POSITIONS],
|
|
|
620 [
|
|
|
621 AC_REQUIRE([AC_PROG_CC])
|
|
|
622 AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
|
|
|
623 AC_CACHE_CHECK([whether printf supports POSIX/XSI format strings with positions],
|
|
|
624 [gl_cv_func_printf_positions],
|
|
|
625 [
|
|
|
626 AC_TRY_RUN([
|
|
|
627 #include <stdio.h>
|
|
|
628 #include <string.h>
|
|
|
629 /* The string "%2$d %1$d", with dollar characters protected from the shell's
|
|
|
630 dollar expansion (possibly an autoconf bug). */
|
|
|
631 static char format[] = { '%', '2', '$', 'd', ' ', '%', '1', '$', 'd', '\0' };
|
|
|
632 static char buf[100];
|
|
|
633 int main ()
|
|
|
634 {
|
|
|
635 sprintf (buf, format, 33, 55);
|
|
|
636 return (strcmp (buf, "55 33") != 0);
|
|
|
637 }], [gl_cv_func_printf_positions=yes], [gl_cv_func_printf_positions=no],
|
|
|
638 [
|
|
|
639 changequote(,)dnl
|
|
|
640 case "$host_os" in
|
|
|
641 netbsd[1-3]* | netbsdelf[1-3]* | netbsdaout[1-3]* | netbsdcoff[1-3]*)
|
|
|
642 gl_cv_func_printf_positions="guessing no";;
|
|
|
643 beos*) gl_cv_func_printf_positions="guessing no";;
|
|
|
644 mingw* | pw*) gl_cv_func_printf_positions="guessing no";;
|
|
|
645 *) gl_cv_func_printf_positions="guessing yes";;
|
|
|
646 esac
|
|
|
647 changequote([,])dnl
|
|
|
648 ])
|
|
|
649 ])
|
|
|
650 ])
|
|
|
651
|
|
|
652 dnl Test whether the *printf family of functions supports POSIX/XSI format
|
|
|
653 dnl strings with the ' flag for grouping of decimal digits. (POSIX:2001)
|
|
|
654 dnl Result is gl_cv_func_printf_flag_grouping.
|
|
|
655
|
|
|
656 AC_DEFUN([gl_PRINTF_FLAG_GROUPING],
|
|
|
657 [
|
|
|
658 AC_REQUIRE([AC_PROG_CC])
|
|
|
659 AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
|
|
|
660 AC_CACHE_CHECK([whether printf supports the grouping flag],
|
|
|
661 [gl_cv_func_printf_flag_grouping],
|
|
|
662 [
|
|
|
663 AC_TRY_RUN([
|
|
|
664 #include <stdio.h>
|
|
|
665 #include <string.h>
|
|
|
666 static char buf[100];
|
|
|
667 int main ()
|
|
|
668 {
|
|
|
669 if (sprintf (buf, "%'d %d", 1234567, 99) < 0
|
|
|
670 || buf[strlen (buf) - 1] != '9')
|
|
|
671 return 1;
|
|
|
672 return 0;
|
|
|
673 }], [gl_cv_func_printf_flag_grouping=yes], [gl_cv_func_printf_flag_grouping=no],
|
|
|
674 [
|
|
|
675 changequote(,)dnl
|
|
|
676 case "$host_os" in
|
|
|
677 cygwin*) gl_cv_func_printf_flag_grouping="guessing no";;
|
|
|
678 netbsd*) gl_cv_func_printf_flag_grouping="guessing no";;
|
|
|
679 mingw* | pw*) gl_cv_func_printf_flag_grouping="guessing no";;
|
|
|
680 *) gl_cv_func_printf_flag_grouping="guessing yes";;
|
|
|
681 esac
|
|
|
682 changequote([,])dnl
|
|
|
683 ])
|
|
|
684 ])
|
|
|
685 ])
|
|
|
686
|
|
|
687 dnl Test whether the *printf family of functions supports the - flag correctly.
|
|
|
688 dnl (ISO C99.) See
|
|
|
689 dnl <http://lists.gnu.org/archive/html/bug-coreutils/2008-02/msg00035.html>
|
|
|
690 dnl Result is gl_cv_func_printf_flag_leftadjust.
|
|
|
691
|
|
|
692 AC_DEFUN([gl_PRINTF_FLAG_LEFTADJUST],
|
|
|
693 [
|
|
|
694 AC_REQUIRE([AC_PROG_CC])
|
|
|
695 AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
|
|
|
696 AC_CACHE_CHECK([whether printf supports the left-adjust flag correctly],
|
|
|
697 [gl_cv_func_printf_flag_leftadjust],
|
|
|
698 [
|
|
|
699 AC_TRY_RUN([
|
|
|
700 #include <stdio.h>
|
|
|
701 #include <string.h>
|
|
|
702 static char buf[100];
|
|
|
703 int main ()
|
|
|
704 {
|
|
|
705 /* Check that a '-' flag is not annihilated by a negative width. */
|
|
|
706 if (sprintf (buf, "a%-*sc", -3, "b") < 0
|
|
|
707 || strcmp (buf, "ab c") != 0)
|
|
|
708 return 1;
|
|
|
709 return 0;
|
|
|
710 }],
|
|
|
711 [gl_cv_func_printf_flag_leftadjust=yes],
|
|
|
712 [gl_cv_func_printf_flag_leftadjust=no],
|
|
|
713 [
|
|
|
714 changequote(,)dnl
|
|
|
715 case "$host_os" in
|
|
|
716 # Guess yes on HP-UX 11.
|
|
|
717 hpux11*) gl_cv_func_printf_flag_leftadjust="guessing yes";;
|
|
|
718 # Guess no on HP-UX 10 and older.
|
|
|
719 hpux*) gl_cv_func_printf_flag_leftadjust="guessing no";;
|
|
|
720 # Guess yes otherwise.
|
|
|
721 *) gl_cv_func_printf_flag_leftadjust="guessing yes";;
|
|
|
722 esac
|
|
|
723 changequote([,])dnl
|
|
|
724 ])
|
|
|
725 ])
|
|
|
726 ])
|
|
|
727
|
|
|
728 dnl Test whether the *printf family of functions supports padding of non-finite
|
|
|
729 dnl values with the 0 flag correctly. (ISO C99 + TC1 + TC2.) See
|
|
|
730 dnl <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html>
|
|
|
731 dnl Result is gl_cv_func_printf_flag_zero.
|
|
|
732
|
|
|
733 AC_DEFUN([gl_PRINTF_FLAG_ZERO],
|
|
|
734 [
|
|
|
735 AC_REQUIRE([AC_PROG_CC])
|
|
|
736 AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
|
|
|
737 AC_CACHE_CHECK([whether printf supports the zero flag correctly],
|
|
|
738 [gl_cv_func_printf_flag_zero],
|
|
|
739 [
|
|
|
740 AC_TRY_RUN([
|
|
|
741 #include <stdio.h>
|
|
|
742 #include <string.h>
|
|
|
743 static char buf[100];
|
|
|
744 int main ()
|
|
|
745 {
|
|
|
746 if (sprintf (buf, "%010f", 1.0 / 0.0, 33, 44, 55) < 0
|
|
|
747 || (strcmp (buf, " inf") != 0
|
|
|
748 && strcmp (buf, " infinity") != 0))
|
|
|
749 return 1;
|
|
|
750 return 0;
|
|
|
751 }], [gl_cv_func_printf_flag_zero=yes], [gl_cv_func_printf_flag_zero=no],
|
|
|
752 [
|
|
|
753 changequote(,)dnl
|
|
|
754 case "$host_os" in
|
|
|
755 # Guess yes on glibc systems.
|
|
|
756 *-gnu*) gl_cv_func_printf_flag_zero="guessing yes";;
|
|
|
757 # Guess yes on BeOS.
|
|
|
758 beos*) gl_cv_func_printf_flag_zero="guessing yes";;
|
|
|
759 # If we don't know, assume the worst.
|
|
|
760 *) gl_cv_func_printf_flag_zero="guessing no";;
|
|
|
761 esac
|
|
|
762 changequote([,])dnl
|
|
|
763 ])
|
|
|
764 ])
|
|
|
765 ])
|
|
|
766
|
|
|
767 dnl Test whether the *printf family of functions supports large precisions.
|
|
|
768 dnl On mingw, precisions larger than 512 are treated like 512, in integer,
|
|
|
769 dnl floating-point or pointer output. On BeOS, precisions larger than 1044
|
|
|
770 dnl crash the program.
|
|
|
771 dnl Result is gl_cv_func_printf_precision.
|
|
|
772
|
|
|
773 AC_DEFUN([gl_PRINTF_PRECISION],
|
|
|
774 [
|
|
|
775 AC_REQUIRE([AC_PROG_CC])
|
|
|
776 AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
|
|
|
777 AC_CACHE_CHECK([whether printf supports large precisions],
|
|
|
778 [gl_cv_func_printf_precision],
|
|
|
779 [
|
|
|
780 AC_TRY_RUN([
|
|
|
781 #include <stdio.h>
|
|
|
782 #include <string.h>
|
|
|
783 static char buf[5000];
|
|
|
784 int main ()
|
|
|
785 {
|
|
|
786 #ifdef __BEOS__
|
|
|
787 /* On BeOS, this would crash and show a dialog box. Avoid the crash. */
|
|
|
788 return 1;
|
|
|
789 #endif
|
|
|
790 if (sprintf (buf, "%.4000d %d", 1, 33, 44) < 4000 + 3)
|
|
|
791 return 1;
|
|
|
792 return 0;
|
|
|
793 }], [gl_cv_func_printf_precision=yes], [gl_cv_func_printf_precision=no],
|
|
|
794 [
|
|
|
795 changequote(,)dnl
|
|
|
796 case "$host_os" in
|
|
|
797 # Guess no only on native Win32 and BeOS systems.
|
|
|
798 mingw* | pw*) gl_cv_func_printf_precision="guessing no" ;;
|
|
|
799 beos*) gl_cv_func_printf_precision="guessing no" ;;
|
|
|
800 *) gl_cv_func_printf_precision="guessing yes" ;;
|
|
|
801 esac
|
|
|
802 changequote([,])dnl
|
|
|
803 ])
|
|
|
804 ])
|
|
|
805 ])
|
|
|
806
|
|
|
807 dnl Test whether the *printf family of functions recovers gracefully in case
|
|
|
808 dnl of an out-of-memory condition, or whether it crashes the entire program.
|
|
|
809 dnl Result is gl_cv_func_printf_enomem.
|
|
|
810
|
|
|
811 AC_DEFUN([gl_PRINTF_ENOMEM],
|
|
|
812 [
|
|
|
813 AC_REQUIRE([AC_PROG_CC])
|
|
|
814 AC_REQUIRE([gl_MULTIARCH])
|
|
|
815 AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
|
|
|
816 AC_CACHE_CHECK([whether printf survives out-of-memory conditions],
|
|
|
817 [gl_cv_func_printf_enomem],
|
|
|
818 [
|
|
|
819 gl_cv_func_printf_enomem="guessing no"
|
|
|
820 if test "$cross_compiling" = no; then
|
|
|
821 if test $APPLE_UNIVERSAL_BUILD = 0; then
|
|
|
822 AC_LANG_CONFTEST([AC_LANG_SOURCE([
|
|
|
823 ]GL_NOCRASH[
|
|
|
824 changequote(,)dnl
|
|
|
825 #include <stdio.h>
|
|
|
826 #include <sys/types.h>
|
|
|
827 #include <sys/time.h>
|
|
|
828 #include <sys/resource.h>
|
|
|
829 #include <errno.h>
|
|
|
830 int main()
|
|
|
831 {
|
|
|
832 struct rlimit limit;
|
|
|
833 int ret;
|
|
|
834 nocrash_init ();
|
|
|
835 /* Some printf implementations allocate temporary space with malloc. */
|
|
|
836 /* On BSD systems, malloc() is limited by RLIMIT_DATA. */
|
|
|
837 #ifdef RLIMIT_DATA
|
|
|
838 if (getrlimit (RLIMIT_DATA, &limit) < 0)
|
|
|
839 return 77;
|
|
|
840 if (limit.rlim_max == RLIM_INFINITY || limit.rlim_max > 5000000)
|
|
|
841 limit.rlim_max = 5000000;
|
|
|
842 limit.rlim_cur = limit.rlim_max;
|
|
|
843 if (setrlimit (RLIMIT_DATA, &limit) < 0)
|
|
|
844 return 77;
|
|
|
845 #endif
|
|
|
846 /* On Linux systems, malloc() is limited by RLIMIT_AS. */
|
|
|
847 #ifdef RLIMIT_AS
|
|
|
848 if (getrlimit (RLIMIT_AS, &limit) < 0)
|
|
|
849 return 77;
|
|
|
850 if (limit.rlim_max == RLIM_INFINITY || limit.rlim_max > 5000000)
|
|
|
851 limit.rlim_max = 5000000;
|
|
|
852 limit.rlim_cur = limit.rlim_max;
|
|
|
853 if (setrlimit (RLIMIT_AS, &limit) < 0)
|
|
|
854 return 77;
|
|
|
855 #endif
|
|
|
856 /* Some printf implementations allocate temporary space on the stack. */
|
|
|
857 #ifdef RLIMIT_STACK
|
|
|
858 if (getrlimit (RLIMIT_STACK, &limit) < 0)
|
|
|
859 return 77;
|
|
|
860 if (limit.rlim_max == RLIM_INFINITY || limit.rlim_max > 5000000)
|
|
|
861 limit.rlim_max = 5000000;
|
|
|
862 limit.rlim_cur = limit.rlim_max;
|
|
|
863 if (setrlimit (RLIMIT_STACK, &limit) < 0)
|
|
|
864 return 77;
|
|
|
865 #endif
|
|
|
866 ret = printf ("%.5000000f", 1.0);
|
|
|
867 return !(ret == 5000002 || (ret < 0 && errno == ENOMEM));
|
|
|
868 }
|
|
|
869 changequote([,])dnl
|
|
|
870 ])])
|
|
|
871 if AC_TRY_EVAL([ac_link]) && test -s conftest$ac_exeext; then
|
|
|
872 (./conftest
|
|
|
873 result=$?
|
|
|
874 if test $result != 0 && test $result != 77; then result=1; fi
|
|
|
875 exit $result
|
|
|
876 ) >/dev/null 2>/dev/null
|
|
|
877 case $? in
|
|
|
878 0) gl_cv_func_printf_enomem="yes" ;;
|
|
|
879 77) gl_cv_func_printf_enomem="guessing no" ;;
|
|
|
880 *) gl_cv_func_printf_enomem="no" ;;
|
|
|
881 esac
|
|
|
882 else
|
|
|
883 gl_cv_func_printf_enomem="guessing no"
|
|
|
884 fi
|
|
|
885 rm -fr conftest*
|
|
|
886 else
|
|
|
887 dnl A universal build on Apple MacOS X platforms.
|
|
|
888 dnl The result would be 'no' in 32-bit mode and 'yes' in 64-bit mode.
|
|
|
889 dnl But we need a configuration result that is valid in both modes.
|
|
|
890 gl_cv_func_printf_enomem="guessing no"
|
|
|
891 fi
|
|
|
892 fi
|
|
|
893 if test "$gl_cv_func_printf_enomem" = "guessing no"; then
|
|
|
894 changequote(,)dnl
|
|
|
895 case "$host_os" in
|
|
|
896 # Guess yes on glibc systems.
|
|
|
897 *-gnu*) gl_cv_func_printf_enomem="guessing yes";;
|
|
|
898 # Guess yes on Solaris.
|
|
|
899 solaris*) gl_cv_func_printf_enomem="guessing yes";;
|
|
|
900 # Guess yes on AIX.
|
|
|
901 aix*) gl_cv_func_printf_enomem="guessing yes";;
|
|
|
902 # Guess yes on HP-UX/hppa.
|
|
|
903 hpux*) case "$host_cpu" in
|
|
|
904 hppa*) gl_cv_func_printf_enomem="guessing yes";;
|
|
|
905 *) gl_cv_func_printf_enomem="guessing no";;
|
|
|
906 esac
|
|
|
907 ;;
|
|
|
908 # Guess yes on IRIX.
|
|
|
909 irix*) gl_cv_func_printf_enomem="guessing yes";;
|
|
|
910 # Guess yes on OSF/1.
|
|
|
911 osf*) gl_cv_func_printf_enomem="guessing yes";;
|
|
|
912 # Guess yes on BeOS.
|
|
|
913 beos*) gl_cv_func_printf_enomem="guessing yes";;
|
|
|
914 # Guess yes on Haiku.
|
|
|
915 haiku*) gl_cv_func_printf_enomem="guessing yes";;
|
|
|
916 # If we don't know, assume the worst.
|
|
|
917 *) gl_cv_func_printf_enomem="guessing no";;
|
|
|
918 esac
|
|
|
919 changequote([,])dnl
|
|
|
920 fi
|
|
|
921 ])
|
|
|
922 ])
|
|
|
923
|
|
|
924 dnl Test whether the snprintf function exists. (ISO C99, POSIX:2001)
|
|
|
925 dnl Result is ac_cv_func_snprintf.
|
|
|
926
|
|
|
927 AC_DEFUN([gl_SNPRINTF_PRESENCE],
|
|
|
928 [
|
|
|
929 AC_CHECK_FUNCS_ONCE([snprintf])
|
|
|
930 ])
|
|
|
931
|
|
|
932 dnl Test whether the string produced by the snprintf function is always NUL
|
|
|
933 dnl terminated. (ISO C99, POSIX:2001)
|
|
|
934 dnl Result is gl_cv_func_snprintf_truncation_c99.
|
|
|
935
|
|
|
936 AC_DEFUN([gl_SNPRINTF_TRUNCATION_C99],
|
|
|
937 [
|
|
|
938 AC_REQUIRE([AC_PROG_CC])
|
|
|
939 AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
|
|
|
940 AC_CACHE_CHECK([whether snprintf truncates the result as in C99],
|
|
|
941 [gl_cv_func_snprintf_truncation_c99],
|
|
|
942 [
|
|
|
943 AC_TRY_RUN([
|
|
|
944 #include <stdio.h>
|
|
|
945 #include <string.h>
|
|
|
946 static char buf[100];
|
|
|
947 int main ()
|
|
|
948 {
|
|
|
949 strcpy (buf, "ABCDEF");
|
|
|
950 snprintf (buf, 3, "%d %d", 4567, 89);
|
|
|
951 if (memcmp (buf, "45\0DEF", 6) != 0)
|
|
|
952 return 1;
|
|
|
953 return 0;
|
|
|
954 }], [gl_cv_func_snprintf_truncation_c99=yes], [gl_cv_func_snprintf_truncation_c99=no],
|
|
|
955 [
|
|
|
956 changequote(,)dnl
|
|
|
957 case "$host_os" in
|
|
|
958 # Guess yes on glibc systems.
|
|
|
959 *-gnu*) gl_cv_func_snprintf_truncation_c99="guessing yes";;
|
|
|
960 # Guess yes on FreeBSD >= 5.
|
|
|
961 freebsd[1-4]*) gl_cv_func_snprintf_truncation_c99="guessing no";;
|
|
|
962 freebsd* | kfreebsd*) gl_cv_func_snprintf_truncation_c99="guessing yes";;
|
|
|
963 # Guess yes on MacOS X >= 10.3.
|
|
|
964 darwin[1-6].*) gl_cv_func_snprintf_truncation_c99="guessing no";;
|
|
|
965 darwin*) gl_cv_func_snprintf_truncation_c99="guessing yes";;
|
|
|
966 # Guess yes on OpenBSD >= 3.9.
|
|
|
967 openbsd[1-2].* | openbsd3.[0-8] | openbsd3.[0-8].*)
|
|
|
968 gl_cv_func_snprintf_truncation_c99="guessing no";;
|
|
|
969 openbsd*) gl_cv_func_snprintf_truncation_c99="guessing yes";;
|
|
|
970 # Guess yes on Solaris >= 2.6.
|
|
|
971 solaris2.[0-5]*) gl_cv_func_snprintf_truncation_c99="guessing no";;
|
|
|
972 solaris*) gl_cv_func_snprintf_truncation_c99="guessing yes";;
|
|
|
973 # Guess yes on AIX >= 4.
|
|
|
974 aix[1-3]*) gl_cv_func_snprintf_truncation_c99="guessing no";;
|
|
|
975 aix*) gl_cv_func_snprintf_truncation_c99="guessing yes";;
|
|
|
976 # Guess yes on HP-UX >= 11.
|
|
|
977 hpux[7-9]* | hpux10*) gl_cv_func_snprintf_truncation_c99="guessing no";;
|
|
|
978 hpux*) gl_cv_func_snprintf_truncation_c99="guessing yes";;
|
|
|
979 # Guess yes on IRIX >= 6.5.
|
|
|
980 irix6.5) gl_cv_func_snprintf_truncation_c99="guessing yes";;
|
|
|
981 # Guess yes on OSF/1 >= 5.
|
|
|
982 osf[3-4]*) gl_cv_func_snprintf_truncation_c99="guessing no";;
|
|
|
983 osf*) gl_cv_func_snprintf_truncation_c99="guessing yes";;
|
|
|
984 # Guess yes on NetBSD >= 3.
|
|
|
985 netbsd[1-2]* | netbsdelf[1-2]* | netbsdaout[1-2]* | netbsdcoff[1-2]*)
|
|
|
986 gl_cv_func_snprintf_truncation_c99="guessing no";;
|
|
|
987 netbsd*) gl_cv_func_snprintf_truncation_c99="guessing yes";;
|
|
|
988 # Guess yes on BeOS.
|
|
|
989 beos*) gl_cv_func_snprintf_truncation_c99="guessing yes";;
|
|
|
990 # If we don't know, assume the worst.
|
|
|
991 *) gl_cv_func_snprintf_truncation_c99="guessing no";;
|
|
|
992 esac
|
|
|
993 changequote([,])dnl
|
|
|
994 ])
|
|
|
995 ])
|
|
|
996 ])
|
|
|
997
|
|
|
998 dnl Test whether the return value of the snprintf function is the number
|
|
|
999 dnl of bytes (excluding the terminating NUL) that would have been produced
|
|
|
1000 dnl if the buffer had been large enough. (ISO C99, POSIX:2001)
|
|
|
1001 dnl For example, this test program fails on IRIX 6.5:
|
|
|
1002 dnl ---------------------------------------------------------------------
|
|
|
1003 dnl #include <stdio.h>
|
|
|
1004 dnl int main()
|
|
|
1005 dnl {
|
|
|
1006 dnl static char buf[8];
|
|
|
1007 dnl int retval = snprintf (buf, 3, "%d", 12345);
|
|
|
1008 dnl return retval >= 0 && retval < 3;
|
|
|
1009 dnl }
|
|
|
1010 dnl ---------------------------------------------------------------------
|
|
|
1011 dnl Result is gl_cv_func_snprintf_retval_c99.
|
|
|
1012
|
|
|
1013 AC_DEFUN([gl_SNPRINTF_RETVAL_C99],
|
|
|
1014 [
|
|
|
1015 AC_REQUIRE([AC_PROG_CC])
|
|
|
1016 AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
|
|
|
1017 AC_CACHE_CHECK([whether snprintf returns a byte count as in C99],
|
|
|
1018 [gl_cv_func_snprintf_retval_c99],
|
|
|
1019 [
|
|
|
1020 AC_TRY_RUN([
|
|
|
1021 #include <stdio.h>
|
|
|
1022 #include <string.h>
|
|
|
1023 static char buf[100];
|
|
|
1024 int main ()
|
|
|
1025 {
|
|
|
1026 strcpy (buf, "ABCDEF");
|
|
|
1027 if (snprintf (buf, 3, "%d %d", 4567, 89) != 7)
|
|
|
1028 return 1;
|
|
|
1029 return 0;
|
|
|
1030 }], [gl_cv_func_snprintf_retval_c99=yes], [gl_cv_func_snprintf_retval_c99=no],
|
|
|
1031 [
|
|
|
1032 changequote(,)dnl
|
|
|
1033 case "$host_os" in
|
|
|
1034 # Guess yes on glibc systems.
|
|
|
1035 *-gnu*) gl_cv_func_snprintf_retval_c99="guessing yes";;
|
|
|
1036 # Guess yes on FreeBSD >= 5.
|
|
|
1037 freebsd[1-4]*) gl_cv_func_snprintf_retval_c99="guessing no";;
|
|
|
1038 freebsd* | kfreebsd*) gl_cv_func_snprintf_retval_c99="guessing yes";;
|
|
|
1039 # Guess yes on MacOS X >= 10.3.
|
|
|
1040 darwin[1-6].*) gl_cv_func_snprintf_retval_c99="guessing no";;
|
|
|
1041 darwin*) gl_cv_func_snprintf_retval_c99="guessing yes";;
|
|
|
1042 # Guess yes on OpenBSD >= 3.9.
|
|
|
1043 openbsd[1-2].* | openbsd3.[0-8] | openbsd3.[0-8].*)
|
|
|
1044 gl_cv_func_snprintf_retval_c99="guessing no";;
|
|
|
1045 openbsd*) gl_cv_func_snprintf_retval_c99="guessing yes";;
|
|
|
1046 # Guess yes on Solaris >= 2.6.
|
|
|
1047 solaris2.[0-5]*) gl_cv_func_snprintf_retval_c99="guessing no";;
|
|
|
1048 solaris*) gl_cv_func_snprintf_retval_c99="guessing yes";;
|
|
|
1049 # Guess yes on AIX >= 4.
|
|
|
1050 aix[1-3]*) gl_cv_func_snprintf_retval_c99="guessing no";;
|
|
|
1051 aix*) gl_cv_func_snprintf_retval_c99="guessing yes";;
|
|
|
1052 # Guess yes on NetBSD >= 3.
|
|
|
1053 netbsd[1-2]* | netbsdelf[1-2]* | netbsdaout[1-2]* | netbsdcoff[1-2]*)
|
|
|
1054 gl_cv_func_snprintf_retval_c99="guessing no";;
|
|
|
1055 netbsd*) gl_cv_func_snprintf_retval_c99="guessing yes";;
|
|
|
1056 # Guess yes on BeOS.
|
|
|
1057 beos*) gl_cv_func_snprintf_retval_c99="guessing yes";;
|
|
|
1058 # If we don't know, assume the worst.
|
|
|
1059 *) gl_cv_func_snprintf_retval_c99="guessing no";;
|
|
|
1060 esac
|
|
|
1061 changequote([,])dnl
|
|
|
1062 ])
|
|
|
1063 ])
|
|
|
1064 ])
|
|
|
1065
|
|
|
1066 dnl Test whether the snprintf function supports the %n format directive
|
|
|
1067 dnl also in truncated portions of the format string. (ISO C99, POSIX:2001)
|
|
|
1068 dnl Result is gl_cv_func_snprintf_directive_n.
|
|
|
1069
|
|
|
1070 AC_DEFUN([gl_SNPRINTF_DIRECTIVE_N],
|
|
|
1071 [
|
|
|
1072 AC_REQUIRE([AC_PROG_CC])
|
|
|
1073 AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
|
|
|
1074 AC_CACHE_CHECK([whether snprintf fully supports the 'n' directive],
|
|
|
1075 [gl_cv_func_snprintf_directive_n],
|
|
|
1076 [
|
|
|
1077 AC_TRY_RUN([
|
|
|
1078 #include <stdio.h>
|
|
|
1079 #include <string.h>
|
|
|
1080 static char fmtstring[10];
|
|
|
1081 static char buf[100];
|
|
|
1082 int main ()
|
|
|
1083 {
|
|
|
1084 int count = -1;
|
|
|
1085 /* Copy the format string. Some systems (glibc with _FORTIFY_SOURCE=2)
|
|
|
1086 support %n in format strings in read-only memory but not in writable
|
|
|
1087 memory. */
|
|
|
1088 strcpy (fmtstring, "%d %n");
|
|
|
1089 snprintf (buf, 4, fmtstring, 12345, &count, 33, 44, 55);
|
|
|
1090 if (count != 6)
|
|
|
1091 return 1;
|
|
|
1092 return 0;
|
|
|
1093 }], [gl_cv_func_snprintf_directive_n=yes], [gl_cv_func_snprintf_directive_n=no],
|
|
|
1094 [
|
|
|
1095 changequote(,)dnl
|
|
|
1096 case "$host_os" in
|
|
|
1097 # Guess yes on glibc systems.
|
|
|
1098 *-gnu*) gl_cv_func_snprintf_directive_n="guessing yes";;
|
|
|
1099 # Guess yes on FreeBSD >= 5.
|
|
|
1100 freebsd[1-4]*) gl_cv_func_snprintf_directive_n="guessing no";;
|
|
|
1101 freebsd* | kfreebsd*) gl_cv_func_snprintf_directive_n="guessing yes";;
|
|
|
1102 # Guess yes on MacOS X >= 10.3.
|
|
|
1103 darwin[1-6].*) gl_cv_func_snprintf_directive_n="guessing no";;
|
|
|
1104 darwin*) gl_cv_func_snprintf_directive_n="guessing yes";;
|
|
|
1105 # Guess yes on Solaris >= 2.6.
|
|
|
1106 solaris2.[0-5]*) gl_cv_func_snprintf_directive_n="guessing no";;
|
|
|
1107 solaris*) gl_cv_func_snprintf_directive_n="guessing yes";;
|
|
|
1108 # Guess yes on AIX >= 4.
|
|
|
1109 aix[1-3]*) gl_cv_func_snprintf_directive_n="guessing no";;
|
|
|
1110 aix*) gl_cv_func_snprintf_directive_n="guessing yes";;
|
|
|
1111 # Guess yes on IRIX >= 6.5.
|
|
|
1112 irix6.5) gl_cv_func_snprintf_directive_n="guessing yes";;
|
|
|
1113 # Guess yes on OSF/1 >= 5.
|
|
|
1114 osf[3-4]*) gl_cv_func_snprintf_directive_n="guessing no";;
|
|
|
1115 osf*) gl_cv_func_snprintf_directive_n="guessing yes";;
|
|
|
1116 # Guess yes on NetBSD >= 3.
|
|
|
1117 netbsd[1-2]* | netbsdelf[1-2]* | netbsdaout[1-2]* | netbsdcoff[1-2]*)
|
|
|
1118 gl_cv_func_snprintf_directive_n="guessing no";;
|
|
|
1119 netbsd*) gl_cv_func_snprintf_directive_n="guessing yes";;
|
|
|
1120 # Guess yes on BeOS.
|
|
|
1121 beos*) gl_cv_func_snprintf_directive_n="guessing yes";;
|
|
|
1122 # If we don't know, assume the worst.
|
|
|
1123 *) gl_cv_func_snprintf_directive_n="guessing no";;
|
|
|
1124 esac
|
|
|
1125 changequote([,])dnl
|
|
|
1126 ])
|
|
|
1127 ])
|
|
|
1128 ])
|
|
|
1129
|
|
|
1130 dnl Test whether the snprintf function, when passed a size = 1, writes any
|
|
|
1131 dnl output without bounds in this case, behaving like sprintf. This is the
|
|
|
1132 dnl case on Linux libc5.
|
|
|
1133 dnl Result is gl_cv_func_snprintf_size1.
|
|
|
1134
|
|
|
1135 AC_DEFUN([gl_SNPRINTF_SIZE1],
|
|
|
1136 [
|
|
|
1137 AC_REQUIRE([AC_PROG_CC])
|
|
|
1138 AC_CACHE_CHECK([whether snprintf respects a size of 1],
|
|
|
1139 [gl_cv_func_snprintf_size1],
|
|
|
1140 [
|
|
|
1141 AC_TRY_RUN([
|
|
|
1142 #include <stdio.h>
|
|
|
1143 int main()
|
|
|
1144 {
|
|
|
1145 static char buf[8] = "DEADBEEF";
|
|
|
1146 snprintf (buf, 1, "%d", 12345);
|
|
|
1147 return buf[1] != 'E';
|
|
|
1148 }],
|
|
|
1149 [gl_cv_func_snprintf_size1=yes],
|
|
|
1150 [gl_cv_func_snprintf_size1=no],
|
|
|
1151 [gl_cv_func_snprintf_size1="guessing yes"])
|
|
|
1152 ])
|
|
|
1153 ])
|
|
|
1154
|
|
|
1155 dnl Test whether the vsnprintf function, when passed a zero size, produces no
|
|
|
1156 dnl output. (ISO C99, POSIX:2001)
|
|
|
1157 dnl For example, snprintf nevertheless writes a NUL byte in this case
|
|
|
1158 dnl on OSF/1 5.1:
|
|
|
1159 dnl ---------------------------------------------------------------------
|
|
|
1160 dnl #include <stdio.h>
|
|
|
1161 dnl int main()
|
|
|
1162 dnl {
|
|
|
1163 dnl static char buf[8] = "DEADBEEF";
|
|
|
1164 dnl snprintf (buf, 0, "%d", 12345);
|
|
|
1165 dnl return buf[0] != 'D';
|
|
|
1166 dnl }
|
|
|
1167 dnl ---------------------------------------------------------------------
|
|
|
1168 dnl And vsnprintf writes any output without bounds in this case, behaving like
|
|
|
1169 dnl vsprintf, on HP-UX 11 and OSF/1 5.1:
|
|
|
1170 dnl ---------------------------------------------------------------------
|
|
|
1171 dnl #include <stdarg.h>
|
|
|
1172 dnl #include <stdio.h>
|
|
|
1173 dnl static int my_snprintf (char *buf, int size, const char *format, ...)
|
|
|
1174 dnl {
|
|
|
1175 dnl va_list args;
|
|
|
1176 dnl int ret;
|
|
|
1177 dnl va_start (args, format);
|
|
|
1178 dnl ret = vsnprintf (buf, size, format, args);
|
|
|
1179 dnl va_end (args);
|
|
|
1180 dnl return ret;
|
|
|
1181 dnl }
|
|
|
1182 dnl int main()
|
|
|
1183 dnl {
|
|
|
1184 dnl static char buf[8] = "DEADBEEF";
|
|
|
1185 dnl my_snprintf (buf, 0, "%d", 12345);
|
|
|
1186 dnl return buf[0] != 'D';
|
|
|
1187 dnl }
|
|
|
1188 dnl ---------------------------------------------------------------------
|
|
|
1189 dnl Result is gl_cv_func_vsnprintf_zerosize_c99.
|
|
|
1190
|
|
|
1191 AC_DEFUN([gl_VSNPRINTF_ZEROSIZE_C99],
|
|
|
1192 [
|
|
|
1193 AC_REQUIRE([AC_PROG_CC])
|
|
|
1194 AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
|
|
|
1195 AC_CACHE_CHECK([whether vsnprintf respects a zero size as in C99],
|
|
|
1196 [gl_cv_func_vsnprintf_zerosize_c99],
|
|
|
1197 [
|
|
|
1198 AC_TRY_RUN([
|
|
|
1199 #include <stdarg.h>
|
|
|
1200 #include <stdio.h>
|
|
|
1201 static int my_snprintf (char *buf, int size, const char *format, ...)
|
|
|
1202 {
|
|
|
1203 va_list args;
|
|
|
1204 int ret;
|
|
|
1205 va_start (args, format);
|
|
|
1206 ret = vsnprintf (buf, size, format, args);
|
|
|
1207 va_end (args);
|
|
|
1208 return ret;
|
|
|
1209 }
|
|
|
1210 int main()
|
|
|
1211 {
|
|
|
1212 static char buf[8] = "DEADBEEF";
|
|
|
1213 my_snprintf (buf, 0, "%d", 12345);
|
|
|
1214 return buf[0] != 'D';
|
|
|
1215 }],
|
|
|
1216 [gl_cv_func_vsnprintf_zerosize_c99=yes],
|
|
|
1217 [gl_cv_func_vsnprintf_zerosize_c99=no],
|
|
|
1218 [
|
|
|
1219 changequote(,)dnl
|
|
|
1220 case "$host_os" in
|
|
|
1221 # Guess yes on glibc systems.
|
|
|
1222 *-gnu*) gl_cv_func_vsnprintf_zerosize_c99="guessing yes";;
|
|
|
1223 # Guess yes on FreeBSD >= 5.
|
|
|
1224 freebsd[1-4]*) gl_cv_func_vsnprintf_zerosize_c99="guessing no";;
|
|
|
1225 freebsd* | kfreebsd*) gl_cv_func_vsnprintf_zerosize_c99="guessing yes";;
|
|
|
1226 # Guess yes on MacOS X >= 10.3.
|
|
|
1227 darwin[1-6].*) gl_cv_func_vsnprintf_zerosize_c99="guessing no";;
|
|
|
1228 darwin*) gl_cv_func_vsnprintf_zerosize_c99="guessing yes";;
|
|
|
1229 # Guess yes on Cygwin.
|
|
|
1230 cygwin*) gl_cv_func_vsnprintf_zerosize_c99="guessing yes";;
|
|
|
1231 # Guess yes on Solaris >= 2.6.
|
|
|
1232 solaris2.[0-5]*) gl_cv_func_vsnprintf_zerosize_c99="guessing no";;
|
|
|
1233 solaris*) gl_cv_func_vsnprintf_zerosize_c99="guessing yes";;
|
|
|
1234 # Guess yes on AIX >= 4.
|
|
|
1235 aix[1-3]*) gl_cv_func_vsnprintf_zerosize_c99="guessing no";;
|
|
|
1236 aix*) gl_cv_func_vsnprintf_zerosize_c99="guessing yes";;
|
|
|
1237 # Guess yes on IRIX >= 6.5.
|
|
|
1238 irix6.5) gl_cv_func_vsnprintf_zerosize_c99="guessing yes";;
|
|
|
1239 # Guess yes on NetBSD >= 3.
|
|
|
1240 netbsd[1-2]* | netbsdelf[1-2]* | netbsdaout[1-2]* | netbsdcoff[1-2]*)
|
|
|
1241 gl_cv_func_vsnprintf_zerosize_c99="guessing no";;
|
|
|
1242 netbsd*) gl_cv_func_vsnprintf_zerosize_c99="guessing yes";;
|
|
|
1243 # Guess yes on BeOS.
|
|
|
1244 beos*) gl_cv_func_vsnprintf_zerosize_c99="guessing yes";;
|
|
|
1245 # Guess yes on mingw.
|
|
|
1246 mingw* | pw*) gl_cv_func_vsnprintf_zerosize_c99="guessing yes";;
|
|
|
1247 # If we don't know, assume the worst.
|
|
|
1248 *) gl_cv_func_vsnprintf_zerosize_c99="guessing no";;
|
|
|
1249 esac
|
|
|
1250 changequote([,])dnl
|
|
|
1251 ])
|
|
|
1252 ])
|
|
|
1253 ])
|
|
|
1254
|
|
|
1255 dnl The results of these tests on various platforms are:
|
|
|
1256 dnl
|
|
|
1257 dnl 1 = gl_PRINTF_SIZES_C99
|
|
|
1258 dnl 2 = gl_PRINTF_LONG_DOUBLE
|
|
|
1259 dnl 3 = gl_PRINTF_INFINITE
|
|
|
1260 dnl 4 = gl_PRINTF_INFINITE_LONG_DOUBLE
|
|
|
1261 dnl 5 = gl_PRINTF_DIRECTIVE_A
|
|
|
1262 dnl 6 = gl_PRINTF_DIRECTIVE_F
|
|
|
1263 dnl 7 = gl_PRINTF_DIRECTIVE_N
|
|
|
1264 dnl 8 = gl_PRINTF_POSITIONS
|
|
|
1265 dnl 9 = gl_PRINTF_FLAG_GROUPING
|
|
|
1266 dnl 10 = gl_PRINTF_FLAG_LEFTADJUST
|
|
|
1267 dnl 11 = gl_PRINTF_FLAG_ZERO
|
|
|
1268 dnl 12 = gl_PRINTF_PRECISION
|
|
|
1269 dnl 13 = gl_PRINTF_ENOMEM
|
|
|
1270 dnl 14 = gl_SNPRINTF_PRESENCE
|
|
|
1271 dnl 15 = gl_SNPRINTF_TRUNCATION_C99
|
|
|
1272 dnl 16 = gl_SNPRINTF_RETVAL_C99
|
|
|
1273 dnl 17 = gl_SNPRINTF_DIRECTIVE_N
|
|
|
1274 dnl 18 = gl_SNPRINTF_SIZE1
|
|
|
1275 dnl 19 = gl_VSNPRINTF_ZEROSIZE_C99
|
|
|
1276 dnl
|
|
|
1277 dnl 1 = checking whether printf supports size specifiers as in C99...
|
|
|
1278 dnl 2 = checking whether printf supports 'long double' arguments...
|
|
|
1279 dnl 3 = checking whether printf supports infinite 'double' arguments...
|
|
|
1280 dnl 4 = checking whether printf supports infinite 'long double' arguments...
|
|
|
1281 dnl 5 = checking whether printf supports the 'a' and 'A' directives...
|
|
|
1282 dnl 6 = checking whether printf supports the 'F' directive...
|
|
|
1283 dnl 7 = checking whether printf supports the 'n' directive...
|
|
|
1284 dnl 8 = checking whether printf supports POSIX/XSI format strings with positions...
|
|
|
1285 dnl 9 = checking whether printf supports the grouping flag...
|
|
|
1286 dnl 10 = checking whether printf supports the left-adjust flag correctly...
|
|
|
1287 dnl 11 = checking whether printf supports the zero flag correctly...
|
|
|
1288 dnl 12 = checking whether printf supports large precisions...
|
|
|
1289 dnl 13 = checking whether printf survives out-of-memory conditions...
|
|
|
1290 dnl 14 = checking for snprintf...
|
|
|
1291 dnl 15 = checking whether snprintf truncates the result as in C99...
|
|
|
1292 dnl 16 = checking whether snprintf returns a byte count as in C99...
|
|
|
1293 dnl 17 = checking whether snprintf fully supports the 'n' directive...
|
|
|
1294 dnl 18 = checking whether snprintf respects a size of 1...
|
|
|
1295 dnl 19 = checking whether vsnprintf respects a zero size as in C99...
|
|
|
1296 dnl
|
|
|
1297 dnl . = yes, # = no.
|
|
|
1298 dnl
|
|
|
1299 dnl 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
|
|
|
1300 dnl glibc 2.5 . . . . . . . . . . . . . . . . . . .
|
|
|
1301 dnl glibc 2.3.6 . . . . # . . . . . . . . . . . . . .
|
|
|
1302 dnl FreeBSD 5.4, 6.1 . . . . # . . . . . # . # . . . . . .
|
|
|
1303 dnl MacOS X 10.3.9 . . . . # . . . . . # . # . . . . . .
|
|
|
1304 dnl OpenBSD 3.9, 4.0 . . # # # # . . # . # . # . . . . . .
|
|
|
1305 dnl Cygwin 2007 (= Cygwin 1.5.24) . . . . # # . . . ? # ? ? . . . . . .
|
|
|
1306 dnl Cygwin 2006 (= Cygwin 1.5.19) # . . . # # . . # ? # ? ? . . . . . .
|
|
|
1307 dnl Solaris 10 . . # # # . . . . . # . . . . . . . .
|
|
|
1308 dnl Solaris 2.6 ... 9 # . # # # # . . . . # . . . . . . . .
|
|
|
1309 dnl Solaris 2.5.1 # . # # # # . . . . # . . # # # # # #
|
|
|
1310 dnl AIX 5.2 . . # # # . . . . . # . . . . . . . .
|
|
|
1311 dnl AIX 4.3.2, 5.1 # . # # # # . . . . # . . . . . . . .
|
|
|
1312 dnl HP-UX 11.31 . . . . # . . . . . # . . . . # # . .
|
|
|
1313 dnl HP-UX 11.{00,11,23} # . . . # # . . . . # . . . . # # . #
|
|
|
1314 dnl HP-UX 10.20 # . . . # # . . . # # . . . . # # ? #
|
|
|
1315 dnl IRIX 6.5 # . # # # # . . . . # . . . . # . . .
|
|
|
1316 dnl OSF/1 5.1 # . # # # # . . . . # . . . . # . . #
|
|
|
1317 dnl OSF/1 4.0d # . # # # # . . . . # . . # # # # # #
|
|
|
1318 dnl NetBSD 4.0 . ? ? ? ? ? . . ? ? ? ? ? . . . ? ? ?
|
|
|
1319 dnl NetBSD 3.0 . . . . # # . # # ? # . # . . . . . .
|
|
|
1320 dnl Haiku . . . # # # . . . . . . ? . . . . . .
|
|
|
1321 dnl BeOS # # . # # # . # . ? . # ? . . . . . .
|
|
|
1322 dnl mingw # # # # # # . # # . # # ? . # # # . .
|
