← Back to branch summary

~ubuntu-branches/ubuntu/quantal/gnutls26/quantal

« back to all changes in this revision

Viewing changes to lib/gl/stdlib.in.h

  • Committer: Bazaar Package Importer
  • Author(s): Steve Langasek
  • Date: 2011-05-20 13:07:18 UTC
  • mfrom: (12.1.11 sid)
  • Revision ID: james.westby@ubuntu.com-20110520130718-db41dybbanzfvlji
Tags: 2.10.5-1ubuntu1
* Merge from Debian unstable, remaining changes:
  - Fix build failure with --no-add-needed.
  - Build for multiarch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/gl/stdlib.in.h
1
1
/* A GNU-like <stdlib.h>.
2
2
 
3
 
   Copyright (C) 1995, 2001-2004, 2006-2009 Free Software Foundation, Inc.
 
3
   Copyright (C) 1995, 2001-2004, 2006-2010 Free Software Foundation, Inc.
4
4
 
5
5
   This program is free software: you can redistribute it and/or modify
6
6
   it under the terms of the GNU Lesser General Public License as published by
35
35
#ifndef _GL_STDLIB_H
36
36
#define _GL_STDLIB_H
37
37
 
 
38
/* NetBSD 5.0 mis-defines NULL.  */
 
39
#include <stddef.h>
38
40
 
39
41
/* Solaris declares getloadavg() in <sys/loadavg.h>.  */
40
 
#if @GNULIB_GETLOADAVG@ && @HAVE_SYS_LOADAVG_H@
 
42
#if (@GNULIB_GETLOADAVG@ || defined GNULIB_POSIXCHECK) && @HAVE_SYS_LOADAVG_H@
41
43
# include <sys/loadavg.h>
42
44
#endif
43
45
 
47
49
# include <random.h>
48
50
#endif
49
51
 
50
 
#if @GNULIB_RANDOM_R@ || !@HAVE_STRUCT_RANDOM_DATA@
 
52
#if !@HAVE_STRUCT_RANDOM_DATA@ || (@GNULIB_RANDOM_R@ && !@HAVE_RANDOM_R@) \
 
53
    || defined GNULIB_POSIXCHECK
51
54
# include <stdint.h>
52
55
#endif
53
56
 
54
57
#if !@HAVE_STRUCT_RANDOM_DATA@
55
58
struct random_data
56
59
{
57
 
  int32_t *fptr;                /* Front pointer.  */
58
 
  int32_t *rptr;                /* Rear pointer.  */
59
 
  int32_t *state;               /* Array of state values.  */
60
 
  int rand_type;                /* Type of random number generator.  */
61
 
  int rand_deg;                 /* Degree of random number generator.  */
62
 
  int rand_sep;                 /* Distance between front and rear.  */
63
 
  int32_t *end_ptr;             /* Pointer behind state table.  */
 
60
  int32_t *fptr;                /* Front pointer.  */
 
61
  int32_t *rptr;                /* Rear pointer.  */
 
62
  int32_t *state;               /* Array of state values.  */
 
63
  int rand_type;                /* Type of random number generator.  */
 
64
  int rand_deg;                 /* Degree of random number generator.  */
 
65
  int rand_sep;                 /* Distance between front and rear.  */
 
66
  int32_t *end_ptr;             /* Pointer behind state table.  */
64
67
};
65
68
#endif
66
69
 
67
 
/* The definition of GL_LINK_WARNING is copied here.  */
 
70
#if (@GNULIB_MKSTEMP@ || @GNULIB_GETSUBOPT@ || defined GNULIB_POSIXCHECK) && ! defined __GLIBC__ && !((defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__)
 
71
/* On MacOS X 10.3, only <unistd.h> declares mkstemp.  */
 
72
/* On Cygwin 1.7.1, only <unistd.h> declares getsubopt.  */
 
73
/* But avoid namespace pollution on glibc systems and native Windows.  */
 
74
# include <unistd.h>
 
75
#endif
 
76
 
 
77
/* The definitions of _GL_FUNCDECL_RPL etc. are copied here.  */
 
78
 
 
79
/* The definition of _GL_ARG_NONNULL is copied here.  */
 
80
 
 
81
/* The definition of _GL_WARN_ON_USE is copied here.  */
68
82
 
69
83
 
70
84
/* Some systems do not define EXIT_*, despite otherwise supporting C89.  */
81
95
#endif
82
96
 
83
97
 
84
 
#ifdef __cplusplus
85
 
