diff options
author | RincewindsHat <12514511+RincewindsHat@users.noreply.github.com> | 2022-02-07 15:01:19 (GMT) |
---|---|---|
committer | RincewindsHat <12514511+RincewindsHat@users.noreply.github.com> | 2022-08-23 15:06:16 (GMT) |
commit | fa1ac7ecb247faf58fe65740c0d40e0585f684c9 (patch) | |
tree | ad9ab0cf4e9fcf734aafdd17c98855144b437453 /gl/malloc/dynarray-skeleton.gl.h | |
parent | c233d88ed75f92c3d06d4d30ed2f566fc4cf5249 (diff) | |
download | monitoring-plugins-fa1ac7ecb247faf58fe65740c0d40e0585f684c9.tar.gz |
Add more header files from gnulib
Diffstat (limited to 'gl/malloc/dynarray-skeleton.gl.h')
-rw-r--r-- | gl/malloc/dynarray-skeleton.gl.h | 529 |
1 files changed, 529 insertions, 0 deletions
diff --git a/gl/malloc/dynarray-skeleton.gl.h b/gl/malloc/dynarray-skeleton.gl.h new file mode 100644 index 0000000..b48c6a9 --- /dev/null +++ b/gl/malloc/dynarray-skeleton.gl.h | |||
@@ -0,0 +1,529 @@ | |||
1 | /* DO NOT EDIT! GENERATED AUTOMATICALLY! */ | ||
2 | /* Type-safe arrays which grow dynamically. | ||
3 | Copyright (C) 2017-2021 Free Software Foundation, Inc. | ||
4 | This file is part of the GNU C Library. | ||
5 | |||
6 | The GNU C Library is free software; you can redistribute it and/or | ||
7 | modify it under the terms of the GNU Lesser General Public | ||
8 | License as published by the Free Software Foundation; either | ||
9 | version 2.1 of the License, or (at your option) any later version. | ||
10 | |||
11 | The GNU C Library is distributed in the hope that it will be useful, | ||
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
14 | Lesser General Public License for more details. | ||
15 | |||
16 | You should have received a copy of the GNU Lesser General Public | ||
17 | License along with the GNU C Library; if not, see | ||
18 | <https://www.gnu.org/licenses/>. */ | ||
19 | |||
20 | /* Pre-processor macros which act as parameters: | ||
21 | |||
22 | DYNARRAY_STRUCT | ||
23 | The struct tag of dynamic array to be defined. | ||
24 | DYNARRAY_ELEMENT | ||
25 | The type name of the element type. Elements are copied | ||
26 | as if by memcpy, and can change address as the dynamic | ||
27 | array grows. | ||
28 | DYNARRAY_PREFIX | ||
29 | The prefix of the functions which are defined. | ||
30 | |||
31 | The following parameters are optional: | ||
32 | |||
33 | DYNARRAY_ELEMENT_FREE | ||
34 | DYNARRAY_ELEMENT_FREE (E) is evaluated to deallocate the | ||
35 | contents of elements. E is of type DYNARRAY_ELEMENT *. | ||
36 | DYNARRAY_ELEMENT_INIT | ||
37 | DYNARRAY_ELEMENT_INIT (E) is evaluated to initialize a new | ||
38 | element. E is of type DYNARRAY_ELEMENT *. | ||
39 | If DYNARRAY_ELEMENT_FREE but not DYNARRAY_ELEMENT_INIT is | ||
40 | defined, new elements are automatically zero-initialized. | ||
41 | Otherwise, new elements have undefined contents. | ||
42 | DYNARRAY_INITIAL_SIZE | ||
43 | The size of the statically allocated array (default: | ||
44 | at least 2, more elements if they fit into 128 bytes). | ||
45 | Must be a preprocessor constant. If DYNARRAY_INITIAL_SIZE is 0, | ||
46 | there is no statically allocated array at, and all non-empty | ||
47 | arrays are heap-allocated. | ||
48 | DYNARRAY_FINAL_TYPE | ||
49 | The name of the type which holds the final array. If not | ||
50 | defined, is PREFIX##finalize not provided. DYNARRAY_FINAL_TYPE | ||
51 | must be a struct type, with members of type DYNARRAY_ELEMENT and | ||
52 | size_t at the start (in this order). | ||
53 | |||
54 | These macros are undefined after this header file has been | ||
55 | included. | ||
56 | |||
57 | The following types are provided (their members are private to the | ||
58 | dynarray implementation): | ||
59 | |||
60 | struct DYNARRAY_STRUCT | ||
61 | |||
62 | The following functions are provided: | ||
63 | |||
64 | void DYNARRAY_PREFIX##init (struct DYNARRAY_STRUCT *); | ||
65 | void DYNARRAY_PREFIX##free (struct DYNARRAY_STRUCT *); | ||
66 | bool DYNARRAY_PREFIX##has_failed (const struct DYNARRAY_STRUCT *); | ||
67 | void DYNARRAY_PREFIX##mark_failed (struct DYNARRAY_STRUCT *); | ||
68 | size_t DYNARRAY_PREFIX##size (const struct DYNARRAY_STRUCT *); | ||
69 | DYNARRAY_ELEMENT *DYNARRAY_PREFIX##begin (const struct DYNARRAY_STRUCT *); | ||
70 | DYNARRAY_ELEMENT *DYNARRAY_PREFIX##end (const struct DYNARRAY_STRUCT *); | ||
71 | DYNARRAY_ELEMENT *DYNARRAY_PREFIX##at (struct DYNARRAY_STRUCT *, size_t); | ||
72 | void DYNARRAY_PREFIX##add (struct DYNARRAY_STRUCT *, DYNARRAY_ELEMENT); | ||
73 | DYNARRAY_ELEMENT *DYNARRAY_PREFIX##emplace (struct DYNARRAY_STRUCT *); | ||
74 | bool DYNARRAY_PREFIX##resize (struct DYNARRAY_STRUCT *, size_t); | ||
75 | void DYNARRAY_PREFIX##remove_last (struct DYNARRAY_STRUCT *); | ||
76 | void DYNARRAY_PREFIX##clear (struct DYNARRAY_STRUCT *); | ||
77 | |||
78 | The following functions are provided are provided if the | ||
79 | prerequisites are met: | ||
80 | |||
81 | bool DYNARRAY_PREFIX##finalize (struct DYNARRAY_STRUCT *, | ||
82 | DYNARRAY_FINAL_TYPE *); | ||
83 | (if DYNARRAY_FINAL_TYPE is defined) | ||
84 | DYNARRAY_ELEMENT *DYNARRAY_PREFIX##finalize (struct DYNARRAY_STRUCT *, | ||
85 | size_t *); | ||
86 | (if DYNARRAY_FINAL_TYPE is not defined) | ||
87 | */ | ||
88 | |||
89 | #include <malloc/dynarray.gl.h> | ||
90 | |||
91 | #include <errno.h> | ||
92 | #include <stdlib.h> | ||
93 | #include <string.h> | ||
94 | |||
95 | #ifndef DYNARRAY_STRUCT | ||
96 | # error "DYNARRAY_STRUCT must be defined" | ||
97 | #endif | ||
98 | |||
99 | #ifndef DYNARRAY_ELEMENT | ||
100 | # error "DYNARRAY_ELEMENT must be defined" | ||
101 | #endif | ||
102 | |||
103 | #ifndef DYNARRAY_PREFIX | ||
104 | # error "DYNARRAY_PREFIX must be defined" | ||
105 | #endif | ||
106 | |||
107 | #ifdef DYNARRAY_INITIAL_SIZE | ||
108 | # if DYNARRAY_INITIAL_SIZE < 0 | ||
109 | # error "DYNARRAY_INITIAL_SIZE must be non-negative" | ||
110 | # endif | ||
111 | # if DYNARRAY_INITIAL_SIZE > 0 | ||
112 | # define DYNARRAY_HAVE_SCRATCH 1 | ||
113 | # else | ||
114 | # define DYNARRAY_HAVE_SCRATCH 0 | ||
115 | # endif | ||
116 | #else | ||
117 | /* Provide a reasonable default which limits the size of | ||
118 | DYNARRAY_STRUCT. */ | ||
119 | # define DYNARRAY_INITIAL_SIZE \ | ||
120 | (sizeof (DYNARRAY_ELEMENT) > 64 ? 2 : 128 / sizeof (DYNARRAY_ELEMENT)) | ||
121 | # define DYNARRAY_HAVE_SCRATCH 1 | ||
122 | #endif | ||
123 | |||
124 | /* Public type definitions. */ | ||
125 | |||
126 | /* All fields of this struct are private to the implementation. */ | ||
127 | struct DYNARRAY_STRUCT | ||
128 | { | ||
129 | union | ||
130 | { | ||
131 | struct dynarray_header dynarray_abstract; | ||
132 | struct | ||
133 | { | ||
134 | /* These fields must match struct dynarray_header. */ | ||
135 | size_t used; | ||
136 | size_t allocated; | ||
137 | DYNARRAY_ELEMENT *array; | ||
138 | } dynarray_header; | ||
139 | } u; | ||
140 | |||
141 | #if DYNARRAY_HAVE_SCRATCH | ||
142 | /* Initial inline allocation. */ | ||
143 | DYNARRAY_ELEMENT scratch[DYNARRAY_INITIAL_SIZE]; | ||
144 | #endif | ||
145 | }; | ||
146 | |||
147 | /* Internal use only: Helper macros. */ | ||
148 | |||
149 | /* Ensure macro-expansion of DYNARRAY_PREFIX. */ | ||
150 | #define DYNARRAY_CONCAT0(prefix, name) prefix##name | ||
151 | #define DYNARRAY_CONCAT1(prefix, name) DYNARRAY_CONCAT0(prefix, name) | ||
152 | #define DYNARRAY_NAME(name) DYNARRAY_CONCAT1(DYNARRAY_PREFIX, name) | ||
153 | |||
154 | /* Use DYNARRAY_FREE instead of DYNARRAY_NAME (free), | ||
155 | so that Gnulib does not change 'free' to 'rpl_free'. */ | ||
156 | #define DYNARRAY_FREE DYNARRAY_CONCAT1 (DYNARRAY_NAME (f), ree) | ||
157 | |||
158 | /* Address of the scratch buffer if any. */ | ||
159 | #if DYNARRAY_HAVE_SCRATCH | ||
160 | # define DYNARRAY_SCRATCH(list) (list)->scratch | ||
161 | #else | ||
162 | # define DYNARRAY_SCRATCH(list) NULL | ||
163 | #endif | ||
164 | |||
165 | /* Internal use only: Helper functions. */ | ||
166 | |||
167 | /* Internal function. Call DYNARRAY_ELEMENT_FREE with the array | ||
168 | elements. Name mangling needed due to the DYNARRAY_ELEMENT_FREE | ||
169 | macro expansion. */ | ||
170 | static inline void | ||
171 | DYNARRAY_NAME (free__elements__) (DYNARRAY_ELEMENT *__dynarray_array, | ||
172 | size_t __dynarray_used) | ||
173 | { | ||
174 | #ifdef DYNARRAY_ELEMENT_FREE | ||
175 | for (size_t __dynarray_i = 0; __dynarray_i < __dynarray_used; ++__dynarray_i) | ||
176 | DYNARRAY_ELEMENT_FREE (&__dynarray_array[__dynarray_i]); | ||
177 | #endif /* DYNARRAY_ELEMENT_FREE */ | ||
178 | } | ||
179 | |||
180 | /* Internal function. Free the non-scratch array allocation. */ | ||
181 | static inline void | ||
182 | DYNARRAY_NAME (free__array__) (struct DYNARRAY_STRUCT *list) | ||
183 | { | ||
184 | #if DYNARRAY_HAVE_SCRATCH | ||
185 | if (list->u.dynarray_header.array != list->scratch) | ||
186 | free (list->u.dynarray_header.array); | ||
187 | #else | ||
188 | free (list->u.dynarray_header.array); | ||
189 | #endif | ||
190 | } | ||
191 | |||
192 | /* Public functions. */ | ||
193 | |||
194 | /* Initialize a dynamic array object. This must be called before any | ||
195 | use of the object. */ | ||
196 | _GL_ATTRIBUTE_NONNULL ((1)) | ||
197 | static void | ||
198 | DYNARRAY_NAME (init) (struct DYNARRAY_STRUCT *list) | ||
199 | { | ||
200 | list->u.dynarray_header.used = 0; | ||
201 | list->u.dynarray_header.allocated = DYNARRAY_INITIAL_SIZE; | ||
202 | list->u.dynarray_header.array = DYNARRAY_SCRATCH (list); | ||
203 | } | ||
204 | |||
205 | /* Deallocate the dynamic array and its elements. */ | ||
206 | _GL_ATTRIBUTE_MAYBE_UNUSED _GL_ATTRIBUTE_NONNULL ((1)) | ||
207 | static void | ||
208 | DYNARRAY_FREE (struct DYNARRAY_STRUCT *list) | ||
209 | { | ||
210 | DYNARRAY_NAME (free__elements__) | ||
211 | (list->u.dynarray_header.array, list->u.dynarray_header.used); | ||
212 | DYNARRAY_NAME (free__array__) (list); | ||
213 | DYNARRAY_NAME (init) (list); | ||
214 | } | ||
215 | |||
216 | /* Return true if the dynamic array is in an error state. */ | ||
217 | _GL_ATTRIBUTE_NONNULL ((1)) | ||
218 | static inline bool | ||
219 | DYNARRAY_NAME (has_failed) (const struct DYNARRAY_STRUCT *list) | ||
220 | { | ||
221 | return list->u.dynarray_header.allocated == __dynarray_error_marker (); | ||
222 | } | ||
223 | |||
224 | /* Mark the dynamic array as failed. All elements are deallocated as | ||
225 | a side effect. */ | ||
226 | _GL_ATTRIBUTE_NONNULL ((1)) | ||
227 | static void | ||
228 | DYNARRAY_NAME (mark_failed) (struct DYNARRAY_STRUCT *list) | ||
229 | { | ||
230 | DYNARRAY_NAME (free__elements__) | ||
231 | (list->u.dynarray_header.array, list->u.dynarray_header.used); | ||
232 | DYNARRAY_NAME (free__array__) (list); | ||
233 | list->u.dynarray_header.array = DYNARRAY_SCRATCH (list); | ||
234 | list->u.dynarray_header.used = 0; | ||
235 | list->u.dynarray_header.allocated = __dynarray_error_marker (); | ||
236 | } | ||
237 | |||
238 | /* Return the number of elements which have been added to the dynamic | ||
239 | array. */ | ||
240 | _GL_ATTRIBUTE_NONNULL ((1)) | ||
241 | static inline size_t | ||
242 | DYNARRAY_NAME (size) (const struct DYNARRAY_STRUCT *list) | ||
243 | { | ||
244 | return list->u.dynarray_header.used; | ||
245 | } | ||
246 | |||
247 | /* Return a pointer to the array element at INDEX. Terminate the | ||
248 | process if INDEX is out of bounds. */ | ||
249 | _GL_ATTRIBUTE_NONNULL ((1)) | ||
250 | static inline DYNARRAY_ELEMENT * | ||
251 | DYNARRAY_NAME (at) (struct DYNARRAY_STRUCT *list, size_t index) | ||
252 | { | ||
253 | if (_GL_UNLIKELY (index >= DYNARRAY_NAME (size) (list))) | ||
254 | __libc_dynarray_at_failure (DYNARRAY_NAME (size) (list), index); | ||
255 | return list->u.dynarray_header.array + index; | ||
256 | } | ||
257 | |||
258 | /* Return a pointer to the first array element, if any. For a | ||
259 | zero-length array, the pointer can be NULL even though the dynamic | ||
260 | array has not entered the failure state. */ | ||
261 | _GL_ATTRIBUTE_NONNULL ((1)) | ||
262 | static inline DYNARRAY_ELEMENT * | ||
263 | DYNARRAY_NAME (begin) (struct DYNARRAY_STRUCT *list) | ||
264 | { | ||
265 | return list->u.dynarray_header.array; | ||
266 | } | ||
267 | |||
268 | /* Return a pointer one element past the last array element. For a | ||
269 | zero-length array, the pointer can be NULL even though the dynamic | ||
270 | array has not entered the failure state. */ | ||
271 | _GL_ATTRIBUTE_NONNULL ((1)) | ||
272 | static inline DYNARRAY_ELEMENT * | ||
273 | DYNARRAY_NAME (end) (struct DYNARRAY_STRUCT *list) | ||
274 | { | ||
275 | return list->u.dynarray_header.array + list->u.dynarray_header.used; | ||
276 | } | ||
277 | |||
278 | /* Internal function. Slow path for the add function below. */ | ||
279 | static void | ||
280 | DYNARRAY_NAME (add__) (struct DYNARRAY_STRUCT *list, DYNARRAY_ELEMENT item) | ||
281 | { | ||
282 | if (_GL_UNLIKELY | ||
283 | (!__libc_dynarray_emplace_enlarge (&list->u.dynarray_abstract, | ||
284 | DYNARRAY_SCRATCH (list), | ||
285 | sizeof (DYNARRAY_ELEMENT)))) | ||
286 | { | ||
287 | DYNARRAY_NAME (mark_failed) (list); | ||
288 | return; | ||
289 | } | ||
290 | |||
291 | /* Copy the new element and increase the array length. */ | ||
292 | list->u.dynarray_header.array[list->u.dynarray_header.used++] = item; | ||
293 | } | ||
294 | |||
295 | /* Add ITEM at the end of the array, enlarging it by one element. | ||
296 | Mark *LIST as failed if the dynamic array allocation size cannot be | ||
297 | increased. */ | ||
298 | _GL_ATTRIBUTE_NONNULL ((1)) | ||
299 | static inline void | ||
300 | DYNARRAY_NAME (add) (struct DYNARRAY_STRUCT *list, DYNARRAY_ELEMENT item) | ||
301 | { | ||
302 | /* Do nothing in case of previous error. */ | ||
303 | if (DYNARRAY_NAME (has_failed) (list)) | ||
304 | return; | ||
305 | |||
306 | /* Enlarge the array if necessary. */ | ||
307 | if (_GL_UNLIKELY (list->u.dynarray_header.used | ||
308 | == list->u.dynarray_header.allocated)) | ||
309 | { | ||
310 | DYNARRAY_NAME (add__) (list, item); | ||
311 | return; | ||
312 | } | ||
313 | |||
314 | /* Copy the new element and increase the array length. */ | ||
315 | list->u.dynarray_header.array[list->u.dynarray_header.used++] = item; | ||
316 | } | ||
317 | |||
318 | /* Internal function. Building block for the emplace functions below. | ||
319 | Assumes space for one more element in *LIST. */ | ||
320 | static inline DYNARRAY_ELEMENT * | ||
321 | DYNARRAY_NAME (emplace__tail__) (struct DYNARRAY_STRUCT *list) | ||
322 | { | ||
323 | DYNARRAY_ELEMENT *result | ||
324 | = &list->u.dynarray_header.array[list->u.dynarray_header.used]; | ||
325 | ++list->u.dynarray_header.used; | ||
326 | #if defined (DYNARRAY_ELEMENT_INIT) | ||
327 | DYNARRAY_ELEMENT_INIT (result); | ||
328 | #elif defined (DYNARRAY_ELEMENT_FREE) | ||
329 | memset (result, 0, sizeof (*result)); | ||
330 | #endif | ||
331 | return result; | ||
332 | } | ||
333 | |||
334 | /* Internal function. Slow path for the emplace function below. */ | ||
335 | static DYNARRAY_ELEMENT * | ||
336 | DYNARRAY_NAME (emplace__) (struct DYNARRAY_STRUCT *list) | ||
337 | { | ||
338 | if (_GL_UNLIKELY | ||
339 | (!__libc_dynarray_emplace_enlarge (&list->u.dynarray_abstract, | ||
340 | DYNARRAY_SCRATCH (list), | ||
341 | sizeof (DYNARRAY_ELEMENT)))) | ||
342 | { | ||
343 | DYNARRAY_NAME (mark_failed) (list); | ||
344 | return NULL; | ||
345 | } | ||
346 | return DYNARRAY_NAME (emplace__tail__) (list); | ||
347 | } | ||
348 | |||
349 | /* Allocate a place for a new element in *LIST and return a pointer to | ||
350 | it. The pointer can be NULL if the dynamic array cannot be | ||
351 | enlarged due to a memory allocation failure. */ | ||
352 | _GL_ATTRIBUTE_MAYBE_UNUSED _GL_ATTRIBUTE_NODISCARD | ||
353 | _GL_ATTRIBUTE_NONNULL ((1)) | ||
354 | static | ||
355 | /* Avoid inlining with the larger initialization code. */ | ||
356 | #if !(defined (DYNARRAY_ELEMENT_INIT) || defined (DYNARRAY_ELEMENT_FREE)) | ||
357 | inline | ||
358 | #endif | ||
359 | DYNARRAY_ELEMENT * | ||
360 | DYNARRAY_NAME (emplace) (struct DYNARRAY_STRUCT *list) | ||
361 | { | ||
362 | /* Do nothing in case of previous error. */ | ||
363 | if (DYNARRAY_NAME (has_failed) (list)) | ||
364 | return NULL; | ||
365 | |||
366 | /* Enlarge the array if necessary. */ | ||
367 | if (_GL_UNLIKELY (list->u.dynarray_header.used | ||
368 | == list->u.dynarray_header.allocated)) | ||
369 | return (DYNARRAY_NAME (emplace__) (list)); | ||
370 | return DYNARRAY_NAME (emplace__tail__) (list); | ||
371 | } | ||
372 | |||
373 | /* Change the size of *LIST to SIZE. If SIZE is larger than the | ||
374 | existing size, new elements are added (which can be initialized). | ||
375 | Otherwise, the list is truncated, and elements are freed. Return | ||
376 | false on memory allocation failure (and mark *LIST as failed). */ | ||
377 | _GL_ATTRIBUTE_MAYBE_UNUSED _GL_ATTRIBUTE_NONNULL ((1)) | ||
378 | static bool | ||
379 | DYNARRAY_NAME (resize) (struct DYNARRAY_STRUCT *list, size_t size) | ||
380 | { | ||
381 | if (size > list->u.dynarray_header.used) | ||
382 | { | ||
383 | bool ok; | ||
384 | #if defined (DYNARRAY_ELEMENT_INIT) | ||
385 | /* The new elements have to be initialized. */ | ||
386 | size_t old_size = list->u.dynarray_header.used; | ||
387 | ok = __libc_dynarray_resize (&list->u.dynarray_abstract, | ||
388 | size, DYNARRAY_SCRATCH (list), | ||
389 | sizeof (DYNARRAY_ELEMENT)); | ||
390 | if (ok) | ||
391 | for (size_t i = old_size; i < size; ++i) | ||
392 | { | ||
393 | DYNARRAY_ELEMENT_INIT (&list->u.dynarray_header.array[i]); | ||
394 | } | ||
395 | #elif defined (DYNARRAY_ELEMENT_FREE) | ||
396 | /* Zero initialization is needed so that the elements can be | ||
397 | safely freed. */ | ||
398 | ok = __libc_dynarray_resize_clear | ||
399 | (&list->u.dynarray_abstract, size, | ||
400 | DYNARRAY_SCRATCH (list), sizeof (DYNARRAY_ELEMENT)); | ||
401 | #else | ||
402 | ok = __libc_dynarray_resize (&list->u.dynarray_abstract, | ||
403 | size, DYNARRAY_SCRATCH (list), | ||
404 | sizeof (DYNARRAY_ELEMENT)); | ||
405 | #endif | ||
406 | if (_GL_UNLIKELY (!ok)) | ||
407 | DYNARRAY_NAME (mark_failed) (list); | ||
408 | return ok; | ||
409 | } | ||
410 | else | ||
411 | { | ||
412 | /* The list has shrunk in size. Free the removed elements. */ | ||
413 | DYNARRAY_NAME (free__elements__) | ||
414 | (list->u.dynarray_header.array + size, | ||
415 | list->u.dynarray_header.used - size); | ||
416 | list->u.dynarray_header.used = size; | ||
417 | return true; | ||
418 | } | ||
419 | } | ||
420 | |||
421 | /* Remove the last element of LIST if it is present. */ | ||
422 | _GL_ATTRIBUTE_MAYBE_UNUSED _GL_ATTRIBUTE_NONNULL ((1)) | ||
423 | static void | ||
424 | DYNARRAY_NAME (remove_last) (struct DYNARRAY_STRUCT *list) | ||
425 | { | ||
426 | /* used > 0 implies that the array is the non-failed state. */ | ||
427 | if (list->u.dynarray_header.used > 0) | ||
428 | { | ||
429 | size_t new_length = list->u.dynarray_header.used - 1; | ||
430 | #ifdef DYNARRAY_ELEMENT_FREE | ||
431 | DYNARRAY_ELEMENT_FREE (&list->u.dynarray_header.array[new_length]); | ||
432 | #endif | ||
433 | list->u.dynarray_header.used = new_length; | ||
434 | } | ||
435 | } | ||
436 | |||
437 | /* Remove all elements from the list. The elements are freed, but the | ||
438 | list itself is not. */ | ||
439 | _GL_ATTRIBUTE_MAYBE_UNUSED _GL_ATTRIBUTE_NONNULL ((1)) | ||
440 | static void | ||
441 | DYNARRAY_NAME (clear) (struct DYNARRAY_STRUCT *list) | ||
442 | { | ||
443 | /* free__elements__ does nothing if the list is in the failed | ||
444 | state. */ | ||
445 | DYNARRAY_NAME (free__elements__) | ||
446 | (list->u.dynarray_header.array, list->u.dynarray_header.used); | ||
447 | list->u.dynarray_header.used = 0; | ||
448 | } | ||
449 | |||
450 | #ifdef DYNARRAY_FINAL_TYPE | ||
451 | /* Transfer the dynamic array to a permanent location at *RESULT. | ||
452 | Returns true on success on false on allocation failure. In either | ||
453 | case, *LIST is re-initialized and can be reused. A NULL pointer is | ||
454 | stored in *RESULT if LIST refers to an empty list. On success, the | ||
455 | pointer in *RESULT is heap-allocated and must be deallocated using | ||
456 | free. */ | ||
457 | _GL_ATTRIBUTE_MAYBE_UNUSED _GL_ATTRIBUTE_NODISCARD | ||
458 | _GL_ATTRIBUTE_NONNULL ((1, 2)) | ||
459 | static bool | ||
460 | DYNARRAY_NAME (finalize) (struct DYNARRAY_STRUCT *list, | ||
461 | DYNARRAY_FINAL_TYPE *result) | ||
462 | { | ||
463 | struct dynarray_finalize_result res; | ||
464 | if (__libc_dynarray_finalize (&list->u.dynarray_abstract, | ||
465 | DYNARRAY_SCRATCH (list), | ||
466 | sizeof (DYNARRAY_ELEMENT), &res)) | ||
467 | { | ||
468 | /* On success, the result owns all the data. */ | ||
469 | DYNARRAY_NAME (init) (list); | ||
470 | *result = (DYNARRAY_FINAL_TYPE) { res.array, res.length }; | ||
471 | return true; | ||
472 | } | ||
473 | else | ||
474 | { | ||
475 | /* On error, we need to free all data. */ | ||
476 | DYNARRAY_FREE (list); | ||
477 | errno = ENOMEM; | ||
478 | return false; | ||
479 | } | ||
480 | } | ||
481 | #else /* !DYNARRAY_FINAL_TYPE */ | ||
482 | /* Transfer the dynamic array to a heap-allocated array and return a | ||
483 | pointer to it. The pointer is NULL if memory allocation fails, or | ||
484 | if the array is empty, so this function should be used only for | ||
485 | arrays which are known not be empty (usually because they always | ||
486 | have a sentinel at the end). If LENGTHP is not NULL, the array | ||
487 | length is written to *LENGTHP. *LIST is re-initialized and can be | ||
488 | reused. */ | ||
489 | _GL_ATTRIBUTE_MAYBE_UNUSED _GL_ATTRIBUTE_NODISCARD | ||
490 | _GL_ATTRIBUTE_NONNULL ((1)) | ||
491 | static DYNARRAY_ELEMENT * | ||
492 | DYNARRAY_NAME (finalize) (struct DYNARRAY_STRUCT *list, size_t *lengthp) | ||
493 | { | ||
494 | struct dynarray_finalize_result res; | ||
495 | if (__libc_dynarray_finalize (&list->u.dynarray_abstract, | ||
496 | DYNARRAY_SCRATCH (list), | ||
497 | sizeof (DYNARRAY_ELEMENT), &res)) | ||
498 | { | ||
499 | /* On success, the result owns all the data. */ | ||
500 | DYNARRAY_NAME (init) (list); | ||
501 | if (lengthp != NULL) | ||
502 | *lengthp = res.length; | ||
503 | return res.array; | ||
504 | } | ||
505 | else | ||
506 | { | ||
507 | /* On error, we need to free all data. */ | ||
508 | DYNARRAY_FREE (list); | ||
509 | errno = ENOMEM; | ||
510 | return NULL; | ||
511 | } | ||
512 | } | ||
513 | #endif /* !DYNARRAY_FINAL_TYPE */ | ||
514 | |||
515 | /* Undo macro definitions. */ | ||
516 | |||
517 | #undef DYNARRAY_CONCAT0 | ||
518 | #undef DYNARRAY_CONCAT1 | ||
519 | #undef DYNARRAY_NAME | ||
520 | #undef DYNARRAY_SCRATCH | ||
521 | #undef DYNARRAY_HAVE_SCRATCH | ||
522 | |||
523 | #undef DYNARRAY_STRUCT | ||
524 | #undef DYNARRAY_ELEMENT | ||
525 | #undef DYNARRAY_PREFIX | ||
526 | #undef DYNARRAY_ELEMENT_FREE | ||
527 | #undef DYNARRAY_ELEMENT_INIT | ||
528 | #undef DYNARRAY_INITIAL_SIZE | ||
529 | #undef DYNARRAY_FINAL_TYPE | ||