eĿlipsis
a language independent preprocessor
 
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Loading...
Searching...
No Matches
ellipsis-str32.h
Go to the documentation of this file.
1
8#ifndef ELLIPSIS_STR32_H
9#define ELLIPSIS_STR32_H 1
10
11#include <uchar.h>
12#include <stdio.h>
13#include <string.h>
14
15#include "ellipsis-error.h"
16
20typedef char32_t ellipsis‿str32‿base;
21
26inline
27int ellipsis‿str32‿base‿compare(ellipsis‿str32‿base const* __LOC_ID_0_1, ellipsis‿str32‿base const* __LOC_ID_0_2) {
28 if (!__LOC_ID_0_1[0] + !__LOC_ID_0_2[0]) {
29 return !__LOC_ID_0_2[0] - !__LOC_ID_0_1[0];
30 }
31 return (__LOC_ID_0_1[0] < __LOC_ID_0_2[0]) ? -1 : (__LOC_ID_0_1[0] > __LOC_ID_0_2[0] ? +1 : 0);
32}
33
34#include <stddef.h>
35#include <string.h>
36#include <stdlib.h>
37#include "utils/ellipsis-error.h"
38
39extern thread_local bool volatile ellipsis‿contracts‿ignore‿dynamic;
40extern thread_local bool volatile ellipsis‿contracts‿proceed‿dynamic;
41extern thread_local bool volatile ellipsis‿contracts‿verbose‿dynamic;
42
43typedef struct ellipsis‿contracts‿is_ice ellipsis‿contracts‿is_ice;
44
45#include <stdio.h>
46#include <stdlib.h>
47#include <stdint.h>
48
49#define STRINGIFY(...) STRINGIFY_(__VA_ARGS__)
50#define STRINGIFY_(...) #__VA_ARGS__
51
52#define ELLIPSIS_CONTRACT_VIOLATION(COUNT, VERB, CTYPE, CSTR, ...) \
53({\
54 static char const contract_format_ ## COUNT[] = \
55 __FILE__ ":" STRINGIFY(__LINE__) ": violation of " CTYPE " `" CSTR "`" __VA_OPT__(", ") __VA_ARGS__ "\n";\
56 (VERB \
57 ? fputs(contract_format_ ## COUNT, stderr) \
58 : 0);\
59 })
60
61#define ELLIPSIS_CONTRACT_IMPL(COUNT, COND, ACTION, VERB, CSTR, CTYPE, ...) \
62(((false) || (COND)) \
63 ? (void)0 \
64 : (ELLIPSIS_CONTRACT_VIOLATION(COUNT, VERB, CTYPE, CSTR __VA_OPT__(,) __VA_ARGS__) \
65 , ((false) \
66 ? (void)0 \
67 : ACTION())))
68
69#define ELLIPSIS_TO_VOIDS(...) ((void*)((uintptr_t)((__VA_ARGS__)-(__VA_ARGS__))))
70
71#define ELLIPSIS_TEST_ICE(...) (false ? ELLIPSIS_TO_VOIDS(__VA_ARGS__) : (ellipsis‿contracts‿is_ice*)nullptr)
72
73#define ELLIPSIS_CONTRACT_ICE_OR_TRUE(...) \
74 _Generic( \
75 ELLIPSIS_TEST_ICE(__VA_ARGS__), \
76 ellipsis‿contracts‿is_ice*: (__VA_ARGS__), \
77 default: true)
78
79#define ELLIPSIS_CONTRACT_CHECK_STATIC(CTYPE, COND, CSTR, ...) \
80 ({\
81 static_assert(ELLIPSIS_CONTRACT_ICE_OR_TRUE(COND), \
82 "compile time violation of " CTYPE " " CSTR \
83 __VA_OPT__(", ") __VA_ARGS__ );\
84 })
85
86#define ELLIPSIS_CONTRACT(COUNT, COND, ACTION, VERB, CSTR, CTYPE, ...) \
87 \
88 do { \
89 _Generic( \
90 ELLIPSIS_TEST_ICE(COND), \
91 ellipsis‿contracts‿is_ice*: ELLIPSIS_CONTRACT_CHECK_STATIC(CTYPE, COND, CSTR __VA_OPT__(,) __VA_ARGS__), \
92 default: ELLIPSIS_CONTRACT_IMPL(COUNT, COND, ACTION, VERB, CSTR, CTYPE __VA_OPT__(,) __VA_ARGS__));\
93 } while(false)
94
155typedef struct ellipsis‿str32 ellipsis‿str32;
156struct ellipsis‿str32 {
157#ifndef DOXYGEN_SPECIAL
158 union {
159#endif
165 size_t const length;
171 [[deprecated("use const member length instead")]]
172 size_t length_mod;
173#ifndef DOXYGEN_SPECIAL
174 };
175#endif
182 size_t const capacity;
188 GNU_ATTR_STRICT_FLEX_ARRAY(3)
189 GNU_ATTR_COUNTED_BY(length)
190 ellipsis‿str32‿base array[];
191};
192
193#define ELLIPSIS_STR32_OVERLAY(N) \
194 union {\
195 struct {\
196 size_t const length;\
197 size_t const padding;\
198 unsigned const :(offsetof(ellipsis‿str32, array)-2*sizeof(size_t));\
199 ellipsis‿str32‿base array[N];\
200 };\
201 ellipsis‿str32 fa;\
202 }
203
204#define ELLIPSIS_STR32_STATIC(N, ...) \
205 (({\
206 static const ELLIPSIS_STR32_OVERLAY( \
207 sizeof((ellipsis‿str32‿base[]){__VA_ARGS__ }) \
208 /sizeof(ellipsis‿str32‿base)) \
209 __LOC_ID_1_1 = {\
210 .length = (N), \
211 .array = {__VA_ARGS__ }, \
212 };&__LOC_ID_1_1;})->fa)
213
234#if __clang__ && (__clang_major__ < 30)
235#define ELLIPSIS_STR32_LITERAL_LOCAL(N, ...) ELLIPSIS_STR32_STATIC(N, __VA_ARGS__)
236#else
237#define ELLIPSIS_STR32_LITERAL_LOCAL(N, ...) \
238 ((static const ELLIPSIS_STR32_OVERLAY( \
239 sizeof((ellipsis‿str32‿base[]){__VA_ARGS__ }) \
240 /sizeof(ellipsis‿str32‿base))) \
241 {\
242 .length = (N), \
243 .array = {__VA_ARGS__ }, \
244 }.fa)
245#endif
246
247#define ELLIPSIS_STR32_LITERAL_GLOBAL(N, ...) \
248 ((const ELLIPSIS_STR32_OVERLAY( \
249 sizeof((ellipsis‿str32‿base[]){__VA_ARGS__ }) \
250 /sizeof(ellipsis‿str32‿base))) \
251 {\
252 .length = (N), \
253 .array = {__VA_ARGS__ }, \
254 }.fa)
255
256#define ELLIPSIS_STR32_LITERAL ELLIPSIS_STR32_LITERAL_LOCAL
257
270void ellipsis‿str32‿delete(ellipsis‿str32 const*);
271
280inline void ellipsis‿str32‿move(ellipsis‿str32* __LOC_ID_0_3[restrict static 1], ellipsis‿str32**restrict __LOC_ID_0_4) {
281 if (*__LOC_ID_0_3)
282 ellipsis‿str32‿delete((void*)*__LOC_ID_0_3);
283 if (__LOC_ID_0_4) {
284 *__LOC_ID_0_3= *__LOC_ID_0_4;
285 *__LOC_ID_0_4= nullptr;
286 } else {
287 *__LOC_ID_0_3= nullptr;
288 }
289
290}
291
300inline void ellipsis‿str32‿cmove(ellipsis‿str32 const* __LOC_ID_0_5[restrict static 1], ellipsis‿str32 const**restrict __LOC_ID_0_6) {
301 if (*__LOC_ID_0_5)
302 ellipsis‿str32‿delete((void*)*__LOC_ID_0_5);
303 if (__LOC_ID_0_6) {
304 *__LOC_ID_0_5= *__LOC_ID_0_6;
305 *__LOC_ID_0_6= nullptr;
306 } else {
307 *__LOC_ID_0_5= nullptr;
308 }
309
310}
311
319GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns")
320inline
321ellipsis‿str32* ellipsis‿str32‿alloc(size_t len) {
322 typeof(ellipsis‿str32*) DEFER_LOC_ID_0_1;
323 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
324 DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32*)) {};
325 }
326 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
327 [[__maybe_unused__]] register bool defer_return_flag = false;
328 if (false) {
329 DEFER_ID_1_1:
330 goto DEFER_END_ID_1_2;
331 } else {
332 (void)0 ;
333 /* defer */
334 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
335 unsigned (*DEFER_LOC_ID_1_1)[DEFER_LOC_ID_0_2] = {};
336 if (false) {
337 DEFER_ID_1_2: {
338 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
339 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
340 {ELLIPSIS_CONTRACT(1, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), unreachable, false, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assumption", "out of memory when growing an FA array");}
341 }
342 goto DEFER_ID_1_1;
343 } else
344 (void)0 ;
345 extern typeof(ellipsis‿str32‿alloc) ellipsis‿str32‿alloc‿_Insta;
346 do {
347 /* return mode 2 */
348 defer_return_flag = true;
349 DEFER_LOC_ID_0_1 = ellipsis‿str32‿alloc‿_Insta(len);
350 goto DEFER_ID_1_2;
351 } while(false);
352
353 goto DEFER_ID_1_2;
354 }
355[[__maybe_unused__]] DEFER_END_ID_1_2:;
356 return DEFER_LOC_ID_0_1;
357}
358
374GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns")
375inline
376ellipsis‿str32* ellipsis‿str32‿append(ellipsis‿str32*restrict s, ellipsis‿str32‿base c) {
377 typeof(ellipsis‿str32*) DEFER_LOC_ID_0_1;
378 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
379 DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32*)) {};
380 }
381 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
382 [[__maybe_unused__]] register bool defer_return_flag = false;
383 if (false) {
384 DEFER_ID_1_3:
385 goto DEFER_END_ID_1_4;
386 } else {
387 (void)0 ;
388 /* defer */
389 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
390 unsigned (*DEFER_LOC_ID_1_2)[DEFER_LOC_ID_0_2] = {};
391 if (false) {
392 DEFER_ID_1_4: {
393 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
394 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
395 {ELLIPSIS_CONTRACT(2, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), unreachable, false, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assumption", "out of memory when creating a one element FA array");}
396 }
397 goto DEFER_ID_1_3;
398 } else
399 (void)0 ;
400 do {ELLIPSIS_CONTRACT(3, !s || (s->length < s->capacity) || (s->capacity < SIZE_MAX), abort, true, "¬s ∨ (s→length < s→capacity) ∨ (s→capacity < SIZE_MAX)", "assertion", "FA array is a its limits");} while (false);
401 extern typeof(ellipsis‿str32‿append) ellipsis‿str32‿append‿_Insta;
402 do {
403 /* return mode 2 */
404 defer_return_flag = true;
405 DEFER_LOC_ID_0_1 = ellipsis‿str32‿append‿_Insta(s, c);
406 goto DEFER_ID_1_4;
407 } while(false);
408
409 goto DEFER_ID_1_4;
410 }
411[[__maybe_unused__]] DEFER_END_ID_1_4:;
412 return DEFER_LOC_ID_0_1;
413}
414
422GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns")
423inline
424ellipsis‿str32* ellipsis‿str32‿concat(ellipsis‿str32 const* s, ellipsis‿str32 const* t) {
425 typeof(ellipsis‿str32*) DEFER_LOC_ID_0_1;
426 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
427 DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32*)) {};
428 }
429 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
430 [[__maybe_unused__]] register bool defer_return_flag = false;
431 if (false) {
432 DEFER_ID_1_5:
433 goto DEFER_END_ID_1_6;
434 } else {
435 (void)0 ;
436 /* defer */
437 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
438 unsigned (*DEFER_LOC_ID_1_3)[DEFER_LOC_ID_0_2] = {};
439 if (false) {
440 DEFER_ID_1_6: {
441 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
442 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
443 {ELLIPSIS_CONTRACT(4, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), unreachable, false, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assumption", "out of memory when concatenating two FA arrays");}
444 }
445 goto DEFER_ID_1_5;
446 } else
447 (void)0 ;
448 do {ELLIPSIS_CONTRACT(5, s && t, abort, true, "s ∧ t", "assertion", "argument FA arrays for concatenation must not be null");} while (false);
449 do {ELLIPSIS_CONTRACT(6, s->length <= (SIZE_MAX - t->length), abort, true, "s→length ≤ (SIZE_MAX − t→length)", "assertion", "concatenation of FA would be too long");} while (false);
450 extern typeof(ellipsis‿str32‿concat) ellipsis‿str32‿concat‿_Insta;
451 do {
452 /* return mode 2 */
453 defer_return_flag = true;
454 DEFER_LOC_ID_0_1 = ellipsis‿str32‿concat‿_Insta(s, t);
455 goto DEFER_ID_1_6;
456 } while(false);
457
458 goto DEFER_ID_1_6;
459 }
460[[__maybe_unused__]] DEFER_END_ID_1_6:;
461 return DEFER_LOC_ID_0_1;
462}
463
492GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns")
493inline
494ellipsis‿str32* ellipsis‿str32‿concat_inplace(ellipsis‿str32 const* s, ellipsis‿str32 const* t) {
495 typeof(ellipsis‿str32*) DEFER_LOC_ID_0_1;
496 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
497 DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32*)) {};
498 }
499 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
500 [[__maybe_unused__]] register bool defer_return_flag = false;
501 if (false) {
502 DEFER_ID_1_7:
503 goto DEFER_END_ID_1_8;
504 } else {
505 (void)0 ;
506 /* defer */
507 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
508 unsigned (*DEFER_LOC_ID_1_4)[DEFER_LOC_ID_0_2] = {};
509 if (false) {
510 DEFER_ID_1_8: {
511 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
512 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
513 {ELLIPSIS_CONTRACT(7, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), unreachable, false, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assumption", "out of memory when growing an FA array");}
514 }
515 goto DEFER_ID_1_7;
516 } else
517 (void)0 ;
518 extern typeof(ellipsis‿str32‿concat_inplace) ellipsis‿str32‿concat_inplace‿_Insta;
519 do {
520 /* return mode 2 */
521 defer_return_flag = true;
522 DEFER_LOC_ID_0_1 = ellipsis‿str32‿concat_inplace‿_Insta(s, t);
523 goto DEFER_ID_1_8;
524 } while(false);
525
526 goto DEFER_ID_1_8;
527 }
528[[__maybe_unused__]] DEFER_END_ID_1_8:;
529 return DEFER_LOC_ID_0_1;
530}
531
547GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns")
548inline
549ellipsis‿str32* ellipsis‿str32‿grow(ellipsis‿str32*restrict s, size_t length) {
550 typeof(ellipsis‿str32*) DEFER_LOC_ID_0_1;
551 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
552 DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32*)) {};
553 }
554 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
555 [[__maybe_unused__]] register bool defer_return_flag = false;
556 if (false) {
557 DEFER_ID_1_9:
558 goto DEFER_END_ID_1_10;
559 } else {
560 (void)0 ;
561 /* defer */
562 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
563 unsigned (*DEFER_LOC_ID_1_5)[DEFER_LOC_ID_0_2] = {};
564 if (false) {
565 DEFER_ID_1_10: {
566 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
567 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
568 {ELLIPSIS_CONTRACT(8, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), unreachable, false, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assumption", "out of memory when growing an FA array");}
569 }
570 goto DEFER_ID_1_9;
571 } else
572 (void)0 ;
573 do {ELLIPSIS_CONTRACT(9, !s || ((bool)((s)->capacity)), abort, true, "¬s ∨ ((bool)((s)→capacity))", "assertion", "flexible array object must be in allocated storage to be growable");} while (false);
574 do {ELLIPSIS_CONTRACT(10, !s || s->length < SIZE_MAX, abort, true, "¬s ∨ s→length < SIZE_MAX", "assertion", "FA array is a its limits");} while (false);
575 extern typeof(ellipsis‿str32‿grow) ellipsis‿str32‿grow‿_Insta;
576 do {
577 /* return mode 2 */
578 defer_return_flag = true;
579 DEFER_LOC_ID_0_1 = ellipsis‿str32‿grow‿_Insta(s, length);
580 goto DEFER_ID_1_10;
581 } while(false);
582
583 goto DEFER_ID_1_10;
584 }
585[[__maybe_unused__]] DEFER_END_ID_1_10:;
586 return DEFER_LOC_ID_0_1;
587}
588
606GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns")
607inline
608ellipsis‿str32* ellipsis‿str32‿shrink(ellipsis‿str32 s[restrict static 1], size_t length) {
609 typeof(ellipsis‿str32*) DEFER_LOC_ID_0_1;
610 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
611 DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32*)) {};
612 }
613 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
614 [[__maybe_unused__]] register bool defer_return_flag = false;
615 if (false) {
616 DEFER_ID_1_11:
617 goto DEFER_END_ID_1_12;
618 } else {
619 (void)0 ;
620 /* defer */
621 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
622 unsigned (*DEFER_LOC_ID_1_6)[DEFER_LOC_ID_0_2] = {};
623 if (false) {
624 DEFER_ID_1_12: {
625 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
626 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
627 {ELLIPSIS_CONTRACT(11, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), unreachable, false, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assumption", "out of memory when shrinking an FA array");}
628 }
629 goto DEFER_ID_1_11;
630 } else
631 (void)0 ;
632 do {ELLIPSIS_CONTRACT(12, s, abort, true, "s", "assertion", "can only shrink existing array");} while (false);
633 do {ELLIPSIS_CONTRACT(13, ((bool)((s)->capacity)), abort, true, "((bool)((s)→capacity))", "assertion", "flexible array object must be in allocated storage to be shrinkable");} while (false);
634 do {ELLIPSIS_CONTRACT(14, length <= s->length, abort, true, "length ≤ s→length", "assertion", "can\'t shrink array to make it longer");} while (false);
635 extern typeof(ellipsis‿str32‿shrink) ellipsis‿str32‿shrink‿_Insta;
636 do {
637 /* return mode 2 */
638 defer_return_flag = true;
639 DEFER_LOC_ID_0_1 = ellipsis‿str32‿shrink‿_Insta(s, length);
640 goto DEFER_ID_1_12;
641 } while(false);
642
643 goto DEFER_ID_1_12;
644 }
645[[__maybe_unused__]] DEFER_END_ID_1_12:;
646 return DEFER_LOC_ID_0_1;
647}
648
657GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns")
658inline
659ellipsis‿str32* ellipsis‿str32‿sub(ellipsis‿str32 const*restrict s, size_t pos, size_t len) {
660 typeof(ellipsis‿str32*) DEFER_LOC_ID_0_1;
661 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
662 DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32*)) {};
663 }
664 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
665 [[__maybe_unused__]] register bool defer_return_flag = false;
666 if (false) {
667 DEFER_ID_1_13:
668 goto DEFER_END_ID_1_14;
669 } else {
670 (void)0 ;
671 do {ELLIPSIS_CONTRACT(15, s, abort, true, "s", "assertion", "substring from non-existing string");} while (false);
672 do {ELLIPSIS_CONTRACT(16, pos < s->length, abort, true, "pos < s→length", "assertion", "start of substring is out of bounds");} while (false);
673 /* defer */
674 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
675 unsigned (*DEFER_LOC_ID_1_7)[DEFER_LOC_ID_0_2] = {};
676 if (false) {
677 DEFER_ID_1_14: {
678 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
679 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
680 {ELLIPSIS_CONTRACT(17, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), unreachable, false, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assumption", "out of memory when growing an FA array");}
681 }
682 goto DEFER_ID_1_13;
683 } else
684 (void)0 ;
685 extern typeof(ellipsis‿str32‿sub) ellipsis‿str32‿sub‿_Insta;
686 do {
687 /* return mode 2 */
688 defer_return_flag = true;
689 DEFER_LOC_ID_0_1 = ellipsis‿str32‿sub‿_Insta(s, pos, len);
690 goto DEFER_ID_1_14;
691 } while(false);
692
693 goto DEFER_ID_1_14;
694 }
695[[__maybe_unused__]] DEFER_END_ID_1_14:;
696 return DEFER_LOC_ID_0_1;
697}
698
710GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns")
711inline
712ellipsis‿str32 const* ellipsis‿str32‿cpy_const(ellipsis‿str32 const*restrict s) {
713 typeof(ellipsis‿str32 const*) DEFER_LOC_ID_0_1;
714 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
715 DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32 const*)) {};
716 }
717 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
718 [[__maybe_unused__]] register bool defer_return_flag = false;
719 if (false) {
720 DEFER_ID_1_15:
721 goto DEFER_END_ID_1_16;
722 } else {
723 (void)0 ;
724 do {ELLIPSIS_CONTRACT(18, s, abort, true, "s", "assertion", "copy of non-existing string");} while (false);
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_16: {
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(19, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), unreachable, false, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assumption", "copy operation failed");}
733 }
734 goto DEFER_ID_1_15;
735 } else
736 (void)0 ;
737 extern typeof(ellipsis‿str32‿cpy_const) ellipsis‿str32‿cpy_const‿_Insta;
738 do {
739 /* return mode 2 */
740 defer_return_flag = true;
741 DEFER_LOC_ID_0_1 = ellipsis‿str32‿cpy_const‿_Insta(s);
742 goto DEFER_ID_1_16;
743 } while(false);
744
745 goto DEFER_ID_1_16;
746 }
747[[__maybe_unused__]] DEFER_END_ID_1_16:;
748 return DEFER_LOC_ID_0_1;
749}
750
758GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns")
759inline
760ellipsis‿str32* ellipsis‿str32‿alloc‿_Ctra(size_t len) {
761 typeof(ellipsis‿str32*) DEFER_LOC_ID_0_1;
762 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
763 DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32*)) {};
764 }
765 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
766 [[__maybe_unused__]] register bool defer_return_flag = false;
767 if (false) {
768 DEFER_ID_1_17:
769 goto DEFER_END_ID_1_18;
770 } else {
771 (void)0 ;
772 /* defer */
773 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
774 unsigned (*DEFER_LOC_ID_1_9)[DEFER_LOC_ID_0_2] = {};
775 if (false) {
776 DEFER_ID_1_18: {
777 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
778 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
779 {ELLIPSIS_CONTRACT(20, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), abort, true, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assertion", "out of memory when growing an FA array");}
780 }
781 goto DEFER_ID_1_17;
782 } else
783 (void)0 ;
784 extern typeof(ellipsis‿str32‿alloc‿_Ctra) ellipsis‿str32‿alloc‿_Inner;
785 do {
786 /* return mode 2 */
787 defer_return_flag = true;
788 DEFER_LOC_ID_0_1 = ellipsis‿str32‿alloc‿_Inner(len);
789 goto DEFER_ID_1_18;
790 } while(false);
791
792 goto DEFER_ID_1_18;
793 }
794[[__maybe_unused__]] DEFER_END_ID_1_18:;
795 return DEFER_LOC_ID_0_1;
796}
797
813GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns")
814inline
815ellipsis‿str32* ellipsis‿str32‿append‿_Ctra(ellipsis‿str32*restrict s, ellipsis‿str32‿base c) {
816 typeof(ellipsis‿str32*) DEFER_LOC_ID_0_1;
817 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
818 DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32*)) {};
819 }
820 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
821 [[__maybe_unused__]] register bool defer_return_flag = false;
822 if (false) {
823 DEFER_ID_1_19:
824 goto DEFER_END_ID_1_20;
825 } else {
826 (void)0 ;
827 /* defer */
828 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
829 unsigned (*DEFER_LOC_ID_1_10)[DEFER_LOC_ID_0_2] = {};
830 if (false) {
831 DEFER_ID_1_20: {
832 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
833 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
834 {ELLIPSIS_CONTRACT(21, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), abort, true, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assertion", "out of memory when creating a one element FA array");}
835 }
836 goto DEFER_ID_1_19;
837 } else
838 (void)0 ;
839 do {ELLIPSIS_CONTRACT(22, !s || (s->length < s->capacity) || (s->capacity < SIZE_MAX), unreachable, false, "¬s ∨ (s→length < s→capacity) ∨ (s→capacity < SIZE_MAX)", "assumption", "FA array is a its limits");} while (false);
840 extern typeof(ellipsis‿str32‿append‿_Ctra) ellipsis‿str32‿append‿_Inner;
841 do {
842 /* return mode 2 */
843 defer_return_flag = true;
844 DEFER_LOC_ID_0_1 = ellipsis‿str32‿append‿_Inner(s, c);
845 goto DEFER_ID_1_20;
846 } while(false);
847
848 goto DEFER_ID_1_20;
849 }
850[[__maybe_unused__]] DEFER_END_ID_1_20:;
851 return DEFER_LOC_ID_0_1;
852}
853
861GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns")
862inline
863ellipsis‿str32* ellipsis‿str32‿concat‿_Ctra(ellipsis‿str32 const* s, ellipsis‿str32 const* t) {
864 typeof(ellipsis‿str32*) DEFER_LOC_ID_0_1;
865 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
866 DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32*)) {};
867 }
868 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
869 [[__maybe_unused__]] register bool defer_return_flag = false;
870 if (false) {
871 DEFER_ID_1_21:
872 goto DEFER_END_ID_1_22;
873 } else {
874 (void)0 ;
875 /* defer */
876 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
877 unsigned (*DEFER_LOC_ID_1_11)[DEFER_LOC_ID_0_2] = {};
878 if (false) {
879 DEFER_ID_1_22: {
880 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
881 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
882 {ELLIPSIS_CONTRACT(23, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), abort, true, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assertion", "out of memory when concatenating two FA arrays");}
883 }
884 goto DEFER_ID_1_21;
885 } else
886 (void)0 ;
887 do {ELLIPSIS_CONTRACT(24, s && t, unreachable, false, "s ∧ t", "assumption", "argument FA arrays for concatenation must not be null");} while (false);
888 do {ELLIPSIS_CONTRACT(25, s->length <= (SIZE_MAX - t->length), unreachable, false, "s→length ≤ (SIZE_MAX − t→length)", "assumption", "concatenation of FA would be too long");} while (false);
889 extern typeof(ellipsis‿str32‿concat‿_Ctra) ellipsis‿str32‿concat‿_Inner;
890 do {
891 /* return mode 2 */
892 defer_return_flag = true;
893 DEFER_LOC_ID_0_1 = ellipsis‿str32‿concat‿_Inner(s, t);
894 goto DEFER_ID_1_22;
895 } while(false);
896
897 goto DEFER_ID_1_22;
898 }
899[[__maybe_unused__]] DEFER_END_ID_1_22:;
900 return DEFER_LOC_ID_0_1;
901}
902
931GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns")
932inline
933ellipsis‿str32* ellipsis‿str32‿concat_inplace‿_Ctra(ellipsis‿str32 const* s, ellipsis‿str32 const* t) {
934 typeof(ellipsis‿str32*) DEFER_LOC_ID_0_1;
935 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
936 DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32*)) {};
937 }
938 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
939 [[__maybe_unused__]] register bool defer_return_flag = false;
940 if (false) {
941 DEFER_ID_1_23:
942 goto DEFER_END_ID_1_24;
943 } else {
944 (void)0 ;
945 /* defer */
946 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
947 unsigned (*DEFER_LOC_ID_1_12)[DEFER_LOC_ID_0_2] = {};
948 if (false) {
949 DEFER_ID_1_24: {
950 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
951 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
952 {ELLIPSIS_CONTRACT(26, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), abort, true, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assertion", "out of memory when growing an FA array");}
953 }
954 goto DEFER_ID_1_23;
955 } else
956 (void)0 ;
957 extern typeof(ellipsis‿str32‿concat_inplace‿_Ctra) ellipsis‿str32‿concat_inplace‿_Inner;
958 do {
959 /* return mode 2 */
960 defer_return_flag = true;
961 DEFER_LOC_ID_0_1 = ellipsis‿str32‿concat_inplace‿_Inner(s, t);
962 goto DEFER_ID_1_24;
963 } while(false);
964
965 goto DEFER_ID_1_24;
966 }
967[[__maybe_unused__]] DEFER_END_ID_1_24:;
968 return DEFER_LOC_ID_0_1;
969}
970
986GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns")
987inline
988ellipsis‿str32* ellipsis‿str32‿grow‿_Ctra(ellipsis‿str32*restrict s, size_t length) {
989 typeof(ellipsis‿str32*) DEFER_LOC_ID_0_1;
990 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
991 DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32*)) {};
992 }
993 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
994 [[__maybe_unused__]] register bool defer_return_flag = false;
995 if (false) {
996 DEFER_ID_1_25:
997 goto DEFER_END_ID_1_26;
998 } else {
999 (void)0 ;
1000 /* defer */
1001 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
1002 unsigned (*DEFER_LOC_ID_1_13)[DEFER_LOC_ID_0_2] = {};
1003 if (false) {
1004 DEFER_ID_1_26: {
1005 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
1006 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
1007 {ELLIPSIS_CONTRACT(27, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), abort, true, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assertion", "out of memory when growing an FA array");}
1008 }
1009 goto DEFER_ID_1_25;
1010 } else
1011 (void)0 ;
1012 do {ELLIPSIS_CONTRACT(28, !s || ((bool)((s)->capacity)), unreachable, false, "¬s ∨ ((bool)((s)→capacity))", "assumption", "flexible array object must be in allocated storage to be growable");} while (false);
1013 do {ELLIPSIS_CONTRACT(29, !s || s->length < SIZE_MAX, unreachable, false, "¬s ∨ s→length < SIZE_MAX", "assumption", "FA array is a its limits");} while (false);
1014 extern typeof(ellipsis‿str32‿grow‿_Ctra) ellipsis‿str32‿grow‿_Inner;
1015 do {
1016 /* return mode 2 */
1017 defer_return_flag = true;
1018 DEFER_LOC_ID_0_1 = ellipsis‿str32‿grow‿_Inner(s, length);
1019 goto DEFER_ID_1_26;
1020 } while(false);
1021
1022 goto DEFER_ID_1_26;
1023 }
1024[[__maybe_unused__]] DEFER_END_ID_1_26:;
1025 return DEFER_LOC_ID_0_1;
1026}
1027
1045GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns")
1046inline
1047ellipsis‿str32* ellipsis‿str32‿shrink‿_Ctra(ellipsis‿str32 s[restrict static 1], size_t length) {
1048 typeof(ellipsis‿str32*) DEFER_LOC_ID_0_1;
1049 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
1050 DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32*)) {};
1051 }
1052 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
1053 [[__maybe_unused__]] register bool defer_return_flag = false;
1054 if (false) {
1055 DEFER_ID_1_27:
1056 goto DEFER_END_ID_1_28;
1057 } else {
1058 (void)0 ;
1059 /* defer */
1060 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
1061 unsigned (*DEFER_LOC_ID_1_14)[DEFER_LOC_ID_0_2] = {};
1062 if (false) {
1063 DEFER_ID_1_28: {
1064 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
1065 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
1066 {ELLIPSIS_CONTRACT(30, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), abort, true, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assertion", "out of memory when shrinking an FA array");}
1067 }
1068 goto DEFER_ID_1_27;
1069 } else
1070 (void)0 ;
1071 do {ELLIPSIS_CONTRACT(31, s, unreachable, false, "s", "assumption", "can only shrink existing array");} while (false);
1072 do {ELLIPSIS_CONTRACT(32, ((bool)((s)->capacity)), unreachable, false, "((bool)((s)→capacity))", "assumption", "flexible array object must be in allocated storage to be shrinkable");} while (false);
1073 do {ELLIPSIS_CONTRACT(33, length <= s->length, unreachable, false, "length ≤ s→length", "assumption", "can\'t shrink array to make it longer");} while (false);
1074 extern typeof(ellipsis‿str32‿shrink‿_Ctra) ellipsis‿str32‿shrink‿_Inner;
1075 do {
1076 /* return mode 2 */
1077 defer_return_flag = true;
1078 DEFER_LOC_ID_0_1 = ellipsis‿str32‿shrink‿_Inner(s, length);
1079 goto DEFER_ID_1_28;
1080 } while(false);
1081
1082 goto DEFER_ID_1_28;
1083 }
1084[[__maybe_unused__]] DEFER_END_ID_1_28:;
1085 return DEFER_LOC_ID_0_1;
1086}
1087
1096GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns")
1097inline
1098ellipsis‿str32* ellipsis‿str32‿sub‿_Ctra(ellipsis‿str32 const*restrict s, size_t pos, size_t len) {
1099 typeof(ellipsis‿str32*) DEFER_LOC_ID_0_1;
1100 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
1101 DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32*)) {};
1102 }
1103 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
1104 [[__maybe_unused__]] register bool defer_return_flag = false;
1105 if (false) {
1106 DEFER_ID_1_29:
1107 goto DEFER_END_ID_1_30;
1108 } else {
1109 (void)0 ;
1110 do {ELLIPSIS_CONTRACT(34, s, unreachable, false, "s", "assumption", "substring from non-existing string");} while (false);
1111 do {ELLIPSIS_CONTRACT(35, pos < s->length, unreachable, false, "pos < s→length", "assumption", "start of substring is out of bounds");} while (false);
1112 /* defer */
1113 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
1114 unsigned (*DEFER_LOC_ID_1_15)[DEFER_LOC_ID_0_2] = {};
1115 if (false) {
1116 DEFER_ID_1_30: {
1117 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
1118 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
1119 {ELLIPSIS_CONTRACT(36, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), abort, true, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assertion", "out of memory when growing an FA array");}
1120 }
1121 goto DEFER_ID_1_29;
1122 } else
1123 (void)0 ;
1124 extern typeof(ellipsis‿str32‿sub‿_Ctra) ellipsis‿str32‿sub‿_Inner;
1125 do {
1126 /* return mode 2 */
1127 defer_return_flag = true;
1128 DEFER_LOC_ID_0_1 = ellipsis‿str32‿sub‿_Inner(s, pos, len);
1129 goto DEFER_ID_1_30;
1130 } while(false);
1131
1132 goto DEFER_ID_1_30;
1133 }
1134[[__maybe_unused__]] DEFER_END_ID_1_30:;
1135 return DEFER_LOC_ID_0_1;
1136}
1137
1149GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns")
1150inline
1151ellipsis‿str32 const* ellipsis‿str32‿cpy_const‿_Ctra(ellipsis‿str32 const*restrict s) {
1152 typeof(ellipsis‿str32 const*) DEFER_LOC_ID_0_1;
1153 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
1154 DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32 const*)) {};
1155 }
1156 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
1157 [[__maybe_unused__]] register bool defer_return_flag = false;
1158 if (false) {
1159 DEFER_ID_1_31:
1160 goto DEFER_END_ID_1_32;
1161 } else {
1162 (void)0 ;
1163 do {ELLIPSIS_CONTRACT(37, s, unreachable, false, "s", "assumption", "copy of non-existing string");} while (false);
1164 /* defer */
1165 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
1166 unsigned (*DEFER_LOC_ID_1_16)[DEFER_LOC_ID_0_2] = {};
1167 if (false) {
1168 DEFER_ID_1_32: {
1169 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
1170 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
1171 {ELLIPSIS_CONTRACT(38, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), abort, true, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assertion", "copy operation failed");}
1172 }
1173 goto DEFER_ID_1_31;
1174 } else
1175 (void)0 ;
1176 extern typeof(ellipsis‿str32‿cpy_const‿_Ctra) ellipsis‿str32‿cpy_const‿_Inner;
1177 do {
1178 /* return mode 2 */
1179 defer_return_flag = true;
1180 DEFER_LOC_ID_0_1 = ellipsis‿str32‿cpy_const‿_Inner(s);
1181 goto DEFER_ID_1_32;
1182 } while(false);
1183
1184 goto DEFER_ID_1_32;
1185 }
1186[[__maybe_unused__]] DEFER_END_ID_1_32:;
1187 return DEFER_LOC_ID_0_1;
1188}
1189
1203GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns") ellipsis‿str32* ellipsis‿str32‿remove(ellipsis‿str32 s[restrict static 1], size_t);
1204
1215inline
1216void ellipsis‿str32‿base‿destroy(size_t _n, ellipsis‿str32‿base _ar[static _n]) {
1217 memset(_ar, 0, _n*sizeof(_ar[0]));
1218}
1219
1229int ellipsis‿str32‿compare(ellipsis‿str32 const* s, ellipsis‿str32 const* t);
1230
1239GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns")
1240inline
1241ellipsis‿str32* ellipsis‿str32‿cpy(ellipsis‿str32 const*restrict __LOC_ID_0_7) {
1242 typeof(ellipsis‿str32*) DEFER_LOC_ID_0_1;
1243 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
1244 DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32*)) {};
1245 }
1246 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
1247 [[__maybe_unused__]] register bool defer_return_flag = false;
1248 if (false) {
1249 DEFER_ID_1_33:
1250 goto DEFER_END_ID_1_34;
1251 } else {
1252 (void)0 ;
1253 ELLIPSIS_CONTRACT(39, __LOC_ID_0_7, abort, true, "__LOC(0, 1)", "precondition", "copy of non-existing string");
1254 do {
1255 /* return mode 2 */
1256 defer_return_flag = true;
1257 DEFER_LOC_ID_0_1 = ellipsis‿str32‿sub(__LOC_ID_0_7, 0, __LOC_ID_0_7->length);
1258 goto DEFER_ID_1_33;
1259 } while(false);
1260
1261 goto DEFER_ID_1_33;
1262 }
1263[[__maybe_unused__]] DEFER_END_ID_1_34:;
1264 return DEFER_LOC_ID_0_1;
1265}
1266
1270inline
1271int ellipsis‿str32‿compareInternal(void const* A, void const* B) {
1272 ellipsis‿str32‿base const* a = A;
1273 ellipsis‿str32‿base const* b = B;
1274 return ellipsis‿str32‿base‿compare(a, b);
1275}
1276
1289inline
1290void ellipsis‿str32‿sort(ellipsis‿str32* p, size_t offs, size_t len) {
1291 extern void (qsort)(void*, size_t, size_t, int (*)(const void*, const void*));
1292 if (offs < p->length) {
1293 size_t rlen = p->length - offs;
1294 if (rlen < len) len = rlen;
1295 if (len > 1) {
1296 qsort((void*)(p->array+offs), len, sizeof(ellipsis‿str32‿base), ellipsis‿str32‿compareInternal);
1297 }
1298 }
1299}
1300
1309inline
1310ellipsis‿str32‿base const* ellipsis‿str32‿search(ellipsis‿str32‿base const el[static 1], ellipsis‿str32 const* p, size_t offs, size_t len) {
1311 extern void* (bsearch)(void const*, void const*, size_t, size_t, int (*)(const void*, const void*));
1312 if (offs < p->length) {
1313 size_t rlen = p->length - offs;
1314 if (rlen < len) len = rlen;
1315 if (len > 0) {
1316 return bsearch((void const*)el, (void const*)(p->array+offs), len, sizeof(ellipsis‿str32‿base), ellipsis‿str32‿compareInternal);
1317 }
1318 }
1319 return nullptr;
1320}
1321
1333GNU_ATTR_RETURNS_NONNULL STDC_ATTR_NODISCARD("functions for " "ellipsis∷str32" " need to keep pointer returns")
1334ellipsis‿str32* ellipsis‿str32‿construct(size_t __LOC_ID_0_8, char const[static __LOC_ID_0_8]);
1335
1336#ifndef DOXYGEN_SPECIAL
1337#define ellipsis_str32_construct(LEN, S) ELLIPSIS_ERROR_CHECK(ellipsis‿str32‿construct, "unable to construct string", LEN, S)
1338#endif
1339
1346#define ELLIPSIS_STR32_CONSTRUCT(S) ellipsis_str32_construct(sizeof S - 1, "" S "")
1347
1371#define ELLIPSIS_STR32_STRING_LITERAL(S) ELLIPSIS_STR32_LITERAL((sizeof(U"" S)/sizeof(U'0')) - 1, U"" S U"")
1372
1378int ellipsis‿str32‿fputs(ellipsis‿str32 const*restrict, FILE *);
1379int ellipsis‿str32‿fputs_entities(ellipsis‿str32 const*restrict s, FILE *stream);
1380
1389GNU_ATTR_MALLOC()
1390inline
1391char* (ellipsis‿str32‿dup)(ellipsis‿str32 const*restrict __LOC_ID_0_9) {
1392 typeof(char*) DEFER_LOC_ID_0_1;
1393 if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
1394 DEFER_LOC_ID_0_1 = (typeof(char*)) {};
1395 }
1396 [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
1397 [[__maybe_unused__]] register bool defer_return_flag = false;
1398 if (false) {
1399 DEFER_ID_1_34:
1400 goto DEFER_END_ID_1_36;
1401 } else {
1402 (void)0 ;
1403 ELLIPSIS_CONTRACT(40, __LOC_ID_0_9, abort, true, "__LOC(0, 1)", "precondition", "attempt to copy empty string");
1404 /* defer */
1405 [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
1406 unsigned (*DEFER_LOC_ID_1_17)[DEFER_LOC_ID_0_2] = {};
1407 if (false) {
1408 DEFER_ID_1_35: {
1409 [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
1410 register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag = false;
1411 {ELLIPSIS_CONTRACT(41, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), unreachable, false, "defer_return_value", "conclusion", "could not copy UTF-32 string to multi-byte");}
1412 }
1413 goto DEFER_ID_1_34;
1414 } else
1415 (void)0 ;
1416 extern typeof(ellipsis‿str32‿dup) ellipsis‿str32‿dup‿inst;
1417 do {
1418 /* return mode 2 */
1419 defer_return_flag = true;
1420 DEFER_LOC_ID_0_1 = ellipsis‿str32‿dup‿inst(__LOC_ID_0_9);
1421 goto DEFER_ID_1_35;
1422 } while(false);
1423
1424 goto DEFER_ID_1_35;
1425 }
1426[[__maybe_unused__]] DEFER_END_ID_1_36:;
1427 return DEFER_LOC_ID_0_1;
1428}
1429
1430#endif
GNU_ATTR_COUNTED_BY
#define GNU_ATTR_COUNTED_BY(...)
Definition ellipsis-error.h:59
STDC_ATTR_NODISCARD
#define STDC_ATTR_NODISCARD(...)
Definition ellipsis-error.h:68
GNU_ATTR_MALLOC
#define GNU_ATTR_MALLOC(...)
Definition ellipsis-error.h:44
GNU_ATTR_STRICT_FLEX_ARRAY
#define GNU_ATTR_STRICT_FLEX_ARRAY(...)
Definition ellipsis-error.h:54
GNU_ATTR_RETURNS_NONNULL
#define GNU_ATTR_RETURNS_NONNULL
Definition ellipsis-error.h:34
ellipsis‿contracts‿is_ice
struct ellipsis‿contracts‿is_ice ellipsis‿contracts‿is_ice
Definition ellipsis-expression.c:24
ellipsis‿str32‿append‿_Inner
ellipsis‿str32 * ellipsis‿str32‿append‿_Inner(ellipsis‿str32 *restrict s, s->array[0] c)
Definition ellipsis-str32.c:169
ellipsis‿str32‿grow‿_Inner
ellipsis‿str32 * ellipsis‿str32‿grow‿_Inner(ellipsis‿str32 *restrict s, size_t length)
Definition ellipsis-str32.c:212
ellipsis‿str32‿concat‿_Inner
ellipsis‿str32 * ellipsis‿str32‿concat‿_Inner(ellipsis‿str32 const *s, ellipsis‿str32 const *t)
Definition ellipsis-str32.c:178
ellipsis‿str32‿dup‿inst
char *() ellipsis‿str32‿dup‿inst(ellipsis‿str32 const *restrict s)
Definition ellipsis-str32.c:866
ellipsis‿str32‿sub‿_Inner
ellipsis‿str32 * ellipsis‿str32‿sub‿_Inner(ellipsis‿str32 const *s, size_t pos, size_t len)
Definition ellipsis-str32.c:250
ellipsis‿str32‿alloc‿_Inner
ellipsis‿str32 * ellipsis‿str32‿alloc‿_Inner(size_t len)
Definition ellipsis-str32.c:157
ellipsis‿str32‿dup
ellipsis‿str32‿dup ellipsis‿str32‿dup
ellipsis‿str32‿cpy_const‿_Inner
ellipsis‿str32 const * ellipsis‿str32‿cpy_const‿_Inner(ellipsis‿str32 const *restrict s)
Definition ellipsis-str32.c:267
ellipsis‿str32‿shrink‿_Inner
ellipsis‿str32 * ellipsis‿str32‿shrink‿_Inner(ellipsis‿str32 s[restrict static 1], size_t length)
Definition ellipsis-str32.c:238
ellipsis‿str32‿concat_inplace‿_Inner
ellipsis‿str32 * ellipsis‿str32‿concat_inplace‿_Inner(ellipsis‿str32 const *s0, ellipsis‿str32 const *t)
Definition ellipsis-str32.c:193
ellipsis‿str32‿fputs_entities
int ellipsis‿str32‿fputs_entities(ellipsis‿str32 const *restrict s, FILE *stream)
Definition ellipsis-str32.c:758
ellipsis‿contracts‿verbose‿dynamic
thread_local bool volatile ellipsis‿contracts‿verbose‿dynamic
ELLIPSIS_CONTRACT
#define ELLIPSIS_CONTRACT(COUNT, COND, ACTION, VERB, CSTR, CTYPE,...)
Definition ellipsis-str32.h:86
ellipsis‿contracts‿proceed‿dynamic
thread_local bool volatile ellipsis‿contracts‿proceed‿dynamic
ellipsis‿contracts‿ignore‿dynamic
thread_local bool volatile ellipsis‿contracts‿ignore‿dynamic
ellipsis‿str32
A structure with a flexible array member of base type ellipsis‿str32‿base.
Definition ellipsis-str32.h:156
ellipsis‿str32::ellipsis‿str32‿remove
ellipsis‿str32 * ellipsis‿str32‿remove(ellipsis‿str32 s[restrict static 1], size_t)
Remove (at most) the indicated amount of elements from the ellipsis‿str32 return a new one and delete...
Definition ellipsis-str32.c:118
ellipsis‿str32::ellipsis‿str32‿fputs
int ellipsis‿str32‿fputs(ellipsis‿str32 const *restrict, FILE *)
Write a ellipsis‿str32 to a stream.
ellipsis‿str32::ellipsis‿str32‿alloc
ellipsis‿str32 * ellipsis‿str32‿alloc(size_t len)
Allocate a ellipsis‿str32 with elements as given by the parameter.
Definition ellipsis-str32.h:321
ellipsis‿str32::ellipsis‿str32‿cpy_const‿_Insta
ellipsis‿str32 const * ellipsis‿str32‿cpy_const‿_Insta(ellipsis‿str32 const *restrict s)
Copy or link to a const-qualified ellipsis‿str32.
Definition ellipsis-str32.c:596
ellipsis‿str32::ellipsis‿str32‿cpy
ellipsis‿str32 * ellipsis‿str32‿cpy(ellipsis‿str32 const *restrict __LOC_ID_0_7)
Allocate a ellipsis‿str32 and copy the data to which the parameter points into it.
Definition ellipsis-str32.h:1241
ellipsis‿str32::ellipsis‿str32‿concat
ellipsis‿str32 * ellipsis‿str32‿concat(ellipsis‿str32 const *s, ellipsis‿str32 const *t)
Concatenate two ellipsis‿str32 into a new one.
Definition ellipsis-str32.h:424
ellipsis‿str32::ellipsis‿str32‿compareInternal
int ellipsis‿str32‿compareInternal(void const *A, void const *B)
Definition ellipsis-str32.h:1271
ellipsis‿str32::ellipsis‿str32‿alloc‿_Insta
ellipsis‿str32 * ellipsis‿str32‿alloc‿_Insta(size_t len)
Allocate a ellipsis‿str32 with elements as given by the parameter.
Definition ellipsis-str32.c:282
ellipsis‿str32::length
size_t const length
Current length of this instance.
Definition ellipsis-str32.h:165
ellipsis‿str32::ellipsis‿str32‿base‿destroy
void ellipsis‿str32‿base‿destroy(size_t _n, ellipsis‿str32‿base _ar[static _n])
Destroy an element of type ellipsis‿str32‿base.
Definition ellipsis-str32.h:1216
ellipsis‿str32::ellipsis‿str32‿base‿compare
int ellipsis‿str32‿base‿compare(ellipsis‿str32‿base const *__LOC_ID_0_1, ellipsis‿str32‿base const *__LOC_ID_0_2)
compare two char32_t by value
Definition ellipsis-str32.h:27
ellipsis‿str32::ellipsis‿str32‿concat_inplace
ellipsis‿str32 * ellipsis‿str32‿concat_inplace(ellipsis‿str32 const *s, ellipsis‿str32 const *t)
Concatenate two ellipsis‿str32 into a new one and delete s.
Definition ellipsis-str32.h:494
ellipsis‿str32::ellipsis‿str32‿append‿_Ctra
ellipsis‿str32 * ellipsis‿str32‿append‿_Ctra(ellipsis‿str32 *restrict s, ellipsis‿str32‿base c)
Append a new element to a ellipsis‿str32 and return a new object.
Definition ellipsis-str32.h:815
ellipsis‿str32::ellipsis‿str32‿shrink‿_Insta
ellipsis‿str32 * ellipsis‿str32‿shrink‿_Insta(ellipsis‿str32 s[restrict static 1], size_t length)
Shrink the ellipsis‿str32 to exactly the indicated amount of elements return a new one and delete the...
Definition ellipsis-str32.c:514
ellipsis‿str32::ellipsis‿str32‿sub
ellipsis‿str32 * ellipsis‿str32‿sub(ellipsis‿str32 const *restrict s, size_t pos, size_t len)
Allocate a ellipsis‿str32 with len elements and copy the data from *s at position pos onward.
Definition ellipsis-str32.h:659
ellipsis‿str32::ellipsis‿str32‿cpy_const
ellipsis‿str32 const * ellipsis‿str32‿cpy_const(ellipsis‿str32 const *restrict s)
Copy or link to a const-qualified ellipsis‿str32.
Definition ellipsis-str32.h:712
ellipsis‿str32::ellipsis‿str32‿cmove
void ellipsis‿str32‿cmove(ellipsis‿str32 const *__LOC_ID_0_5[restrict static 1], ellipsis‿str32 const **restrict __LOC_ID_0_6)
Move a ellipsis‿str32 const pointed to by the second parameter to the one pointed to by the first.
Definition ellipsis-str32.h:300
ellipsis‿str32::ellipsis‿str32‿move
void ellipsis‿str32‿move(ellipsis‿str32 *__LOC_ID_0_3[restrict static 1], ellipsis‿str32 **restrict __LOC_ID_0_4)
Move a ellipsis‿str32 pointed to by the second parameter to the one pointed to by the first.
Definition ellipsis-str32.h:280
ellipsis‿str32::ellipsis‿str32‿concat_inplace‿_Ctra
ellipsis‿str32 * ellipsis‿str32‿concat_inplace‿_Ctra(ellipsis‿str32 const *s, ellipsis‿str32 const *t)
Concatenate two ellipsis‿str32 into a new one and delete s.
Definition ellipsis-str32.h:933
ellipsis‿str32::ellipsis‿str32‿grow‿_Insta
ellipsis‿str32 * ellipsis‿str32‿grow‿_Insta(ellipsis‿str32 *restrict s, size_t length)
Grow the ellipsis‿str32 to (at least) the indicated amount of elements return a new one and delete th...
Definition ellipsis-str32.c:466
ellipsis‿str32::length_mod
size_t length_mod
Modifiable length of this instance.
Definition ellipsis-str32.h:172
ellipsis‿str32::ellipsis‿str32‿sub‿_Ctra
ellipsis‿str32 * ellipsis‿str32‿sub‿_Ctra(ellipsis‿str32 const *restrict s, size_t pos, size_t len)
Allocate a ellipsis‿str32 with len elements and copy the data from *s at position pos onward.
Definition ellipsis-str32.h:1098
ellipsis‿str32::ellipsis‿str32‿concat‿_Ctra
ellipsis‿str32 * ellipsis‿str32‿concat‿_Ctra(ellipsis‿str32 const *s, ellipsis‿str32 const *t)
Concatenate two ellipsis‿str32 into a new one.
Definition ellipsis-str32.h:863
ellipsis‿str32::ellipsis‿str32‿shrink‿_Ctra
ellipsis‿str32 * ellipsis‿str32‿shrink‿_Ctra(ellipsis‿str32 s[restrict static 1], size_t length)
Shrink the ellipsis‿str32 to exactly the indicated amount of elements return a new one and delete the...
Definition ellipsis-str32.h:1047
ellipsis‿str32::ellipsis‿str32‿cpy_const‿_Ctra
ellipsis‿str32 const * ellipsis‿str32‿cpy_const‿_Ctra(ellipsis‿str32 const *restrict s)
Copy or link to a const-qualified ellipsis‿str32.
Definition ellipsis-str32.h:1151
ellipsis‿str32::ellipsis‿str32‿alloc‿_Ctra
ellipsis‿str32 * ellipsis‿str32‿alloc‿_Ctra(size_t len)
Allocate a ellipsis‿str32 with elements as given by the parameter.
Definition ellipsis-str32.h:760
ellipsis‿str32::ellipsis‿str32‿delete
void ellipsis‿str32‿delete(ellipsis‿str32 const *)
Delete a ellipsis‿str32 pointed to by the parameter.
Definition ellipsis-str32.c:625
ellipsis‿str32::ellipsis‿str32‿shrink
ellipsis‿str32 * ellipsis‿str32‿shrink(ellipsis‿str32 s[restrict static 1], size_t length)
Shrink the ellipsis‿str32 to exactly the indicated amount of elements return a new one and delete the...
Definition ellipsis-str32.h:608
ellipsis‿str32::ellipsis‿str32‿search
ellipsis‿str32‿base const * ellipsis‿str32‿search(ellipsis‿str32‿base const el[static 1], ellipsis‿str32 const *p, size_t offs, size_t len)
search for an element in a ellipsis‿str32
Definition ellipsis-str32.h:1310
ellipsis‿str32::ellipsis‿str32‿grow‿_Ctra
ellipsis‿str32 * ellipsis‿str32‿grow‿_Ctra(ellipsis‿str32 *restrict s, size_t length)
Grow the ellipsis‿str32 to (at least) the indicated amount of elements return a new one and delete th...
Definition ellipsis-str32.h:988
ellipsis‿str32::ellipsis‿str32‿append
ellipsis‿str32 * ellipsis‿str32‿append(ellipsis‿str32 *restrict s, ellipsis‿str32‿base c)
Append a new element to a ellipsis‿str32 and return a new object.
Definition ellipsis-str32.h:376
ellipsis‿str32::ellipsis‿str32‿concat_inplace‿_Insta
ellipsis‿str32 * ellipsis‿str32‿concat_inplace‿_Insta(ellipsis‿str32 const *s, ellipsis‿str32 const *t)
Concatenate two ellipsis‿str32 into a new one and delete s.
Definition ellipsis-str32.c:422
ellipsis‿str32::ellipsis‿str32‿base
char32_t ellipsis‿str32‿base
Definition ellipsis-str32.h:20
ellipsis‿str32::ellipsis‿str32‿append‿_Insta
ellipsis‿str32 * ellipsis‿str32‿append‿_Insta(ellipsis‿str32 *restrict s, ellipsis‿str32‿base c)
Append a new element to a ellipsis‿str32 and return a new object.
Definition ellipsis-str32.c:326
ellipsis‿str32::ellipsis‿str32‿construct
ellipsis‿str32 * ellipsis‿str32‿construct(size_t __LOC_ID_0_8, char const [static __LOC_ID_0_8])
Construct a ellipsis‿str32 from a character array of length len.
ellipsis‿str32::array
ellipsis‿str32‿base array[]
The current data array.
Definition ellipsis-str32.h:190
ellipsis‿str32::ellipsis‿str32‿concat‿_Insta
ellipsis‿str32 * ellipsis‿str32‿concat‿_Insta(ellipsis‿str32 const *s, ellipsis‿str32 const *t)
Concatenate two ellipsis‿str32 into a new one.
Definition ellipsis-str32.c:363
ellipsis‿str32::capacity
size_t const capacity
Maximal length of this instance.
Definition ellipsis-str32.h:182
ellipsis‿str32::ellipsis‿str32‿grow
ellipsis‿str32 * ellipsis‿str32‿grow(ellipsis‿str32 *restrict s, size_t length)
Grow the ellipsis‿str32 to (at least) the indicated amount of elements return a new one and delete th...
Definition ellipsis-str32.h:549
ellipsis‿str32::ellipsis‿str32‿sub‿_Insta
ellipsis‿str32 * ellipsis‿str32‿sub‿_Insta(ellipsis‿str32 const *restrict s, size_t pos, size_t len)
Allocate a ellipsis‿str32 with len elements and copy the data from *s at position pos onward.
Definition ellipsis-str32.c:554
ellipsis‿str32::ellipsis‿str32‿sort
void ellipsis‿str32‿sort(ellipsis‿str32 *p, size_t offs, size_t len)
sort a ellipsis‿str32 in place.
Definition ellipsis-str32.h:1290
ellipsis‿str32::ellipsis‿str32‿compare
int ellipsis‿str32‿compare(ellipsis‿str32 const *s, ellipsis‿str32 const *t)
Compare two arrays lexicographically.
Definition ellipsis-str32.c:129
eĿlipsis 20250309