1/* DO NOT EDIT! GENERATED AUTOMATICALLY! */
2/* A more-standard <time.h>.
3
4 Copyright (C) 2007-2019 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, see <https://www.gnu.org/licenses/>. */
18
19#if __GNUC__ >= 3
20#pragma GCC system_header
21#endif
22
23
24/* Don't get in the way of glibc when it includes time.h merely to
25 declare a few standard symbols, rather than to declare all the
26 symbols. (However, skip this for MinGW as it treats __need_time_t
27 incompatibly.) Also, Solaris 8 <time.h> eventually includes itself
28 recursively; if that is happening, just include the system <time.h>
29 without adding our own declarations. */
30#if (((defined __need_time_t || defined __need_clock_t \
31 || defined __need_timespec) \
32 && !defined __MINGW32__) \
33 || defined _GL_TIME_H)
34
35# include_next <time.h>
36
37#else
38
39# define _GL_TIME_H
40
41# include_next <time.h>
42
43/* NetBSD 5.0 mis-defines NULL. */
44# include <stddef.h>
45
46/* The definitions of _GL_FUNCDECL_RPL etc. are copied here. */
47/* C++ compatible function declaration macros.
48 Copyright (C) 2010-2019 Free Software Foundation, Inc.
49
50 This program is free software: you can redistribute it and/or modify it
51 under the terms of the GNU General Public License as published
52 by the Free Software Foundation; either version 3 of the License, or
53 (at your option) any later version.
54
55 This program is distributed in the hope that it will be useful,
56 but WITHOUT ANY WARRANTY; without even the implied warranty of
57 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
58 General Public License for more details.
59
60 You should have received a copy of the GNU General Public License
61 along with this program. If not, see <https://www.gnu.org/licenses/>. */
62
63#ifndef _GL_CXXDEFS_H
64#define _GL_CXXDEFS_H
65
66/* Begin/end the GNULIB_NAMESPACE namespace. */
67#if defined __cplusplus && defined GNULIB_NAMESPACE
68# define _GL_BEGIN_NAMESPACE namespace GNULIB_NAMESPACE {
69# define _GL_END_NAMESPACE }
70#else
71# define _GL_BEGIN_NAMESPACE
72# define _GL_END_NAMESPACE
73#endif
74
75/* The three most frequent use cases of these macros are:
76
77 * For providing a substitute for a function that is missing on some
78 platforms, but is declared and works fine on the platforms on which
79 it exists:
80
81 #if @GNULIB_FOO@
82 # if !@HAVE_FOO@
83 _GL_FUNCDECL_SYS (foo, ...);
84 # endif
85 _GL_CXXALIAS_SYS (foo, ...);
86 _GL_CXXALIASWARN (foo);
87 #elif defined GNULIB_POSIXCHECK
88 ...
89 #endif
90
91 * For providing a replacement for a function that exists on all platforms,
92 but is broken/insufficient and needs to be replaced on some platforms:
93
94 #if @GNULIB_FOO@
95 # if @REPLACE_FOO@
96 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)
97 # undef foo
98 # define foo rpl_foo
99 # endif
100 _GL_FUNCDECL_RPL (foo, ...);
101 _GL_CXXALIAS_RPL (foo, ...);
102 # else
103 _GL_CXXALIAS_SYS (foo, ...);
104 # endif
105 _GL_CXXALIASWARN (foo);
106 #elif defined GNULIB_POSIXCHECK
107 ...
108 #endif
109
110 * For providing a replacement for a function that exists on some platforms
111 but is broken/insufficient and needs to be replaced on some of them and
112 is additionally either missing or undeclared on some other platforms:
113
114 #if @GNULIB_FOO@
115 # if @REPLACE_FOO@
116 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)
117 # undef foo
118 # define foo rpl_foo
119 # endif
120 _GL_FUNCDECL_RPL (foo, ...);
121 _GL_CXXALIAS_RPL (foo, ...);
122 # else
123 # if !@HAVE_FOO@ or if !@HAVE_DECL_FOO@
124 _GL_FUNCDECL_SYS (foo, ...);
125 # endif
126 _GL_CXXALIAS_SYS (foo, ...);
127 # endif
128 _GL_CXXALIASWARN (foo);
129 #elif defined GNULIB_POSIXCHECK
130 ...
131 #endif
132*/
133
134/* _GL_EXTERN_C declaration;
135 performs the declaration with C linkage. */
136#if defined __cplusplus
137# define _GL_EXTERN_C extern "C"
138#else
139# define _GL_EXTERN_C extern
140#endif
141
142/* _GL_FUNCDECL_RPL (func, rettype, parameters_and_attributes);
143 declares a replacement function, named rpl_func, with the given prototype,
144 consisting of return type, parameters, and attributes.
145 Example:
146 _GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...)
147 _GL_ARG_NONNULL ((1)));
148 */
149#define _GL_FUNCDECL_RPL(func,rettype,parameters_and_attributes) \
150 _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters_and_attributes)
151#define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters_and_attributes) \
152 _GL_EXTERN_C rettype rpl_func parameters_and_attributes
153
154/* _GL_FUNCDECL_SYS (func, rettype, parameters_and_attributes);
155 declares the system function, named func, with the given prototype,
156 consisting of return type, parameters, and attributes.
157 Example:
158 _GL_FUNCDECL_SYS (open, int, (const char *filename, int flags, ...)
159 _GL_ARG_NONNULL ((1)));
160 */
161#define _GL_FUNCDECL_SYS(func,rettype,parameters_and_attributes) \
162 _GL_EXTERN_C rettype func parameters_and_attributes
163
164/* _GL_CXXALIAS_RPL (func, rettype, parameters);
165 declares a C++ alias called GNULIB_NAMESPACE::func
166 that redirects to rpl_func, if GNULIB_NAMESPACE is defined.
167 Example:
168 _GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...));
169
170 Wrapping rpl_func in an object with an inline conversion operator
171 avoids a reference to rpl_func unless GNULIB_NAMESPACE::func is
172 actually used in the program. */
173#define _GL_CXXALIAS_RPL(func,rettype,parameters) \
174 _GL_CXXALIAS_RPL_1 (func, rpl_##func, rettype, parameters)
175#if defined __cplusplus && defined GNULIB_NAMESPACE
176# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \
177 namespace GNULIB_NAMESPACE \
178 { \
179 static const struct _gl_ ## func ## _wrapper \
180 { \
181 typedef rettype (*type) parameters; \
182 \
183 inline operator type () const \
184 { \
185 return ::rpl_func; \
186 } \
187 } func = {}; \
188 } \
189 _GL_EXTERN_C int _gl_cxxalias_dummy
190#else
191# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \
192 _GL_EXTERN_C int _gl_cxxalias_dummy
193#endif
194
195/* _GL_CXXALIAS_RPL_CAST_1 (func, rpl_func, rettype, parameters);
196 is like _GL_CXXALIAS_RPL_1 (func, rpl_func, rettype, parameters);
197 except that the C function rpl_func may have a slightly different
198 declaration. A cast is used to silence the "invalid conversion" error
199 that would otherwise occur. */
200#if defined __cplusplus && defined GNULIB_NAMESPACE
201# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \
202 namespace GNULIB_NAMESPACE \
203 { \
204 static const struct _gl_ ## func ## _wrapper \
205 { \
206 typedef rettype (*type) parameters; \
207 \
208 inline operator type () const \
209 { \
210 return reinterpret_cast<type>(::rpl_func); \
211 } \
212 } func = {}; \
213 } \
214 _GL_EXTERN_C int _gl_cxxalias_dummy
215#else
216# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \
217 _GL_EXTERN_C int _gl_cxxalias_dummy
218#endif
219
220/* _GL_CXXALIAS_SYS (func, rettype, parameters);
221 declares a C++ alias called GNULIB_NAMESPACE::func
222 that redirects to the system provided function func, if GNULIB_NAMESPACE
223 is defined.
224 Example:
225 _GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...));
226
227 Wrapping func in an object with an inline conversion operator
228 avoids a reference to func unless GNULIB_NAMESPACE::func is
229 actually used in the program. */
230#if defined __cplusplus && defined GNULIB_NAMESPACE
231# define _GL_CXXALIAS_SYS(func,rettype,parameters) \
232 namespace GNULIB_NAMESPACE \
233 { \
234 static const struct _gl_ ## func ## _wrapper \
235 { \
236 typedef rettype (*type) parameters; \
237 \
238 inline operator type () const \
239 { \
240 return ::func; \
241 } \
242 } func = {}; \
243 } \
244 _GL_EXTERN_C int _gl_cxxalias_dummy
245#else
246# define _GL_CXXALIAS_SYS(func,rettype,parameters) \
247 _GL_EXTERN_C int _gl_cxxalias_dummy
248#endif
249
250/* _GL_CXXALIAS_SYS_CAST (func, rettype, parameters);
251 is like _GL_CXXALIAS_SYS (func, rettype, parameters);
252 except that the C function func may have a slightly different declaration.
253 A cast is used to silence the "invalid conversion" error that would
254 otherwise occur. */
255#if defined __cplusplus && defined GNULIB_NAMESPACE
256# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \
257 namespace GNULIB_NAMESPACE \
258 { \
259 static const struct _gl_ ## func ## _wrapper \
260 { \
261 typedef rettype (*type) parameters; \
262 \
263 inline operator type () const \
264 { \
265 return reinterpret_cast<type>(::func); \
266 } \
267 } func = {}; \
268 } \
269 _GL_EXTERN_C int _gl_cxxalias_dummy
270#else
271# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \
272 _GL_EXTERN_C int _gl_cxxalias_dummy
273#endif
274
275/* _GL_CXXALIAS_SYS_CAST2 (func, rettype, parameters, rettype2, parameters2);
276 is like _GL_CXXALIAS_SYS (func, rettype, parameters);
277 except that the C function is picked among a set of overloaded functions,
278 namely the one with rettype2 and parameters2. Two consecutive casts
279 are used to silence the "cannot find a match" and "invalid conversion"
280 errors that would otherwise occur. */
281#if defined __cplusplus && defined GNULIB_NAMESPACE
282 /* The outer cast must be a reinterpret_cast.
283 The inner cast: When the function is defined as a set of overloaded
284 functions, it works as a static_cast<>, choosing the designated variant.
285 When the function is defined as a single variant, it works as a
286 reinterpret_cast<>. The parenthesized cast syntax works both ways. */
287# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \
288 namespace GNULIB_NAMESPACE \
289 { \
290 static const struct _gl_ ## func ## _wrapper \
291 { \
292 typedef rettype (*type) parameters; \
293 \
294 inline operator type () const \
295 { \
296 return reinterpret_cast<type>((rettype2 (*) parameters2)(::func)); \
297 } \
298 } func = {}; \
299 } \
300 _GL_EXTERN_C int _gl_cxxalias_dummy
301#else
302# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \
303 _GL_EXTERN_C int _gl_cxxalias_dummy
304#endif
305
306/* _GL_CXXALIASWARN (func);
307 causes a warning to be emitted when ::func is used but not when
308 GNULIB_NAMESPACE::func is used. func must be defined without overloaded
309 variants. */
310#if defined __cplusplus && defined GNULIB_NAMESPACE
311# define _GL_CXXALIASWARN(func) \
312 _GL_CXXALIASWARN_1 (func, GNULIB_NAMESPACE)
313# define _GL_CXXALIASWARN_1(func,namespace) \
314 _GL_CXXALIASWARN_2 (func, namespace)
315/* To work around GCC bug <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,
316 we enable the warning only when not optimizing. */
317# if !__OPTIMIZE__
318# define _GL_CXXALIASWARN_2(func,namespace) \
319 _GL_WARN_ON_USE (func, \
320 "The symbol ::" #func " refers to the system function. " \
321 "Use " #namespace "::" #func " instead.")
322# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
323# define _GL_CXXALIASWARN_2(func,namespace) \
324 extern __typeof__ (func) func
325# else
326# define _GL_CXXALIASWARN_2(func,namespace) \
327 _GL_EXTERN_C int _gl_cxxalias_dummy
328# endif
329#else
330# define _GL_CXXALIASWARN(func) \
331 _GL_EXTERN_C int _gl_cxxalias_dummy
332#endif
333
334/* _GL_CXXALIASWARN1 (func, rettype, parameters_and_attributes);
335 causes a warning to be emitted when the given overloaded variant of ::func
336 is used but not when GNULIB_NAMESPACE::func is used. */
337#if defined __cplusplus && defined GNULIB_NAMESPACE
338# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \
339 _GL_CXXALIASWARN1_1 (func, rettype, parameters_and_attributes, \
340 GNULIB_NAMESPACE)
341# define _GL_CXXALIASWARN1_1(func,rettype,parameters_and_attributes,namespace) \
342 _GL_CXXALIASWARN1_2 (func, rettype, parameters_and_attributes, namespace)
343/* To work around GCC bug <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,
344 we enable the warning only when not optimizing. */
345# if !__OPTIMIZE__
346# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
347 _GL_WARN_ON_USE_CXX (func, rettype, parameters_and_attributes, \
348 "The symbol ::" #func " refers to the system function. " \
349 "Use " #namespace "::" #func " instead.")
350# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
351# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
352 extern __typeof__ (func) func
353# else
354# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
355 _GL_EXTERN_C int _gl_cxxalias_dummy
356# endif
357#else
358# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \
359 _GL_EXTERN_C int _gl_cxxalias_dummy
360#endif
361
362#endif /* _GL_CXXDEFS_H */
363
364/* The definition of _GL_ARG_NONNULL is copied here. */
365/* A C macro for declaring that specific arguments must not be NULL.
366 Copyright (C) 2009-2019 Free Software Foundation, Inc.
367
368 This program is free software: you can redistribute it and/or modify it
369 under the terms of the GNU General Public License as published
370 by the Free Software Foundation; either version 3 of the License, or
371 (at your option) any later version.
372
373 This program is distributed in the hope that it will be useful,
374 but WITHOUT ANY WARRANTY; without even the implied warranty of
375 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
376 General Public License for more details.
377
378 You should have received a copy of the GNU General Public License
379 along with this program. If not, see <https://www.gnu.org/licenses/>. */
380
381/* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools
382 that the values passed as arguments n, ..., m must be non-NULL pointers.
383 n = 1 stands for the first argument, n = 2 for the second argument etc. */
384#ifndef _GL_ARG_NONNULL
385# if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || __GNUC__ > 3
386# define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params))
387# else
388# define _GL_ARG_NONNULL(params)
389# endif
390#endif
391
392/* The definition of _GL_WARN_ON_USE is copied here. */
393/* A C macro for emitting warnings if a function is used.
394 Copyright (C) 2010-2019 Free Software Foundation, Inc.
395
396 This program is free software: you can redistribute it and/or modify it
397 under the terms of the GNU General Public License as published
398 by the Free Software Foundation; either version 3 of the License, or
399 (at your option) any later version.
400
401 This program is distributed in the hope that it will be useful,
402 but WITHOUT ANY WARRANTY; without even the implied warranty of
403 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
404 General Public License for more details.
405
406 You should have received a copy of the GNU General Public License
407 along with this program. If not, see <https://www.gnu.org/licenses/>. */
408
409/* _GL_WARN_ON_USE (function, "literal string") issues a declaration
410 for FUNCTION which will then trigger a compiler warning containing
411 the text of "literal string" anywhere that function is called, if
412 supported by the compiler. If the compiler does not support this
413 feature, the macro expands to an unused extern declaration.
414
415 _GL_WARN_ON_USE_ATTRIBUTE ("literal string") expands to the
416 attribute used in _GL_WARN_ON_USE. If the compiler does not support
417 this feature, it expands to empty.
418
419 These macros are useful for marking a function as a potential
420 portability trap, with the intent that "literal string" include
421 instructions on the replacement function that should be used
422 instead.
423 _GL_WARN_ON_USE is for functions with 'extern' linkage.
424 _GL_WARN_ON_USE_ATTRIBUTE is for functions with 'static' or 'inline'
425 linkage.
426
427 However, one of the reasons that a function is a portability trap is
428 if it has the wrong signature. Declaring FUNCTION with a different
429 signature in C is a compilation error, so this macro must use the
430 same type as any existing declaration so that programs that avoid
431 the problematic FUNCTION do not fail to compile merely because they
432 included a header that poisoned the function. But this implies that
433 _GL_WARN_ON_USE is only safe to use if FUNCTION is known to already
434 have a declaration. Use of this macro implies that there must not
435 be any other macro hiding the declaration of FUNCTION; but
436 undefining FUNCTION first is part of the poisoning process anyway
437 (although for symbols that are provided only via a macro, the result
438 is a compilation error rather than a warning containing
439 "literal string"). Also note that in C++, it is only safe to use if
440 FUNCTION has no overloads.
441
442 For an example, it is possible to poison 'getline' by:
443 - adding a call to gl_WARN_ON_USE_PREPARE([[#include <stdio.h>]],
444 [getline]) in configure.ac, which potentially defines
445 HAVE_RAW_DECL_GETLINE
446 - adding this code to a header that wraps the system <stdio.h>:
447 #undef getline
448 #if HAVE_RAW_DECL_GETLINE
449 _GL_WARN_ON_USE (getline, "getline is required by POSIX 2008, but"
450 "not universally present; use the gnulib module getline");
451 #endif
452
453 It is not possible to directly poison global variables. But it is
454 possible to write a wrapper accessor function, and poison that
455 (less common usage, like &environ, will cause a compilation error
456 rather than issue the nice warning, but the end result of informing
457 the developer about their portability problem is still achieved):
458 #if HAVE_RAW_DECL_ENVIRON
459 static char ***
460 rpl_environ (void) { return &environ; }
461 _GL_WARN_ON_USE (rpl_environ, "environ is not always properly declared");
462 # undef environ
463 # define environ (*rpl_environ ())
464 #endif
465 or better (avoiding contradictory use of 'static' and 'extern'):
466 #if HAVE_RAW_DECL_ENVIRON
467 static char ***
468 _GL_WARN_ON_USE_ATTRIBUTE ("environ is not always properly declared")
469 rpl_environ (void) { return &environ; }
470 # undef environ
471 # define environ (*rpl_environ ())
472 #endif
473 */
474#ifndef _GL_WARN_ON_USE
475
476# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)
477/* A compiler attribute is available in gcc versions 4.3.0 and later. */
478# define _GL_WARN_ON_USE(function, message) \
479extern __typeof__ (function) function __attribute__ ((__warning__ (message)))
480# define _GL_WARN_ON_USE_ATTRIBUTE(message) \
481 __attribute__ ((__warning__ (message)))
482# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
483/* Verify the existence of the function. */
484# define _GL_WARN_ON_USE(function, message) \
485extern __typeof__ (function) function
486# define _GL_WARN_ON_USE_ATTRIBUTE(message)
487# else /* Unsupported. */
488# define _GL_WARN_ON_USE(function, message) \
489_GL_WARN_EXTERN_C int _gl_warn_on_use
490# define _GL_WARN_ON_USE_ATTRIBUTE(message)
491# endif
492#endif
493
494/* _GL_WARN_ON_USE_CXX (function, rettype, parameters_and_attributes, "string")
495 is like _GL_WARN_ON_USE (function, "string"), except that the function is
496 declared with the given prototype, consisting of return type, parameters,
497 and attributes.
498 This variant is useful for overloaded functions in C++. _GL_WARN_ON_USE does
499 not work in this case. */
500#ifndef _GL_WARN_ON_USE_CXX
501# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)
502# define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
503extern rettype function parameters_and_attributes \
504 __attribute__ ((__warning__ (msg)))
505# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
506/* Verify the existence of the function. */
507# define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
508extern rettype function parameters_and_attributes
509# else /* Unsupported. */
510# define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
511_GL_WARN_EXTERN_C int _gl_warn_on_use
512# endif
513#endif
514
515/* _GL_WARN_EXTERN_C declaration;
516 performs the declaration with C linkage. */
517#ifndef _GL_WARN_EXTERN_C
518# if defined __cplusplus
519# define _GL_WARN_EXTERN_C extern "C"
520# else
521# define _GL_WARN_EXTERN_C extern
522# endif
523#endif
524
525/* Some systems don't define struct timespec (e.g., AIX 4.1).
526 Or they define it with the wrong member names or define it in <sys/time.h>
527 (e.g., FreeBSD circa 1997). Stock Mingw prior to 3.0 does not define it,
528 but the pthreads-win32 library defines it in <pthread.h>. */
529# if ! 1
530# if 0
531# include <sys/time.h>
532# elif 0
533# include <pthread.h>
534# elif 0
535# include <unistd.h>
536# else
537
538# ifdef __cplusplus
539extern "C" {
540# endif
541
542# if !GNULIB_defined_struct_timespec
543# undef timespec
544# define timespec rpl_timespec
545struct timespec
546{
547 time_t tv_sec;
548 long int tv_nsec;
549};
550# define GNULIB_defined_struct_timespec 1
551# endif
552
553# ifdef __cplusplus
554}
555# endif
556
557# endif
558# endif
559
560# if !GNULIB_defined_struct_time_t_must_be_integral
561/* Per http://austingroupbugs.net/view.php?id=327, POSIX requires
562 time_t to be an integer type, even though C99 permits floating
563 point. We don't know of any implementation that uses floating
564 point, and it is much easier to write code that doesn't have to
565 worry about that corner case, so we force the issue. */
566struct __time_t_must_be_integral {
567 unsigned int __floating_time_t_unsupported : (time_t) 1;
568};
569# define GNULIB_defined_struct_time_t_must_be_integral 1
570# endif
571
572/* Sleep for at least RQTP seconds unless interrupted, If interrupted,
573 return -1 and store the remaining time into RMTP. See
574 <http://www.opengroup.org/susv3xsh/nanosleep.html>. */
575# if 0
576# if GNULIB_PORTCHECK
577# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
578# define nanosleep rpl_nanosleep
579# endif
580_GL_FUNCDECL_RPL (nanosleep, int,
581 (struct timespec const *__rqtp, struct timespec *__rmtp)
582 _GL_ARG_NONNULL ((1)));
583_GL_CXXALIAS_RPL (nanosleep, int,
584 (struct timespec const *__rqtp, struct timespec *__rmtp));
585# else
586# if ! 1
587_GL_FUNCDECL_SYS (nanosleep, int,
588 (struct timespec const *__rqtp, struct timespec *__rmtp)
589 _GL_ARG_NONNULL ((1)));
590# endif
591_GL_CXXALIAS_SYS (nanosleep, int,
592 (struct timespec const *__rqtp, struct timespec *__rmtp));
593# endif
594_GL_CXXALIASWARN (nanosleep);
595# endif
596
597/* Initialize time conversion information. */
598# if 0
599# if GNULIB_PORTCHECK
600# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
601# undef tzset
602# define tzset rpl_tzset
603# endif
604_GL_FUNCDECL_RPL (tzset, void, (void));
605_GL_CXXALIAS_RPL (tzset, void, (void));
606# else
607# if ! 1
608_GL_FUNCDECL_SYS (tzset, void, (void));
609# endif
610_GL_CXXALIAS_SYS (tzset, void, (void));
611# endif
612_GL_CXXALIASWARN (tzset);
613# endif
614
615/* Return the 'time_t' representation of TP and normalize TP. */
616# if 0
617# if GNULIB_PORTCHECK
618# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
619# define mktime rpl_mktime
620# endif
621_GL_FUNCDECL_RPL (mktime, time_t, (struct tm *__tp) _GL_ARG_NONNULL ((1)));
622_GL_CXXALIAS_RPL (mktime, time_t, (struct tm *__tp));
623# else
624_GL_CXXALIAS_SYS (mktime, time_t, (struct tm *__tp));
625# endif
626_GL_CXXALIASWARN (mktime);
627# endif
628
629/* Convert TIMER to RESULT, assuming local time and UTC respectively. See
630 <http://www.opengroup.org/susv3xsh/localtime_r.html> and
631 <http://www.opengroup.org/susv3xsh/gmtime_r.html>. */
632# if 0
633# if GNULIB_PORTCHECK
634# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
635# undef localtime_r
636# define localtime_r rpl_localtime_r
637# endif
638_GL_FUNCDECL_RPL (localtime_r, struct tm *, (time_t const *restrict __timer,
639 struct tm *restrict __result)
640 _GL_ARG_NONNULL ((1, 2)));
641_GL_CXXALIAS_RPL (localtime_r, struct tm *, (time_t const *restrict __timer,
642 struct tm *restrict __result));
643# else
644# if ! 1
645_GL_FUNCDECL_SYS (localtime_r, struct tm *, (time_t const *restrict __timer,
646 struct tm *restrict __result)
647 _GL_ARG_NONNULL ((1, 2)));
648# endif
649_GL_CXXALIAS_SYS (localtime_r, struct tm *, (time_t const *restrict __timer,
650 struct tm *restrict __result));
651# endif
652# if 1
653_GL_CXXALIASWARN (localtime_r);
654# endif
655# if GNULIB_PORTCHECK
656# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
657# undef gmtime_r
658# define gmtime_r rpl_gmtime_r
659# endif
660_GL_FUNCDECL_RPL (gmtime_r, struct tm *, (time_t const *restrict __timer,
661 struct tm *restrict __result)
662 _GL_ARG_NONNULL ((1, 2)));
663_GL_CXXALIAS_RPL (gmtime_r, struct tm *, (time_t const *restrict __timer,
664 struct tm *restrict __result));
665# else
666# if ! 1
667_GL_FUNCDECL_SYS (gmtime_r, struct tm *, (time_t const *restrict __timer,
668 struct tm *restrict __result)
669 _GL_ARG_NONNULL ((1, 2)));
670# endif
671_GL_CXXALIAS_SYS (gmtime_r, struct tm *, (time_t const *restrict __timer,
672 struct tm *restrict __result));
673# endif
674# if 1
675_GL_CXXALIASWARN (gmtime_r);
676# endif
677# endif
678
679/* Convert TIMER to RESULT, assuming local time and UTC respectively. See
680 <http://www.opengroup.org/susv3xsh/localtime.html> and
681 <http://www.opengroup.org/susv3xsh/gmtime.html>. */
682# if 0 || 0
683# if 0
684# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
685# undef localtime
686# define localtime rpl_localtime
687# endif
688_GL_FUNCDECL_RPL (localtime, struct tm *, (time_t const *__timer)
689 _GL_ARG_NONNULL ((1)));
690_GL_CXXALIAS_RPL (localtime, struct tm *, (time_t const *__timer));
691# else
692_GL_CXXALIAS_SYS (localtime, struct tm *, (time_t const *__timer));
693# endif
694_GL_CXXALIASWARN (localtime);
695# endif
696
697# if 0 || 0
698# if 0
699# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
700# undef gmtime
701# define gmtime rpl_gmtime
702# endif
703_GL_FUNCDECL_RPL (gmtime, struct tm *, (time_t const *__timer)
704 _GL_ARG_NONNULL ((1)));
705_GL_CXXALIAS_RPL (gmtime, struct tm *, (time_t const *__timer));
706# else
707_GL_CXXALIAS_SYS (gmtime, struct tm *, (time_t const *__timer));
708# endif
709_GL_CXXALIASWARN (gmtime);
710# endif
711
712/* Parse BUF as a timestamp, assuming FORMAT specifies its layout, and store
713 the resulting broken-down time into TM. See
714 <http://www.opengroup.org/susv3xsh/strptime.html>. */
715# if 0
716# if ! 1
717_GL_FUNCDECL_SYS (strptime, char *, (char const *restrict __buf,
718 char const *restrict __format,
719 struct tm *restrict __tm)
720 _GL_ARG_NONNULL ((1, 2, 3)));
721# endif
722_GL_CXXALIAS_SYS (strptime, char *, (char const *restrict __buf,
723 char const *restrict __format,
724 struct tm *restrict __tm));
725_GL_CXXALIASWARN (strptime);
726# endif
727
728/* Convert *TP to a date and time string. See
729 <http://pubs.opengroup.org/onlinepubs/9699919799/functions/ctime.html>. */
730# if 0
731# if GNULIB_PORTCHECK
732# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
733# define ctime rpl_ctime
734# endif
735_GL_FUNCDECL_RPL (ctime, char *, (time_t const *__tp)
736 _GL_ARG_NONNULL ((1)));
737_GL_CXXALIAS_RPL (ctime, char *, (time_t const *__tp));
738# else
739_GL_CXXALIAS_SYS (ctime, char *, (time_t const *__tp));
740# endif
741_GL_CXXALIASWARN (ctime);
742# endif
743
744/* Convert *TP to a date and time string. See
745 <http://pubs.opengroup.org/onlinepubs/9699919799/functions/strftime.html>. */
746# if 0
747# if GNULIB_PORTCHECK
748# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
749# define strftime rpl_strftime
750# endif
751_GL_FUNCDECL_RPL (strftime, size_t, (char *__buf, size_t __bufsize,
752 const char *__fmt, const struct tm *__tp)
753 _GL_ARG_NONNULL ((1, 3, 4)));
754_GL_CXXALIAS_RPL (strftime, size_t, (char *__buf, size_t __bufsize,
755 const char *__fmt, const struct tm *__tp));
756# else
757_GL_CXXALIAS_SYS (strftime, size_t, (char *__buf, size_t __bufsize,
758 const char *__fmt, const struct tm *__tp));
759# endif
760_GL_CXXALIASWARN (strftime);
761# endif
762
763# if defined _GNU_SOURCE && 0 && ! 0
764typedef struct tm_zone *timezone_t;
765_GL_FUNCDECL_SYS (tzalloc, timezone_t, (char const *__name));
766_GL_CXXALIAS_SYS (tzalloc, timezone_t, (char const *__name));
767_GL_FUNCDECL_SYS (tzfree, void, (timezone_t __tz));
768_GL_CXXALIAS_SYS (tzfree, void, (timezone_t __tz));
769_GL_FUNCDECL_SYS (localtime_rz, struct tm *,
770 (timezone_t __tz, time_t const *restrict __timer,
771 struct tm *restrict __result) _GL_ARG_NONNULL ((2, 3)));
772_GL_CXXALIAS_SYS (localtime_rz, struct tm *,
773 (timezone_t __tz, time_t const *restrict __timer,
774 struct tm *restrict __result));
775_GL_FUNCDECL_SYS (mktime_z, time_t,
776 (timezone_t __tz, struct tm *restrict __result)
777 _GL_ARG_NONNULL ((2)));
778_GL_CXXALIAS_SYS (mktime_z, time_t,
779 (timezone_t __tz, struct tm *restrict __result));
780# endif
781
782/* Convert TM to a time_t value, assuming UTC. */
783# if 0
784# if GNULIB_PORTCHECK
785# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
786# undef timegm
787# define timegm rpl_timegm
788# endif
789_GL_FUNCDECL_RPL (timegm, time_t, (struct tm *__tm) _GL_ARG_NONNULL ((1)));
790_GL_CXXALIAS_RPL (timegm, time_t, (struct tm *__tm));
791# else
792# if ! 1
793_GL_FUNCDECL_SYS (timegm, time_t, (struct tm *__tm) _GL_ARG_NONNULL ((1)));
794# endif
795_GL_CXXALIAS_SYS (timegm, time_t, (struct tm *__tm));
796# endif
797_GL_CXXALIASWARN (timegm);
798# endif
799
800/* Encourage applications to avoid unsafe functions that can overrun
801 buffers when given outlandish struct tm values. Portable
802 applications should use strftime (or even sprintf) instead. */
803# if defined GNULIB_POSIXCHECK
804# undef asctime
805_GL_WARN_ON_USE (asctime, "asctime can overrun buffers in some cases - "
806 "better use strftime (or even sprintf) instead");
807# endif
808# if defined GNULIB_POSIXCHECK
809# undef asctime_r
810_GL_WARN_ON_USE (asctime, "asctime_r can overrun buffers in some cases - "
811 "better use strftime (or even sprintf) instead");
812# endif
813# if defined GNULIB_POSIXCHECK
814# undef ctime
815_GL_WARN_ON_USE (asctime, "ctime can overrun buffers in some cases - "
816 "better use strftime (or even sprintf) instead");
817# endif
818# if defined GNULIB_POSIXCHECK
819# undef ctime_r
820_GL_WARN_ON_USE (asctime, "ctime_r can overrun buffers in some cases - "
821 "better use strftime (or even sprintf) instead");
822# endif
823
824#endif
825