|
1 | 1 | #ifndef _SYS_QUEUE_H_
|
2 | 2 | #define _SYS_QUEUE_H_
|
3 | 3 |
|
4 |
| -#define QMD_SAVELINK(name, link) |
5 |
| -#define TRASHIT(x) |
6 |
| - |
7 |
| -/* |
8 |
| - * Singly-linked List declarations. |
9 |
| - */ |
10 |
| -#define SLIST_HEAD(name, type) \ |
11 |
| -struct name { \ |
12 |
| - struct type *slh_first; /* first element */ \ |
13 |
| -} |
14 |
| - |
15 |
| -#define SLIST_HEAD_INITIALIZER(head) \ |
16 |
| - { NULL } |
17 |
| - |
18 |
| -#define SLIST_ENTRY(type) \ |
19 |
| -struct { \ |
20 |
| - struct type *sle_next; /* next element */ \ |
21 |
| -} |
22 |
| - |
23 |
| -/* |
24 |
| - * Singly-linked List functions. |
25 |
| - */ |
26 |
| -#define SLIST_EMPTY(head) ((head)->slh_first == NULL) |
27 |
| - |
28 |
| -#define SLIST_FIRST(head) ((head)->slh_first) |
29 |
| - |
30 |
| -#define SLIST_FOREACH(var, head, field) \ |
31 |
| - for ((var) = SLIST_FIRST((head)); \ |
32 |
| - (var); \ |
33 |
| - (var) = SLIST_NEXT((var), field)) |
34 |
| - |
35 |
| -#define SLIST_FOREACH_SAFE(var, head, field, tvar) \ |
36 |
| - for ((var) = SLIST_FIRST((head)); \ |
37 |
| - (var) && ((tvar) = SLIST_NEXT((var), field), 1); \ |
38 |
| - (var) = (tvar)) |
39 |
| - |
40 |
| -#define SLIST_FOREACH_PREVPTR(var, varp, head, field) \ |
41 |
| - for ((varp) = &SLIST_FIRST((head)); \ |
42 |
| - ((var) = *(varp)) != NULL; \ |
43 |
| - (varp) = &SLIST_NEXT((var), field)) |
44 |
| - |
45 |
| -#define SLIST_INIT(head) do { \ |
46 |
| - SLIST_FIRST((head)) = NULL; \ |
47 |
| -} while (0) |
48 |
| - |
49 |
| -#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \ |
50 |
| - SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \ |
51 |
| - SLIST_NEXT((slistelm), field) = (elm); \ |
52 |
| -} while (0) |
53 |
| - |
54 |
| -#define SLIST_INSERT_HEAD(head, elm, field) do { \ |
55 |
| - SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \ |
56 |
| - SLIST_FIRST((head)) = (elm); \ |
57 |
| -} while (0) |
58 |
| - |
59 |
| -#define SLIST_NEXT(elm, field) ((elm)->field.sle_next) |
60 |
| - |
61 |
| -#define SLIST_REMOVE(head, elm, type, field) do { \ |
62 |
| - QMD_SAVELINK(oldnext, (elm)->field.sle_next); \ |
63 |
| - if (SLIST_FIRST((head)) == (elm)) { \ |
64 |
| - SLIST_REMOVE_HEAD((head), field); \ |
65 |
| - } \ |
66 |
| - else { \ |
67 |
| - struct type *curelm = SLIST_FIRST((head)); \ |
68 |
| - while (SLIST_NEXT(curelm, field) != (elm)) \ |
69 |
| - curelm = SLIST_NEXT(curelm, field); \ |
70 |
| - SLIST_REMOVE_AFTER(curelm, field); \ |
71 |
| - } \ |
72 |
| - TRASHIT(*oldnext); \ |
73 |
| -} while (0) |
74 |
| - |
75 |
| -#define SLIST_REMOVE_AFTER(elm, field) do { \ |
76 |
| - SLIST_NEXT(elm, field) = \ |
77 |
| - SLIST_NEXT(SLIST_NEXT(elm, field), field); \ |
78 |
| -} while (0) |
79 |
| - |
80 |
| -#define SLIST_REMOVE_HEAD(head, field) do { \ |
81 |
| - SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \ |
82 |
| -} while (0) |
83 |
| - |
84 |
| -/* |
85 |
| - * Singly-linked Tail queue declarations. |
86 |
| - */ |
87 |
| -#define STAILQ_HEAD(name, type) \ |
88 |
| - struct name { \ |
89 |
| - struct type *stqh_first;/* first element */ \ |
90 |
| - struct type **stqh_last;/* addr of last next element */ \ |
91 |
| - } |
92 |
| - |
93 |
| -#define STAILQ_HEAD_INITIALIZER(head) \ |
94 |
| - { NULL, &(head).stqh_first } |
95 |
| - |
96 |
| -#define STAILQ_ENTRY(type) \ |
97 |
| - struct { \ |
98 |
| - struct type *stqe_next; /* next element */ \ |
99 |
| - } |
100 |
| - |
101 |
| -/* |
102 |
| - * Singly-linked Tail queue functions. |
103 |
| - */ |
104 |
| -#define STAILQ_CONCAT(head1, head2) do { \ |
105 |
| - if (!STAILQ_EMPTY((head2))) { \ |
106 |
| - *(head1)->stqh_last = (head2)->stqh_first; \ |
107 |
| - (head1)->stqh_last = (head2)->stqh_last; \ |
108 |
| - STAILQ_INIT((head2)); \ |
109 |
| - } \ |
110 |
| - } while (0) |
111 |
| - |
112 |
| -#define STAILQ_EMPTY(head) ((head)->stqh_first == NULL) |
113 |
| - |
114 |
| -#define STAILQ_FIRST(head) ((head)->stqh_first) |
115 |
| - |
116 |
| -#define STAILQ_FOREACH(var, head, field) \ |
117 |
| - for((var) = STAILQ_FIRST((head)); \ |
118 |
| - (var); \ |
119 |
| - (var) = STAILQ_NEXT((var), field)) |
120 |
| - |
121 |
| - |
122 |
| -#define STAILQ_FOREACH_SAFE(var, head, field, tvar) \ |
123 |
| - for ((var) = STAILQ_FIRST((head)); \ |
124 |
| - (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \ |
125 |
| - (var) = (tvar)) |
126 |
| - |
127 |
| -#define STAILQ_INIT(head) do { \ |
128 |
| - STAILQ_FIRST((head)) = NULL; \ |
129 |
| - (head)->stqh_last = &STAILQ_FIRST((head)); \ |
130 |
| - } while (0) |
131 |
| - |
132 |
| -#define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \ |
133 |
| - if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\ |
134 |
| - (head)->stqh_last = &STAILQ_NEXT((elm), field); \ |
135 |
| - STAILQ_NEXT((tqelm), field) = (elm); \ |
136 |
| - } while (0) |
137 |
| - |
138 |
| -#define STAILQ_INSERT_HEAD(head, elm, field) do { \ |
139 |
| - if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \ |
140 |
| - (head)->stqh_last = &STAILQ_NEXT((elm), field); \ |
141 |
| - STAILQ_FIRST((head)) = (elm); \ |
142 |
| - } while (0) |
143 |
| - |
144 |
| -#define STAILQ_INSERT_TAIL(head, elm, field) do { \ |
145 |
| - STAILQ_NEXT((elm), field) = NULL; \ |
146 |
| - *(head)->stqh_last = (elm); \ |
147 |
| - (head)->stqh_last = &STAILQ_NEXT((elm), field); \ |
148 |
| - } while (0) |
149 |
| - |
150 |
| -#define STAILQ_LAST(head, type, field) \ |
151 |
| - (STAILQ_EMPTY((head)) ? \ |
152 |
| - NULL : \ |
153 |
| - ((struct type *)(void *) \ |
154 |
| - ((char *)((head)->stqh_last) - __offsetof(struct type, field)))) |
155 |
| - |
156 |
| -#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next) |
157 |
| - |
158 |
| -#define STAILQ_REMOVE(head, elm, type, field) do { \ |
159 |
| - QMD_SAVELINK(oldnext, (elm)->field.stqe_next); \ |
160 |
| - if (STAILQ_FIRST((head)) == (elm)) { \ |
161 |
| - STAILQ_REMOVE_HEAD((head), field); \ |
162 |
| - } \ |
163 |
| - else { \ |
164 |
| - struct type *curelm = STAILQ_FIRST((head)); \ |
165 |
| - while (STAILQ_NEXT(curelm, field) != (elm)) \ |
166 |
| - curelm = STAILQ_NEXT(curelm, field); \ |
167 |
| - STAILQ_REMOVE_AFTER(head, curelm, field); \ |
168 |
| - } \ |
169 |
| - TRASHIT(*oldnext); \ |
170 |
| - } while (0) |
171 |
| - |
172 |
| -#define STAILQ_REMOVE_HEAD(head, field) do { \ |
173 |
| - if ((STAILQ_FIRST((head)) = \ |
174 |
| - STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \ |
175 |
| - (head)->stqh_last = &STAILQ_FIRST((head)); \ |
176 |
| - } while (0) |
177 |
| - |
178 |
| -#define STAILQ_REMOVE_AFTER(head, elm, field) do { \ |
179 |
| - if ((STAILQ_NEXT(elm, field) = \ |
180 |
| - STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL) \ |
181 |
| - (head)->stqh_last = &STAILQ_NEXT((elm), field); \ |
182 |
| - } while (0) |
183 |
| - |
184 |
| -#define STAILQ_SWAP(head1, head2, type) do { \ |
185 |
| - struct type *swap_first = STAILQ_FIRST(head1); \ |
186 |
| - struct type **swap_last = (head1)->stqh_last; \ |
187 |
| - STAILQ_FIRST(head1) = STAILQ_FIRST(head2); \ |
188 |
| - (head1)->stqh_last = (head2)->stqh_last; \ |
189 |
| - STAILQ_FIRST(head2) = swap_first; \ |
190 |
| - (head2)->stqh_last = swap_last; \ |
191 |
| - if (STAILQ_EMPTY(head1)) \ |
192 |
| - (head1)->stqh_last = &STAILQ_FIRST(head1); \ |
193 |
| - if (STAILQ_EMPTY(head2)) \ |
194 |
| - (head2)->stqh_last = &STAILQ_FIRST(head2); \ |
195 |
| - } while (0) |
196 |
| - |
197 |
| -#define STAILQ_INSERT_CHAIN_HEAD(head, elm_chead, elm_ctail, field) do { \ |
198 |
| - if ((STAILQ_NEXT(elm_ctail, field) = STAILQ_FIRST(head)) == NULL ) { \ |
199 |
| - (head)->stqh_last = &STAILQ_NEXT(elm_ctail, field); \ |
200 |
| - } \ |
201 |
| - STAILQ_FIRST(head) = (elm_chead); \ |
202 |
| - } while (0) |
203 |
| - |
204 | 4 | #endif /* !_SYS_QUEUE_H_ */
|
0 commit comments