Author: aurel32
Date: 2008-08-11 02:31:42 +0000 (Mon, 11 Aug 2008)
New Revision: 3082
Modified:
glibc-package/branches/glibc-2.8/debian/changelog
glibc-package/branches/glibc-2.8/debian/patches/kfreebsd/local-sys_queue_h.diff
glibc-package/branches/glibc-2.8/debian/patches/series.kfreebsd-amd64
glibc-package/branches/glibc-2.8/debian/patches/series.kfreebsd-i386
Log:
- Update kfreebsd/local-sys_queue_h.diff
Modified: glibc-package/branches/glibc-2.8/debian/changelog
===================================================================
--- glibc-package/branches/glibc-2.8/debian/changelog 2008-08-10 22:14:07 UTC
(rev 3081)
+++ glibc-package/branches/glibc-2.8/debian/changelog 2008-08-11 02:31:42 UTC
(rev 3082)
@@ -9,6 +9,7 @@
+ rules.d/quilt.mk: fix the unpatch target
- Update any/cvs-getaddrinfo.diff.
- Update any/submitted-i686-timing.diff.
+ - Update kfreebsd/local-sys_queue_h.diff
- Update locale/preprocessor-collate-uli-sucks.diff
- Update localedata/tailor-iso14651_t1.diff.
- Update localedata/locales-fr.diff.
@@ -82,6 +83,7 @@
* testsuite-checking/expected-results-ia64-linux-gnu-libc: new file.
* testsuite-checking/expected-results-powerpc-linux-gnu-libc: new file.
* testsuite-checking/expected-results-s390-linux-gnu-libc: new file.
+
* testsuite-checking/expected-results-s390x-linux-s390x: new file.
* testsuite-checking/expected-results-sparc64-linux-sparc64: new file.
* testsuite-checking/expected-results-sparc-linux-gnu-libc: new file.
Modified:
glibc-package/branches/glibc-2.8/debian/patches/kfreebsd/local-sys_queue_h.diff
===================================================================
---
glibc-package/branches/glibc-2.8/debian/patches/kfreebsd/local-sys_queue_h.diff
2008-08-10 22:14:07 UTC (rev 3081)
+++
glibc-package/branches/glibc-2.8/debian/patches/kfreebsd/local-sys_queue_h.diff
2008-08-11 02:31:42 UTC (rev 3082)
@@ -1,227 +1,30 @@
---- misc/sys/queue.h.orig 2006-05-10 16:53:51.000000000 +0200
-+++ misc/sys/queue.h 2006-10-13 13:05:17.000000000 +0200
-@@ -27,24 +27,38 @@
- * SUCH DAMAGE.
- *
- * @(#)queue.h 8.5 (Berkeley) 8/20/94
-+ * $FreeBSD: src/sys/sys/queue.h,v 1.58 2004/04/07 04:19:49 imp Exp $
- */
-
--#ifndef _SYS_QUEUE_H_
-+#ifndef _SYS_QUEUE_H_
+--- a/misc/sys/queue.h
++++ b/misc/sys/queue.h
+@@ -32,6 +32,8 @@
+ #ifndef _SYS_QUEUE_H_
#define _SYS_QUEUE_H_
+#include <sys/cdefs.h>
+
/*
-- * This file defines five types of data structures: singly-linked lists,
-- * lists, simple queues, tail queues, and circular queues.
-+ * This file defines four types of data structures: singly-linked lists,
-+ * singly-linked tail queues, lists and tail queues.
-+ *
-+ * A singly-linked list is headed by a single forward pointer. The elements
-+ * are singly linked for minimum space and pointer manipulation overhead at
-+ * the expense of O(n) removal for arbitrary elements. New elements can be
-+ * added to the list after an existing element or at the head of the list.
-+ * Elements being removed from the head of the list should use the explicit
-+ * macro for this purpose for optimum efficiency. A singly-linked list may
-+ * only be traversed in the forward direction. Singly-linked lists are ideal
-+ * for applications with large datasets and few or no removals or for
-+ * implementing a LIFO queue.
- *
-- * A singly-linked list is headed by a single forward pointer. The
-- * elements are singly linked for minimum space and pointer manipulation
-- * overhead at the expense of O(n) removal for arbitrary elements. New
-- * elements can be added to the list after an existing element or at the
-- * head of the list. Elements being removed from the head of the list
-- * should use the explicit macro for this purpose for optimum
-- * efficiency. A singly-linked list may only be traversed in the forward
-- * direction. Singly-linked lists are ideal for applications with large
-- * datasets and few or no removals or for implementing a LIFO queue.
-+ * A singly-linked tail queue is headed by a pair of pointers, one to the
-+ * head of the list and the other to the tail of the list. The elements are
-+ * singly linked for minimum space and pointer manipulation overhead at the
-+ * expense of O(n) removal for arbitrary elements. New elements can be added
-+ * to the list after an existing element, at the head of the list, or at the
-+ * end of the list. Elements being removed from the head of the tail queue
-+ * should use the explicit macro for this purpose for optimum efficiency.
-+ * A singly-linked tail queue may only be traversed in the forward direction.
-+ * Singly-linked tail queues are ideal for applications with large datasets
-+ * and few or no removals or for implementing a FIFO queue.
- *
- * A list is headed by a single forward pointer (or an array of forward
- * pointers for a hash table header). The elements are doubly linked
-@@ -53,13 +67,6 @@
- * or after an existing element or at the head of the list. A list
- * may only be traversed in the forward direction.
- *
-- * A simple queue is headed by a pair of pointers, one the head of the
-- * list and the other to the tail of the list. The elements are singly
-- * linked to save space, so elements can only be removed from the
-- * head of the list. New elements can be added to the list after
-- * an existing element, at the head of the list, or at the end of the
-- * list. A simple queue may only be traversed in the forward direction.
-- *
- * A tail queue is headed by a pair of pointers, one to the head of the
- * list and the other to the tail of the list. The elements are doubly
- * linked so that an arbitrary element can be removed without a need to
-@@ -67,85 +74,68 @@
- * after an existing element, at the head of the list, or at the end of
- * the list. A tail queue may be traversed in either direction.
- *
-- * A circle queue is headed by a pair of pointers, one to the head of the
-- * list and the other to the tail of the list. The elements are doubly
-- * linked so that an arbitrary element can be removed without a need to
-- * traverse the list. New elements can be added to the list before or after
-- * an existing element, at the head of the list, or at the end of the list.
-- * A circle queue may be traversed in either direction, but has a more
-- * complex end of list detection.
-- *
- * For details on the use of these macros, see the queue(3) manual page.
-+ *
-+ *
-+ * SLIST LIST STAILQ TAILQ
-+ * _HEAD + + + +
-+ * _HEAD_INITIALIZER + + + +
-+ * _ENTRY + + + +
-+ * _INIT + + + +
-+ * _EMPTY + + + +
-+ * _FIRST + + + +
-+ * _NEXT + + + +
-+ * _PREV - - - +
-+ * _LAST - - + +
-+ * _FOREACH + + + +
-+ * _FOREACH_SAFE + + + +
-+ * _FOREACH_REVERSE - - - +
-+ * _FOREACH_REVERSE_SAFE - - - +
-+ * _INSERT_HEAD + + + +
-+ * _INSERT_BEFORE - + - +
-+ * _INSERT_AFTER + + + +
-+ * _INSERT_TAIL - - + +
-+ * _CONCAT - - + +
-+ * _REMOVE_HEAD + - + -
-+ * _REMOVE + + + +
-+ *
- */
-+#define QUEUE_MACRO_DEBUG 0
-+#if QUEUE_MACRO_DEBUG
-+/* Store the last 2 places the queue element or head was altered */
-+struct qm_trace {
-+ char * lastfile;
-+ int lastline;
-+ char * prevfile;
-+ int prevline;
-+};
-+
-+#define TRACEBUF struct qm_trace trace;
-+#define TRASHIT(x) do {(x) = (void *)-1;} while (0)
-+
-+#define QMD_TRACE_HEAD(head) do {
\
-+ (head)->trace.prevline = (head)->trace.lastline; \
-+ (head)->trace.prevfile = (head)->trace.lastfile; \
-+ (head)->trace.lastline = __LINE__; \
-+ (head)->trace.lastfile = __FILE__; \
-+} while (0)
-+
-+#define QMD_TRACE_ELEM(elem) do {
\
-+ (elem)->trace.prevline = (elem)->trace.lastline; \
-+ (elem)->trace.prevfile = (elem)->trace.lastfile; \
-+ (elem)->trace.lastline = __LINE__; \
-+ (elem)->trace.lastfile = __FILE__; \
-+} while (0)
-+
-+#else
-+#define QMD_TRACE_ELEM(elem)
-+#define QMD_TRACE_HEAD(head)
-+#define TRACEBUF
-+#define TRASHIT(x)
-+#endif /* QUEUE_MACRO_DEBUG */
+ * This file defines five types of data structures: singly-linked lists,
+ * lists, simple queues, tail queues, and circular queues.
+@@ -136,6 +138,11 @@
+ (var); \
+ (var) = ((var)->field.le_next))
++#define LIST_FOREACH_SAFE(var, head, field, tvar)
\
++ for (((var) = ((head)->lh_first); \
++ (var) && ((tvar) = ((var)->field.le_next), 1); \
++ (var) = (tvar))
++
/*
-- * List definitions.
-- */
--#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_INIT(head) do {
\
-- (head)->lh_first = NULL; \
--} while (/*CONSTCOND*/0)
--
--#define LIST_INSERT_AFTER(listelm, elm, field) do {
\
-- if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \
-- (listelm)->field.le_next->field.le_prev = \
-- &(elm)->field.le_next; \
-- (listelm)->field.le_next = (elm); \
-- (elm)->field.le_prev = &(listelm)->field.le_next; \
--} while (/*CONSTCOND*/0)
--
--#define LIST_INSERT_BEFORE(listelm, elm, field) do {
\
-- (elm)->field.le_prev = (listelm)->field.le_prev; \
-- (elm)->field.le_next = (listelm); \
-- *(listelm)->field.le_prev = (elm); \
-- (listelm)->field.le_prev = &(elm)->field.le_next; \
--} while (/*CONSTCOND*/0)
--
--#define LIST_INSERT_HEAD(head, elm, field) do {
\
-- if (((elm)->field.le_next = (head)->lh_first) != NULL) \
-- (head)->lh_first->field.le_prev = &(elm)->field.le_next;\
-- (head)->lh_first = (elm); \
-- (elm)->field.le_prev = &(head)->lh_first; \
--} while (/*CONSTCOND*/0)
--
--#define LIST_REMOVE(elm, field) do {
\
-- if ((elm)->field.le_next != NULL) \
-- (elm)->field.le_next->field.le_prev = \
-- (elm)->field.le_prev; \
-- *(elm)->field.le_prev = (elm)->field.le_next; \
--} while (/*CONSTCOND*/0)
--
--#define LIST_FOREACH(var, head, field)
\
-- for ((var) = ((head)->lh_first); \
-- (var); \
-- (var) = ((var)->field.le_next))
--
--/*
-- * List access methods.
-- */
--#define LIST_EMPTY(head) ((head)->lh_first == NULL)
--#define LIST_FIRST(head) ((head)->lh_first)
--#define LIST_NEXT(elm, field) ((elm)->field.le_next)
--
--
--/*
-- * Singly-linked List definitions.
-+ * Singly-linked List declarations.
+ * List access methods.
*/
- #define SLIST_HEAD(name, type)
\
- struct name { \
-@@ -163,55 +153,65 @@
- /*
- * Singly-linked List functions.
- */
-+#define SLIST_EMPTY(head) ((head)->slh_first == NULL)
-+
-+#define SLIST_FIRST(head) ((head)->slh_first)
-+
-+#define SLIST_FOREACH(var, head, field)
\
-+ for ((var) = SLIST_FIRST((head)); \
-+ (var); \
-+ (var) = SLIST_NEXT((var), field))
-+
+@@ -197,6 +204,16 @@
+ #define SLIST_FOREACH(var, head, field)
\
+ for((var) = (head)->slh_first; (var); (var) = (var)->field.sle_next)
+
+#define SLIST_FOREACH_SAFE(var, head, field, tvar)
\
+ for ((var) = SLIST_FIRST((head)); \
+ (var) && ((tvar) = SLIST_NEXT((var), field), 1); \
@@ -232,665 +35,52 @@
+ ((var) = *(varp)) != NULL; \
+ (varp) = &SLIST_NEXT((var), field))
+
- #define SLIST_INIT(head) do {
\
-- (head)->slh_first = NULL; \
--} while (/*CONSTCOND*/0)
-+ SLIST_FIRST((head)) = NULL; \
-+} while (0)
-
- #define SLIST_INSERT_AFTER(slistelm, elm, field) do {
\
-- (elm)->field.sle_next = (slistelm)->field.sle_next; \
-- (slistelm)->field.sle_next = (elm); \
--} while (/*CONSTCOND*/0)
-+ SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \
-+ SLIST_NEXT((slistelm), field) = (elm); \
-+} while (0)
-
- #define SLIST_INSERT_HEAD(head, elm, field) do {
\
-- (elm)->field.sle_next = (head)->slh_first; \
-- (head)->slh_first = (elm); \
--} while (/*CONSTCOND*/0)
-+ SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \
-+ SLIST_FIRST((head)) = (elm); \
-+} while (0)
-
--#define SLIST_REMOVE_HEAD(head, field) do {
\
-- (head)->slh_first = (head)->slh_first->field.sle_next; \
--} while (/*CONSTCOND*/0)
-+#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)
-
- #define SLIST_REMOVE(head, elm, type, field) do {
\
-- if ((head)->slh_first == (elm)) { \
-+ if (SLIST_FIRST((head)) == (elm)) { \
- SLIST_REMOVE_HEAD((head), field); \
- } \
- else { \
-- struct type *curelm = (head)->slh_first; \
-- while(curelm->field.sle_next != (elm)) \
-- curelm = curelm->field.sle_next; \
-- curelm->field.sle_next = \
-- curelm->field.sle_next->field.sle_next; \
-+ struct type *curelm = SLIST_FIRST((head)); \
-+ while (SLIST_NEXT(curelm, field) != (elm)) \
-+ curelm = SLIST_NEXT(curelm, field); \
-+ SLIST_NEXT(curelm, field) = \
-+ SLIST_NEXT(SLIST_NEXT(curelm, field), field); \
- } \
--} while (/*CONSTCOND*/0)
--
--#define SLIST_FOREACH(var, head, field)
\
-- for((var) = (head)->slh_first; (var); (var) = (var)->field.sle_next)
--
--/*
-- * Singly-linked List access methods.
-- */
--#define SLIST_EMPTY(head) ((head)->slh_first == NULL)
--#define SLIST_FIRST(head) ((head)->slh_first)
--#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)
-+} while (0)
-
-+#define SLIST_REMOVE_HEAD(head, field) do {
\
-+ SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \
-+} while (0)
-
/*
- * Singly-linked Tail queue declarations.
+ * Singly-linked List access methods.
*/
--#define STAILQ_HEAD(name, type) \
-+#define STAILQ_HEAD(name, type)
\
- struct name { \
-- struct type *stqh_first; /* first element */
\
-- struct type **stqh_last; /* addr of last next element */
\
-+ struct type *stqh_first;/* first element */ \
-+ struct type **stqh_last;/* addr of last next element */ \
- }
+@@ -253,6 +270,11 @@
+ (head)->stqh_last = &(head)->stqh_first;
\
+ } while (/*CONSTCOND*/0)
- #define STAILQ_HEAD_INITIALIZER(head)
\
-@@ -225,333 +225,329 @@
- /*
- * 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_REMOVE_HEAD_UNTIL(head, elm, field) do {
\
++ if (((head)->stqh_first = ((elm)->field.stqe_next)) == NULL) \
++ (head)->stqh_last = &((head)->stqh_first); \
++} while (/*CONSTCOND*/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_FOREACH_SAFE(var, head, field, tvar)
\
-+ for ((var) = STAILQ_FIRST((head)); \
-+ (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \
-+ (var) = (tvar))
-+
- #define STAILQ_INIT(head) do {
\
-- (head)->stqh_first = NULL; \
-- (head)->stqh_last = &(head)->stqh_first;
\
--} while (/*CONSTCOND*/0)
-+ 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 (((elm)->field.stqe_next = (head)->stqh_first) == NULL) \
-- (head)->stqh_last = &(elm)->field.stqe_next; \
-- (head)->stqh_first = (elm); \
--} while (/*CONSTCOND*/0)
-+ 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 {
\
-- (elm)->field.stqe_next = NULL; \
-+ STAILQ_NEXT((elm), field) = NULL; \
- *(head)->stqh_last = (elm); \
-- (head)->stqh_last = &(elm)->field.stqe_next; \
--} while (/*CONSTCOND*/0)
-+ (head)->stqh_last = &STAILQ_NEXT((elm), field); \
-+} while (0)
-
--#define STAILQ_INSERT_AFTER(head, listelm, elm, field) do {
\
-- if (((elm)->field.stqe_next = (listelm)->field.stqe_next) == NULL)\
-- (head)->stqh_last = &(elm)->field.stqe_next; \
-- (listelm)->field.stqe_next = (elm); \
--} while (/*CONSTCOND*/0)
-+#define STAILQ_LAST(head, type, field)
\
-+ (STAILQ_EMPTY((head)) ? \
-+ NULL : \
-+ ((struct type *)(void *) \
-+ ((char *)((head)->stqh_last) - __offsetof(struct type, field))))
-
--#define STAILQ_REMOVE_HEAD(head, field) do {
\
-- if (((head)->stqh_first = (head)->stqh_first->field.stqe_next) == NULL)
\
-- (head)->stqh_last = &(head)->stqh_first;
\
--} while (/*CONSTCOND*/0)
-+#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)
-
#define STAILQ_REMOVE(head, elm, type, field) do {
\
-- if ((head)->stqh_first == (elm)) { \
-+ if (STAILQ_FIRST((head)) == (elm)) { \
+ if ((head)->stqh_first == (elm)) { \
STAILQ_REMOVE_HEAD((head), field); \
-- } else { \
-- struct type *curelm = (head)->stqh_first; \
-- while (curelm->field.stqe_next != (elm))
\
-- curelm = curelm->field.stqe_next; \
-- if ((curelm->field.stqe_next = \
-- curelm->field.stqe_next->field.stqe_next) == NULL) \
-- (head)->stqh_last = &(curelm)->field.stqe_next; \
- } \
--} while (/*CONSTCOND*/0)
--
--#define STAILQ_FOREACH(var, head, field)
\
-- for ((var) = ((head)->stqh_first); \
-- (var); \
-- (var) = ((var)->field.stqe_next))
--
--/*
-- * Singly-linked Tail queue access methods.
-- */
--#define STAILQ_EMPTY(head) ((head)->stqh_first == NULL)
--#define STAILQ_FIRST(head) ((head)->stqh_first)
--#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)
-+ 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)
+@@ -271,6 +293,11 @@
+ (var); \
+ (var) = ((var)->field.stqe_next))
-+#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)
-
- /*
-- * Simple queue definitions.
-+ * List declarations.
- */
--#define SIMPLEQ_HEAD(name, type)
\
-+#define LIST_HEAD(name, type)
\
- struct name { \
-- struct type *sqh_first; /* first element */ \
-- struct type **sqh_last; /* addr of last next element */ \
-+ struct type *lh_first; /* first element */ \
- }
-
--#define SIMPLEQ_HEAD_INITIALIZER(head)
\
-- { NULL, &(head).sqh_first }
-+#define LIST_HEAD_INITIALIZER(head)
\
-+ { NULL }
-
--#define SIMPLEQ_ENTRY(type)
\
-+#define LIST_ENTRY(type)
\
- struct { \
-- struct type *sqe_next; /* next element */ \
-+ struct type *le_next; /* next element */ \
-+ struct type **le_prev; /* address of previous next element */ \
- }
-
- /*
-- * Simple queue functions.
-+ * List functions.
- */
--#define SIMPLEQ_INIT(head) do {
\
-- (head)->sqh_first = NULL; \
-- (head)->sqh_last = &(head)->sqh_first; \
--} while (/*CONSTCOND*/0)
--
--#define SIMPLEQ_INSERT_HEAD(head, elm, field) do {
\
-- if (((elm)->field.sqe_next = (head)->sqh_first) == NULL) \
-- (head)->sqh_last = &(elm)->field.sqe_next; \
-- (head)->sqh_first = (elm); \
--} while (/*CONSTCOND*/0)
--
--#define SIMPLEQ_INSERT_TAIL(head, elm, field) do {
\
-- (elm)->field.sqe_next = NULL; \
-- *(head)->sqh_last = (elm); \
-- (head)->sqh_last = &(elm)->field.sqe_next; \
--} while (/*CONSTCOND*/0)
--
--#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do {
\
-- if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\
-- (head)->sqh_last = &(elm)->field.sqe_next; \
-- (listelm)->field.sqe_next = (elm); \
--} while (/*CONSTCOND*/0)
--
--#define SIMPLEQ_REMOVE_HEAD(head, field) do {
\
-- if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \
-- (head)->sqh_last = &(head)->sqh_first; \
--} while (/*CONSTCOND*/0)
--
--#define SIMPLEQ_REMOVE(head, elm, type, field) do {
\
-- if ((head)->sqh_first == (elm)) { \
-- SIMPLEQ_REMOVE_HEAD((head), field); \
-- } else { \
-- struct type *curelm = (head)->sqh_first; \
-- while (curelm->field.sqe_next != (elm)) \
-- curelm = curelm->field.sqe_next; \
-- if ((curelm->field.sqe_next = \
-- curelm->field.sqe_next->field.sqe_next) == NULL) \
-- (head)->sqh_last = &(curelm)->field.sqe_next; \
-- } \
--} while (/*CONSTCOND*/0)
-
--#define SIMPLEQ_FOREACH(var, head, field)
\
-- for ((var) = ((head)->sqh_first); \
-- (var); \
-- (var) = ((var)->field.sqe_next))
-+#define LIST_EMPTY(head) ((head)->lh_first == NULL)
-
--/*
-- * Simple queue access methods.
-- */
--#define SIMPLEQ_EMPTY(head) ((head)->sqh_first == NULL)
--#define SIMPLEQ_FIRST(head) ((head)->sqh_first)
--#define SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next)
-+#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_FOREACH_SAFE(var, head, field, tvar)
\
-+ for ((var) = LIST_FIRST((head)); \
-+ (var) && ((tvar) = LIST_NEXT((var), field), 1); \
++#define STAILQ_FOREACH_SAFE(var, head, field, tvar)
\
++ for ((var) = ((elm)->field.stqe_next); \
++ (var) && ((tvar) = ((var)->field.stqe_next), 1); \
+ (var) = (tvar))
+
-+#define LIST_INIT(head) do {
\
-+ LIST_FIRST((head)) = NULL; \
-+} while (0)
-+
-+#define LIST_INSERT_AFTER(listelm, elm, field) do {
\
-+ if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
-+ LIST_NEXT((listelm), field)->field.le_prev = \
-+ &LIST_NEXT((elm), field); \
-+ LIST_NEXT((listelm), field) = (elm); \
-+ (elm)->field.le_prev = &LIST_NEXT((listelm), field); \
-+} while (0)
-+
-+#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_INSERT_HEAD(head, elm, field) do {
\
-+ if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \
-+ LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
-+ LIST_FIRST((head)) = (elm); \
-+ (elm)->field.le_prev = &LIST_FIRST((head)); \
-+} while (0)
-+
-+#define LIST_NEXT(elm, field) ((elm)->field.le_next)
+ #define STAILQ_CONCAT(head1, head2) do {
\
+ if (!STAILQ_EMPTY((head2))) { \
+ *(head1)->stqh_last = (head2)->stqh_first; \
+@@ -437,11 +464,21 @@
+ (var); \
+ (var) = ((var)->field.tqe_next))
-+#define LIST_REMOVE(elm, field) do {
\
-+ if (LIST_NEXT((elm), field) != NULL) \
-+ LIST_NEXT((elm), field)->field.le_prev = \
-+ (elm)->field.le_prev; \
-+ *(elm)->field.le_prev = LIST_NEXT((elm), field); \
-+} while (0)
-
- /*
-- * Tail queue definitions.
-+ * Tail queue declarations.
- */
--#define _TAILQ_HEAD(name, type, qual)
\
-+#define TAILQ_HEAD(name, type)
\
- struct name { \
-- qual type *tqh_first; /* first element */ \
-- qual type *qual *tqh_last; /* addr of last next element */ \
-+ struct type *tqh_first; /* first element */ \
-+ struct type **tqh_last; /* addr of last next element */ \
-+ TRACEBUF \
- }
--#define TAILQ_HEAD(name, type) _TAILQ_HEAD(name, struct type,)
-
- #define TAILQ_HEAD_INITIALIZER(head)
\
- { NULL, &(head).tqh_first }
-
--#define _TAILQ_ENTRY(type, qual)
\
-+#define TAILQ_ENTRY(type)
\
- struct { \
-- qual type *tqe_next; /* next element */ \
-- qual type *qual *tqe_prev; /* address of previous next element */\
-+ struct type *tqe_next; /* next element */ \
-+ struct type **tqe_prev; /* address of previous next element */ \
-+ TRACEBUF \
- }
--#define TAILQ_ENTRY(type) _TAILQ_ENTRY(struct type,)
-
- /*
- * Tail queue functions.
- */
-+#define TAILQ_CONCAT(head1, head2, field) do {
\
-+ if (!TAILQ_EMPTY(head2)) { \
-+ *(head1)->tqh_last = (head2)->tqh_first; \
-+ (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \
-+ (head1)->tqh_last = (head2)->tqh_last; \
-+ TAILQ_INIT((head2)); \
-+ QMD_TRACE_HEAD(head1); \
-+ QMD_TRACE_HEAD(head2); \
-+ } \
-+} while (0)
-+
-+#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL)
-+
-+#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_FOREACH_SAFE(var, head, field, tvar)
\
-+ for ((var) = TAILQ_FIRST((head)); \
-+ (var) && ((tvar) = TAILQ_NEXT((var), field), 1); \
++ for ((var) = ((head)->tqh_first); \
++ (var) && ((tvar) = ((var)->field.tqe_next), 1); \
+ (var) = (tvar))
+
-+#define TAILQ_FOREACH_REVERSE(var, head, headname, field)
\
-+ for ((var) = TAILQ_LAST((head), headname); \
-+ (var); \
-+ (var) = TAILQ_PREV((var), headname, field))
-+
+ #define TAILQ_FOREACH_REVERSE(var, head, headname, field)
\
+ for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last));
\
+ (var); \
+ (var) = (*(((struct headname
*)((var)->field.tqe_prev))->tqh_last)))
+
+#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)
\
-+ for ((var) = TAILQ_LAST((head), headname); \
-+ (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \
++ for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last));
\
++ (var) && ((tvar) = (*(((struct headname
*)((elm)->field.tqe_prev))->tqh_last)), 1); \
+ (var) = (tvar))
+
- #define TAILQ_INIT(head) do {
\
-- (head)->tqh_first = NULL; \
-- (head)->tqh_last = &(head)->tqh_first; \
--} while (/*CONSTCOND*/0)
-+ TAILQ_FIRST((head)) = NULL; \
-+ (head)->tqh_last = &TAILQ_FIRST((head)); \
-+ QMD_TRACE_HEAD(head); \
-+} while (0)
-+
-+#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do {
\
-+ if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
-+ TAILQ_NEXT((elm), field)->field.tqe_prev = \
-+ &TAILQ_NEXT((elm), field); \
-+ else { \
-+ (head)->tqh_last = &TAILQ_NEXT((elm), field); \
-+ QMD_TRACE_HEAD(head); \
-+ } \
-+ TAILQ_NEXT((listelm), field) = (elm); \
-+ (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field); \
-+ QMD_TRACE_ELEM(&(elm)->field); \
-+ QMD_TRACE_ELEM(&listelm->field); \
-+} while (0)
-+
-+#define TAILQ_INSERT_BEFORE(listelm, elm, field) do {
\
-+ (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
-+ TAILQ_NEXT((elm), field) = (listelm); \
-+ *(listelm)->field.tqe_prev = (elm); \
-+ (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field); \
-+ QMD_TRACE_ELEM(&(elm)->field); \
-+ QMD_TRACE_ELEM(&listelm->field); \
-+} while (0)
-
- #define TAILQ_INSERT_HEAD(head, elm, field) do {
\
-- if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \
-- (head)->tqh_first->field.tqe_prev = \
-- &(elm)->field.tqe_next; \
-+ if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) \
-+ TAILQ_FIRST((head))->field.tqe_prev = \
-+ &TAILQ_NEXT((elm), field); \
- else \
-- (head)->tqh_last = &(elm)->field.tqe_next; \
-- (head)->tqh_first = (elm); \
-- (elm)->field.tqe_prev = &(head)->tqh_first; \
--} while (/*CONSTCOND*/0)
-+ (head)->tqh_last = &TAILQ_NEXT((elm), field); \
-+ TAILQ_FIRST((head)) = (elm); \
-+ (elm)->field.tqe_prev = &TAILQ_FIRST((head)); \
-+ QMD_TRACE_HEAD(head); \
-+ QMD_TRACE_ELEM(&(elm)->field); \
-+} while (0)
-
- #define TAILQ_INSERT_TAIL(head, elm, field) do {
\
-- (elm)->field.tqe_next = NULL; \
-+ TAILQ_NEXT((elm), field) = NULL; \
- (elm)->field.tqe_prev = (head)->tqh_last; \
- *(head)->tqh_last = (elm); \
-- (head)->tqh_last = &(elm)->field.tqe_next; \
--} while (/*CONSTCOND*/0)
-+ (head)->tqh_last = &TAILQ_NEXT((elm), field); \
-+ QMD_TRACE_HEAD(head); \
-+ QMD_TRACE_ELEM(&(elm)->field); \
-+} while (0)
-
--#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do {
\
-- if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
-- (elm)->field.tqe_next->field.tqe_prev = \
-- &(elm)->field.tqe_next; \
-- else \
-- (head)->tqh_last = &(elm)->field.tqe_next; \
-- (listelm)->field.tqe_next = (elm); \
-- (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \
--} while (/*CONSTCOND*/0)
-+#define TAILQ_LAST(head, headname)
\
-+ (*(((struct headname *)((head)->tqh_last))->tqh_last))
-
--#define TAILQ_INSERT_BEFORE(listelm, elm, field) do {
\
-- (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
-- (elm)->field.tqe_next = (listelm); \
-- *(listelm)->field.tqe_prev = (elm); \
-- (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \
--} while (/*CONSTCOND*/0)
-+#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
-+
-+#define TAILQ_PREV(elm, headname, field)
\
-+ (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
-
- #define TAILQ_REMOVE(head, elm, field) do {
\
-- if (((elm)->field.tqe_next) != NULL) \
-- (elm)->field.tqe_next->field.tqe_prev = \
-+ if ((TAILQ_NEXT((elm), field)) != NULL) \
-+ TAILQ_NEXT((elm), field)->field.tqe_prev = \
- (elm)->field.tqe_prev; \
-- else \
-+ else { \
- (head)->tqh_last = (elm)->field.tqe_prev; \
-- *(elm)->field.tqe_prev = (elm)->field.tqe_next; \
--} while (/*CONSTCOND*/0)
-+ QMD_TRACE_HEAD(head); \
-+ } \
-+ *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field); \
-+ TRASHIT((elm)->field.tqe_next); \
-+ TRASHIT((elm)->field.tqe_prev); \
-+ QMD_TRACE_ELEM(&(elm)->field); \
-+} while (0)
-
--#define TAILQ_FOREACH(var, head, field)
\
-- for ((var) = ((head)->tqh_first); \
-- (var); \
-- (var) = ((var)->field.tqe_next))
-
--#define TAILQ_FOREACH_REVERSE(var, head, headname, field)
\
-- for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last));
\
-- (var); \
-- (var) = (*(((struct headname
*)((var)->field.tqe_prev))->tqh_last)))
-+#ifdef _KERNEL
-
- /*
-- * Tail queue access methods.
-+ * XXX insque() and remque() are an old way of handling certain queues.
-+ * They bogusly assumes that all queue heads look alike.
- */
--#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL)
--#define TAILQ_FIRST(head) ((head)->tqh_first)
--#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
-
--#define TAILQ_LAST(head, headname) \
-- (*(((struct headname *)((head)->tqh_last))->tqh_last))
--#define TAILQ_PREV(elm, headname, field) \
-- (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
-+struct quehead {
-+ struct quehead *qh_link;
-+ struct quehead *qh_rlink;
-+};
-
-+#if defined(__GNUC__) || defined(__INTEL_COMPILER)
-
--/*
-- * Circular queue definitions.
-- */
--#define CIRCLEQ_HEAD(name, type)
\
--struct name { \
-- struct type *cqh_first; /* first element */ \
-- struct type *cqh_last; /* last element */ \
-+static __inline void
-+insque(void *a, void *b)
-+{
-+ struct quehead *element = (struct quehead *)a,
-+ *head = (struct quehead *)b;
-+
-+ element->qh_link = head->qh_link;
-+ element->qh_rlink = head;
-+ head->qh_link = element;
-+ element->qh_link->qh_rlink = element;
- }
-
--#define CIRCLEQ_HEAD_INITIALIZER(head)
\
-- { (void *)&head, (void *)&head }
-+static __inline void
-+remque(void *a)
-+{
-+ struct quehead *element = (struct quehead *)a;
-
--#define CIRCLEQ_ENTRY(type)
\
--struct { \
-- struct type *cqe_next; /* next element */ \
-- struct type *cqe_prev; /* previous element */ \
-+ element->qh_link->qh_rlink = element->qh_rlink;
-+ element->qh_rlink->qh_link = element->qh_link;
-+ element->qh_rlink = 0;
- }
-
--/*
-- * Circular queue functions.
-- */
--#define CIRCLEQ_INIT(head) do {
\
-- (head)->cqh_first = (void *)(head); \
-- (head)->cqh_last = (void *)(head); \
--} while (/*CONSTCOND*/0)
--
--#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do {
\
-- (elm)->field.cqe_next = (listelm)->field.cqe_next; \
-- (elm)->field.cqe_prev = (listelm); \
-- if ((listelm)->field.cqe_next == (void *)(head)) \
-- (head)->cqh_last = (elm); \
-- else \
-- (listelm)->field.cqe_next->field.cqe_prev = (elm); \
-- (listelm)->field.cqe_next = (elm); \
--} while (/*CONSTCOND*/0)
--
--#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do {
\
-- (elm)->field.cqe_next = (listelm); \
-- (elm)->field.cqe_prev = (listelm)->field.cqe_prev; \
-- if ((listelm)->field.cqe_prev == (void *)(head)) \
-- (head)->cqh_first = (elm); \
-- else \
-- (listelm)->field.cqe_prev->field.cqe_next = (elm); \
-- (listelm)->field.cqe_prev = (elm); \
--} while (/*CONSTCOND*/0)
--
--#define CIRCLEQ_INSERT_HEAD(head, elm, field) do {
\
-- (elm)->field.cqe_next = (head)->cqh_first; \
-- (elm)->field.cqe_prev = (void *)(head); \
-- if ((head)->cqh_last == (void *)(head)) \
-- (head)->cqh_last = (elm); \
-- else \
-- (head)->cqh_first->field.cqe_prev = (elm); \
-- (head)->cqh_first = (elm); \
--} while (/*CONSTCOND*/0)
--
--#define CIRCLEQ_INSERT_TAIL(head, elm, field) do {
\
-- (elm)->field.cqe_next = (void *)(head); \
-- (elm)->field.cqe_prev = (head)->cqh_last; \
-- if ((head)->cqh_first == (void *)(head)) \
-- (head)->cqh_first = (elm); \
-- else \
-- (head)->cqh_last->field.cqe_next = (elm); \
-- (head)->cqh_last = (elm); \
--} while (/*CONSTCOND*/0)
--
--#define CIRCLEQ_REMOVE(head, elm, field) do {
\
-- if ((elm)->field.cqe_next == (void *)(head)) \
-- (head)->cqh_last = (elm)->field.cqe_prev; \
-- else \
-- (elm)->field.cqe_next->field.cqe_prev = \
-- (elm)->field.cqe_prev; \
-- if ((elm)->field.cqe_prev == (void *)(head)) \
-- (head)->cqh_first = (elm)->field.cqe_next; \
-- else \
-- (elm)->field.cqe_prev->field.cqe_next = \
-- (elm)->field.cqe_next; \
--} while (/*CONSTCOND*/0)
--
--#define CIRCLEQ_FOREACH(var, head, field)
\
-- for ((var) = ((head)->cqh_first); \
-- (var) != (const void *)(head); \
-- (var) = ((var)->field.cqe_next))
--
--#define CIRCLEQ_FOREACH_REVERSE(var, head, field)
\
-- for ((var) = ((head)->cqh_last); \
-- (var) != (const void *)(head); \
-- (var) = ((var)->field.cqe_prev))
-+#else /* !(__GNUC__ || __INTEL_COMPILER) */
-
--/*
-- * Circular queue access methods.
-- */
--#define CIRCLEQ_EMPTY(head) ((head)->cqh_first == (void
*)(head))
--#define CIRCLEQ_FIRST(head) ((head)->cqh_first)
--#define CIRCLEQ_LAST(head) ((head)->cqh_last)
--#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next)
--#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev)
--
--#define CIRCLEQ_LOOP_NEXT(head, elm, field) \
-- (((elm)->field.cqe_next == (void *)(head)) \
-- ? ((head)->cqh_first) \
-- : (elm->field.cqe_next))
--#define CIRCLEQ_LOOP_PREV(head, elm, field) \
-- (((elm)->field.cqe_prev == (void *)(head)) \
-- ? ((head)->cqh_last) \
-- : (elm->field.cqe_prev))
-+void insque(void *a, void *b);
-+void remque(void *a);
-+
-+#endif /* __GNUC__ || __INTEL_COMPILER */
-+
-+#endif /* _KERNEL */
-
--#endif /* sys/queue.h */
-+#endif /* !_SYS_QUEUE_H_ */
+ #define TAILQ_CONCAT(head1, head2, field) do {
\
+ if (!TAILQ_EMPTY(head2)) { \
+ *(head1)->tqh_last = (head2)->tqh_first; \
Modified: glibc-package/branches/glibc-2.8/debian/patches/series.kfreebsd-amd64
===================================================================
--- glibc-package/branches/glibc-2.8/debian/patches/series.kfreebsd-amd64
2008-08-10 22:14:07 UTC (rev 3081)
+++ glibc-package/branches/glibc-2.8/debian/patches/series.kfreebsd-amd64
2008-08-11 02:31:42 UTC (rev 3082)
@@ -3,6 +3,6 @@
kfreebsd/local-pthread_at_fork.diff -p0
kfreebsd/local-readdir_r.diff -p0
kfreebsd/local-scripts.diff -p0
-kfreebsd/local-sys_queue_h.diff -p0
+kfreebsd/local-sys_queue_h.diff -p1
kfreebsd/local-sysdeps.diff -p0
kfreebsd/local-undef-glibc.diff -p0
Modified: glibc-package/branches/glibc-2.8/debian/patches/series.kfreebsd-i386
===================================================================
--- glibc-package/branches/glibc-2.8/debian/patches/series.kfreebsd-i386
2008-08-10 22:14:07 UTC (rev 3081)
+++ glibc-package/branches/glibc-2.8/debian/patches/series.kfreebsd-i386
2008-08-11 02:31:42 UTC (rev 3082)
@@ -3,6 +3,6 @@
kfreebsd/local-pthread_at_fork.diff -p0
kfreebsd/local-readdir_r.diff -p0
kfreebsd/local-scripts.diff -p0
-kfreebsd/local-sys_queue_h.diff -p0
+kfreebsd/local-sys_queue_h.diff -p1
kfreebsd/local-sysdeps.diff -p0
kfreebsd/local-undef-glibc.diff -p0
--
To UNSUBSCRIBE, email to [EMAIL PROTECTED]
with a subject of "unsubscribe". Trouble? Contact [EMAIL PROTECTED]
