diff options
Diffstat (limited to 'gl/stdint_.h')
-rw-r--r-- | gl/stdint_.h | 489 |
1 files changed, 489 insertions, 0 deletions
diff --git a/gl/stdint_.h b/gl/stdint_.h new file mode 100644 index 00000000..64ec8c5b --- /dev/null +++ b/gl/stdint_.h | |||
@@ -0,0 +1,489 @@ | |||
1 | /* Copyright (C) 2001-2002, 2004-2007 Free Software Foundation, Inc. | ||
2 | Written by Paul Eggert, Bruno Haible, Sam Steingold, Peter Burwood. | ||
3 | This file is part of gnulib. | ||
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 2, 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_STDINT_H | ||
20 | #define _GL_STDINT_H | ||
21 | |||
22 | /* | ||
23 | * ISO C 99 <stdint.h> for platforms that lack it. | ||
24 | * <http://www.opengroup.org/susv3xbd/stdint.h.html> | ||
25 | */ | ||
26 | |||
27 | /* Get those types that are already defined in other system include | ||
28 | files, so that we can "#define int8_t signed char" below without | ||
29 | worrying about a later system include file containing a "typedef | ||
30 | signed char int8_t;" that will get messed up by our macro. Our | ||
31 | macros should all be consistent with the system versions, except | ||
32 | for the "fast" types and macros, which we recommend against using | ||
33 | in public interfaces due to compiler differences. */ | ||
34 | |||
35 | #if @HAVE_STDINT_H@ | ||
36 | # if defined __sgi && ! defined __c99 | ||
37 | /* Bypass IRIX's <stdint.h> if in C89 mode, since it merely annoys users | ||
38 | with "This header file is to be used only for c99 mode compilations" | ||
39 | diagnostics. */ | ||
40 | # define __STDINT_H__ | ||
41 | # endif | ||
42 | /* Other systems may have an incomplete or buggy <stdint.h>. | ||
43 | Include it before <inttypes.h>, since any "#include <stdint.h>" | ||
44 | in <inttypes.h> would reinclude us, skipping our contents because | ||
45 | _GL_STDINT_H is defined. */ | ||
46 | # include @ABSOLUTE_STDINT_H@ | ||
47 | #endif | ||
48 | |||
49 | /* <sys/types.h> defines some of the stdint.h types as well, on glibc, | ||
50 | IRIX 6.5, and OpenBSD 3.8 (via <machine/types.h>). | ||
51 | AIX 5.2 <sys/types.h> isn't needed and causes troubles. | ||
52 | MacOS X 10.4.6 <sys/types.h> includes <stdint.h> (which is us), but | ||
53 | relies on the system <stdint.h> definitions, so include | ||
54 | <sys/types.h> after @ABSOLUTE_STDINT_H@. */ | ||
55 | #if @HAVE_SYS_TYPES_H@ && ! defined _AIX | ||
56 | # include <sys/types.h> | ||
57 | #endif | ||
58 | |||
59 | /* Get LONG_MIN, LONG_MAX, ULONG_MAX. */ | ||
60 | #include <limits.h> | ||
61 | |||
62 | #if @HAVE_INTTYPES_H@ | ||
63 | /* In OpenBSD 3.8, <inttypes.h> includes <machine/types.h>, which defines | ||
64 | int{8,16,32,64}_t, uint{8,16,32,64}_t and __BIT_TYPES_DEFINED__. | ||
65 | <inttypes.h> also defines intptr_t and uintptr_t. */ | ||
66 | # define _GL_JUST_INCLUDE_ABSOLUTE_INTTYPES_H | ||
67 | # include <inttypes.h> | ||
68 | # undef _GL_JUST_INCLUDE_ABSOLUTE_INTTYPES_H | ||
69 | #elif @HAVE_SYS_INTTYPES_H@ | ||
70 | /* Solaris 7 <sys/inttypes.h> has the types except the *_fast*_t types, and | ||
71 | the macros except for *_FAST*_*, INTPTR_MIN, PTRDIFF_MIN, PTRDIFF_MAX. */ | ||
72 | # include <sys/inttypes.h> | ||
73 | #endif | ||
74 | |||
75 | #if @HAVE_SYS_BITYPES_H@ && ! defined __BIT_TYPES_DEFINED__ | ||
76 | /* Linux libc4 >= 4.6.7 and libc5 have a <sys/bitypes.h> that defines | ||
77 | int{8,16,32,64}_t and __BIT_TYPES_DEFINED__. In libc5 >= 5.2.2 it is | ||
78 | included by <sys/types.h>. */ | ||
79 | # include <sys/bitypes.h> | ||
80 | #endif | ||
81 | |||
82 | #if ! defined __cplusplus || defined __STDC_CONSTANT_MACROS | ||
83 | |||
84 | /* Get WCHAR_MIN, WCHAR_MAX. */ | ||
85 | # if ! (defined WCHAR_MIN && defined WCHAR_MAX) | ||
86 | # include <wchar.h> | ||
87 | # endif | ||
88 | |||
89 | #endif | ||
90 | |||
91 | /* Minimum and maximum values for a integer type under the usual assumption. | ||
92 | Return an unspecified value if BITS == 0, adding a check to pacify | ||
93 | picky compilers. */ | ||
94 | |||
95 | #define _STDINT_MIN(signed, bits, zero) \ | ||
96 | ((signed) ? (- ((zero) + 1) << ((bits) ? (bits) - 1 : 0)) : (zero)) | ||
97 | |||
98 | #define _STDINT_MAX(signed, bits, zero) \ | ||
99 | ((signed) \ | ||
100 | ? ~ _STDINT_MIN (signed, bits, zero) \ | ||
101 | : ((((zero) + 1) << ((bits) ? (bits) - 1 : 0)) - 1) * 2 + 1) | ||
102 | |||
103 | /* 7.18.1.1. Exact-width integer types */ | ||
104 | |||
105 | /* Here we assume a standard architecture where the hardware integer | ||
106 | types have 8, 16, 32, optionally 64 bits. */ | ||
107 | |||
108 | #undef int8_t | ||
109 | #undef uint8_t | ||
110 | #define int8_t signed char | ||
111 | #define uint8_t unsigned char | ||
112 | |||
113 | #undef int16_t | ||
114 | #undef uint16_t | ||
115 | #define int16_t short int | ||
116 | #define uint16_t unsigned short int | ||
117 | |||
118 | #undef int32_t | ||
119 | #undef uint32_t | ||
120 | #define int32_t int | ||
121 | #define uint32_t unsigned int | ||
122 | |||
123 | #undef int64_t | ||
124 | #if LONG_MAX >> 31 >> 31 == 1 | ||
125 | # define int64_t long int | ||
126 | #elif defined _MSC_VER | ||
127 | # define int64_t __int64 | ||
128 | #elif @HAVE_LONG_LONG_INT@ | ||
129 | # define int64_t long long int | ||
130 | #endif | ||
131 | |||
132 | #undef uint64_t | ||
133 | #if ULONG_MAX >> 31 >> 31 >> 1 == 1 | ||
134 | # define uint64_t unsigned long int | ||
135 | #elif defined _MSC_VER | ||
136 | # define uint64_t unsigned __int64 | ||
137 | #elif @HAVE_UNSIGNED_LONG_LONG_INT@ | ||
138 | # define uint64_t unsigned long long int | ||
139 | #endif | ||
140 | |||
141 | /* Avoid collision with Solaris 2.5.1 <pthread.h> etc. */ | ||
142 | #define _UINT8_T | ||
143 | #define _UINT32_T | ||
144 | #define _UINT64_T | ||
145 | |||
146 | |||
147 | /* 7.18.1.2. Minimum-width integer types */ | ||
148 | |||
149 | /* Here we assume a standard architecture where the hardware integer | ||
150 | types have 8, 16, 32, optionally 64 bits. Therefore the leastN_t types | ||
151 | are the same as the corresponding N_t types. */ | ||
152 | |||
153 | #undef int_least8_t | ||
154 | #undef uint_least8_t | ||
155 | #undef int_least16_t | ||
156 | #undef uint_least16_t | ||
157 | #undef int_least32_t | ||
158 | #undef uint_least32_t | ||
159 | #undef int_least64_t | ||
160 | #undef uint_least64_t | ||
161 | #define int_least8_t int8_t | ||
162 | #define uint_least8_t uint8_t | ||
163 | #define int_least16_t int16_t | ||
164 | #define uint_least16_t uint16_t | ||
165 | #define int_least32_t int32_t | ||
166 | #define uint_least32_t uint32_t | ||
167 | #ifdef int64_t | ||
168 | # define int_least64_t int64_t | ||
169 | #endif | ||
170 | #ifdef uint64_t | ||
171 | # define uint_least64_t uint64_t | ||
172 | #endif | ||
173 | |||
174 | /* 7.18.1.3. Fastest minimum-width integer types */ | ||
175 | |||
176 | /* Note: Other <stdint.h> substitutes may define these types differently. | ||
177 | It is not recommended to use these types in public header files. */ | ||
178 | |||
179 | /* Here we assume a standard architecture where the hardware integer | ||
180 | types have 8, 16, 32, optionally 64 bits. Therefore the fastN_t types | ||
181 | are taken from the same list of types. Assume that 'long int' | ||
182 | is fast enough for all narrower integers. */ | ||
183 | |||
184 | #undef int_fast8_t | ||
185 | #undef uint_fast8_t | ||
186 | #undef int_fast16_t | ||
187 | #undef uint_fast16_t | ||
188 | #undef int_fast32_t | ||
189 | #undef uint_fast32_t | ||
190 | #undef int_fast64_t | ||
191 | #undef uint_fast64_t | ||
192 | #define int_fast8_t long int | ||
193 | #define uint_fast8_t unsigned int_fast8_t | ||
194 | #define int_fast16_t long int | ||
195 | #define uint_fast16_t unsigned int_fast16_t | ||
196 | #define int_fast32_t long int | ||
197 | #define uint_fast32_t unsigned int_fast32_t | ||
198 | #ifdef int64_t | ||
199 | # define int_fast64_t int64_t | ||
200 | #endif | ||
201 | #ifdef uint64_t | ||
202 | # define uint_fast64_t uint64_t | ||
203 | #endif | ||
204 | |||
205 | /* 7.18.1.4. Integer types capable of holding object pointers */ | ||
206 | |||
207 | #undef intptr_t | ||
208 | #undef uintptr_t | ||
209 | #define intptr_t long int | ||
210 | #define uintptr_t unsigned long int | ||
211 | |||
212 | /* 7.18.1.5. Greatest-width integer types */ | ||
213 | |||
214 | /* Note: These types are compiler dependent. It may be unwise to use them in | ||
215 | public header files. */ | ||
216 | |||
217 | #undef intmax_t | ||
218 | #if @HAVE_LONG_LONG_INT@ && LONG_MAX >> 30 == 1 | ||
219 | # define intmax_t long long int | ||
220 | #elif defined int64_t | ||
221 | # define intmax_t int64_t | ||
222 | #else | ||
223 | # define intmax_t long int | ||
224 | #endif | ||
225 | |||
226 | #undef uintmax_t | ||
227 | #if @HAVE_UNSIGNED_LONG_LONG_INT@ && ULONG_MAX >> 31 == 1 | ||
228 | # define uintmax_t unsigned long long int | ||
229 | #elif defined uint64_t | ||
230 | # define uintmax_t uint64_t | ||
231 | #else | ||
232 | # define uintmax_t unsigned long int | ||
233 | #endif | ||
234 | |||
235 | /* 7.18.2. Limits of specified-width integer types */ | ||
236 | |||
237 | #if ! defined __cplusplus || defined __STDC_LIMIT_MACROS | ||
238 | |||
239 | /* 7.18.2.1. Limits of exact-width integer types */ | ||
240 | |||
241 | /* Here we assume a standard architecture where the hardware integer | ||
242 | types have 8, 16, 32, optionally 64 bits. */ | ||
243 | |||
244 | #undef INT8_MIN | ||
245 | #undef INT8_MAX | ||
246 | #undef UINT8_MAX | ||
247 | #define INT8_MIN (~ INT8_MAX) | ||
248 | #define INT8_MAX 127 | ||
249 | #define UINT8_MAX 255 | ||
250 | |||
251 | #undef INT16_MIN | ||
252 | #undef INT16_MAX | ||
253 | #undef UINT16_MAX | ||
254 | #define INT16_MIN (~ INT16_MAX) | ||
255 | #define INT16_MAX 32767 | ||
256 | #define UINT16_MAX 65535 | ||
257 | |||
258 | #undef INT32_MIN | ||
259 | #undef INT32_MAX | ||
260 | #undef UINT32_MAX | ||
261 | #define INT32_MIN (~ INT32_MAX) | ||
262 | #define INT32_MAX 2147483647 | ||
263 | #define UINT32_MAX 4294967295U | ||
264 | |||
265 | #undef INT64_MIN | ||
266 | #undef INT64_MAX | ||
267 | #ifdef int64_t | ||
268 | # define INT64_MIN (~ INT64_MAX) | ||
269 | # define INT64_MAX INTMAX_C (9223372036854775807) | ||
270 | #endif | ||
271 | |||
272 | #undef UINT64_MAX | ||
273 | #ifdef uint64_t | ||
274 | # define UINT64_MAX UINTMAX_C (18446744073709551615) | ||
275 | #endif | ||
276 | |||
277 | /* 7.18.2.2. Limits of minimum-width integer types */ | ||
278 | |||
279 | /* Here we assume a standard architecture where the hardware integer | ||
280 | types have 8, 16, 32, optionally 64 bits. Therefore the leastN_t types | ||
281 | are the same as the corresponding N_t types. */ | ||
282 | |||
283 | #undef INT_LEAST8_MIN | ||
284 | #undef INT_LEAST8_MAX | ||
285 | #undef UINT_LEAST8_MAX | ||
286 | #define INT_LEAST8_MIN INT8_MIN | ||
287 | #define INT_LEAST8_MAX INT8_MAX | ||
288 | #define UINT_LEAST8_MAX UINT8_MAX | ||
289 | |||
290 | #undef INT_LEAST16_MIN | ||
291 | #undef INT_LEAST16_MAX | ||
292 | #undef UINT_LEAST16_MAX | ||
293 | #define INT_LEAST16_MIN INT16_MIN | ||
294 | #define INT_LEAST16_MAX INT16_MAX | ||
295 | #define UINT_LEAST16_MAX UINT16_MAX | ||
296 | |||
297 | #undef INT_LEAST32_MIN | ||
298 | #undef INT_LEAST32_MAX | ||
299 | #undef UINT_LEAST32_MAX | ||
300 | #define INT_LEAST32_MIN INT32_MIN | ||
301 | #define INT_LEAST32_MAX INT32_MAX | ||
302 | #define UINT_LEAST32_MAX UINT32_MAX | ||
303 | |||
304 | #undef INT_LEAST64_MIN | ||
305 | #undef INT_LEAST64_MAX | ||
306 | #ifdef int64_t | ||
307 | # define INT_LEAST64_MIN INT64_MIN | ||
308 | # define INT_LEAST64_MAX INT64_MAX | ||
309 | #endif | ||
310 | |||
311 | #undef UINT_LEAST64_MAX | ||
312 | #ifdef uint64_t | ||
313 | # define UINT_LEAST64_MAX UINT64_MAX | ||
314 | #endif | ||
315 | |||
316 | /* 7.18.2.3. Limits of fastest minimum-width integer types */ | ||
317 | |||
318 | /* Here we assume a standard architecture where the hardware integer | ||
319 | types have 8, 16, 32, optionally 64 bits. Therefore the fastN_t types | ||
320 | are taken from the same list of types. */ | ||
321 | |||
322 | #undef INT_FAST8_MIN | ||
323 | #undef INT_FAST8_MAX | ||
324 | #undef UINT_FAST8_MAX | ||
325 | #define INT_FAST8_MIN LONG_MIN | ||
326 | #define INT_FAST8_MAX LONG_MAX | ||
327 | #define UINT_FAST8_MAX ULONG_MAX | ||
328 | |||
329 | #undef INT_FAST16_MIN | ||
330 | #undef INT_FAST16_MAX | ||
331 | #undef UINT_FAST16_MAX | ||
332 | #define INT_FAST16_MIN LONG_MIN | ||
333 | #define INT_FAST16_MAX LONG_MAX | ||
334 | #define UINT_FAST16_MAX ULONG_MAX | ||
335 | |||
336 | #undef INT_FAST32_MIN | ||
337 | #undef INT_FAST32_MAX | ||
338 | #undef UINT_FAST32_MAX | ||
339 | #define INT_FAST32_MIN LONG_MIN | ||
340 | #define INT_FAST32_MAX LONG_MAX | ||
341 | #define UINT_FAST32_MAX ULONG_MAX | ||
342 | |||
343 | #undef INT_FAST64_MIN | ||
344 | #undef INT_FAST64_MAX | ||
345 | #ifdef int64_t | ||
346 | # define INT_FAST64_MIN INT64_MIN | ||
347 | # define INT_FAST64_MAX INT64_MAX | ||
348 | #endif | ||
349 | |||
350 | #undef UINT_FAST64_MAX | ||
351 | #ifdef uint64_t | ||
352 | # define UINT_FAST64_MAX UINT64_MAX | ||
353 | #endif | ||
354 | |||
355 | /* 7.18.2.4. Limits of integer types capable of holding object pointers */ | ||
356 | |||
357 | #undef INTPTR_MIN | ||
358 | #undef INTPTR_MAX | ||
359 | #undef UINTPTR_MAX | ||
360 | #define INTPTR_MIN LONG_MIN | ||
361 | #define INTPTR_MAX LONG_MAX | ||
362 | #define UINTPTR_MAX ULONG_MAX | ||
363 | |||
364 | /* 7.18.2.5. Limits of greatest-width integer types */ | ||
365 | |||
366 | #undef INTMAX_MIN | ||
367 | #undef INTMAX_MAX | ||
368 | #define INTMAX_MIN (~ INTMAX_MAX) | ||
369 | #ifdef INT64_MAX | ||
370 | # define INTMAX_MAX INT64_MAX | ||
371 | #else | ||
372 | # define INTMAX_MAX INT32_MAX | ||
373 | #endif | ||
374 | |||
375 | #undef UINTMAX_MAX | ||
376 | #ifdef UINT64_MAX | ||
377 | # define UINTMAX_MAX UINT64_MAX | ||
378 | #else | ||
379 | # define UINTMAX_MAX UINT32_MAX | ||
380 | #endif | ||
381 | |||
382 | /* 7.18.3. Limits of other integer types */ | ||
383 | |||
384 | /* ptrdiff_t limits */ | ||
385 | #undef PTRDIFF_MIN | ||
386 | #undef PTRDIFF_MAX | ||
387 | #define PTRDIFF_MIN \ | ||
388 | _STDINT_MIN (1, @BITSIZEOF_PTRDIFF_T@, 0@PTRDIFF_T_SUFFIX@) | ||
389 | #define PTRDIFF_MAX \ | ||
390 | _STDINT_MAX (1, @BITSIZEOF_PTRDIFF_T@, 0@PTRDIFF_T_SUFFIX@) | ||
391 | |||
392 | /* sig_atomic_t limits */ | ||
393 | #undef SIG_ATOMIC_MIN | ||
394 | #undef SIG_ATOMIC_MAX | ||
395 | #define SIG_ATOMIC_MIN \ | ||
396 | _STDINT_MIN (@HAVE_SIGNED_SIG_ATOMIC_T@, @BITSIZEOF_SIG_ATOMIC_T@, \ | ||
397 | 0@SIG_ATOMIC_T_SUFFIX@) | ||
398 | #define SIG_ATOMIC_MAX \ | ||
399 | _STDINT_MAX (@HAVE_SIGNED_SIG_ATOMIC_T@, @BITSIZEOF_SIG_ATOMIC_T@, \ | ||
400 | 0@SIG_ATOMIC_T_SUFFIX@) | ||
401 | |||
402 | |||
403 | /* size_t limit */ | ||
404 | #undef SIZE_MAX | ||
405 | #define SIZE_MAX _STDINT_MAX (0, @BITSIZEOF_SIZE_T@, 0@SIZE_T_SUFFIX@) | ||
406 | |||
407 | /* wchar_t limits */ | ||
408 | #undef WCHAR_MIN | ||
409 | #undef WCHAR_MAX | ||
410 | #define WCHAR_MIN \ | ||
411 | _STDINT_MIN (@HAVE_SIGNED_WCHAR_T@, @BITSIZEOF_WCHAR_T@, 0@WCHAR_T_SUFFIX@) | ||
412 | #define WCHAR_MAX \ | ||
413 | _STDINT_MAX (@HAVE_SIGNED_WCHAR_T@, @BITSIZEOF_WCHAR_T@, 0@WCHAR_T_SUFFIX@) | ||
414 | |||
415 | /* wint_t limits */ | ||
416 | #undef WINT_MIN | ||
417 | #undef WINT_MAX | ||
418 | #define WINT_MIN \ | ||
419 | _STDINT_MIN (@HAVE_SIGNED_WINT_T@, @BITSIZEOF_WINT_T@, 0@WINT_T_SUFFIX@) | ||
420 | #define WINT_MAX \ | ||
421 | _STDINT_MAX (@HAVE_SIGNED_WINT_T@, @BITSIZEOF_WINT_T@, 0@WINT_T_SUFFIX@) | ||
422 | |||
423 | #endif /* !defined __cplusplus || defined __STDC_LIMIT_MACROS */ | ||
424 | |||
425 | /* 7.18.4. Macros for integer constants */ | ||
426 | |||
427 | #if ! defined __cplusplus || defined __STDC_CONSTANT_MACROS | ||
428 | |||
429 | /* 7.18.4.1. Macros for minimum-width integer constants */ | ||
430 | /* According to ISO C 99 Technical Corrigendum 1 */ | ||
431 | |||
432 | /* Here we assume a standard architecture where the hardware integer | ||
433 | types have 8, 16, 32, optionally 64 bits, and int is 32 bits. */ | ||
434 | |||
435 | #undef INT8_C | ||
436 | #undef UINT8_C | ||
437 | #define INT8_C(x) x | ||
438 | #define UINT8_C(x) x | ||
439 | |||
440 | #undef INT16_C | ||
441 | #undef UINT16_C | ||
442 | #define INT16_C(x) x | ||
443 | #define UINT16_C(x) x | ||
444 | |||
445 | #undef INT32_C | ||
446 | #undef UINT32_C | ||
447 | #define INT32_C(x) x | ||
448 | #define UINT32_C(x) x ## U | ||
449 | |||
450 | #undef INT64_C | ||
451 | #undef UINT64_C | ||
452 | #if LONG_MAX >> 31 >> 31 == 1 | ||
453 | # define INT64_C(x) x##L | ||
454 | #elif defined _MSC_VER | ||
455 | # define INT64_C(x) x##i64 | ||
456 | #elif @HAVE_LONG_LONG_INT@ | ||
457 | # define INT64_C(x) x##LL | ||
458 | #endif | ||
459 | #if ULONG_MAX >> 31 >> 31 >> 1 == 1 | ||
460 | # define UINT64_C(x) x##UL | ||
461 | #elif defined _MSC_VER | ||
462 | # define UINT64_C(x) x##ui64 | ||
463 | #elif @HAVE_UNSIGNED_LONG_LONG_INT@ | ||
464 | # define UINT64_C(x) x##ULL | ||
465 | #endif | ||
466 | |||
467 | /* 7.18.4.2. Macros for greatest-width integer constants */ | ||
468 | |||
469 | #undef INTMAX_C | ||
470 | #if @HAVE_LONG_LONG_INT@ && LONG_MAX >> 30 == 1 | ||
471 | # define INTMAX_C(x) x##LL | ||
472 | #elif defined int64_t | ||
473 | # define INTMAX_C(x) INT64_C(x) | ||
474 | #else | ||
475 | # define INTMAX_C(x) x##L | ||
476 | #endif | ||
477 | |||
478 | #undef UINTMAX_C | ||
479 | #if @HAVE_UNSIGNED_LONG_LONG_INT@ && ULONG_MAX >> 31 == 1 | ||
480 | # define UINTMAX_C(x) x##ULL | ||
481 | #elif defined uint64_t | ||
482 | # define UINTMAX_C(x) UINT64_C(x) | ||
483 | #else | ||
484 | # define UINTMAX_C(x) x##UL | ||
485 | #endif | ||
486 | |||
487 | #endif /* !defined __cplusplus || defined __STDC_CONSTANT_MACROS */ | ||
488 | |||
489 | #endif /* _GL_STDINT_H */ | ||