musl-fixup.patch (25184B)
1 From 57dee7a87c40cd2210bd548013f67f4ad060ec7c Mon Sep 17 00:00:00 2001 2 From: sin <sin@2f30.org> 3 Date: Sat, 14 Jun 2014 19:46:29 +0100 4 Subject: [PATCH] Fix up patch to make it compile against musl 5 6 --- 7 Makefile | 2 +- 8 def.h | 1 + 9 fileio.c | 4 +- 10 linux.c | 1 - 11 re_search.c | 1 + 12 sys/queue.h | 648 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 13 6 files changed, 653 insertions(+), 4 deletions(-) 14 create mode 100644 sys/queue.h 15 16 diff --git a/Makefile b/Makefile 17 index 9935033..04ce580 100644 18 --- a/Makefile 19 +++ b/Makefile 20 @@ -5,7 +5,7 @@ DOCDIR?= $(PREFIX)/share/doc 21 22 CC?= gcc 23 CFLAGS+= -O2 -Wall -D_GNU_SOURCE -DFKEYS -DREGEX -DXKEYS 24 -LDADD+= -lcurses 25 +LDADD+= -lncurses 26 27 SRCS= $(shell ls *.c) 28 OBJS= $(SRCS:.c=.o) 29 diff --git a/def.h b/def.h 30 index 562516f..485c823 100644 31 --- a/def.h 32 +++ b/def.h 33 @@ -10,6 +10,7 @@ 34 * per-terminal definitions are in special header files. 35 */ 36 37 +#include <sys/types.h> 38 #include "sysdef.h" /* Order is critical. */ 39 #include "ttydef.h" 40 #include "chrdef.h" 41 diff --git a/fileio.c b/fileio.c 42 index 78bd876..e6eca16 100644 43 --- a/fileio.c 44 +++ b/fileio.c 45 @@ -95,7 +95,7 @@ int 46 ffwopen(FILE ** ffp, const char *fn, struct buffer *bp) 47 { 48 int fd; 49 - mode_t fmode = DEFFILEMODE; 50 + mode_t fmode = 0666; 51 52 if (bp && bp->b_fi.fi_mode) 53 fmode = bp->b_fi.fi_mode & 07777; 54 @@ -361,7 +361,7 @@ copy(char *frname, char *toname) 55 { 56 int ifd, ofd; 57 char buf[BUFSIZ]; 58 - mode_t fmode = DEFFILEMODE; /* XXX?? */ 59 + mode_t fmode = 0666; 60 struct stat orig; 61 ssize_t sr; 62 63 diff --git a/linux.c b/linux.c 64 index ebceec4..6a41919 100644 65 --- a/linux.c 66 +++ b/linux.c 67 @@ -1,5 +1,4 @@ 68 #include <sys/types.h> 69 -#include <sys/cdefs.h> 70 71 #include <errno.h> 72 #include <limits.h> 73 diff --git a/re_search.c b/re_search.c 74 index d8d4008..1a64d5b 100644 75 --- a/re_search.c 76 +++ b/re_search.c 77 @@ -28,6 +28,7 @@ 78 #define SRCH_ACCM (-4) 79 #define SRCH_MARK (-5) 80 81 +#define REG_STARTEND (1 << 2) 82 #define RE_NMATCH 10 /* max number of matches */ 83 #define REPLEN 256 /* max length of replacement string */ 84 85 diff --git a/sys/queue.h b/sys/queue.h 86 new file mode 100644 87 index 0000000..f8f09bf 88 --- /dev/null 89 +++ b/sys/queue.h 90 @@ -0,0 +1,648 @@ 91 +/* $OpenBSD: queue.h,v 1.38 2013/07/03 15:05:21 fgsch Exp $ */ 92 +/* $NetBSD: queue.h,v 1.11 1996/05/16 05:17:14 mycroft Exp $ */ 93 + 94 +/* 95 + * Copyright (c) 1991, 1993 96 + * The Regents of the University of California. All rights reserved. 97 + * 98 + * Redistribution and use in source and binary forms, with or without 99 + * modification, are permitted provided that the following conditions 100 + * are met: 101 + * 1. Redistributions of source code must retain the above copyright 102 + * notice, this list of conditions and the following disclaimer. 103 + * 2. Redistributions in binary form must reproduce the above copyright 104 + * notice, this list of conditions and the following disclaimer in the 105 + * documentation and/or other materials provided with the distribution. 106 + * 3. Neither the name of the University nor the names of its contributors 107 + * may be used to endorse or promote products derived from this software 108 + * without specific prior written permission. 109 + * 110 + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 111 + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 112 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 113 + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 114 + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 115 + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 116 + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 117 + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 118 + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 119 + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 120 + * SUCH DAMAGE. 121 + * 122 + * @(#)queue.h 8.5 (Berkeley) 8/20/94 123 + */ 124 + 125 +#ifndef _SYS_QUEUE_H_ 126 +#define _SYS_QUEUE_H_ 127 + 128 +/* 129 + * This file defines five types of data structures: singly-linked lists, 130 + * lists, simple queues, tail queues, and circular queues. 131 + * 132 + * 133 + * A singly-linked list is headed by a single forward pointer. The elements 134 + * are singly linked for minimum space and pointer manipulation overhead at 135 + * the expense of O(n) removal for arbitrary elements. New elements can be 136 + * added to the list after an existing element or at the head of the list. 137 + * Elements being removed from the head of the list should use the explicit 138 + * macro for this purpose for optimum efficiency. A singly-linked list may 139 + * only be traversed in the forward direction. Singly-linked lists are ideal 140 + * for applications with large datasets and few or no removals or for 141 + * implementing a LIFO queue. 142 + * 143 + * A list is headed by a single forward pointer (or an array of forward 144 + * pointers for a hash table header). The elements are doubly linked 145 + * so that an arbitrary element can be removed without a need to 146 + * traverse the list. New elements can be added to the list before 147 + * or after an existing element or at the head of the list. A list 148 + * may only be traversed in the forward direction. 149 + * 150 + * A simple queue is headed by a pair of pointers, one the head of the 151 + * list and the other to the tail of the list. The elements are singly 152 + * linked to save space, so elements can only be removed from the 153 + * head of the list. New elements can be added to the list before or after 154 + * an existing element, at the head of the list, or at the end of the 155 + * list. A simple queue may only be traversed in the forward direction. 156 + * 157 + * A tail queue is headed by a pair of pointers, one to the head of the 158 + * list and the other to the tail of the list. The elements are doubly 159 + * linked so that an arbitrary element can be removed without a need to 160 + * traverse the list. New elements can be added to the list before or 161 + * after an existing element, at the head of the list, or at the end of 162 + * the list. A tail queue may be traversed in either direction. 163 + * 164 + * A circle queue is headed by a pair of pointers, one to the head of the 165 + * list and the other to the tail of the list. The elements are doubly 166 + * linked so that an arbitrary element can be removed without a need to 167 + * traverse the list. New elements can be added to the list before or after 168 + * an existing element, at the head of the list, or at the end of the list. 169 + * A circle queue may be traversed in either direction, but has a more 170 + * complex end of list detection. 171 + * 172 + * For details on the use of these macros, see the queue(3) manual page. 173 + */ 174 + 175 +#if defined(QUEUE_MACRO_DEBUG) || (defined(_KERNEL) && defined(DIAGNOSTIC)) 176 +#define _Q_INVALIDATE(a) (a) = ((void *)-1) 177 +#else 178 +#define _Q_INVALIDATE(a) 179 +#endif 180 + 181 +/* 182 + * Singly-linked List definitions. 183 + */ 184 +#define SLIST_HEAD(name, type) \ 185 +struct name { \ 186 + struct type *slh_first; /* first element */ \ 187 +} 188 + 189 +#define SLIST_HEAD_INITIALIZER(head) \ 190 + { NULL } 191 + 192 +#define SLIST_ENTRY(type) \ 193 +struct { \ 194 + struct type *sle_next; /* next element */ \ 195 +} 196 + 197 +/* 198 + * Singly-linked List access methods. 199 + */ 200 +#define SLIST_FIRST(head) ((head)->slh_first) 201 +#define SLIST_END(head) NULL 202 +#define SLIST_EMPTY(head) (SLIST_FIRST(head) == SLIST_END(head)) 203 +#define SLIST_NEXT(elm, field) ((elm)->field.sle_next) 204 + 205 +#define SLIST_FOREACH(var, head, field) \ 206 + for((var) = SLIST_FIRST(head); \ 207 + (var) != SLIST_END(head); \ 208 + (var) = SLIST_NEXT(var, field)) 209 + 210 +#define SLIST_FOREACH_SAFE(var, head, field, tvar) \ 211 + for ((var) = SLIST_FIRST(head); \ 212 + (var) && ((tvar) = SLIST_NEXT(var, field), 1); \ 213 + (var) = (tvar)) 214 + 215 +/* 216 + * Singly-linked List functions. 217 + */ 218 +#define SLIST_INIT(head) { \ 219 + SLIST_FIRST(head) = SLIST_END(head); \ 220 +} 221 + 222 +#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \ 223 + (elm)->field.sle_next = (slistelm)->field.sle_next; \ 224 + (slistelm)->field.sle_next = (elm); \ 225 +} while (0) 226 + 227 +#define SLIST_INSERT_HEAD(head, elm, field) do { \ 228 + (elm)->field.sle_next = (head)->slh_first; \ 229 + (head)->slh_first = (elm); \ 230 +} while (0) 231 + 232 +#define SLIST_REMOVE_AFTER(elm, field) do { \ 233 + (elm)->field.sle_next = (elm)->field.sle_next->field.sle_next; \ 234 +} while (0) 235 + 236 +#define SLIST_REMOVE_HEAD(head, field) do { \ 237 + (head)->slh_first = (head)->slh_first->field.sle_next; \ 238 +} while (0) 239 + 240 +#define SLIST_REMOVE(head, elm, type, field) do { \ 241 + if ((head)->slh_first == (elm)) { \ 242 + SLIST_REMOVE_HEAD((head), field); \ 243 + } else { \ 244 + struct type *curelm = (head)->slh_first; \ 245 + \ 246 + while (curelm->field.sle_next != (elm)) \ 247 + curelm = curelm->field.sle_next; \ 248 + curelm->field.sle_next = \ 249 + curelm->field.sle_next->field.sle_next; \ 250 + _Q_INVALIDATE((elm)->field.sle_next); \ 251 + } \ 252 +} while (0) 253 + 254 +/* 255 + * List definitions. 256 + */ 257 +#define LIST_HEAD(name, type) \ 258 +struct name { \ 259 + struct type *lh_first; /* first element */ \ 260 +} 261 + 262 +#define LIST_HEAD_INITIALIZER(head) \ 263 + { NULL } 264 + 265 +#define LIST_ENTRY(type) \ 266 +struct { \ 267 + struct type *le_next; /* next element */ \ 268 + struct type **le_prev; /* address of previous next element */ \ 269 +} 270 + 271 +/* 272 + * List access methods 273 + */ 274 +#define LIST_FIRST(head) ((head)->lh_first) 275 +#define LIST_END(head) NULL 276 +#define LIST_EMPTY(head) (LIST_FIRST(head) == LIST_END(head)) 277 +#define LIST_NEXT(elm, field) ((elm)->field.le_next) 278 + 279 +#define LIST_FOREACH(var, head, field) \ 280 + for((var) = LIST_FIRST(head); \ 281 + (var)!= LIST_END(head); \ 282 + (var) = LIST_NEXT(var, field)) 283 + 284 +#define LIST_FOREACH_SAFE(var, head, field, tvar) \ 285 + for ((var) = LIST_FIRST(head); \ 286 + (var) && ((tvar) = LIST_NEXT(var, field), 1); \ 287 + (var) = (tvar)) 288 + 289 +/* 290 + * List functions. 291 + */ 292 +#define LIST_INIT(head) do { \ 293 + LIST_FIRST(head) = LIST_END(head); \ 294 +} while (0) 295 + 296 +#define LIST_INSERT_AFTER(listelm, elm, field) do { \ 297 + if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \ 298 + (listelm)->field.le_next->field.le_prev = \ 299 + &(elm)->field.le_next; \ 300 + (listelm)->field.le_next = (elm); \ 301 + (elm)->field.le_prev = &(listelm)->field.le_next; \ 302 +} while (0) 303 + 304 +#define LIST_INSERT_BEFORE(listelm, elm, field) do { \ 305 + (elm)->field.le_prev = (listelm)->field.le_prev; \ 306 + (elm)->field.le_next = (listelm); \ 307 + *(listelm)->field.le_prev = (elm); \ 308 + (listelm)->field.le_prev = &(elm)->field.le_next; \ 309 +} while (0) 310 + 311 +#define LIST_INSERT_HEAD(head, elm, field) do { \ 312 + if (((elm)->field.le_next = (head)->lh_first) != NULL) \ 313 + (head)->lh_first->field.le_prev = &(elm)->field.le_next;\ 314 + (head)->lh_first = (elm); \ 315 + (elm)->field.le_prev = &(head)->lh_first; \ 316 +} while (0) 317 + 318 +#define LIST_REMOVE(elm, field) do { \ 319 + if ((elm)->field.le_next != NULL) \ 320 + (elm)->field.le_next->field.le_prev = \ 321 + (elm)->field.le_prev; \ 322 + *(elm)->field.le_prev = (elm)->field.le_next; \ 323 + _Q_INVALIDATE((elm)->field.le_prev); \ 324 + _Q_INVALIDATE((elm)->field.le_next); \ 325 +} while (0) 326 + 327 +#define LIST_REPLACE(elm, elm2, field) do { \ 328 + if (((elm2)->field.le_next = (elm)->field.le_next) != NULL) \ 329 + (elm2)->field.le_next->field.le_prev = \ 330 + &(elm2)->field.le_next; \ 331 + (elm2)->field.le_prev = (elm)->field.le_prev; \ 332 + *(elm2)->field.le_prev = (elm2); \ 333 + _Q_INVALIDATE((elm)->field.le_prev); \ 334 + _Q_INVALIDATE((elm)->field.le_next); \ 335 +} while (0) 336 + 337 +/* 338 + * Simple queue definitions. 339 + */ 340 +#define SIMPLEQ_HEAD(name, type) \ 341 +struct name { \ 342 + struct type *sqh_first; /* first element */ \ 343 + struct type **sqh_last; /* addr of last next element */ \ 344 +} 345 + 346 +#define SIMPLEQ_HEAD_INITIALIZER(head) \ 347 + { NULL, &(head).sqh_first } 348 + 349 +#define SIMPLEQ_ENTRY(type) \ 350 +struct { \ 351 + struct type *sqe_next; /* next element */ \ 352 +} 353 + 354 +/* 355 + * Simple queue access methods. 356 + */ 357 +#define SIMPLEQ_FIRST(head) ((head)->sqh_first) 358 +#define SIMPLEQ_END(head) NULL 359 +#define SIMPLEQ_EMPTY(head) (SIMPLEQ_FIRST(head) == SIMPLEQ_END(head)) 360 +#define SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next) 361 + 362 +#define SIMPLEQ_FOREACH(var, head, field) \ 363 + for((var) = SIMPLEQ_FIRST(head); \ 364 + (var) != SIMPLEQ_END(head); \ 365 + (var) = SIMPLEQ_NEXT(var, field)) 366 + 367 +#define SIMPLEQ_FOREACH_SAFE(var, head, field, tvar) \ 368 + for ((var) = SIMPLEQ_FIRST(head); \ 369 + (var) && ((tvar) = SIMPLEQ_NEXT(var, field), 1); \ 370 + (var) = (tvar)) 371 + 372 +/* 373 + * Simple queue functions. 374 + */ 375 +#define SIMPLEQ_INIT(head) do { \ 376 + (head)->sqh_first = NULL; \ 377 + (head)->sqh_last = &(head)->sqh_first; \ 378 +} while (0) 379 + 380 +#define SIMPLEQ_INSERT_HEAD(head, elm, field) do { \ 381 + if (((elm)->field.sqe_next = (head)->sqh_first) == NULL) \ 382 + (head)->sqh_last = &(elm)->field.sqe_next; \ 383 + (head)->sqh_first = (elm); \ 384 +} while (0) 385 + 386 +#define SIMPLEQ_INSERT_TAIL(head, elm, field) do { \ 387 + (elm)->field.sqe_next = NULL; \ 388 + *(head)->sqh_last = (elm); \ 389 + (head)->sqh_last = &(elm)->field.sqe_next; \ 390 +} while (0) 391 + 392 +#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ 393 + if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\ 394 + (head)->sqh_last = &(elm)->field.sqe_next; \ 395 + (listelm)->field.sqe_next = (elm); \ 396 +} while (0) 397 + 398 +#define SIMPLEQ_REMOVE_HEAD(head, field) do { \ 399 + if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \ 400 + (head)->sqh_last = &(head)->sqh_first; \ 401 +} while (0) 402 + 403 +#define SIMPLEQ_REMOVE_AFTER(head, elm, field) do { \ 404 + if (((elm)->field.sqe_next = (elm)->field.sqe_next->field.sqe_next) \ 405 + == NULL) \ 406 + (head)->sqh_last = &(elm)->field.sqe_next; \ 407 +} while (0) 408 + 409 +/* 410 + * XOR Simple queue definitions. 411 + */ 412 +#define XSIMPLEQ_HEAD(name, type) \ 413 +struct name { \ 414 + struct type *sqx_first; /* first element */ \ 415 + struct type **sqx_last; /* addr of last next element */ \ 416 + unsigned long sqx_cookie; \ 417 +} 418 + 419 +#define XSIMPLEQ_ENTRY(type) \ 420 +struct { \ 421 + struct type *sqx_next; /* next element */ \ 422 +} 423 + 424 +/* 425 + * XOR Simple queue access methods. 426 + */ 427 +#define XSIMPLEQ_XOR(head, ptr) ((__typeof(ptr))((head)->sqx_cookie ^ \ 428 + (unsigned long)(ptr))) 429 +#define XSIMPLEQ_FIRST(head) XSIMPLEQ_XOR(head, ((head)->sqx_first)) 430 +#define XSIMPLEQ_END(head) NULL 431 +#define XSIMPLEQ_EMPTY(head) (XSIMPLEQ_FIRST(head) == XSIMPLEQ_END(head)) 432 +#define XSIMPLEQ_NEXT(head, elm, field) XSIMPLEQ_XOR(head, ((elm)->field.sqx_next)) 433 + 434 + 435 +#define XSIMPLEQ_FOREACH(var, head, field) \ 436 + for ((var) = XSIMPLEQ_FIRST(head); \ 437 + (var) != XSIMPLEQ_END(head); \ 438 + (var) = XSIMPLEQ_NEXT(head, var, field)) 439 + 440 +#define XSIMPLEQ_FOREACH_SAFE(var, head, field, tvar) \ 441 + for ((var) = XSIMPLEQ_FIRST(head); \ 442 + (var) && ((tvar) = XSIMPLEQ_NEXT(head, var, field), 1); \ 443 + (var) = (tvar)) 444 + 445 +/* 446 + * XOR Simple queue functions. 447 + */ 448 +#define XSIMPLEQ_INIT(head) do { \ 449 + arc4random_buf(&(head)->sqx_cookie, sizeof((head)->sqx_cookie)); \ 450 + (head)->sqx_first = XSIMPLEQ_XOR(head, NULL); \ 451 + (head)->sqx_last = XSIMPLEQ_XOR(head, &(head)->sqx_first); \ 452 +} while (0) 453 + 454 +#define XSIMPLEQ_INSERT_HEAD(head, elm, field) do { \ 455 + if (((elm)->field.sqx_next = (head)->sqx_first) == \ 456 + XSIMPLEQ_XOR(head, NULL)) \ 457 + (head)->sqx_last = XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \ 458 + (head)->sqx_first = XSIMPLEQ_XOR(head, (elm)); \ 459 +} while (0) 460 + 461 +#define XSIMPLEQ_INSERT_TAIL(head, elm, field) do { \ 462 + (elm)->field.sqx_next = XSIMPLEQ_XOR(head, NULL); \ 463 + *(XSIMPLEQ_XOR(head, (head)->sqx_last)) = XSIMPLEQ_XOR(head, (elm)); \ 464 + (head)->sqx_last = XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \ 465 +} while (0) 466 + 467 +#define XSIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ 468 + if (((elm)->field.sqx_next = (listelm)->field.sqx_next) == \ 469 + XSIMPLEQ_XOR(head, NULL)) \ 470 + (head)->sqx_last = XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \ 471 + (listelm)->field.sqx_next = XSIMPLEQ_XOR(head, (elm)); \ 472 +} while (0) 473 + 474 +#define XSIMPLEQ_REMOVE_HEAD(head, field) do { \ 475 + if (((head)->sqx_first = XSIMPLEQ_XOR(head, \ 476 + (head)->sqx_first)->field.sqx_next) == XSIMPLEQ_XOR(head, NULL)) \ 477 + (head)->sqx_last = XSIMPLEQ_XOR(head, &(head)->sqx_first); \ 478 +} while (0) 479 + 480 +#define XSIMPLEQ_REMOVE_AFTER(head, elm, field) do { \ 481 + if (((elm)->field.sqx_next = XSIMPLEQ_XOR(head, \ 482 + (elm)->field.sqx_next)->field.sqx_next) \ 483 + == XSIMPLEQ_XOR(head, NULL)) \ 484 + (head)->sqx_last = \ 485 + XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \ 486 +} while (0) 487 + 488 + 489 +/* 490 + * Tail queue definitions. 491 + */ 492 +#define TAILQ_HEAD(name, type) \ 493 +struct name { \ 494 + struct type *tqh_first; /* first element */ \ 495 + struct type **tqh_last; /* addr of last next element */ \ 496 +} 497 + 498 +#define TAILQ_HEAD_INITIALIZER(head) \ 499 + { NULL, &(head).tqh_first } 500 + 501 +#define TAILQ_ENTRY(type) \ 502 +struct { \ 503 + struct type *tqe_next; /* next element */ \ 504 + struct type **tqe_prev; /* address of previous next element */ \ 505 +} 506 + 507 +/* 508 + * tail queue access methods 509 + */ 510 +#define TAILQ_FIRST(head) ((head)->tqh_first) 511 +#define TAILQ_END(head) NULL 512 +#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) 513 +#define TAILQ_LAST(head, headname) \ 514 + (*(((struct headname *)((head)->tqh_last))->tqh_last)) 515 +/* XXX */ 516 +#define TAILQ_PREV(elm, headname, field) \ 517 + (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) 518 +#define TAILQ_EMPTY(head) \ 519 + (TAILQ_FIRST(head) == TAILQ_END(head)) 520 + 521 +#define TAILQ_FOREACH(var, head, field) \ 522 + for((var) = TAILQ_FIRST(head); \ 523 + (var) != TAILQ_END(head); \ 524 + (var) = TAILQ_NEXT(var, field)) 525 + 526 +#define TAILQ_FOREACH_SAFE(var, head, field, tvar) \ 527 + for ((var) = TAILQ_FIRST(head); \ 528 + (var) != TAILQ_END(head) && \ 529 + ((tvar) = TAILQ_NEXT(var, field), 1); \ 530 + (var) = (tvar)) 531 + 532 + 533 +#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ 534 + for((var) = TAILQ_LAST(head, headname); \ 535 + (var) != TAILQ_END(head); \ 536 + (var) = TAILQ_PREV(var, headname, field)) 537 + 538 +#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \ 539 + for ((var) = TAILQ_LAST(head, headname); \ 540 + (var) != TAILQ_END(head) && \ 541 + ((tvar) = TAILQ_PREV(var, headname, field), 1); \ 542 + (var) = (tvar)) 543 + 544 +/* 545 + * Tail queue functions. 546 + */ 547 +#define TAILQ_INIT(head) do { \ 548 + (head)->tqh_first = NULL; \ 549 + (head)->tqh_last = &(head)->tqh_first; \ 550 +} while (0) 551 + 552 +#define TAILQ_INSERT_HEAD(head, elm, field) do { \ 553 + if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \ 554 + (head)->tqh_first->field.tqe_prev = \ 555 + &(elm)->field.tqe_next; \ 556 + else \ 557 + (head)->tqh_last = &(elm)->field.tqe_next; \ 558 + (head)->tqh_first = (elm); \ 559 + (elm)->field.tqe_prev = &(head)->tqh_first; \ 560 +} while (0) 561 + 562 +#define TAILQ_INSERT_TAIL(head, elm, field) do { \ 563 + (elm)->field.tqe_next = NULL; \ 564 + (elm)->field.tqe_prev = (head)->tqh_last; \ 565 + *(head)->tqh_last = (elm); \ 566 + (head)->tqh_last = &(elm)->field.tqe_next; \ 567 +} while (0) 568 + 569 +#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ 570 + if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\ 571 + (elm)->field.tqe_next->field.tqe_prev = \ 572 + &(elm)->field.tqe_next; \ 573 + else \ 574 + (head)->tqh_last = &(elm)->field.tqe_next; \ 575 + (listelm)->field.tqe_next = (elm); \ 576 + (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \ 577 +} while (0) 578 + 579 +#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ 580 + (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ 581 + (elm)->field.tqe_next = (listelm); \ 582 + *(listelm)->field.tqe_prev = (elm); \ 583 + (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \ 584 +} while (0) 585 + 586 +#define TAILQ_REMOVE(head, elm, field) do { \ 587 + if (((elm)->field.tqe_next) != NULL) \ 588 + (elm)->field.tqe_next->field.tqe_prev = \ 589 + (elm)->field.tqe_prev; \ 590 + else \ 591 + (head)->tqh_last = (elm)->field.tqe_prev; \ 592 + *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ 593 + _Q_INVALIDATE((elm)->field.tqe_prev); \ 594 + _Q_INVALIDATE((elm)->field.tqe_next); \ 595 +} while (0) 596 + 597 +#define TAILQ_REPLACE(head, elm, elm2, field) do { \ 598 + if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != NULL) \ 599 + (elm2)->field.tqe_next->field.tqe_prev = \ 600 + &(elm2)->field.tqe_next; \ 601 + else \ 602 + (head)->tqh_last = &(elm2)->field.tqe_next; \ 603 + (elm2)->field.tqe_prev = (elm)->field.tqe_prev; \ 604 + *(elm2)->field.tqe_prev = (elm2); \ 605 + _Q_INVALIDATE((elm)->field.tqe_prev); \ 606 + _Q_INVALIDATE((elm)->field.tqe_next); \ 607 +} while (0) 608 + 609 +/* 610 + * Circular queue definitions. 611 + */ 612 +#define CIRCLEQ_HEAD(name, type) \ 613 +struct name { \ 614 + struct type *cqh_first; /* first element */ \ 615 + struct type *cqh_last; /* last element */ \ 616 +} 617 + 618 +#define CIRCLEQ_HEAD_INITIALIZER(head) \ 619 + { CIRCLEQ_END(&head), CIRCLEQ_END(&head) } 620 + 621 +#define CIRCLEQ_ENTRY(type) \ 622 +struct { \ 623 + struct type *cqe_next; /* next element */ \ 624 + struct type *cqe_prev; /* previous element */ \ 625 +} 626 + 627 +/* 628 + * Circular queue access methods 629 + */ 630 +#define CIRCLEQ_FIRST(head) ((head)->cqh_first) 631 +#define CIRCLEQ_LAST(head) ((head)->cqh_last) 632 +#define CIRCLEQ_END(head) ((void *)(head)) 633 +#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next) 634 +#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev) 635 +#define CIRCLEQ_EMPTY(head) \ 636 + (CIRCLEQ_FIRST(head) == CIRCLEQ_END(head)) 637 + 638 +#define CIRCLEQ_FOREACH(var, head, field) \ 639 + for((var) = CIRCLEQ_FIRST(head); \ 640 + (var) != CIRCLEQ_END(head); \ 641 + (var) = CIRCLEQ_NEXT(var, field)) 642 + 643 +#define CIRCLEQ_FOREACH_SAFE(var, head, field, tvar) \ 644 + for ((var) = CIRCLEQ_FIRST(head); \ 645 + (var) != CIRCLEQ_END(head) && \ 646 + ((tvar) = CIRCLEQ_NEXT(var, field), 1); \ 647 + (var) = (tvar)) 648 + 649 +#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \ 650 + for((var) = CIRCLEQ_LAST(head); \ 651 + (var) != CIRCLEQ_END(head); \ 652 + (var) = CIRCLEQ_PREV(var, field)) 653 + 654 +#define CIRCLEQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \ 655 + for ((var) = CIRCLEQ_LAST(head, headname); \ 656 + (var) != CIRCLEQ_END(head) && \ 657 + ((tvar) = CIRCLEQ_PREV(var, headname, field), 1); \ 658 + (var) = (tvar)) 659 + 660 +/* 661 + * Circular queue functions. 662 + */ 663 +#define CIRCLEQ_INIT(head) do { \ 664 + (head)->cqh_first = CIRCLEQ_END(head); \ 665 + (head)->cqh_last = CIRCLEQ_END(head); \ 666 +} while (0) 667 + 668 +#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ 669 + (elm)->field.cqe_next = (listelm)->field.cqe_next; \ 670 + (elm)->field.cqe_prev = (listelm); \ 671 + if ((listelm)->field.cqe_next == CIRCLEQ_END(head)) \ 672 + (head)->cqh_last = (elm); \ 673 + else \ 674 + (listelm)->field.cqe_next->field.cqe_prev = (elm); \ 675 + (listelm)->field.cqe_next = (elm); \ 676 +} while (0) 677 + 678 +#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \ 679 + (elm)->field.cqe_next = (listelm); \ 680 + (elm)->field.cqe_prev = (listelm)->field.cqe_prev; \ 681 + if ((listelm)->field.cqe_prev == CIRCLEQ_END(head)) \ 682 + (head)->cqh_first = (elm); \ 683 + else \ 684 + (listelm)->field.cqe_prev->field.cqe_next = (elm); \ 685 + (listelm)->field.cqe_prev = (elm); \ 686 +} while (0) 687 + 688 +#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \ 689 + (elm)->field.cqe_next = (head)->cqh_first; \ 690 + (elm)->field.cqe_prev = CIRCLEQ_END(head); \ 691 + if ((head)->cqh_last == CIRCLEQ_END(head)) \ 692 + (head)->cqh_last = (elm); \ 693 + else \ 694 + (head)->cqh_first->field.cqe_prev = (elm); \ 695 + (head)->cqh_first = (elm); \ 696 +} while (0) 697 + 698 +#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \ 699 + (elm)->field.cqe_next = CIRCLEQ_END(head); \ 700 + (elm)->field.cqe_prev = (head)->cqh_last; \ 701 + if ((head)->cqh_first == CIRCLEQ_END(head)) \ 702 + (head)->cqh_first = (elm); \ 703 + else \ 704 + (head)->cqh_last->field.cqe_next = (elm); \ 705 + (head)->cqh_last = (elm); \ 706 +} while (0) 707 + 708 +#define CIRCLEQ_REMOVE(head, elm, field) do { \ 709 + if ((elm)->field.cqe_next == CIRCLEQ_END(head)) \ 710 + (head)->cqh_last = (elm)->field.cqe_prev; \ 711 + else \ 712 + (elm)->field.cqe_next->field.cqe_prev = \ 713 + (elm)->field.cqe_prev; \ 714 + if ((elm)->field.cqe_prev == CIRCLEQ_END(head)) \ 715 + (head)->cqh_first = (elm)->field.cqe_next; \ 716 + else \ 717 + (elm)->field.cqe_prev->field.cqe_next = \ 718 + (elm)->field.cqe_next; \ 719 + _Q_INVALIDATE((elm)->field.cqe_prev); \ 720 + _Q_INVALIDATE((elm)->field.cqe_next); \ 721 +} while (0) 722 + 723 +#define CIRCLEQ_REPLACE(head, elm, elm2, field) do { \ 724 + if (((elm2)->field.cqe_next = (elm)->field.cqe_next) == \ 725 + CIRCLEQ_END(head)) \ 726 + (head)->cqh_last = (elm2); \ 727 + else \ 728 + (elm2)->field.cqe_next->field.cqe_prev = (elm2); \ 729 + if (((elm2)->field.cqe_prev = (elm)->field.cqe_prev) == \ 730 + CIRCLEQ_END(head)) \ 731 + (head)->cqh_first = (elm2); \ 732 + else \ 733 + (elm2)->field.cqe_prev->field.cqe_next = (elm2); \ 734 + _Q_INVALIDATE((elm)->field.cqe_prev); \ 735 + _Q_INVALIDATE((elm)->field.cqe_next); \ 736 +} while (0) 737 + 738 +#endif /* !_SYS_QUEUE_H_ */ 739 -- 740 2.0.0 741