Branch data Line data Source code
1 : : /* Test of <stdint.h> substitute.
2 : : Copyright (C) 2006-2012 Free Software Foundation, Inc.
3 : :
4 : : This program is free software: you can redistribute it and/or modify
5 : : it under the terms of the GNU General Public License as published by
6 : : the Free Software Foundation; either version 3 of the License, or
7 : : (at your option) any later version.
8 : :
9 : : This program is distributed in the hope that it will be useful,
10 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
11 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 : : GNU General Public License for more details.
13 : :
14 : : You should have received a copy of the GNU General Public License
15 : : along with this program. If not, see <http://www.gnu.org/licenses/>. */
16 : :
17 : : /* Written by Bruno Haible <bruno@clisp.org>, 2006. */
18 : :
19 : : #include <config.h>
20 : :
21 : : /* Whether to enable pedantic checks. */
22 : : #define DO_PEDANTIC 0
23 : :
24 : : #include <stdint.h>
25 : :
26 : : #include "verify.h"
27 : : #include "intprops.h"
28 : :
29 : : #if __GNUC__ >= 2 && DO_PEDANTIC
30 : : # define verify_same_types(expr1,expr2) \
31 : : extern void _verify_func(__LINE__) (__typeof__ (expr1) *); \
32 : : extern void _verify_func(__LINE__) (__typeof__ (expr2) *);
33 : : # define _verify_func(line) _verify_func2(line)
34 : : # define _verify_func2(line) verify_func_ ## line
35 : : #else
36 : : # define verify_same_types(expr1,expr2) extern void verify_func (int)
37 : : #endif
38 : :
39 : : /* 7.18.1.1. Exact-width integer types */
40 : : /* 7.18.2.1. Limits of exact-width integer types */
41 : :
42 : : int8_t a1[3] = { INT8_C (17), INT8_MIN, INT8_MAX };
43 : : verify (TYPE_MINIMUM (int8_t) == INT8_MIN);
44 : : verify (TYPE_MAXIMUM (int8_t) == INT8_MAX);
45 : : verify_same_types (INT8_MIN, (int8_t) 0 + 0);
46 : : verify_same_types (INT8_MAX, (int8_t) 0 + 0);
47 : :
48 : : int16_t a2[3] = { INT16_C (17), INT16_MIN, INT16_MAX };
49 : : verify (TYPE_MINIMUM (int16_t) == INT16_MIN);
50 : : verify (TYPE_MAXIMUM (int16_t) == INT16_MAX);
51 : : verify_same_types (INT16_MIN, (int16_t) 0 + 0);
52 : : verify_same_types (INT16_MAX, (int16_t) 0 + 0);
53 : :
54 : : int32_t a3[3] = { INT32_C (17), INT32_MIN, INT32_MAX };
55 : : verify (TYPE_MINIMUM (int32_t) == INT32_MIN);
56 : : verify (TYPE_MAXIMUM (int32_t) == INT32_MAX);
57 : : verify_same_types (INT32_MIN, (int32_t) 0 + 0);
58 : : verify_same_types (INT32_MAX, (int32_t) 0 + 0);
59 : :
60 : : #ifdef INT64_MAX
61 : : int64_t a4[3] = { INT64_C (17), INT64_MIN, INT64_MAX };
62 : : verify (TYPE_MINIMUM (int64_t) == INT64_MIN);
63 : : verify (TYPE_MAXIMUM (int64_t) == INT64_MAX);
64 : : verify_same_types (INT64_MIN, (int64_t) 0 + 0);
65 : : verify_same_types (INT64_MAX, (int64_t) 0 + 0);
66 : : #endif
67 : :
68 : : uint8_t b1[2] = { UINT8_C (17), UINT8_MAX };
69 : : verify (TYPE_MAXIMUM (uint8_t) == UINT8_MAX);
70 : : verify_same_types (UINT8_MAX, (uint8_t) 0 + 0);
71 : :
72 : : uint16_t b2[2] = { UINT16_C (17), UINT16_MAX };
73 : : verify (TYPE_MAXIMUM (uint16_t) == UINT16_MAX);
74 : : verify_same_types (UINT16_MAX, (uint16_t) 0 + 0);
75 : :
76 : : uint32_t b3[2] = { UINT32_C (17), UINT32_MAX };
77 : : verify (TYPE_MAXIMUM (uint32_t) == UINT32_MAX);
78 : : verify_same_types (UINT32_MAX, (uint32_t) 0 + 0);
79 : :
80 : : #ifdef UINT64_MAX
81 : : uint64_t b4[2] = { UINT64_C (17), UINT64_MAX };
82 : : verify (TYPE_MAXIMUM (uint64_t) == UINT64_MAX);
83 : : verify_same_types (UINT64_MAX, (uint64_t) 0 + 0);
84 : : #endif
85 : :
86 : : #if INT8_MIN && INT8_MAX && INT16_MIN && INT16_MAX && INT32_MIN && INT32_MAX
87 : : /* ok */
88 : : #else
89 : : err or;
90 : : #endif
91 : :
92 : : #if UINT8_MAX && UINT16_MAX && UINT32_MAX
93 : : /* ok */
94 : : #else
95 : : err or;
96 : : #endif
97 : :
98 : : /* 7.18.1.2. Minimum-width integer types */
99 : : /* 7.18.2.2. Limits of minimum-width integer types */
100 : :
101 : : int_least8_t c1[3] = { 17, INT_LEAST8_MIN, INT_LEAST8_MAX };
102 : : verify (TYPE_MINIMUM (int_least8_t) == INT_LEAST8_MIN);
103 : : verify (TYPE_MAXIMUM (int_least8_t) == INT_LEAST8_MAX);
104 : : verify_same_types (INT_LEAST8_MIN, (int_least8_t) 0 + 0);
105 : : verify_same_types (INT_LEAST8_MAX, (int_least8_t) 0 + 0);
106 : :
107 : : int_least16_t c2[3] = { 17, INT_LEAST16_MIN, INT_LEAST16_MAX };
108 : : verify (TYPE_MINIMUM (int_least16_t) == INT_LEAST16_MIN);
109 : : verify (TYPE_MAXIMUM (int_least16_t) == INT_LEAST16_MAX);
110 : : verify_same_types (INT_LEAST16_MIN, (int_least16_t) 0 + 0);
111 : : verify_same_types (INT_LEAST16_MAX, (int_least16_t) 0 + 0);
112 : :
113 : : int_least32_t c3[3] = { 17, INT_LEAST32_MIN, INT_LEAST32_MAX };
114 : : verify (TYPE_MINIMUM (int_least32_t) == INT_LEAST32_MIN);
115 : : verify (TYPE_MAXIMUM (int_least32_t) == INT_LEAST32_MAX);
116 : : verify_same_types (INT_LEAST32_MIN, (int_least32_t) 0 + 0);
117 : : verify_same_types (INT_LEAST32_MAX, (int_least32_t) 0 + 0);
118 : :
119 : : #ifdef INT_LEAST64_MAX
120 : : int_least64_t c4[3] = { 17, INT_LEAST64_MIN, INT_LEAST64_MAX };
121 : : verify (TYPE_MINIMUM (int_least64_t) == INT_LEAST64_MIN);
122 : : verify (TYPE_MAXIMUM (int_least64_t) == INT_LEAST64_MAX);
123 : : verify_same_types (INT_LEAST64_MIN, (int_least64_t) 0 + 0);
124 : : verify_same_types (INT_LEAST64_MAX, (int_least64_t) 0 + 0);
125 : : #endif
126 : :
127 : : uint_least8_t d1[2] = { 17, UINT_LEAST8_MAX };
128 : : verify (TYPE_MAXIMUM (uint_least8_t) == UINT_LEAST8_MAX);
129 : : verify_same_types (UINT_LEAST8_MAX, (uint_least8_t) 0 + 0);
130 : :
131 : : uint_least16_t d2[2] = { 17, UINT_LEAST16_MAX };
132 : : verify (TYPE_MAXIMUM (uint_least16_t) == UINT_LEAST16_MAX);
133 : : verify_same_types (UINT_LEAST16_MAX, (uint_least16_t) 0 + 0);
134 : :
135 : : uint_least32_t d3[2] = { 17, UINT_LEAST32_MAX };
136 : : verify (TYPE_MAXIMUM (uint_least32_t) == UINT_LEAST32_MAX);
137 : : verify_same_types (UINT_LEAST32_MAX, (uint_least32_t) 0 + 0);
138 : :
139 : : #ifdef UINT_LEAST64_MAX
140 : : uint_least64_t d4[2] = { 17, UINT_LEAST64_MAX };
141 : : verify (TYPE_MAXIMUM (uint_least64_t) == UINT_LEAST64_MAX);
142 : : verify_same_types (UINT_LEAST64_MAX, (uint_least64_t) 0 + 0);
143 : : #endif
144 : :
145 : : #if INT_LEAST8_MIN && INT_LEAST8_MAX && INT_LEAST16_MIN && INT_LEAST16_MAX && INT_LEAST32_MIN && INT_LEAST32_MAX
146 : : /* ok */
147 : : #else
148 : : err or;
149 : : #endif
150 : :
151 : : #if UINT_LEAST8_MAX && UINT_LEAST16_MAX && UINT_LEAST32_MAX
152 : : /* ok */
153 : : #else
154 : : err or;
155 : : #endif
156 : :
157 : : /* 7.18.1.3. Fastest minimum-width integer types */
158 : : /* 7.18.2.3. Limits of fastest minimum-width integer types */
159 : :
160 : : int_fast8_t e1[3] = { 17, INT_FAST8_MIN, INT_FAST8_MAX };
161 : : verify (TYPE_MINIMUM (int_fast8_t) == INT_FAST8_MIN);
162 : : verify (TYPE_MAXIMUM (int_fast8_t) == INT_FAST8_MAX);
163 : : verify_same_types (INT_FAST8_MIN, (int_fast8_t) 0 + 0);
164 : : verify_same_types (INT_FAST8_MAX, (int_fast8_t) 0 + 0);
165 : :
166 : : int_fast16_t e2[3] = { 17, INT_FAST16_MIN, INT_FAST16_MAX };
167 : : verify (TYPE_MINIMUM (int_fast16_t) == INT_FAST16_MIN);
168 : : verify (TYPE_MAXIMUM (int_fast16_t) == INT_FAST16_MAX);
169 : : verify_same_types (INT_FAST16_MIN, (int_fast16_t) 0 + 0);
170 : : verify_same_types (INT_FAST16_MAX, (int_fast16_t) 0 + 0);
171 : :
172 : : int_fast32_t e3[3] = { 17, INT_FAST32_MIN, INT_FAST32_MAX };
173 : : verify (TYPE_MINIMUM (int_fast32_t) == INT_FAST32_MIN);
174 : : verify (TYPE_MAXIMUM (int_fast32_t) == INT_FAST32_MAX);
175 : : verify_same_types (INT_FAST32_MIN, (int_fast32_t) 0 + 0);
176 : : verify_same_types (INT_FAST32_MAX, (int_fast32_t) 0 + 0);
177 : :
178 : : #ifdef INT_FAST64_MAX
179 : : int_fast64_t e4[3] = { 17, INT_FAST64_MIN, INT_FAST64_MAX };
180 : : verify (TYPE_MINIMUM (int_fast64_t) == INT_FAST64_MIN);
181 : : verify (TYPE_MAXIMUM (int_fast64_t) == INT_FAST64_MAX);
182 : : verify_same_types (INT_FAST64_MIN, (int_fast64_t) 0 + 0);
183 : : verify_same_types (INT_FAST64_MAX, (int_fast64_t) 0 + 0);
184 : : #endif
185 : :
186 : : uint_fast8_t f1[2] = { 17, UINT_FAST8_MAX };
187 : : verify (TYPE_MAXIMUM (uint_fast8_t) == UINT_FAST8_MAX);
188 : : verify_same_types (UINT_FAST8_MAX, (uint_fast8_t) 0 + 0);
189 : :
190 : : uint_fast16_t f2[2] = { 17, UINT_FAST16_MAX };
191 : : verify (TYPE_MAXIMUM (uint_fast16_t) == UINT_FAST16_MAX);
192 : : verify_same_types (UINT_FAST16_MAX, (uint_fast16_t) 0 + 0);
193 : :
194 : : uint_fast32_t f3[2] = { 17, UINT_FAST32_MAX };
195 : : verify (TYPE_MAXIMUM (uint_fast32_t) == UINT_FAST32_MAX);
196 : : verify_same_types (UINT_FAST32_MAX, (uint_fast32_t) 0 + 0);
197 : :
198 : : #ifdef UINT_FAST64_MAX
199 : : uint_fast64_t f4[2] = { 17, UINT_FAST64_MAX };
200 : : verify (TYPE_MAXIMUM (uint_fast64_t) == UINT_FAST64_MAX);
201 : : verify_same_types (UINT_FAST64_MAX, (uint_fast64_t) 0 + 0);
202 : : #endif
203 : :
204 : : #if INT_FAST8_MIN && INT_FAST8_MAX && INT_FAST16_MIN && INT_FAST16_MAX && INT_FAST32_MIN && INT_FAST32_MAX
205 : : /* ok */
206 : : #else
207 : : err or;
208 : : #endif
209 : :
210 : : #if UINT_FAST8_MAX && UINT_FAST16_MAX && UINT_FAST32_MAX
211 : : /* ok */
212 : : #else
213 : : err or;
214 : : #endif
215 : :
216 : : /* 7.18.1.4. Integer types capable of holding object pointers */
217 : : /* 7.18.2.4. Limits of integer types capable of holding object pointers */
218 : :
219 : : intptr_t g[3] = { 17, INTPTR_MIN, INTPTR_MAX };
220 : : verify (TYPE_MINIMUM (intptr_t) == INTPTR_MIN);
221 : : verify (TYPE_MAXIMUM (intptr_t) == INTPTR_MAX);
222 : : verify_same_types (INTPTR_MIN, (intptr_t) 0 + 0);
223 : : verify_same_types (INTPTR_MAX, (intptr_t) 0 + 0);
224 : :
225 : : uintptr_t h[2] = { 17, UINTPTR_MAX };
226 : : verify (TYPE_MAXIMUM (uintptr_t) == UINTPTR_MAX);
227 : : verify_same_types (UINTPTR_MAX, (uintptr_t) 0 + 0);
228 : :
229 : : #if INTPTR_MIN && INTPTR_MAX && UINTPTR_MAX
230 : : /* ok */
231 : : #else
232 : : err or;
233 : : #endif
234 : :
235 : : /* 7.18.1.5. Greatest-width integer types */
236 : : /* 7.18.2.5. Limits of greatest-width integer types */
237 : :
238 : : intmax_t i[3] = { INTMAX_C (17), INTMAX_MIN, INTMAX_MAX };
239 : : verify (TYPE_MINIMUM (intmax_t) == INTMAX_MIN);
240 : : verify (TYPE_MAXIMUM (intmax_t) == INTMAX_MAX);
241 : : verify_same_types (INTMAX_MIN, (intmax_t) 0 + 0);
242 : : verify_same_types (INTMAX_MAX, (intmax_t) 0 + 0);
243 : :
244 : : uintmax_t j[2] = { UINTMAX_C (17), UINTMAX_MAX };
245 : : verify (TYPE_MAXIMUM (uintmax_t) == UINTMAX_MAX);
246 : : verify_same_types (UINTMAX_MAX, (uintmax_t) 0 + 0);
247 : :
248 : : /* As of 2007, Sun C and HP-UX 10.20 cc don't support 'long long' constants in
249 : : the preprocessor. */
250 : : #if !(defined __SUNPRO_C || (defined __hpux && !defined __GNUC__))
251 : : #if INTMAX_MIN && INTMAX_MAX && UINTMAX_MAX
252 : : /* ok */
253 : : #else
254 : : err or;
255 : : #endif
256 : : #endif
257 : :
258 : : /* 7.18.3. Limits of other integer types */
259 : :
260 : : #include <stddef.h>
261 : :
262 : : verify (TYPE_MINIMUM (ptrdiff_t) == PTRDIFF_MIN);
263 : : verify (TYPE_MAXIMUM (ptrdiff_t) == PTRDIFF_MAX);
264 : : verify_same_types (PTRDIFF_MIN, (ptrdiff_t) 0 + 0);
265 : : verify_same_types (PTRDIFF_MAX, (ptrdiff_t) 0 + 0);
266 : :
267 : : #if PTRDIFF_MIN && PTRDIFF_MAX
268 : : /* ok */
269 : : #else
270 : : err or;
271 : : #endif
272 : :
273 : : #include <signal.h>
274 : :
275 : : verify (TYPE_MINIMUM (sig_atomic_t) == SIG_ATOMIC_MIN);
276 : : verify (TYPE_MAXIMUM (sig_atomic_t) == SIG_ATOMIC_MAX);
277 : : verify_same_types (SIG_ATOMIC_MIN, (sig_atomic_t) 0 + 0);
278 : : verify_same_types (SIG_ATOMIC_MAX, (sig_atomic_t) 0 + 0);
279 : :
280 : : #if SIG_ATOMIC_MIN != 17 && SIG_ATOMIC_MAX
281 : : /* ok */
282 : : #else
283 : : err or;
284 : : #endif
285 : :
286 : : verify (TYPE_MAXIMUM (size_t) == SIZE_MAX);
287 : : verify_same_types (SIZE_MAX, (size_t) 0 + 0);
288 : :
289 : : #if SIZE_MAX
290 : : /* ok */
291 : : #else
292 : : err or;
293 : : #endif
294 : :
295 : : #if HAVE_WCHAR_T
296 : : verify (TYPE_MINIMUM (wchar_t) == WCHAR_MIN);
297 : : verify (TYPE_MAXIMUM (wchar_t) == WCHAR_MAX);
298 : : verify_same_types (WCHAR_MIN, (wchar_t) 0 + 0);
299 : : verify_same_types (WCHAR_MAX, (wchar_t) 0 + 0);
300 : :
301 : : # if WCHAR_MIN != 17 && WCHAR_MAX
302 : : /* ok */
303 : : # else
304 : : err or;
305 : : # endif
306 : : #endif
307 : :
308 : : #if HAVE_WINT_T
309 : : # include <wchar.h>
310 : :
311 : : verify (TYPE_MINIMUM (wint_t) == WINT_MIN);
312 : : verify (TYPE_MAXIMUM (wint_t) == WINT_MAX);
313 : : verify_same_types (WINT_MIN, (wint_t) 0 + 0);
314 : : verify_same_types (WINT_MAX, (wint_t) 0 + 0);
315 : :
316 : : # if WINT_MIN != 17 && WINT_MAX
317 : : /* ok */
318 : : # else
319 : : err or;
320 : : # endif
321 : : #endif
322 : :
323 : : /* 7.18.4. Macros for integer constants */
324 : :
325 : : verify (INT8_C (17) == 17);
326 : : verify_same_types (INT8_C (17), (int_least8_t)0 + 0);
327 : : verify (UINT8_C (17) == 17);
328 : : verify_same_types (UINT8_C (17), (uint_least8_t)0 + 0);
329 : :
330 : : verify (INT16_C (17) == 17);
331 : : verify_same_types (INT16_C (17), (int_least16_t)0 + 0);
332 : : verify (UINT16_C (17) == 17);
333 : : verify_same_types (UINT16_C (17), (uint_least16_t)0 + 0);
334 : :
335 : : verify (INT32_C (17) == 17);
336 : : verify_same_types (INT32_C (17), (int_least32_t)0 + 0);
337 : : verify (UINT32_C (17) == 17);
338 : : verify_same_types (UINT32_C (17), (uint_least32_t)0 + 0);
339 : :
340 : : #ifdef INT64_C
341 : : verify (INT64_C (17) == 17);
342 : : verify_same_types (INT64_C (17), (int_least64_t)0 + 0);
343 : : #endif
344 : : #ifdef UINT64_C
345 : : verify (UINT64_C (17) == 17);
346 : : verify_same_types (UINT64_C (17), (uint_least64_t)0 + 0);
347 : : #endif
348 : :
349 : : verify (INTMAX_C (17) == 17);
350 : : verify_same_types (INTMAX_C (17), (intmax_t)0 + 0);
351 : : verify (UINTMAX_C (17) == 17);
352 : : verify_same_types (UINTMAX_C (17), (uintmax_t)0 + 0);
353 : :
354 : :
355 : : int
356 : 1 : main (void)
357 : : {
358 : 1 : return 0;
359 : : }
|
