fast-xml 1.0.1 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,773 @@
1
+ /* Licensed under BSD-MIT - see ccan/licenses/BSD-MIT file for details */
2
+ #ifndef CCAN_LIST_H
3
+ #define CCAN_LIST_H
4
+ #include <assert.h>
5
+ #include "ccan/str/str.h"
6
+ #include "ccan/container_of/container_of.h"
7
+ #include "ccan/check_type/check_type.h"
8
+
9
+ /**
10
+ * struct list_node - an entry in a doubly-linked list
11
+ * @next: next entry (self if empty)
12
+ * @prev: previous entry (self if empty)
13
+ *
14
+ * This is used as an entry in a linked list.
15
+ * Example:
16
+ * struct child {
17
+ * const char *name;
18
+ * // Linked list of all us children.
19
+ * struct list_node list;
20
+ * };
21
+ */
22
+ struct list_node
23
+ {
24
+ struct list_node *next, *prev;
25
+ };
26
+
27
+ /**
28
+ * struct list_head - the head of a doubly-linked list
29
+ * @h: the list_head (containing next and prev pointers)
30
+ *
31
+ * This is used as the head of a linked list.
32
+ * Example:
33
+ * struct parent {
34
+ * const char *name;
35
+ * struct list_head children;
36
+ * unsigned int num_children;
37
+ * };
38
+ */
39
+ struct list_head
40
+ {
41
+ struct list_node n;
42
+ };
43
+
44
+ #define LIST_LOC __FILE__ ":" stringify(__LINE__)
45
+ #define list_debug(h, loc) ((void)loc, h)
46
+ #define list_debug_node(n, loc) ((void)loc, n)
47
+
48
+ /**
49
+ * LIST_HEAD_INIT - initializer for an empty list_head
50
+ * @name: the name of the list.
51
+ *
52
+ * Explicit initializer for an empty list.
53
+ *
54
+ * See also:
55
+ * LIST_HEAD, list_head_init()
56
+ *
57
+ * Example:
58
+ * static struct list_head my_list = LIST_HEAD_INIT(my_list);
59
+ */
60
+ #define LIST_HEAD_INIT(name) { { &name.n, &name.n } }
61
+
62
+ /**
63
+ * LIST_HEAD - define and initialize an empty list_head
64
+ * @name: the name of the list.
65
+ *
66
+ * The LIST_HEAD macro defines a list_head and initializes it to an empty
67
+ * list. It can be prepended by "static" to define a static list_head.
68
+ *
69
+ * See also:
70
+ * LIST_HEAD_INIT, list_head_init()
71
+ *
72
+ * Example:
73
+ * static LIST_HEAD(my_global_list);
74
+ */
75
+ #define LIST_HEAD(name) \
76
+ struct list_head name = LIST_HEAD_INIT(name)
77
+
78
+ /**
79
+ * list_head_init - initialize a list_head
80
+ * @h: the list_head to set to the empty list
81
+ *
82
+ * Example:
83
+ * ...
84
+ * struct parent *parent = malloc(sizeof(*parent));
85
+ *
86
+ * list_head_init(&parent->children);
87
+ * parent->num_children = 0;
88
+ */
89
+ static inline void list_head_init(struct list_head *h)
90
+ {
91
+ h->n.next = h->n.prev = &h->n;
92
+ }
93
+
94
+ /**
95
+ * list_node_init - initialize a list_node
96
+ * @n: the list_node to link to itself.
97
+ *
98
+ * You don't need to use this normally! But it lets you list_del(@n)
99
+ * safely.
100
+ */
101
+ static inline void list_node_init(struct list_node *n)
102
+ {
103
+ n->next = n->prev = n;
104
+ }
105
+
106
+ /**
107
+ * list_add_after - add an entry after an existing node in a linked list
108
+ * @h: the list_head to add the node to (for debugging)
109
+ * @p: the existing list_node to add the node after
110
+ * @n: the new list_node to add to the list.
111
+ *
112
+ * The existing list_node must already be a member of the list.
113
+ * The new list_node does not need to be initialized; it will be overwritten.
114
+ *
115
+ * Example:
116
+ * struct child c1, c2, c3;
117
+ * LIST_HEAD(h);
118
+ *
119
+ * list_add_tail(&h, &c1.list);
120
+ * list_add_tail(&h, &c3.list);
121
+ * list_add_after(&h, &c1.list, &c2.list);
122
+ */
123
+ #define list_add_after(h, p, n) list_add_after_(h, p, n, LIST_LOC)
124
+ static inline void list_add_after_(struct list_head *h,
125
+ struct list_node *p,
126
+ struct list_node *n,
127
+ const char *abortstr)
128
+ {
129
+ n->next = p->next;
130
+ n->prev = p;
131
+ p->next->prev = n;
132
+ p->next = n;
133
+ (void)list_debug(h, abortstr);
134
+ }
135
+
136
+ /**
137
+ * list_add - add an entry at the start of a linked list.
138
+ * @h: the list_head to add the node to
139
+ * @n: the list_node to add to the list.
140
+ *
141
+ * The list_node does not need to be initialized; it will be overwritten.
142
+ * Example:
143
+ * struct child *child = malloc(sizeof(*child));
144
+ *
145
+ * child->name = "marvin";
146
+ * list_add(&parent->children, &child->list);
147
+ * parent->num_children++;
148
+ */
149
+ #define list_add(h, n) list_add_(h, n, LIST_LOC)
150
+ static inline void list_add_(struct list_head *h,
151
+ struct list_node *n,
152
+ const char *abortstr)
153
+ {
154
+ list_add_after_(h, &h->n, n, abortstr);
155
+ }
156
+
157
+ /**
158
+ * list_add_before - add an entry before an existing node in a linked list
159
+ * @h: the list_head to add the node to (for debugging)
160
+ * @p: the existing list_node to add the node before
161
+ * @n: the new list_node to add to the list.
162
+ *
163
+ * The existing list_node must already be a member of the list.
164
+ * The new list_node does not need to be initialized; it will be overwritten.
165
+ *
166
+ * Example:
167
+ * list_head_init(&h);
168
+ * list_add_tail(&h, &c1.list);
169
+ * list_add_tail(&h, &c3.list);
170
+ * list_add_before(&h, &c3.list, &c2.list);
171
+ */
172
+ #define list_add_before(h, p, n) list_add_before_(h, p, n, LIST_LOC)
173
+ static inline void list_add_before_(struct list_head *h,
174
+ struct list_node *p,
175
+ struct list_node *n,
176
+ const char *abortstr)
177
+ {
178
+ n->next = p;
179
+ n->prev = p->prev;
180
+ p->prev->next = n;
181
+ p->prev = n;
182
+ (void)list_debug(h, abortstr);
183
+ }
184
+
185
+ /**
186
+ * list_add_tail - add an entry at the end of a linked list.
187
+ * @h: the list_head to add the node to
188
+ * @n: the list_node to add to the list.
189
+ *
190
+ * The list_node does not need to be initialized; it will be overwritten.
191
+ * Example:
192
+ * list_add_tail(&parent->children, &child->list);
193
+ * parent->num_children++;
194
+ */
195
+ #define list_add_tail(h, n) list_add_tail_(h, n, LIST_LOC)
196
+ static inline void list_add_tail_(struct list_head *h,
197
+ struct list_node *n,
198
+ const char *abortstr)
199
+ {
200
+ list_add_before_(h, &h->n, n, abortstr);
201
+ }
202
+
203
+ /**
204
+ * list_empty - is a list empty?
205
+ * @h: the list_head
206
+ *
207
+ * If the list is empty, returns true.
208
+ *
209
+ * Example:
210
+ * assert(list_empty(&parent->children) == (parent->num_children == 0));
211
+ */
212
+ #define list_empty(h) list_empty_(h, LIST_LOC)
213
+ static inline int list_empty_(const struct list_head *h, const char* abortstr)
214
+ {
215
+ (void)list_debug(h, abortstr);
216
+ return h->n.next == &h->n;
217
+ }
218
+
219
+ /**
220
+ * list_empty_nodebug - is a list empty (and don't perform debug checks)?
221
+ * @h: the list_head
222
+ *
223
+ * If the list is empty, returns true.
224
+ * This differs from list_empty() in that if CCAN_LIST_DEBUG is set it
225
+ * will NOT perform debug checks. Only use this function if you REALLY
226
+ * know what you're doing.
227
+ *
228
+ * Example:
229
+ * assert(list_empty_nodebug(&parent->children) == (parent->num_children == 0));
230
+ */
231
+ #ifndef CCAN_LIST_DEBUG
232
+ #define list_empty_nodebug(h) list_empty(h)
233
+ #else
234
+ static inline int list_empty_nodebug(const struct list_head *h)
235
+ {
236
+ return h->n.next == &h->n;
237
+ }
238
+ #endif
239
+
240
+ /**
241
+ * list_del - delete an entry from an (unknown) linked list.
242
+ * @n: the list_node to delete from the list.
243
+ *
244
+ * Note that this leaves @n in an undefined state; it can be added to
245
+ * another list, but not deleted again.
246
+ *
247
+ * See also:
248
+ * list_del_from(), list_del_init()
249
+ *
250
+ * Example:
251
+ * list_del(&child->list);
252
+ * parent->num_children--;
253
+ */
254
+ #define list_del(n) list_del_(n, LIST_LOC)
255
+ static inline void list_del_(struct list_node *n, const char* abortstr)
256
+ {
257
+ (void)list_debug_node(n, abortstr);
258
+ n->next->prev = n->prev;
259
+ n->prev->next = n->next;
260
+ #ifdef CCAN_LIST_DEBUG
261
+ /* Catch use-after-del. */
262
+ n->next = n->prev = NULL;
263
+ #endif
264
+ }
265
+
266
+ /**
267
+ * list_del_init - delete a node, and reset it so it can be deleted again.
268
+ * @n: the list_node to be deleted.
269
+ *
270
+ * list_del(@n) or list_del_init() again after this will be safe,
271
+ * which can be useful in some cases.
272
+ *
273
+ * See also:
274
+ * list_del_from(), list_del()
275
+ *
276
+ * Example:
277
+ * list_del_init(&child->list);
278
+ * parent->num_children--;
279
+ */
280
+ #define list_del_init(n) list_del_init_(n, LIST_LOC)
281
+ static inline void list_del_init_(struct list_node *n, const char *abortstr)
282
+ {
283
+ list_del_(n, abortstr);
284
+ list_node_init(n);
285
+ }
286
+
287
+ /**
288
+ * list_del_from - delete an entry from a known linked list.
289
+ * @h: the list_head the node is in.
290
+ * @n: the list_node to delete from the list.
291
+ *
292
+ * This explicitly indicates which list a node is expected to be in,
293
+ * which is better documentation and can catch more bugs.
294
+ *
295
+ * See also: list_del()
296
+ *
297
+ * Example:
298
+ * list_del_from(&parent->children, &child->list);
299
+ * parent->num_children--;
300
+ */
301
+ static inline void list_del_from(struct list_head *h, struct list_node *n)
302
+ {
303
+ #ifdef CCAN_LIST_DEBUG
304
+ {
305
+ /* Thorough check: make sure it was in list! */
306
+ struct list_node *i;
307
+ for (i = h->n.next; i != n; i = i->next)
308
+ assert(i != &h->n);
309
+ }
310
+ #endif /* CCAN_LIST_DEBUG */
311
+
312
+ /* Quick test that catches a surprising number of bugs. */
313
+ assert(!list_empty(h));
314
+ list_del(n);
315
+ }
316
+
317
+ /**
318
+ * list_swap - swap out an entry from an (unknown) linked list for a new one.
319
+ * @o: the list_node to replace from the list.
320
+ * @n: the list_node to insert in place of the old one.
321
+ *
322
+ * Note that this leaves @o in an undefined state; it can be added to
323
+ * another list, but not deleted/swapped again.
324
+ *
325
+ * See also:
326
+ * list_del()
327
+ *
328
+ * Example:
329
+ * struct child x1, x2;
330
+ * LIST_HEAD(xh);
331
+ *
332
+ * list_add(&xh, &x1.list);
333
+ * list_swap(&x1.list, &x2.list);
334
+ */
335
+ #define list_swap(o, n) list_swap_(o, n, LIST_LOC)
336
+ static inline void list_swap_(struct list_node *o,
337
+ struct list_node *n,
338
+ const char* abortstr)
339
+ {
340
+ (void)list_debug_node(o, abortstr);
341
+ *n = *o;
342
+ n->next->prev = n;
343
+ n->prev->next = n;
344
+ #ifdef CCAN_LIST_DEBUG
345
+ /* Catch use-after-del. */
346
+ o->next = o->prev = NULL;
347
+ #endif
348
+ }
349
+
350
+ /**
351
+ * list_entry - convert a list_node back into the structure containing it.
352
+ * @n: the list_node
353
+ * @type: the type of the entry
354
+ * @member: the list_node member of the type
355
+ *
356
+ * Example:
357
+ * // First list entry is children.next; convert back to child.
358
+ * child = list_entry(parent->children.n.next, struct child, list);
359
+ *
360
+ * See Also:
361
+ * list_top(), list_for_each()
362
+ */
363
+ #define list_entry(n, type, member) container_of(n, type, member)
364
+
365
+ /**
366
+ * list_top - get the first entry in a list
367
+ * @h: the list_head
368
+ * @type: the type of the entry
369
+ * @member: the list_node member of the type
370
+ *
371
+ * If the list is empty, returns NULL.
372
+ *
373
+ * Example:
374
+ * struct child *first;
375
+ * first = list_top(&parent->children, struct child, list);
376
+ * if (!first)
377
+ * printf("Empty list!\n");
378
+ */
379
+ #define list_top(h, type, member) \
380
+ ((type *)list_top_((h), list_off_(type, member)))
381
+
382
+ static inline const void *list_top_(const struct list_head *h, size_t off)
383
+ {
384
+ if (list_empty(h))
385
+ return NULL;
386
+ return (const char *)h->n.next - off;
387
+ }
388
+
389
+ /**
390
+ * list_pop - remove the first entry in a list
391
+ * @h: the list_head
392
+ * @type: the type of the entry
393
+ * @member: the list_node member of the type
394
+ *
395
+ * If the list is empty, returns NULL.
396
+ *
397
+ * Example:
398
+ * struct child *one;
399
+ * one = list_pop(&parent->children, struct child, list);
400
+ * if (!one)
401
+ * printf("Empty list!\n");
402
+ */
403
+ #define list_pop(h, type, member) \
404
+ ((type *)list_pop_((h), list_off_(type, member)))
405
+
406
+ static inline const void *list_pop_(const struct list_head *h, size_t off)
407
+ {
408
+ struct list_node *n;
409
+
410
+ if (list_empty(h))
411
+ return NULL;
412
+ n = h->n.next;
413
+ list_del(n);
414
+ return (const char *)n - off;
415
+ }
416
+
417
+ /**
418
+ * list_tail - get the last entry in a list
419
+ * @h: the list_head
420
+ * @type: the type of the entry
421
+ * @member: the list_node member of the type
422
+ *
423
+ * If the list is empty, returns NULL.
424
+ *
425
+ * Example:
426
+ * struct child *last;
427
+ * last = list_tail(&parent->children, struct child, list);
428
+ * if (!last)
429
+ * printf("Empty list!\n");
430
+ */
431
+ #define list_tail(h, type, member) \
432
+ ((type *)list_tail_((h), list_off_(type, member)))
433
+
434
+ static inline const void *list_tail_(const struct list_head *h, size_t off)
435
+ {
436
+ if (list_empty(h))
437
+ return NULL;
438
+ return (const char *)h->n.prev - off;
439
+ }
440
+
441
+ /**
442
+ * list_for_each - iterate through a list.
443
+ * @h: the list_head (warning: evaluated multiple times!)
444
+ * @i: the structure containing the list_node
445
+ * @member: the list_node member of the structure
446
+ *
447
+ * This is a convenient wrapper to iterate @i over the entire list. It's
448
+ * a for loop, so you can break and continue as normal.
449
+ *
450
+ * Example:
451
+ * list_for_each(&parent->children, child, list)
452
+ * printf("Name: %s\n", child->name);
453
+ */
454
+ #define list_for_each(h, i, member) \
455
+ list_for_each_off(h, i, list_off_var_(i, member))
456
+
457
+ /**
458
+ * list_for_each_rev - iterate through a list backwards.
459
+ * @h: the list_head
460
+ * @i: the structure containing the list_node
461
+ * @member: the list_node member of the structure
462
+ *
463
+ * This is a convenient wrapper to iterate @i over the entire list. It's
464
+ * a for loop, so you can break and continue as normal.
465
+ *
466
+ * Example:
467
+ * list_for_each_rev(&parent->children, child, list)
468
+ * printf("Name: %s\n", child->name);
469
+ */
470
+ #define list_for_each_rev(h, i, member) \
471
+ list_for_each_rev_off(h, i, list_off_var_(i, member))
472
+
473
+ /**
474
+ * list_for_each_rev_safe - iterate through a list backwards,
475
+ * maybe during deletion
476
+ * @h: the list_head
477
+ * @i: the structure containing the list_node
478
+ * @nxt: the structure containing the list_node
479
+ * @member: the list_node member of the structure
480
+ *
481
+ * This is a convenient wrapper to iterate @i over the entire list backwards.
482
+ * It's a for loop, so you can break and continue as normal. The extra
483
+ * variable * @nxt is used to hold the next element, so you can delete @i
484
+ * from the list.
485
+ *
486
+ * Example:
487
+ * struct child *next;
488
+ * list_for_each_rev_safe(&parent->children, child, next, list) {
489
+ * printf("Name: %s\n", child->name);
490
+ * }
491
+ */
492
+ #define list_for_each_rev_safe(h, i, nxt, member) \
493
+ list_for_each_rev_safe_off(h, i, nxt, list_off_var_(i, member))
494
+
495
+ /**
496
+ * list_for_each_safe - iterate through a list, maybe during deletion
497
+ * @h: the list_head
498
+ * @i: the structure containing the list_node
499
+ * @nxt: the structure containing the list_node
500
+ * @member: the list_node member of the structure
501
+ *
502
+ * This is a convenient wrapper to iterate @i over the entire list. It's
503
+ * a for loop, so you can break and continue as normal. The extra variable
504
+ * @nxt is used to hold the next element, so you can delete @i from the list.
505
+ *
506
+ * Example:
507
+ * list_for_each_safe(&parent->children, child, next, list) {
508
+ * list_del(&child->list);
509
+ * parent->num_children--;
510
+ * }
511
+ */
512
+ #define list_for_each_safe(h, i, nxt, member) \
513
+ list_for_each_safe_off(h, i, nxt, list_off_var_(i, member))
514
+
515
+ /**
516
+ * list_next - get the next entry in a list
517
+ * @h: the list_head
518
+ * @i: a pointer to an entry in the list.
519
+ * @member: the list_node member of the structure
520
+ *
521
+ * If @i was the last entry in the list, returns NULL.
522
+ *
523
+ * Example:
524
+ * struct child *second;
525
+ * second = list_next(&parent->children, first, list);
526
+ * if (!second)
527
+ * printf("No second child!\n");
528
+ */
529
+ #define list_next(h, i, member) \
530
+ ((list_typeof(i))list_entry_or_null(list_debug(h, \
531
+ __FILE__ ":" stringify(__LINE__)), \
532
+ (i)->member.next, \
533
+ list_off_var_((i), member)))
534
+
535
+ /**
536
+ * list_prev - get the previous entry in a list
537
+ * @h: the list_head
538
+ * @i: a pointer to an entry in the list.
539
+ * @member: the list_node member of the structure
540
+ *
541
+ * If @i was the first entry in the list, returns NULL.
542
+ *
543
+ * Example:
544
+ * first = list_prev(&parent->children, second, list);
545
+ * if (!first)
546
+ * printf("Can't go back to first child?!\n");
547
+ */
548
+ #define list_prev(h, i, member) \
549
+ ((list_typeof(i))list_entry_or_null(list_debug(h, \
550
+ __FILE__ ":" stringify(__LINE__)), \
551
+ (i)->member.prev, \
552
+ list_off_var_((i), member)))
553
+
554
+ /**
555
+ * list_append_list - empty one list onto the end of another.
556
+ * @to: the list to append into
557
+ * @from: the list to empty.
558
+ *
559
+ * This takes the entire contents of @from and moves it to the end of
560
+ * @to. After this @from will be empty.
561
+ *
562
+ * Example:
563
+ * struct list_head adopter;
564
+ *
565
+ * list_append_list(&adopter, &parent->children);
566
+ * assert(list_empty(&parent->children));
567
+ * parent->num_children = 0;
568
+ */
569
+ #define list_append_list(t, f) list_append_list_(t, f, \
570
+ __FILE__ ":" stringify(__LINE__))
571
+ static inline void list_append_list_(struct list_head *to,
572
+ struct list_head *from,
573
+ const char *abortstr)
574
+ {
575
+ struct list_node *from_tail = list_debug(from, abortstr)->n.prev;
576
+ struct list_node *to_tail = list_debug(to, abortstr)->n.prev;
577
+
578
+ /* Sew in head and entire list. */
579
+ to->n.prev = from_tail;
580
+ from_tail->next = &to->n;
581
+ to_tail->next = &from->n;
582
+ from->n.prev = to_tail;
583
+
584
+ /* Now remove head. */
585
+ list_del(&from->n);
586
+ list_head_init(from);
587
+ }
588
+
589
+ /**
590
+ * list_prepend_list - empty one list into the start of another.
591
+ * @to: the list to prepend into
592
+ * @from: the list to empty.
593
+ *
594
+ * This takes the entire contents of @from and moves it to the start
595
+ * of @to. After this @from will be empty.
596
+ *
597
+ * Example:
598
+ * list_prepend_list(&adopter, &parent->children);
599
+ * assert(list_empty(&parent->children));
600
+ * parent->num_children = 0;
601
+ */
602
+ #define list_prepend_list(t, f) list_prepend_list_(t, f, LIST_LOC)
603
+ static inline void list_prepend_list_(struct list_head *to,
604
+ struct list_head *from,
605
+ const char *abortstr)
606
+ {
607
+ struct list_node *from_tail = list_debug(from, abortstr)->n.prev;
608
+ struct list_node *to_head = list_debug(to, abortstr)->n.next;
609
+
610
+ /* Sew in head and entire list. */
611
+ to->n.next = &from->n;
612
+ from->n.prev = &to->n;
613
+ to_head->prev = from_tail;
614
+ from_tail->next = to_head;
615
+
616
+ /* Now remove head. */
617
+ list_del(&from->n);
618
+ list_head_init(from);
619
+ }
620
+
621
+ /* internal macros, do not use directly */
622
+ #define list_for_each_off_dir_(h, i, off, dir) \
623
+ for (i = list_node_to_off_(list_debug(h, LIST_LOC)->n.dir, \
624
+ (off)); \
625
+ list_node_from_off_((void *)i, (off)) != &(h)->n; \
626
+ i = list_node_to_off_(list_node_from_off_((void *)i, (off))->dir, \
627
+ (off)))
628
+
629
+ #define list_for_each_safe_off_dir_(h, i, nxt, off, dir) \
630
+ for (i = list_node_to_off_(list_debug(h, LIST_LOC)->n.dir, \
631
+ (off)), \
632
+ nxt = list_node_to_off_(list_node_from_off_(i, (off))->dir, \
633
+ (off)); \
634
+ list_node_from_off_(i, (off)) != &(h)->n; \
635
+ i = nxt, \
636
+ nxt = list_node_to_off_(list_node_from_off_(i, (off))->dir, \
637
+ (off)))
638
+
639
+ /**
640
+ * list_for_each_off - iterate through a list of memory regions.
641
+ * @h: the list_head
642
+ * @i: the pointer to a memory region wich contains list node data.
643
+ * @off: offset(relative to @i) at which list node data resides.
644
+ *
645
+ * This is a low-level wrapper to iterate @i over the entire list, used to
646
+ * implement all oher, more high-level, for-each constructs. It's a for loop,
647
+ * so you can break and continue as normal.
648
+ *
649
+ * WARNING! Being the low-level macro that it is, this wrapper doesn't know
650
+ * nor care about the type of @i. The only assumtion made is that @i points
651
+ * to a chunk of memory that at some @offset, relative to @i, contains a
652
+ * properly filled `struct node_list' which in turn contains pointers to
653
+ * memory chunks and it's turtles all the way down. Whith all that in mind
654
+ * remember that given the wrong pointer/offset couple this macro will
655
+ * happilly churn all you memory untill SEGFAULT stops it, in other words
656
+ * caveat emptor.
657
+ *
658
+ * It is worth mentioning that one of legitimate use-cases for that wrapper
659
+ * is operation on opaque types with known offset for `struct list_node'
660
+ * member(preferably 0), because it allows you not to disclose the type of
661
+ * @i.
662
+ *
663
+ * Example:
664
+ * list_for_each_off(&parent->children, child,
665
+ * offsetof(struct child, list))
666
+ * printf("Name: %s\n", child->name);
667
+ */
668
+ #define list_for_each_off(h, i, off) \
669
+ list_for_each_off_dir_((h),(i),(off),next)
670
+
671
+ /**
672
+ * list_for_each_rev_off - iterate through a list of memory regions backwards
673
+ * @h: the list_head
674
+ * @i: the pointer to a memory region wich contains list node data.
675
+ * @off: offset(relative to @i) at which list node data resides.
676
+ *
677
+ * See list_for_each_off for details
678
+ */
679
+ #define list_for_each_rev_off(h, i, off) \
680
+ list_for_each_off_dir_((h),(i),(off),prev)
681
+
682
+ /**
683
+ * list_for_each_safe_off - iterate through a list of memory regions, maybe
684
+ * during deletion
685
+ * @h: the list_head
686
+ * @i: the pointer to a memory region wich contains list node data.
687
+ * @nxt: the structure containing the list_node
688
+ * @off: offset(relative to @i) at which list node data resides.
689
+ *
690
+ * For details see `list_for_each_off' and `list_for_each_safe'
691
+ * descriptions.
692
+ *
693
+ * Example:
694
+ * list_for_each_safe_off(&parent->children, child,
695
+ * next, offsetof(struct child, list))
696
+ * printf("Name: %s\n", child->name);
697
+ */
698
+ #define list_for_each_safe_off(h, i, nxt, off) \
699
+ list_for_each_safe_off_dir_((h),(i),(nxt),(off),next)
700
+
701
+ /**
702
+ * list_for_each_rev_safe_off - iterate backwards through a list of
703
+ * memory regions, maybe during deletion
704
+ * @h: the list_head
705
+ * @i: the pointer to a memory region wich contains list node data.
706
+ * @nxt: the structure containing the list_node
707
+ * @off: offset(relative to @i) at which list node data resides.
708
+ *
709
+ * For details see `list_for_each_rev_off' and `list_for_each_rev_safe'
710
+ * descriptions.
711
+ *
712
+ * Example:
713
+ * list_for_each_rev_safe_off(&parent->children, child,
714
+ * next, offsetof(struct child, list))
715
+ * printf("Name: %s\n", child->name);
716
+ */
717
+ #define list_for_each_rev_safe_off(h, i, nxt, off) \
718
+ list_for_each_safe_off_dir_((h),(i),(nxt),(off),prev)
719
+
720
+ /* Other -off variants. */
721
+ #define list_entry_off(n, type, off) \
722
+ ((type *)list_node_from_off_((n), (off)))
723
+
724
+ #define list_head_off(h, type, off) \
725
+ ((type *)list_head_off((h), (off)))
726
+
727
+ #define list_tail_off(h, type, off) \
728
+ ((type *)list_tail_((h), (off)))
729
+
730
+ #define list_add_off(h, n, off) \
731
+ list_add((h), list_node_from_off_((n), (off)))
732
+
733
+ #define list_del_off(n, off) \
734
+ list_del(list_node_from_off_((n), (off)))
735
+
736
+ #define list_del_from_off(h, n, off) \
737
+ list_del_from(h, list_node_from_off_((n), (off)))
738
+
739
+ /* Offset helper functions so we only single-evaluate. */
740
+ static inline void *list_node_to_off_(struct list_node *node, size_t off)
741
+ {
742
+ return (void *)((char *)node - off);
743
+ }
744
+ static inline struct list_node *list_node_from_off_(void *ptr, size_t off)
745
+ {
746
+ return (struct list_node *)((char *)ptr + off);
747
+ }
748
+
749
+ /* Get the offset of the member, but make sure it's a list_node. */
750
+ #define list_off_(type, member) \
751
+ (container_off(type, member) + \
752
+ check_type(((type *)0)->member, struct list_node))
753
+
754
+ #define list_off_var_(var, member) \
755
+ (container_off_var(var, member) + \
756
+ check_type(var->member, struct list_node))
757
+
758
+ #if HAVE_TYPEOF
759
+ #define list_typeof(var) typeof(var)
760
+ #else
761
+ #define list_typeof(var) void *
762
+ #endif
763
+
764
+ /* Returns member, or NULL if at end of list. */
765
+ static inline void *list_entry_or_null(const struct list_head *h,
766
+ const struct list_node *n,
767
+ size_t off)
768
+ {
769
+ if (n == &h->n)
770
+ return NULL;
771
+ return (char *)n - off;
772
+ }
773
+ #endif /* CCAN_LIST_H */