diff options
-rw-r--r-- | gl/charset.alias | 5 | ||||
-rw-r--r-- | gl/configmake.h | 25 | ||||
-rw-r--r-- | gl/math.h | 442 | ||||
-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 |
9 files changed, 0 insertions, 2054 deletions
diff --git a/gl/charset.alias b/gl/charset.alias deleted file mode 100644 index d9501e2..0000000 --- a/gl/charset.alias +++ /dev/null | |||
@@ -1,5 +0,0 @@ | |||
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 deleted file mode 100644 index f73bc38..0000000 --- a/gl/configmake.h +++ /dev/null | |||
@@ -1,25 +0,0 @@ | |||
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/math.h b/gl/math.h deleted file mode 100644 index 9db986e..0000000 --- a/gl/math.h +++ /dev/null | |||
@@ -1,442 +0,0 @@ | |||
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/ref-add.sed b/gl/ref-add.sed deleted file mode 100644 index 3ac991f..0000000 --- a/gl/ref-add.sed +++ /dev/null | |||
@@ -1,10 +0,0 @@ | |||
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 deleted file mode 100644 index a48fdb7..0000000 --- a/gl/ref-del.sed +++ /dev/null | |||
@@ -1,5 +0,0 @@ | |||
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 deleted file mode 100644 index f09ee83..0000000 --- a/gl/stdio.h +++ /dev/null | |||
@@ -1,411 +0,0 @@ | |||
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 deleted file mode 100644 index 86da899..0000000 --- a/gl/stdlib.h +++ /dev/null | |||
@@ -1,237 +0,0 @@ | |||
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 deleted file mode 100644 index e5bcef5..0000000 --- a/gl/string.h +++ /dev/null | |||
@@ -1,598 +0,0 @@ | |||
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 deleted file mode 100644 index e72a5d9..0000000 --- a/gl/unistd.h +++ /dev/null | |||
@@ -1,321 +0,0 @@ | |||
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 */ | ||