eĿlipsis
a language independent preprocessor
 
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Loading...
Searching...
No Matches
ellipsis-init.h
Go to the documentation of this file.
1
12#ifndef ELLIPSIS_INIT_H
13#define ELLIPSIS_INIT_H
14
15extern thread_local bool volatile ellipsis‿contracts‿ignore‿dynamic;
16extern thread_local bool volatile ellipsis‿contracts‿proceed‿dynamic;
17extern thread_local bool volatile ellipsis‿contracts‿verbose‿dynamic;
18
19typedef struct ellipsis‿contracts‿is_ice ellipsis‿contracts‿is_ice;
20
21#include <stdio.h>
22#include <stdlib.h>
23#include <stdint.h>
24
25#define STRINGIFY(...) STRINGIFY_(__VA_ARGS__)
26#define STRINGIFY_(...) #__VA_ARGS__
27
28#define ELLIPSIS_CONTRACT_VIOLATION(COUNT, VERB, CTYPE, CSTR, ...) \
29({\
30 static char const contract_format_ ## COUNT[] = \
31 __FILE__ ":" STRINGIFY(__LINE__) ": violation of " CTYPE " `" CSTR "`" __VA_OPT__(", ") __VA_ARGS__ "\n";\
32 (VERB \
33 ? fputs(contract_format_ ## COUNT, stderr) \
34 : 0);\
35 })
36
37#define ELLIPSIS_CONTRACT_IMPL(COUNT, COND, ACTION, VERB, CSTR, CTYPE, ...) \
38(((false) || (COND)) \
39 ? (void)0 \
40 : (ELLIPSIS_CONTRACT_VIOLATION(COUNT, VERB, CTYPE, CSTR __VA_OPT__(,) __VA_ARGS__) \
41 , ((false) \
42 ? (void)0 \
43 : ACTION())))
44
45#define ELLIPSIS_TO_VOIDS(...) ((void*)((uintptr_t)((__VA_ARGS__)-(__VA_ARGS__))))
46
47#define ELLIPSIS_TEST_ICE(...) (false ? ELLIPSIS_TO_VOIDS(__VA_ARGS__) : (ellipsis‿contracts‿is_ice*)nullptr)
48
49#define ELLIPSIS_CONTRACT_ICE_OR_TRUE(...) \
50 _Generic( \
51 ELLIPSIS_TEST_ICE(__VA_ARGS__), \
52 ellipsis‿contracts‿is_ice*: (__VA_ARGS__), \
53 default: true)
54
55#define ELLIPSIS_CONTRACT_CHECK_STATIC(CTYPE, COND, CSTR, ...) \
56 ({\
57 static_assert(ELLIPSIS_CONTRACT_ICE_OR_TRUE(COND), \
58 "compile time violation of " CTYPE " " CSTR \
59 __VA_OPT__(", ") __VA_ARGS__ );\
60 })
61
62#define ELLIPSIS_CONTRACT(COUNT, COND, ACTION, VERB, CSTR, CTYPE, ...) \
63 \
64 do { \
65 _Generic( \
66 ELLIPSIS_TEST_ICE(COND), \
67 ellipsis‿contracts‿is_ice*: ELLIPSIS_CONTRACT_CHECK_STATIC(CTYPE, COND, CSTR __VA_OPT__(,) __VA_ARGS__), \
68 default: ELLIPSIS_CONTRACT_IMPL(COUNT, COND, ACTION, VERB, CSTR, CTYPE __VA_OPT__(,) __VA_ARGS__));\
69 } while(false)
70
71#include <limits.h>
72#include <errno.h>
73#include <stdint.h>
74#include "utils/ellipsis-error.h"
75#include "utils/ellipsis-malloc.h"
76
77#ifdef __has_include
78# if __has_include(<stdckdint.h>)
79# include <stdckdint.h>
80# endif
81#endif
82
83/* If we do not have the header, yet, we may easily emulate it if we
84are on a compiler claiming compatibility with gcc. */
85#ifndef ckd_add
86# ifdef __GNUC__
87# define ckd_add(R, A, B) __builtin_add_overflow ((A), (B), (R))
88# define ckd_sub(R, A, B) __builtin_sub_overflow ((A), (B), (R))
89# define ckd_mul(R, A, B) __builtin_mul_overflow ((A), (B), (R))
90# else
91# error "we need a compiler extension for this"
92# endif
93#endif
94
111
115typedef enum ellipsis‿init‿flex ellipsis‿init‿flex;
116
120STDC_ATTR_NODISCARD()
121void* ellipsis‿init‿obfuscate(void* p);
122
123#define ALLOC_CHECK_RETURN(T, M) \
124 case ellipsis‿init‿flex_ ## T: return (len <= M ## _MAX)
125
126inline
127bool ellipsis‿init‿check_type(ellipsis‿init‿flex type, size_t len) {
128 /* Check if the requested size overflows. */
129 switch (type) {
130 ALLOC_CHECK_RETURN(char, CHAR);
131 ALLOC_CHECK_RETURN(uchar, UCHAR);
132 ALLOC_CHECK_RETURN(schar, SCHAR);
133 ALLOC_CHECK_RETURN(short, SHRT);
134 ALLOC_CHECK_RETURN(ushort, USHRT);
135 ALLOC_CHECK_RETURN(signed, INT);
136 ALLOC_CHECK_RETURN(unsigned, UINT);
137 ALLOC_CHECK_RETURN(long, LONG);
138 ALLOC_CHECK_RETURN(ulong, ULONG);
139 ALLOC_CHECK_RETURN(llong, LLONG);
140 ALLOC_CHECK_RETURN(ullong, ULLONG);
141 default: return false;
142 }
143}
144
145inline
146bool ellipsis‿init‿check_range(size_t len, size_t size_dat, size_t off_dat) {
147 size_t size;
148 return !ckd_mul(&size, len, size_dat) && !ckd_add(&size, size, off_dat);
149}
150
154inline
155void ellipsis‿init‿repeat(size_t n, unsigned char const sample[restrict static n],
156 size_t m, unsigned char buffer[restrict static m]) {
157 do {ELLIPSIS_CONTRACT(1, sample, abort, true, "sample", "assertion", "missing sample");} while (false);
158 do {ELLIPSIS_CONTRACT(2, buffer, abort, true, "buffer", "assertion", "missing buffer");} while (false);
159 extern typeof(ellipsis‿init‿repeat) ellipsis‿init‿repeat‿_Insta;
160 ellipsis‿init‿repeat‿_Insta(n, sample, m, buffer);
161}
162
166STDC_ATTR_NODISCARD()
167inline
168void* ellipsis‿init‿flex_core_u(unsigned long long len,
169 size_t size_base,
170 ellipsis‿init‿flex type, size_t off_len,
171 size_t size_dat, size_t off_dat,
172 unsigned char ret[restrict static (off_dat + len*size_dat)],
173 unsigned char const base_init[restrict static 1],
174 unsigned char const dat_init[restrict static 1]) {
175 typeof(void*) DEFER_LOC_ID_0_1;
176 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
177 DEFER_LOC_ID_0_1 = (typeof(void*)) {};
178 }
179 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
180 [[__maybe_unused__]] register bool defer_return_flag = false;
181 if (false) {
182 DEFER_ID_1_1:
183 goto DEFER_END_ID_1_2;
184 } else {
185 (void)0 ;
186 do {ELLIPSIS_CONTRACT(3, ret, abort, true, "ret", "assertion", "missing return buffer");} while (false);
187 do {ELLIPSIS_CONTRACT(4, base_init, abort, true, "base_init", "assertion", "missing base_init");} while (false);
188 do {ELLIPSIS_CONTRACT(5, dat_init, abort, true, "dat_init", "assertion", "missing dat_init");} while (false);
189 do {ELLIPSIS_CONTRACT(6, ellipsis‿init‿check_type(type, len), abort, true, "ellipsis∷init∷check_type(type, len)", "assertion", "array length is too large for the type");} while (false);
190 do {ELLIPSIS_CONTRACT(7, ellipsis‿init‿check_range(len, size_dat, off_dat), abort, true, "ellipsis∷init∷check_range(len, size_dat, off_dat)", "assertion", "data range is not presentable in type size_t");} while (false);
191 extern typeof(ellipsis‿init‿flex_core_u) ellipsis‿init‿flex_core_u‿_Insta;
192 do {
193 /* return mode 2 */
194 defer_return_flag = true;
195 DEFER_LOC_ID_0_1 = ellipsis‿init‿flex_core_u‿_Insta(len, size_base, type, off_len, size_dat, off_dat, ret, base_init, dat_init);
196 goto DEFER_ID_1_1;
197 } while(false);
198
199 goto DEFER_ID_1_1;
200 }
201[[__maybe_unused__]] DEFER_END_ID_1_2:;
202 return DEFER_LOC_ID_0_1;
203}
204
208STDC_ATTR_NODISCARD()
209inline
210void* ellipsis‿init‿flex_core_s(signed long long len,
211 size_t size_base,
212 ellipsis‿init‿flex type, size_t off_len,
213 size_t size_dat, size_t off_dat,
214 unsigned char ret[restrict static (off_dat + len*size_dat)],
215 unsigned char const base_init[restrict static 1],
216 unsigned char const dat_init[restrict static 1]) {
217 typeof(void*) DEFER_LOC_ID_0_1;
218 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
219 DEFER_LOC_ID_0_1 = (typeof(void*)) {};
220 }
221 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
222 [[__maybe_unused__]] register bool defer_return_flag = false;
223 if (false) {
224 DEFER_ID_1_2:
225 goto DEFER_END_ID_1_4;
226 } else {
227 (void)0 ;
228 do {ELLIPSIS_CONTRACT(8, ret, abort, true, "ret", "assertion", "missing return buffer");} while (false);
229 do {ELLIPSIS_CONTRACT(9, base_init, abort, true, "base_init", "assertion", "missing base_init");} while (false);
230 do {ELLIPSIS_CONTRACT(10, dat_init, abort, true, "dat_init", "assertion", "missing dat_init");} while (false);
231 do {ELLIPSIS_CONTRACT(11, ellipsis‿init‿check_type(type, len), abort, true, "ellipsis∷init∷check_type(type, len)", "assertion", "requested array length is too large for the type");} while (false);
232 do {ELLIPSIS_CONTRACT(12, ellipsis‿init‿check_range(len, size_dat, off_dat), abort, true, "ellipsis∷init∷check_range(len, size_dat, off_dat)", "assertion", "data range is not presentable in type size_t");} while (false);
233 extern typeof(ellipsis‿init‿flex_core_s) ellipsis‿init‿flex_core_s‿_Insta;
234 do {
235 /* return mode 2 */
236 defer_return_flag = true;
237 DEFER_LOC_ID_0_1 = ellipsis‿init‿flex_core_s‿_Insta(len, size_base, type, off_len, size_dat, off_dat, ret, base_init, dat_init);
238 goto DEFER_ID_1_2;
239 } while(false);
240
241 goto DEFER_ID_1_2;
242 }
243[[__maybe_unused__]] DEFER_END_ID_1_4:;
244 return DEFER_LOC_ID_0_1;
245}
246
250STDC_ATTR_NODISCARD()
251inline
252void* ellipsis‿alloc‿flex_core_u(unsigned long long len,
253 size_t size_base,
254 ellipsis‿init‿flex type, size_t off_len,
255 size_t size_dat, size_t off_dat,
256 unsigned char const base_init[restrict static 1],
257 unsigned char const dat_init[restrict static 1]) {
258 typeof(void*) DEFER_LOC_ID_0_1;
259 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
260 DEFER_LOC_ID_0_1 = (typeof(void*)) {};
261 }
262 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
263 [[__maybe_unused__]] register bool defer_return_flag = false;
264 if (false) {
265 DEFER_ID_1_3:
266 goto DEFER_END_ID_1_6;
267 } else {
268 (void)0 ;
269 /* defer */
270 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
271 unsigned (*DEFER_LOC_ID_1_1)[DEFER_LOC_ID_0_2] = {};
272 if (false) {
273 DEFER_ID_1_4: {
274 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
275 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
276 {ELLIPSIS_CONTRACT(13, !len || ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), unreachable, false, "¬len ∨ ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assumption", "allocation failed");}
277 }
278 goto DEFER_ID_1_3;
279 } else
280 (void)0 ;
281 do {ELLIPSIS_CONTRACT(14, base_init, abort, true, "base_init", "assertion", "missing base_init");} while (false);
282 do {ELLIPSIS_CONTRACT(15, dat_init, abort, true, "dat_init", "assertion", "missing dat_init");} while (false);
283 do {ELLIPSIS_CONTRACT(16, ellipsis‿init‿check_type(type, len), abort, true, "ellipsis∷init∷check_type(type, len)", "assertion", "requested array length is too large for the type");} while (false);
284 do {ELLIPSIS_CONTRACT(17, ellipsis‿init‿check_range(len, size_dat, off_dat), abort, true, "ellipsis∷init∷check_range(len, size_dat, off_dat)", "assertion", "data range is not presentable in type size_t");} while (false);
285 extern typeof(ellipsis‿alloc‿flex_core_u) ellipsis‿alloc‿flex_core_u‿_Insta;
286 do {
287 /* return mode 2 */
288 defer_return_flag = true;
289 DEFER_LOC_ID_0_1 = ellipsis‿alloc‿flex_core_u‿_Insta(len, size_base, type, off_len, size_dat, off_dat, base_init, dat_init);
290 goto DEFER_ID_1_4;
291 } while(false);
292
293 goto DEFER_ID_1_4;
294 }
295[[__maybe_unused__]] DEFER_END_ID_1_6:;
296 return DEFER_LOC_ID_0_1;
297}
298
302STDC_ATTR_NODISCARD()
303inline
304void* ellipsis‿alloc‿flex_core_s(signed long long len,
305 size_t size_base,
306 ellipsis‿init‿flex type, size_t off_len,
307 size_t size_dat, size_t off_dat,
308 unsigned char const base_init[restrict static 1],
309 unsigned char const dat_init[restrict static 1]) {
310 typeof(void*) DEFER_LOC_ID_0_1;
311 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
312 DEFER_LOC_ID_0_1 = (typeof(void*)) {};
313 }
314 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
315 [[__maybe_unused__]] register bool defer_return_flag = false;
316 if (false) {
317 DEFER_ID_1_5:
318 goto DEFER_END_ID_1_8;
319 } else {
320 (void)0 ;
321 /* defer */
322 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
323 unsigned (*DEFER_LOC_ID_1_2)[DEFER_LOC_ID_0_2] = {};
324 if (false) {
325 DEFER_ID_1_6: {
326 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
327 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
328 {ELLIPSIS_CONTRACT(18, len <= 0 || ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), unreachable, false, "len ≤ 0 ∨ ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assumption", "allocation failed");}
329 }
330 goto DEFER_ID_1_5;
331 } else
332 (void)0 ;
333 do {ELLIPSIS_CONTRACT(19, base_init, abort, true, "base_init", "assertion", "missing base_init");} while (false);
334 do {ELLIPSIS_CONTRACT(20, dat_init, abort, true, "dat_init", "assertion", "missing dat_init");} while (false);
335 do {ELLIPSIS_CONTRACT(21, ellipsis‿init‿check_type(type, len), abort, true, "ellipsis∷init∷check_type(type, len)", "assertion", "requested array length is too large for the type");} while (false);
336 do {ELLIPSIS_CONTRACT(22, ellipsis‿init‿check_range(len, size_dat, off_dat), abort, true, "ellipsis∷init∷check_range(len, size_dat, off_dat)", "assertion", "data range is not presentable in type size_t");} while (false);
337 extern typeof(ellipsis‿alloc‿flex_core_s) ellipsis‿alloc‿flex_core_s‿_Insta;
338 do {
339 /* return mode 2 */
340 defer_return_flag = true;
341 DEFER_LOC_ID_0_1 = ellipsis‿alloc‿flex_core_s‿_Insta(len, size_base, type, off_len, size_dat, off_dat, base_init, dat_init);
342 goto DEFER_ID_1_6;
343 } while(false);
344
345 goto DEFER_ID_1_6;
346 }
347[[__maybe_unused__]] DEFER_END_ID_1_8:;
348 return DEFER_LOC_ID_0_1;
349}
350
354STDC_ATTR_NODISCARD()
355inline
356void* ellipsis‿realloc‿flex_core_u(unsigned long long len, void* ostart_,
357 size_t size_base,
358 ellipsis‿init‿flex type, size_t off_len,
359 size_t size_dat, size_t off_dat,
360 unsigned char const ini[restrict static 1]) {
361 typeof(void*) DEFER_LOC_ID_0_1;
362 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
363 DEFER_LOC_ID_0_1 = (typeof(void*)) {};
364 }
365 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
366 [[__maybe_unused__]] register bool defer_return_flag = false;
367 if (false) {
368 DEFER_ID_1_7:
369 goto DEFER_END_ID_1_10;
370 } else {
371 (void)0 ;
372 /* defer */
373 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
374 unsigned (*DEFER_LOC_ID_1_3)[DEFER_LOC_ID_0_2] = {};
375 if (false) {
376 DEFER_ID_1_8: {
377 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
378 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
379 {ELLIPSIS_CONTRACT(23, !len || ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), unreachable, false, "¬len ∨ ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assumption", "allocation failed");}
380 }
381 goto DEFER_ID_1_7;
382 } else
383 (void)0 ;
384 do {ELLIPSIS_CONTRACT(24, ostart_, abort, true, "ostart_", "assertion", "missing ostart_");} while (false);
385 do {ELLIPSIS_CONTRACT(25, ini, abort, true, "ini", "assertion", "missing ini");} while (false);
386 do {ELLIPSIS_CONTRACT(26, ellipsis‿init‿check_type(type, len), abort, true, "ellipsis∷init∷check_type(type, len)", "assertion", "requested array length is too large for the type");} while (false);
387 do {ELLIPSIS_CONTRACT(27, ellipsis‿init‿check_range(len, size_dat, off_dat), abort, true, "ellipsis∷init∷check_range(len, size_dat, off_dat)", "assertion", "data range is not presentable in type size_t");} while (false);
388 extern typeof(ellipsis‿realloc‿flex_core_u) ellipsis‿realloc‿flex_core_u‿_Insta;
389 do {
390 /* return mode 2 */
391 defer_return_flag = true;
392 DEFER_LOC_ID_0_1 = ellipsis‿realloc‿flex_core_u‿_Insta(len, ostart_, size_base, type, off_len, size_dat, off_dat, ini);
393 goto DEFER_ID_1_8;
394 } while(false);
395
396 goto DEFER_ID_1_8;
397 }
398[[__maybe_unused__]] DEFER_END_ID_1_10:;
399 return DEFER_LOC_ID_0_1;
400}
401
405STDC_ATTR_NODISCARD()
406inline
407void* ellipsis‿realloc‿flex_core_s(signed long long len, void* ostart_,
408 size_t size_base,
409 ellipsis‿init‿flex type, size_t off_len,
410 size_t size_dat, size_t off_dat,
411 unsigned char const ini[restrict static 1]) {
412 typeof(void*) DEFER_LOC_ID_0_1;
413 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
414 DEFER_LOC_ID_0_1 = (typeof(void*)) {};
415 }
416 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
417 [[__maybe_unused__]] register bool defer_return_flag = false;
418 if (false) {
419 DEFER_ID_1_9:
420 goto DEFER_END_ID_1_12;
421 } else {
422 (void)0 ;
423 /* defer */
424 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
425 unsigned (*DEFER_LOC_ID_1_4)[DEFER_LOC_ID_0_2] = {};
426 if (false) {
427 DEFER_ID_1_10: {
428 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
429 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
430 {ELLIPSIS_CONTRACT(28, len <= 0 || ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), unreachable, false, "len ≤ 0 ∨ ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assumption", "allocation failed");}
431 }
432 goto DEFER_ID_1_9;
433 } else
434 (void)0 ;
435 do {ELLIPSIS_CONTRACT(29, ostart_, abort, true, "ostart_", "assertion", "missing ostart_");} while (false);
436 do {ELLIPSIS_CONTRACT(30, ini, abort, true, "ini", "assertion", "missing ini");} while (false);
437 do {ELLIPSIS_CONTRACT(31, ellipsis‿init‿check_type(type, len), abort, true, "ellipsis∷init∷check_type(type, len)", "assertion", "requested array length is too large for the type");} while (false);
438 do {ELLIPSIS_CONTRACT(32, ellipsis‿init‿check_range(len, size_dat, off_dat), abort, true, "ellipsis∷init∷check_range(len, size_dat, off_dat)", "assertion", "data range is not presentable in type size_t");} while (false);
439 extern typeof(ellipsis‿realloc‿flex_core_s) ellipsis‿realloc‿flex_core_s‿_Insta;
440 do {
441 /* return mode 2 */
442 defer_return_flag = true;
443 DEFER_LOC_ID_0_1 = ellipsis‿realloc‿flex_core_s‿_Insta(len, ostart_, size_base, type, off_len, size_dat, off_dat, ini);
444 goto DEFER_ID_1_10;
445 } while(false);
446
447 goto DEFER_ID_1_10;
448 }
449[[__maybe_unused__]] DEFER_END_ID_1_12:;
450 return DEFER_LOC_ID_0_1;
451}
452
456inline
457void ellipsis‿init‿repeat‿_Ctra(size_t n, unsigned char const sample[restrict static n],
458 size_t m, unsigned char buffer[restrict static m]) {
459 do {ELLIPSIS_CONTRACT(33, sample, unreachable, false, "sample", "assumption", "missing sample");} while (false);
460 do {ELLIPSIS_CONTRACT(34, buffer, unreachable, false, "buffer", "assumption", "missing buffer");} while (false);
461 extern typeof(ellipsis‿init‿repeat‿_Ctra) ellipsis‿init‿repeat‿_Inner;
462 ellipsis‿init‿repeat‿_Inner(n, sample, m, buffer);
463}
464
468STDC_ATTR_NODISCARD()
469inline
470void* ellipsis‿init‿flex_core_u‿_Ctra(unsigned long long len,
471 size_t size_base,
472 ellipsis‿init‿flex type, size_t off_len,
473 size_t size_dat, size_t off_dat,
474 unsigned char ret[restrict static (off_dat + len*size_dat)],
475 unsigned char const base_init[restrict static 1],
476 unsigned char const dat_init[restrict static 1]) {
477 typeof(void*) DEFER_LOC_ID_0_1;
478 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
479 DEFER_LOC_ID_0_1 = (typeof(void*)) {};
480 }
481 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
482 [[__maybe_unused__]] register bool defer_return_flag = false;
483 if (false) {
484 DEFER_ID_1_11:
485 goto DEFER_END_ID_1_14;
486 } else {
487 (void)0 ;
488 do {ELLIPSIS_CONTRACT(35, ret, unreachable, false, "ret", "assumption", "missing return buffer");} while (false);
489 do {ELLIPSIS_CONTRACT(36, base_init, unreachable, false, "base_init", "assumption", "missing base_init");} while (false);
490 do {ELLIPSIS_CONTRACT(37, dat_init, unreachable, false, "dat_init", "assumption", "missing dat_init");} while (false);
491 do {ELLIPSIS_CONTRACT(38, ellipsis‿init‿check_type(type, len), unreachable, false, "ellipsis∷init∷check_type(type, len)", "assumption", "array length is too large for the type");} while (false);
492 do {ELLIPSIS_CONTRACT(39, ellipsis‿init‿check_range(len, size_dat, off_dat), unreachable, false, "ellipsis∷init∷check_range(len, size_dat, off_dat)", "assumption", "data range is not presentable in type size_t");} while (false);
493 extern typeof(ellipsis‿init‿flex_core_u‿_Ctra) ellipsis‿init‿flex_core_u‿_Inner;
494 do {
495 /* return mode 2 */
496 defer_return_flag = true;
497 DEFER_LOC_ID_0_1 = ellipsis‿init‿flex_core_u‿_Inner(len, size_base, type, off_len, size_dat, off_dat, ret, base_init, dat_init);
498 goto DEFER_ID_1_11;
499 } while(false);
500
501 goto DEFER_ID_1_11;
502 }
503[[__maybe_unused__]] DEFER_END_ID_1_14:;
504 return DEFER_LOC_ID_0_1;
505}
506
510STDC_ATTR_NODISCARD()
511inline
512void* ellipsis‿init‿flex_core_s‿_Ctra(signed long long len,
513 size_t size_base,
514 ellipsis‿init‿flex type, size_t off_len,
515 size_t size_dat, size_t off_dat,
516 unsigned char ret[restrict static (off_dat + len*size_dat)],
517 unsigned char const base_init[restrict static 1],
518 unsigned char const dat_init[restrict static 1]) {
519 typeof(void*) DEFER_LOC_ID_0_1;
520 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
521 DEFER_LOC_ID_0_1 = (typeof(void*)) {};
522 }
523 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
524 [[__maybe_unused__]] register bool defer_return_flag = false;
525 if (false) {
526 DEFER_ID_1_12:
527 goto DEFER_END_ID_1_16;
528 } else {
529 (void)0 ;
530 do {ELLIPSIS_CONTRACT(40, ret, unreachable, false, "ret", "assumption", "missing return buffer");} while (false);
531 do {ELLIPSIS_CONTRACT(41, base_init, unreachable, false, "base_init", "assumption", "missing base_init");} while (false);
532 do {ELLIPSIS_CONTRACT(42, dat_init, unreachable, false, "dat_init", "assumption", "missing dat_init");} while (false);
533 do {ELLIPSIS_CONTRACT(43, ellipsis‿init‿check_type(type, len), unreachable, false, "ellipsis∷init∷check_type(type, len)", "assumption", "requested array length is too large for the type");} while (false);
534 do {ELLIPSIS_CONTRACT(44, ellipsis‿init‿check_range(len, size_dat, off_dat), unreachable, false, "ellipsis∷init∷check_range(len, size_dat, off_dat)", "assumption", "data range is not presentable in type size_t");} while (false);
535 extern typeof(ellipsis‿init‿flex_core_s‿_Ctra) ellipsis‿init‿flex_core_s‿_Inner;
536 do {
537 /* return mode 2 */
538 defer_return_flag = true;
539 DEFER_LOC_ID_0_1 = ellipsis‿init‿flex_core_s‿_Inner(len, size_base, type, off_len, size_dat, off_dat, ret, base_init, dat_init);
540 goto DEFER_ID_1_12;
541 } while(false);
542
543 goto DEFER_ID_1_12;
544 }
545[[__maybe_unused__]] DEFER_END_ID_1_16:;
546 return DEFER_LOC_ID_0_1;
547}
548
552STDC_ATTR_NODISCARD()
553inline
554void* ellipsis‿alloc‿flex_core_u‿_Ctra(unsigned long long len,
555 size_t size_base,
556 ellipsis‿init‿flex type, size_t off_len,
557 size_t size_dat, size_t off_dat,
558 unsigned char const base_init[restrict static 1],
559 unsigned char const dat_init[restrict static 1]) {
560 typeof(void*) DEFER_LOC_ID_0_1;
561 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
562 DEFER_LOC_ID_0_1 = (typeof(void*)) {};
563 }
564 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
565 [[__maybe_unused__]] register bool defer_return_flag = false;
566 if (false) {
567 DEFER_ID_1_13:
568 goto DEFER_END_ID_1_18;
569 } else {
570 (void)0 ;
571 /* defer */
572 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
573 unsigned (*DEFER_LOC_ID_1_5)[DEFER_LOC_ID_0_2] = {};
574 if (false) {
575 DEFER_ID_1_14: {
576 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
577 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
578 {ELLIPSIS_CONTRACT(45, !len || ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), abort, true, "¬len ∨ ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assertion", "allocation failed");}
579 }
580 goto DEFER_ID_1_13;
581 } else
582 (void)0 ;
583 do {ELLIPSIS_CONTRACT(46, base_init, unreachable, false, "base_init", "assumption", "missing base_init");} while (false);
584 do {ELLIPSIS_CONTRACT(47, dat_init, unreachable, false, "dat_init", "assumption", "missing dat_init");} while (false);
585 do {ELLIPSIS_CONTRACT(48, ellipsis‿init‿check_type(type, len), unreachable, false, "ellipsis∷init∷check_type(type, len)", "assumption", "requested array length is too large for the type");} while (false);
586 do {ELLIPSIS_CONTRACT(49, ellipsis‿init‿check_range(len, size_dat, off_dat), unreachable, false, "ellipsis∷init∷check_range(len, size_dat, off_dat)", "assumption", "data range is not presentable in type size_t");} while (false);
587 extern typeof(ellipsis‿alloc‿flex_core_u‿_Ctra) ellipsis‿alloc‿flex_core_u‿_Inner;
588 do {
589 /* return mode 2 */
590 defer_return_flag = true;
591 DEFER_LOC_ID_0_1 = ellipsis‿alloc‿flex_core_u‿_Inner(len, size_base, type, off_len, size_dat, off_dat, base_init, dat_init);
592 goto DEFER_ID_1_14;
593 } while(false);
594
595 goto DEFER_ID_1_14;
596 }
597[[__maybe_unused__]] DEFER_END_ID_1_18:;
598 return DEFER_LOC_ID_0_1;
599}
600
604STDC_ATTR_NODISCARD()
605inline
606void* ellipsis‿alloc‿flex_core_s‿_Ctra(signed long long len,
607 size_t size_base,
608 ellipsis‿init‿flex type, size_t off_len,
609 size_t size_dat, size_t off_dat,
610 unsigned char const base_init[restrict static 1],
611 unsigned char const dat_init[restrict static 1]) {
612 typeof(void*) DEFER_LOC_ID_0_1;
613 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
614 DEFER_LOC_ID_0_1 = (typeof(void*)) {};
615 }
616 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
617 [[__maybe_unused__]] register bool defer_return_flag = false;
618 if (false) {
619 DEFER_ID_1_15:
620 goto DEFER_END_ID_1_20;
621 } else {
622 (void)0 ;
623 /* defer */
624 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
625 unsigned (*DEFER_LOC_ID_1_6)[DEFER_LOC_ID_0_2] = {};
626 if (false) {
627 DEFER_ID_1_16: {
628 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
629 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
630 {ELLIPSIS_CONTRACT(50, len <= 0 || ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), abort, true, "len ≤ 0 ∨ ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assertion", "allocation failed");}
631 }
632 goto DEFER_ID_1_15;
633 } else
634 (void)0 ;
635 do {ELLIPSIS_CONTRACT(51, base_init, unreachable, false, "base_init", "assumption", "missing base_init");} while (false);
636 do {ELLIPSIS_CONTRACT(52, dat_init, unreachable, false, "dat_init", "assumption", "missing dat_init");} while (false);
637 do {ELLIPSIS_CONTRACT(53, ellipsis‿init‿check_type(type, len), unreachable, false, "ellipsis∷init∷check_type(type, len)", "assumption", "requested array length is too large for the type");} while (false);
638 do {ELLIPSIS_CONTRACT(54, ellipsis‿init‿check_range(len, size_dat, off_dat), unreachable, false, "ellipsis∷init∷check_range(len, size_dat, off_dat)", "assumption", "data range is not presentable in type size_t");} while (false);
639 extern typeof(ellipsis‿alloc‿flex_core_s‿_Ctra) ellipsis‿alloc‿flex_core_s‿_Inner;
640 do {
641 /* return mode 2 */
642 defer_return_flag = true;
643 DEFER_LOC_ID_0_1 = ellipsis‿alloc‿flex_core_s‿_Inner(len, size_base, type, off_len, size_dat, off_dat, base_init, dat_init);
644 goto DEFER_ID_1_16;
645 } while(false);
646
647 goto DEFER_ID_1_16;
648 }
649[[__maybe_unused__]] DEFER_END_ID_1_20:;
650 return DEFER_LOC_ID_0_1;
651}
652
656STDC_ATTR_NODISCARD()
657inline
658void* ellipsis‿realloc‿flex_core_u‿_Ctra(unsigned long long len, void* ostart_,
659 size_t size_base,
660 ellipsis‿init‿flex type, size_t off_len,
661 size_t size_dat, size_t off_dat,
662 unsigned char const ini[restrict static 1]) {
663 typeof(void*) DEFER_LOC_ID_0_1;
664 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
665 DEFER_LOC_ID_0_1 = (typeof(void*)) {};
666 }
667 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
668 [[__maybe_unused__]] register bool defer_return_flag = false;
669 if (false) {
670 DEFER_ID_1_17:
671 goto DEFER_END_ID_1_22;
672 } else {
673 (void)0 ;
674 /* defer */
675 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
676 unsigned (*DEFER_LOC_ID_1_7)[DEFER_LOC_ID_0_2] = {};
677 if (false) {
678 DEFER_ID_1_18: {
679 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
680 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
681 {ELLIPSIS_CONTRACT(55, !len || ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), abort, true, "¬len ∨ ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assertion", "allocation failed");}
682 }
683 goto DEFER_ID_1_17;
684 } else
685 (void)0 ;
686 do {ELLIPSIS_CONTRACT(56, ostart_, unreachable, false, "ostart_", "assumption", "missing ostart_");} while (false);
687 do {ELLIPSIS_CONTRACT(57, ini, unreachable, false, "ini", "assumption", "missing ini");} while (false);
688 do {ELLIPSIS_CONTRACT(58, ellipsis‿init‿check_type(type, len), unreachable, false, "ellipsis∷init∷check_type(type, len)", "assumption", "requested array length is too large for the type");} while (false);
689 do {ELLIPSIS_CONTRACT(59, ellipsis‿init‿check_range(len, size_dat, off_dat), unreachable, false, "ellipsis∷init∷check_range(len, size_dat, off_dat)", "assumption", "data range is not presentable in type size_t");} while (false);
690 extern typeof(ellipsis‿realloc‿flex_core_u‿_Ctra) ellipsis‿realloc‿flex_core_u‿_Inner;
691 do {
692 /* return mode 2 */
693 defer_return_flag = true;
694 DEFER_LOC_ID_0_1 = ellipsis‿realloc‿flex_core_u‿_Inner(len, ostart_, size_base, type, off_len, size_dat, off_dat, ini);
695 goto DEFER_ID_1_18;
696 } while(false);
697
698 goto DEFER_ID_1_18;
699 }
700[[__maybe_unused__]] DEFER_END_ID_1_22:;
701 return DEFER_LOC_ID_0_1;
702}
703
707STDC_ATTR_NODISCARD()
708inline
709void* ellipsis‿realloc‿flex_core_s‿_Ctra(signed long long len, void* ostart_,
710 size_t size_base,
711 ellipsis‿init‿flex type, size_t off_len,
712 size_t size_dat, size_t off_dat,
713 unsigned char const ini[restrict static 1]) {
714 typeof(void*) DEFER_LOC_ID_0_1;
715 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
716 DEFER_LOC_ID_0_1 = (typeof(void*)) {};
717 }
718 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
719 [[__maybe_unused__]] register bool defer_return_flag = false;
720 if (false) {
721 DEFER_ID_1_19:
722 goto DEFER_END_ID_1_24;
723 } else {
724 (void)0 ;
725 /* defer */
726 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
727 unsigned (*DEFER_LOC_ID_1_8)[DEFER_LOC_ID_0_2] = {};
728 if (false) {
729 DEFER_ID_1_20: {
730 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
731 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
732 {ELLIPSIS_CONTRACT(60, len <= 0 || ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), abort, true, "len ≤ 0 ∨ ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assertion", "allocation failed");}
733 }
734 goto DEFER_ID_1_19;
735 } else
736 (void)0 ;
737 do {ELLIPSIS_CONTRACT(61, ostart_, unreachable, false, "ostart_", "assumption", "missing ostart_");} while (false);
738 do {ELLIPSIS_CONTRACT(62, ini, unreachable, false, "ini", "assumption", "missing ini");} while (false);
739 do {ELLIPSIS_CONTRACT(63, ellipsis‿init‿check_type(type, len), unreachable, false, "ellipsis∷init∷check_type(type, len)", "assumption", "requested array length is too large for the type");} while (false);
740 do {ELLIPSIS_CONTRACT(64, ellipsis‿init‿check_range(len, size_dat, off_dat), unreachable, false, "ellipsis∷init∷check_range(len, size_dat, off_dat)", "assumption", "data range is not presentable in type size_t");} while (false);
741 extern typeof(ellipsis‿realloc‿flex_core_s‿_Ctra) ellipsis‿realloc‿flex_core_s‿_Inner;
742 do {
743 /* return mode 2 */
744 defer_return_flag = true;
745 DEFER_LOC_ID_0_1 = ellipsis‿realloc‿flex_core_s‿_Inner(len, ostart_, size_base, type, off_len, size_dat, off_dat, ini);
746 goto DEFER_ID_1_20;
747 } while(false);
748
749 goto DEFER_ID_1_20;
750 }
751[[__maybe_unused__]] DEFER_END_ID_1_24:;
752 return DEFER_LOC_ID_0_1;
753}
754
761#define ELLIPSIS_INIT_OBFUSCATE(X) ((typeof(X)restrict const){ellipsis‿init‿obfuscate(X), })
762
771#ifdef __GNUC__
772#define TARGET_SIZE(T) (sizeof(*(T)))
773#else
774#define TARGET_SIZE(T) \
775 ({\
776 auto __LOC_ID_1_1 = (typeof(T))nullptr;\
777 ((size_t)_Generic((typeof(*__LOC_ID_1_1)const volatile*)nullptr, \
778 void const volatile*: 1, \
779 default: sizeof(*__LOC_ID_1_1)));\
780 })
781#endif
782
791#define TARGET_TYPE(T) \
792 _Generic((typeof(*((typeof(T))nullptr))const volatile*)nullptr, \
793 void const volatile*: (unsigned char*)nullptr, \
794 default: ((typeof(T))nullptr))
795
796/* Prior to C23, VLA could not be initialized */
797#if 202000L < 202311L
798# define ELLIPSIS_INIT_DEFAULT 0
799#else
800# define ELLIPSIS_INIT_DEFAULT
801#endif
802
816#define ellipsis_alloc(L, ...) ELLIPSIS_ALLOC_Iplus ((L) __VA_OPT__(,) __VA_ARGS__)
817
821#define ELLIPSIS_ALLOC_Iplus(L, ...) ELLIPSIS_ALLOC_I ## __VA_OPT__(Iplus) (L __VA_OPT__(,) __VA_ARGS__)
825#define ELLIPSIS_ALLOC_I(L) ELLIPSIS_ALLOC_IIplus (L, void)
826
832#define ELLIPSIS_ALLOC_IIplus(L, T, ...) \
833 ({\
834 /* captures */ \
835 auto const __LOC_ID_1_2 = L;\
836 typeof(T)*restrict __LOC_ID_1_3 = nullptr;\
837 /* code */ \
838 auto const __LOC_ID_1_4 = TARGET_TYPE(__LOC_ID_1_3);\
839 typedef typeof(*__LOC_ID_1_4) __LOC_ID_1_5;\
840 ELLIPSIS_CONTRACT(65, 0 < __LOC_ID_1_2 && __LOC_ID_1_2 <= SIZE_MAX, abort, true, "0 < __LOC(3) ∧ __LOC(3) ≤ SIZE_MAX" , "assertion","the requested length overflows" );\
841 ELLIPSIS_CONTRACT(66, !ckd_mul(&(size_t){}, (size_t)__LOC_ID_1_2, sizeof(__LOC_ID_1_5)), abort, true, "¬ckd_mul(&(size_t){}, (size_t)__LOC(3), sizeof(__LOC(0)))" , "assertion","the requested size overflows");\
842 __LOC_ID_1_3 = ellipsis‿malloc(sizeof(__LOC_ID_1_5[__LOC_ID_1_2]));\
843 /* By the constraints, if this is an array, the list is empty. */ \
844 ellipsis_init(__LOC_ID_1_2, __LOC_ID_1_3, __LOC_ID_1_5, __VA_ARGS__);\
845 __LOC_ID_1_3 = ellipsis‿init‿obfuscate(__LOC_ID_1_3);\
846 ELLIPSIS_CONTRACT(67, __LOC_ID_1_3, unreachable, false, "__LOC(2)" , "assumption","failed allocation");\
847 __LOC_ID_1_3;\
848 })
849
871#define ellipsis_init(L, P, ...) ELLIPSIS_INIT_IIplus((L), (P) __VA_OPT__(,) __VA_ARGS__)
872
876#define ELLIPSIS_INIT_IIplus(L, P, ...) ELLIPSIS_INIT_II ## __VA_OPT__(Iplus)(L, P __VA_OPT__(,) __VA_ARGS__)
880#define ELLIPSIS_INIT_IIIplus(L, P, T, ...) ELLIPSIS_INIT_III ## __VA_OPT__(Iplus)(L, P, T __VA_OPT__(,) __VA_ARGS__)
884#define ELLIPSIS_INIT_II(L, P) ELLIPSIS_INIT_IIIIplus (L, P, void, ELLIPSIS_INIT_DEFAULT)
888#define ELLIPSIS_INIT_III(L, P, T) ELLIPSIS_INIT_IIIIplus (L, P, T, ELLIPSIS_INIT_DEFAULT)
889
895#define ELLIPSIS_INIT_IIIIplus(L, P, T, ...) \
896 ({\
897 /* captures */ \
898 auto const __LOC_ID_1_6 = (L);\
899 auto const __LOC_ID_1_7 = (typeof(T)*)(P);\
900 /* code */ \
901 auto const __LOC_ID_1_8 = TARGET_TYPE(__LOC_ID_1_7);\
902 typedef typeof(*__LOC_ID_1_8) __LOC_ID_1_9;\
903 /* Evaluate initializer in the calling context. */ \
904 /* By the constraints, if this is an array, the list is empty. */ \
905 /* So this works even if __LOC_ID_1_9 is a VLA type. */ \
906 /* A compound literal would not offer the same range of functionality. */ \
907 __LOC_ID_1_9 const __LOC_ID_1_10 = {__VA_ARGS__ };\
908 if (__LOC_ID_1_7) {\
909 ellipsis‿init‿repeat(sizeof(__LOC_ID_1_9), (void const*)&__LOC_ID_1_10, \
910 sizeof(__LOC_ID_1_9[__LOC_ID_1_6]), (void*)__LOC_ID_1_7);\
911 }\
912 ELLIPSIS_INIT_OBFUSCATE(__LOC_ID_1_7);\
913 })
914
918#define ELLIPSIS_INIT_FLEX_TYPE(...) \
919 _Generic((__VA_ARGS__), \
920 char: ellipsis‿init‿flex_char, \
921 signed char: ellipsis‿init‿flex_schar, \
922 unsigned char: ellipsis‿init‿flex_uchar, \
923 short: ellipsis‿init‿flex_short, \
924 unsigned short: ellipsis‿init‿flex_ushort, \
925 signed: ellipsis‿init‿flex_signed, \
926 unsigned: ellipsis‿init‿flex_unsigned, \
927 long: ellipsis‿init‿flex_long, \
928 unsigned long: ellipsis‿init‿flex_ulong, \
929 long long: ellipsis‿init‿flex_llong, \
930 unsigned long long: ellipsis‿init‿flex_ullong)
931
935#define ELLIPSIS_INIT_WHEN_SIGNED(X, A, B) \
936 _Generic((char(*)[(((typeof(X))-1) < 0)+1]){}, \
937 char(*)[2]: (A), \
938 char(*)[1]: (B))
939
940#define ellipsis_init_flex(L, P, T, FL, LEN, ...) \
941 ((typeof(T)*restrict const){\
942 ELLIPSIS_INIT_WHEN_SIGNED(L, ellipsis‿init‿flex_core_s, ellipsis‿init‿flex_core_u) \
943 (L, sizeof(T), \
944 ELLIPSIS_INIT_FLEX_TYPE(((typeof(T)*)nullptr)->LEN), offsetof(typeof(T), LEN), \
945 sizeof(((typeof(T)*)nullptr)->FL[0]), offsetof(typeof(T), FL), \
946 (void*)(P), \
947 (void const*)&((typeof(T) const){__VA_ARGS__ }), \
948 (void const*)&((typeof(((typeof(T)*)nullptr)->FL[0]) const){})), })
949
950#define ellipsis_alloc_flex(L, T, FL, LEN, ...) \
951 ((typeof(T)*restrict const){\
952 ELLIPSIS_INIT_WHEN_SIGNED(L, ellipsis‿alloc‿flex_core_s, ellipsis‿alloc‿flex_core_u) \
953 (L, sizeof(T), \
954 ELLIPSIS_INIT_FLEX_TYPE(((typeof(T)*)nullptr)->LEN), offsetof(typeof(T), LEN), \
955 sizeof(((typeof(T)*)nullptr)->FL[0]), offsetof(typeof(T), FL), \
956 (void const*)&((typeof(T)){__VA_ARGS__ }), \
957 (void const*)&((typeof(((typeof(T)*)nullptr)->FL[0])){})), })
958
959#define ellipsis_realloc_flex(L, P, FL, LEN) \
960 ((typeof(P)restrict const){\
961 ELLIPSIS_INIT_WHEN_SIGNED(L, ellipsis‿realloc‿flex_core_s, ellipsis‿realloc‿flex_core_u) \
962 (L, P, sizeof(*P), \
963 ELLIPSIS_INIT_FLEX_TYPE(((typeof(P))nullptr)->LEN), offsetof(typeof(*(P)), LEN), \
964 sizeof((P)->FL[0]), offsetof(typeof(*(P)), FL), \
965 (void const*)&(typeof((P)->FL[0])){}), })
966
967#endif
STDC_ATTR_NODISCARD
#define STDC_ATTR_NODISCARD(...)
Definition ellipsis-error.h:68
ellipsis‿contracts‿is_ice
struct ellipsis‿contracts‿is_ice ellipsis‿contracts‿is_ice
Definition ellipsis-expression.c:24
ellipsis‿init‿flex_core_s‿_Insta
void * ellipsis‿init‿flex_core_s‿_Insta(signed long long len, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char ret[restrict static(off_dat+len *size_dat)], unsigned char const base_init[restrict static 1], unsigned char const dat_init[restrict static 1])
Definition ellipsis-init.c:328
ellipsis‿realloc‿flex_core_u
ellipsis‿realloc‿flex_core_u ellipsis‿realloc‿flex_core_u
Definition ellipsis-init.c:83
ellipsis‿init‿flex_core_u‿_Inner
void * ellipsis‿init‿flex_core_u‿_Inner(unsigned long long len, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char ret[restrict static(off_dat+len *size_dat)], unsigned char const base_init[restrict static 1], unsigned char const dat_init[restrict static 1])
Definition ellipsis-init.c:109
ellipsis‿alloc‿flex_core_u‿_Insta
void * ellipsis‿alloc‿flex_core_u‿_Insta(unsigned long long len, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char const base_init[restrict static 1], unsigned char const dat_init[restrict static 1])
Definition ellipsis-init.c:370
ellipsis‿realloc‿flex_core_s‿_Inner
void * ellipsis‿realloc‿flex_core_s‿_Inner(signed long long len, void *ostart_, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char const ini[restrict static 1])
Definition ellipsis-init.c:258
ellipsis‿alloc‿flex_core_s‿_Insta
void * ellipsis‿alloc‿flex_core_s‿_Insta(signed long long len, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char const base_init[restrict static 1], unsigned char const dat_init[restrict static 1])
Definition ellipsis-init.c:411
ellipsis‿realloc‿flex_core_u‿_Insta
void * ellipsis‿realloc‿flex_core_u‿_Insta(unsigned long long len, void *ostart_, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char const ini[restrict static 1])
Definition ellipsis-init.c:452
ellipsis‿realloc‿flex_core_s
ellipsis‿realloc‿flex_core_s ellipsis‿realloc‿flex_core_s
Definition ellipsis-init.c:84
ellipsis‿init‿flex_core_u‿_Insta
void * ellipsis‿init‿flex_core_u‿_Insta(unsigned long long len, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char ret[restrict static(off_dat+len *size_dat)], unsigned char const base_init[restrict static 1], unsigned char const dat_init[restrict static 1])
Definition ellipsis-init.c:286
ellipsis‿alloc‿flex_core_s
ellipsis‿alloc‿flex_core_s ellipsis‿alloc‿flex_core_s
Definition ellipsis-init.c:82
ellipsis‿init‿flex_core_s‿_Inner
void * ellipsis‿init‿flex_core_s‿_Inner(signed long long len, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char ret[restrict static(off_dat+len *size_dat)], unsigned char const base_init[restrict static 1], unsigned char const dat_init[restrict static 1])
Definition ellipsis-init.c:142
ellipsis‿realloc‿flex_core_s‿_Insta
void * ellipsis‿realloc‿flex_core_s‿_Insta(signed long long len, void *ostart_, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char const ini[restrict static 1])
Definition ellipsis-init.c:492
ellipsis‿alloc‿flex_core_u‿_Inner
void * ellipsis‿alloc‿flex_core_u‿_Inner(unsigned long long len, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char const base_init[restrict static 1], unsigned char const dat_init[restrict static 1])
Definition ellipsis-init.c:156
ellipsis‿realloc‿flex_core_u‿_Inner
void * ellipsis‿realloc‿flex_core_u‿_Inner(unsigned long long len, void *ostart_, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char const ini[restrict static 1])
Definition ellipsis-init.c:203
ellipsis‿init‿repeat‿_Inner
void ellipsis‿init‿repeat‿_Inner(size_t n, unsigned char const sample[restrict static n], size_t m, unsigned char buffer[restrict static m])
Definition ellipsis-init.c:96
ellipsis‿alloc‿flex_core_u
ellipsis‿alloc‿flex_core_u ellipsis‿alloc‿flex_core_u
Definition ellipsis-init.c:81
ellipsis‿init‿repeat‿_Insta
void ellipsis‿init‿repeat‿_Insta(size_t n, unsigned char const sample[restrict static n], size_t m, unsigned char buffer[restrict static m])
Definition ellipsis-init.c:273
ellipsis‿alloc‿flex_core_s‿_Inner
void * ellipsis‿alloc‿flex_core_s‿_Inner(signed long long len, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char const base_init[restrict static 1], unsigned char const dat_init[restrict static 1])
Definition ellipsis-init.c:190
ellipsis‿init‿check_range
bool ellipsis‿init‿check_range(size_t len, size_t size_dat, size_t off_dat)
Definition ellipsis-init.h:146
ellipsis‿init‿flex_core_s‿_Ctra
void * ellipsis‿init‿flex_core_s‿_Ctra(signed long long len, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char ret[restrict static(off_dat+len *size_dat)], unsigned char const base_init[restrict static 1], unsigned char const dat_init[restrict static 1])
Definition ellipsis-init.h:512
ellipsis‿contracts‿verbose‿dynamic
thread_local bool volatile ellipsis‿contracts‿verbose‿dynamic
ellipsis‿init‿repeat
void ellipsis‿init‿repeat(size_t n, unsigned char const sample[restrict static n], size_t m, unsigned char buffer[restrict static m])
Definition ellipsis-init.h:155
ELLIPSIS_CONTRACT
#define ELLIPSIS_CONTRACT(COUNT, COND, ACTION, VERB, CSTR, CTYPE,...)
Definition ellipsis-init.h:62
ellipsis‿init‿flex_core_s
void * ellipsis‿init‿flex_core_s(signed long long len, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char ret[restrict static(off_dat+len *size_dat)], unsigned char const base_init[restrict static 1], unsigned char const dat_init[restrict static 1])
Definition ellipsis-init.h:210
ellipsis‿alloc‿flex_core_u‿_Ctra
void * ellipsis‿alloc‿flex_core_u‿_Ctra(unsigned long long len, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char const base_init[restrict static 1], unsigned char const dat_init[restrict static 1])
Definition ellipsis-init.h:554
ALLOC_CHECK_RETURN
#define ALLOC_CHECK_RETURN(T, M)
Definition ellipsis-init.h:123
ellipsis‿alloc‿flex_core_s‿_Ctra
void * ellipsis‿alloc‿flex_core_s‿_Ctra(signed long long len, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char const base_init[restrict static 1], unsigned char const dat_init[restrict static 1])
Definition ellipsis-init.h:606
ellipsis‿contracts‿proceed‿dynamic
thread_local bool volatile ellipsis‿contracts‿proceed‿dynamic
ellipsis‿init‿flex_core_u
void * ellipsis‿init‿flex_core_u(unsigned long long len, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char ret[restrict static(off_dat+len *size_dat)], unsigned char const base_init[restrict static 1], unsigned char const dat_init[restrict static 1])
Definition ellipsis-init.h:168
ellipsis‿init‿repeat‿_Ctra
void ellipsis‿init‿repeat‿_Ctra(size_t n, unsigned char const sample[restrict static n], size_t m, unsigned char buffer[restrict static m])
Definition ellipsis-init.h:457
ellipsis‿init‿flex
ellipsis‿init‿flex
Definition ellipsis-init.h:98
ellipsis‿init‿flex_unsigned
@ ellipsis‿init‿flex_unsigned
Definition ellipsis-init.h:105
ellipsis‿init‿flex_short
@ ellipsis‿init‿flex_short
Definition ellipsis-init.h:102
ellipsis‿init‿flex_signed
@ ellipsis‿init‿flex_signed
Definition ellipsis-init.h:104
ellipsis‿init‿flex_schar
@ ellipsis‿init‿flex_schar
Definition ellipsis-init.h:100
ellipsis‿init‿flex_ushort
@ ellipsis‿init‿flex_ushort
Definition ellipsis-init.h:103
ellipsis‿init‿flex_long
@ ellipsis‿init‿flex_long
Definition ellipsis-init.h:106
ellipsis‿init‿flex_char
@ ellipsis‿init‿flex_char
Definition ellipsis-init.h:99
ellipsis‿init‿flex_uchar
@ ellipsis‿init‿flex_uchar
Definition ellipsis-init.h:101
ellipsis‿init‿flex_llong
@ ellipsis‿init‿flex_llong
Definition ellipsis-init.h:108
ellipsis‿init‿flex_ullong
@ ellipsis‿init‿flex_ullong
Definition ellipsis-init.h:109
ellipsis‿init‿flex_ulong
@ ellipsis‿init‿flex_ulong
Definition ellipsis-init.h:107
ellipsis‿init‿obfuscate
void * ellipsis‿init‿obfuscate(void *p)
Definition ellipsis-init.c:528
ellipsis‿realloc‿flex_core_u‿_Ctra
void * ellipsis‿realloc‿flex_core_u‿_Ctra(unsigned long long len, void *ostart_, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char const ini[restrict static 1])
Definition ellipsis-init.h:658
ellipsis‿contracts‿ignore‿dynamic
thread_local bool volatile ellipsis‿contracts‿ignore‿dynamic
ellipsis‿init‿check_type
bool ellipsis‿init‿check_type(ellipsis‿init‿flex type, size_t len)
Definition ellipsis-init.h:127
ellipsis‿realloc‿flex_core_s‿_Ctra
void * ellipsis‿realloc‿flex_core_s‿_Ctra(signed long long len, void *ostart_, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char const ini[restrict static 1])
Definition ellipsis-init.h:709
ellipsis‿init‿flex_core_u‿_Ctra
void * ellipsis‿init‿flex_core_u‿_Ctra(unsigned long long len, size_t size_base, ellipsis‿init‿flex type, size_t off_len, size_t size_dat, size_t off_dat, unsigned char ret[restrict static(off_dat+len *size_dat)], unsigned char const base_init[restrict static 1], unsigned char const dat_init[restrict static 1])
Definition ellipsis-init.h:470
eĿlipsis 20250309