|
22 | 22 |
|
23 | 23 | #define SLIST_HEAD(name, type) \
|
24 | 24 | struct name { \
|
25 |
| - struct type *first; \ |
| 25 | + struct type *slh_first; \ |
26 | 26 | }
|
27 | 27 |
|
28 | 28 | #define SLIST_CLASS_HEAD(name, type) \
|
29 | 29 | struct name { \
|
30 |
| - class type *first; \ |
| 30 | + class type *slh_first; \ |
31 | 31 | }
|
32 | 32 |
|
33 | 33 | #define SLIST_HEAD_INITIALIZER(head) \
|
|
45 | 45 |
|
46 | 46 | // Singly-linked list access methods.
|
47 | 47 |
|
48 |
| -#define SLIST_EMPTY(head) ((head)->first == NULL) |
49 |
| -#define SLIST_FIRST(head) ((head)->first) |
| 48 | +#define SLIST_EMPTY(head) ((head)->slh_first == NULL) |
| 49 | +#define SLIST_FIRST(head) ((head)->slh_first) |
50 | 50 | #define SLIST_NEXT(elem, field) ((elem)->field.next)
|
51 | 51 |
|
52 | 52 | #define SLIST_FOREACH(var, head, field) \
|
|
132 | 132 |
|
133 | 133 | #define STAILQ_HEAD(name, type) \
|
134 | 134 | struct name { \
|
135 |
| - struct type *first; \ |
136 |
| - struct type **last; \ |
| 135 | + struct type *stqh_first; \ |
| 136 | + struct type **stqh_last; \ |
137 | 137 | }
|
138 | 138 |
|
139 | 139 | #define STAILQ_CLASS_HEAD(name, type) \
|
140 | 140 | struct name { \
|
141 |
| - class type *first; \ |
142 |
| - class type **last; \ |
| 141 | + class type *stqh_first; \ |
| 142 | + class type **stqh_last; \ |
143 | 143 | }
|
144 | 144 |
|
145 | 145 | #define STAILQ_HEAD_INITIALIZER(head) \
|
146 |
| - { NULL, &(head).first } |
| 146 | + { NULL, &(head).stqh_first } |
147 | 147 |
|
148 | 148 | #define STAILQ_ENTRY(type) \
|
149 | 149 | struct { \
|
|
157 | 157 |
|
158 | 158 | // Singly-linked tail queue access methods.
|
159 | 159 |
|
160 |
| -#define STAILQ_EMPTY(head) ((head)->first == NULL) |
161 |
| -#define STAILQ_FIRST(head) ((head)->first) |
| 160 | +#define STAILQ_EMPTY(head) ((head)->stqh_first == NULL) |
| 161 | +#define STAILQ_FIRST(head) ((head)->stqh_first) |
162 | 162 | #define STAILQ_LAST(head, type, field) \
|
163 | 163 | (STAILQ_EMPTY(head) \
|
164 | 164 | ? NULL \
|
165 |
| - : __containerof((head)->last, QUEUE_TYPEOF(type), field.next)) |
| 165 | + : __containerof((head)->stqh_last, QUEUE_TYPEOF(type), field.next)) |
166 | 166 | #define STAILQ_NEXT(elem, field) ((elem)->field.next)
|
167 | 167 |
|
168 | 168 | #define STAILQ_FOREACH(var, head, field) \
|
|
187 | 187 | #define STAILQ_CONCAT(head1, head2, type, field) \
|
188 | 188 | do { \
|
189 | 189 | if (!STAILQ_EMPTY(head2)) { \
|
190 |
| - *(head1)->last = (head2)->first; \ |
191 |
| - (head1)->last = (head2)->last; \ |
| 190 | + *(head1)->stqh_last = (head2)->stqh_first; \ |
| 191 | + (head1)->stqh_last = (head2)->stqh_last; \ |
192 | 192 | STAILQ_INIT(head2); \
|
193 | 193 | } \
|
194 | 194 | } while (0)
|
195 | 195 |
|
196 | 196 | #define STAILQ_INIT(head) \
|
197 | 197 | do { \
|
198 | 198 | STAILQ_FIRST(head) = NULL; \
|
199 |
| - (head)->last = &STAILQ_FIRST(head); \ |
| 199 | + (head)->stqh_last = &STAILQ_FIRST(head); \ |
200 | 200 | } while (0)
|
201 | 201 |
|
202 | 202 | #define STAILQ_INSERT_AFTER(head, listelem, elem, field) \
|
203 | 203 | do { \
|
204 | 204 | if ((STAILQ_NEXT(elem, field) = STAILQ_NEXT(listelem, field)) == NULL) \
|
205 |
| - (head)->last = &STAILQ_NEXT(elem, field); \ |
| 205 | + (head)->stqh_last = &STAILQ_NEXT(elem, field); \ |
206 | 206 | STAILQ_NEXT(listelem, field) = (elem); \
|
207 | 207 | } while (0)
|
208 | 208 |
|
209 | 209 | #define STAILQ_INSERT_HEAD(head, elem, field) \
|
210 | 210 | do { \
|
211 | 211 | if ((STAILQ_NEXT(elem, field) = STAILQ_FIRST(head)) == NULL) \
|
212 |
| - (head)->last = &STAILQ_NEXT(elem, field); \ |
| 212 | + (head)->stqh_last = &STAILQ_NEXT(elem, field); \ |
213 | 213 | STAILQ_FIRST(head) = (elem); \
|
214 | 214 | } while (0)
|
215 | 215 |
|
216 | 216 | #define STAILQ_INSERT_TAIL(head, elem, field) \
|
217 | 217 | do { \
|
218 | 218 | STAILQ_NEXT(elem, field) = NULL; \
|
219 |
| - *(head)->last = (elem); \ |
220 |
| - (head)->last = &STAILQ_NEXT(elem, field); \ |
| 219 | + *(head)->stqh_last = (elem); \ |
| 220 | + (head)->stqh_last = &STAILQ_NEXT(elem, field); \ |
221 | 221 | } while (0)
|
222 | 222 |
|
223 | 223 | #define STAILQ_REMOVE(head, elem, type, field) \
|
|
236 | 236 | do { \
|
237 | 237 | if ((STAILQ_NEXT(elem, field) = \
|
238 | 238 | STAILQ_NEXT(STAILQ_NEXT(elem, field), field)) == NULL) \
|
239 |
| - (head)->last = &STAILQ_NEXT(elem, field); \ |
| 239 | + (head)->stqh_last = &STAILQ_NEXT(elem, field); \ |
240 | 240 | } while (0)
|
241 | 241 |
|
242 | 242 | #define STAILQ_REMOVE_HEAD(head, field) \
|
243 | 243 | do { \
|
244 | 244 | if ((STAILQ_FIRST(head) = STAILQ_NEXT(STAILQ_FIRST(head), field)) == NULL) \
|
245 |
| - (head)->last = &STAILQ_FIRST(head); \ |
| 245 | + (head)->stqh_last = &STAILQ_FIRST(head); \ |
246 | 246 | } while (0)
|
247 | 247 |
|
248 | 248 | #define STAILQ_SWAP(head1, head2, type) \
|
249 | 249 | do { \
|
250 | 250 | QUEUE_TYPEOF(type) *first = STAILQ_FIRST(head1); \
|
251 |
| - QUEUE_TYPEOF(type) **last = (head1)->last; \ |
| 251 | + QUEUE_TYPEOF(type) **last = (head1)->stqh_last; \ |
252 | 252 | STAILQ_FIRST(head1) = STAILQ_FIRST(head2); \
|
253 |
| - (head1)->last = (head2)->last; \ |
| 253 | + (head1)->stqh_last = (head2)->stqh_last; \ |
254 | 254 | STAILQ_FIRST(head2) = first; \
|
255 |
| - (head2)->last = last; \ |
| 255 | + (head2)->stqh_last = last; \ |
256 | 256 | if (STAILQ_EMPTY(head1)) \
|
257 |
| - (head1)->last = &STAILQ_FIRST(head1); \ |
| 257 | + (head1)->stqh_last = &STAILQ_FIRST(head1); \ |
258 | 258 | if (STAILQ_EMPTY(head2)) \
|
259 |
| - (head2)->last = &STAILQ_FIRST(head2); \ |
| 259 | + (head2)->stqh_last = &STAILQ_FIRST(head2); \ |
260 | 260 | } while (0)
|
261 | 261 |
|
262 | 262 | #endif // __LLVM_LIBC_MACROS_SYS_QUEUE_MACROS_H
|
0 commit comments