lib/queue.h

   1 /*
   2  * lists and queues implementations
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License as published by the Free
   6  * Software Foundation; either version 2 of the License, or (at your option)
   7  * any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; see the file COPYING; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 #ifndef _FRR_QUEUE_H
  20 #define _FRR_QUEUE_H
  21
  22 #if defined(__OpenBSD__) && !defined(STAILQ_HEAD)
  23 #include "openbsd-queue.h"
  24
  25 /* Try to map FreeBSD implementation to OpenBSD one. */
  26 #define STAILQ_HEAD(name, type)                         SIMPLEQ_HEAD(name, type)
  27 #define STAILQ_HEAD_INITIALIZER(head)                   SIMPLEQ_HEAD_INITIALIZER(head)
  28 #define STAILQ_ENTRY(entry)                             SIMPLEQ_ENTRY(entry)
  29
  30 #define STAILQ_CONCAT(head1, head2)                     SIMPLEQ_CONCAT(head1, head2)
  31 #define STAILQ_EMPTY(head)                              SIMPLEQ_EMPTY(head)
  32 #define STAILQ_FIRST(head)                              SIMPLEQ_FIRST(head)
  33 #define STAILQ_FOREACH(var, head, field)                SIMPLEQ_FOREACH(var, head, field)
  34 #define STAILQ_FOREACH_SAFE(var, head, field, tvar)     SIMPLEQ_FOREACH_SAFE(var, head, field, tvar)
  35 #define STAILQ_INIT(head)                               SIMPLEQ_INIT(head)
  36 #define STAILQ_INSERT_AFTER(head, tqelm, elm, field)    SIMPLEQ_INSERT_AFTER(head, tqelm, elm, field)
  37 #define STAILQ_INSERT_HEAD(head, elm, field)            SIMPLEQ_INSERT_HEAD(head, elm, field)
  38 #define STAILQ_INSERT_TAIL(head, elm, field)            SIMPLEQ_INSERT_TAIL(head, elm, field)
  39 #define STAILQ_LAST(head, type, field)                                         \
  40         (SIMPLEQ_EMPTY((head))                                                 \
  41                  ? NULL                                                        \
  42                  : ((struct type *)(void *)((char *)((head)->sqh_last)         \
  43                                             - offsetof(struct type, field))))
  44 #define STAILQ_NEXT(elm, field)                         SIMPLEQ_NEXT(elm, field)
  45 #define STAILQ_REMOVE(head, elm, type, field)                                  \
  46         do {                                                                   \
  47                 if (SIMPLEQ_FIRST((head)) == (elm)) {                          \
  48                         SIMPLEQ_REMOVE_HEAD((head), field);                    \
  49                 } else {                                                       \
  50                         struct type *curelm = SIMPLEQ_FIRST((head));           \
  51                         while (SIMPLEQ_NEXT(curelm, field) != (elm))           \
  52                                 curelm = SIMPLEQ_NEXT(curelm, field);          \
  53                         SIMPLEQ_REMOVE_AFTER(head, curelm, field);             \
  54                 }                                                              \
  55         } while (0)
  56 #define STAILQ_REMOVE_AFTER(head, elm, field)           SIMPLEQ_REMOVE_AFTER(head, elm, field)
  57 #define STAILQ_REMOVE_HEAD(head, field)                 SIMPLEQ_REMOVE_HEAD(head, field)
  58 #define STAILQ_SWAP(head1, head2, type)                                        \
  59         do {                                                                   \
  60                 struct type *swap_first = STAILQ_FIRST(head1);                 \
  61                 struct type **swap_last = (head1)->sqh_last;                   \
  62                 STAILQ_FIRST(head1) = STAILQ_FIRST(head2);                     \
  63                 (head1)->sqh_last = (head2)->sqh_last;                         \
  64                 STAILQ_FIRST(head2) = swap_first;                              \
  65                 (head2)->sqh_last = swap_last;                                 \
  66                 if (STAILQ_EMPTY(head1))                                       \
  67                         (head1)->sqh_last = &STAILQ_FIRST(head1);              \
  68                 if (STAILQ_EMPTY(head2))                                       \
  69                         (head2)->sqh_last = &STAILQ_FIRST(head2);              \
  70         } while (0)
  71 #else
  72 #include "freebsd-queue.h"
  73 #endif /* defined(__OpenBSD__) && !defined(STAILQ_HEAD) */
  74
  75 #ifndef TAILQ_POP_FIRST
  76 #define TAILQ_POP_FIRST(head, field)                                           \
  77         ({  typeof((head)->tqh_first) _elm = TAILQ_FIRST(head);                \
  78             if (_elm) {                                                        \
  79                 if ((TAILQ_NEXT((_elm), field)) != NULL)                       \
  80                         TAILQ_NEXT((_elm), field)->field.tqe_prev =            \
  81                                 &TAILQ_FIRST(head);                            \
  82                 else                                                           \
  83                         (head)->tqh_last = &TAILQ_FIRST(head);                 \
  84                 TAILQ_FIRST(head) = TAILQ_NEXT((_elm), field);                 \
  85         }; _elm; })
  86 #endif
  87
  88 #endif /* _FRR_QUEUE_H */