gwj / at91sam9263 · Commits

Commit fc56ef08b9bb8cc1478fa0758c2bc65f1b6a9a79

Authored by blueswir1
1 parent e2832619

Remove CRs 

git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6021 c046a42c-6fe2-441c-8c8c-71466251a162
Inline Side-by-side
Showing 1 changed file with 343 additions and 343 deletions
sys-queue.h
  View file @fc56ef0
1   -/* $NetBSD: queue.h,v 1.45.14.1 2007/07/18 20:13:24 liamjfoy Exp $ */
2   -
3   -/*
4   - * Qemu version: Copy from netbsd, removed debug code, removed some of
5   - * the implementations. Left in lists, tail queues and circular queues.
6   - */
7   -
8   -/*
9   - * Copyright (c) 1991, 1993
10   - * The Regents of the University of California. All rights reserved.
11   - *
12   - * Redistribution and use in source and binary forms, with or without
13   - * modification, are permitted provided that the following conditions
14   - * are met:
15   - * 1. Redistributions of source code must retain the above copyright
16   - * notice, this list of conditions and the following disclaimer.
17   - * 2. Redistributions in binary form must reproduce the above copyright
18   - * notice, this list of conditions and the following disclaimer in the
19   - * documentation and/or other materials provided with the distribution.
20   - * 3. Neither the name of the University nor the names of its contributors
21   - * may be used to endorse or promote products derived from this software
22   - * without specific prior written permission.
23   - *
24   - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25   - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26   - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27   - * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28   - * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29   - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30   - * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31   - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32   - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33   - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34   - * SUCH DAMAGE.
35   - *
36   - * @(#)queue.h 8.5 (Berkeley) 8/20/94
37   - */
38   -
39   -#ifndef _SYS_QUEUE_H_
40   -#define _SYS_QUEUE_H_
41   -
42   -/*
43   - * This file defines three types of data structures:
44   - * lists, tail queues, and circular queues.
45   - *
46   - * A list is headed by a single forward pointer (or an array of forward
47   - * pointers for a hash table header). The elements are doubly linked
48   - * so that an arbitrary element can be removed without a need to
49   - * traverse the list. New elements can be added to the list before
50   - * or after an existing element or at the head of the list. A list
51   - * may only be traversed in the forward direction.
52   - *
53   - * A tail queue is headed by a pair of pointers, one to the head of the
54   - * list and the other to the tail of the list. The elements are doubly
55   - * linked so that an arbitrary element can be removed without a need to
56   - * traverse the list. New elements can be added to the list before or
57   - * after an existing element, at the head of the list, or at the end of
58   - * the list. A tail queue may be traversed in either direction.
59   - *
60   - * A circle queue is headed by a pair of pointers, one to the head of the
61   - * list and the other to the tail of the list. The elements are doubly
62   - * linked so that an arbitrary element can be removed without a need to
63   - * traverse the list. New elements can be added to the list before or after
64   - * an existing element, at the head of the list, or at the end of the list.
65   - * A circle queue may be traversed in either direction, but has a more
66   - * complex end of list detection.
67   - *
68   - * For details on the use of these macros, see the queue(3) manual page.
69   - */
70   -
71   -/*
72   - * List definitions.
73   - */
74   -#define LIST_HEAD(name, type) \
75   -struct name { \
76   - struct type *lh_first; /* first element */ \
77   -}
78   -
79   -#define LIST_HEAD_INITIALIZER(head) \
80   - { NULL }
81   -
82   -#define LIST_ENTRY(type) \
83   -struct { \
84   - struct type *le_next; /* next element */ \
85   - struct type **le_prev; /* address of previous next element */ \
86   -}
87   -
88   -/*
89   - * List functions.
90   - */
91   -#define LIST_INIT(head) do { \
92   - (head)->lh_first = NULL; \
93   -} while (/*CONSTCOND*/0)
94   -
95   -#define LIST_INSERT_AFTER(listelm, elm, field) do { \
96   - if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \
97   - (listelm)->field.le_next->field.le_prev = \
98   - &(elm)->field.le_next; \
99   - (listelm)->field.le_next = (elm); \
100   - (elm)->field.le_prev = &(listelm)->field.le_next; \
101   -} while (/*CONSTCOND*/0)
102   -
103   -#define LIST_INSERT_BEFORE(listelm, elm, field) do { \
104   - (elm)->field.le_prev = (listelm)->field.le_prev; \
105   - (elm)->field.le_next = (listelm); \
106   - *(listelm)->field.le_prev = (elm); \
107   - (listelm)->field.le_prev = &(elm)->field.le_next; \
108   -} while (/*CONSTCOND*/0)
109   -
110   -#define LIST_INSERT_HEAD(head, elm, field) do { \
111   - if (((elm)->field.le_next = (head)->lh_first) != NULL) \
112   - (head)->lh_first->field.le_prev = &(elm)->field.le_next;\
113   - (head)->lh_first = (elm); \
114   - (elm)->field.le_prev = &(head)->lh_first; \
115   -} while (/*CONSTCOND*/0)
116   -
117   -#define LIST_REMOVE(elm, field) do { \
118   - if ((elm)->field.le_next != NULL) \
119   - (elm)->field.le_next->field.le_prev = \
120   - (elm)->field.le_prev; \
121   - *(elm)->field.le_prev = (elm)->field.le_next; \
122   -} while (/*CONSTCOND*/0)
123   -
124   -#define LIST_FOREACH(var, head, field) \
125   - for ((var) = ((head)->lh_first); \
126   - (var); \
127   - (var) = ((var)->field.le_next))
128   -
129   -/*
130   - * List access methods.
131   - */
132   -#define LIST_EMPTY(head) ((head)->lh_first == NULL)
133   -#define LIST_FIRST(head) ((head)->lh_first)
134   -#define LIST_NEXT(elm, field) ((elm)->field.le_next)
135   -
136   -
137   -/*
138   - * Tail queue definitions.
139   - */
140   -#define _TAILQ_HEAD(name, type, qual) \
141   -struct name { \
142   - qual type *tqh_first; /* first element */ \
143   - qual type *qual *tqh_last; /* addr of last next element */ \
144   -}
145   -#define TAILQ_HEAD(name, type) _TAILQ_HEAD(name, struct type,)
146   -
147   -#define TAILQ_HEAD_INITIALIZER(head) \
148   - { NULL, &(head).tqh_first }
149   -
150   -#define _TAILQ_ENTRY(type, qual) \
151   -struct { \
152   - qual type *tqe_next; /* next element */ \
153   - qual type *qual *tqe_prev; /* address of previous next element */\
154   -}
155   -#define TAILQ_ENTRY(type) _TAILQ_ENTRY(struct type,)
156   -
157   -/*
158   - * Tail queue functions.
159   - */
160   -#define TAILQ_INIT(head) do { \
161   - (head)->tqh_first = NULL; \
162   - (head)->tqh_last = &(head)->tqh_first; \
163   -} while (/*CONSTCOND*/0)
164   -
165   -#define TAILQ_INSERT_HEAD(head, elm, field) do { \
166   - if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \
167   - (head)->tqh_first->field.tqe_prev = \
168   - &(elm)->field.tqe_next; \
169   - else \
170   - (head)->tqh_last = &(elm)->field.tqe_next; \
171   - (head)->tqh_first = (elm); \
172   - (elm)->field.tqe_prev = &(head)->tqh_first; \
173   -} while (/*CONSTCOND*/0)
174   -
175   -#define TAILQ_INSERT_TAIL(head, elm, field) do { \
176   - (elm)->field.tqe_next = NULL; \
177   - (elm)->field.tqe_prev = (head)->tqh_last; \
178   - *(head)->tqh_last = (elm); \
179   - (head)->tqh_last = &(elm)->field.tqe_next; \
180   -} while (/*CONSTCOND*/0)
181   -
182   -#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
183   - if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
184   - (elm)->field.tqe_next->field.tqe_prev = \
185   - &(elm)->field.tqe_next; \
186   - else \
187   - (head)->tqh_last = &(elm)->field.tqe_next; \
188   - (listelm)->field.tqe_next = (elm); \
189   - (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \
190   -} while (/*CONSTCOND*/0)
191   -
192   -#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \
193   - (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
194   - (elm)->field.tqe_next = (listelm); \
195   - *(listelm)->field.tqe_prev = (elm); \
196   - (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \
197   -} while (/*CONSTCOND*/0)
198   -
199   -#define TAILQ_REMOVE(head, elm, field) do { \
200   - if (((elm)->field.tqe_next) != NULL) \
201   - (elm)->field.tqe_next->field.tqe_prev = \
202   - (elm)->field.tqe_prev; \
203   - else \
204   - (head)->tqh_last = (elm)->field.tqe_prev; \
205   - *(elm)->field.tqe_prev = (elm)->field.tqe_next; \
206   -} while (/*CONSTCOND*/0)
207   -
208   -#define TAILQ_FOREACH(var, head, field) \
209   - for ((var) = ((head)->tqh_first); \
210   - (var); \
211   - (var) = ((var)->field.tqe_next))
212   -
213   -#define TAILQ_FOREACH_SAFE(var, head, field, next_var) \
214   - for ((var) = ((head)->tqh_first); \
215   - (var) && ((next_var) = ((var)->field.tqe_next), 1); \
216   - (var) = (next_var))
217   -
218   -#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
219   - for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last)); \
220   - (var); \
221   - (var) = (*(((struct headname *)((var)->field.tqe_prev))->tqh_last)))
222   -
223   -/*
224   - * Tail queue access methods.
225   - */
226   -#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL)
227   -#define TAILQ_FIRST(head) ((head)->tqh_first)
228   -#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
229   -
230   -#define TAILQ_LAST(head, headname) \
231   - (*(((struct headname *)((head)->tqh_last))->tqh_last))
232   -#define TAILQ_PREV(elm, headname, field) \
233   - (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
234   -
235   -
236   -/*
237   - * Circular queue definitions.
238   - */
239   -#define CIRCLEQ_HEAD(name, type) \
240   -struct name { \
241   - struct type *cqh_first; /* first element */ \
242   - struct type *cqh_last; /* last element */ \
243   -}
244   -
245   -#define CIRCLEQ_HEAD_INITIALIZER(head) \
246   - { (void *)&head, (void *)&head }
247   -
248   -#define CIRCLEQ_ENTRY(type) \
249   -struct { \
250   - struct type *cqe_next; /* next element */ \
251   - struct type *cqe_prev; /* previous element */ \
252   -}
253   -
254   -/*
255   - * Circular queue functions.
256   - */
257   -#define CIRCLEQ_INIT(head) do { \
258   - (head)->cqh_first = (void *)(head); \
259   - (head)->cqh_last = (void *)(head); \
260   -} while (/*CONSTCOND*/0)
261   -
262   -#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
263   - (elm)->field.cqe_next = (listelm)->field.cqe_next; \
264   - (elm)->field.cqe_prev = (listelm); \
265   - if ((listelm)->field.cqe_next == (void *)(head)) \
266   - (head)->cqh_last = (elm); \
267   - else \
268   - (listelm)->field.cqe_next->field.cqe_prev = (elm); \
269   - (listelm)->field.cqe_next = (elm); \
270   -} while (/*CONSTCOND*/0)
271   -
272   -#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \
273   - (elm)->field.cqe_next = (listelm); \
274   - (elm)->field.cqe_prev = (listelm)->field.cqe_prev; \
275   - if ((listelm)->field.cqe_prev == (void *)(head)) \
276   - (head)->cqh_first = (elm); \
277   - else \
278   - (listelm)->field.cqe_prev->field.cqe_next = (elm); \
279   - (listelm)->field.cqe_prev = (elm); \
280   -} while (/*CONSTCOND*/0)
281   -
282   -#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \
283   - (elm)->field.cqe_next = (head)->cqh_first; \
284   - (elm)->field.cqe_prev = (void *)(head); \
285   - if ((head)->cqh_last == (void *)(head)) \
286   - (head)->cqh_last = (elm); \
287   - else \
288   - (head)->cqh_first->field.cqe_prev = (elm); \
289   - (head)->cqh_first = (elm); \
290   -} while (/*CONSTCOND*/0)
291   -
292   -#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \
293   - (elm)->field.cqe_next = (void *)(head); \
294   - (elm)->field.cqe_prev = (head)->cqh_last; \
295   - if ((head)->cqh_first == (void *)(head)) \
296   - (head)->cqh_first = (elm); \
297   - else \
298   - (head)->cqh_last->field.cqe_next = (elm); \
299   - (head)->cqh_last = (elm); \
300   -} while (/*CONSTCOND*/0)
301   -
302   -#define CIRCLEQ_REMOVE(head, elm, field) do { \
303   - if ((elm)->field.cqe_next == (void *)(head)) \
304   - (head)->cqh_last = (elm)->field.cqe_prev; \
305   - else \
306   - (elm)->field.cqe_next->field.cqe_prev = \
307   - (elm)->field.cqe_prev; \
308   - if ((elm)->field.cqe_prev == (void *)(head)) \
309   - (head)->cqh_first = (elm)->field.cqe_next; \
310   - else \
311   - (elm)->field.cqe_prev->field.cqe_next = \
312   - (elm)->field.cqe_next; \
313   -} while (/*CONSTCOND*/0)
314   -
315   -#define CIRCLEQ_FOREACH(var, head, field) \
316   - for ((var) = ((head)->cqh_first); \
317   - (var) != (const void *)(head); \
318   - (var) = ((var)->field.cqe_next))
319   -
320   -#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \
321   - for ((var) = ((head)->cqh_last); \
322   - (var) != (const void *)(head); \
323   - (var) = ((var)->field.cqe_prev))
324   -
325   -/*
326   - * Circular queue access methods.
327   - */
328   -#define CIRCLEQ_EMPTY(head) ((head)->cqh_first == (void *)(head))
329   -#define CIRCLEQ_FIRST(head) ((head)->cqh_first)
330   -#define CIRCLEQ_LAST(head) ((head)->cqh_last)
331   -#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next)
332   -#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev)
333   -
334   -#define CIRCLEQ_LOOP_NEXT(head, elm, field) \
335   - (((elm)->field.cqe_next == (void *)(head)) \
336   - ? ((head)->cqh_first) \
337   - : (elm->field.cqe_next))
338   -#define CIRCLEQ_LOOP_PREV(head, elm, field) \
339   - (((elm)->field.cqe_prev == (void *)(head)) \
340   - ? ((head)->cqh_last) \
341   - : (elm->field.cqe_prev))
342   -
343   -#endif /* !_SYS_QUEUE_H_ */
  1 +/* $NetBSD: queue.h,v 1.45.14.1 2007/07/18 20:13:24 liamjfoy Exp $ */
  2 +
  3 +/*
  4 + * Qemu version: Copy from netbsd, removed debug code, removed some of
  5 + * the implementations. Left in lists, tail queues and circular queues.
  6 + */
  7 +
  8 +/*
  9 + * Copyright (c) 1991, 1993
  10 + * The Regents of the University of California. All rights reserved.
  11 + *
  12 + * Redistribution and use in source and binary forms, with or without
  13 + * modification, are permitted provided that the following conditions
  14 + * are met:
  15 + * 1. Redistributions of source code must retain the above copyright
  16 + * notice, this list of conditions and the following disclaimer.
  17 + * 2. Redistributions in binary form must reproduce the above copyright
  18 + * notice, this list of conditions and the following disclaimer in the
  19 + * documentation and/or other materials provided with the distribution.
  20 + * 3. Neither the name of the University nor the names of its contributors
  21 + * may be used to endorse or promote products derived from this software
  22 + * without specific prior written permission.
  23 + *
  24 + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25 + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27 + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28 + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29 + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30 + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31 + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32 + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33 + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34 + * SUCH DAMAGE.
  35 + *
  36 + * @(#)queue.h 8.5 (Berkeley) 8/20/94
  37 + */
  38 +
  39 +#ifndef _SYS_QUEUE_H_
  40 +#define _SYS_QUEUE_H_
  41 +
  42 +/*
  43 + * This file defines three types of data structures:
  44 + * lists, tail queues, and circular queues.
  45 + *
  46 + * A list is headed by a single forward pointer (or an array of forward
  47 + * pointers for a hash table header). The elements are doubly linked
  48 + * so that an arbitrary element can be removed without a need to
  49 + * traverse the list. New elements can be added to the list before
  50 + * or after an existing element or at the head of the list. A list
  51 + * may only be traversed in the forward direction.
  52 + *
  53 + * A tail queue is headed by a pair of pointers, one to the head of the
  54 + * list and the other to the tail of the list. The elements are doubly
  55 + * linked so that an arbitrary element can be removed without a need to
  56 + * traverse the list. New elements can be added to the list before or
  57 + * after an existing element, at the head of the list, or at the end of
  58 + * the list. A tail queue may be traversed in either direction.
  59 + *
  60 + * A circle queue is headed by a pair of pointers, one to the head of the
  61 + * list and the other to the tail of the list. The elements are doubly
  62 + * linked so that an arbitrary element can be removed without a need to
  63 + * traverse the list. New elements can be added to the list before or after
  64 + * an existing element, at the head of the list, or at the end of the list.
  65 + * A circle queue may be traversed in either direction, but has a more
  66 + * complex end of list detection.
  67 + *
  68 + * For details on the use of these macros, see the queue(3) manual page.
  69 + */
  70 +
  71 +/*
  72 + * List definitions.
  73 + */
  74 +#define LIST_HEAD(name, type) \
  75 +struct name { \
  76 + struct type *lh_first; /* first element */ \
  77 +}
  78 +
  79 +#define LIST_HEAD_INITIALIZER(head) \
  80 + { NULL }
  81 +
  82 +#define LIST_ENTRY(type) \
  83 +struct { \
  84 + struct type *le_next; /* next element */ \
  85 + struct type **le_prev; /* address of previous next element */ \
  86 +}
  87 +
  88 +/*
  89 + * List functions.
  90 + */
  91 +#define LIST_INIT(head) do { \
  92 + (head)->lh_first = NULL; \
  93 +} while (/*CONSTCOND*/0)
  94 +
  95 +#define LIST_INSERT_AFTER(listelm, elm, field) do { \
  96 + if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \
  97 + (listelm)->field.le_next->field.le_prev = \
  98 + &(elm)->field.le_next; \
  99 + (listelm)->field.le_next = (elm); \
  100 + (elm)->field.le_prev = &(listelm)->field.le_next; \
  101 +} while (/*CONSTCOND*/0)
  102 +
  103 +#define LIST_INSERT_BEFORE(listelm, elm, field) do { \
  104 + (elm)->field.le_prev = (listelm)->field.le_prev; \
  105 + (elm)->field.le_next = (listelm); \
  106 + *(listelm)->field.le_prev = (elm); \
  107 + (listelm)->field.le_prev = &(elm)->field.le_next; \
  108 +} while (/*CONSTCOND*/0)
  109 +
  110 +#define LIST_INSERT_HEAD(head, elm, field) do { \
  111 + if (((elm)->field.le_next = (head)->lh_first) != NULL) \
  112 + (head)->lh_first->field.le_prev = &(elm)->field.le_next;\
  113 + (head)->lh_first = (elm); \
  114 + (elm)->field.le_prev = &(head)->lh_first; \
  115 +} while (/*CONSTCOND*/0)
  116 +
  117 +#define LIST_REMOVE(elm, field) do { \
  118 + if ((elm)->field.le_next != NULL) \
  119 + (elm)->field.le_next->field.le_prev = \
  120 + (elm)->field.le_prev; \
  121 + *(elm)->field.le_prev = (elm)->field.le_next; \
  122 +} while (/*CONSTCOND*/0)
  123 +
  124 +#define LIST_FOREACH(var, head, field) \
  125 + for ((var) = ((head)->lh_first); \
  126 + (var); \
  127 + (var) = ((var)->field.le_next))
  128 +
  129 +/*
  130 + * List access methods.
  131 + */
  132 +#define LIST_EMPTY(head) ((head)->lh_first == NULL)
  133 +#define LIST_FIRST(head) ((head)->lh_first)
  134 +#define LIST_NEXT(elm, field) ((elm)->field.le_next)
  135 +
  136 +
  137 +/*
  138 + * Tail queue definitions.
  139 + */
  140 +#define _TAILQ_HEAD(name, type, qual) \
  141 +struct name { \
  142 + qual type *tqh_first; /* first element */ \
  143 + qual type *qual *tqh_last; /* addr of last next element */ \
  144 +}
  145 +#define TAILQ_HEAD(name, type) _TAILQ_HEAD(name, struct type,)
  146 +
  147 +#define TAILQ_HEAD_INITIALIZER(head) \
  148 + { NULL, &(head).tqh_first }
  149 +
  150 +#define _TAILQ_ENTRY(type, qual) \
  151 +struct { \
  152 + qual type *tqe_next; /* next element */ \
  153 + qual type *qual *tqe_prev; /* address of previous next element */\
  154 +}
  155 +#define TAILQ_ENTRY(type) _TAILQ_ENTRY(struct type,)
  156 +
  157 +/*
  158 + * Tail queue functions.
  159 + */
  160 +#define TAILQ_INIT(head) do { \
  161 + (head)->tqh_first = NULL; \
  162 + (head)->tqh_last = &(head)->tqh_first; \
  163 +} while (/*CONSTCOND*/0)
  164 +
  165 +#define TAILQ_INSERT_HEAD(head, elm, field) do { \
  166 + if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \
  167 + (head)->tqh_first->field.tqe_prev = \
  168 + &(elm)->field.tqe_next; \
  169 + else \
  170 + (head)->tqh_last = &(elm)->field.tqe_next; \
  171 + (head)->tqh_first = (elm); \
  172 + (elm)->field.tqe_prev = &(head)->tqh_first; \
  173 +} while (/*CONSTCOND*/0)
  174 +
  175 +#define TAILQ_INSERT_TAIL(head, elm, field) do { \
  176 + (elm)->field.tqe_next = NULL; \
  177 + (elm)->field.tqe_prev = (head)->tqh_last; \
  178 + *(head)->tqh_last = (elm); \
  179 + (head)->tqh_last = &(elm)->field.tqe_next; \
  180 +} while (/*CONSTCOND*/0)
  181 +
  182 +#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
  183 + if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
  184 + (elm)->field.tqe_next->field.tqe_prev = \
  185 + &(elm)->field.tqe_next; \
  186 + else \
  187 + (head)->tqh_last = &(elm)->field.tqe_next; \
  188 + (listelm)->field.tqe_next = (elm); \
  189 + (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \
  190 +} while (/*CONSTCOND*/0)
  191 +
  192 +#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \
  193 + (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
  194 + (elm)->field.tqe_next = (listelm); \
  195 + *(listelm)->field.tqe_prev = (elm); \
  196 + (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \
  197 +} while (/*CONSTCOND*/0)
  198 +
  199 +#define TAILQ_REMOVE(head, elm, field) do { \
  200 + if (((elm)->field.tqe_next) != NULL) \
  201 + (elm)->field.tqe_next->field.tqe_prev = \
  202 + (elm)->field.tqe_prev; \
  203 + else \
  204 + (head)->tqh_last = (elm)->field.tqe_prev; \
  205 + *(elm)->field.tqe_prev = (elm)->field.tqe_next; \
  206 +} while (/*CONSTCOND*/0)
  207 +
  208 +#define TAILQ_FOREACH(var, head, field) \
  209 + for ((var) = ((head)->tqh_first); \
  210 + (var); \
  211 + (var) = ((var)->field.tqe_next))
  212 +
  213 +#define TAILQ_FOREACH_SAFE(var, head, field, next_var) \
  214 + for ((var) = ((head)->tqh_first); \
  215 + (var) && ((next_var) = ((var)->field.tqe_next), 1); \
  216 + (var) = (next_var))
  217 +
  218 +#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
  219 + for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last)); \
  220 + (var); \
  221 + (var) = (*(((struct headname *)((var)->field.tqe_prev))->tqh_last)))
  222 +
  223 +/*
  224 + * Tail queue access methods.
  225 + */
  226 +#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL)
  227 +#define TAILQ_FIRST(head) ((head)->tqh_first)
  228 +#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
  229 +
  230 +#define TAILQ_LAST(head, headname) \
  231 + (*(((struct headname *)((head)->tqh_last))->tqh_last))
  232 +#define TAILQ_PREV(elm, headname, field) \
  233 + (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
  234 +
  235 +
  236 +/*
  237 + * Circular queue definitions.
  238 + */
  239 +#define CIRCLEQ_HEAD(name, type) \
  240 +struct name { \
  241 + struct type *cqh_first; /* first element */ \
  242 + struct type *cqh_last; /* last element */ \
  243 +}
  244 +
  245 +#define CIRCLEQ_HEAD_INITIALIZER(head) \
  246 + { (void *)&head, (void *)&head }
  247 +
  248 +#define CIRCLEQ_ENTRY(type) \
  249 +struct { \
  250 + struct type *cqe_next; /* next element */ \
  251 + struct type *cqe_prev; /* previous element */ \
  252 +}
  253 +
  254 +/*
  255 + * Circular queue functions.
  256 + */
  257 +#define CIRCLEQ_INIT(head) do { \
  258 + (head)->cqh_first = (void *)(head); \
  259 + (head)->cqh_last = (void *)(head); \
  260 +} while (/*CONSTCOND*/0)
  261 +
  262 +#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
  263 + (elm)->field.cqe_next = (listelm)->field.cqe_next; \
  264 + (elm)->field.cqe_prev = (listelm); \
  265 + if ((listelm)->field.cqe_next == (void *)(head)) \
  266 + (head)->cqh_last = (elm); \
  267 + else \
  268 + (listelm)->field.cqe_next->field.cqe_prev = (elm); \
  269 + (listelm)->field.cqe_next = (elm); \
  270 +} while (/*CONSTCOND*/0)
  271 +
  272 +#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \
  273 + (elm)->field.cqe_next = (listelm); \
  274 + (elm)->field.cqe_prev = (listelm)->field.cqe_prev; \
  275 + if ((listelm)->field.cqe_prev == (void *)(head)) \
  276 + (head)->cqh_first = (elm); \
  277 + else \
  278 + (listelm)->field.cqe_prev->field.cqe_next = (elm); \
  279 + (listelm)->field.cqe_prev = (elm); \
  280 +} while (/*CONSTCOND*/0)
  281 +
  282 +#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \
  283 + (elm)->field.cqe_next = (head)->cqh_first; \
  284 + (elm)->field.cqe_prev = (void *)(head); \
  285 + if ((head)->cqh_last == (void *)(head)) \
  286 + (head)->cqh_last = (elm); \
  287 + else \
  288 + (head)->cqh_first->field.cqe_prev = (elm); \
  289 + (head)->cqh_first = (elm); \
  290 +} while (/*CONSTCOND*/0)
  291 +
  292 +#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \
  293 + (elm)->field.cqe_next = (void *)(head); \
  294 + (elm)->field.cqe_prev = (head)->cqh_last; \
  295 + if ((head)->cqh_first == (void *)(head)) \
  296 + (head)->cqh_first = (elm); \
  297 + else \
  298 + (head)->cqh_last->field.cqe_next = (elm); \
  299 + (head)->cqh_last = (elm); \
  300 +} while (/*CONSTCOND*/0)
  301 +
  302 +#define CIRCLEQ_REMOVE(head, elm, field) do { \
  303 + if ((elm)->field.cqe_next == (void *)(head)) \
  304 + (head)->cqh_last = (elm)->field.cqe_prev; \
  305 + else \
  306 + (elm)->field.cqe_next->field.cqe_prev = \
  307 + (elm)->field.cqe_prev; \
  308 + if ((elm)->field.cqe_prev == (void *)(head)) \
  309 + (head)->cqh_first = (elm)->field.cqe_next; \
  310 + else \
  311 + (elm)->field.cqe_prev->field.cqe_next = \
  312 + (elm)->field.cqe_next; \
  313 +} while (/*CONSTCOND*/0)
  314 +
  315 +#define CIRCLEQ_FOREACH(var, head, field) \
  316 + for ((var) = ((head)->cqh_first); \
  317 + (var) != (const void *)(head); \
  318 + (var) = ((var)->field.cqe_next))
  319 +
  320 +#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \
  321 + for ((var) = ((head)->cqh_last); \
  322 + (var) != (const void *)(head); \
  323 + (var) = ((var)->field.cqe_prev))
  324 +
  325 +/*
  326 + * Circular queue access methods.
  327 + */
  328 +#define CIRCLEQ_EMPTY(head) ((head)->cqh_first == (void *)(head))
  329 +#define CIRCLEQ_FIRST(head) ((head)->cqh_first)
  330 +#define CIRCLEQ_LAST(head) ((head)->cqh_last)
  331 +#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next)
  332 +#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev)
  333 +
  334 +#define CIRCLEQ_LOOP_NEXT(head, elm, field) \
  335 + (((elm)->field.cqe_next == (void *)(head)) \
  336 + ? ((head)->cqh_first) \
  337 + : (elm->field.cqe_next))
  338 +#define CIRCLEQ_LOOP_PREV(head, elm, field) \
  339 + (((elm)->field.cqe_prev == (void *)(head)) \
  340 + ? ((head)->cqh_last) \
  341 + : (elm->field.cqe_prev))
  342 +
  343 +#endif /* !_SYS_QUEUE_H_ */
... ...