extern "C" {
86
 
#endif
87
 
 
88
 
 
89
 
#if @GNULIB_MALLOC_POSIX@
90
 
# if !@HAVE_MALLOC_POSIX@
91
 
#  undef malloc
92
 
#  define malloc rpl_malloc
93
 
extern void * malloc (size_t size);
94
 
# endif
95
 
#elif defined GNULIB_POSIXCHECK
96
 
# undef malloc
97
 
# define malloc(s) \
98
 
    (GL_LINK_WARNING ("malloc is not POSIX compliant everywhere - " \
99
 
                      "use gnulib module malloc-posix for portability"), \
100
 
     malloc (s))
101
 
#endif
102
 
 
103
 
 
104
 
#if @GNULIB_REALLOC_POSIX@
105
 
# if !@HAVE_REALLOC_POSIX@
106
 
#  undef realloc
107
 
#  define realloc rpl_realloc
108
 
extern void * realloc (void *ptr, size_t size);
109
 
# endif
110
 
#elif defined GNULIB_POSIXCHECK
111
 
# undef realloc
112
 
# define realloc(p,s) \
113
 
    (GL_LINK_WARNING ("realloc is not POSIX compliant everywhere - " \
114
 
                      "use gnulib module realloc-posix for portability"), \
115
 
     realloc (p, s))
116
 
#endif
117
 
 
118
 
 
119
 
#if @GNULIB_CALLOC_POSIX@
120
 
# if !@HAVE_CALLOC_POSIX@
121
 
#  undef calloc
122
 
#  define calloc rpl_calloc
123
 
extern void * calloc (size_t nmemb, size_t size);
124
 
# endif
125
 
#elif defined GNULIB_POSIXCHECK
126
 
# undef calloc
127
 
# define calloc(n,s) \
128
 
    (GL_LINK_WARNING ("calloc is not POSIX compliant everywhere - " \
129
 
                      "use gnulib module calloc-posix for portability"), \
130
 
     calloc (n, s))
131
 
#endif
132
 
 
133
 
 
134
98
#if @GNULIB_ATOLL@
135
 
# if !@HAVE_ATOLL@
136
99
/* Parse a signed decimal integer.
137
100
   Returns the value of the integer.  Errors are not detected.  */
138
 
extern long long atoll (const char *string);
 
101
# if !@HAVE_ATOLL@
 
102
_GL_FUNCDECL_SYS (atoll, long long, (const char *string) _GL_ARG_NONNULL ((1)));
139
103
# endif
 
104
_GL_CXXALIAS_SYS (atoll, long long, (const char *string));
 
105
_GL_CXXALIASWARN (atoll);
140
106
#elif defined GNULIB_POSIXCHECK
141
107
# undef atoll
142
 
# define atoll(s) \
143
 
    (GL_LINK_WARNING ("atoll is unportable - " \
144
 
                      "use gnulib module atoll for portability"), \
145
 
     atoll (s))
146
 
#endif
147
 
 
 
108
# if HAVE_RAW_DECL_ATOLL
 
109
_GL_WARN_ON_USE (atoll, "atoll is unportable - "
 
110
                 "use gnulib module atoll for portability");
 
111
# endif
 
112
#endif
 
113
 
 
114
#if @GNULIB_CALLOC_POSIX@
 
115
# if !@HAVE_CALLOC_POSIX@
 
116
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
117
#   undef calloc
 
118
#   define calloc rpl_calloc
 
119
#  endif
 
120
_GL_FUNCDECL_RPL (calloc, void *, (size_t nmemb, size_t size));
 
121
_GL_CXXALIAS_RPL (calloc, void *, (size_t nmemb, size_t size));
 
122
# else
 
123
_GL_CXXALIAS_SYS (calloc, void *, (size_t nmemb, size_t size));
 
124
# endif
 
125
_GL_CXXALIASWARN (calloc);
 
126
#elif defined GNULIB_POSIXCHECK
 
127
# undef calloc
 
128
/* Assume calloc is always declared.  */
 
129
_GL_WARN_ON_USE (calloc, "calloc is not POSIX compliant everywhere - "
 
130
                 "use gnulib module calloc-posix for portability");
 
131
#endif
 
132
 
 
133
#if @GNULIB_CANONICALIZE_FILE_NAME@
 
134
# if @REPLACE_CANONICALIZE_FILE_NAME@
 
135
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
136
#   define canonicalize_file_name rpl_canonicalize_file_name
 
137
#  endif
 
138
_GL_FUNCDECL_RPL (canonicalize_file_name, char *, (const char *name)
 
139
                                                  _GL_ARG_NONNULL ((1)));
 
140
_GL_CXXALIAS_RPL (canonicalize_file_name, char *, (const char *name));
 
141
# else
 
142
#  if !@HAVE_CANONICALIZE_FILE_NAME@
 
143
_GL_FUNCDECL_SYS (canonicalize_file_name, char *, (const char *name)
 
144
                                                  _GL_ARG_NONNULL ((1)));
 
145
#  endif
 
146
_GL_CXXALIAS_SYS (canonicalize_file_name, char *, (const char *name));
 
147
# endif
 
148
_GL_CXXALIASWARN (canonicalize_file_name);
 
149
#elif defined GNULIB_POSIXCHECK
 
150
# undef canonicalize_file_name
 
151
# if HAVE_RAW_DECL_CANONICALIZE_FILE_NAME
 
152
_GL_WARN_ON_USE (canonicalize_file_name, "canonicalize_file_name is unportable - "
 
153
                 "use gnulib module canonicalize-lgpl for portability");
 
154
# endif
 
155
#endif
148
156
 
149
157
#if @GNULIB_GETLOADAVG@
150
 
# if !@HAVE_DECL_GETLOADAVG@
151
158
/* Store max(NELEM,3) load average numbers in LOADAVG[].
152
159
   The three numbers are the load average of the last 1 minute, the last 5
153
160
   minutes, and the last 15 minutes, respectively.
154
161
   LOADAVG is an array of NELEM numbers.  */
155
 
extern int getloadavg (double loadavg[], int nelem);
 
162
# if !@HAVE_DECL_GETLOADAVG@
 
163
_GL_FUNCDECL_SYS (getloadavg, int, (double loadavg[], int nelem)
 
164
                                   _GL_ARG_NONNULL ((1)));
156
165
# endif
 
166
_GL_CXXALIAS_SYS (getloadavg, int, (double loadavg[], int nelem));
 
167
_GL_CXXALIASWARN (getloadavg);
157
168
#elif defined GNULIB_POSIXCHECK
158
169
# undef getloadavg
159
 
# define getloadavg(l,n) \
160
 
    (GL_LINK_WARNING ("getloadavg is not portable - " \
161
 
                      "use gnulib module getloadavg for portability"), \
162
 
     getloadavg (l, n))
 
170
# if HAVE_RAW_DECL_GETLOADAVG
 
171
_GL_WARN_ON_USE (getloadavg, "getloadavg is not portable - "
 
172
                 "use gnulib module getloadavg for portability");
 
173
# endif
163
174
#endif
164
175
 
165
 
 
166
176
#if @GNULIB_GETSUBOPT@
167
177
/* Assuming *OPTIONP is a comma separated list of elements of the form
168
178
   "token" or "token=value", getsubopt parses the first of these elements.
176
186
   For more details see the POSIX:2001 specification.
177
187
   http://www.opengroup.org/susv3xsh/getsubopt.html */
178
188
# if !@HAVE_GETSUBOPT@
179
 
extern int getsubopt (char **optionp, char *const *tokens, char **valuep);
 
189
_GL_FUNCDECL_SYS (getsubopt, int,
 
190
                  (char **optionp, char *const *tokens, char **valuep)
 
191
                  _GL_ARG_NONNULL ((1, 2, 3)));
180
192
# endif
 
193
_GL_CXXALIAS_SYS (getsubopt, int,
 
194
                  (char **optionp, char *const *tokens, char **valuep));
 
195
_GL_CXXALIASWARN (getsubopt);
181
196
#elif defined GNULIB_POSIXCHECK
182
197
# undef getsubopt
183
 
# define getsubopt(o,t,v) \
184
 
    (GL_LINK_WARNING ("getsubopt is unportable - " \
185
 
                      "use gnulib module getsubopt for portability"), \
186
 
     getsubopt (o, t, v))
187
 
#endif
188
 
 
 
198
# if HAVE_RAW_DECL_GETSUBOPT
 
199
_GL_WARN_ON_USE (getsubopt, "getsubopt is unportable - "
 
200
                 "use gnulib module getsubopt for portability");
 
201
# endif
 
202
#endif
 
203
 
 
204
#if @GNULIB_GRANTPT@
 
205
/* Change the ownership and access permission of the slave side of the
 
206
   pseudo-terminal whose master side is specified by FD.  */
 
207
# if !@HAVE_GRANTPT@
 
208
_GL_FUNCDECL_SYS (grantpt, int, (int fd));
 
209
# endif
 
210
_GL_CXXALIAS_SYS (grantpt, int, (int fd));
 
211
_GL_CXXALIASWARN (grantpt);
 
212
#elif defined GNULIB_POSIXCHECK
 
213
# undef grantpt
 
214
# if HAVE_RAW_DECL_GRANTPT
 
215
_GL_WARN_ON_USE (ptsname, "grantpt is not portable - "
 
216
                 "use gnulib module grantpt for portability");
 
217
# endif
 
218
#endif
 
219
 
 
220
#if @GNULIB_MALLOC_POSIX@
 
221
# if !@HAVE_MALLOC_POSIX@
 
222
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
223
#   undef malloc
 
224
#   define malloc rpl_malloc
 
225
#  endif
 
226
_GL_FUNCDECL_RPL (malloc, void *, (size_t size));
 
227
_GL_CXXALIAS_RPL (malloc, void *, (size_t size));
 
228
# else
 
229
_GL_CXXALIAS_SYS (malloc, void *, (size_t size));
 
230
# endif
 
231
_GL_CXXALIASWARN (malloc);
 
232
#elif defined GNULIB_POSIXCHECK
 
233
# undef malloc
 
234
/* Assume malloc is always declared.  */
 
235
_GL_WARN_ON_USE (malloc, "malloc is not POSIX compliant everywhere - "
 
236
                 "use gnulib module malloc-posix for portability");
 
237
#endif
189
238
 
190
239
#if @GNULIB_MKDTEMP@
191
 
# if !@HAVE_MKDTEMP@
192
240
/* Create a unique temporary directory from TEMPLATE.
193
241
   The last six characters of TEMPLATE must be "XXXXXX";
194
242
   they are replaced with a string that makes the directory name unique.
195
243
   Returns TEMPLATE, or a null pointer if it cannot get a unique name.
196
244
   The directory is created mode 700.  */
197
 
extern char * mkdtemp (char * /*template*/);
 
245
# if !@HAVE_MKDTEMP@
 
246
_GL_FUNCDECL_SYS (mkdtemp, char *, (char * /*template*/) _GL_ARG_NONNULL ((1)));
198
247
# endif
 
248
_GL_CXXALIAS_SYS (mkdtemp, char *, (char * /*template*/));
 
249
_GL_CXXALIASWARN (mkdtemp);
199
250
#elif defined GNULIB_POSIXCHECK
200
251
# undef mkdtemp
201
 
# define mkdtemp(t) \
202
 
    (GL_LINK_WARNING ("mkdtemp is unportable - " \
203
 
                      "use gnulib module mkdtemp for portability"), \
204
 
     mkdtemp (t))
205
 
#endif
206
 
 
 
252
# if HAVE_RAW_DECL_MKDTEMP
 
253
_GL_WARN_ON_USE (mkdtemp, "mkdtemp is unportable - "
 
254
                 "use gnulib module mkdtemp for portability");
 
255
# endif
 
256
#endif
 
257
 
 
258
#if @GNULIB_MKOSTEMP@
 
259
/* Create a unique temporary file from TEMPLATE.
 
260
   The last six characters of TEMPLATE must be "XXXXXX";
 
261
   they are replaced with a string that makes the file name unique.
 
262
   The flags are a bitmask, possibly including O_CLOEXEC (defined in <fcntl.h>)
 
263
   and O_TEXT, O_BINARY (defined in "binary-io.h").
 
264
   The file is then created, with the specified flags, ensuring it didn't exist
 
265
   before.
 
266
   The file is created read-write (mask at least 0600 & ~umask), but it may be
 
267
   world-readable and world-writable (mask 0666 & ~umask), depending on the
 
268
   implementation.
 
269
   Returns the open file descriptor if successful, otherwise -1 and errno
 
270
   set.  */
 
271
# if !@HAVE_MKOSTEMP@
 
272
_GL_FUNCDECL_SYS (mkostemp, int, (char * /*template*/, int /*flags*/)
 
273
                                 _GL_ARG_NONNULL ((1)));
 
274
# endif
 
275
_GL_CXXALIAS_SYS (mkostemp, int, (char * /*template*/, int /*flags*/));
 
276
_GL_CXXALIASWARN (mkostemp);
 
277
#elif defined GNULIB_POSIXCHECK
 
278
# undef mkostemp
 
279
# if HAVE_RAW_DECL_MKOSTEMP
 
280
_GL_WARN_ON_USE (mkostemp, "mkostemp is unportable - "
 
281
                 "use gnulib module mkostemp for portability");
 
282
# endif
 
283
#endif
 
284
 
 
285
#if @GNULIB_MKOSTEMPS@
 
286
/* Create a unique temporary file from TEMPLATE.
 
287
   The last six characters of TEMPLATE before a suffix of length
 
288
   SUFFIXLEN must be "XXXXXX";
 
289
   they are replaced with a string that makes the file name unique.
 
290
   The flags are a bitmask, possibly including O_CLOEXEC (defined in <fcntl.h>)
 
291
   and O_TEXT, O_BINARY (defined in "binary-io.h").
 
292
   The file is then created, with the specified flags, ensuring it didn't exist
 
293
   before.
 
294
   The file is created read-write (mask at least 0600 & ~umask), but it may be
 
295
   world-readable and world-writable (mask 0666 & ~umask), depending on the
 
296
   implementation.
 
297
   Returns the open file descriptor if successful, otherwise -1 and errno
 
298
   set.  */
 
299
# if !@HAVE_MKOSTEMPS@
 
300
_GL_FUNCDECL_SYS (mkostemps, int,
 
301
                  (char * /*template*/, int /*suffixlen*/, int /*flags*/)
 
302
                  _GL_ARG_NONNULL ((1)));
 
303
# endif
 
304
_GL_CXXALIAS_SYS (mkostemps, int,
 
305
                  (char * /*template*/, int /*suffixlen*/, int /*flags*/));
 
306
_GL_CXXALIASWARN (mkostemps);
 
307
#elif defined GNULIB_POSIXCHECK
 
308
# undef mkostemps
 
309
# if HAVE_RAW_DECL_MKOSTEMPS
 
310
_GL_WARN_ON_USE (mkostemps, "mkostemps is unportable - "
 
311
                 "use gnulib module mkostemps for portability");
 
312
# endif
 
313
#endif
207
314
 
208
315
#if @GNULIB_MKSTEMP@
 
316
/* Create a unique temporary file from TEMPLATE.
 
317
   The last six characters of TEMPLATE must be "XXXXXX";
 
318
   they are replaced with a string that makes the file name unique.
 
319
   The file is then created, ensuring it didn't exist before.
 
320
   The file is created read-write (mask at least 0600 & ~umask), but it may be
 
321
   world-readable and world-writable (mask 0666 & ~umask), depending on the
 
322
   implementation.
 
323
   Returns the open file descriptor if successful, otherwise -1 and errno
 
324
   set.  */
209
325
# if @REPLACE_MKSTEMP@
210
 
/* Create a unique temporary file from TEMPLATE.
211
 
   The last six characters of TEMPLATE must be "XXXXXX";
212
 
   they are replaced with a string that makes the file name unique.
213
 
   The file is then created, ensuring it didn't exist before.
214
 
   The file is created read-write (mask at least 0600 & ~umask), but it may be
215
 
   world-readable and world-writable (mask 0666 & ~umask), depending on the
216
 
   implementation.
217
 
   Returns the open file descriptor if successful, otherwise -1 and errno
218
 
   set.  */
219
 
#  define mkstemp rpl_mkstemp
220
 
extern int mkstemp (char * /*template*/);
 
326
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
327
#   define mkstemp rpl_mkstemp
 
328
#  endif
 
329
_GL_FUNCDECL_RPL (mkstemp, int, (char * /*template*/) _GL_ARG_NONNULL ((1)));
 
330
_GL_CXXALIAS_RPL (mkstemp, int, (char * /*template*/));
221
331
# else
222
 
/* On MacOS X 10.3, only <unistd.h> declares mkstemp.  */
223
 
#  include <unistd.h>
 
332
#  if ! @HAVE_MKSTEMP@
 
333
_GL_FUNCDECL_SYS (mkstemp, int, (char * /*template*/) _GL_ARG_NONNULL ((1)));
 
334
#  endif
 
335
_GL_CXXALIAS_SYS (mkstemp, int, (char * /*template*/));
224
336
# endif
 
337
_GL_CXXALIASWARN (mkstemp);
225
338
#elif defined GNULIB_POSIXCHECK
226
339
# undef mkstemp
227
 
# define mkstemp(t) \
228
 
    (GL_LINK_WARNING ("mkstemp is unportable - " \
229
 
                      "use gnulib module mkstemp for portability"), \
230
 
     mkstemp (t))
231
 
#endif
232
 
 
 
340
# if HAVE_RAW_DECL_MKSTEMP
 
341
_GL_WARN_ON_USE (mkstemp, "mkstemp is unportable - "
 
342
                 "use gnulib module mkstemp for portability");
 
343
# endif
 
344
#endif
 
345
 
 
346
#if @GNULIB_MKSTEMPS@
 
347
/* Create a unique temporary file from TEMPLATE.
 
348
   The last six characters of TEMPLATE prior to a suffix of length
 
349
   SUFFIXLEN must be "XXXXXX";
 
350
   they are replaced with a string that makes the file name unique.
 
351
   The file is then created, ensuring it didn't exist before.
 
352
   The file is created read-write (mask at least 0600 & ~umask), but it may be
 
353
   world-readable and world-writable (mask 0666 & ~umask), depending on the
 
354
   implementation.
 
355
   Returns the open file descriptor if successful, otherwise -1 and errno
 
356
   set.  */
 
357
# if !@HAVE_MKSTEMPS@
 
358
_GL_FUNCDECL_SYS (mkstemps, int, (char * /*template*/, int /*suffixlen*/)
 
359
                                 _GL_ARG_NONNULL ((1)));
 
360
# endif
 
361
_GL_CXXALIAS_SYS (mkstemps, int, (char * /*template*/, int /*suffixlen*/));
 
362
_GL_CXXALIASWARN (mkstemps);
 
363
#elif defined GNULIB_POSIXCHECK
 
364
# undef mkstemps
 
365
# if HAVE_RAW_DECL_MKSTEMPS
 
366
_GL_WARN_ON_USE (mkstemps, "mkstemps is unportable - "
 
367
                 "use gnulib module mkstemps for portability");
 
368
# endif
 
369
#endif
 
370
 
 
371
#if @GNULIB_PTSNAME@
 
372
/* Return the pathname of the pseudo-terminal slave associated with
 
373
   the master FD is open on, or NULL on errors.  */
 
374
# if !@HAVE_PTSNAME@
 
375
_GL_FUNCDECL_SYS (ptsname, char *, (int fd));
 
376
# endif
 
377
_GL_CXXALIAS_SYS (ptsname, char *, (int fd));
 
378
_GL_CXXALIASWARN (ptsname);
 
379
#elif defined GNULIB_POSIXCHECK
 
380
# undef ptsname
 
381
# if HAVE_RAW_DECL_PTSNAME
 
382
_GL_WARN_ON_USE (ptsname, "ptsname is not portable - "
 
383
                 "use gnulib module ptsname for portability");
 
384
# endif
 
385
#endif
233
386
 
234
387
#if @GNULIB_PUTENV@
235
388
# if @REPLACE_PUTENV@
236
 
#  undef putenv
237
 
#  define putenv rpl_putenv
238
 
extern int putenv (char *string);
 
389
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
390
#   undef putenv
 
391
#   define putenv rpl_putenv
 
392
#  endif
 
393
_GL_FUNCDECL_RPL (putenv, int, (char *string) _GL_ARG_NONNULL ((1)));
 
394
_GL_CXXALIAS_RPL (putenv, int, (char *string));
 
395
# else
 
396
_GL_CXXALIAS_SYS (putenv, int, (char *string));
239
397
# endif
 
398
_GL_CXXALIASWARN (putenv);
240
399
#endif
241
400
 
242
401
 
243
402
#if @GNULIB_RANDOM_R@
244
403
# if !@HAVE_RANDOM_R@
245
 
 
246
404
#  ifndef RAND_MAX
247
405
#   define RAND_MAX 2147483647
248
406
#  endif
 
407
# endif
 
408
#endif
249
409
 
250
 
int srandom_r (unsigned int seed, struct random_data *rand_state);
251
 
int initstate_r (unsigned int seed, char *buf, size_t buf_size,
252
 
                 struct random_data *rand_state);
253
 
int setstate_r (char *arg_state, struct random_data *rand_state);
254
 
int random_r (struct random_data *buf, int32_t *result);
 
410
#if @GNULIB_RANDOM_R@
 
411
# if !@HAVE_RANDOM_R@
 
412
_GL_FUNCDECL_SYS (random_r, int, (struct random_data *buf, int32_t *result)
 
413
                                 _GL_ARG_NONNULL ((1, 2)));
255
414
# endif
 
415
_GL_CXXALIAS_SYS (random_r, int, (struct random_data *buf, int32_t *result));
 
416
_GL_CXXALIASWARN (random_r);
256
417
#elif defined GNULIB_POSIXCHECK
257
418
# undef random_r
258
 
# define random_r(b,r)                            \
259
 
    (GL_LINK_WARNING ("random_r is unportable - " \
260
 
                      "use gnulib module random_r for portability"), \
261
 
     random_r (b,r))
 
419
# if HAVE_RAW_DECL_RANDOM_R
 
420
_GL_WARN_ON_USE (random_r, "random_r is unportable - "
 
421
                 "use gnulib module random_r for portability");
 
422
# endif
 
423
#endif
 
424
 
 
425
#if @GNULIB_RANDOM_R@
 
426
# if !@HAVE_RANDOM_R@
 
427
_GL_FUNCDECL_SYS (srandom_r, int,
 
428
                  (unsigned int seed, struct random_data *rand_state)
 
429
                  _GL_ARG_NONNULL ((2)));
 
430
# endif
 
431
_GL_CXXALIAS_SYS (srandom_r, int,
 
432
                  (unsigned int seed, struct random_data *rand_state));
 
433
_GL_CXXALIASWARN (srandom_r);
 
434
#elif defined GNULIB_POSIXCHECK
 
435
# undef srandom_r
 
436
# if HAVE_RAW_DECL_SRANDOM_R
 
437
_GL_WARN_ON_USE (srandom_r, "srandom_r is unportable - "
 
438
                 "use gnulib module random_r for portability");
 
439
# endif
 
440
#endif
 
441
 
 
442
#if @GNULIB_RANDOM_R@
 
443
# if !@HAVE_RANDOM_R@
 
444
_GL_FUNCDECL_SYS (initstate_r, int,
 
445
                  (unsigned int seed, char *buf, size_t buf_size,
 
446
                   struct random_data *rand_state)
 
447
                  _GL_ARG_NONNULL ((2, 4)));
 
448
# endif
 
449
_GL_CXXALIAS_SYS (initstate_r, int,
 
450
                  (unsigned int seed, char *buf, size_t buf_size,
 
451
                   struct random_data *rand_state));
 
452
_GL_CXXALIASWARN (initstate_r);
 
453
#elif defined GNULIB_POSIXCHECK
262
454
# undef initstate_r
263
 
# define initstate_r(s,b,sz,r)                       \
264
 
    (GL_LINK_WARNING ("initstate_r is unportable - " \
265
 
                      "use gnulib module random_r for portability"), \
266
 
     initstate_r (s,b,sz,r))
267
 
# undef srandom_r
268
 
# define srandom_r(s,r)                            \
269
 
    (GL_LINK_WARNING ("srandom_r is unportable - " \
270
 
                      "use gnulib module random_r for portability"), \
271
 
     srandom_r (s,r))
 
455
# if HAVE_RAW_DECL_INITSTATE_R
 
456
_GL_WARN_ON_USE (initstate_r, "initstate_r is unportable - "
 
457
                 "use gnulib module random_r for portability");
 
458
# endif
 
459
#endif
 
460
 
 
461
#if @GNULIB_RANDOM_R@
 
462
# if !@HAVE_RANDOM_R@
 
463
_GL_FUNCDECL_SYS (setstate_r, int,
 
464
                  (char *arg_state, struct random_data *rand_state)
 
465
                  _GL_ARG_NONNULL ((1, 2)));
 
466
# endif
 
467
_GL_CXXALIAS_SYS (setstate_r, int,
 
468
                  (char *arg_state, struct random_data *rand_state));
 
469
_GL_CXXALIASWARN (setstate_r);
 
470
#elif defined GNULIB_POSIXCHECK
272
471
# undef setstate_r
273
 
# define setstate_r(a,r)                                    \
274
 
    (GL_LINK_WARNING ("setstate_r is unportable - " \
275
 
                      "use gnulib module random_r for portability"), \
276
 
     setstate_r (a,r))
277
 
#endif
278
 
 
 
472
# if HAVE_RAW_DECL_SETSTATE_R
 
473
_GL_WARN_ON_USE (setstate_r, "setstate_r is unportable - "
 
474
                 "use gnulib module random_r for portability");
 
475
# endif
 
476
#endif
 
477
 
 
478
 
 
479
#if @GNULIB_REALLOC_POSIX@
 
480
# if !@HAVE_REALLOC_POSIX@
 
481
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
482
#   undef realloc
 
483
#   define realloc rpl_realloc
 
484
#  endif
 
485
_GL_FUNCDECL_RPL (realloc, void *, (void *ptr, size_t size));
 
486
_GL_CXXALIAS_RPL (realloc, void *, (void *ptr, size_t size));
 
487
# else
 
488
_GL_CXXALIAS_SYS (realloc, void *, (void *ptr, size_t size));
 
489
# endif
 
490
_GL_CXXALIASWARN (realloc);
 
491
#elif defined GNULIB_POSIXCHECK
 
492
# undef realloc
 
493
/* Assume realloc is always declared.  */
 
494
_GL_WARN_ON_USE (realloc, "realloc is not POSIX compliant everywhere - "
 
495
                 "use gnulib module realloc-posix for portability");
 
496
#endif
 
497
 
 
498
#if @GNULIB_REALPATH@
 
499
# if @REPLACE_REALPATH@
 
500
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
501
#   define realpath rpl_realpath
 
502
#  endif
 
503
_GL_FUNCDECL_RPL (realpath, char *, (const char *name, char *resolved)
 
504
                                    _GL_ARG_NONNULL ((1)));
 
505
_GL_CXXALIAS_RPL (realpath, char *, (const char *name, char *resolved));
 
506
# else
 
507
#  if !@HAVE_REALPATH@
 
508
_GL_FUNCDECL_SYS (realpath, char *, (const char *name, char *resolved)
 
509
                                    _GL_ARG_NONNULL ((1)));
 
510
#  endif
 
511
_GL_CXXALIAS_SYS (realpath, char *, (const char *name, char *resolved));
 
512
# endif
 
513
_GL_CXXALIASWARN (realpath);
 
514
#elif defined GNULIB_POSIXCHECK
 
515
# undef realpath
 
516
# if HAVE_RAW_DECL_REALPATH
 
517
_GL_WARN_ON_USE (realpath, "realpath is unportable - use gnulib module "
 
518
                 "canonicalize or canonicalize-lgpl for portability");
 
519
# endif
 
520
#endif
279
521
 
280
522
#if @GNULIB_RPMATCH@
281
 
# if !@HAVE_RPMATCH@
282
523
/* Test a user response to a question.
283
524
   Return 1 if it is affirmative, 0 if it is negative, or -1 if not clear.  */
284
 
extern int rpmatch (const char *response);
 
525
# if !@HAVE_RPMATCH@
 
526
_GL_FUNCDECL_SYS (rpmatch, int, (const char *response) _GL_ARG_NONNULL ((1)));
285
527
# endif
 
528
_GL_CXXALIAS_SYS (rpmatch, int, (const char *response));
 
529
_GL_CXXALIASWARN (rpmatch);
286
530
#elif defined GNULIB_POSIXCHECK
287
531
# undef rpmatch
288
 
# define rpmatch(r) \
289
 
    (GL_LINK_WARNING ("rpmatch is unportable - " \
290
 
                      "use gnulib module rpmatch for portability"), \
291
 
     rpmatch (r))
 
532
# if HAVE_RAW_DECL_RPMATCH
 
533
_GL_WARN_ON_USE (rpmatch, "rpmatch is unportable - "
 
534
                 "use gnulib module rpmatch for portability");
 
535
# endif
292
536
#endif
293
537
 
294
 
 
295
538
#if @GNULIB_SETENV@
296
 
# if !@HAVE_SETENV@
297
539
/* Set NAME to VALUE in the environment.
298
540
   If REPLACE is nonzero, overwrite an existing value.  */
299
 
extern int setenv (const char *name, const char *value, int replace);
300
 
# endif
301
 
#endif
302
 
 
303
 
 
304
 
#if @GNULIB_UNSETENV@
305
 
# if @HAVE_UNSETENV@
306
 
#  if @VOID_UNSETENV@
307
 
/* On some systems, unsetenv() returns void.
308
 
   This is the case for MacOS X 10.3, FreeBSD 4.8, NetBSD 1.6, OpenBSD 3.4.  */
309
 
#   define unsetenv(name) ((unsetenv)(name), 0)
 
541
# if @REPLACE_SETENV@
 
542
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
543
#   undef setenv
 
544
#   define setenv rpl_setenv
310
545
#  endif
 
546
_GL_FUNCDECL_RPL (setenv, int,
 
547
                  (const char *name, const char *value, int replace)
 
548
                  _GL_ARG_NONNULL ((1)));
 
549
_GL_CXXALIAS_RPL (setenv, int,
 
550
                  (const char *name, const char *value, int replace));
311
551
# else
312
 
/* Remove the variable NAME from the environment.  */
313
 
extern int unsetenv (const char *name);
 
552
#  if !@HAVE_SETENV@
 
553
_GL_FUNCDECL_SYS (setenv, int,
 
554
                  (const char *name, const char *value, int replace)
 
555
                  _GL_ARG_NONNULL ((1)));
 
556
#  endif
 
557
_GL_CXXALIAS_SYS (setenv, int,
 
558
                  (const char *name, const char *value, int replace));
 
559
# endif
 
560
_GL_CXXALIASWARN (setenv);
 
561
#elif defined GNULIB_POSIXCHECK
 
562
# undef setenv
 
563
# if HAVE_RAW_DECL_SETENV
 
564
_GL_WARN_ON_USE (setenv, "setenv is unportable - "
 
565
                 "use gnulib module setenv for portability");
314
566
# endif
315
567
#endif
316
568
 
317
 
 
318
569
#if @GNULIB_STRTOD@
 
570
 /* Parse a double from STRING, updating ENDP if appropriate.  */
319
571
# if @REPLACE_STRTOD@
320
 
#  define strtod rpl_strtod
321
 
# endif
322
 
# if !@HAVE_STRTOD@ || @REPLACE_STRTOD@
323
 
 /* Parse a double from STRING, updating ENDP if appropriate.  */
324
 
extern double strtod (const char *str, char **endp);
325
 
# endif
 
572
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
573
#   define strtod rpl_strtod
 
574
#  endif
 
575
_GL_FUNCDECL_RPL (strtod, double, (const char *str, char **endp)
 
576
                                  _GL_ARG_NONNULL ((1)));
 
577
_GL_CXXALIAS_RPL (strtod, double, (const char *str, char **endp));
 
578
# else
 
579
#  if !@HAVE_STRTOD@
 
580
_GL_FUNCDECL_SYS (strtod, double, (const char *str, char **endp)
 
581
                                  _GL_ARG_NONNULL ((1)));
 
582
#  endif
 
583
_GL_CXXALIAS_SYS (strtod, double, (const char *str, char **endp));
 
584
# endif
 
585
_GL_CXXALIASWARN (strtod);
326
586
#elif defined GNULIB_POSIXCHECK
327
587
# undef strtod
328
 
# define strtod(s, e)                           \
329
 
    (GL_LINK_WARNING ("strtod is unportable - " \
330
 
                      "use gnulib module strtod for portability"), \
331
 
     strtod (s, e))
 
588
# if HAVE_RAW_DECL_STRTOD
 
589
_GL_WARN_ON_USE (strtod, "strtod is unportable - "
 
590
                 "use gnulib module strtod for portability");
 
591
# endif
332
592
#endif
333
593
 
334
 
 
335
594
#if @GNULIB_STRTOLL@
336
 
# if !@HAVE_STRTOLL@
337
595
/* Parse a signed integer whose textual representation starts at STRING.
338
596
   The integer is expected to be in base BASE (2 <= BASE <= 36); if BASE == 0,
339
597
   it may be decimal or octal (with prefix "0") or hexadecimal (with prefix
342
600
   stored in *ENDPTR.
343
601
   Upon overflow, the return value is LLONG_MAX or LLONG_MIN, and errno is set
344
602
   to ERANGE.  */
345
 
extern long long strtoll (const char *string, char **endptr, int base);
 
603
# if !@HAVE_STRTOLL@
 
604
_GL_FUNCDECL_SYS (strtoll, long long,
 
605
                  (const char *string, char **endptr, int base)
 
606
                  _GL_ARG_NONNULL ((1)));
346
607
# endif
 
608
_GL_CXXALIAS_SYS (strtoll, long long,
 
609
                  (const char *string, char **endptr, int base));
 
610
_GL_CXXALIASWARN (strtoll);
347
611
#elif defined GNULIB_POSIXCHECK
348
612
# undef strtoll
349
 
# define strtoll(s,e,b) \
350
 
    (GL_LINK_WARNING ("strtoll is unportable - " \
351
 
                      "use gnulib module strtoll for portability"), \
352
 
     strtoll (s, e, b))
 
613
# if HAVE_RAW_DECL_STRTOLL
 
614
_GL_WARN_ON_USE (strtoll, "strtoll is unportable - "
 
615
                 "use gnulib module strtoll for portability");
 
616
# endif
353
617
#endif
354
618
 
355
 
 
356
619
#if @GNULIB_STRTOULL@
357
 
# if !@HAVE_STRTOULL@
358
620
/* Parse an unsigned integer whose textual representation starts at STRING.
359
621
   The integer is expected to be in base BASE (2 <= BASE <= 36); if BASE == 0,
360
622
   it may be decimal or octal (with prefix "0") or hexadecimal (with prefix
363
625
   stored in *ENDPTR.
364
626
   Upon overflow, the return value is ULLONG_MAX, and errno is set to
365
627
   ERANGE.  */
366
 
extern unsigned long long strtoull (const char *string, char **endptr, int base);
 
628
# if !@HAVE_STRTOULL@
 
629
_GL_FUNCDECL_SYS (strtoull, unsigned long long,
 
630
                  (const char *string, char **endptr, int base)
 
631
                  _GL_ARG_NONNULL ((1)));
367
632
# endif
 
633
_GL_CXXALIAS_SYS (strtoull, unsigned long long,
 
634
                  (const char *string, char **endptr, int base));
 
635
_GL_CXXALIASWARN (strtoull);
368
636
#elif defined GNULIB_POSIXCHECK
369
637
# undef strtoull
370
 
# define strtoull(s,e,b) \
371
 
    (GL_LINK_WARNING ("strtoull is unportable - " \
372
 
                      "use gnulib module strtoull for portability"), \
373
 
     strtoull (s, e, b))
374
 
#endif
375
 
 
376
 
 
377
 
#ifdef __cplusplus
378
 
}
379
 
