antithread, foreach, grab_file, hashtable, str_talloc: fix _info depends.
[ccan] / ccan / foreach / foreach.c
1 #if !HAVE_COMPOUND_LITERALS || !HAVE_FOR_LOOP_DECLARATION
2 #include <ccan/foreach/foreach.h>
3 #include <ccan/list/list.h>
4 #include <stdint.h>
5 #include <stdlib.h>
6 #include <stdarg.h>
7
8 /* This list is normally very short. */
9 static LIST_HEAD(iters);
10
11 struct iter_info {
12         struct list_node list;
13         const void *index;
14         unsigned int i, num;
15 };
16
17 static void free_old_iters(const void *index)
18 {
19         struct iter_info *i, *next;
20
21         list_for_each_safe(&iters, i, next, list) {
22                 /* If we're re-using an index, free the old one.
23                  * Otherwise, if it's past i on the stack, it's old.  Don't
24                  * assume stack direction, but we know index is downstack. */
25                 if (i->index == index
26                     || (((uintptr_t)index < (uintptr_t)&i)
27                         == ((uintptr_t)&i < (uintptr_t)i->index))) {
28                         list_del(&i->list);
29                         free(i);
30                 }
31         }
32 }
33
34 static struct iter_info *find_iter(const void *index)
35 {
36         struct iter_info *i;
37
38         list_for_each(&iters, i, list) {
39                 if (i->index == index)
40                         return i;
41         }
42         abort();
43 }
44
45 static struct iter_info *new_iter(const void *index)
46 {
47         struct iter_info *info = malloc(sizeof *info);
48         info->index = index;
49         info->i = info->num = 0;
50         list_add(&iters, &info->list);
51         return info;
52 };
53
54 #if HAVE_COMPOUND_LITERALS
55 void _foreach_iter_init(const void *i)
56 {
57         free_old_iters(i);
58         new_iter(i);
59 }
60
61 unsigned int _foreach_iter(const void *i)
62 {
63         struct iter_info *info = find_iter(i);
64         return info->i;
65 }
66
67 unsigned int _foreach_iter_inc(const void *i)
68 {
69         struct iter_info *info = find_iter(i);
70         return ++info->i;
71 }
72 #else /* Don't have compound literals... */
73 int _foreach_term = 0x42430199;
74
75 /* We count values at beginning, and every time around the loop.  We change
76  * the terminator each time, so we don't get fooled in case it really appears
77  * in the list. */
78 static unsigned int count_vals(struct iter_info *info, va_list *ap)
79 {
80         unsigned int i;
81         int val = 0;
82
83         for (i = 0; i < info->num || val != _foreach_term; i++) {
84                 val = va_arg(*ap, int);
85         }
86         _foreach_term++;
87         return i;
88 }
89
90 int _foreach_intval_init(const void *i, int val, ...)
91 {
92         va_list ap;
93         struct iter_info *info;
94
95         free_old_iters(i);
96         info = new_iter(i);
97
98         va_start(ap, val);
99         info->num = count_vals(info, &ap);
100         va_end(ap);
101
102         return val;
103 }
104
105 bool _foreach_intval_done(const void *i)
106 {
107         struct iter_info *info = find_iter(i);
108         return info->i == info->num;
109 }
110         
111 int _foreach_intval_next(const void *i, int val, ...)
112 {
113         struct iter_info *info = find_iter(i);
114         va_list ap;
115         unsigned int num;
116
117         va_start(ap, val);
118         info->num = count_vals(info, &ap);
119         va_end(ap);
120
121         info->i++;
122         assert(info->i <= info->num);
123         if (info->i == info->num)
124                 return 0;
125
126         va_start(ap, val);
127         for (num = 0; num < info->i; num++)
128                 val = va_arg(ap, int);
129
130         va_end(ap);
131         return val;
132 }
133
134 void *_foreach_ptrval_init(const void *i, const void *val, ...)
135 {
136         struct iter_info *info;
137
138         free_old_iters(i);
139         info = new_iter(i);
140
141         return (void *)val;
142 }
143
144 void *_foreach_ptrval_next(const void *i, const void *val, ...)
145 {
146         struct iter_info *info = find_iter(i);
147         va_list ap;
148         unsigned int num;
149
150         info->i++;
151         va_start(ap, val);
152         for (num = 0; num < info->i; num++)
153                 val = va_arg(ap, void *);
154         va_end(ap);
155         return (void *)val;
156 }
157 #endif /* !HAVE_COMPOUND_LITERALS */
158 #endif /* !HAVE_COMPOUND_LITERALS || !HAVE_FOR_LOOP_DECLARATION */