xref: /titanic_41/usr/src/uts/common/io/bnxe/577xx/include/listq.h (revision f391a51a4e9639750045473dba1cc2831267c93e)
1 /*******************************************************************************
2  * The information contained in this file is confidential and proprietary to
3  * ZNK Corporation.  No part of this file may be reproduced or distributed,
4  * in any form or by any means for any purpose, without the express written
5  * permission of ZNK Corporation.
6  *
7  * (c) COPYRIGHT 1998 ZNK Corporation, ALL RIGHTS RESERVED.
8  *
9  * Single link list routines:
10  *    void              s_list_init        (s_list_t *,  *head, *tail, cnt)
11  *    void              s_list_clear       (s_list_t *)
12  *    void              s_list_push_head   (s_list_t *,  s_list_entry_t *)
13  *    s_list_entry_t *  s_list_pop_head    (s_list_t *)
14  *    void              s_list_push_tail   (s_list_t *,  s_list_entry_t *)
15  *    s_list_entry_t *  s_list_peek_head   (s_list_t *)
16  *    s_list_entry_t *  s_list_peek_tail   (s_list_t *)
17  *    s_list_entry_t *  s_list_next_entry  (s_list_entry_t *)
18  *    unsigned long     s_list_entry_cnt   (s_list_t *)
19  *    char              s_list_is_empty    (s_list_t *)
20  *    void              s_list_add_head    (s_list_t *,  s_list_t *)
21  *    void              s_list_add_tail    (s_list_t *,  s_list_t *)
22  *    void              s_list_split       (d_list_t *,  d_list_t *, d_list_entry_t *, ulong)
23  *
24  * Double link list routines:
25  *    void              d_list_init        (d_list_t *,  *head, *tail, cnt)
26  *    void              d_list_clear       (d_list_t *)
27  *    void              d_list_push_head   (d_list_t *,  d_list_entry_t *)
28  *    d_list_entry_t *  d_list_pop_head    (d_list_t *)
29  *    void              d_list_push_tail   (d_list_t *,  d_list_entry_t *)
30  *    d_list_entry_t *  d_list_pop_tail    (d_list_t *)
31  *    d_list_entry_t *  d_list_peek_head   (d_list_t *)
32  *    d_list_entry_t *  d_list_peek_tail   (d_list_t *)
33  *    d_list_entry_t *  d_list_next_entry  (d_list_entry_t *)
34  *    void              d_list_remove_entry(d_list_t *,  d_list_entry_t *)
35  *    void              d_list_insert_entry(d_list_t *,  *prev, *next, *new)
36  *    d_list_entry_t *  d_list_prev_entry  (d_list_entry_t *)
37  *    unsigned long     d_list_entry_cnt   (d_list_t *)
38  *    char              d_list_is_empty    (d_list_t *)
39  *    void              d_list_add_head    (d_list_t *,  d_list_t *)
40  *    void              d_list_add_tail    (d_list_t *,  d_list_t *)
41  *
42  * Array list routines:
43  *    void              q_list_init        (q_list_t *,  q_list_entry *, ulong)
44  *    void              q_list_clear       (q_list_t *)
45  *    void              q_list_push_head   (q_list_t *,  q_list_entry_t)
46  *    q_list_entry_t    q_list_pop_head    (q_list_t *)
47  *    void              q_list_push_tail   (q_list_t *,  q_list_entry_t)
48  *    q_list_entry_t    q_list_pop_tail    (q_list_t *)
49  *    q_list_entry_t    q_list_peek_head   (q_list_t *)
50  *    q_list_entry_t    q_list_peek_tail   (q_list_t *)
51  *    unsigned long     q_list_entry_cnt   (q_list_t *)
52  *    char              q_list_is_empty    (q_list_t *)
53  *    char              q_list_is_full     (q_list_t *)
54  *
55  * History:
56  *    03/30/98 Hav Khauv                Initial version.
57  ******************************************************************************/
58 
59 #ifndef _listq_h_
60 #define _listq_h_
61 
62 
63 
64 /*******************************************************************************
65  * Single link list.
66  ******************************************************************************/
67 
68 typedef struct _s_list_entry_t
69 {
70     struct _s_list_entry_t *next;
71 } s_list_entry_t;
72 
73 #define S_LINK_CAST(_p)                 ((s_list_entry_t *) (_p))
74 
75 
76 typedef struct _s_list_t
77 {
78     s_list_entry_t *head;
79     s_list_entry_t *tail;
80     unsigned long cnt;
81 } s_list_t;
82 
83 
84 
85 #ifdef _INLINE_LISTQ_CALLS
86 
87 
88 __inline
89 void
s_list_init(s_list_t * s_list,s_list_entry_t * head_entry,s_list_entry_t * tail_entry,unsigned long entry_cnt)90 s_list_init(
91     s_list_t *s_list,
92     s_list_entry_t *head_entry,
93     s_list_entry_t *tail_entry,
94     unsigned long entry_cnt)
95 {
96     s_list->head = head_entry;
97     s_list->tail = tail_entry;
98     s_list->cnt = entry_cnt;
99 }
100 
101 
102 __inline
103 void
s_list_clear(s_list_t * s_list)104 s_list_clear(
105     s_list_t *s_list)
106 {
107     s_list->head = (s_list_entry_t *) 0;
108     s_list->tail = (s_list_entry_t *) 0;
109     s_list->cnt = 0;
110 }
111 
112 
113 __inline
114 void
s_list_push_head(s_list_t * s_list,s_list_entry_t * s_entry)115 s_list_push_head(
116     s_list_t *s_list,
117     s_list_entry_t *s_entry)
118 {
119     s_entry->next = s_list->head;
120 
121     if(s_list->tail == (s_list_entry_t *) 0)
122     {
123         s_list->tail = s_entry;
124     }
125     s_list->head = s_entry;
126 
127     s_list->cnt++;
128 }
129 
130 
131 __inline
132 s_list_entry_t *
s_list_pop_head(s_list_t * s_list)133 s_list_pop_head(
134     s_list_t *s_list)
135 {
136     s_list_entry_t *s_entry;
137 
138     s_entry = s_list->head;
139     if(s_list->head)
140     {
141         s_list->head = s_list->head->next;
142         if(s_list->head == (s_list_entry_t *) 0)
143         {
144             s_list->tail = (s_list_entry_t *) 0;
145         }
146 
147         s_list->cnt--;
148     }
149 
150     return s_entry;
151 }
152 
153 
154 __inline
155 void
s_list_push_tail(s_list_t * s_list,s_list_entry_t * s_entry)156 s_list_push_tail(
157     s_list_t *s_list,
158     s_list_entry_t *s_entry)
159 {
160     s_entry->next = (s_list_entry_t *) 0;
161 
162     if(s_list->tail)
163     {
164         s_list->tail->next = s_entry;
165     }
166     else
167     {
168         s_list->head = s_entry;
169     }
170     s_list->tail = s_entry;
171 
172     s_list->cnt++;
173 }
174 
175 
176 __inline
177 s_list_entry_t *
s_list_peek_head(s_list_t * s_list)178 s_list_peek_head(
179     s_list_t *s_list)
180 {
181     return s_list->head;
182 }
183 
184 
185 __inline
186 s_list_entry_t *
s_list_peek_tail(s_list_t * s_list)187 s_list_peek_tail(
188     s_list_t *s_list)
189 {
190     return s_list->tail;
191 }
192 
193 
194 __inline
195 s_list_entry_t *
s_list_next_entry(s_list_entry_t * s_entry)196 s_list_next_entry(
197     s_list_entry_t *s_entry)
198 {
199     return s_entry->next;
200 }
201 
202 
203 __inline
204 unsigned long
s_list_entry_cnt(s_list_t * s_list)205 s_list_entry_cnt(
206     s_list_t *s_list)
207 {
208     return s_list->cnt;
209 }
210 
211 
212 __inline
213 char
s_list_is_empty(s_list_t * s_list)214 s_list_is_empty(
215     s_list_t *s_list)
216 {
217     return s_list->cnt == 0;
218 }
219 
220 
221 __inline
222 void
s_list_add_head(s_list_t * s_list,s_list_t * s_list_head)223 s_list_add_head(
224     s_list_t *s_list,
225     s_list_t *s_list_head)
226 {
227     if(s_list->cnt == 0)
228     {
229         *s_list = *s_list_head;
230     }
231     else if(s_list_head->cnt)
232     {
233         s_list_head->tail->next = s_list->head;
234         s_list->head = s_list_head->head;
235         s_list->cnt += s_list_head->cnt;
236     }
237 }
238 
239 
240 __inline
241 void
s_list_add_tail(s_list_t * s_list,s_list_t * s_list_tail)242 s_list_add_tail(
243     s_list_t *s_list,
244     s_list_t *s_list_tail)
245 {
246     if(s_list->cnt == 0)
247     {
248         *s_list = *s_list_tail;
249     }
250     else if(s_list_tail->cnt)
251     {
252         s_list->tail->next = s_list_tail->head;
253         s_list->tail = s_list_tail->tail;
254         s_list->cnt += s_list_tail->cnt;
255     }
256 }
257 
258 __inline
259 void
s_list_split(s_list_t * s_list,s_list_t * s_list_head,s_list_entry_t * split_entry,unsigned long entry_cnt)260 s_list_split(
261     s_list_t * s_list,
262     s_list_t * s_list_head,
263     s_list_entry_t * split_entry,
264     unsigned long entry_cnt)
265 {
266     if (split_entry->next == NULL) {
267         s_list_head->head = s_list->head;
268         s_list_head->tail = split_entry;
269         s_list_head->cnt = entry_cnt;
270 
271         s_list->head = NULL;
272         s_list->tail = NULL;
273         s_list->cnt = 0;
274     } else {
275         s_list_head->head = s_list->head;
276         s_list_head->tail = split_entry;
277         s_list_head->cnt = entry_cnt;
278 
279         s_list->head = split_entry->next;
280         s_list->cnt = s_list->cnt - entry_cnt;
281         split_entry->next = NULL;
282 
283     }
284 }
285 
286 #else
287 
288 
289 #define s_list_init(_s_list, _head_entry, _tail_entry, _entry_cnt) \
290     (_s_list)->head = (_head_entry); \
291     (_s_list)->tail = (_tail_entry); \
292     (_s_list)->cnt = (_entry_cnt)
293 
294 
295 #define s_list_clear(_s_list) \
296     (_s_list)->head = (s_list_entry_t *) 0; \
297     (_s_list)->tail = (s_list_entry_t *) 0; \
298     (_s_list)->cnt = 0
299 
300 
301 #define s_list_push_head(_s_list, _s_entry) \
302     (_s_entry)->next = (_s_list)->head; \
303     if((_s_list)->tail == (s_list_entry_t *) 0) \
304     { \
305         (_s_list)->tail = (_s_entry); \
306     } \
307     (_s_list)->head = (_s_entry); \
308     (_s_list)->cnt++
309 
310 
311 #define s_list_pop_head(_s_list) \
312     (_s_list)->head; \
313     if((_s_list)->head) \
314     { \
315         (_s_list)->head = (_s_list)->head->next; \
316         if((_s_list)->head == (s_list_entry_t *) 0) \
317         { \
318             (_s_list)->tail = (s_list_entry_t *) 0; \
319         } \
320         (_s_list)->cnt--; \
321     }
322 
323 
324 #define s_list_push_tail(_s_list, _s_entry) \
325     (_s_entry)->next = (s_list_entry_t *) 0; \
326     if((_s_list)->tail) \
327     { \
328         (_s_list)->tail->next = (_s_entry); \
329     } \
330     else \
331     { \
332         (_s_list)->head = (_s_entry); \
333     } \
334     (_s_list)->tail = (_s_entry); \
335     (_s_list)->cnt++
336 
337 
338 #define s_list_peek_head(_s_list)       ((_s_list)->head)
339 
340 
341 #define s_list_peek_tail(_s_list)       ((_s_list)->tail)
342 
343 
344 #define s_list_next_entry(_s_entry)     ((_s_entry)->next)
345 
346 
347 #define s_list_entry_cnt(_s_list)       ((_s_list)->cnt)
348 
349 
350 #define s_list_is_empty(_s_list)        ((_s_list)->cnt == 0)
351 
352 
353 #define s_list_add_head(_s_list, _s_list_head) \
354     if((_s_list)->cnt == 0) \
355     { \
356         *(_s_list) = *(_s_list_head); \
357     } \
358     else if((_s_list_head)->cnt) \
359     { \
360         (_s_list_head)->tail->next = (_s_list)->head; \
361         (_s_list)->head = (_s_list_head)->head; \
362         (_s_list)->cnt += (_s_list_head)->cnt; \
363     }
364 
365 #define s_list_add_tail(_s_list, _s_list_tail) \
366     if((_s_list)->cnt == 0) \
367     { \
368         *(_s_list) = *(_s_list_tail); \
369     } \
370     else if((_s_list_tail)->cnt) \
371     { \
372         (_s_list)->tail->next = (_s_list_tail)->head; \
373         (_s_list)->tail = (_s_list_tail)->tail; \
374         (_s_list)->cnt += (_s_list_tail)->cnt; \
375     }
376 
377 #define s_list_split(_s_list, _s_list_head, _split_entry, _entry_cnt) \
378     if ((_split_entry)->next == NULL) { \
379         (_s_list_head)->head = (_s_list)->head; \
380         (_s_list_head)->tail = _split_entry; \
381         (_s_list_head)->cnt = _entry_cnt; \
382         (_s_list)->head = NULL; \
383         (_s_list)->tail = NULL; \
384         (_s_list)->cnt = 0; \
385     } else { \
386         (_s_list_head)->head = (_s_list)->head; \
387         (_s_list_head)->tail = _split_entry; \
388         (_s_list_head)->cnt = (_entry_cnt); \
389         (_s_list)->head = (_split_entry)->next; \
390         (_s_list)->cnt = (_s_list)->cnt - (_entry_cnt); \
391         (_split_entry)->next = NULL; \
392     }
393 
394 #endif
395 
396 
397 
398 /*******************************************************************************
399  * Double link list entry.
400  ******************************************************************************/
401 
402 typedef struct _d_list_entry_t
403 {
404     struct _d_list_entry_t *next;
405     struct _d_list_entry_t *prev;
406 } d_list_entry_t;
407 
408 #define D_LINK_CAST(_p)                 ((d_list_entry_t *) (_p))
409 
410 
411 typedef struct _d_list_t
412 {
413     d_list_entry_t *head;
414     d_list_entry_t *tail;
415     unsigned long cnt;
416 } d_list_t;
417 
418 
419 
420 #ifdef _INLINE_LISTQ_CALLS
421 
422 
423 __inline
424 void
d_list_init(d_list_t * d_list,d_list_entry_t * head_entry,d_list_entry_t * tail_entry,unsigned long entry_cnt)425 d_list_init(
426     d_list_t *d_list,
427     d_list_entry_t *head_entry,
428     d_list_entry_t *tail_entry,
429     unsigned long entry_cnt)
430 {
431     d_list->head = head_entry;
432     d_list->tail = tail_entry;
433     d_list->cnt = entry_cnt;
434 }
435 
436 
437 __inline
438 void
d_list_clear(d_list_t * d_list)439 d_list_clear(
440     d_list_t *d_list)
441 {
442     d_list->head = (d_list_entry_t *) 0;
443     d_list->tail = (d_list_entry_t *) 0;
444     d_list->cnt = 0;
445 }
446 
447 
448 __inline
449 void
d_list_push_head(d_list_t * d_list,d_list_entry_t * d_entry)450 d_list_push_head(
451     d_list_t *d_list,
452     d_list_entry_t *d_entry)
453 {
454     d_entry->prev = (d_list_entry_t *) 0;
455     d_entry->next = d_list->head;
456 
457     if(d_list->tail == (d_list_entry_t *) 0)
458     {
459         d_list->tail = d_entry;
460     }
461     else
462     {
463         d_list->head->prev = d_entry;
464     }
465 
466     d_list->head = d_entry;
467 
468     d_list->cnt++;
469 }
470 
471 
472 __inline
473 d_list_entry_t *
d_list_pop_head(d_list_t * d_list)474 d_list_pop_head(
475     d_list_t *d_list)
476 {
477     d_list_entry_t *d_entry;
478 
479     d_entry = d_list->head;
480     if(d_list->head)
481     {
482         d_list->head = d_list->head->next;
483         if(d_list->head)
484         {
485             d_list->head->prev = (d_list_entry_t *) 0;
486         }
487         else
488         {
489             d_list->tail = (d_list_entry_t *) 0;
490         }
491 
492         d_list->cnt--;
493     }
494 
495     return d_entry;
496 }
497 
498 
499 __inline
500 void
d_list_push_tail(d_list_t * d_list,d_list_entry_t * d_entry)501 d_list_push_tail(
502     d_list_t *d_list,
503     d_list_entry_t *d_entry)
504 {
505     d_entry->next = (d_list_entry_t *) 0;
506     d_entry->prev = d_list->tail;
507 
508     if(d_list->tail)
509     {
510         d_list->tail->next = d_entry;
511     }
512     else
513     {
514         d_list->head = d_entry;
515     }
516     d_list->tail = d_entry;
517 
518     d_list->cnt++;
519 }
520 
521 
522 __inline
523 d_list_entry_t *
d_list_pop_tail(d_list_t * d_list)524 d_list_pop_tail(
525     d_list_t *d_list)
526 {
527     d_list_entry_t *d_entry;
528 
529     d_entry = d_list->tail;
530 
531     if(d_list->tail)
532     {
533         d_list->tail = d_list->tail->prev;
534         if(d_list->tail)
535         {
536             d_list->tail->next = (d_list_entry_t *) 0;
537         }
538         else
539         {
540             d_list->head = (d_list_entry_t *) 0;
541         }
542 
543         d_list->cnt--;
544     }
545 
546     return d_entry;
547 }
548 
549 
550 __inline
551 d_list_entry_t *
d_list_peek_head(d_list_t * d_list)552 d_list_peek_head(
553     d_list_t *d_list)
554 {
555     return d_list->head;
556 }
557 
558 
559 __inline
560 d_list_entry_t *
d_list_peek_tail(d_list_t * d_list)561 d_list_peek_tail(
562     d_list_t *d_list)
563 {
564     return d_list->tail;
565 }
566 
567 
568 __inline
569 d_list_entry_t *
d_list_next_entry(d_list_entry_t * d_entry)570 d_list_next_entry(
571     d_list_entry_t *d_entry)
572 {
573     return d_entry->next;
574 }
575 
576 
577 __inline
578 void
d_list_remove_entry(d_list_t * d_list,d_list_entry_t * d_entry)579 d_list_remove_entry(
580     d_list_t *d_list,
581     d_list_entry_t *d_entry)
582 {
583     if(d_list->head == d_entry)
584     {
585         d_list_pop_head(d_list);
586     }
587     else if(d_list->tail == d_entry)
588     {
589         d_list_pop_tail(d_list);
590     }
591     else
592     {
593         d_entry->prev->next = d_entry->next;
594         d_entry->next->prev = d_entry->prev;
595         d_list->cnt--;
596     }
597 }
598 
599 __inline
600 void
d_list_insert_entry(d_list_t * d_list,d_list_entry_t * d_entry_prev,d_list_entry_t * d_entry_next,d_list_entry_t * d_entry)601 d_list_insert_entry(
602     d_list_t *d_list,
603     d_list_entry_t *d_entry_prev,
604     d_list_entry_t *d_entry_next,
605     d_list_entry_t *d_entry)
606 {
607     if (d_entry_prev  == NULL)
608     {
609         d_list_push_head(d_list, d_entry);
610     }
611     else if (d_entry_next == NULL)
612     {
613         d_list_push_tail(d_list, d_entry);
614     }
615     else
616     {
617         d_entry->next = d_entry_next;
618         d_entry->prev = d_entry_prev;
619         d_entry_prev->next = d_entry;
620         d_entry_next->prev = d_entry;
621         d_list->cnt++;
622     }
623 }
624 
625 
626 __inline
627 d_list_entry_t *
d_list_prev_entry(d_list_entry_t * d_entry)628 d_list_prev_entry(
629     d_list_entry_t *d_entry)
630 {
631     return d_entry->prev;
632 }
633 
634 
635 __inline
636 unsigned long
d_list_entry_cnt(d_list_t * d_list)637 d_list_entry_cnt(
638     d_list_t *d_list)
639 {
640     return d_list->cnt;
641 }
642 
643 
644 __inline
645 char
d_list_is_empty(d_list_t * d_list)646 d_list_is_empty(
647     d_list_t *d_list)
648 {
649     return d_list->cnt == 0;
650 }
651 
652 
653 __inline
654 void
d_list_add_head(d_list_t * d_list,d_list_t * d_list_head)655 d_list_add_head(
656     d_list_t *d_list,
657     d_list_t *d_list_head)
658 {
659     d_list_head->tail->next = d_list->head;
660 
661     if(d_list->head)
662     {
663         d_list->head->prev = d_list_head->tail;
664     }
665     else
666     {
667         d_list->tail = d_list_head->tail;
668     }
669     d_list->head = d_list_head->head;
670 
671     d_list->cnt += d_list_head->cnt;
672 }
673 
674 
675 __inline
676 void
d_list_add_tail(d_list_t * d_list,d_list_t * d_list_tail)677 d_list_add_tail(
678     d_list_t *d_list,
679     d_list_t *d_list_tail)
680 {
681     d_list_tail->head->prev = d_list->tail;
682 
683     if(d_list->tail)
684     {
685         d_list->tail->next = d_list_tail->head;
686     }
687     else
688     {
689         d_list->head = d_list_tail->head;
690     }
691     d_list->tail = d_list_tail->tail;
692 
693     d_list->cnt += d_list_tail->cnt;
694 }
695 
696 
697 #else
698 
699 
700 #define d_list_init(_d_list, _head_entry, _tail_entry, _entry_cnt) \
701     (_d_list)->head = (_head_entry); \
702     (_d_list)->tail = (_tail_entry); \
703     (_d_list)->cnt = (_entry_cnt)
704 
705 
706 #define d_list_clear(_d_list) \
707     (_d_list)->head = (d_list_entry_t *) 0; \
708     (_d_list)->tail = (d_list_entry_t *) 0; \
709     (_d_list)->cnt = 0
710 
711 
712 #define d_list_push_head(_d_list, _d_entry) \
713     (_d_entry)->prev = (d_list_entry_t *) 0; \
714     (_d_entry)->next = (_d_list)->head; \
715     if((_d_list)->tail == (d_list_entry_t *) 0) \
716     { \
717         (_d_list)->tail = (_d_entry); \
718     } \
719     else \
720     { \
721         (_d_list)->head->prev = (_d_entry); \
722     } \
723     (_d_list)->head = (_d_entry); \
724     (_d_list)->cnt++
725 
726 
727 #define d_list_pop_head(_d_list) \
728     (_d_list)->head; \
729     if((_d_list)->head) \
730     { \
731         (_d_list)->head = (_d_list)->head->next; \
732         if((_d_list)->head) \
733         { \
734             (_d_list)->head->prev = (d_list_entry_t *) 0; \
735         } \
736         else \
737         { \
738             (_d_list)->tail = (d_list_entry_t *) 0; \
739         } \
740         (_d_list)->cnt--; \
741     }
742 
743 
744 #define d_list_push_tail(_d_list, _d_entry) \
745     (_d_entry)->next = (d_list_entry_t *) 0; \
746     (_d_entry)->prev = (_d_list)->tail; \
747     if((_d_list)->tail) \
748     { \
749         (_d_list)->tail->next = (_d_entry); \
750     } \
751     else \
752     { \
753         (_d_list)->head = (_d_entry); \
754     } \
755     (_d_list)->tail = (_d_entry); \
756     (_d_list)->cnt++
757 
758 
759 #define d_list_pop_tail(_d_list) \
760     (_d_list)->tail; \
761     if((_d_list)->tail) \
762     { \
763         (_d_list)->tail = (_d_list)->tail->prev; \
764         if((_d_list)->tail) \
765         { \
766             (_d_list)->tail->next = (d_list_entry_t *) 0; \
767         } \
768         else \
769         { \
770             (_d_list)->head = (d_list_entry_t *) 0; \
771         } \
772         (_d_list)->cnt--; \
773     }
774 
775 
776 #define d_list_peek_head(_d_list)       ((_d_list)->head)
777 
778 
779 #define d_list_peek_tail(_d_list)       ((_d_list)->tail)
780 
781 
782 #define d_list_next_entry(_d_entry)     ((_d_entry)->next)
783 
784 #define d_list_insert_entry(_d_list, _d_entry_prev, _d_entry_next, _d_entry) \
785     if (_d_entry_prev  == NULL ) \
786     { \
787         (_d_entry)->prev = (d_list_entry_t *) 0; \
788         (_d_entry)->next = (_d_list)->head; \
789         if((_d_list)->tail == (d_list_entry_t *) 0) \
790         { \
791             (_d_list)->tail = (_d_entry); \
792         } \
793         (_d_list)->head = (_d_entry); \
794         (_d_list)->cnt++; \
795     } \
796     else if (_d_entry_next == NULL ) \
797     { \
798         (_d_entry)->next = (d_list_entry_t *) 0; \
799         (_d_entry)->prev = (_d_list)->tail; \
800         if((_d_list)->tail) \
801         { \
802             (_d_list)->tail->next = (_d_entry); \
803         } \
804         else \
805         { \
806             (_d_list)->head = (_d_entry); \
807         } \
808         (_d_list)->tail = (_d_entry); \
809         (_d_list)->cnt++; \
810     } \
811     else \
812     { \
813         (_d_entry)->next = (_d_entry_next); \
814         (_d_entry)->prev = (_d_entry_prev); \
815         (_d_entry_prev)->next = (_d_entry); \
816         (_d_entry_next)->prev = (_d_entry); \
817         (_d_list)->cnt++; \
818     }
819 
820 #define d_list_remove_entry(_d_list, _d_entry) \
821     if((_d_list)->head == (_d_entry)) \
822     { \
823         if((_d_list)->head) \
824         { \
825             (_d_list)->head = (_d_list)->head->next; \
826             if((_d_list)->head) \
827             { \
828                 (_d_list)->head->prev = (d_list_entry_t *) 0; \
829             } \
830             else \
831             { \
832                 (_d_list)->tail = (d_list_entry_t *) 0; \
833             } \
834             (_d_list)->cnt--; \
835         } \
836     } \
837     else if((_d_list)->tail == (_d_entry)) \
838     { \
839         if((_d_list)->tail) \
840         { \
841             (_d_list)->tail = (_d_list)->tail->prev; \
842             if((_d_list)->tail) \
843             { \
844                 (_d_list)->tail->next = (d_list_entry_t *) 0; \
845             } \
846             else \
847             { \
848                 (_d_list)->head = (d_list_entry_t *) 0; \
849             } \
850             (_d_list)->cnt--; \
851         } \
852     } \
853     else \
854     { \
855         (_d_entry)->prev->next = (_d_entry)->next; \
856         (_d_entry)->next->prev = (_d_entry)->prev; \
857         (_d_list)->cnt--; \
858     }
859 
860 
861 #define d_list_prev_entry(_d_entry)     ((_d_entry)->prev)
862 
863 
864 #define d_list_entry_cnt(_d_list)       ((_d_list)->cnt)
865 
866 
867 #define d_list_is_empty(_d_list)        ((_d_list)->cnt == 0)
868 
869 
870 #define d_list_add_head(_d_list, _d_list_head) \
871     (_d_list_head)->tail->next = (_d_list)->head; \
872     if((_d_list)->head) \
873     { \
874         (_d_list)->head->prev = (_d_list_head)->tail; \
875     } \
876     else \
877     { \
878         (_d_list)->tail = (_d_list_head)->tail; \
879     } \
880     (_d_list)->head = (_d_list_head)->head; \
881     (_d_list)->cnt += (_d_list_head)->cnt
882 
883 
884 #define d_list_add_tail(_d_list, _d_list_tail) \
885     (_d_list_tail)->head->prev = (_d_list)->tail; \
886     if((_d_list)->tail) \
887     { \
888         (_d_list)->tail->next = (_d_list_tail)->head; \
889     } \
890     else \
891     { \
892         (_d_list)->head = (_d_list_tail)->head; \
893     } \
894     (_d_list)->tail = (_d_list_tail)->tail; \
895     (_d_list)->cnt += (_d_list_tail)->cnt
896 
897 
898 #endif
899 
900 
901 
902 /*******************************************************************************
903  * Array list.
904  ******************************************************************************/
905 
906 typedef void *q_list_entry_t;
907 
908 typedef struct _q_list_t
909 {
910     q_list_entry_t *head;
911     q_list_entry_t *tail;
912     unsigned long cnt;
913 
914     unsigned long max_cnt;
915     q_list_entry_t *first_entry_addr;
916     q_list_entry_t *last_entry_addr;
917 } q_list_t;
918 
919 
920 
921 #ifdef _INLINE_LISTQ_CALLS
922 
923 
924 __inline
925 void
q_list_init(q_list_t * q_list,q_list_entry_t q_list_arr[],unsigned long max_cnt)926 q_list_init(
927     q_list_t *q_list,
928     q_list_entry_t q_list_arr[],
929     unsigned long max_cnt)
930 {
931     q_list->max_cnt = max_cnt;
932     q_list->first_entry_addr = q_list_arr;
933     q_list->last_entry_addr = q_list_arr + (max_cnt-1);
934 
935     q_list->head = q_list->first_entry_addr;
936     q_list->tail = q_list->first_entry_addr;
937     q_list->cnt = 0;
938 }
939 
940 
941 __inline
942 void
q_list_clear(q_list_t * q_list)943 q_list_clear(
944     q_list_t *q_list)
945 {
946     q_list->head = q_list->first_entry_addr;
947     q_list->tail = q_list->first_entry_addr;
948     q_list->cnt = 0;
949 }
950 
951 
952 __inline
953 void
q_list_push_head(q_list_t * q_list,q_list_entry_t q_entry)954 q_list_push_head(
955     q_list_t *q_list,
956     q_list_entry_t q_entry)
957 {
958     if(q_list->cnt < q_list->max_cnt)
959     {
960         if(q_list->head == q_list->first_entry_addr)
961         {
962             q_list->head = q_list->last_entry_addr;
963         }
964         else
965         {
966             q_list->head--;
967         }
968 
969         *(q_list->head) = q_entry;
970         q_list->cnt++;
971     }
972 }
973 
974 
975 __inline
976 q_list_entry_t
q_list_pop_head(q_list_t * q_list)977 q_list_pop_head(
978     q_list_t *q_list)
979 {
980     q_list_entry_t q_entry;
981 
982     q_entry = q_list->cnt ? *q_list->head : (q_list_entry_t *) 0;
983     if(q_list->cnt)
984     {
985         if(q_list->head == q_list->last_entry_addr)
986         {
987             q_list->head = q_list->first_entry_addr;
988         }
989         else
990         {
991             q_list->head++;
992         }
993 
994         q_list->cnt--;
995     }
996 
997     return q_entry;
998 }
999 
1000 
1001 __inline
1002 void
q_list_push_tail(q_list_t * q_list,q_list_entry_t q_entry)1003 q_list_push_tail(
1004     q_list_t *q_list,
1005     q_list_entry_t q_entry)
1006 {
1007     if(q_list->cnt < q_list->max_cnt)
1008     {
1009         *q_list->tail = q_entry;
1010         if(q_list->tail == q_list->last_entry_addr)
1011         {
1012             q_list->tail = q_list->first_entry_addr;
1013         }
1014         else
1015         {
1016             q_list->tail++;
1017         }
1018 
1019         q_list->cnt++;
1020     }
1021 }
1022 
1023 
1024 __inline
1025 q_list_entry_t
q_list_pop_tail(q_list_t * q_list)1026 q_list_pop_tail(
1027     q_list_t *q_list)
1028 {
1029     q_list_entry_t q_entry;
1030 
1031     q_entry = q_list->cnt ?
1032         (q_list->tail == q_list->first_entry_addr ?
1033             *q_list->last_entry_addr : *(q_list->tail-1)) :
1034         (q_list_entry_t *) 0;
1035 
1036     if(q_list->cnt)
1037     {
1038         if(q_list->tail == q_list->first_entry_addr)
1039         {
1040             q_list->tail = q_list->last_entry_addr;
1041         }
1042         else
1043         {
1044             q_list->tail--;
1045         }
1046 
1047         q_list->cnt--;
1048     }
1049 
1050     return q_entry;
1051 }
1052 
1053 
1054 __inline
1055 q_list_entry_t
q_list_peek_head(q_list_t * q_list)1056 q_list_peek_head(
1057     q_list_t *q_list)
1058 {
1059     q_list_entry_t q_entry;
1060 
1061     q_entry = q_list->cnt ? *q_list->head : (q_list_entry_t *) 0;
1062 
1063     return q_entry;
1064 }
1065 
1066 
1067 __inline
1068 q_list_entry_t
q_list_peek_tail(q_list_t * q_list)1069 q_list_peek_tail(
1070     q_list_t *q_list)
1071 {
1072     q_list_entry_t q_entry;
1073 
1074     q_entry = q_list->cnt ?
1075         (q_list->tail == q_list->first_entry_addr ?
1076             *q_list->last_entry_addr : *(q_list->tail - 1)) :
1077         (q_list_entry_t *) 0;
1078 
1079     return q_entry;
1080 }
1081 
1082 
1083 __inline
1084 unsigned long
q_list_entry_cnt(q_list_t * q_list)1085 q_list_entry_cnt(
1086     q_list_t *q_list)
1087 {
1088     return q_list->cnt;
1089 }
1090 
1091 
1092 __inline
1093 char
q_list_is_empty(q_list_t * q_list)1094 q_list_is_empty(
1095     q_list_t *q_list)
1096 {
1097     return q_list->cnt == 0;
1098 }
1099 
1100 
1101 __inline
1102 char
q_list_is_full(q_list_t * q_list)1103 q_list_is_full(
1104     q_list_t *q_list)
1105 {
1106     return q_list->cnt == q_list->max_cnt;
1107 }
1108 
1109 
1110 #else
1111 
1112 
1113 #define q_list_init(_q_list, _q_list_arr, _max_cnt) \
1114     (_q_list)->max_cnt = (_max_cnt); \
1115     (_q_list)->first_entry_addr = (_q_list_arr); \
1116     (_q_list)->last_entry_addr = (_q_list_arr) + ((_max_cnt) - 1); \
1117     (_q_list)->head = (_q_list)->first_entry_addr; \
1118     (_q_list)->tail = (_q_list)->first_entry_addr; \
1119     (_q_list)->cnt = 0
1120 
1121 
1122 #define q_list_clear(_q_list) \
1123     (_q_list)->head = (_q_list)->first_entry_addr; \
1124     (_q_list)->tail = (_q_list)->first_entry_addr; \
1125     (_q_list)->cnt = 0
1126 
1127 
1128 #define q_list_push_head(_q_list, _q_entry) \
1129     if((_q_list)->cnt < (_q_list)->max_cnt) \
1130     { \
1131         if((_q_list)->head == (_q_list)->first_entry_addr) \
1132         { \
1133             (_q_list)->head = (_q_list)->last_entry_addr; \
1134         } \
1135         else \
1136         { \
1137             (_q_list)->head--; \
1138         } \
1139         *((_q_list)->head) = (_q_entry); \
1140         (_q_list)->cnt++; \
1141     }
1142 
1143 
1144 #define q_list_pop_head(_q_list) \
1145     (_q_list)->cnt ? *(_q_list)->head : (q_list_entry_t *) 0; \
1146     if((_q_list)->cnt) \
1147     { \
1148         if((_q_list)->head == (_q_list)->last_entry_addr) \
1149         { \
1150             (_q_list)->head = (_q_list)->first_entry_addr; \
1151         } \
1152         else \
1153         { \
1154             (_q_list)->head++; \
1155         } \
1156         (_q_list)->cnt--; \
1157     }
1158 
1159 
1160 #define q_list_push_tail(_q_list, _q_entry) \
1161     if((_q_list)->cnt < (_q_list)->max_cnt) \
1162     { \
1163         *(_q_list)->tail = (_q_entry); \
1164         if((_q_list)->tail == (_q_list)->last_entry_addr) \
1165         { \
1166             (_q_list)->tail = (_q_list)->first_entry_addr; \
1167         } \
1168         else \
1169         { \
1170             (_q_list)->tail++; \
1171         } \
1172         (_q_list)->cnt++; \
1173     }
1174 
1175 
1176 #define q_list_pop_tail(_q_list) \
1177     (_q_list)->cnt ? ((_q_list)->tail == (_q_list)->first_entry_addr ? \
1178         *(_q_list)->last_entry_addr : *((_q_list)->tail-1)) : \
1179         (q_list_entry_t *) 0; \
1180     if((_q_list)->cnt) \
1181     { \
1182         if((_q_list)->tail == (_q_list)->first_entry_addr) \
1183         { \
1184             (_q_list)->tail = (_q_list)->last_entry_addr; \
1185         } \
1186         else \
1187         { \
1188             (_q_list)->tail--; \
1189         } \
1190         (_q_list)->cnt--; \
1191     } \
1192 
1193 
1194 #define q_list_peek_head(_q_list) \
1195     ((_q_list)->cnt ? *(_q_list)->head : (q_list_entry_t *) 0)
1196 
1197 
1198 #define q_list_peek_tail(_q_list) \
1199     ((_q_list)->cnt ? ((_q_list)->tail == (_q_list)->first_entry_addr ? \
1200         *(_q_list)->last_entry_addr : *((_q_list)->tail - 1)) : \
1201         (q_list_entry_t *) 0)
1202 
1203 
1204 #define q_list_entry_cnt(_q_list)   ((_q_list)->cnt)
1205 
1206 
1207 #define q_list_is_empty(_q_list)    ((_q_list)->cnt == 0)
1208 
1209 
1210 #define q_list_is_full(_q_list)     ((_q_list)->cnt == (_q_list)->max_cnt)
1211 
1212 
1213 #endif
1214 
1215 
1216 
1217 
1218 #endif /* _listq_h_ */
1219 
1220