kc3-lang/libbsd/include/bsd/queue.h

• Show log

  Commit

• Hash : 657f1b59
  Author :
  Date : 2005-10-31T22:57:10
  

  Reorganize header files

Download

• include/bsd/queue.h

• #ifndef LIBBSD_QUEUE_H
  #define LIBBSD_QUEUE_H
  
  #include <sys/queue.h>
  
  /*
   * Singly-linked Tail queue declarations.
   */
  #define	STAILQ_HEAD(name, type)						\
  struct name {								\
  	struct type *stqh_first;/* first element */			\
  	struct type **stqh_last;/* addr of last next element */		\
  }
  
  #define	STAILQ_HEAD_INITIALIZER(head)					\
  	{ NULL, &(head).stqh_first }
  
  #define	STAILQ_ENTRY(type)						\
  struct {								\
  	struct type *stqe_next;	/* next element */			\
  }
  
  /*
   * Singly-linked Tail queue functions.
   */
  #define	STAILQ_CONCAT(head1, head2) do {				\
  	if (!STAILQ_EMPTY((head2))) {					\
  		*(head1)->stqh_last = (head2)->stqh_first;		\
  		(head1)->stqh_last = (head2)->stqh_last;		\
  		STAILQ_INIT((head2));					\
  	}								\
  } while (0)
  
  #define	STAILQ_EMPTY(head)	((head)->stqh_first == NULL)
  
  #define	STAILQ_FIRST(head)	((head)->stqh_first)
  
  #define	STAILQ_FOREACH(var, head, field)				\
  	for((var) = STAILQ_FIRST((head));				\
  	   (var);							\
  	   (var) = STAILQ_NEXT((var), field))
  
  #define	STAILQ_INIT(head) do {						\
  	STAILQ_FIRST((head)) = NULL;					\
  	(head)->stqh_last = &STAILQ_FIRST((head));			\
  } while (0)
  
  #define	STAILQ_INSERT_AFTER(head, tqelm, elm, field) do {		\
  	if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
  		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
  	STAILQ_NEXT((tqelm), field) = (elm);				\
  } while (0)
  
  #define	STAILQ_INSERT_HEAD(head, elm, field) do {			\
  	if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL)	\
  		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
  	STAILQ_FIRST((head)) = (elm);					\
  } while (0)
  
  #define	STAILQ_INSERT_TAIL(head, elm, field) do {			\
  	STAILQ_NEXT((elm), field) = NULL;				\
  	*(head)->stqh_last = (elm);					\
  	(head)->stqh_last = &STAILQ_NEXT((elm), field);			\
  } while (0)
  
  #define	STAILQ_LAST(head, type, field)					\
  	(STAILQ_EMPTY((head)) ?						\
  		NULL :							\
  	        ((struct type *)					\
  		((char *)((head)->stqh_last) - __offsetof(struct type, field))))
  
  #define	STAILQ_NEXT(elm, field)	((elm)->field.stqe_next)
  
  #define	STAILQ_REMOVE(head, elm, type, field) do {			\
  	if (STAILQ_FIRST((head)) == (elm)) {				\
  		STAILQ_REMOVE_HEAD((head), field);			\
  	}								\
  	else {								\
  		struct type *curelm = STAILQ_FIRST((head));		\
  		while (STAILQ_NEXT(curelm, field) != (elm))		\
  			curelm = STAILQ_NEXT(curelm, field);		\
  		if ((STAILQ_NEXT(curelm, field) =			\
  		     STAILQ_NEXT(STAILQ_NEXT(curelm, field), field)) == NULL)\
  			(head)->stqh_last = &STAILQ_NEXT((curelm), field);\
  	}								\
  } while (0)
  
  #define	STAILQ_REMOVE_HEAD(head, field) do {				\
  	if ((STAILQ_FIRST((head)) =					\
  	     STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL)		\
  		(head)->stqh_last = &STAILQ_FIRST((head));		\
  } while (0)
  
  #define	STAILQ_REMOVE_HEAD_UNTIL(head, elm, field) do {			\
  	if ((STAILQ_FIRST((head)) = STAILQ_NEXT((elm), field)) == NULL)	\
  		(head)->stqh_last = &STAILQ_FIRST((head));		\
  } while (0)
  
  /*
   * List declarations.
   */
  #define	LIST_HEAD(name, type)						\
  struct name {								\
  	struct type *lh_first;	/* first element */			\
  }
  
  #define	LIST_HEAD_INITIALIZER(head)					\
  	{ NULL }
  
  #define	LIST_ENTRY(type)						\
  struct {								\
  	struct type *le_next;	/* next element */			\
  	struct type **le_prev;	/* address of previous next element */	\
  }
  
  /*
   * List functions.
   */
  
  #define	LIST_EMPTY(head)	((head)->lh_first == NULL)
  
  #define	LIST_FIRST(head)	((head)->lh_first)
  
  #define	LIST_FOREACH(var, head, field)					\
  	for ((var) = LIST_FIRST((head));				\
  	    (var);							\
  	    (var) = LIST_NEXT((var), field))
  
  #define	LIST_INSERT_BEFORE(listelm, elm, field) do {			\
  	(elm)->field.le_prev = (listelm)->field.le_prev;		\
  	LIST_NEXT((elm), field) = (listelm);				\
  	*(listelm)->field.le_prev = (elm);				\
  	(listelm)->field.le_prev = &LIST_NEXT((elm), field);		\
  } while (0)
  
  #define	LIST_NEXT(elm, field)	((elm)->field.le_next)
  
  #define	TAILQ_FIRST(head)	((head)->tqh_first)
  
  #define	TAILQ_FOREACH(var, head, field)					\
  	for ((var) = TAILQ_FIRST((head));				\
  	    (var);							\
  	    (var) = TAILQ_NEXT((var), field))
  
  #define	TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
  
  #define	TAILQ_HEAD_INITIALIZER(head)					\
  	{ NULL, &(head).tqh_first }
  
  #endif
  
  

Download