MeterLogger
queue.h
Go to the documentation of this file.
1 #ifndef _SYS_QUEUE_H_
2 #define _SYS_QUEUE_H_
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 #endif /* !_SYS_QUEUE_H_ */
Generated by   doxygen 1.8.13