#endif
 
638
# if HAVE_RAW_DECL_STRTOULL
 
639
_GL_WARN_ON_USE (strtoull, "strtoull is unportable - "
 
640
                 "use gnulib module strtoull for portability");
 
641
# endif
 
642
#endif
 
643
 
 
644
#if @GNULIB_UNLOCKPT@
 
645
/* Unlock the slave side of the pseudo-terminal whose master side is specified
 
646
   by FD, so that it can be opened.  */
 
647
# if !@HAVE_UNLOCKPT@
 
648
_GL_FUNCDECL_SYS (unlockpt, int, (int fd));
 
649
# endif
 
650
_GL_CXXALIAS_SYS (unlockpt, int, (int fd));
 
651
_GL_CXXALIASWARN (unlockpt);
 
652
#elif defined GNULIB_POSIXCHECK
 
653
# undef unlockpt
 
654
# if HAVE_RAW_DECL_UNLOCKPT
 
655
_GL_WARN_ON_USE (ptsname, "unlockpt is not portable - "
 
656
                 "use gnulib module unlockpt for portability");
 
657
# endif
 
658
#endif
 
659
 
 
660
#if @GNULIB_UNSETENV@
 
661
/* Remove the variable NAME from the environment.  */
 
662
# if @REPLACE_UNSETENV@
 
663
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
664
#   undef unsetenv
 
665
#   define unsetenv rpl_unsetenv
 
666
#  endif
 
667
_GL_FUNCDECL_RPL (unsetenv, int, (const char *name) _GL_ARG_NONNULL ((1)));
 
668
_GL_CXXALIAS_RPL (unsetenv, int, (const char *name));
 
669
# else
 
670
#  if !@HAVE_UNSETENV@
 
671
_GL_FUNCDECL_SYS (unsetenv, int, (const char *name) _GL_ARG_NONNULL ((1)));
 
672
#  endif
 
673
_GL_CXXALIAS_SYS (unsetenv, int, (const char *name));
 
674
# endif
 
675
_GL_CXXALIASWARN (unsetenv);
 
676
#elif defined GNULIB_POSIXCHECK
 
677
# undef unsetenv
 
678
# if HAVE_RAW_DECL_UNSETENV
 
679
_GL_WARN_ON_USE (unsetenv, "unsetenv is unportable - "
 
680
                 "use gnulib module unsetenv for portability");
 
681
# endif
 
682
#endif
 
683
 
380
684
 
381
685
#endif /* _GL_STDLIB_H */
382
686
#endif /* _GL_STDLIB_H */