Update sys-queue.h (Gerd Hoffmann) (23cde8bb) | Commits | gwj / at91sam9263

Commit 23cde8bb1265bc9dba63dac64055bd9857d7285f

Authored by aliguori 2008-07-29 20:00:31 +0000

Update sys-queue.h (Gerd Hoffmann)

 - got recent copy from netbsd.
 - deleted debug code.
 - deleted some list implementations, left in only the ones which
   qemu already has.

Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>



git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@4973 c046a42c-6fe2-441c-8c8c-71466251a162

Inline Side-by-side

Showing 1 changed file with 338 additions and 241 deletions

audio/sys-queue.h

View file @23cde8b

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

gwj / at91sam9263 · Commits

GitLab

Update sys-queue.h (Gerd Hoffmann)