diff options
-rw-r--r-- | gl/Makefile.am | 81 | ||||
-rw-r--r-- | gl/base64.c | 425 | ||||
-rw-r--r-- | gl/base64.h | 45 | ||||
-rw-r--r-- | gl/charset.alias | 5 | ||||
-rw-r--r-- | gl/configmake.h | 25 | ||||
-rw-r--r-- | gl/floor.c | 93 | ||||
-rw-r--r-- | gl/floorf.c | 20 | ||||
-rw-r--r-- | gl/m4/base64.m4 | 16 | ||||
-rw-r--r-- | gl/m4/floorf.m4 | 62 | ||||
-rw-r--r-- | gl/m4/gnulib-cache.m4 | 4 | ||||
-rw-r--r-- | gl/m4/gnulib-comp.m4 | 12 | ||||
-rw-r--r-- | gl/m4/math_h.m4 | 66 | ||||
-rw-r--r-- | gl/math.h | 442 | ||||
-rw-r--r-- | gl/math.in.h | 413 | ||||
-rw-r--r-- | gl/ref-add.sed | 10 | ||||
-rw-r--r-- | gl/ref-del.sed | 5 | ||||
-rw-r--r-- | gl/stdio.h | 411 | ||||
-rw-r--r-- | gl/stdlib.h | 237 | ||||
-rw-r--r-- | gl/string.h | 598 | ||||
-rw-r--r-- | gl/unistd.h | 321 | ||||
-rw-r--r-- | lib/Makefile.am | 4 | ||||
-rw-r--r-- | lib/base64.c | 50 | ||||
-rw-r--r-- | lib/base64.h | 4 | ||||
-rw-r--r-- | lib/tests/Makefile.am | 2 | ||||
-rw-r--r-- | lib/tests/test_base64.c | 10 | ||||
-rw-r--r-- | plugins/check_http.c | 2 | ||||
-rw-r--r-- | plugins/check_smtp.c | 6 |
27 files changed, 3302 insertions, 67 deletions
diff --git a/gl/Makefile.am b/gl/Makefile.am index 92c675ea..1eefee9d 100644 --- a/gl/Makefile.am +++ b/gl/Makefile.am | |||
@@ -9,7 +9,7 @@ | |||
9 | # the same distribution terms as the rest of that program. | 9 | # the same distribution terms as the rest of that program. |
10 | # | 10 | # |
11 | # Generated by gnulib-tool. | 11 | # Generated by gnulib-tool. |
12 | # Reproduce by: gnulib-tool --import --dir=. --lib=libgnu --source-base=gl --m4-base=gl/m4 --doc-base=doc --aux-dir=build-aux --no-libtool --macro-prefix=gl dirname fsusage getaddrinfo gethostname getloadavg getopt gettext mountlist regex vasprintf vsnprintf | 12 | # Reproduce by: gnulib-tool --import --dir=. --lib=libgnu --source-base=gl --m4-base=gl/m4 --doc-base=doc --aux-dir=build-aux --no-libtool --macro-prefix=gl base64 dirname floorf fsusage getaddrinfo gethostname getloadavg getopt gettext mountlist regex vasprintf vsnprintf |
13 | 13 | ||
14 | AUTOMAKE_OPTIONS = 1.5 gnits | 14 | AUTOMAKE_OPTIONS = 1.5 gnits |
15 | 15 | ||
@@ -89,6 +89,12 @@ MOSTLYCLEANDIRS += arpa | |||
89 | 89 | ||
90 | ## end gnulib module arpa_inet | 90 | ## end gnulib module arpa_inet |
91 | 91 | ||
92 | ## begin gnulib module base64 | ||
93 | |||
94 | libgnu_a_SOURCES += base64.h base64.c | ||
95 | |||
96 | ## end gnulib module base64 | ||
97 | |||
92 | ## begin gnulib module c-strtod | 98 | ## begin gnulib module c-strtod |
93 | 99 | ||
94 | 100 | ||
@@ -219,6 +225,15 @@ EXTRA_DIST += float.in.h | |||
219 | 225 | ||
220 | ## end gnulib module float | 226 | ## end gnulib module float |
221 | 227 | ||
228 | ## begin gnulib module floorf | ||
229 | |||
230 | |||
231 | EXTRA_DIST += floor.c floorf.c | ||
232 | |||
233 | EXTRA_libgnu_a_SOURCES += floor.c floorf.c | ||
234 | |||
235 | ## end gnulib module floorf | ||
236 | |||
222 | ## begin gnulib module fsusage | 237 | ## begin gnulib module fsusage |
223 | 238 | ||
224 | 239 | ||
@@ -415,6 +430,70 @@ EXTRA_libgnu_a_SOURCES += malloc.c | |||
415 | 430 | ||
416 | ## end gnulib module malloc-posix | 431 | ## end gnulib module malloc-posix |
417 | 432 | ||
433 | ## begin gnulib module math | ||
434 | |||
435 | BUILT_SOURCES += math.h | ||
436 | |||
437 | # We need the following in order to create <math.h> when the system | ||
438 | # doesn't have one that works with the given compiler. | ||
439 | math.h: math.in.h | ||
440 | rm -f $@-t $@ | ||
441 | { echo '/* DO NOT EDIT! GENERATED AUTOMATICALLY! */' && \ | ||
442 | sed -e 's/@''INCLUDE_NEXT''@/$(INCLUDE_NEXT)/g' \ | ||
443 | -e 's|@''NEXT_MATH_H''@|$(NEXT_MATH_H)|g' \ | ||
444 | -e 's|@''GNULIB_CEILF''@|$(GNULIB_CEILF)|g' \ | ||
445 | -e 's|@''GNULIB_CEILL''@|$(GNULIB_CEILL)|g' \ | ||
446 | -e 's|@''GNULIB_FLOORF''@|$(GNULIB_FLOORF)|g' \ | ||
447 | -e 's|@''GNULIB_FLOORL''@|$(GNULIB_FLOORL)|g' \ | ||
448 | -e 's|@''GNULIB_FREXP''@|$(GNULIB_FREXP)|g' \ | ||
449 | -e 's|@''GNULIB_FREXPL''@|$(GNULIB_FREXPL)|g' \ | ||
450 | -e 's|@''GNULIB_ISFINITE''@|$(GNULIB_ISFINITE)|g' \ | ||
451 | -e 's|@''GNULIB_LDEXPL''@|$(GNULIB_LDEXPL)|g' \ | ||
452 | -e 's|@''GNULIB_MATHL''@|$(GNULIB_MATHL)|g' \ | ||
453 | -e 's|@''GNULIB_ROUND''@|$(GNULIB_ROUND)|g' \ | ||
454 | -e 's|@''GNULIB_ROUNDF''@|$(GNULIB_ROUNDF)|g' \ | ||
455 | -e 's|@''GNULIB_ROUNDL''@|$(GNULIB_ROUNDL)|g' \ | ||
456 | -e 's|@''GNULIB_SIGNBIT''@|$(GNULIB_SIGNBIT)|g' \ | ||
457 | -e 's|@''GNULIB_TRUNC''@|$(GNULIB_TRUNC)|g' \ | ||
458 | -e 's|@''GNULIB_TRUNCF''@|$(GNULIB_TRUNCF)|g' \ | ||
459 | -e 's|@''GNULIB_TRUNCL''@|$(GNULIB_TRUNCL)|g' \ | ||
460 | -e 's|@''HAVE_DECL_ACOSL''@|$(HAVE_DECL_ACOSL)|g' \ | ||
461 | -e 's|@''HAVE_DECL_ASINL''@|$(HAVE_DECL_ASINL)|g' \ | ||
462 | -e 's|@''HAVE_DECL_ATANL''@|$(HAVE_DECL_ATANL)|g' \ | ||
463 | -e 's|@''HAVE_DECL_COSL''@|$(HAVE_DECL_COSL)|g' \ | ||
464 | -e 's|@''HAVE_DECL_EXPL''@|$(HAVE_DECL_EXPL)|g' \ | ||
465 | -e 's|@''HAVE_DECL_FREXPL''@|$(HAVE_DECL_FREXPL)|g' \ | ||
466 | -e 's|@''HAVE_DECL_LDEXPL''@|$(HAVE_DECL_LDEXPL)|g' \ | ||
467 | -e 's|@''HAVE_DECL_LOGL''@|$(HAVE_DECL_LOGL)|g' \ | ||
468 | -e 's|@''HAVE_DECL_SINL''@|$(HAVE_DECL_SINL)|g' \ | ||
469 | -e 's|@''HAVE_DECL_SQRTL''@|$(HAVE_DECL_SQRTL)|g' \ | ||
470 | -e 's|@''HAVE_DECL_TANL''@|$(HAVE_DECL_TANL)|g' \ | ||
471 | -e 's|@''HAVE_DECL_TRUNC''@|$(HAVE_DECL_TRUNC)|g' \ | ||
472 | -e 's|@''HAVE_DECL_TRUNCF''@|$(HAVE_DECL_TRUNCF)|g' \ | ||
473 | -e 's|@''HAVE_DECL_TRUNCL''@|$(HAVE_DECL_TRUNCL)|g' \ | ||
474 | -e 's|@''REPLACE_CEILF''@|$(REPLACE_CEILF)|g' \ | ||
475 | -e 's|@''REPLACE_CEILL''@|$(REPLACE_CEILL)|g' \ | ||
476 | -e 's|@''REPLACE_FLOORF''@|$(REPLACE_FLOORF)|g' \ | ||
477 | -e 's|@''REPLACE_FLOORL''@|$(REPLACE_FLOORL)|g' \ | ||
478 | -e 's|@''REPLACE_FREXP''@|$(REPLACE_FREXP)|g' \ | ||
479 | -e 's|@''REPLACE_FREXPL''@|$(REPLACE_FREXPL)|g' \ | ||
480 | -e 's|@''REPLACE_ISFINITE''@|$(REPLACE_ISFINITE)|g' \ | ||
481 | -e 's|@''REPLACE_LDEXPL''@|$(REPLACE_LDEXPL)|g' \ | ||
482 | -e 's|@''REPLACE_ROUND''@|$(REPLACE_ROUND)|g' \ | ||
483 | -e 's|@''REPLACE_ROUNDF''@|$(REPLACE_ROUNDF)|g' \ | ||
484 | -e 's|@''REPLACE_ROUNDL''@|$(REPLACE_ROUNDL)|g' \ | ||
485 | -e 's|@''REPLACE_SIGNBIT''@|$(REPLACE_SIGNBIT)|g' \ | ||
486 | -e 's|@''REPLACE_SIGNBIT_USING_GCC''@|$(REPLACE_SIGNBIT_USING_GCC)|g' \ | ||
487 | -e '/definition of GL_LINK_WARNING/r $(LINK_WARNING_H)' \ | ||
488 | < $(srcdir)/math.in.h; \ | ||
489 | } > $@-t | ||
490 | mv $@-t $@ | ||
491 | MOSTLYCLEANFILES += math.h math.h-t | ||
492 | |||
493 | EXTRA_DIST += math.in.h | ||
494 | |||
495 | ## end gnulib module math | ||
496 | |||
418 | ## begin gnulib module mountlist | 497 | ## begin gnulib module mountlist |
419 | 498 | ||
420 | 499 | ||
diff --git a/gl/base64.c b/gl/base64.c new file mode 100644 index 00000000..e67075d1 --- /dev/null +++ b/gl/base64.c | |||
@@ -0,0 +1,425 @@ | |||
1 | /* base64.c -- Encode binary data using printable characters. | ||
2 | Copyright (C) 1999, 2000, 2001, 2004, 2005, 2006 Free Software | ||
3 | Foundation, Inc. | ||
4 | |||
5 | This program is free software; you can redistribute it and/or modify | ||
6 | it under the terms of the GNU General Public License as published by | ||
7 | the Free Software Foundation; either version 3, or (at your option) | ||
8 | any later version. | ||
9 | |||
10 | This program is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
13 | GNU General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU General Public License | ||
16 | along with this program; if not, write to the Free Software Foundation, | ||
17 | Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ | ||
18 | |||
19 | /* Written by Simon Josefsson. Partially adapted from GNU MailUtils | ||
20 | * (mailbox/filter_trans.c, as of 2004-11-28). Improved by review | ||
21 | * from Paul Eggert, Bruno Haible, and Stepan Kasal. | ||
22 | * | ||
23 | * See also RFC 3548 <http://www.ietf.org/rfc/rfc3548.txt>. | ||
24 | * | ||
25 | * Be careful with error checking. Here is how you would typically | ||
26 | * use these functions: | ||
27 | * | ||
28 | * bool ok = base64_decode_alloc (in, inlen, &out, &outlen); | ||
29 | * if (!ok) | ||
30 | * FAIL: input was not valid base64 | ||
31 | * if (out == NULL) | ||
32 | * FAIL: memory allocation error | ||
33 | * OK: data in OUT/OUTLEN | ||
34 | * | ||
35 | * size_t outlen = base64_encode_alloc (in, inlen, &out); | ||
36 | * if (out == NULL && outlen == 0 && inlen != 0) | ||
37 | * FAIL: input too long | ||
38 | * if (out == NULL) | ||
39 | * FAIL: memory allocation error | ||
40 | * OK: data in OUT/OUTLEN. | ||
41 | * | ||
42 | */ | ||
43 | |||
44 | #include <config.h> | ||
45 | |||
46 | /* Get prototype. */ | ||
47 | #include "base64.h" | ||
48 | |||
49 | /* Get malloc. */ | ||
50 | #include <stdlib.h> | ||
51 | |||
52 | /* Get UCHAR_MAX. */ | ||
53 | #include <limits.h> | ||
54 | |||
55 | /* C89 compliant way to cast 'char' to 'unsigned char'. */ | ||
56 | static inline unsigned char | ||
57 | to_uchar (char ch) | ||
58 | { | ||
59 | return ch; | ||
60 | } | ||
61 | |||
62 | /* Base64 encode IN array of size INLEN into OUT array of size OUTLEN. | ||
63 | If OUTLEN is less than BASE64_LENGTH(INLEN), write as many bytes as | ||
64 | possible. If OUTLEN is larger than BASE64_LENGTH(INLEN), also zero | ||
65 | terminate the output buffer. */ | ||
66 | void | ||
67 | base64_encode (const char *restrict in, size_t inlen, | ||
68 | char *restrict out, size_t outlen) | ||
69 | { | ||
70 | static const char b64str[64] = | ||
71 | "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; | ||
72 | |||
73 | while (inlen && outlen) | ||
74 | { | ||
75 | *out++ = b64str[(to_uchar (in[0]) >> 2) & 0x3f]; | ||
76 | if (!--outlen) | ||
77 | break; | ||
78 | *out++ = b64str[((to_uchar (in[0]) << 4) | ||
79 | + (--inlen ? to_uchar (in[1]) >> 4 : 0)) | ||
80 | & 0x3f]; | ||
81 | if (!--outlen) | ||
82 | break; | ||
83 | *out++ = | ||
84 | (inlen | ||
85 | ? b64str[((to_uchar (in[1]) << 2) | ||
86 | + (--inlen ? to_uchar (in[2]) >> 6 : 0)) | ||
87 | & 0x3f] | ||
88 | : '='); | ||
89 | if (!--outlen) | ||
90 | break; | ||
91 | *out++ = inlen ? b64str[to_uchar (in[2]) & 0x3f] : '='; | ||
92 | if (!--outlen) | ||
93 | break; | ||
94 | if (inlen) | ||
95 | inlen--; | ||
96 | if (inlen) | ||
97 | in += 3; | ||
98 | } | ||
99 | |||
100 | if (outlen) | ||
101 | *out = '\0'; | ||
102 | } | ||
103 | |||
104 | /* Allocate a buffer and store zero terminated base64 encoded data | ||
105 | from array IN of size INLEN, returning BASE64_LENGTH(INLEN), i.e., | ||
106 | the length of the encoded data, excluding the terminating zero. On | ||
107 | return, the OUT variable will hold a pointer to newly allocated | ||
108 | memory that must be deallocated by the caller. If output string | ||
109 | length would overflow, 0 is returned and OUT is set to NULL. If | ||
110 | memory allocation failed, OUT is set to NULL, and the return value | ||
111 | indicates length of the requested memory block, i.e., | ||
112 | BASE64_LENGTH(inlen) + 1. */ | ||
113 | size_t | ||
114 | base64_encode_alloc (const char *in, size_t inlen, char **out) | ||
115 | { | ||
116 | size_t outlen = 1 + BASE64_LENGTH (inlen); | ||
117 | |||
118 | /* Check for overflow in outlen computation. | ||
119 | * | ||
120 | * If there is no overflow, outlen >= inlen. | ||
121 | * | ||
122 | * If the operation (inlen + 2) overflows then it yields at most +1, so | ||
123 | * outlen is 0. | ||
124 | * | ||
125 | * If the multiplication overflows, we lose at least half of the | ||
126 | * correct value, so the result is < ((inlen + 2) / 3) * 2, which is | ||
127 | * less than (inlen + 2) * 0.66667, which is less than inlen as soon as | ||
128 | * (inlen > 4). | ||
129 | */ | ||
130 | if (inlen > outlen) | ||
131 | { | ||
132 | *out = NULL; | ||
133 | return 0; | ||
134 | } | ||
135 | |||
136 | *out = malloc (outlen); | ||
137 | if (!*out) | ||
138 | return outlen; | ||
139 | |||
140 | base64_encode (in, inlen, *out, outlen); | ||
141 | |||
142 | return outlen - 1; | ||
143 | } | ||
144 | |||
145 | /* With this approach this file works independent of the charset used | ||
146 | (think EBCDIC). However, it does assume that the characters in the | ||
147 | Base64 alphabet (A-Za-z0-9+/) are encoded in 0..255. POSIX | ||
148 | 1003.1-2001 require that char and unsigned char are 8-bit | ||
149 | quantities, though, taking care of that problem. But this may be a | ||
150 | potential problem on non-POSIX C99 platforms. | ||
151 | |||
152 | IBM C V6 for AIX mishandles "#define B64(x) ...'x'...", so use "_" | ||
153 | as the formal parameter rather than "x". */ | ||
154 | #define B64(_) \ | ||
155 | ((_) == 'A' ? 0 \ | ||
156 | : (_) == 'B' ? 1 \ | ||
157 | : (_) == 'C' ? 2 \ | ||
158 | : (_) == 'D' ? 3 \ | ||
159 | : (_) == 'E' ? 4 \ | ||
160 | : (_) == 'F' ? 5 \ | ||
161 | : (_) == 'G' ? 6 \ | ||
162 | : (_) == 'H' ? 7 \ | ||
163 | : (_) == 'I' ? 8 \ | ||
164 | : (_) == 'J' ? 9 \ | ||
165 | : (_) == 'K' ? 10 \ | ||
166 | : (_) == 'L' ? 11 \ | ||
167 | : (_) == 'M' ? 12 \ | ||
168 | : (_) == 'N' ? 13 \ | ||
169 | : (_) == 'O' ? 14 \ | ||
170 | : (_) == 'P' ? 15 \ | ||
171 | : (_) == 'Q' ? 16 \ | ||
172 | : (_) == 'R' ? 17 \ | ||
173 | : (_) == 'S' ? 18 \ | ||
174 | : (_) == 'T' ? 19 \ | ||
175 | : (_) == 'U' ? 20 \ | ||
176 | : (_) == 'V' ? 21 \ | ||
177 | : (_) == 'W' ? 22 \ | ||
178 | : (_) == 'X' ? 23 \ | ||
179 | : (_) == 'Y' ? 24 \ | ||
180 | : (_) == 'Z' ? 25 \ | ||
181 | : (_) == 'a' ? 26 \ | ||
182 | : (_) == 'b' ? 27 \ | ||
183 | : (_) == 'c' ? 28 \ | ||
184 | : (_) == 'd' ? 29 \ | ||
185 | : (_) == 'e' ? 30 \ | ||
186 | : (_) == 'f' ? 31 \ | ||
187 | : (_) == 'g' ? 32 \ | ||
188 | : (_) == 'h' ? 33 \ | ||
189 | : (_) == 'i' ? 34 \ | ||
190 | : (_) == 'j' ? 35 \ | ||
191 | : (_) == 'k' ? 36 \ | ||
192 | : (_) == 'l' ? 37 \ | ||
193 | : (_) == 'm' ? 38 \ | ||
194 | : (_) == 'n' ? 39 \ | ||
195 | : (_) == 'o' ? 40 \ | ||
196 | : (_) == 'p' ? 41 \ | ||
197 | : (_) == 'q' ? 42 \ | ||
198 | : (_) == 'r' ? 43 \ | ||
199 | : (_) == 's' ? 44 \ | ||
200 | : (_) == 't' ? 45 \ | ||
201 | : (_) == 'u' ? 46 \ | ||
202 | : (_) == 'v' ? 47 \ | ||
203 | : (_) == 'w' ? 48 \ | ||
204 | : (_) == 'x' ? 49 \ | ||
205 | : (_) == 'y' ? 50 \ | ||
206 | : (_) == 'z' ? 51 \ | ||
207 | : (_) == '0' ? 52 \ | ||
208 | : (_) == '1' ? 53 \ | ||
209 | : (_) == '2' ? 54 \ | ||
210 | : (_) == '3' ? 55 \ | ||
211 | : (_) == '4' ? 56 \ | ||
212 | : (_) == '5' ? 57 \ | ||
213 | : (_) == '6' ? 58 \ | ||
214 | : (_) == '7' ? 59 \ | ||
215 | : (_) == '8' ? 60 \ | ||
216 | : (_) == '9' ? 61 \ | ||
217 | : (_) == '+' ? 62 \ | ||
218 | : (_) == '/' ? 63 \ | ||
219 | : -1) | ||
220 | |||
221 | static const signed char b64[0x100] = { | ||
222 | B64 (0), B64 (1), B64 (2), B64 (3), | ||
223 | B64 (4), B64 (5), B64 (6), B64 (7), | ||
224 | B64 (8), B64 (9), B64 (10), B64 (11), | ||
225 | B64 (12), B64 (13), B64 (14), B64 (15), | ||
226 | B64 (16), B64 (17), B64 (18), B64 (19), | ||
227 | B64 (20), B64 (21), B64 (22), B64 (23), | ||
228 | B64 (24), B64 (25), B64 (26), B64 (27), | ||
229 | B64 (28), B64 (29), B64 (30), B64 (31), | ||
230 | B64 (32), B64 (33), B64 (34), B64 (35), | ||
231 | B64 (36), B64 (37), B64 (38), B64 (39), | ||
232 | B64 (40), B64 (41), B64 (42), B64 (43), | ||
233 | B64 (44), B64 (45), B64 (46), B64 (47), | ||
234 | B64 (48), B64 (49), B64 (50), B64 (51), | ||
235 | B64 (52), B64 (53), B64 (54), B64 (55), | ||
236 | B64 (56), B64 (57), B64 (58), B64 (59), | ||
237 | B64 (60), B64 (61), B64 (62), B64 (63), | ||
238 | B64 (64), B64 (65), B64 (66), B64 (67), | ||
239 | B64 (68), B64 (69), B64 (70), B64 (71), | ||
240 | B64 (72), B64 (73), B64 (74), B64 (75), | ||
241 | B64 (76), B64 (77), B64 (78), B64 (79), | ||
242 | B64 (80), B64 (81), B64 (82), B64 (83), | ||
243 | B64 (84), B64 (85), B64 (86), B64 (87), | ||
244 | B64 (88), B64 (89), B64 (90), B64 (91), | ||
245 | B64 (92), B64 (93), B64 (94), B64 (95), | ||
246 | B64 (96), B64 (97), B64 (98), B64 (99), | ||
247 | B64 (100), B64 (101), B64 (102), B64 (103), | ||
248 | B64 (104), B64 (105), B64 (106), B64 (107), | ||
249 | B64 (108), B64 (109), B64 (110), B64 (111), | ||
250 | B64 (112), B64 (113), B64 (114), B64 (115), | ||
251 | B64 (116), B64 (117), B64 (118), B64 (119), | ||
252 | B64 (120), B64 (121), B64 (122), B64 (123), | ||
253 | B64 (124), B64 (125), B64 (126), B64 (127), | ||
254 | B64 (128), B64 (129), B64 (130), B64 (131), | ||
255 | B64 (132), B64 (133), B64 (134), B64 (135), | ||
256 | B64 (136), B64 (137), B64 (138), B64 (139), | ||
257 | B64 (140), B64 (141), B64 (142), B64 (143), | ||
258 | B64 (144), B64 (145), B64 (146), B64 (147), | ||
259 | B64 (148), B64 (149), B64 (150), B64 (151), | ||
260 | B64 (152), B64 (153), B64 (154), B64 (155), | ||
261 | B64 (156), B64 (157), B64 (158), B64 (159), | ||
262 | B64 (160), B64 (161), B64 (162), B64 (163), | ||
263 | B64 (164), B64 (165), B64 (166), B64 (167), | ||
264 | B64 (168), B64 (169), B64 (170), B64 (171), | ||
265 | B64 (172), B64 (173), B64 (174), B64 (175), | ||
266 | B64 (176), B64 (177), B64 (178), B64 (179), | ||
267 | B64 (180), B64 (181), B64 (182), B64 (183), | ||
268 | B64 (184), B64 (185), B64 (186), B64 (187), | ||
269 | B64 (188), B64 (189), B64 (190), B64 (191), | ||
270 | B64 (192), B64 (193), B64 (194), B64 (195), | ||
271 | B64 (196), B64 (197), B64 (198), B64 (199), | ||
272 | B64 (200), B64 (201), B64 (202), B64 (203), | ||
273 | B64 (204), B64 (205), B64 (206), B64 (207), | ||
274 | B64 (208), B64 (209), B64 (210), B64 (211), | ||
275 | B64 (212), B64 (213), B64 (214), B64 (215), | ||
276 | B64 (216), B64 (217), B64 (218), B64 (219), | ||
277 | B64 (220), B64 (221), B64 (222), B64 (223), | ||
278 | B64 (224), B64 (225), B64 (226), B64 (227), | ||
279 | B64 (228), B64 (229), B64 (230), B64 (231), | ||
280 | B64 (232), B64 (233), B64 (234), B64 (235), | ||
281 | B64 (236), B64 (237), B64 (238), B64 (239), | ||
282 | B64 (240), B64 (241), B64 (242), B64 (243), | ||
283 | B64 (244), B64 (245), B64 (246), B64 (247), | ||
284 | B64 (248), B64 (249), B64 (250), B64 (251), | ||
285 | B64 (252), B64 (253), B64 (254), B64 (255) | ||
286 | }; | ||
287 | |||
288 | #if UCHAR_MAX == 255 | ||
289 | # define uchar_in_range(c) true | ||
290 | #else | ||
291 | # define uchar_in_range(c) ((c) <= 255) | ||
292 | #endif | ||
293 | |||
294 | /* Return true if CH is a character from the Base64 alphabet, and | ||
295 | false otherwise. Note that '=' is padding and not considered to be | ||
296 | part of the alphabet. */ | ||
297 | bool | ||
298 | isbase64 (char ch) | ||
299 | { | ||
300 | return uchar_in_range (to_uchar (ch)) && 0 <= b64[to_uchar (ch)]; | ||
301 | } | ||
302 | |||
303 | /* Decode base64 encoded input array IN of length INLEN to output | ||
304 | array OUT that can hold *OUTLEN bytes. Return true if decoding was | ||
305 | successful, i.e. if the input was valid base64 data, false | ||
306 | otherwise. If *OUTLEN is too small, as many bytes as possible will | ||
307 | be written to OUT. On return, *OUTLEN holds the length of decoded | ||
308 | bytes in OUT. Note that as soon as any non-alphabet characters are | ||
309 | encountered, decoding is stopped and false is returned. This means | ||
310 | that, when applicable, you must remove any line terminators that is | ||
311 | part of the data stream before calling this function. */ | ||
312 | bool | ||
313 | base64_decode (const char *restrict in, size_t inlen, | ||
314 | char *restrict out, size_t *outlen) | ||
315 | { | ||
316 | size_t outleft = *outlen; | ||
317 | |||
318 | while (inlen >= 2) | ||
319 | { | ||
320 | if (!isbase64 (in[0]) || !isbase64 (in[1])) | ||
321 | break; | ||
322 | |||
323 | if (outleft) | ||
324 | { | ||
325 | *out++ = ((b64[to_uchar (in[0])] << 2) | ||
326 | | (b64[to_uchar (in[1])] >> 4)); | ||
327 | outleft--; | ||
328 | } | ||
329 | |||
330 | if (inlen == 2) | ||
331 | break; | ||
332 | |||
333 | if (in[2] == '=') | ||
334 | { | ||
335 | if (inlen != 4) | ||
336 | break; | ||
337 | |||
338 | if (in[3] != '=') | ||
339 | break; | ||
340 | |||
341 | } | ||
342 | else | ||
343 | { | ||
344 | if (!isbase64 (in[2])) | ||
345 | break; | ||
346 | |||
347 | if (outleft) | ||
348 | { | ||
349 | *out++ = (((b64[to_uchar (in[1])] << 4) & 0xf0) | ||
350 | | (b64[to_uchar (in[2])] >> 2)); | ||
351 | outleft--; | ||
352 | } | ||
353 | |||
354 | if (inlen == 3) | ||
355 | break; | ||
356 | |||
357 | if (in[3] == '=') | ||
358 | { | ||
359 | if (inlen != 4) | ||
360 | break; | ||
361 | } | ||
362 | else | ||
363 | { | ||
364 | if (!isbase64 (in[3])) | ||
365 | break; | ||
366 | |||
367 | if (outleft) | ||
368 | { | ||
369 | *out++ = (((b64[to_uchar (in[2])] << 6) & 0xc0) | ||
370 | | b64[to_uchar (in[3])]); | ||
371 | outleft--; | ||
372 | } | ||
373 | } | ||
374 | } | ||
375 | |||
376 | in += 4; | ||
377 | inlen -= 4; | ||
378 | } | ||
379 | |||
380 | *outlen -= outleft; | ||
381 | |||
382 | if (inlen != 0) | ||
383 | return false; | ||
384 | |||
385 | return true; | ||
386 | } | ||
387 | |||
388 | /* Allocate an output buffer in *OUT, and decode the base64 encoded | ||
389 | data stored in IN of size INLEN to the *OUT buffer. On return, the | ||
390 | size of the decoded data is stored in *OUTLEN. OUTLEN may be NULL, | ||
391 | if the caller is not interested in the decoded length. *OUT may be | ||
392 | NULL to indicate an out of memory error, in which case *OUTLEN | ||
393 | contains the size of the memory block needed. The function returns | ||
394 | true on successful decoding and memory allocation errors. (Use the | ||
395 | *OUT and *OUTLEN parameters to differentiate between successful | ||
396 | decoding and memory error.) The function returns false if the | ||
397 | input was invalid, in which case *OUT is NULL and *OUTLEN is | ||
398 | undefined. */ | ||
399 | bool | ||
400 | base64_decode_alloc (const char *in, size_t inlen, char **out, | ||
401 | size_t *outlen) | ||
402 | { | ||
403 | /* This may allocate a few bytes too much, depending on input, | ||
404 | but it's not worth the extra CPU time to compute the exact amount. | ||
405 | The exact amount is 3 * inlen / 4, minus 1 if the input ends | ||
406 | with "=" and minus another 1 if the input ends with "==". | ||
407 | Dividing before multiplying avoids the possibility of overflow. */ | ||
408 | size_t needlen = 3 * (inlen / 4) + 2; | ||
409 | |||
410 | *out = malloc (needlen); | ||
411 | if (!*out) | ||
412 | return true; | ||
413 | |||
414 | if (!base64_decode (in, inlen, *out, &needlen)) | ||
415 | { | ||
416 | free (*out); | ||
417 | *out = NULL; | ||
418 | return false; | ||
419 | } | ||
420 | |||
421 | if (outlen) | ||
422 | *outlen = needlen; | ||
423 | |||
424 | return true; | ||
425 | } | ||
diff --git a/gl/base64.h b/gl/base64.h new file mode 100644 index 00000000..1f9b203e --- /dev/null +++ b/gl/base64.h | |||
@@ -0,0 +1,45 @@ | |||
1 | /* base64.h -- Encode binary data using printable characters. | ||
2 | Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc. | ||
3 | Written by Simon Josefsson. | ||
4 | |||
5 | This program is free software; you can redistribute it and/or modify | ||
6 | it under the terms of the GNU General Public License as published by | ||
7 | the Free Software Foundation; either version 3, or (at your option) | ||
8 | any later version. | ||
9 | |||
10 | This program is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
13 | GNU General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU General Public License | ||
16 | along with this program; if not, write to the Free Software Foundation, | ||
17 | Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ | ||
18 | |||
19 | #ifndef BASE64_H | ||
20 | # define BASE64_H | ||
21 | |||
22 | /* Get size_t. */ | ||
23 | # include <stddef.h> | ||
24 | |||
25 | /* Get bool. */ | ||
26 | # include <stdbool.h> | ||
27 | |||
28 | /* This uses that the expression (n+(k-1))/k means the smallest | ||
29 | integer >= n/k, i.e., the ceiling of n/k. */ | ||
30 | # define BASE64_LENGTH(inlen) ((((inlen) + 2) / 3) * 4) | ||
31 | |||
32 | extern bool isbase64 (char ch); | ||
33 | |||
34 | extern void base64_encode (const char *restrict in, size_t inlen, | ||
35 | char *restrict out, size_t outlen); | ||
36 | |||
37 | extern size_t base64_encode_alloc (const char *in, size_t inlen, char **out); | ||
38 | |||
39 | extern bool base64_decode (const char *restrict in, size_t inlen, | ||
40 | char *restrict out, size_t *outlen); | ||
41 | |||
42 | extern bool base64_decode_alloc (const char *in, size_t inlen, | ||
43 | char **out, size_t *outlen); | ||
44 | |||
45 | #endif /* BASE64_H */ | ||
diff --git a/gl/charset.alias b/gl/charset.alias new file mode 100644 index 00000000..d9501e2b --- /dev/null +++ b/gl/charset.alias | |||
@@ -0,0 +1,5 @@ | |||
1 | # This file contains a table of character encoding aliases, | ||
2 | # suitable for operating system 'linux-gnu'. | ||
3 | # It was automatically generated from config.charset. | ||
4 | # Packages using this file: | ||
5 | ISO_646.IRV:1983 ASCII | ||
diff --git a/gl/configmake.h b/gl/configmake.h new file mode 100644 index 00000000..f73bc381 --- /dev/null +++ b/gl/configmake.h | |||
@@ -0,0 +1,25 @@ | |||
1 | /* DO NOT EDIT! GENERATED AUTOMATICALLY! */ | ||
2 | #define PREFIX "/usr/local/nagios" | ||
3 | #define EXEC_PREFIX "/usr/local/nagios" | ||
4 | #define BINDIR "/usr/local/nagios/bin" | ||
5 | #define SBINDIR "/usr/local/nagios/sbin" | ||
6 | #define LIBEXECDIR "/usr/local/nagios/libexec" | ||
7 | #define DATAROOTDIR "/usr/local/nagios/share" | ||
8 | #define DATADIR "/usr/local/nagios/share" | ||
9 | #define SYSCONFDIR "/usr/local/nagios/etc" | ||
10 | #define SHAREDSTATEDIR "/usr/local/nagios/com" | ||
11 | #define LOCALSTATEDIR "/usr/local/nagios/var" | ||
12 | #define INCLUDEDIR "/usr/local/nagios/include" | ||
13 | #define OLDINCLUDEDIR "/usr/include" | ||
14 | #define DOCDIR "/usr/local/nagios/share/doc/nagios-plugins" | ||
15 | #define INFODIR "/usr/local/nagios/share/info" | ||
16 | #define HTMLDIR "/usr/local/nagios/share/doc/nagios-plugins" | ||
17 | #define DVIDIR "/usr/local/nagios/share/doc/nagios-plugins" | ||
18 | #define PDFDIR "/usr/local/nagios/share/doc/nagios-plugins" | ||
19 | #define PSDIR "/usr/local/nagios/share/doc/nagios-plugins" | ||
20 | #define LIBDIR "/usr/local/nagios/lib" | ||
21 | #define LOCALEDIR "/usr/local/nagios/share/locale" | ||
22 | #define MANDIR "/usr/local/nagios/share/man" | ||
23 | #define PKGDATADIR "/usr/local/nagios/share/nagios-plugins" | ||
24 | #define PKGINCLUDEDIR "/usr/local/nagios/include/nagios-plugins" | ||
25 | #define PKGLIBDIR "/usr/local/nagios/lib/nagios-plugins" | ||
diff --git a/gl/floor.c b/gl/floor.c new file mode 100644 index 00000000..05a6591a --- /dev/null +++ b/gl/floor.c | |||
@@ -0,0 +1,93 @@ | |||
1 | /* Round towards negative infinity. | ||
2 | Copyright (C) 2007 Free Software Foundation, Inc. | ||
3 | |||
4 | This program is free software: you can redistribute it and/or modify | ||
5 | it under the terms of the GNU General Public License as published by | ||
6 | the Free Software Foundation; either version 3 of the License, or | ||
7 | (at your option) any later version. | ||
8 | |||
9 | This program is distributed in the hope that it will be useful, | ||
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
12 | GNU General Public License for more details. | ||
13 | |||
14 | You should have received a copy of the GNU General Public License | ||
15 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ | ||
16 | |||
17 | /* Written by Bruno Haible <bruno@clisp.org>, 2007. */ | ||
18 | |||
19 | #include <config.h> | ||
20 | |||
21 | /* Specification. */ | ||
22 | #include <math.h> | ||
23 | |||
24 | #include <float.h> | ||
25 | |||
26 | #ifdef USE_LONG_DOUBLE | ||
27 | # define FUNC floorl | ||
28 | # define DOUBLE long double | ||
29 | # define MANT_DIG LDBL_MANT_DIG | ||
30 | # define L_(literal) literal##L | ||
31 | #elif ! defined USE_FLOAT | ||
32 | # define FUNC floor | ||
33 | # define DOUBLE double | ||
34 | # define MANT_DIG DBL_MANT_DIG | ||
35 | # define L_(literal) literal | ||
36 | #else /* defined USE_FLOAT */ | ||
37 | # define FUNC floorf | ||
38 | # define DOUBLE float | ||
39 | # define MANT_DIG FLT_MANT_DIG | ||
40 | # define L_(literal) literal##f | ||
41 | #endif | ||
42 | |||
43 | /* 2^(MANT_DIG-1). */ | ||
44 | static const DOUBLE TWO_MANT_DIG = | ||
45 | /* Assume MANT_DIG <= 5 * 31. | ||
46 | Use the identity | ||
47 | n = floor(n/5) + floor((n+1)/5) + ... + floor((n+4)/5). */ | ||
48 | (DOUBLE) (1U << ((MANT_DIG - 1) / 5)) | ||
49 | * (DOUBLE) (1U << ((MANT_DIG - 1 + 1) / 5)) | ||
50 | * (DOUBLE) (1U << ((MANT_DIG - 1 + 2) / 5)) | ||
51 | * (DOUBLE) (1U << ((MANT_DIG - 1 + 3) / 5)) | ||
52 | * (DOUBLE) (1U << ((MANT_DIG - 1 + 4) / 5)); | ||
53 | |||
54 | DOUBLE | ||
55 | FUNC (DOUBLE x) | ||
56 | { | ||
57 | /* The use of 'volatile' guarantees that excess precision bits are dropped | ||
58 | at each addition step and before the following comparison at the caller's | ||
59 | site. It is necessary on x86 systems where double-floats are not IEEE | ||
60 | compliant by default, to avoid that the results become platform and compiler | ||
61 | option dependent. 'volatile' is a portable alternative to gcc's | ||
62 | -ffloat-store option. */ | ||
63 | volatile DOUBLE y = x; | ||
64 | volatile DOUBLE z = y; | ||
65 | |||
66 | if (z > L_(0.0)) | ||
67 | { | ||
68 | /* Avoid rounding errors for values near 2^k, where k >= MANT_DIG-1. */ | ||
69 | if (z < TWO_MANT_DIG) | ||
70 | { | ||
71 | /* Round to the next integer (nearest or up or down, doesn't matter). */ | ||
72 | z += TWO_MANT_DIG; | ||
73 | z -= TWO_MANT_DIG; | ||
74 | /* Enforce rounding down. */ | ||
75 | if (z > y) | ||
76 | z -= L_(1.0); | ||
77 | } | ||
78 | } | ||
79 | else if (z < L_(0.0)) | ||
80 | { | ||
81 | /* Avoid rounding errors for values near -2^k, where k >= MANT_DIG-1. */ | ||
82 | if (z > - TWO_MANT_DIG) | ||
83 | { | ||
84 | /* Round to the next integer (nearest or up or down, doesn't matter). */ | ||
85 | z -= TWO_MANT_DIG; | ||
86 | z += TWO_MANT_DIG; | ||
87 | /* Enforce rounding down. */ | ||
88 | if (z > y) | ||
89 | z -= L_(1.0); | ||
90 | } | ||
91 | } | ||
92 | return z; | ||
93 | } | ||
diff --git a/gl/floorf.c b/gl/floorf.c new file mode 100644 index 00000000..f0aff338 --- /dev/null +++ b/gl/floorf.c | |||
@@ -0,0 +1,20 @@ | |||
1 | /* Round towards negative infinity. | ||
2 | Copyright (C) 2007 Free Software Foundation, Inc. | ||
3 | |||
4 | This program is free software: you can redistribute it and/or modify | ||
5 | it under the terms of the GNU General Public License as published by | ||
6 | the Free Software Foundation; either version 3 of the License, or | ||
7 | (at your option) any later version. | ||
8 | |||
9 | This program is distributed in the hope that it will be useful, | ||
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
12 | GNU General Public License for more details. | ||
13 | |||
14 | You should have received a copy of the GNU General Public License | ||
15 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ | ||
16 | |||
17 | /* Written by Bruno Haible <bruno@clisp.org>, 2007. */ | ||
18 | |||
19 | #define USE_FLOAT | ||
20 | #include "floor.c" | ||
diff --git a/gl/m4/base64.m4 b/gl/m4/base64.m4 new file mode 100644 index 00000000..24801efa --- /dev/null +++ b/gl/m4/base64.m4 | |||
@@ -0,0 +1,16 @@ | |||
1 | # base64.m4 serial 3 | ||
2 | dnl Copyright (C) 2004, 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 | AC_DEFUN([gl_FUNC_BASE64], | ||
8 | [ | ||
9 | gl_PREREQ_BASE64 | ||
10 | ]) | ||
11 | |||
12 | # Prerequisites of lib/base64.c. | ||
13 | AC_DEFUN([gl_PREREQ_BASE64], [ | ||
14 | AC_REQUIRE([AC_C_INLINE]) | ||
15 | AC_REQUIRE([AC_C_RESTRICT]) | ||
16 | ]) | ||
diff --git a/gl/m4/floorf.m4 b/gl/m4/floorf.m4 new file mode 100644 index 00000000..8cdaa946 --- /dev/null +++ b/gl/m4/floorf.m4 | |||
@@ -0,0 +1,62 @@ | |||
1 | # floorf.m4 serial 3 | ||
2 | dnl Copyright (C) 2007 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 | AC_DEFUN([gl_FUNC_FLOORF], | ||
8 | [ | ||
9 | AC_REQUIRE([gl_MATH_H_DEFAULTS]) | ||
10 | dnl Persuade glibc <math.h> to declare floorf(). | ||
11 | AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) | ||
12 | dnl Test whether floorf() is declared. | ||
13 | AC_CHECK_DECLS([floorf], , , [#include <math.h>]) | ||
14 | if test "$ac_cv_have_decl_floorf" = yes; then | ||
15 | dnl Test whether floorf() can be used without libm. | ||
16 | gl_FUNC_FLOORF_LIBS | ||
17 | if test "$FLOORF_LIBM" = "?"; then | ||
18 | dnl Sun C 5.0 on Solaris declares floorf() and has it in the system-wide | ||
19 | dnl libm.so, but not in the libm.so that the compiler uses. | ||
20 | REPLACE_FLOORF=1 | ||
21 | fi | ||
22 | else | ||
23 | REPLACE_FLOORF=1 | ||
24 | fi | ||
25 | if test $REPLACE_FLOORF = 1; then | ||
26 | AC_LIBOBJ([floorf]) | ||
27 | FLOORF_LIBM= | ||
28 | fi | ||
29 | AC_SUBST([REPLACE_FLOORF]) | ||
30 | AC_SUBST([FLOORF_LIBM]) | ||
31 | ]) | ||
32 | |||
33 | # Determines the libraries needed to get the floorf() function. | ||
34 | # Sets FLOORF_LIBM. | ||
35 | AC_DEFUN([gl_FUNC_FLOORF_LIBS], | ||
36 | [ | ||
37 | AC_CACHE_VAL([gl_cv_func_floorf_libm], [ | ||
38 | gl_cv_func_floorf_libm=? | ||
39 | AC_TRY_LINK([ | ||
40 | #ifndef __NO_MATH_INLINES | ||
41 | # define __NO_MATH_INLINES 1 /* for glibc */ | ||
42 | #endif | ||
43 | #include <math.h> | ||
44 | float x;], | ||
45 | [x = floorf(x);], | ||
46 | [gl_cv_func_floorf_libm=]) | ||
47 | if test "$gl_cv_func_floorf_libm" = "?"; then | ||
48 | save_LIBS="$LIBS" | ||
49 | LIBS="$LIBS -lm" | ||
50 | AC_TRY_LINK([ | ||
51 | #ifndef __NO_MATH_INLINES | ||
52 | # define __NO_MATH_INLINES 1 /* for glibc */ | ||
53 | #endif | ||
54 | #include <math.h> | ||
55 | float x;], | ||
56 | [x = floorf(x);], | ||
57 | [gl_cv_func_floorf_libm="-lm"]) | ||
58 | LIBS="$save_LIBS" | ||
59 | fi | ||
60 | ]) | ||
61 | FLOORF_LIBM="$gl_cv_func_floorf_libm" | ||
62 | ]) | ||
diff --git a/gl/m4/gnulib-cache.m4 b/gl/m4/gnulib-cache.m4 index 6da4d657..302dc191 100644 --- a/gl/m4/gnulib-cache.m4 +++ b/gl/m4/gnulib-cache.m4 | |||
@@ -15,11 +15,11 @@ | |||
15 | 15 | ||
16 | 16 | ||
17 | # Specification in the form of a command-line invocation: | 17 | # Specification in the form of a command-line invocation: |
18 | # gnulib-tool --import --dir=. --lib=libgnu --source-base=gl --m4-base=gl/m4 --doc-base=doc --aux-dir=build-aux --no-libtool --macro-prefix=gl dirname fsusage getaddrinfo gethostname getloadavg getopt gettext mountlist regex vasprintf vsnprintf | 18 | # gnulib-tool --import --dir=. --lib=libgnu --source-base=gl --m4-base=gl/m4 --doc-base=doc --aux-dir=build-aux --no-libtool --macro-prefix=gl base64 dirname floorf fsusage getaddrinfo gethostname getloadavg getopt gettext mountlist regex vasprintf vsnprintf |
19 | 19 | ||
20 | # Specification in the form of a few gnulib-tool.m4 macro invocations: | 20 | # Specification in the form of a few gnulib-tool.m4 macro invocations: |
21 | gl_LOCAL_DIR([]) | 21 | gl_LOCAL_DIR([]) |
22 | gl_MODULES([dirname fsusage getaddrinfo gethostname getloadavg getopt gettext mountlist regex vasprintf vsnprintf]) | 22 | gl_MODULES([base64 dirname floorf fsusage getaddrinfo gethostname getloadavg getopt gettext mountlist regex vasprintf vsnprintf]) |
23 | gl_AVOID([]) | 23 | gl_AVOID([]) |
24 | gl_SOURCE_BASE([gl]) | 24 | gl_SOURCE_BASE([gl]) |
25 | gl_M4_BASE([gl/m4]) | 25 | gl_M4_BASE([gl/m4]) |
diff --git a/gl/m4/gnulib-comp.m4 b/gl/m4/gnulib-comp.m4 index a17e36ad..85ad2e9d 100644 --- a/gl/m4/gnulib-comp.m4 +++ b/gl/m4/gnulib-comp.m4 | |||
@@ -44,6 +44,7 @@ AC_DEFUN([gl_INIT], | |||
44 | gl_FUNC_ALLOCA | 44 | gl_FUNC_ALLOCA |
45 | gl_HEADER_ARPA_INET | 45 | gl_HEADER_ARPA_INET |
46 | AC_PROG_MKDIR_P | 46 | AC_PROG_MKDIR_P |
47 | gl_FUNC_BASE64 | ||
47 | gl_C_STRTOD | 48 | gl_C_STRTOD |
48 | gl_CLOEXEC | 49 | gl_CLOEXEC |
49 | gl_DIRNAME | 50 | gl_DIRNAME |
@@ -56,6 +57,8 @@ AC_DEFUN([gl_INIT], | |||
56 | gl_FCNTL_SAFER | 57 | gl_FCNTL_SAFER |
57 | gl_MODULE_INDICATOR([fcntl-safer]) | 58 | gl_MODULE_INDICATOR([fcntl-safer]) |
58 | gl_FLOAT_H | 59 | gl_FLOAT_H |
60 | gl_FUNC_FLOORF | ||
61 | gl_MATH_MODULE_INDICATOR([floorf]) | ||
59 | gl_FSUSAGE | 62 | gl_FSUSAGE |
60 | gl_GETADDRINFO | 63 | gl_GETADDRINFO |
61 | gl_FUNC_GETHOSTNAME | 64 | gl_FUNC_GETHOSTNAME |
@@ -74,6 +77,7 @@ AC_DEFUN([gl_INIT], | |||
74 | AC_DEFINE([GNULIB_MALLOC_GNU], 1, [Define to indicate the 'malloc' module.]) | 77 | AC_DEFINE([GNULIB_MALLOC_GNU], 1, [Define to indicate the 'malloc' module.]) |
75 | gl_FUNC_MALLOC_POSIX | 78 | gl_FUNC_MALLOC_POSIX |
76 | gl_STDLIB_MODULE_INDICATOR([malloc-posix]) | 79 | gl_STDLIB_MODULE_INDICATOR([malloc-posix]) |
80 | gl_MATH_H | ||
77 | gl_MOUNTLIST | 81 | gl_MOUNTLIST |
78 | gl_HEADER_NETINET_IN | 82 | gl_HEADER_NETINET_IN |
79 | AC_PROG_MKDIR_P | 83 | AC_PROG_MKDIR_P |
@@ -240,6 +244,8 @@ AC_DEFUN([gl_FILE_LIST], [ | |||
240 | lib/alloca.in.h | 244 | lib/alloca.in.h |
241 | lib/asnprintf.c | 245 | lib/asnprintf.c |
242 | lib/asprintf.c | 246 | lib/asprintf.c |
247 | lib/base64.c | ||
248 | lib/base64.h | ||
243 | lib/basename.c | 249 | lib/basename.c |
244 | lib/c-strtod.c | 250 | lib/c-strtod.c |
245 | lib/c-strtod.h | 251 | lib/c-strtod.h |
@@ -259,6 +265,8 @@ AC_DEFUN([gl_FILE_LIST], [ | |||
259 | lib/fd-safer.c | 265 | lib/fd-safer.c |
260 | lib/float+.h | 266 | lib/float+.h |
261 | lib/float.in.h | 267 | lib/float.in.h |
268 | lib/floor.c | ||
269 | lib/floorf.c | ||
262 | lib/fsusage.c | 270 | lib/fsusage.c |
263 | lib/fsusage.h | 271 | lib/fsusage.h |
264 | lib/full-read.c | 272 | lib/full-read.c |
@@ -281,6 +289,7 @@ AC_DEFUN([gl_FILE_LIST], [ | |||
281 | lib/localcharset.c | 289 | lib/localcharset.c |
282 | lib/localcharset.h | 290 | lib/localcharset.h |
283 | lib/malloc.c | 291 | lib/malloc.c |
292 | lib/math.in.h | ||
284 | lib/mountlist.c | 293 | lib/mountlist.c |
285 | lib/mountlist.h | 294 | lib/mountlist.h |
286 | lib/netinet_in.in.h | 295 | lib/netinet_in.in.h |
@@ -333,6 +342,7 @@ AC_DEFUN([gl_FILE_LIST], [ | |||
333 | m4/absolute-header.m4 | 342 | m4/absolute-header.m4 |
334 | m4/alloca.m4 | 343 | m4/alloca.m4 |
335 | m4/arpa_inet_h.m4 | 344 | m4/arpa_inet_h.m4 |
345 | m4/base64.m4 | ||
336 | m4/c-strtod.m4 | 346 | m4/c-strtod.m4 |
337 | m4/cloexec.m4 | 347 | m4/cloexec.m4 |
338 | m4/codeset.m4 | 348 | m4/codeset.m4 |
@@ -345,6 +355,7 @@ AC_DEFUN([gl_FILE_LIST], [ | |||
345 | m4/extensions.m4 | 355 | m4/extensions.m4 |
346 | m4/fcntl-safer.m4 | 356 | m4/fcntl-safer.m4 |
347 | m4/float_h.m4 | 357 | m4/float_h.m4 |
358 | m4/floorf.m4 | ||
348 | m4/fstypename.m4 | 359 | m4/fstypename.m4 |
349 | m4/fsusage.m4 | 360 | m4/fsusage.m4 |
350 | m4/getaddrinfo.m4 | 361 | m4/getaddrinfo.m4 |
@@ -376,6 +387,7 @@ AC_DEFUN([gl_FILE_LIST], [ | |||
376 | m4/longlong.m4 | 387 | m4/longlong.m4 |
377 | m4/ls-mntd-fs.m4 | 388 | m4/ls-mntd-fs.m4 |
378 | m4/malloc.m4 | 389 | m4/malloc.m4 |
390 | m4/math_h.m4 | ||
379 | m4/mountlist.m4 | 391 | m4/mountlist.m4 |
380 | m4/netinet_in_h.m4 | 392 | m4/netinet_in_h.m4 |
381 | m4/nls.m4 | 393 | m4/nls.m4 |
diff --git a/gl/m4/math_h.m4 b/gl/m4/math_h.m4 new file mode 100644 index 00000000..dd99e7f2 --- /dev/null +++ b/gl/m4/math_h.m4 | |||
@@ -0,0 +1,66 @@ | |||
1 | # math_h.m4 serial 9 | ||
2 | dnl Copyright (C) 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 | AC_DEFUN([gl_MATH_H], | ||
8 | [ | ||
9 | AC_REQUIRE([gl_MATH_H_DEFAULTS]) | ||
10 | gl_CHECK_NEXT_HEADERS([math.h]) | ||
11 | ]) | ||
12 | |||
13 | AC_DEFUN([gl_MATH_MODULE_INDICATOR], | ||
14 | [ | ||
15 | dnl Use AC_REQUIRE here, so that the default settings are expanded once only. | ||
16 | AC_REQUIRE([gl_MATH_H_DEFAULTS]) | ||
17 | GNULIB_[]m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./-],[ABCDEFGHIJKLMNOPQRSTUVWXYZ___])=1 | ||
18 | ]) | ||
19 | |||
20 | AC_DEFUN([gl_MATH_H_DEFAULTS], | ||
21 | [ | ||
22 | GNULIB_CEILF=0; AC_SUBST([GNULIB_CEILF]) | ||
23 | GNULIB_CEILL=0; AC_SUBST([GNULIB_CEILL]) | ||
24 | GNULIB_FLOORF=0; AC_SUBST([GNULIB_FLOORF]) | ||
25 | GNULIB_FLOORL=0; AC_SUBST([GNULIB_FLOORL]) | ||
26 | GNULIB_FREXP=0; AC_SUBST([GNULIB_FREXP]) | ||
27 | GNULIB_FREXPL=0; AC_SUBST([GNULIB_FREXPL]) | ||
28 | GNULIB_ISFINITE=0; AC_SUBST([GNULIB_ISFINITE]) | ||
29 | GNULIB_LDEXPL=0; AC_SUBST([GNULIB_LDEXPL]) | ||
30 | GNULIB_MATHL=0; AC_SUBST([GNULIB_MATHL]) | ||
31 | GNULIB_ROUND=0; AC_SUBST([GNULIB_ROUND]) | ||
32 | GNULIB_ROUNDF=0; AC_SUBST([GNULIB_ROUNDF]) | ||
33 | GNULIB_ROUNDL=0; AC_SUBST([GNULIB_ROUNDL]) | ||
34 | GNULIB_SIGNBIT=0; AC_SUBST([GNULIB_SIGNBIT]) | ||
35 | GNULIB_TRUNC=0; AC_SUBST([GNULIB_TRUNC]) | ||
36 | GNULIB_TRUNCF=0; AC_SUBST([GNULIB_TRUNCF]) | ||
37 | GNULIB_TRUNCL=0; AC_SUBST([GNULIB_TRUNCL]) | ||
38 | dnl Assume proper GNU behavior unless another module says otherwise. | ||
39 | HAVE_DECL_ACOSL=1; AC_SUBST([HAVE_DECL_ACOSL]) | ||
40 | HAVE_DECL_ASINL=1; AC_SUBST([HAVE_DECL_ASINL]) | ||
41 | HAVE_DECL_ATANL=1; AC_SUBST([HAVE_DECL_ATANL]) | ||
42 | HAVE_DECL_COSL=1; AC_SUBST([HAVE_DECL_COSL]) | ||
43 | HAVE_DECL_EXPL=1; AC_SUBST([HAVE_DECL_EXPL]) | ||
44 | HAVE_DECL_FREXPL=1; AC_SUBST([HAVE_DECL_FREXPL]) | ||
45 | HAVE_DECL_LDEXPL=1; AC_SUBST([HAVE_DECL_LDEXPL]) | ||
46 | HAVE_DECL_LOGL=1; AC_SUBST([HAVE_DECL_LOGL]) | ||
47 | HAVE_DECL_SINL=1; AC_SUBST([HAVE_DECL_SINL]) | ||
48 | HAVE_DECL_SQRTL=1; AC_SUBST([HAVE_DECL_SQRTL]) | ||
49 | HAVE_DECL_TANL=1; AC_SUBST([HAVE_DECL_TANL]) | ||
50 | HAVE_DECL_TRUNC=1; AC_SUBST([HAVE_DECL_TRUNC]) | ||
51 | HAVE_DECL_TRUNCF=1; AC_SUBST([HAVE_DECL_TRUNCF]) | ||
52 | HAVE_DECL_TRUNCL=1; AC_SUBST([HAVE_DECL_TRUNCL]) | ||
53 | REPLACE_CEILF=0; AC_SUBST([REPLACE_CEILF]) | ||
54 | REPLACE_CEILL=0; AC_SUBST([REPLACE_CEILL]) | ||
55 | REPLACE_FLOORF=0; AC_SUBST([REPLACE_FLOORF]) | ||
56 | REPLACE_FLOORL=0; AC_SUBST([REPLACE_FLOORL]) | ||
57 | REPLACE_FREXP=0; AC_SUBST([REPLACE_FREXP]) | ||
58 | REPLACE_FREXPL=0; AC_SUBST([REPLACE_FREXPL]) | ||
59 | REPLACE_ISFINITE=0; AC_SUBST([REPLACE_ISFINITE]) | ||
60 | REPLACE_LDEXPL=0; AC_SUBST([REPLACE_LDEXPL]) | ||
61 | REPLACE_ROUND=0; AC_SUBST([REPLACE_ROUND]) | ||
62 | REPLACE_ROUNDF=0; AC_SUBST([REPLACE_ROUNDF]) | ||
63 | REPLACE_ROUNDL=0; AC_SUBST([REPLACE_ROUNDL]) | ||
64 | REPLACE_SIGNBIT=0; AC_SUBST([REPLACE_SIGNBIT]) | ||
65 | REPLACE_SIGNBIT_USING_GCC=0; AC_SUBST([REPLACE_SIGNBIT_USING_GCC]) | ||
66 | ]) | ||
diff --git a/gl/math.h b/gl/math.h new file mode 100644 index 00000000..9db986e0 --- /dev/null +++ b/gl/math.h | |||
@@ -0,0 +1,442 @@ | |||
1 | /* DO NOT EDIT! GENERATED AUTOMATICALLY! */ | ||
2 | /* A GNU-like <math.h>. | ||
3 | |||
4 | Copyright (C) 2002-2003, 2007 Free Software Foundation, Inc. | ||
5 | |||
6 | This program is free software: you can redistribute it and/or modify | ||
7 | it under the terms of the GNU General Public License as published by | ||
8 | the Free Software Foundation; either version 3 of the License, or | ||
9 | (at your option) any later version. | ||
10 | |||
11 | This program is distributed in the hope that it will be useful, | ||
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
14 | GNU General Public License for more details. | ||
15 | |||
16 | You should have received a copy of the GNU General Public License | ||
17 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ | ||
18 | |||
19 | #ifndef _GL_MATH_H | ||
20 | |||
21 | /* The include_next requires a split double-inclusion guard. */ | ||
22 | #include_next <math.h> | ||
23 | |||
24 | #ifndef _GL_MATH_H | ||
25 | #define _GL_MATH_H | ||
26 | |||
27 | |||
28 | /* The definition of GL_LINK_WARNING is copied here. */ | ||
29 | /* GL_LINK_WARNING("literal string") arranges to emit the literal string as | ||
30 | a linker warning on most glibc systems. | ||
31 | We use a linker warning rather than a preprocessor warning, because | ||
32 | #warning cannot be used inside macros. */ | ||
33 | #ifndef GL_LINK_WARNING | ||
34 | /* This works on platforms with GNU ld and ELF object format. | ||
35 | Testing __GLIBC__ is sufficient for asserting that GNU ld is in use. | ||
36 | Testing __ELF__ guarantees the ELF object format. | ||
37 | Testing __GNUC__ is necessary for the compound expression syntax. */ | ||
38 | # if defined __GLIBC__ && defined __ELF__ && defined __GNUC__ | ||
39 | # define GL_LINK_WARNING(message) \ | ||
40 | GL_LINK_WARNING1 (__FILE__, __LINE__, message) | ||
41 | # define GL_LINK_WARNING1(file, line, message) \ | ||
42 | GL_LINK_WARNING2 (file, line, message) /* macroexpand file and line */ | ||
43 | # define GL_LINK_WARNING2(file, line, message) \ | ||
44 | GL_LINK_WARNING3 (file ":" #line ": warning: " message) | ||
45 | # define GL_LINK_WARNING3(message) \ | ||
46 | ({ static const char warning[sizeof (message)] \ | ||
47 | __attribute__ ((__unused__, \ | ||
48 | __section__ (".gnu.warning"), \ | ||
49 | __aligned__ (1))) \ | ||
50 | = message "\n"; \ | ||
51 | (void)0; \ | ||
52 | }) | ||
53 | # else | ||
54 | # define GL_LINK_WARNING(message) ((void) 0) | ||
55 | # endif | ||
56 | #endif | ||
57 | |||
58 | |||
59 | #ifdef __cplusplus | ||
60 | extern "C" { | ||
61 | #endif | ||
62 | |||
63 | |||
64 | /* Write x as | ||
65 | x = mantissa * 2^exp | ||
66 | where | ||
67 | If x finite and nonzero: 0.5 <= |mantissa| < 1.0. | ||
68 | If x is zero: mantissa = x, exp = 0. | ||
69 | If x is infinite or NaN: mantissa = x, exp unspecified. | ||
70 | Store exp in *EXPPTR and return mantissa. */ | ||
71 | #if 0 | ||
72 | # if 0 | ||
73 | # define frexp rpl_frexp | ||
74 | extern double frexp (double x, int *expptr); | ||
75 | # endif | ||
76 | #elif defined GNULIB_POSIXCHECK | ||
77 | # undef frexp | ||
78 | # define frexp(x,e) \ | ||
79 | (GL_LINK_WARNING ("frexp is unportable - " \ | ||
80 | "use gnulib module frexp for portability"), \ | ||
81 | frexp (x, e)) | ||
82 | #endif | ||
83 | |||
84 | |||
85 | #if 0 || !1 | ||
86 | extern long double acosl (long double x); | ||
87 | #endif | ||
88 | #if !0 && defined GNULIB_POSIXCHECK | ||
89 | # undef acosl | ||
90 | # define acosl(x) \ | ||
91 | (GL_LINK_WARNING ("acosl is unportable - " \ | ||
92 | "use gnulib module mathl for portability"), \ | ||
93 | acosl (x)) | ||
94 | #endif | ||
95 | |||
96 | |||
97 | #if 0 || !1 | ||
98 | extern long double asinl (long double x); | ||
99 | #endif | ||
100 | #if !0 && defined GNULIB_POSIXCHECK | ||
101 | # undef asinl | ||
102 | # define asinl(x) \ | ||
103 | (GL_LINK_WARNING ("asinl is unportable - " \ | ||
104 | "use gnulib module mathl for portability"), \ | ||
105 | asinl (x)) | ||
106 | #endif | ||
107 | |||
108 | |||
109 | #if 0 || !1 | ||
110 | extern long double atanl (long double x); | ||
111 | #endif | ||
112 | #if !0 && defined GNULIB_POSIXCHECK | ||
113 | # undef atanl | ||
114 | # define atanl(x) \ | ||
115 | (GL_LINK_WARNING ("atanl is unportable - " \ | ||
116 | "use gnulib module mathl for portability"), \ | ||
117 | atanl (x)) | ||
118 | #endif | ||
119 | |||
120 | |||
121 | #if 0 | ||
122 | # if 0 | ||
123 | # define ceilf rpl_ceilf | ||
124 | extern float ceilf (float x); | ||
125 | # endif | ||
126 | #elif defined GNULIB_POSIXCHECK | ||
127 | # undef ceilf | ||
128 | # define ceilf(x) \ | ||
129 | (GL_LINK_WARNING ("ceilf is unportable - " \ | ||
130 | "use gnulib module ceilf for portability"), \ | ||
131 | ceilf (x)) | ||
132 | #endif | ||
133 | |||
134 | #if 0 | ||
135 | # if 0 | ||
136 | # define ceill rpl_ceill | ||
137 | extern long double ceill (long double x); | ||
138 | # endif | ||
139 | #elif defined GNULIB_POSIXCHECK | ||
140 | # undef ceill | ||
141 | # define ceill(x) \ | ||
142 | (GL_LINK_WARNING ("ceill is unportable - " \ | ||
143 | "use gnulib module ceill for portability"), \ | ||
144 | ceill (x)) | ||
145 | #endif | ||
146 | |||
147 | |||
148 | #if 0 || !1 | ||
149 | extern long double cosl (long double x); | ||
150 | #endif | ||
151 | #if !0 && defined GNULIB_POSIXCHECK | ||
152 | # undef cosl | ||
153 | # define cosl(x) \ | ||
154 | (GL_LINK_WARNING ("cosl is unportable - " \ | ||
155 | "use gnulib module mathl for portability"), \ | ||
156 | cosl (x)) | ||
157 | #endif | ||
158 | |||
159 | |||
160 | #if 0 || !1 | ||
161 | extern long double expl (long double x); | ||
162 | #endif | ||
163 | #if !0 && defined GNULIB_POSIXCHECK | ||
164 | # undef expl | ||
165 | # define expl(x) \ | ||
166 | (GL_LINK_WARNING ("expl is unportable - " \ | ||
167 | "use gnulib module mathl for portability"), \ | ||
168 | expl (x)) | ||
169 | #endif | ||
170 | |||
171 | |||
172 | #if 1 | ||
173 | # if 0 | ||
174 | # define floorf rpl_floorf | ||
175 | extern float floorf (float x); | ||
176 | # endif | ||
177 | #elif defined GNULIB_POSIXCHECK | ||
178 | # undef floorf | ||
179 | # define floorf(x) \ | ||
180 | (GL_LINK_WARNING ("floorf is unportable - " \ | ||
181 | "use gnulib module floorf for portability"), \ | ||
182 | floorf (x)) | ||
183 | #endif | ||
184 | |||
185 | #if 0 | ||
186 | # if 0 | ||
187 | # define floorl rpl_floorl | ||
188 | extern long double floorl (long double x); | ||
189 | # endif | ||
190 | #elif defined GNULIB_POSIXCHECK | ||
191 | # undef floorl | ||
192 | # define floorl(x) \ | ||
193 | (GL_LINK_WARNING ("floorl is unportable - " \ | ||
194 | "use gnulib module floorl for portability"), \ | ||
195 | floorl (x)) | ||
196 | #endif | ||
197 | |||
198 | |||
199 | /* Write x as | ||
200 | x = mantissa * 2^exp | ||
201 | where | ||
202 | If x finite and nonzero: 0.5 <= |mantissa| < 1.0. | ||
203 | If x is zero: mantissa = x, exp = 0. | ||
204 | If x is infinite or NaN: mantissa = x, exp unspecified. | ||
205 | Store exp in *EXPPTR and return mantissa. */ | ||
206 | #if 0 && 0 | ||
207 | # define frexpl rpl_frexpl | ||
208 | #endif | ||
209 | #if (0 && 0) || !1 | ||
210 | extern long double frexpl (long double x, int *expptr); | ||
211 | #endif | ||
212 | #if !0 && defined GNULIB_POSIXCHECK | ||
213 | # undef frexpl | ||
214 | # define frexpl(x,e) \ | ||
215 | (GL_LINK_WARNING ("frexpl is unportable - " \ | ||
216 | "use gnulib module frexpl for portability"), \ | ||
217 | frexpl (x, e)) | ||
218 | #endif | ||
219 | |||
220 | |||
221 | /* Return x * 2^exp. */ | ||
222 | #if 0 && 0 | ||
223 | # define ldexpl rpl_ldexpl | ||
224 | #endif | ||
225 | #if (0 && 0) || !1 | ||
226 | extern long double ldexpl (long double x, int exp); | ||
227 | #endif | ||
228 | #if !0 && defined GNULIB_POSIXCHECK | ||
229 | # undef ldexpl | ||
230 | # define ldexpl(x,e) \ | ||
231 | (GL_LINK_WARNING ("ldexpl is unportable - " \ | ||
232 | "use gnulib module ldexpl for portability"), \ | ||
233 | ldexpl (x, e)) | ||
234 | #endif | ||
235 | |||
236 | |||
237 | #if 0 || !1 | ||
238 | extern long double logl (long double x); | ||
239 | #endif | ||
240 | #if !0 && defined GNULIB_POSIXCHECK | ||
241 | # undef logl | ||
242 | # define logl(x) \ | ||
243 | (GL_LINK_WARNING ("logl is unportable - " \ | ||
244 | "use gnulib module mathl for portability"), \ | ||
245 | logl (x)) | ||
246 | #endif | ||
247 | |||
248 | |||
249 | #if 0 | ||
250 | # if 0 | ||
251 | # undef roundf | ||
252 | # define roundf rpl_roundf | ||
253 | extern float roundf (float x); | ||
254 | # endif | ||
255 | #elif defined GNULIB_POSIXCHECK | ||
256 | # undef roundf | ||
257 | # define roundf(x) \ | ||
258 | (GL_LINK_WARNING ("roundf is unportable - " \ | ||
259 | "use gnulib module roundf for portability"), \ | ||
260 | roundf (x)) | ||
261 | #endif | ||
262 | |||
263 | #if 0 | ||
264 | # if 0 | ||
265 | # undef round | ||
266 | # define round rpl_round | ||
267 | extern double round (double x); | ||
268 | # endif | ||
269 | #elif defined GNULIB_POSIXCHECK | ||
270 | # undef round | ||
271 | # define round(x) \ | ||
272 | (GL_LINK_WARNING ("round is unportable - " \ | ||
273 | "use gnulib module round for portability"), \ | ||
274 | round (x)) | ||
275 | #endif | ||
276 | |||
277 | #if 0 | ||
278 | # if 0 | ||
279 | # undef roundl | ||
280 | # define roundl rpl_roundl | ||
281 | extern long double roundl (long double x); | ||
282 | # endif | ||
283 | #elif defined GNULIB_POSIXCHECK | ||
284 | # undef roundl | ||
285 | # define roundl(x) \ | ||
286 | (GL_LINK_WARNING ("roundl is unportable - " \ | ||
287 | "use gnulib module roundl for portability"), \ | ||
288 | roundl (x)) | ||
289 | #endif | ||
290 | |||
291 | |||
292 | #if 0 || !1 | ||
293 | extern long double sinl (long double x); | ||
294 | #endif | ||
295 | #if !0 && defined GNULIB_POSIXCHECK | ||
296 | # undef sinl | ||
297 | # define sinl(x) \ | ||
298 | (GL_LINK_WARNING ("sinl is unportable - " \ | ||
299 | "use gnulib module mathl for portability"), \ | ||
300 | sinl (x)) | ||
301 | #endif | ||
302 | |||
303 | |||
304 | #if 0 || !1 | ||
305 | extern long double sqrtl (long double x); | ||
306 | #endif | ||
307 | #if !0 && defined GNULIB_POSIXCHECK | ||
308 | # undef sqrtl | ||
309 | # define sqrtl(x) \ | ||
310 | (GL_LINK_WARNING ("sqrtl is unportable - " \ | ||
311 | "use gnulib module mathl for portability"), \ | ||
312 | sqrtl (x)) | ||
313 | #endif | ||
314 | |||
315 | |||
316 | #if 0 || !1 | ||
317 | extern long double tanl (long double x); | ||
318 | #endif | ||
319 | #if !0 && defined GNULIB_POSIXCHECK | ||
320 | # undef tanl | ||
321 | # define tanl(x) \ | ||
322 | (GL_LINK_WARNING ("tanl is unportable - " \ | ||
323 | "use gnulib module mathl for portability"), \ | ||
324 | tanl (x)) | ||
325 | #endif | ||
326 | |||
327 | |||
328 | #if 0 | ||
329 | # if !1 | ||
330 | # define truncf rpl_truncf | ||
331 | extern float truncf (float x); | ||
332 | # endif | ||
333 | #elif defined GNULIB_POSIXCHECK | ||
334 | # undef truncf | ||
335 | # define truncf(x) \ | ||
336 | (GL_LINK_WARNING ("truncf is unportable - " \ | ||
337 | "use gnulib module truncf for portability"), \ | ||
338 | truncf (x)) | ||
339 | #endif | ||
340 | |||
341 | #if 0 | ||
342 | # if !1 | ||
343 | # define trunc rpl_trunc | ||
344 | extern double trunc (double x); | ||
345 | # endif | ||
346 | #elif defined GNULIB_POSIXCHECK | ||
347 | # undef trunc | ||
348 | # define trunc(x) \ | ||
349 | (GL_LINK_WARNING ("trunc is unportable - " \ | ||
350 | "use gnulib module trunc for portability"), \ | ||
351 | trunc (x)) | ||
352 | #endif | ||
353 | |||
354 | #if 0 | ||
355 | # if !1 | ||
356 | # define truncl rpl_truncl | ||
357 | extern long double truncl (long double x); | ||
358 | # endif | ||
359 | #elif defined GNULIB_POSIXCHECK | ||
360 | # undef truncl | ||
361 | # define truncl(x) \ | ||
362 | (GL_LINK_WARNING ("truncl is unportable - " \ | ||
363 | "use gnulib module truncl for portability"), \ | ||
364 | truncl (x)) | ||
365 | #endif | ||
366 | |||
367 | |||
368 | #if 0 | ||
369 | # if 0 | ||
370 | extern int gl_isfinitef (float x); | ||
371 | extern int gl_isfinited (double x); | ||
372 | extern int gl_isfinitel (long double x); | ||
373 | # undef isfinite | ||
374 | # define isfinite(x) \ | ||
375 | (sizeof (x) == sizeof (long double) ? gl_isfinitel (x) : \ | ||
376 | sizeof (x) == sizeof (double) ? gl_isfinited (x) : \ | ||
377 | gl_isfinitef (x)) | ||
378 | # endif | ||
379 | #elif defined GNULIB_POSIXCHECK | ||
380 | /* How to override a macro? */ | ||
381 | #endif | ||
382 | |||
383 | |||
384 | #if 0 | ||
385 | # if 0 | ||
386 | # undef signbit | ||
387 | /* GCC 4.0 and newer provides three built-ins for signbit. */ | ||
388 | # define signbit(x) \ | ||
389 | (sizeof (x) == sizeof (long double) ? __builtin_signbitl (x) : \ | ||
390 | sizeof (x) == sizeof (double) ? __builtin_signbit (x) : \ | ||
391 | __builtin_signbitf (x)) | ||
392 | # endif | ||
393 | # if 0 | ||
394 | # undef signbit | ||
395 | extern int gl_signbitf (float arg); | ||
396 | extern int gl_signbitd (double arg); | ||
397 | extern int gl_signbitl (long double arg); | ||
398 | # if __GNUC__ >= 2 && !__STRICT_ANSI__ | ||
399 | # if defined FLT_SIGNBIT_WORD && defined FLT_SIGNBIT_BIT | ||
400 | # define gl_signbitf(arg) \ | ||
401 | ({ union { float _value; \ | ||
402 | unsigned int _word[(sizeof (float) + sizeof (unsigned int) - 1) / sizeof (unsigned int)]; \ | ||
403 | } _m; \ | ||
404 | _m._value = (arg); \ | ||
405 | (_m._word[FLT_SIGNBIT_WORD] >> FLT_SIGNBIT_BIT) & 1; \ | ||
406 | }) | ||
407 | # endif | ||
408 | # if defined DBL_SIGNBIT_WORD && defined DBL_SIGNBIT_BIT | ||
409 | # define gl_signbitd(arg) \ | ||
410 | ({ union { double _value; \ | ||
411 | unsigned int _word[(sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)]; \ | ||
412 | } _m; \ | ||
413 | _m._value = (arg); \ | ||
414 | (_m._word[DBL_SIGNBIT_WORD] >> DBL_SIGNBIT_BIT) & 1; \ | ||
415 | }) | ||
416 | # endif | ||
417 | # if defined LDBL_SIGNBIT_WORD && defined LDBL_SIGNBIT_BIT | ||
418 | # define gl_signbitl(arg) \ | ||
419 | ({ union { long double _value; \ | ||
420 | unsigned int _word[(sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)]; \ | ||
421 | } _m; \ | ||
422 | _m._value = (arg); \ | ||
423 | (_m._word[LDBL_SIGNBIT_WORD] >> LDBL_SIGNBIT_BIT) & 1; \ | ||
424 | }) | ||
425 | # endif | ||
426 | # endif | ||
427 | # define signbit(x) \ | ||
428 | (sizeof (x) == sizeof (long double) ? gl_signbitl (x) : \ | ||
429 | sizeof (x) == sizeof (double) ? gl_signbitd (x) : \ | ||
430 | gl_signbitf (x)) | ||
431 | # endif | ||
432 | #elif defined GNULIB_POSIXCHECK | ||
433 | /* How to override a macro? */ | ||
434 | #endif | ||
435 | |||
436 | |||
437 | #ifdef __cplusplus | ||
438 | } | ||
439 | #endif | ||
440 | |||
441 | #endif /* _GL_MATH_H */ | ||
442 | #endif /* _GL_MATH_H */ | ||
diff --git a/gl/math.in.h b/gl/math.in.h new file mode 100644 index 00000000..c3515d73 --- /dev/null +++ b/gl/math.in.h | |||
@@ -0,0 +1,413 @@ | |||
1 | /* A GNU-like <math.h>. | ||
2 | |||
3 | Copyright (C) 2002-2003, 2007 Free Software Foundation, Inc. | ||
4 | |||
5 | This program is free software: you can redistribute it and/or modify | ||
6 | it under the terms of the GNU General Public License as published by | ||
7 | the Free Software Foundation; either version 3 of the License, or | ||
8 | (at your option) any later version. | ||
9 | |||
10 | This program is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
13 | GNU General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU General Public License | ||
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ | ||
17 | |||
18 | #ifndef _GL_MATH_H | ||
19 | |||
20 | /* The include_next requires a split double-inclusion guard. */ | ||
21 | #@INCLUDE_NEXT@ @NEXT_MATH_H@ | ||
22 | |||
23 | #ifndef _GL_MATH_H | ||
24 | #define _GL_MATH_H | ||
25 | |||
26 | |||
27 | /* The definition of GL_LINK_WARNING is copied here. */ | ||
28 | |||
29 | |||
30 | #ifdef __cplusplus | ||
31 | extern "C" { | ||
32 | #endif | ||
33 | |||
34 | |||
35 | /* Write x as | ||
36 | x = mantissa * 2^exp | ||
37 | where | ||
38 | If x finite and nonzero: 0.5 <= |mantissa| < 1.0. | ||
39 | If x is zero: mantissa = x, exp = 0. | ||
40 | If x is infinite or NaN: mantissa = x, exp unspecified. | ||
41 | Store exp in *EXPPTR and return mantissa. */ | ||
42 | #if @GNULIB_FREXP@ | ||
43 | # if @REPLACE_FREXP@ | ||
44 | # define frexp rpl_frexp | ||
45 | extern double frexp (double x, int *expptr); | ||
46 | # endif | ||
47 | #elif defined GNULIB_POSIXCHECK | ||
48 | # undef frexp | ||
49 | # define frexp(x,e) \ | ||
50 | (GL_LINK_WARNING ("frexp is unportable - " \ | ||
51 | "use gnulib module frexp for portability"), \ | ||
52 | frexp (x, e)) | ||
53 | #endif | ||
54 | |||
55 | |||
56 | #if @GNULIB_MATHL@ || !@HAVE_DECL_ACOSL@ | ||
57 | extern long double acosl (long double x); | ||
58 | #endif | ||
59 | #if !@GNULIB_MATHL@ && defined GNULIB_POSIXCHECK | ||
60 | # undef acosl | ||
61 | # define acosl(x) \ | ||
62 | (GL_LINK_WARNING ("acosl is unportable - " \ | ||
63 | "use gnulib module mathl for portability"), \ | ||
64 | acosl (x)) | ||
65 | #endif | ||
66 | |||
67 | |||
68 | #if @GNULIB_MATHL@ || !@HAVE_DECL_ASINL@ | ||
69 | extern long double asinl (long double x); | ||
70 | #endif | ||
71 | #if !@GNULIB_MATHL@ && defined GNULIB_POSIXCHECK | ||
72 | # undef asinl | ||
73 | # define asinl(x) \ | ||
74 | (GL_LINK_WARNING ("asinl is unportable - " \ | ||
75 | "use gnulib module mathl for portability"), \ | ||
76 | asinl (x)) | ||
77 | #endif | ||
78 | |||
79 | |||
80 | #if @GNULIB_MATHL@ || !@HAVE_DECL_ATANL@ | ||
81 | extern long double atanl (long double x); | ||
82 | #endif | ||
83 | #if !@GNULIB_MATHL@ && defined GNULIB_POSIXCHECK | ||
84 | # undef atanl | ||
85 | # define atanl(x) \ | ||
86 | (GL_LINK_WARNING ("atanl is unportable - " \ | ||
87 | "use gnulib module mathl for portability"), \ | ||
88 | atanl (x)) | ||
89 | #endif | ||
90 | |||
91 | |||
92 | #if @GNULIB_CEILF@ | ||
93 | # if @REPLACE_CEILF@ | ||
94 | # define ceilf rpl_ceilf | ||
95 | extern float ceilf (float x); | ||
96 | # endif | ||
97 | #elif defined GNULIB_POSIXCHECK | ||
98 | # undef ceilf | ||
99 | # define ceilf(x) \ | ||
100 | (GL_LINK_WARNING ("ceilf is unportable - " \ | ||
101 | "use gnulib module ceilf for portability"), \ | ||
102 | ceilf (x)) | ||
103 | #endif | ||
104 | |||
105 | #if @GNULIB_CEILL@ | ||
106 | # if @REPLACE_CEILL@ | ||
107 | # define ceill rpl_ceill | ||
108 | extern long double ceill (long double x); | ||
109 | # endif | ||
110 | #elif defined GNULIB_POSIXCHECK | ||
111 | # undef ceill | ||
112 | # define ceill(x) \ | ||
113 | (GL_LINK_WARNING ("ceill is unportable - " \ | ||
114 | "use gnulib module ceill for portability"), \ | ||
115 | ceill (x)) | ||
116 | #endif | ||
117 | |||
118 | |||
119 | #if @GNULIB_MATHL@ || !@HAVE_DECL_COSL@ | ||
120 | extern long double cosl (long double x); | ||
121 | #endif | ||
122 | #if !@GNULIB_MATHL@ && defined GNULIB_POSIXCHECK | ||
123 | # undef cosl | ||
124 | # define cosl(x) \ | ||
125 | (GL_LINK_WARNING ("cosl is unportable - " \ | ||
126 | "use gnulib module mathl for portability"), \ | ||
127 | cosl (x)) | ||
128 | #endif | ||
129 | |||
130 | |||
131 | #if @GNULIB_MATHL@ || !@HAVE_DECL_EXPL@ | ||
132 | extern long double expl (long double x); | ||
133 | #endif | ||
134 | #if !@GNULIB_MATHL@ && defined GNULIB_POSIXCHECK | ||
135 | # undef expl | ||
136 | # define expl(x) \ | ||
137 | (GL_LINK_WARNING ("expl is unportable - " \ | ||
138 | "use gnulib module mathl for portability"), \ | ||
139 | expl (x)) | ||
140 | #endif | ||
141 | |||
142 | |||
143 | #if @GNULIB_FLOORF@ | ||
144 | # if @REPLACE_FLOORF@ | ||
145 | # define floorf rpl_floorf | ||
146 | extern float floorf (float x); | ||
147 | # endif | ||
148 | #elif defined GNULIB_POSIXCHECK | ||
149 | # undef floorf | ||
150 | # define floorf(x) \ | ||
151 | (GL_LINK_WARNING ("floorf is unportable - " \ | ||
152 | "use gnulib module floorf for portability"), \ | ||
153 | floorf (x)) | ||
154 | #endif | ||
155 | |||
156 | #if @GNULIB_FLOORL@ | ||
157 | # if @REPLACE_FLOORL@ | ||
158 | # define floorl rpl_floorl | ||
159 | extern long double floorl (long double x); | ||
160 | # endif | ||
161 | #elif defined GNULIB_POSIXCHECK | ||
162 | # undef floorl | ||
163 | # define floorl(x) \ | ||
164 | (GL_LINK_WARNING ("floorl is unportable - " \ | ||
165 | "use gnulib module floorl for portability"), \ | ||
166 | floorl (x)) | ||
167 | #endif | ||
168 | |||
169 | |||
170 | /* Write x as | ||
171 | x = mantissa * 2^exp | ||
172 | where | ||
173 | If x finite and nonzero: 0.5 <= |mantissa| < 1.0. | ||
174 | If x is zero: mantissa = x, exp = 0. | ||
175 | If x is infinite or NaN: mantissa = x, exp unspecified. | ||
176 | Store exp in *EXPPTR and return mantissa. */ | ||
177 | #if @GNULIB_FREXPL@ && @REPLACE_FREXPL@ | ||
178 | # define frexpl rpl_frexpl | ||
179 | #endif | ||
180 | #if (@GNULIB_FREXPL@ && @REPLACE_FREXPL@) || !@HAVE_DECL_FREXPL@ | ||
181 | extern long double frexpl (long double x, int *expptr); | ||
182 | #endif | ||
183 | #if !@GNULIB_FREXPL@ && defined GNULIB_POSIXCHECK | ||
184 | # undef frexpl | ||
185 | # define frexpl(x,e) \ | ||
186 | (GL_LINK_WARNING ("frexpl is unportable - " \ | ||
187 | "use gnulib module frexpl for portability"), \ | ||
188 | frexpl (x, e)) | ||
189 | #endif | ||
190 | |||
191 | |||
192 | /* Return x * 2^exp. */ | ||
193 | #if @GNULIB_LDEXPL@ && @REPLACE_LDEXPL@ | ||
194 | # define ldexpl rpl_ldexpl | ||
195 | #endif | ||
196 | #if (@GNULIB_LDEXPL@ && @REPLACE_LDEXPL@) || !@HAVE_DECL_LDEXPL@ | ||
197 | extern long double ldexpl (long double x, int exp); | ||
198 | #endif | ||
199 | #if !@GNULIB_LDEXPL@ && defined GNULIB_POSIXCHECK | ||
200 | # undef ldexpl | ||
201 | # define ldexpl(x,e) \ | ||
202 | (GL_LINK_WARNING ("ldexpl is unportable - " \ | ||
203 | "use gnulib module ldexpl for portability"), \ | ||
204 | ldexpl (x, e)) | ||
205 | #endif | ||
206 | |||
207 | |||
208 | #if @GNULIB_MATHL@ || !@HAVE_DECL_LOGL@ | ||
209 | extern long double logl (long double x); | ||
210 | #endif | ||
211 | #if !@GNULIB_MATHL@ && defined GNULIB_POSIXCHECK | ||
212 | # undef logl | ||
213 | # define logl(x) \ | ||
214 | (GL_LINK_WARNING ("logl is unportable - " \ | ||
215 | "use gnulib module mathl for portability"), \ | ||
216 | logl (x)) | ||
217 | #endif | ||
218 | |||
219 | |||
220 | #if @GNULIB_ROUNDF@ | ||
221 | # if @REPLACE_ROUNDF@ | ||
222 | # undef roundf | ||
223 | # define roundf rpl_roundf | ||
224 | extern float roundf (float x); | ||
225 | # endif | ||
226 | #elif defined GNULIB_POSIXCHECK | ||
227 | # undef roundf | ||
228 | # define roundf(x) \ | ||
229 | (GL_LINK_WARNING ("roundf is unportable - " \ | ||
230 | "use gnulib module roundf for portability"), \ | ||
231 | roundf (x)) | ||
232 | #endif | ||
233 | |||
234 | #if @GNULIB_ROUND@ | ||
235 | # if @REPLACE_ROUND@ | ||
236 | # undef round | ||
237 | # define round rpl_round | ||
238 | extern double round (double x); | ||
239 | # endif | ||
240 | #elif defined GNULIB_POSIXCHECK | ||
241 | # undef round | ||
242 | # define round(x) \ | ||
243 | (GL_LINK_WARNING ("round is unportable - " \ | ||
244 | "use gnulib module round for portability"), \ | ||
245 | round (x)) | ||
246 | #endif | ||
247 | |||
248 | #if @GNULIB_ROUNDL@ | ||
249 | # if @REPLACE_ROUNDL@ | ||
250 | # undef roundl | ||
251 | # define roundl rpl_roundl | ||
252 | extern long double roundl (long double x); | ||
253 | # endif | ||
254 | #elif defined GNULIB_POSIXCHECK | ||
255 | # undef roundl | ||
256 | # define roundl(x) \ | ||
257 | (GL_LINK_WARNING ("roundl is unportable - " \ | ||
258 | "use gnulib module roundl for portability"), \ | ||
259 | roundl (x)) | ||
260 | #endif | ||
261 | |||
262 | |||
263 | #if @GNULIB_MATHL@ || !@HAVE_DECL_SINL@ | ||
264 | extern long double sinl (long double x); | ||
265 | #endif | ||
266 | #if !@GNULIB_MATHL@ && defined GNULIB_POSIXCHECK | ||
267 | # undef sinl | ||
268 | # define sinl(x) \ | ||
269 | (GL_LINK_WARNING ("sinl is unportable - " \ | ||
270 | "use gnulib module mathl for portability"), \ | ||
271 | sinl (x)) | ||
272 | #endif | ||
273 | |||
274 | |||
275 | #if @GNULIB_MATHL@ || !@HAVE_DECL_SQRTL@ | ||
276 | extern long double sqrtl (long double x); | ||
277 | #endif | ||
278 | #if !@GNULIB_MATHL@ && defined GNULIB_POSIXCHECK | ||
279 | # undef sqrtl | ||
280 | # define sqrtl(x) \ | ||
281 | (GL_LINK_WARNING ("sqrtl is unportable - " \ | ||
282 | "use gnulib module mathl for portability"), \ | ||
283 | sqrtl (x)) | ||
284 | #endif | ||
285 | |||
286 | |||
287 | #if @GNULIB_MATHL@ || !@HAVE_DECL_TANL@ | ||
288 | extern long double tanl (long double x); | ||
289 | #endif | ||
290 | #if !@GNULIB_MATHL@ && defined GNULIB_POSIXCHECK | ||
291 | # undef tanl | ||
292 | # define tanl(x) \ | ||
293 | (GL_LINK_WARNING ("tanl is unportable - " \ | ||
294 | "use gnulib module mathl for portability"), \ | ||
295 | tanl (x)) | ||
296 | #endif | ||
297 | |||
298 | |||
299 | #if @GNULIB_TRUNCF@ | ||
300 | # if !@HAVE_DECL_TRUNCF@ | ||
301 | # define truncf rpl_truncf | ||
302 | extern float truncf (float x); | ||
303 | # endif | ||
304 | #elif defined GNULIB_POSIXCHECK | ||
305 | # undef truncf | ||
306 | # define truncf(x) \ | ||
307 | (GL_LINK_WARNING ("truncf is unportable - " \ | ||
308 | "use gnulib module truncf for portability"), \ | ||
309 | truncf (x)) | ||
310 | #endif | ||
311 | |||
312 | #if @GNULIB_TRUNC@ | ||
313 | # if !@HAVE_DECL_TRUNC@ | ||
314 | # define trunc rpl_trunc | ||
315 | extern double trunc (double x); | ||
316 | # endif | ||
317 | #elif defined GNULIB_POSIXCHECK | ||
318 | # undef trunc | ||
319 | # define trunc(x) \ | ||
320 | (GL_LINK_WARNING ("trunc is unportable - " \ | ||
321 | "use gnulib module trunc for portability"), \ | ||
322 | trunc (x)) | ||
323 | #endif | ||
324 | |||
325 | #if @GNULIB_TRUNCL@ | ||
326 | # if !@HAVE_DECL_TRUNCL@ | ||
327 | # define truncl rpl_truncl | ||
328 | extern long double truncl (long double x); | ||
329 | # endif | ||
330 | #elif defined GNULIB_POSIXCHECK | ||
331 | # undef truncl | ||
332 | # define truncl(x) \ | ||
333 | (GL_LINK_WARNING ("truncl is unportable - " \ | ||
334 | "use gnulib module truncl for portability"), \ | ||
335 | truncl (x)) | ||
336 | #endif | ||
337 | |||
338 | |||
339 | #if @GNULIB_ISFINITE@ | ||
340 | # if @REPLACE_ISFINITE@ | ||
341 | extern int gl_isfinitef (float x); | ||
342 | extern int gl_isfinited (double x); | ||
343 | extern int gl_isfinitel (long double x); | ||
344 | # undef isfinite | ||
345 | # define isfinite(x) \ | ||
346 | (sizeof (x) == sizeof (long double) ? gl_isfinitel (x) : \ | ||
347 | sizeof (x) == sizeof (double) ? gl_isfinited (x) : \ | ||
348 | gl_isfinitef (x)) | ||
349 | # endif | ||
350 | #elif defined GNULIB_POSIXCHECK | ||
351 | /* How to override a macro? */ | ||
352 | #endif | ||
353 | |||
354 | |||
355 | #if @GNULIB_SIGNBIT@ | ||
356 | # if @REPLACE_SIGNBIT_USING_GCC@ | ||
357 | # undef signbit | ||
358 | /* GCC 4.0 and newer provides three built-ins for signbit. */ | ||
359 | # define signbit(x) \ | ||
360 | (sizeof (x) == sizeof (long double) ? __builtin_signbitl (x) : \ | ||
361 | sizeof (x) == sizeof (double) ? __builtin_signbit (x) : \ | ||
362 | __builtin_signbitf (x)) | ||
363 | # endif | ||
364 | # if @REPLACE_SIGNBIT@ | ||
365 | # undef signbit | ||
366 | extern int gl_signbitf (float arg); | ||
367 | extern int gl_signbitd (double arg); | ||
368 | extern int gl_signbitl (long double arg); | ||
369 | # if __GNUC__ >= 2 && !__STRICT_ANSI__ | ||
370 | # if defined FLT_SIGNBIT_WORD && defined FLT_SIGNBIT_BIT | ||
371 | # define gl_signbitf(arg) \ | ||
372 | ({ union { float _value; \ | ||
373 | unsigned int _word[(sizeof (float) + sizeof (unsigned int) - 1) / sizeof (unsigned int)]; \ | ||
374 | } _m; \ | ||
375 | _m._value = (arg); \ | ||
376 | (_m._word[FLT_SIGNBIT_WORD] >> FLT_SIGNBIT_BIT) & 1; \ | ||
377 | }) | ||
378 | # endif | ||
379 | # if defined DBL_SIGNBIT_WORD && defined DBL_SIGNBIT_BIT | ||
380 | # define gl_signbitd(arg) \ | ||
381 | ({ union { double _value; \ | ||
382 | unsigned int _word[(sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)]; \ | ||
383 | } _m; \ | ||
384 | _m._value = (arg); \ | ||
385 | (_m._word[DBL_SIGNBIT_WORD] >> DBL_SIGNBIT_BIT) & 1; \ | ||
386 | }) | ||
387 | # endif | ||
388 | # if defined LDBL_SIGNBIT_WORD && defined LDBL_SIGNBIT_BIT | ||
389 | # define gl_signbitl(arg) \ | ||
390 | ({ union { long double _value; \ | ||
391 | unsigned int _word[(sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)]; \ | ||
392 | } _m; \ | ||
393 | _m._value = (arg); \ | ||
394 | (_m._word[LDBL_SIGNBIT_WORD] >> LDBL_SIGNBIT_BIT) & 1; \ | ||
395 | }) | ||
396 | # endif | ||
397 | # endif | ||
398 | # define signbit(x) \ | ||
399 | (sizeof (x) == sizeof (long double) ? gl_signbitl (x) : \ | ||
400 | sizeof (x) == sizeof (double) ? gl_signbitd (x) : \ | ||
401 | gl_signbitf (x)) | ||
402 | # endif | ||
403 | #elif defined GNULIB_POSIXCHECK | ||
404 | /* How to override a macro? */ | ||
405 | #endif | ||
406 | |||
407 | |||
408 | #ifdef __cplusplus | ||
409 | } | ||
410 | #endif | ||
411 | |||
412 | #endif /* _GL_MATH_H */ | ||
413 | #endif /* _GL_MATH_H */ | ||
diff --git a/gl/ref-add.sed b/gl/ref-add.sed new file mode 100644 index 00000000..3ac991fe --- /dev/null +++ b/gl/ref-add.sed | |||
@@ -0,0 +1,10 @@ | |||
1 | /^# Packages using this file: / { | ||
2 | s/# Packages using this file:// | ||
3 | ta | ||
4 | :a | ||
5 | s/ nagios-plugins / nagios-plugins / | ||
6 | tb | ||
7 | s/ $/ nagios-plugins / | ||
8 | :b | ||
9 | s/^/# Packages using this file:/ | ||
10 | } | ||
diff --git a/gl/ref-del.sed b/gl/ref-del.sed new file mode 100644 index 00000000..a48fdb77 --- /dev/null +++ b/gl/ref-del.sed | |||
@@ -0,0 +1,5 @@ | |||
1 | /^# Packages using this file: / { | ||
2 | s/# Packages using this file:// | ||
3 | s/ nagios-plugins / / | ||
4 | s/^/# Packages using this file:/ | ||
5 | } | ||
diff --git a/gl/stdio.h b/gl/stdio.h new file mode 100644 index 00000000..f09ee831 --- /dev/null +++ b/gl/stdio.h | |||
@@ -0,0 +1,411 @@ | |||
1 | /* DO NOT EDIT! GENERATED AUTOMATICALLY! */ | ||
2 | /* A GNU-like <stdio.h>. | ||
3 | |||
4 | Copyright (C) 2004, 2007-2008 Free Software Foundation, Inc. | ||
5 | |||
6 | This program is free software; you can redistribute it and/or modify | ||
7 | it under the terms of the GNU General Public License as published by | ||
8 | the Free Software Foundation; either version 3, or (at your option) | ||
9 | any later version. | ||
10 | |||
11 | This program is distributed in the hope that it will be useful, | ||
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
14 | GNU General Public License for more details. | ||
15 | |||
16 | You should have received a copy of the GNU General Public License | ||
17 | along with this program; if not, write to the Free Software Foundation, | ||
18 | Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ | ||
19 | |||
20 | #if defined __need_FILE || defined __need___FILE | ||
21 | /* Special invocation convention inside glibc header files. */ | ||
22 | |||
23 | #include_next <stdio.h> | ||
24 | |||
25 | #else | ||
26 | /* Normal invocation convention. */ | ||
27 | |||
28 | #ifndef _GL_STDIO_H | ||
29 | |||
30 | /* The include_next requires a split double-inclusion guard. */ | ||
31 | #include_next <stdio.h> | ||
32 | |||
33 | #ifndef _GL_STDIO_H | ||
34 | #define _GL_STDIO_H | ||
35 | |||
36 | #include <stdarg.h> | ||
37 | #include <stddef.h> | ||
38 | |||
39 | #if (0 && 0) \ | ||
40 | || (0 && 0) \ | ||
41 | || (0 && !1) \ | ||
42 | || (0 && (!1 || 0)) | ||
43 | /* Get off_t and ssize_t. */ | ||
44 | # include <sys/types.h> | ||
45 | #endif | ||
46 | |||
47 | #ifndef __attribute__ | ||
48 | /* This feature is available in gcc versions 2.5 and later. */ | ||
49 | # if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) | ||
50 | # define __attribute__(Spec) /* empty */ | ||
51 | # endif | ||
52 | /* The __-protected variants of `format' and `printf' attributes | ||
53 | are accepted by gcc versions 2.6.4 (effectively 2.7) and later. */ | ||
54 | # if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7) | ||
55 | # define __format__ format | ||
56 | # define __printf__ printf | ||
57 | # endif | ||
58 | #endif | ||
59 | |||
60 | |||
61 | /* The definition of GL_LINK_WARNING is copied here. */ | ||
62 | /* GL_LINK_WARNING("literal string") arranges to emit the literal string as | ||
63 | a linker warning on most glibc systems. | ||
64 | We use a linker warning rather than a preprocessor warning, because | ||
65 | #warning cannot be used inside macros. */ | ||
66 | #ifndef GL_LINK_WARNING | ||
67 | /* This works on platforms with GNU ld and ELF object format. | ||
68 | Testing __GLIBC__ is sufficient for asserting that GNU ld is in use. | ||
69 | Testing __ELF__ guarantees the ELF object format. | ||
70 | Testing __GNUC__ is necessary for the compound expression syntax. */ | ||
71 | # if defined __GLIBC__ && defined __ELF__ && defined __GNUC__ | ||
72 | # define GL_LINK_WARNING(message) \ | ||
73 | GL_LINK_WARNING1 (__FILE__, __LINE__, message) | ||
74 | # define GL_LINK_WARNING1(file, line, message) \ | ||
75 | GL_LINK_WARNING2 (file, line, message) /* macroexpand file and line */ | ||
76 | # define GL_LINK_WARNING2(file, line, message) \ | ||
77 | GL_LINK_WARNING3 (file ":" #line ": warning: " message) | ||
78 | # define GL_LINK_WARNING3(message) \ | ||
79 | ({ static const char warning[sizeof (message)] \ | ||
80 | __attribute__ ((__unused__, \ | ||
81 | __section__ (".gnu.warning"), \ | ||
82 | __aligned__ (1))) \ | ||
83 | = message "\n"; \ | ||
84 | (void)0; \ | ||
85 | }) | ||
86 | # else | ||
87 | # define GL_LINK_WARNING(message) ((void) 0) | ||
88 | # endif | ||
89 | #endif | ||
90 | |||
91 | |||
92 | #ifdef __cplusplus | ||
93 | extern "C" { | ||
94 | #endif | ||
95 | |||
96 | |||
97 | #if 0 | ||
98 | # if 0 | ||
99 | # define fprintf rpl_fprintf | ||
100 | extern int fprintf (FILE *fp, const char *format, ...) | ||
101 | __attribute__ ((__format__ (__printf__, 2, 3))); | ||
102 | # endif | ||
103 | #elif defined GNULIB_POSIXCHECK | ||
104 | # undef fprintf | ||
105 | # define fprintf \ | ||
106 | (GL_LINK_WARNING ("fprintf is not always POSIX compliant - " \ | ||
107 | "use gnulib module fprintf-posix for portable " \ | ||
108 | "POSIX compliance"), \ | ||
109 | fprintf) | ||
110 | #endif | ||
111 | |||
112 | #if 0 | ||
113 | # if 0 | ||
114 | # define vfprintf rpl_vfprintf | ||
115 | extern int vfprintf (FILE *fp, const char *format, va_list args) | ||
116 | __attribute__ ((__format__ (__printf__, 2, 0))); | ||
117 | # endif | ||
118 | #elif defined GNULIB_POSIXCHECK | ||
119 | # undef vfprintf | ||
120 | # define vfprintf(s,f,a) \ | ||
121 | (GL_LINK_WARNING ("vfprintf is not always POSIX compliant - " \ | ||
122 | "use gnulib module vfprintf-posix for portable " \ | ||
123 | "POSIX compliance"), \ | ||
124 | vfprintf (s, f, a)) | ||
125 | #endif | ||
126 | |||
127 | #if 0 | ||
128 | # if 0 | ||
129 | /* Don't break __attribute__((format(printf,M,N))). */ | ||
130 | # define printf __printf__ | ||
131 | extern int printf (const char *format, ...) | ||
132 | __attribute__ ((__format__ (__printf__, 1, 2))); | ||
133 | # endif | ||
134 | #elif defined GNULIB_POSIXCHECK | ||
135 | # undef printf | ||
136 | # define printf \ | ||
137 | (GL_LINK_WARNING ("printf is not always POSIX compliant - " \ | ||
138 | "use gnulib module printf-posix for portable " \ | ||
139 | "POSIX compliance"), \ | ||
140 | printf) | ||
141 | /* Don't break __attribute__((format(printf,M,N))). */ | ||
142 | # define format(kind,m,n) format (__##kind##__, m, n) | ||
143 | # define __format__(kind,m,n) __format__ (__##kind##__, m, n) | ||
144 | # define ____printf____ __printf__ | ||
145 | # define ____scanf____ __scanf__ | ||
146 | # define ____strftime____ __strftime__ | ||
147 | # define ____strfmon____ __strfmon__ | ||
148 | #endif | ||
149 | |||
150 | #if 0 | ||
151 | # if 0 | ||
152 | # define vprintf rpl_vprintf | ||
153 | extern int vprintf (const char *format, va_list args) | ||
154 | __attribute__ ((__format__ (__printf__, 1, 0))); | ||
155 | # endif | ||
156 | #elif defined GNULIB_POSIXCHECK | ||
157 | # undef vprintf | ||
158 | # define vprintf(f,a) \ | ||
159 | (GL_LINK_WARNING ("vprintf is not always POSIX compliant - " \ | ||
160 | "use gnulib module vprintf-posix for portable " \ | ||
161 | "POSIX compliance"), \ | ||
162 | vprintf (f, a)) | ||
163 | #endif | ||
164 | |||
165 | #if 1 | ||
166 | # if 0 | ||
167 | # define snprintf rpl_snprintf | ||
168 | # endif | ||
169 | # if 0 || !1 | ||
170 | extern int snprintf (char *str, size_t size, const char *format, ...) | ||
171 | __attribute__ ((__format__ (__printf__, 3, 4))); | ||
172 | # endif | ||
173 | #elif defined GNULIB_POSIXCHECK | ||
174 | # undef snprintf | ||
175 | # define snprintf \ | ||
176 | (GL_LINK_WARNING ("snprintf is unportable - " \ | ||
177 | "use gnulib module snprintf for portability"), \ | ||
178 | snprintf) | ||
179 | #endif | ||
180 | |||
181 | #if 1 | ||
182 | # if 0 | ||
183 | # define vsnprintf rpl_vsnprintf | ||
184 | # endif | ||
185 | # if 0 || !1 | ||
186 | extern int vsnprintf (char *str, size_t size, const char *format, va_list args) | ||
187 | __attribute__ ((__format__ (__printf__, 3, 0))); | ||
188 | # endif | ||
189 | #elif defined GNULIB_POSIXCHECK | ||
190 | # undef vsnprintf | ||
191 | # define vsnprintf(b,s,f,a) \ | ||
192 | (GL_LINK_WARNING ("vsnprintf is unportable - " \ | ||
193 | "use gnulib module vsnprintf for portability"), \ | ||
194 | vsnprintf (b, s, f, a)) | ||
195 | #endif | ||
196 | |||
197 | #if 0 | ||
198 | # if 0 | ||
199 | # define sprintf rpl_sprintf | ||
200 | extern int sprintf (char *str, const char *format, ...) | ||
201 | __attribute__ ((__format__ (__printf__, 2, 3))); | ||
202 | # endif | ||
203 | #elif defined GNULIB_POSIXCHECK | ||
204 | # undef sprintf | ||
205 | # define sprintf \ | ||
206 | (GL_LINK_WARNING ("sprintf is not always POSIX compliant - " \ | ||
207 | "use gnulib module sprintf-posix for portable " \ | ||
208 | "POSIX compliance"), \ | ||
209 | sprintf) | ||
210 | #endif | ||
211 | |||
212 | #if 0 | ||
213 | # if 0 | ||
214 | # define vsprintf rpl_vsprintf | ||
215 | extern int vsprintf (char *str, const char *format, va_list args) | ||
216 | __attribute__ ((__format__ (__printf__, 2, 0))); | ||
217 | # endif | ||
218 | #elif defined GNULIB_POSIXCHECK | ||
219 | # undef vsprintf | ||
220 | # define vsprintf(b,f,a) \ | ||
221 | (GL_LINK_WARNING ("vsprintf is not always POSIX compliant - " \ | ||
222 | "use gnulib module vsprintf-posix for portable " \ | ||
223 | "POSIX compliance"), \ | ||
224 | vsprintf (b, f, a)) | ||
225 | #endif | ||
226 | |||
227 | #if 1 | ||
228 | # if 0 | ||
229 | # define asprintf rpl_asprintf | ||
230 | # define vasprintf rpl_vasprintf | ||
231 | # endif | ||
232 | # if 0 || !1 | ||
233 | /* Write formatted output to a string dynamically allocated with malloc(). | ||
234 | If the memory allocation succeeds, store the address of the string in | ||
235 | *RESULT and return the number of resulting bytes, excluding the trailing | ||
236 | NUL. Upon memory allocation error, or some other error, return -1. */ | ||
237 | extern int asprintf (char **result, const char *format, ...) | ||
238 | __attribute__ ((__format__ (__printf__, 2, 3))); | ||
239 | extern int vasprintf (char **result, const char *format, va_list args) | ||
240 | __attribute__ ((__format__ (__printf__, 2, 0))); | ||
241 | # endif | ||
242 | #endif | ||
243 | |||
244 | #if 0 | ||
245 | # if 0 | ||
246 | # define fopen rpl_fopen | ||
247 | extern FILE * fopen (const char *filename, const char *mode); | ||
248 | # endif | ||
249 | #elif defined GNULIB_POSIXCHECK | ||
250 | # undef fopen | ||
251 | # define fopen(f,m) \ | ||
252 | (GL_LINK_WARNING ("fopen on Win32 platforms is not POSIX compatible - " \ | ||
253 | "use gnulib module fopen for portability"), \ | ||
254 | fopen (f, m)) | ||
255 | #endif | ||
256 | |||
257 | #if 0 | ||
258 | # if 0 | ||
259 | # define freopen rpl_freopen | ||
260 | extern FILE * freopen (const char *filename, const char *mode, FILE *stream); | ||
261 | # endif | ||
262 | #elif defined GNULIB_POSIXCHECK | ||
263 | # undef freopen | ||
264 | # define freopen(f,m,s) \ | ||
265 | (GL_LINK_WARNING ("freopen on Win32 platforms is not POSIX compatible - " \ | ||
266 | "use gnulib module freopen for portability"), \ | ||
267 | freopen (f, m, s)) | ||
268 | #endif | ||
269 | |||
270 | #if 0 | ||
271 | # if 0 | ||
272 | /* Provide fseek, fseeko functions that are aware of a preceding | ||
273 | fflush(), and which detect pipes. */ | ||
274 | # define fseeko rpl_fseeko | ||
275 | extern int fseeko (FILE *fp, off_t offset, int whence); | ||
276 | # define fseek(fp, offset, whence) fseeko (fp, (off_t)(offset), whence) | ||
277 | # endif | ||
278 | #elif defined GNULIB_POSIXCHECK | ||
279 | # undef fseeko | ||
280 | # define fseeko(f,o,w) \ | ||
281 | (GL_LINK_WARNING ("fseeko is unportable - " \ | ||
282 | "use gnulib module fseeko for portability"), \ | ||
283 | fseeko (f, o, w)) | ||
284 | #endif | ||
285 | |||
286 | #if 0 && 0 | ||
287 | extern int rpl_fseek (FILE *fp, long offset, int whence); | ||
288 | # undef fseek | ||
289 | # if defined GNULIB_POSIXCHECK | ||
290 | # define fseek(f,o,w) \ | ||
291 | (GL_LINK_WARNING ("fseek cannot handle files larger than 4 GB " \ | ||
292 | "on 32-bit platforms - " \ | ||
293 | "use fseeko function for handling of large files"), \ | ||
294 | rpl_fseek (f, o, w)) | ||
295 | # else | ||
296 | # define fseek rpl_fseek | ||
297 | # endif | ||
298 | #elif defined GNULIB_POSIXCHECK | ||
299 | # ifndef fseek | ||
300 | # define fseek(f,o,w) \ | ||
301 | (GL_LINK_WARNING ("fseek cannot handle files larger than 4 GB " \ | ||
302 | "on 32-bit platforms - " \ | ||
303 | "use fseeko function for handling of large files"), \ | ||
304 | fseek (f, o, w)) | ||
305 | # endif | ||
306 | #endif | ||
307 | |||
308 | #if 0 | ||
309 | # if 0 | ||
310 | # define ftello rpl_ftello | ||
311 | extern off_t ftello (FILE *fp); | ||
312 | # define ftell(fp) ftello (fp) | ||
313 | # endif | ||
314 | #elif defined GNULIB_POSIXCHECK | ||
315 | # undef ftello | ||
316 | # define ftello(f) \ | ||
317 | (GL_LINK_WARNING ("ftello is unportable - " \ | ||
318 | "use gnulib module ftello for portability"), \ | ||
319 | ftello (f)) | ||
320 | #endif | ||
321 | |||
322 | #if 0 && 0 | ||
323 | extern long rpl_ftell (FILE *fp); | ||
324 | # undef ftell | ||
325 | # if GNULIB_POSIXCHECK | ||
326 | # define ftell(f) \ | ||
327 | (GL_LINK_WARNING ("ftell cannot handle files larger than 4 GB " \ | ||
328 | "on 32-bit platforms - " \ | ||
329 | "use ftello function for handling of large files"), \ | ||
330 | rpl_ftell (f)) | ||
331 | # else | ||
332 | # define ftell rpl_ftell | ||
333 | # endif | ||
334 | #elif defined GNULIB_POSIXCHECK | ||
335 | # ifndef ftell | ||
336 | # define ftell(f) \ | ||
337 | (GL_LINK_WARNING ("ftell cannot handle files larger than 4 GB " \ | ||
338 | "on 32-bit platforms - " \ | ||
339 | "use ftello function for handling of large files"), \ | ||
340 | ftell (f)) | ||
341 | # endif | ||
342 | #endif | ||
343 | |||
344 | #if 0 | ||
345 | # if 0 | ||
346 | # define fflush rpl_fflush | ||
347 | /* Flush all pending data on STREAM according to POSIX rules. Both | ||
348 | output and seekable input streams are supported. | ||
349 | Note! LOSS OF DATA can occur if fflush is applied on an input stream | ||
350 | that is _not_seekable_ or on an update stream that is _not_seekable_ | ||
351 | and in which the most recent operation was input. Seekability can | ||
352 | be tested with lseek(fileno(fp),0,SEEK_CUR). */ | ||
353 | extern int fflush (FILE *gl_stream); | ||
354 | # endif | ||
355 | #elif defined GNULIB_POSIXCHECK | ||
356 | # undef fflush | ||
357 | # define fflush(f) \ | ||
358 | (GL_LINK_WARNING ("fflush is not always POSIX compliant - " \ | ||
359 | "use gnulib module fflush for portable " \ | ||
360 | "POSIX compliance"), \ | ||
361 | fflush (f)) | ||
362 | #endif | ||
363 | |||
364 | #if 0 | ||
365 | # if !1 | ||
366 | /* Read input, up to (and including) the next occurrence of DELIMITER, from | ||
367 | STREAM, store it in *LINEPTR (and NUL-terminate it). | ||
368 | *LINEPTR is a pointer returned from malloc (or NULL), pointing to *LINESIZE | ||
369 | bytes of space. It is realloc'd as necessary. | ||
370 | Return the number of bytes read and stored at *LINEPTR (not including the | ||
371 | NUL terminator), or -1 on error or EOF. */ | ||
372 | extern ssize_t getdelim (char **lineptr, size_t *linesize, int delimiter, | ||
373 | FILE *stream); | ||
374 | # endif | ||
375 | #elif defined GNULIB_POSIXCHECK | ||
376 | # undef getdelim | ||
377 | # define getdelim(l, s, d, f) \ | ||
378 | (GL_LINK_WARNING ("getdelim is unportable - " \ | ||
379 | "use gnulib module getdelim for portability"), \ | ||
380 | getdelim (l, s, d, f)) | ||
381 | #endif | ||
382 | |||
383 | #if 0 | ||
384 | # if 0 | ||
385 | # undef getline | ||
386 | # define getline rpl_getline | ||
387 | # endif | ||
388 | # if !1 || 0 | ||
389 | /* Read a line, up to (and including) the next newline, from STREAM, store it | ||
390 | in *LINEPTR (and NUL-terminate it). | ||
391 | *LINEPTR is a pointer returned from malloc (or NULL), pointing to *LINESIZE | ||
392 | bytes of space. It is realloc'd as necessary. | ||
393 | Return the number of bytes read and stored at *LINEPTR (not including the | ||
394 | NUL terminator), or -1 on error or EOF. */ | ||
395 | extern ssize_t getline (char **lineptr, size_t *linesize, FILE *stream); | ||
396 | # endif | ||
397 | #elif defined GNULIB_POSIXCHECK | ||
398 | # undef getline | ||
399 | # define getline(l, s, f) \ | ||
400 | (GL_LINK_WARNING ("getline is unportable - " \ | ||
401 | "use gnulib module getline for portability"), \ | ||
402 | getline (l, s, f)) | ||
403 | #endif | ||
404 | |||
405 | #ifdef __cplusplus | ||
406 | } | ||
407 | #endif | ||
408 | |||
409 | #endif /* _GL_STDIO_H */ | ||
410 | #endif /* _GL_STDIO_H */ | ||
411 | #endif | ||
diff --git a/gl/stdlib.h b/gl/stdlib.h new file mode 100644 index 00000000..86da899f --- /dev/null +++ b/gl/stdlib.h | |||
@@ -0,0 +1,237 @@ | |||
1 | /* DO NOT EDIT! GENERATED AUTOMATICALLY! */ | ||
2 | /* A GNU-like <stdlib.h>. | ||
3 | |||
4 | Copyright (C) 1995, 2001-2004, 2006-2007 Free Software Foundation, Inc. | ||
5 | |||
6 | This program is free software: you can redistribute it and/or modify | ||
7 | it under the terms of the GNU General Public License as published by | ||
8 | the Free Software Foundation; either version 3 of the License, or | ||
9 | (at your option) any later version. | ||
10 | |||
11 | This program is distributed in the hope that it will be useful, | ||
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
14 | GNU General Public License for more details. | ||
15 | |||
16 | You should have received a copy of the GNU General Public License | ||
17 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ | ||
18 | |||
19 | #if defined __need_malloc_and_calloc | ||
20 | /* Special invocation convention inside glibc header files. */ | ||
21 | |||
22 | #include_next <stdlib.h> | ||
23 | |||
24 | #else | ||
25 | /* Normal invocation convention. */ | ||
26 | |||
27 | #ifndef _GL_STDLIB_H | ||
28 | |||
29 | /* The include_next requires a split double-inclusion guard. */ | ||
30 | #include_next <stdlib.h> | ||
31 | |||
32 | #ifndef _GL_STDLIB_H | ||
33 | #define _GL_STDLIB_H | ||
34 | |||
35 | |||
36 | /* The definition of GL_LINK_WARNING is copied here. */ | ||
37 | /* GL_LINK_WARNING("literal string") arranges to emit the literal string as | ||
38 | a linker warning on most glibc systems. | ||
39 | We use a linker warning rather than a preprocessor warning, because | ||
40 | #warning cannot be used inside macros. */ | ||
41 | #ifndef GL_LINK_WARNING | ||
42 | /* This works on platforms with GNU ld and ELF object format. | ||
43 | Testing __GLIBC__ is sufficient for asserting that GNU ld is in use. | ||
44 | Testing __ELF__ guarantees the ELF object format. | ||
45 | Testing __GNUC__ is necessary for the compound expression syntax. */ | ||
46 | # if defined __GLIBC__ && defined __ELF__ && defined __GNUC__ | ||
47 | # define GL_LINK_WARNING(message) \ | ||
48 | GL_LINK_WARNING1 (__FILE__, __LINE__, message) | ||
49 | # define GL_LINK_WARNING1(file, line, message) \ | ||
50 | GL_LINK_WARNING2 (file, line, message) /* macroexpand file and line */ | ||
51 | # define GL_LINK_WARNING2(file, line, message) \ | ||
52 | GL_LINK_WARNING3 (file ":" #line ": warning: " message) | ||
53 | # define GL_LINK_WARNING3(message) \ | ||
54 | ({ static const char warning[sizeof (message)] \ | ||
55 | __attribute__ ((__unused__, \ | ||
56 | __section__ (".gnu.warning"), \ | ||
57 | __aligned__ (1))) \ | ||
58 | = message "\n"; \ | ||
59 | (void)0; \ | ||
60 | }) | ||
61 | # else | ||
62 | # define GL_LINK_WARNING(message) ((void) 0) | ||
63 | # endif | ||
64 | #endif | ||
65 | |||
66 | |||
67 | /* Some systems do not define EXIT_*, despite otherwise supporting C89. */ | ||
68 | #ifndef EXIT_SUCCESS | ||
69 | # define EXIT_SUCCESS 0 | ||
70 | #endif | ||
71 | /* Tandem/NSK and other platforms that define EXIT_FAILURE as -1 interfere | ||
72 | with proper operation of xargs. */ | ||
73 | #ifndef EXIT_FAILURE | ||
74 | # define EXIT_FAILURE 1 | ||
75 | #elif EXIT_FAILURE != 1 | ||
76 | # undef EXIT_FAILURE | ||
77 | # define EXIT_FAILURE 1 | ||
78 | #endif | ||
79 | |||
80 | |||
81 | #ifdef __cplusplus | ||
82 | extern "C" { | ||
83 | #endif | ||
84 | |||
85 | |||
86 | #if 1 | ||
87 | # if !1 | ||
88 | # undef malloc | ||
89 | # define malloc rpl_malloc | ||
90 | extern void * malloc (size_t size); | ||
91 | # endif | ||
92 | #elif defined GNULIB_POSIXCHECK | ||
93 | # undef malloc | ||
94 | # define malloc(s) \ | ||
95 | (GL_LINK_WARNING ("malloc is not POSIX compliant everywhere - " \ | ||
96 | "use gnulib module malloc-posix for portability"), \ | ||
97 | malloc (s)) | ||
98 | #endif | ||
99 | |||
100 | |||
101 | #if 0 | ||
102 | # if !1 | ||
103 | # undef realloc | ||
104 | # define realloc rpl_realloc | ||
105 | extern void * realloc (void *ptr, size_t size); | ||
106 | # endif | ||
107 | #elif defined GNULIB_POSIXCHECK | ||
108 | # undef realloc | ||
109 | # define realloc(p,s) \ | ||
110 | (GL_LINK_WARNING ("realloc is not POSIX compliant everywhere - " \ | ||
111 | "use gnulib module realloc-posix for portability"), \ | ||
112 | realloc (p, s)) | ||
113 | #endif | ||
114 | |||
115 | |||
116 | #if 0 | ||
117 | # if !1 | ||
118 | # undef calloc | ||
119 | # define calloc rpl_calloc | ||
120 | extern void * calloc (size_t nmemb, size_t size); | ||
121 | # endif | ||
122 | #elif defined GNULIB_POSIXCHECK | ||
123 | # undef calloc | ||
124 | # define calloc(n,s) \ | ||
125 | (GL_LINK_WARNING ("calloc is not POSIX compliant everywhere - " \ | ||
126 | "use gnulib module calloc-posix for portability"), \ | ||
127 | calloc (n, s)) | ||
128 | #endif | ||
129 | |||
130 | |||
131 | #if 0 | ||
132 | /* Assuming *OPTIONP is a comma separated list of elements of the form | ||
133 | "token" or "token=value", getsubopt parses the first of these elements. | ||
134 | If the first element refers to a "token" that is member of the given | ||
135 | NULL-terminated array of tokens: | ||
136 | - It replaces the comma with a NUL byte, updates *OPTIONP to point past | ||
137 | the first option and the comma, sets *VALUEP to the value of the | ||
138 | element (or NULL if it doesn't contain an "=" sign), | ||
139 | - It returns the index of the "token" in the given array of tokens. | ||
140 | Otherwise it returns -1, and *OPTIONP and *VALUEP are undefined. | ||
141 | For more details see the POSIX:2001 specification. | ||
142 | http://www.opengroup.org/susv3xsh/getsubopt.html */ | ||
143 | # if !1 | ||
144 | extern int getsubopt (char **optionp, char *const *tokens, char **valuep); | ||
145 | # endif | ||
146 | #elif defined GNULIB_POSIXCHECK | ||
147 | # undef getsubopt | ||
148 | # define getsubopt(o,t,v) \ | ||
149 | (GL_LINK_WARNING ("getsubopt is unportable - " \ | ||
150 | "use gnulib module getsubopt for portability"), \ | ||
151 | getsubopt (o, t, v)) | ||
152 | #endif | ||
153 | |||
154 | |||
155 | #if 0 | ||
156 | # if !1 | ||
157 | /* Create a unique temporary directory from TEMPLATE. | ||
158 | The last six characters of TEMPLATE must be "XXXXXX"; | ||
159 | they are replaced with a string that makes the directory name unique. | ||
160 | Returns TEMPLATE, or a null pointer if it cannot get a unique name. | ||
161 | The directory is created mode 700. */ | ||
162 | extern char * mkdtemp (char * /*template*/); | ||
163 | # endif | ||
164 | #elif defined GNULIB_POSIXCHECK | ||
165 | # undef mkdtemp | ||
166 | # define mkdtemp(t) \ | ||
167 | (GL_LINK_WARNING ("mkdtemp is unportable - " \ | ||
168 | "use gnulib module mkdtemp for portability"), \ | ||
169 | mkdtemp (t)) | ||
170 | #endif | ||
171 | |||
172 | |||
173 | #if 0 | ||
174 | # if 0 | ||
175 | /* Create a unique temporary file from TEMPLATE. | ||
176 | The last six characters of TEMPLATE must be "XXXXXX"; | ||
177 | they are replaced with a string that makes the file name unique. | ||
178 | The file is then created, ensuring it didn't exist before. | ||
179 | The file is created read-write (mask at least 0600 & ~umask), but it may be | ||
180 | world-readable and world-writable (mask 0666 & ~umask), depending on the | ||
181 | implementation. | ||
182 | Returns the open file descriptor if successful, otherwise -1 and errno | ||
183 | set. */ | ||
184 | # define mkstemp rpl_mkstemp | ||
185 | extern int mkstemp (char * /*template*/); | ||
186 | # else | ||
187 | /* On MacOS X 10.3, only <unistd.h> declares mkstemp. */ | ||
188 | # include <unistd.h> | ||
189 | # endif | ||
190 | #elif defined GNULIB_POSIXCHECK | ||
191 | # undef mkstemp | ||
192 | # define mkstemp(t) \ | ||
193 | (GL_LINK_WARNING ("mkstemp is unportable - " \ | ||
194 | "use gnulib module mkstemp for portability"), \ | ||
195 | mkstemp (t)) | ||
196 | #endif | ||
197 | |||
198 | |||
199 | #if 0 | ||
200 | # if 0 | ||
201 | # undef putenv | ||
202 | # define putenv rpl_putenv | ||
203 | extern int putenv (char *string); | ||
204 | # endif | ||
205 | #endif | ||
206 | |||
207 | |||
208 | #if 0 | ||
209 | # if !1 | ||
210 | /* Set NAME to VALUE in the environment. | ||
211 | If REPLACE is nonzero, overwrite an existing value. */ | ||
212 | extern int setenv (const char *name, const char *value, int replace); | ||
213 | # endif | ||
214 | #endif | ||
215 | |||
216 | |||
217 | #if 0 | ||
218 | # if 1 | ||
219 | # if 0 | ||
220 | /* On some systems, unsetenv() returns void. | ||
221 | This is the case for MacOS X 10.3, FreeBSD 4.8, NetBSD 1.6, OpenBSD 3.4. */ | ||
222 | # define unsetenv(name) ((unsetenv)(name), 0) | ||
223 | # endif | ||
224 | # else | ||
225 | /* Remove the variable NAME from the environment. */ | ||
226 | extern int unsetenv (const char *name); | ||
227 | # endif | ||
228 | #endif | ||
229 | |||
230 | |||
231 | #ifdef __cplusplus | ||
232 | } | ||
233 | #endif | ||
234 | |||
235 | #endif /* _GL_STDLIB_H */ | ||
236 | #endif /* _GL_STDLIB_H */ | ||
237 | #endif | ||
diff --git a/gl/string.h b/gl/string.h new file mode 100644 index 00000000..e5bcef55 --- /dev/null +++ b/gl/string.h | |||
@@ -0,0 +1,598 @@ | |||
1 | /* DO NOT EDIT! GENERATED AUTOMATICALLY! */ | ||
2 | /* A GNU-like <string.h>. | ||
3 | |||
4 | Copyright (C) 1995-1996, 2001-2008 Free Software Foundation, Inc. | ||
5 | |||
6 | This program is free software; you can redistribute it and/or modify | ||
7 | it under the terms of the GNU General Public License as published by | ||
8 | the Free Software Foundation; either version 3, or (at your option) | ||
9 | any later version. | ||
10 | |||
11 | This program is distributed in the hope that it will be useful, | ||
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
14 | GNU General Public License for more details. | ||
15 | |||
16 | You should have received a copy of the GNU General Public License | ||
17 | along with this program; if not, write to the Free Software Foundation, | ||
18 | Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ | ||
19 | |||
20 | #ifndef _GL_STRING_H | ||
21 | |||
22 | /* The include_next requires a split double-inclusion guard. */ | ||
23 | #include_next <string.h> | ||
24 | |||
25 | #ifndef _GL_STRING_H | ||
26 | #define _GL_STRING_H | ||
27 | |||
28 | |||
29 | #ifndef __attribute__ | ||
30 | /* This feature is available in gcc versions 2.5 and later. */ | ||
31 | # if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) | ||
32 | # define __attribute__(Spec) /* empty */ | ||
33 | # endif | ||
34 | /* The attribute __pure__ was added in gcc 2.96. */ | ||
35 | # if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 96) | ||
36 | # define __pure__ /* empty */ | ||
37 | # endif | ||
38 | #endif | ||
39 | |||
40 | |||
41 | /* The definition of GL_LINK_WARNING is copied here. */ | ||
42 | /* GL_LINK_WARNING("literal string") arranges to emit the literal string as | ||
43 | a linker warning on most glibc systems. | ||
44 | We use a linker warning rather than a preprocessor warning, because | ||
45 | #warning cannot be used inside macros. */ | ||
46 | #ifndef GL_LINK_WARNING | ||
47 | /* This works on platforms with GNU ld and ELF object format. | ||
48 | Testing __GLIBC__ is sufficient for asserting that GNU ld is in use. | ||
49 | Testing __ELF__ guarantees the ELF object format. | ||
50 | Testing __GNUC__ is necessary for the compound expression syntax. */ | ||
51 | # if defined __GLIBC__ && defined __ELF__ && defined __GNUC__ | ||
52 | # define GL_LINK_WARNING(message) \ | ||
53 | GL_LINK_WARNING1 (__FILE__, __LINE__, message) | ||
54 | # define GL_LINK_WARNING1(file, line, message) \ | ||
55 | GL_LINK_WARNING2 (file, line, message) /* macroexpand file and line */ | ||
56 | # define GL_LINK_WARNING2(file, line, message) \ | ||
57 | GL_LINK_WARNING3 (file ":" #line ": warning: " message) | ||
58 | # define GL_LINK_WARNING3(message) \ | ||
59 | ({ static const char warning[sizeof (message)] \ | ||
60 | __attribute__ ((__unused__, \ | ||
61 | __section__ (".gnu.warning"), \ | ||
62 | __aligned__ (1))) \ | ||
63 | = message "\n"; \ | ||
64 | (void)0; \ | ||
65 | }) | ||
66 | # else | ||
67 | # define GL_LINK_WARNING(message) ((void) 0) | ||
68 | # endif | ||
69 | #endif | ||
70 | |||
71 | |||
72 | #ifdef __cplusplus | ||
73 | extern "C" { | ||
74 | #endif | ||
75 | |||
76 | |||
77 | /* Return the first occurrence of NEEDLE in HAYSTACK. */ | ||
78 | #if 0 | ||
79 | # if 0 | ||
80 | # define memmem rpl_memmem | ||
81 | # endif | ||
82 | # if ! 1 || 0 | ||
83 | extern void *memmem (void const *__haystack, size_t __haystack_len, | ||
84 | void const *__needle, size_t __needle_len) | ||
85 | __attribute__ ((__pure__)); | ||
86 | # endif | ||
87 | #elif defined GNULIB_POSIXCHECK | ||
88 | # undef memmem | ||
89 | # define memmem(a,al,b,bl) \ | ||
90 | (GL_LINK_WARNING ("memmem is unportable and often quadratic - " \ | ||
91 | "use gnulib module memmem-simple for portability, " \ | ||
92 | "and module memmem for speed" ), \ | ||
93 | memmem (a, al, b, bl)) | ||
94 | #endif | ||
95 | |||
96 | /* Copy N bytes of SRC to DEST, return pointer to bytes after the | ||
97 | last written byte. */ | ||
98 | #if 0 | ||
99 | # if ! 1 | ||
100 | extern void *mempcpy (void *restrict __dest, void const *restrict __src, | ||
101 | size_t __n); | ||
102 | # endif | ||
103 | #elif defined GNULIB_POSIXCHECK | ||
104 | # undef mempcpy | ||
105 | # define mempcpy(a,b,n) \ | ||
106 | (GL_LINK_WARNING ("mempcpy is unportable - " \ | ||
107 | "use gnulib module mempcpy for portability"), \ | ||
108 | mempcpy (a, b, n)) | ||
109 | #endif | ||
110 | |||
111 | /* Search backwards through a block for a byte (specified as an int). */ | ||
112 | #if 0 | ||
113 | # if ! 1 | ||
114 | extern void *memrchr (void const *, int, size_t) | ||
115 | __attribute__ ((__pure__)); | ||
116 | # endif | ||
117 | #elif defined GNULIB_POSIXCHECK | ||
118 | # undef memrchr | ||
119 | # define memrchr(a,b,c) \ | ||
120 | (GL_LINK_WARNING ("memrchr is unportable - " \ | ||
121 | "use gnulib module memrchr for portability"), \ | ||
122 | memrchr (a, b, c)) | ||
123 | #endif | ||
124 | |||
125 | /* Copy SRC to DST, returning the address of the terminating '\0' in DST. */ | ||
126 | #if 0 | ||
127 | # if ! 1 | ||
128 | extern char *stpcpy (char *restrict __dst, char const *restrict __src); | ||
129 | # endif | ||
130 | #elif defined GNULIB_POSIXCHECK | ||
131 | # undef stpcpy | ||
132 | # define stpcpy(a,b) \ | ||
133 | (GL_LINK_WARNING ("stpcpy is unportable - " \ | ||
134 | "use gnulib module stpcpy for portability"), \ | ||
135 | stpcpy (a, b)) | ||
136 | #endif | ||
137 | |||
138 | /* Copy no more than N bytes of SRC to DST, returning a pointer past the | ||
139 | last non-NUL byte written into DST. */ | ||
140 | #if 0 | ||
141 | # if ! 1 | ||
142 | # define stpncpy gnu_stpncpy | ||
143 | extern char *stpncpy (char *restrict __dst, char const *restrict __src, | ||
144 | size_t __n); | ||
145 | # endif | ||
146 | #elif defined GNULIB_POSIXCHECK | ||
147 | # undef stpncpy | ||
148 | # define stpncpy(a,b,n) \ | ||
149 | (GL_LINK_WARNING ("stpncpy is unportable - " \ | ||
150 | "use gnulib module stpncpy for portability"), \ | ||
151 | stpncpy (a, b, n)) | ||
152 | #endif | ||
153 | |||
154 | #if defined GNULIB_POSIXCHECK | ||
155 | /* strchr() does not work with multibyte strings if the locale encoding is | ||
156 | GB18030 and the character to be searched is a digit. */ | ||
157 | # undef strchr | ||
158 | # define strchr(s,c) \ | ||
159 | (GL_LINK_WARNING ("strchr cannot work correctly on character strings " \ | ||
160 | "in some multibyte locales - " \ | ||
161 | "use mbschr if you care about internationalization"), \ | ||
162 | strchr (s, c)) | ||
163 | #endif | ||
164 | |||
165 | /* Find the first occurrence of C in S or the final NUL byte. */ | ||
166 | #if 0 | ||
167 | # if ! 1 | ||
168 | extern char *strchrnul (char const *__s, int __c_in) | ||
169 | __attribute__ ((__pure__)); | ||
170 | # endif | ||
171 | #elif defined GNULIB_POSIXCHECK | ||
172 | # undef strchrnul | ||
173 | # define strchrnul(a,b) \ | ||
174 | (GL_LINK_WARNING ("strchrnul is unportable - " \ | ||
175 | "use gnulib module strchrnul for portability"), \ | ||
176 | strchrnul (a, b)) | ||
177 | #endif | ||
178 | |||
179 | /* Duplicate S, returning an identical malloc'd string. */ | ||
180 | #if 1 | ||
181 | # if ! 1 && ! defined strdup | ||
182 | extern char *strdup (char const *__s); | ||
183 | # endif | ||
184 | #elif defined GNULIB_POSIXCHECK | ||
185 | # undef strdup | ||
186 | # define strdup(a) \ | ||
187 | (GL_LINK_WARNING ("strdup is unportable - " \ | ||
188 | "use gnulib module strdup for portability"), \ | ||
189 | strdup (a)) | ||
190 | #endif | ||
191 | |||
192 | /* Return a newly allocated copy of at most N bytes of STRING. */ | ||
193 | #if 1 | ||
194 | # if ! 1 | ||
195 | # undef strndup | ||
196 | # define strndup rpl_strndup | ||
197 | # endif | ||
198 | # if ! 1 || ! 1 | ||
199 | extern char *strndup (char const *__string, size_t __n); | ||
200 | # endif | ||
201 | #elif defined GNULIB_POSIXCHECK | ||
202 | # undef strndup | ||
203 | # define strndup(a,n) \ | ||
204 | (GL_LINK_WARNING ("strndup is unportable - " \ | ||
205 | "use gnulib module strndup for portability"), \ | ||
206 | strndup (a, n)) | ||
207 | #endif | ||
208 | |||
209 | /* Find the length (number of bytes) of STRING, but scan at most | ||
210 | MAXLEN bytes. If no '\0' terminator is found in that many bytes, | ||
211 | return MAXLEN. */ | ||
212 | #if 1 | ||
213 | # if ! 1 | ||
214 | extern size_t strnlen (char const *__string, size_t __maxlen) | ||
215 | __attribute__ ((__pure__)); | ||
216 | # endif | ||
217 | #elif defined GNULIB_POSIXCHECK | ||
218 | # undef strnlen | ||
219 | # define strnlen(a,n) \ | ||
220 | (GL_LINK_WARNING ("strnlen is unportable - " \ | ||
221 | "use gnulib module strnlen for portability"), \ | ||
222 | strnlen (a, n)) | ||
223 | #endif | ||
224 | |||
225 | #if defined GNULIB_POSIXCHECK | ||
226 | /* strcspn() assumes the second argument is a list of single-byte characters. | ||
227 | Even in this simple case, it does not work with multibyte strings if the | ||
228 | locale encoding is GB18030 and one of the characters to be searched is a | ||
229 | digit. */ | ||
230 | # undef strcspn | ||
231 | # define strcspn(s,a) \ | ||
232 | (GL_LINK_WARNING ("strcspn cannot work correctly on character strings " \ | ||
233 | "in multibyte locales - " \ | ||
234 | "use mbscspn if you care about internationalization"), \ | ||
235 | strcspn (s, a)) | ||
236 | #endif | ||
237 | |||
238 | /* Find the first occurrence in S of any character in ACCEPT. */ | ||
239 | #if 0 | ||
240 | # if ! 1 | ||
241 | extern char *strpbrk (char const *__s, char const *__accept) | ||
242 | __attribute__ ((__pure__)); | ||
243 | # endif | ||
244 | # if defined GNULIB_POSIXCHECK | ||
245 | /* strpbrk() assumes the second argument is a list of single-byte characters. | ||
246 | Even in this simple case, it does not work with multibyte strings if the | ||
247 | locale encoding is GB18030 and one of the characters to be searched is a | ||
248 | digit. */ | ||
249 | # undef strpbrk | ||
250 | # define strpbrk(s,a) \ | ||
251 | (GL_LINK_WARNING ("strpbrk cannot work correctly on character strings " \ | ||
252 | "in multibyte locales - " \ | ||
253 | "use mbspbrk if you care about internationalization"), \ | ||
254 | strpbrk (s, a)) | ||
255 | # endif | ||
256 | #elif defined GNULIB_POSIXCHECK | ||
257 | # undef strpbrk | ||
258 | # define strpbrk(s,a) \ | ||
259 | (GL_LINK_WARNING ("strpbrk is unportable - " \ | ||
260 | "use gnulib module strpbrk for portability"), \ | ||
261 | strpbrk (s, a)) | ||
262 | #endif | ||
263 | |||
264 | #if defined GNULIB_POSIXCHECK | ||
265 | /* strspn() assumes the second argument is a list of single-byte characters. | ||
266 | Even in this simple case, it cannot work with multibyte strings. */ | ||
267 | # undef strspn | ||
268 | # define strspn(s,a) \ | ||
269 | (GL_LINK_WARNING ("strspn cannot work correctly on character strings " \ | ||
270 | "in multibyte locales - " \ | ||
271 | "use mbsspn if you care about internationalization"), \ | ||
272 | strspn (s, a)) | ||
273 | #endif | ||
274 | |||
275 | #if defined GNULIB_POSIXCHECK | ||
276 | /* strrchr() does not work with multibyte strings if the locale encoding is | ||
277 | GB18030 and the character to be searched is a digit. */ | ||
278 | # undef strrchr | ||
279 | # define strrchr(s,c) \ | ||
280 | (GL_LINK_WARNING ("strrchr cannot work correctly on character strings " \ | ||
281 | "in some multibyte locales - " \ | ||
282 | "use mbsrchr if you care about internationalization"), \ | ||
283 | strrchr (s, c)) | ||
284 | #endif | ||
285 | |||
286 | /* Search the next delimiter (char listed in DELIM) starting at *STRINGP. | ||
287 | If one is found, overwrite it with a NUL, and advance *STRINGP | ||
288 | to point to the next char after it. Otherwise, set *STRINGP to NULL. | ||
289 | If *STRINGP was already NULL, nothing happens. | ||
290 | Return the old value of *STRINGP. | ||
291 | |||
292 | This is a variant of strtok() that is multithread-safe and supports | ||
293 | empty fields. | ||
294 | |||
295 | Caveat: It modifies the original string. | ||
296 | Caveat: These functions cannot be used on constant strings. | ||
297 | Caveat: The identity of the delimiting character is lost. | ||
298 | Caveat: It doesn't work with multibyte strings unless all of the delimiter | ||
299 | characters are ASCII characters < 0x30. | ||
300 | |||
301 | See also strtok_r(). */ | ||
302 | #if 0 | ||
303 | # if ! 1 | ||
304 | extern char *strsep (char **restrict __stringp, char const *restrict __delim); | ||
305 | # endif | ||
306 | # if defined GNULIB_POSIXCHECK | ||
307 | # undef strsep | ||
308 | # define strsep(s,d) \ | ||
309 | (GL_LINK_WARNING ("strsep cannot work correctly on character strings " \ | ||
310 | "in multibyte locales - " \ | ||
311 | "use mbssep if you care about internationalization"), \ | ||
312 | strsep (s, d)) | ||
313 | # endif | ||
314 | #elif defined GNULIB_POSIXCHECK | ||
315 | # undef strsep | ||
316 | # define strsep(s,d) \ | ||
317 | (GL_LINK_WARNING ("strsep is unportable - " \ | ||
318 | "use gnulib module strsep for portability"), \ | ||
319 | strsep (s, d)) | ||
320 | #endif | ||
321 | |||
322 | #if 0 | ||
323 | # if 0 | ||
324 | # define strstr rpl_strstr | ||
325 | char *strstr (const char *haystack, const char *needle) | ||
326 | __attribute__ ((__pure__)); | ||
327 | # endif | ||
328 | #elif defined GNULIB_POSIXCHECK | ||
329 | /* strstr() does not work with multibyte strings if the locale encoding is | ||
330 | different from UTF-8: | ||
331 | POSIX says that it operates on "strings", and "string" in POSIX is defined | ||
332 | as a sequence of bytes, not of characters. */ | ||
333 | # undef strstr | ||
334 | # define strstr(a,b) \ | ||
335 | (GL_LINK_WARNING ("strstr is quadratic on many systems, and cannot " \ | ||
336 | "work correctly on character strings in most " \ | ||
337 | "multibyte locales - " \ | ||
338 | "use mbsstr if you care about internationalization, " \ | ||
339 | "or use strstr if you care about speed"), \ | ||
340 | strstr (a, b)) | ||
341 | #endif | ||
342 | |||
343 | /* Find the first occurrence of NEEDLE in HAYSTACK, using case-insensitive | ||
344 | comparison. */ | ||
345 | #if 0 | ||
346 | # if 0 | ||
347 | # define strcasestr rpl_strcasestr | ||
348 | # endif | ||
349 | # if ! 1 || 0 | ||
350 | extern char *strcasestr (const char *haystack, const char *needle) | ||
351 | __attribute__ ((__pure__)); | ||
352 | # endif | ||
353 | #elif defined GNULIB_POSIXCHECK | ||
354 | /* strcasestr() does not work with multibyte strings: | ||
355 | It is a glibc extension, and glibc implements it only for unibyte | ||
356 | locales. */ | ||
357 | # undef strcasestr | ||
358 | # define strcasestr(a,b) \ | ||
359 | (GL_LINK_WARNING ("strcasestr does work correctly on character strings " \ | ||
360 | "in multibyte locales - " \ | ||
361 | "use mbscasestr if you care about " \ | ||
362 | "internationalization, or use c-strcasestr if you want " \ | ||
363 | "a locale independent function"), \ | ||
364 | strcasestr (a, b)) | ||
365 | #endif | ||
366 | |||
367 | /* Parse S into tokens separated by characters in DELIM. | ||
368 | If S is NULL, the saved pointer in SAVE_PTR is used as | ||
369 | the next starting point. For example: | ||
370 | char s[] = "-abc-=-def"; | ||
371 | char *sp; | ||
372 | x = strtok_r(s, "-", &sp); // x = "abc", sp = "=-def" | ||
373 | x = strtok_r(NULL, "-=", &sp); // x = "def", sp = NULL | ||
374 | x = strtok_r(NULL, "=", &sp); // x = NULL | ||
375 | // s = "abc\0-def\0" | ||
376 | |||
377 | This is a variant of strtok() that is multithread-safe. | ||
378 | |||
379 | For the POSIX documentation for this function, see: | ||
380 | http://www.opengroup.org/susv3xsh/strtok.html | ||
381 | |||
382 | Caveat: It modifies the original string. | ||
383 | Caveat: These functions cannot be used on constant strings. | ||
384 | Caveat: The identity of the delimiting character is lost. | ||
385 | Caveat: It doesn't work with multibyte strings unless all of the delimiter | ||
386 | characters are ASCII characters < 0x30. | ||
387 | |||
388 | See also strsep(). */ | ||
389 | #if 0 | ||
390 | # if ! 1 | ||
391 | extern char *strtok_r (char *restrict s, char const *restrict delim, | ||
392 | char **restrict save_ptr); | ||
393 | # endif | ||
394 | # if defined GNULIB_POSIXCHECK | ||
395 | # undef strtok_r | ||
396 | # define strtok_r(s,d,p) \ | ||
397 | (GL_LINK_WARNING ("strtok_r cannot work correctly on character strings " \ | ||
398 | "in multibyte locales - " \ | ||
399 | "use mbstok_r if you care about internationalization"), \ | ||
400 | strtok_r (s, d, p)) | ||
401 | # endif | ||
402 | #elif defined GNULIB_POSIXCHECK | ||
403 | # undef strtok_r | ||
404 | # define strtok_r(s,d,p) \ | ||
405 | (GL_LINK_WARNING ("strtok_r is unportable - " \ | ||
406 | "use gnulib module strtok_r for portability"), \ | ||
407 | strtok_r (s, d, p)) | ||
408 | #endif | ||
409 | |||
410 | |||
411 | /* The following functions are not specified by POSIX. They are gnulib | ||
412 | extensions. */ | ||
413 | |||
414 | #if 0 | ||
415 | /* Return the number of multibyte characters in the character string STRING. | ||
416 | This considers multibyte characters, unlike strlen, which counts bytes. */ | ||
417 | extern size_t mbslen (const char *string); | ||
418 | #endif | ||
419 | |||
420 | #if 0 | ||
421 | /* Return the number of multibyte characters in the character string starting | ||
422 | at STRING and ending at STRING + LEN. */ | ||
423 | extern size_t mbsnlen (const char *string, size_t len); | ||
424 | #endif | ||
425 | |||
426 | #if 0 | ||
427 | /* Locate the first single-byte character C in the character string STRING, | ||
428 | and return a pointer to it. Return NULL if C is not found in STRING. | ||
429 | Unlike strchr(), this function works correctly in multibyte locales with | ||
430 | encodings such as GB18030. */ | ||
431 | # define mbschr rpl_mbschr /* avoid collision with HP-UX function */ | ||
432 | extern char * mbschr (const char *string, int c); | ||
433 | #endif | ||
434 | |||
435 | #if 0 | ||
436 | /* Locate the last single-byte character C in the character string STRING, | ||
437 | and return a pointer to it. Return NULL if C is not found in STRING. | ||
438 | Unlike strrchr(), this function works correctly in multibyte locales with | ||
439 | encodings such as GB18030. */ | ||
440 | # define mbsrchr rpl_mbsrchr /* avoid collision with HP-UX function */ | ||
441 | extern char * mbsrchr (const char *string, int c); | ||
442 | #endif | ||
443 | |||
444 | #if 0 | ||
445 | /* Find the first occurrence of the character string NEEDLE in the character | ||
446 | string HAYSTACK. Return NULL if NEEDLE is not found in HAYSTACK. | ||
447 | Unlike strstr(), this function works correctly in multibyte locales with | ||
448 | encodings different from UTF-8. */ | ||
449 | extern char * mbsstr (const char *haystack, const char *needle); | ||
450 | #endif | ||
451 | |||
452 | #if 0 | ||
453 | /* Compare the character strings S1 and S2, ignoring case, returning less than, | ||
454 | equal to or greater than zero if S1 is lexicographically less than, equal to | ||
455 | or greater than S2. | ||
456 | Note: This function may, in multibyte locales, return 0 for strings of | ||
457 | different lengths! | ||
458 | Unlike strcasecmp(), this function works correctly in multibyte locales. */ | ||
459 | extern int mbscasecmp (const char *s1, const char *s2); | ||
460 | #endif | ||
461 | |||
462 | #if 0 | ||
463 | /* Compare the initial segment of the character string S1 consisting of at most | ||
464 | N characters with the initial segment of the character string S2 consisting | ||
465 | of at most N characters, ignoring case, returning less than, equal to or | ||
466 | greater than zero if the initial segment of S1 is lexicographically less | ||
467 | than, equal to or greater than the initial segment of S2. | ||
468 | Note: This function may, in multibyte locales, return 0 for initial segments | ||
469 | of different lengths! | ||
470 | Unlike strncasecmp(), this function works correctly in multibyte locales. | ||
471 | But beware that N is not a byte count but a character count! */ | ||
472 | extern int mbsncasecmp (const char *s1, const char *s2, size_t n); | ||
473 | #endif | ||
474 | |||
475 | #if 0 | ||
476 | /* Compare the initial segment of the character string STRING consisting of | ||
477 | at most mbslen (PREFIX) characters with the character string PREFIX, | ||
478 | ignoring case, returning less than, equal to or greater than zero if this | ||
479 | initial segment is lexicographically less than, equal to or greater than | ||
480 | PREFIX. | ||
481 | Note: This function may, in multibyte locales, return 0 if STRING is of | ||
482 | smaller length than PREFIX! | ||
483 | Unlike strncasecmp(), this function works correctly in multibyte | ||
484 | locales. */ | ||
485 | extern char * mbspcasecmp (const char *string, const char *prefix); | ||
486 | #endif | ||
487 | |||
488 | #if 0 | ||
489 | /* Find the first occurrence of the character string NEEDLE in the character | ||
490 | string HAYSTACK, using case-insensitive comparison. | ||
491 | Note: This function may, in multibyte locales, return success even if | ||
492 | strlen (haystack) < strlen (needle) ! | ||
493 | Unlike strcasestr(), this function works correctly in multibyte locales. */ | ||
494 | extern char * mbscasestr (const char *haystack, const char *needle); | ||
495 | #endif | ||
496 | |||
497 | #if 0 | ||
498 | /* Find the first occurrence in the character string STRING of any character | ||
499 | in the character string ACCEPT. Return the number of bytes from the | ||
500 | beginning of the string to this occurrence, or to the end of the string | ||
501 | if none exists. | ||
502 | Unlike strcspn(), this function works correctly in multibyte locales. */ | ||
503 | extern size_t mbscspn (const char *string, const char *accept); | ||
504 | #endif | ||
505 | |||
506 | #if 0 | ||
507 | /* Find the first occurrence in the character string STRING of any character | ||
508 | in the character string ACCEPT. Return the pointer to it, or NULL if none | ||
509 | exists. | ||
510 | Unlike strpbrk(), this function works correctly in multibyte locales. */ | ||
511 | # define mbspbrk rpl_mbspbrk /* avoid collision with HP-UX function */ | ||
512 | extern char * mbspbrk (const char *string, const char *accept); | ||
513 | #endif | ||
514 | |||
515 | #if 0 | ||
516 | /* Find the first occurrence in the character string STRING of any character | ||
517 | not in the character string REJECT. Return the number of bytes from the | ||
518 | beginning of the string to this occurrence, or to the end of the string | ||
519 | if none exists. | ||
520 | Unlike strspn(), this function works correctly in multibyte locales. */ | ||
521 | extern size_t mbsspn (const char *string, const char *reject); | ||
522 | #endif | ||
523 | |||
524 | #if 0 | ||
525 | /* Search the next delimiter (multibyte character listed in the character | ||
526 | string DELIM) starting at the character string *STRINGP. | ||
527 | If one is found, overwrite it with a NUL, and advance *STRINGP to point | ||
528 | to the next multibyte character after it. Otherwise, set *STRINGP to NULL. | ||
529 | If *STRINGP was already NULL, nothing happens. | ||
530 | Return the old value of *STRINGP. | ||
531 | |||
532 | This is a variant of mbstok_r() that supports empty fields. | ||
533 | |||
534 | Caveat: It modifies the original string. | ||
535 | Caveat: These functions cannot be used on constant strings. | ||
536 | Caveat: The identity of the delimiting character is lost. | ||
537 | |||
538 | See also mbstok_r(). */ | ||
539 | extern char * mbssep (char **stringp, const char *delim); | ||
540 | #endif | ||
541 | |||
542 | #if 0 | ||
543 | /* Parse the character string STRING into tokens separated by characters in | ||
544 | the character string DELIM. | ||
545 | If STRING is NULL, the saved pointer in SAVE_PTR is used as | ||
546 | the next starting point. For example: | ||
547 | char s[] = "-abc-=-def"; | ||
548 | char *sp; | ||
549 | x = mbstok_r(s, "-", &sp); // x = "abc", sp = "=-def" | ||
550 | x = mbstok_r(NULL, "-=", &sp); // x = "def", sp = NULL | ||
551 | x = mbstok_r(NULL, "=", &sp); // x = NULL | ||
552 | // s = "abc\0-def\0" | ||
553 | |||
554 | Caveat: It modifies the original string. | ||
555 | Caveat: These functions cannot be used on constant strings. | ||
556 | Caveat: The identity of the delimiting character is lost. | ||
557 | |||
558 | See also mbssep(). */ | ||
559 | extern char * mbstok_r (char *string, const char *delim, char **save_ptr); | ||
560 | #endif | ||
561 | |||
562 | /* Map any int, typically from errno, into an error message. */ | ||
563 | #if 1 | ||
564 | # if 0 | ||
565 | # undef strerror | ||
566 | # define strerror rpl_strerror | ||
567 | extern char *strerror (int); | ||
568 | # endif | ||
569 | #elif defined GNULIB_POSIXCHECK | ||
570 | # undef strerror | ||
571 | # define strerror(e) \ | ||
572 | (GL_LINK_WARNING ("strerror is unportable - " \ | ||
573 | "use gnulib module strerror to guarantee non-NULL result"), \ | ||
574 | strerror (e)) | ||
575 | #endif | ||
576 | |||
577 | #if 0 | ||
578 | # if 0 | ||
579 | # define strsignal rpl_strsignal | ||
580 | # endif | ||
581 | # if ! 1 || 0 | ||
582 | extern char *strsignal (int __sig); | ||
583 | # endif | ||
584 | #elif defined GNULIB_POSIXCHECK | ||
585 | # undef strsignal | ||
586 | # define strsignal(a) \ | ||
587 | (GL_LINK_WARNING ("strsignal is unportable - " \ | ||
588 | "use gnulib module strsignal for portability"), \ | ||
589 | strsignal (a)) | ||
590 | #endif | ||
591 | |||
592 | |||
593 | #ifdef __cplusplus | ||
594 | } | ||
595 | #endif | ||
596 | |||
597 | #endif /* _GL_STRING_H */ | ||
598 | #endif /* _GL_STRING_H */ | ||
diff --git a/gl/unistd.h b/gl/unistd.h new file mode 100644 index 00000000..e72a5d9a --- /dev/null +++ b/gl/unistd.h | |||
@@ -0,0 +1,321 @@ | |||
1 | /* DO NOT EDIT! GENERATED AUTOMATICALLY! */ | ||
2 | /* Substitute for and wrapper around <unistd.h>. | ||
3 | Copyright (C) 2004-2007 Free Software Foundation, Inc. | ||
4 | |||
5 | This program is free software; you can redistribute it and/or modify | ||
6 | it under the terms of the GNU General Public License as published by | ||
7 | the Free Software Foundation; either version 3, or (at your option) | ||
8 | any later version. | ||
9 | |||
10 | This program is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
13 | GNU General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU General Public License | ||
16 | along with this program; if not, write to the Free Software Foundation, | ||
17 | Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ | ||
18 | |||
19 | #ifndef _GL_UNISTD_H | ||
20 | |||
21 | /* The include_next requires a split double-inclusion guard. */ | ||
22 | #if 1 | ||
23 | # include_next <unistd.h> | ||
24 | #endif | ||
25 | |||
26 | #ifndef _GL_UNISTD_H | ||
27 | #define _GL_UNISTD_H | ||
28 | |||
29 | /* mingw doesn't define the SEEK_* macros in <unistd.h>. */ | ||
30 | #if !(defined SEEK_CUR && defined SEEK_END && defined SEEK_SET) | ||
31 | # include <stdio.h> | ||
32 | #endif | ||
33 | |||
34 | /* mingw fails to declare _exit in <unistd.h>. */ | ||
35 | #include <stdlib.h> | ||
36 | |||
37 | /* The definition of GL_LINK_WARNING is copied here. */ | ||
38 | |||
39 | |||
40 | /* Declare overridden functions. */ | ||
41 | |||
42 | #ifdef __cplusplus | ||
43 | extern "C" { | ||
44 | #endif | ||
45 | |||
46 | |||
47 | #if 0 | ||
48 | # if 0 | ||
49 | # ifndef REPLACE_CHOWN | ||
50 | # define REPLACE_CHOWN 1 | ||
51 | # endif | ||
52 | # if REPLACE_CHOWN | ||
53 | /* Change the owner of FILE to UID (if UID is not -1) and the group of FILE | ||
54 | to GID (if GID is not -1). Follow symbolic links. | ||
55 | Return 0 if successful, otherwise -1 and errno set. | ||
56 | See the POSIX:2001 specification | ||
57 | <http://www.opengroup.org/susv3xsh/chown.html>. */ | ||
58 | # define chown rpl_chown | ||
59 | extern int chown (const char *file, uid_t uid, gid_t gid); | ||
60 | # endif | ||
61 | # endif | ||
62 | #elif defined GNULIB_POSIXCHECK | ||
63 | # undef chown | ||
64 | # define chown(f,u,g) \ | ||
65 | (GL_LINK_WARNING ("chown fails to follow symlinks on some systems and " \ | ||
66 | "doesn't treat a uid or gid of -1 on some systems - " \ | ||
67 | "use gnulib module chown for portability"), \ | ||
68 | chown (f, u, g)) | ||
69 | #endif | ||
70 | |||
71 | |||
72 | #if 0 | ||
73 | # if !1 | ||
74 | /* Copy the file descriptor OLDFD into file descriptor NEWFD. Do nothing if | ||
75 | NEWFD = OLDFD, otherwise close NEWFD first if it is open. | ||
76 | Return 0 if successful, otherwise -1 and errno set. | ||
77 | See the POSIX:2001 specification | ||
78 | <http://www.opengroup.org/susv3xsh/dup2.html>. */ | ||
79 | extern int dup2 (int oldfd, int newfd); | ||
80 | # endif | ||
81 | #elif defined GNULIB_POSIXCHECK | ||
82 | # undef dup2 | ||
83 | # define dup2(o,n) \ | ||
84 | (GL_LINK_WARNING ("dup2 is unportable - " \ | ||
85 | "use gnulib module dup2 for portability"), \ | ||
86 | dup2 (o, n)) | ||
87 | #endif | ||
88 | |||
89 | |||
90 | #if 0 | ||
91 | # if 0 | ||
92 | |||
93 | /* Change the process' current working directory to the directory on which | ||
94 | the given file descriptor is open. | ||
95 | Return 0 if successful, otherwise -1 and errno set. | ||
96 | See the POSIX:2001 specification | ||
97 | <http://www.opengroup.org/susv3xsh/fchdir.html>. */ | ||
98 | extern int fchdir (int /*fd*/); | ||
99 | |||
100 | # define close rpl_close | ||
101 | extern int close (int); | ||
102 | # define dup rpl_dup | ||
103 | extern int dup (int); | ||
104 | # define dup2 rpl_dup2 | ||
105 | extern int dup2 (int, int); | ||
106 | |||
107 | # endif | ||
108 | #elif defined GNULIB_POSIXCHECK | ||
109 | # undef fchdir | ||
110 | # define fchdir(f) \ | ||
111 | (GL_LINK_WARNING ("fchdir is unportable - " \ | ||
112 | "use gnulib module fchdir for portability"), \ | ||
113 | fchdir (f)) | ||
114 | #endif | ||
115 | |||
116 | |||
117 | #if 0 | ||
118 | # if !1 | ||
119 | /* Change the size of the file to which FD is opened to become equal to LENGTH. | ||
120 | Return 0 if successful, otherwise -1 and errno set. | ||
121 | See the POSIX:2001 specification | ||
122 | <http://www.opengroup.org/susv3xsh/ftruncate.html>. */ | ||
123 | extern int ftruncate (int fd, off_t length); | ||
124 | # endif | ||
125 | #elif defined GNULIB_POSIXCHECK | ||
126 | # undef ftruncate | ||
127 | # define ftruncate(f,l) \ | ||
128 | (GL_LINK_WARNING ("ftruncate is unportable - " \ | ||
129 | "use gnulib module ftruncate for portability"), \ | ||
130 | ftruncate (f, l)) | ||
131 | #endif | ||
132 | |||
133 | |||
134 | #if 0 | ||
135 | /* Include the headers that might declare getcwd so that they will not | ||
136 | cause confusion if included after this file. */ | ||
137 | # include <stdlib.h> | ||
138 | # if 0 | ||
139 | /* Get the name of the current working directory, and put it in SIZE bytes | ||
140 | of BUF. | ||
141 | Return BUF if successful, or NULL if the directory couldn't be determined | ||
142 | or SIZE was too small. | ||
143 | See the POSIX:2001 specification | ||
144 | <http://www.opengroup.org/susv3xsh/getcwd.html>. | ||
145 | Additionally, the gnulib module 'getcwd' guarantees the following GNU | ||
146 | extension: If BUF is NULL, an array is allocated with 'malloc'; the array | ||
147 | is SIZE bytes long, unless SIZE == 0, in which case it is as big as | ||
148 | necessary. */ | ||
149 | # define getcwd rpl_getcwd | ||
150 | extern char * getcwd (char *buf, size_t size); | ||
151 | # endif | ||
152 | #elif defined GNULIB_POSIXCHECK | ||
153 | # undef getcwd | ||
154 | # define getcwd(b,s) \ | ||
155 | (GL_LINK_WARNING ("getcwd is unportable - " \ | ||
156 | "use gnulib module getcwd for portability"), \ | ||
157 | getcwd (b, s)) | ||
158 | #endif | ||
159 | |||
160 | |||
161 | #if 0 | ||
162 | /* Copies the user's login name to NAME. | ||
163 | The array pointed to by NAME has room for SIZE bytes. | ||
164 | |||
165 | Returns 0 if successful. Upon error, an error number is returned, or -1 in | ||
166 | the case that the login name cannot be found but no specific error is | ||
167 | provided (this case is hopefully rare but is left open by the POSIX spec). | ||
168 | |||
169 | See <http://www.opengroup.org/susv3xsh/getlogin.html>. | ||
170 | */ | ||
171 | # if !1 | ||
172 | # include <stddef.h> | ||
173 | extern int getlogin_r (char *name, size_t size); | ||
174 | # endif | ||
175 | #elif defined GNULIB_POSIXCHECK | ||
176 | # undef getlogin_r | ||
177 | # define getlogin_r(n,s) \ | ||
178 | (GL_LINK_WARNING ("getlogin_r is unportable - " \ | ||
179 | "use gnulib module getlogin_r for portability"), \ | ||
180 | getlogin_r (n, s)) | ||
181 | #endif | ||
182 | |||
183 | |||
184 | #if 0 | ||
185 | # if 0 | ||
186 | # define getpagesize rpl_getpagesize | ||
187 | extern int getpagesize (void); | ||
188 | # elif !1 | ||
189 | /* This is for POSIX systems. */ | ||
190 | # if !defined getpagesize && defined _SC_PAGESIZE | ||
191 | # if ! (defined __VMS && __VMS_VER < 70000000) | ||
192 | # define getpagesize() sysconf (_SC_PAGESIZE) | ||
193 | # endif | ||
194 | # endif | ||
195 | /* This is for older VMS. */ | ||
196 | # if !defined getpagesize && defined __VMS | ||
197 | # ifdef __ALPHA | ||
198 | # define getpagesize() 8192 | ||
199 | # else | ||
200 | # define getpagesize() 512 | ||
201 | # endif | ||
202 | # endif | ||
203 | /* This is for BeOS. */ | ||
204 | # if !defined getpagesize && 0 | ||
205 | # include <OS.h> | ||
206 | # if defined B_PAGE_SIZE | ||
207 | # define getpagesize() B_PAGE_SIZE | ||
208 | # endif | ||
209 | # endif | ||
210 | /* This is for AmigaOS4.0. */ | ||
211 | # if !defined getpagesize && defined __amigaos4__ | ||
212 | # define getpagesize() 2048 | ||
213 | # endif | ||
214 | /* This is for older Unix systems. */ | ||
215 | # if !defined getpagesize && 0 | ||
216 | # include <sys/param.h> | ||
217 | # ifdef EXEC_PAGESIZE | ||
218 | # define getpagesize() EXEC_PAGESIZE | ||
219 | # else | ||
220 | # ifdef NBPG | ||
221 | # ifndef CLSIZE | ||
222 | # define CLSIZE 1 | ||
223 | # endif | ||
224 | # define getpagesize() (NBPG * CLSIZE) | ||
225 | # else | ||
226 | # ifdef NBPC | ||
227 | # define getpagesize() NBPC | ||
228 | # endif | ||
229 | # endif | ||
230 | # endif | ||
231 | # endif | ||
232 | # endif | ||
233 | #elif defined GNULIB_POSIXCHECK | ||
234 | # undef getpagesize | ||
235 | # define getpagesize() \ | ||
236 | (GL_LINK_WARNING ("getpagesize is unportable - " \ | ||
237 | "use gnulib module getpagesize for portability"), \ | ||
238 | getpagesize ()) | ||
239 | #endif | ||
240 | |||
241 | |||
242 | #if 0 | ||
243 | # if 0 | ||
244 | /* Change the owner of FILE to UID (if UID is not -1) and the group of FILE | ||
245 | to GID (if GID is not -1). Do not follow symbolic links. | ||
246 | Return 0 if successful, otherwise -1 and errno set. | ||
247 | See the POSIX:2001 specification | ||
248 | <http://www.opengroup.org/susv3xsh/lchown.html>. */ | ||
249 | # define lchown rpl_lchown | ||
250 | extern int lchown (char const *file, uid_t owner, gid_t group); | ||
251 | # endif | ||
252 | #elif defined GNULIB_POSIXCHECK | ||
253 | # undef lchown | ||
254 | # define lchown(f,u,g) \ | ||
255 | (GL_LINK_WARNING ("lchown is unportable to pre-POSIX.1-2001 " \ | ||
256 | "systems - use gnulib module lchown for portability"), \ | ||
257 | lchown (f, u, g)) | ||
258 | #endif | ||
259 | |||
260 | |||
261 | #if 0 | ||
262 | # if 0 | ||
263 | /* Set the offset of FD relative to SEEK_SET, SEEK_CUR, or SEEK_END. | ||
264 | Return the new offset if successful, otherwise -1 and errno set. | ||
265 | See the POSIX:2001 specification | ||
266 | <http://www.opengroup.org/susv3xsh/lseek.html>. */ | ||
267 | # define lseek rpl_lseek | ||
268 | extern off_t lseek (int fd, off_t offset, int whence); | ||
269 | # endif | ||
270 | #elif defined GNULIB_POSIXCHECK | ||
271 | # undef lseek | ||
272 | # define lseek(f,o,w) \ | ||
273 | (GL_LINK_WARNING ("lseek does not fail with ESPIPE on pipes on some " \ | ||
274 | "systems - use gnulib module lseek for portability"), \ | ||
275 | lseek (f, o, w)) | ||
276 | #endif | ||
277 | |||
278 | |||
279 | #if 0 | ||
280 | /* Read the contents of the symbolic link FILE and place the first BUFSIZE | ||
281 | bytes of it into BUF. Return the number of bytes placed into BUF if | ||
282 | successful, otherwise -1 and errno set. | ||
283 | See the POSIX:2001 specification | ||
284 | <http://www.opengroup.org/susv3xsh/readlink.html>. */ | ||
285 | # if !1 | ||
286 | # include <stddef.h> | ||
287 | extern int readlink (const char *file, char *buf, size_t bufsize); | ||
288 | # endif | ||
289 | #elif defined GNULIB_POSIXCHECK | ||
290 | # undef readlink | ||
291 | # define readlink(f,b,s) \ | ||
292 | (GL_LINK_WARNING ("readlink is unportable - " \ | ||
293 | "use gnulib module readlink for portability"), \ | ||
294 | readlink (f, b, s)) | ||
295 | #endif | ||
296 | |||
297 | |||
298 | #if 0 | ||
299 | /* Pause the execution of the current thread for N seconds. | ||
300 | Returns the number of seconds left to sleep. | ||
301 | See the POSIX:2001 specification | ||
302 | <http://www.opengroup.org/susv3xsh/sleep.html>. */ | ||
303 | # if !1 | ||
304 | extern unsigned int sleep (unsigned int n); | ||
305 | # endif | ||
306 | #elif defined GNULIB_POSIXCHECK | ||
307 | # undef sleep | ||
308 | # define sleep(n) \ | ||
309 | (GL_LINK_WARNING ("sleep is unportable - " \ | ||
310 | "use gnulib module sleep for portability"), \ | ||
311 | sleep (n)) | ||
312 | #endif | ||
313 | |||
314 | |||
315 | #ifdef __cplusplus | ||
316 | } | ||
317 | #endif | ||
318 | |||
319 | |||
320 | #endif /* _GL_UNISTD_H */ | ||
321 | #endif /* _GL_UNISTD_H */ | ||
diff --git a/lib/Makefile.am b/lib/Makefile.am index 36ff245c..5d65bed6 100644 --- a/lib/Makefile.am +++ b/lib/Makefile.am | |||
@@ -5,8 +5,8 @@ SUBDIRS = tests | |||
5 | noinst_LIBRARIES = libnagiosplug.a | 5 | noinst_LIBRARIES = libnagiosplug.a |
6 | 6 | ||
7 | 7 | ||
8 | libnagiosplug_a_SOURCES = utils_base.c utils_disk.c utils_tcp.c utils_cmd.c base64.c | 8 | libnagiosplug_a_SOURCES = utils_base.c utils_disk.c utils_tcp.c utils_cmd.c |
9 | EXTRA_DIST = utils_base.h utils_disk.h utils_tcp.h utils_cmd.h base64.h | 9 | EXTRA_DIST = utils_base.h utils_disk.h utils_tcp.h utils_cmd.h |
10 | 10 | ||
11 | INCLUDES = -I$(srcdir) -I$(top_srcdir)/gl -I$(top_srcdir)/intl -I$(top_srcdir)/plugins | 11 | INCLUDES = -I$(srcdir) -I$(top_srcdir)/gl -I$(top_srcdir)/intl -I$(top_srcdir)/plugins |
12 | 12 | ||
diff --git a/lib/base64.c b/lib/base64.c deleted file mode 100644 index 1f1fcb8c..00000000 --- a/lib/base64.c +++ /dev/null | |||
@@ -1,50 +0,0 @@ | |||
1 | /**************************************************************************** | ||
2 | * Function to encode in Base64 | ||
3 | * | ||
4 | * Written by Lauri Alanko | ||
5 | * | ||
6 | *****************************************************************************/ | ||
7 | |||
8 | #include "common.h" | ||
9 | #include "base64.h" | ||
10 | |||
11 | char * | ||
12 | base64 (const char *bin, size_t len) | ||
13 | { | ||
14 | |||
15 | char *buf = (char *) malloc ((len + 2) / 3 * 4 + 1); | ||
16 | size_t i = 0, j = 0; | ||
17 | |||
18 | char BASE64_END = '='; | ||
19 | char base64_table[64]; | ||
20 | strncpy (base64_table, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", 64); | ||
21 | |||
22 | while (j < len - 2) { | ||
23 | buf[i++] = base64_table[bin[j] >> 2]; | ||
24 | buf[i++] = base64_table[((bin[j] & 3) << 4) | (bin[j + 1] >> 4)]; | ||
25 | buf[i++] = base64_table[((bin[j + 1] & 15) << 2) | (bin[j + 2] >> 6)]; | ||
26 | buf[i++] = base64_table[bin[j + 2] & 63]; | ||
27 | j += 3; | ||
28 | } | ||
29 | |||
30 | switch (len - j) { | ||
31 | case 1: | ||
32 | buf[i++] = base64_table[bin[j] >> 2]; | ||
33 | buf[i++] = base64_table[(bin[j] & 3) << 4]; | ||
34 | buf[i++] = BASE64_END; | ||
35 | buf[i++] = BASE64_END; | ||
36 | break; | ||
37 | case 2: | ||
38 | buf[i++] = base64_table[bin[j] >> 2]; | ||
39 | buf[i++] = base64_table[((bin[j] & 3) << 4) | (bin[j + 1] >> 4)]; | ||
40 | buf[i++] = base64_table[(bin[j + 1] & 15) << 2]; | ||
41 | buf[i++] = BASE64_END; | ||
42 | break; | ||
43 | case 0: | ||
44 | break; | ||
45 | } | ||
46 | |||
47 | buf[i] = '\0'; | ||
48 | return buf; | ||
49 | } | ||
50 | |||
diff --git a/lib/base64.h b/lib/base64.h deleted file mode 100644 index 1e0a0b04..00000000 --- a/lib/base64.h +++ /dev/null | |||
@@ -1,4 +0,0 @@ | |||
1 | /* Header file for base64.c */ | ||
2 | |||
3 | char *base64 (const char *bin, size_t len); | ||
4 | |||
diff --git a/lib/tests/Makefile.am b/lib/tests/Makefile.am index 0ddc8abf..bd25ccfe 100644 --- a/lib/tests/Makefile.am +++ b/lib/tests/Makefile.am | |||
@@ -36,7 +36,7 @@ test_cmd_LDADD = ../utils_cmd.o ../utils_base.o | |||
36 | test_base64_SOURCES = test_base64.c | 36 | test_base64_SOURCES = test_base64.c |
37 | test_base64_CFLAGS = -g -I.. | 37 | test_base64_CFLAGS = -g -I.. |
38 | test_base64_LDFLAGS = -L/usr/local/lib -ltap | 38 | test_base64_LDFLAGS = -L/usr/local/lib -ltap |
39 | test_base64_LDADD = ../base64.o | 39 | test_base64_LDADD = $(top_srcdir)/gl/base64.o |
40 | 40 | ||
41 | test: ${noinst_PROGRAMS} | 41 | test: ${noinst_PROGRAMS} |
42 | perl -MTest::Harness -e '$$Test::Harness::switches=""; runtests(map {$$_ .= ".t"} @ARGV)' $(EXTRA_PROGRAMS) | 42 | perl -MTest::Harness -e '$$Test::Harness::switches=""; runtests(map {$$_ .= ".t"} @ARGV)' $(EXTRA_PROGRAMS) |
diff --git a/lib/tests/test_base64.c b/lib/tests/test_base64.c index e3ff3e35..650cfa1a 100644 --- a/lib/tests/test_base64.c +++ b/lib/tests/test_base64.c | |||
@@ -18,13 +18,12 @@ | |||
18 | *****************************************************************************/ | 18 | *****************************************************************************/ |
19 | 19 | ||
20 | #include "common.h" | 20 | #include "common.h" |
21 | #include "base64.h" | 21 | #include "gl/base64.h" |
22 | #include "tap.h" | 22 | #include "tap.h" |
23 | 23 | ||
24 | int | 24 | int |
25 | main (int argc, char **argv) | 25 | main (int argc, char **argv) |
26 | { | 26 | { |
27 | #if 0 /* The current base64 function doesn't work on 8bit data */ | ||
28 | char random[1024] = { | 27 | char random[1024] = { |
29 | 0x8b,0xb0,0xc4,0xe2,0xfc,0x22,0x9f,0x0d,0x85,0xe7,0x2c,0xaa,0x39,0xa1,0x46,0x88, | 28 | 0x8b,0xb0,0xc4,0xe2,0xfc,0x22,0x9f,0x0d,0x85,0xe7,0x2c,0xaa,0x39,0xa1,0x46,0x88, |
30 | 0x50,0xe6,0x34,0x37,0x0b,0x45,0x4b,0xb8,0xb2,0x86,0x7a,0x3e,0x7f,0x0c,0x40,0x18, | 29 | 0x50,0xe6,0x34,0x37,0x0b,0x45,0x4b,0xb8,0xb2,0x86,0x7a,0x3e,0x7f,0x0c,0x40,0x18, |
@@ -180,8 +179,9 @@ main (int argc, char **argv) | |||
180 | 0x46,0x62,0x5a,0x61,0x35,0x52,0x6e,0x50,0x59,0x43,0x4f,0x36,0x4f,0x70,0x4d,0x6c, | 179 | 0x46,0x62,0x5a,0x61,0x35,0x52,0x6e,0x50,0x59,0x43,0x4f,0x36,0x4f,0x70,0x4d,0x6c, |
181 | 0x41,0x6e,0x6a,0x4d,0x56,0x41,0x3d,0x3d | 180 | 0x41,0x6e,0x6a,0x4d,0x56,0x41,0x3d,0x3d |
182 | }; | 181 | }; |
183 | #endif | ||
184 | 182 | ||
183 | #if 0 | ||
184 | /* The old base64 function didn't work on 8bit data, below is 7bit */ | ||
185 | char random[1024] = { | 185 | char random[1024] = { |
186 | 0x0b,0x30,0x44,0x62,0x7c,0x22,0x1f,0x0d,0x05,0x67,0x2c,0x2a,0x39,0x21,0x46,0x08, | 186 | 0x0b,0x30,0x44,0x62,0x7c,0x22,0x1f,0x0d,0x05,0x67,0x2c,0x2a,0x39,0x21,0x46,0x08, |
187 | 0x50,0x66,0x34,0x37,0x0b,0x45,0x4b,0x38,0x32,0x06,0x7a,0x3e,0x7f,0x0c,0x40,0x18, | 187 | 0x50,0x66,0x34,0x37,0x0b,0x45,0x4b,0x38,0x32,0x06,0x7a,0x3e,0x7f,0x0c,0x40,0x18, |
@@ -336,11 +336,13 @@ main (int argc, char **argv) | |||
336 | 0x46,0x54,0x5a,0x61,0x5a,0x52,0x6c,0x50,0x59,0x43,0x4d,0x36,0x4f,0x68,0x4d,0x6c, | 336 | 0x46,0x54,0x5a,0x61,0x5a,0x52,0x6c,0x50,0x59,0x43,0x4d,0x36,0x4f,0x68,0x4d,0x6c, |
337 | 0x41,0x6e,0x68,0x4d,0x56,0x41,0x3d,0x3d,0x00 | 337 | 0x41,0x6e,0x68,0x4d,0x56,0x41,0x3d,0x3d,0x00 |
338 | }; | 338 | }; |
339 | #endif | ||
340 | |||
339 | char *b64_test; | 341 | char *b64_test; |
340 | 342 | ||
341 | plan_tests(1); | 343 | plan_tests(1); |
342 | 344 | ||
343 | b64_test = base64 (random, 1024); | 345 | base64_encode_alloc (random, 1024, &b64_test); |
344 | 346 | ||
345 | ok(strcmp(b64_known, b64_test) == 0, | 347 | ok(strcmp(b64_known, b64_test) == 0, |
346 | "Test matching a base64 encoded 1024 bytes random string"); | 348 | "Test matching a base64 encoded 1024 bytes random string"); |
diff --git a/plugins/check_http.c b/plugins/check_http.c index 02754021..151eacac 100644 --- a/plugins/check_http.c +++ b/plugins/check_http.c | |||
@@ -764,7 +764,7 @@ check_http (void) | |||
764 | 764 | ||
765 | /* optionally send the authentication info */ | 765 | /* optionally send the authentication info */ |
766 | if (strlen(user_auth)) { | 766 | if (strlen(user_auth)) { |
767 | auth = base64 (user_auth, strlen (user_auth)); | 767 | base64_encode_alloc (user_auth, strlen (user_auth), &auth); |
768 | asprintf (&buf, "%sAuthorization: Basic %s\r\n", buf, auth); | 768 | asprintf (&buf, "%sAuthorization: Basic %s\r\n", buf, auth); |
769 | } | 769 | } |
770 | 770 | ||
diff --git a/plugins/check_smtp.c b/plugins/check_smtp.c index d3e4f42e..3310bceb 100644 --- a/plugins/check_smtp.c +++ b/plugins/check_smtp.c | |||
@@ -366,7 +366,8 @@ main (int argc, char **argv) | |||
366 | } | 366 | } |
367 | 367 | ||
368 | /* encode authuser with base64 */ | 368 | /* encode authuser with base64 */ |
369 | abuf = base64 (authuser, strlen(authuser)); | 369 | base64_encode_alloc (authuser, strlen(authuser), &abuf); |
370 | /* FIXME: abuf shouldn't have enough space to strcat a '\r\n' into it. */ | ||
370 | strcat (abuf, "\r\n"); | 371 | strcat (abuf, "\r\n"); |
371 | my_send(abuf, strlen(abuf)); | 372 | my_send(abuf, strlen(abuf)); |
372 | if (verbose) | 373 | if (verbose) |
@@ -386,7 +387,8 @@ main (int argc, char **argv) | |||
386 | break; | 387 | break; |
387 | } | 388 | } |
388 | /* encode authpass with base64 */ | 389 | /* encode authpass with base64 */ |
389 | abuf = base64 (authpass, strlen(authpass)); | 390 | base64_encode_alloc (authpass, strlen(authpass), &abuf); |
391 | /* FIXME: abuf shouldn't have enough space to strcat a '\r\n' into it. */ | ||
390 | strcat (abuf, "\r\n"); | 392 | strcat (abuf, "\r\n"); |
391 | my_send(abuf, strlen(abuf)); | 393 | my_send(abuf, strlen(abuf)); |
392 | if (verbose) { | 394 | if (verbose) { |