proxmox-mirrors/mirror_frr
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_frr synced 2025-07-01 07:45:38 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

lib: revert reindent of files imported from OpenBSD

Browse Source 
We should preserve the original indentation to make it easier to keep
these files in sync with the upstream.

Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
This commit is contained in:
Renato Westphal 2017-07-24 18:36:51 -03:00
parent 92690ee649
commit 52535beec1
5 changed files with 654 additions and 617 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
lib/imsg-buffer.c
View File

@ -25,7 +25,8 @@ int ibuf_realloc(struct ibuf *, size_t);
void ibuf_enqueue(struct msgbuf *, struct ibuf *); void ibuf_enqueue(struct msgbuf *, struct ibuf *);
void ibuf_dequeue(struct msgbuf *, struct ibuf *); void ibuf_dequeue(struct msgbuf *, struct ibuf *);
struct ibuf *ibuf_open(size_t len) struct ibuf *
ibuf_open(size_t len)
{ {
struct ibuf *buf; struct ibuf *buf;
@ -41,7 +42,8 @@ struct ibuf *ibuf_open(size_t len)
return (buf); return (buf);
} }
struct ibuf *ibuf_dynamic(size_t len, size_t max) struct ibuf *
ibuf_dynamic(size_t len, size_t max)
{ {
struct ibuf *buf; struct ibuf *buf;
@ -57,7 +59,8 @@ struct ibuf *ibuf_dynamic(size_t len, size_t max)
return (buf); return (buf);
} }
int ibuf_realloc(struct ibuf *buf, size_t len) int
ibuf_realloc(struct ibuf *buf, size_t len)
{ {
u_char *b; u_char *b;
@ -76,7 +79,8 @@ int ibuf_realloc(struct ibuf *buf, size_t len)
return (0); return (0);
} }
int ibuf_add(struct ibuf *buf, const void *data, size_t len) int
ibuf_add(struct ibuf *buf, const void *data, size_t len)
{ {
if (buf->wpos + len > buf->size) if (buf->wpos + len > buf->size)
if (ibuf_realloc(buf, len) == -1) if (ibuf_realloc(buf, len) == -1)
@ -87,7 +91,8 @@ int ibuf_add(struct ibuf *buf, const void *data, size_t len)
return (0); return (0);
} }
void *ibuf_reserve(struct ibuf *buf, size_t len) void *
ibuf_reserve(struct ibuf *buf, size_t len)
{ {
void *b; void *b;
@ -100,7 +105,8 @@ void *ibuf_reserve(struct ibuf *buf, size_t len)
return (b); return (b);
} }
void *ibuf_seek(struct ibuf *buf, size_t pos, size_t len) void *
ibuf_seek(struct ibuf *buf, size_t pos, size_t len)
{ {
/* only allowed to seek in already written parts */ /* only allowed to seek in already written parts */
if (pos + len > buf->wpos) if (pos + len > buf->wpos)
@ -109,22 +115,26 @@ void *ibuf_seek(struct ibuf *buf, size_t pos, size_t len)
return (buf->buf + pos); return (buf->buf + pos);
} }
size_t ibuf_size(struct ibuf *buf) size_t
ibuf_size(struct ibuf *buf)
{ {
return (buf->wpos); return (buf->wpos);
} }
size_t ibuf_left(struct ibuf *buf) size_t
ibuf_left(struct ibuf *buf)
{ {
return (buf->max - buf->wpos); return (buf->max - buf->wpos);
} }
void ibuf_close(struct msgbuf *msgbuf, struct ibuf *buf) void
ibuf_close(struct msgbuf *msgbuf, struct ibuf *buf)
{ {
ibuf_enqueue(msgbuf, buf); ibuf_enqueue(msgbuf, buf);
} }
int ibuf_write(struct msgbuf *msgbuf) int
ibuf_write(struct msgbuf *msgbuf)
{ {
struct iovec iov[IOV_MAX]; struct iovec iov[IOV_MAX];
struct ibuf *buf; struct ibuf *buf;
@ -132,8 +142,7 @@ int ibuf_write(struct msgbuf *msgbuf)
ssize_t n; ssize_t n;
memset(&iov, 0, sizeof(iov)); memset(&iov, 0, sizeof(iov));
TAILQ_FOREACH(buf, &msgbuf->bufs, entry) TAILQ_FOREACH(buf, &msgbuf->bufs, entry) {
{
if (i >= IOV_MAX) if (i >= IOV_MAX)
break; break;
iov[i].iov_base = buf->buf + buf->rpos; iov[i].iov_base = buf->buf + buf->rpos;
@ -160,7 +169,8 @@ again:
return (1); return (1);
} }
void ibuf_free(struct ibuf *buf) void
ibuf_free(struct ibuf *buf)
{ {
if (buf == NULL) if (buf == NULL)
return; return;
@ -168,14 +178,16 @@ void ibuf_free(struct ibuf *buf)
free(buf); free(buf);
} }
void msgbuf_init(struct msgbuf *msgbuf) void
msgbuf_init(struct msgbuf *msgbuf)
{ {
msgbuf->queued = 0; msgbuf->queued = 0;
msgbuf->fd = -1; msgbuf->fd = -1;
TAILQ_INIT(&msgbuf->bufs); TAILQ_INIT(&msgbuf->bufs);
} }
void msgbuf_drain(struct msgbuf *msgbuf, size_t n) void
msgbuf_drain(struct msgbuf *msgbuf, size_t n)
{ {
struct ibuf *buf, *next; struct ibuf *buf, *next;
@ -192,7 +204,8 @@ void msgbuf_drain(struct msgbuf *msgbuf, size_t n)
} }
} }
void msgbuf_clear(struct msgbuf *msgbuf) void
msgbuf_clear(struct msgbuf *msgbuf)
{ {
struct ibuf *buf; struct ibuf *buf;
@ -200,7 +213,8 @@ void msgbuf_clear(struct msgbuf *msgbuf)
ibuf_dequeue(msgbuf, buf); ibuf_dequeue(msgbuf, buf);
} }
int msgbuf_write(struct msgbuf *msgbuf) int
msgbuf_write(struct msgbuf *msgbuf)
{ {
struct iovec iov[IOV_MAX]; struct iovec iov[IOV_MAX];
struct ibuf *buf; struct ibuf *buf;
@ -216,8 +230,7 @@ int msgbuf_write(struct msgbuf *msgbuf)
memset(&iov, 0, sizeof(iov)); memset(&iov, 0, sizeof(iov));
memset(&msg, 0, sizeof(msg)); memset(&msg, 0, sizeof(msg));
memset(&cmsgbuf, 0, sizeof(cmsgbuf)); memset(&cmsgbuf, 0, sizeof(cmsgbuf));
TAILQ_FOREACH(buf, &msgbuf->bufs, entry) TAILQ_FOREACH(buf, &msgbuf->bufs, entry) {
{
if (i >= IOV_MAX) if (i >= IOV_MAX)
break; break;
iov[i].iov_base = buf->buf + buf->rpos; iov[i].iov_base = buf->buf + buf->rpos;
@ -268,13 +281,15 @@ again:
return (1); return (1);
} }
void ibuf_enqueue(struct msgbuf *msgbuf, struct ibuf *buf) void
ibuf_enqueue(struct msgbuf *msgbuf, struct ibuf *buf)
{ {
TAILQ_INSERT_TAIL(&msgbuf->bufs, buf, entry); TAILQ_INSERT_TAIL(&msgbuf->bufs, buf, entry);
msgbuf->queued++; msgbuf->queued++;
} }
void ibuf_dequeue(struct msgbuf *msgbuf, struct ibuf *buf) void
ibuf_dequeue(struct msgbuf *msgbuf, struct ibuf *buf)
{ {
TAILQ_REMOVE(&msgbuf->bufs, buf, entry); TAILQ_REMOVE(&msgbuf->bufs, buf, entry);

61
lib/imsg.c
View File

@ -30,7 +30,8 @@ int imsg_get_fd(struct imsgbuf *);
* The original code calls getdtablecount() which is OpenBSD specific. Use * The original code calls getdtablecount() which is OpenBSD specific. Use
* available_fds() from OpenSMTPD instead. * available_fds() from OpenSMTPD instead.
*/ */
static int available_fds(unsigned int n) static int
available_fds(unsigned int n)
{ {
unsigned int i; unsigned int i;
int ret, fds[256]; int ret, fds[256];
@ -58,7 +59,8 @@ static int available_fds(unsigned int n)
} }
#endif #endif
void imsg_init(struct imsgbuf *ibuf, int fd) void
imsg_init(struct imsgbuf *ibuf, int fd)
{ {
msgbuf_init(&ibuf->w); msgbuf_init(&ibuf->w);
memset(&ibuf->r, 0, sizeof(ibuf->r)); memset(&ibuf->r, 0, sizeof(ibuf->r));
@ -68,7 +70,8 @@ void imsg_init(struct imsgbuf *ibuf, int fd)
TAILQ_INIT(&ibuf->fds); TAILQ_INIT(&ibuf->fds);
} }
ssize_t imsg_read(struct imsgbuf *ibuf) ssize_t
imsg_read(struct imsgbuf *ibuf)
{ {
struct msghdr msg; struct msghdr msg;
struct cmsghdr *cmsg; struct cmsghdr *cmsg;
@ -96,14 +99,12 @@ ssize_t imsg_read(struct imsgbuf *ibuf)
again: again:
#ifdef __OpenBSD__ #ifdef __OpenBSD__
if (getdtablecount() + imsg_fd_overhead if (getdtablecount() + imsg_fd_overhead +
+ (int)((CMSG_SPACE(sizeof(int)) - CMSG_SPACE(0)) (int)((CMSG_SPACE(sizeof(int))-CMSG_SPACE(0))/sizeof(int))
/ sizeof(int))
>= getdtablesize()) { >= getdtablesize()) {
#else #else
if (available_fds(imsg_fd_overhead if (available_fds(imsg_fd_overhead +
+ (CMSG_SPACE(sizeof(int)) - CMSG_SPACE(0)) (CMSG_SPACE(sizeof(int))-CMSG_SPACE(0))/sizeof(int))) {
/ sizeof(int))) {
#endif #endif
errno = EAGAIN; errno = EAGAIN;
free(ifd); free(ifd);
@ -120,8 +121,8 @@ again:
for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL;
cmsg = CMSG_NXTHDR(&msg, cmsg)) { cmsg = CMSG_NXTHDR(&msg, cmsg)) {
if (cmsg->cmsg_level == SOL_SOCKET if (cmsg->cmsg_level == SOL_SOCKET &&
&& cmsg->cmsg_type == SCM_RIGHTS) { cmsg->cmsg_type == SCM_RIGHTS) {
int i; int i;
int j; int j;
@ -130,9 +131,8 @@ again:
* padding rules, our control buffer might contain * padding rules, our control buffer might contain
* more than one fd, and we must close them. * more than one fd, and we must close them.
*/ */
j = ((char *)cmsg + cmsg->cmsg_len j = ((char *)cmsg + cmsg->cmsg_len -
- (char *)CMSG_DATA(cmsg)) (char *)CMSG_DATA(cmsg)) / sizeof(int);
/ sizeof(int);
for (i = 0; i < j; i++) { for (i = 0; i < j; i++) {
fd = ((int *)CMSG_DATA(cmsg))[i]; fd = ((int *)CMSG_DATA(cmsg))[i];
if (ifd != NULL) { if (ifd != NULL) {
@ -152,7 +152,8 @@ fail:
return (n); return (n);
} }
ssize_t imsg_get(struct imsgbuf *ibuf, struct imsg *imsg) ssize_t
imsg_get(struct imsgbuf *ibuf, struct imsg *imsg)
{ {
size_t av, left, datalen; size_t av, left, datalen;
@ -162,7 +163,8 @@ ssize_t imsg_get(struct imsgbuf *ibuf, struct imsg *imsg)
return (0); return (0);
memcpy(&imsg->hdr, ibuf->r.buf, sizeof(imsg->hdr)); memcpy(&imsg->hdr, ibuf->r.buf, sizeof(imsg->hdr));
if (imsg->hdr.len < IMSG_HEADER_SIZE || imsg->hdr.len > MAX_IMSGSIZE) { if (imsg->hdr.len < IMSG_HEADER_SIZE ||
imsg->hdr.len > MAX_IMSGSIZE) {
errno = ERANGE; errno = ERANGE;
return (-1); return (-1);
} }
@ -193,7 +195,8 @@ ssize_t imsg_get(struct imsgbuf *ibuf, struct imsg *imsg)
return (datalen + IMSG_HEADER_SIZE); return (datalen + IMSG_HEADER_SIZE);
} }
int imsg_compose(struct imsgbuf *ibuf, u_int32_t type, u_int32_t peerid, int
imsg_compose(struct imsgbuf *ibuf, u_int32_t type, u_int32_t peerid,
pid_t pid, int fd, const void *data, u_int16_t datalen) pid_t pid, int fd, const void *data, u_int16_t datalen)
{ {
struct ibuf *wbuf; struct ibuf *wbuf;
@ -211,7 +214,8 @@ int imsg_compose(struct imsgbuf *ibuf, u_int32_t type, u_int32_t peerid,
return (1); return (1);
} }
int imsg_composev(struct imsgbuf *ibuf, u_int32_t type, u_int32_t peerid, int
imsg_composev(struct imsgbuf *ibuf, u_int32_t type, u_int32_t peerid,
pid_t pid, int fd, const struct iovec *iov, int iovcnt) pid_t pid, int fd, const struct iovec *iov, int iovcnt)
{ {
struct ibuf *wbuf; struct ibuf *wbuf;
@ -235,7 +239,8 @@ int imsg_composev(struct imsgbuf *ibuf, u_int32_t type, u_int32_t peerid,
} }
/* ARGSUSED */ /* ARGSUSED */
struct ibuf *imsg_create(struct imsgbuf *ibuf, u_int32_t type, u_int32_t peerid, struct ibuf *
imsg_create(struct imsgbuf *ibuf, u_int32_t type, u_int32_t peerid,
pid_t pid, u_int16_t datalen) pid_t pid, u_int16_t datalen)
{ {
struct ibuf *wbuf; struct ibuf *wbuf;
@ -261,7 +266,8 @@ struct ibuf *imsg_create(struct imsgbuf *ibuf, u_int32_t type, u_int32_t peerid,
return (wbuf); return (wbuf);
} }
int imsg_add(struct ibuf *msg, const void *data, u_int16_t datalen) int
imsg_add(struct ibuf *msg, const void *data, u_int16_t datalen)
{ {
if (datalen) if (datalen)
if (ibuf_add(msg, data, datalen) == -1) { if (ibuf_add(msg, data, datalen) == -1) {
@ -271,7 +277,8 @@ int imsg_add(struct ibuf *msg, const void *data, u_int16_t datalen)
return (datalen); return (datalen);
} }
void imsg_close(struct imsgbuf *ibuf, struct ibuf *msg) void
imsg_close(struct imsgbuf *ibuf, struct ibuf *msg)
{ {
struct imsg_hdr *hdr; struct imsg_hdr *hdr;
@ -286,12 +293,14 @@ void imsg_close(struct imsgbuf *ibuf, struct ibuf *msg)
ibuf_close(&ibuf->w, msg); ibuf_close(&ibuf->w, msg);
} }
void imsg_free(struct imsg *imsg) void
imsg_free(struct imsg *imsg)
{ {
free(imsg->data); free(imsg->data);
} }
int imsg_get_fd(struct imsgbuf *ibuf) int
imsg_get_fd(struct imsgbuf *ibuf)
{ {
int fd; int fd;
struct imsg_fd *ifd; struct imsg_fd *ifd;
@ -306,7 +315,8 @@ int imsg_get_fd(struct imsgbuf *ibuf)
return (fd); return (fd);
} }
int imsg_flush(struct imsgbuf *ibuf) int
imsg_flush(struct imsgbuf *ibuf)
{ {
while (ibuf->w.queued) while (ibuf->w.queued)
if (msgbuf_write(&ibuf->w) <= 0) if (msgbuf_write(&ibuf->w) <= 0)
@ -314,7 +324,8 @@ int imsg_flush(struct imsgbuf *ibuf)
return (0); return (0);
} }
void imsg_clear(struct imsgbuf *ibuf) void
imsg_clear(struct imsgbuf *ibuf)
{ {
int fd; int fd;

8
lib/imsg.h
View File

@ -97,10 +97,10 @@ void msgbuf_drain(struct msgbuf *, size_t);
void imsg_init(struct imsgbuf *, int); void imsg_init(struct imsgbuf *, int);
ssize_t imsg_read(struct imsgbuf *); ssize_t imsg_read(struct imsgbuf *);
ssize_t imsg_get(struct imsgbuf *, struct imsg *); ssize_t imsg_get(struct imsgbuf *, struct imsg *);
int imsg_compose(struct imsgbuf *, u_int32_t, u_int32_t, pid_t, int, int imsg_compose(struct imsgbuf *, u_int32_t, u_int32_t, pid_t,
const void *, u_int16_t); int, const void *, u_int16_t);
int imsg_composev(struct imsgbuf *, u_int32_t, u_int32_t, pid_t, int, int imsg_composev(struct imsgbuf *, u_int32_t, u_int32_t, pid_t,
const struct iovec *, int); int, const struct iovec *, int);
struct ibuf *imsg_create(struct imsgbuf *, u_int32_t, u_int32_t, pid_t, struct ibuf *imsg_create(struct imsgbuf *, u_int32_t, u_int32_t, pid_t,
u_int16_t); u_int16_t);
int imsg_add(struct ibuf *, const void *, u_int16_t); int imsg_add(struct ibuf *, const void *, u_int16_t);

144
lib/openbsd-tree.c
View File

@ -45,14 +45,16 @@
#include <lib/openbsd-tree.h> #include <lib/openbsd-tree.h>
static inline struct rb_entry *rb_n2e(const struct rb_type *t, void *node) static inline struct rb_entry *
rb_n2e(const struct rb_type *t, void *node)
{ {
unsigned long addr = (unsigned long)node; unsigned long addr = (unsigned long)node;
return ((struct rb_entry *)(addr + t->t_offset)); return ((struct rb_entry *)(addr + t->t_offset));
} }
static inline void *rb_e2n(const struct rb_type *t, struct rb_entry *rbe) static inline void *
rb_e2n(const struct rb_type *t, struct rb_entry *rbe)
{ {
unsigned long addr = (unsigned long)rbe; unsigned long addr = (unsigned long)rbe;
@ -66,33 +68,37 @@ static inline void *rb_e2n(const struct rb_type *t, struct rb_entry *rbe)
#define RBH_ROOT(_rbt) (_rbt)->rbt_root #define RBH_ROOT(_rbt) (_rbt)->rbt_root
static inline void rbe_set(struct rb_entry *rbe, struct rb_entry *parent) static inline void
rbe_set(struct rb_entry *rbe, struct rb_entry *parent)
{ {
RBE_PARENT(rbe) = parent; RBE_PARENT(rbe) = parent;
RBE_LEFT(rbe) = RBE_RIGHT(rbe) = NULL; RBE_LEFT(rbe) = RBE_RIGHT(rbe) = NULL;
RBE_COLOR(rbe) = RB_RED; RBE_COLOR(rbe) = RB_RED;
} }
static inline void rbe_set_blackred(struct rb_entry *black, static inline void
struct rb_entry *red) rbe_set_blackred(struct rb_entry *black, struct rb_entry *red)
{ {
RBE_COLOR(black) = RB_BLACK; RBE_COLOR(black) = RB_BLACK;
RBE_COLOR(red) = RB_RED; RBE_COLOR(red) = RB_RED;
} }
static inline void rbe_augment(const struct rb_type *t, struct rb_entry *rbe) static inline void
rbe_augment(const struct rb_type *t, struct rb_entry *rbe)
{ {
(*t->t_augment)(rb_e2n(t, rbe)); (*t->t_augment)(rb_e2n(t, rbe));
} }
static inline void rbe_if_augment(const struct rb_type *t, struct rb_entry *rbe) static inline void
rbe_if_augment(const struct rb_type *t, struct rb_entry *rbe)
{ {
if (t->t_augment != NULL) if (t->t_augment != NULL)
rbe_augment(t, rbe); rbe_augment(t, rbe);
} }
static inline void rbe_rotate_left(const struct rb_type *t, static inline void
struct rbt_tree *rbt, struct rb_entry *rbe) rbe_rotate_left(const struct rb_type *t, struct rbt_tree *rbt,
struct rb_entry *rbe)
{ {
struct rb_entry *parent; struct rb_entry *parent;
struct rb_entry *tmp; struct rb_entry *tmp;
@ -124,8 +130,9 @@ static inline void rbe_rotate_left(const struct rb_type *t,
} }
} }
static inline void rbe_rotate_right(const struct rb_type *t, static inline void
struct rbt_tree *rbt, struct rb_entry *rbe) rbe_rotate_right(const struct rb_type *t, struct rbt_tree *rbt,
struct rb_entry *rbe)
{ {
struct rb_entry *parent; struct rb_entry *parent;
struct rb_entry *tmp; struct rb_entry *tmp;
@ -157,13 +164,14 @@ static inline void rbe_rotate_right(const struct rb_type *t,
} }
} }
static inline void rbe_insert_color(const struct rb_type *t, static inline void
struct rbt_tree *rbt, struct rb_entry *rbe) rbe_insert_color(const struct rb_type *t, struct rbt_tree *rbt,
struct rb_entry *rbe)
{ {
struct rb_entry *parent, *gparent, *tmp; struct rb_entry *parent, *gparent, *tmp;
while ((parent = RBE_PARENT(rbe)) != NULL while ((parent = RBE_PARENT(rbe)) != NULL &&
&& RBE_COLOR(parent) == RB_RED) { RBE_COLOR(parent) == RB_RED) {
gparent = RBE_PARENT(parent); gparent = RBE_PARENT(parent);
if (parent == RBE_LEFT(gparent)) { if (parent == RBE_LEFT(gparent)) {
@ -208,10 +216,9 @@ static inline void rbe_insert_color(const struct rb_type *t,
RBE_COLOR(RBH_ROOT(rbt)) = RB_BLACK; RBE_COLOR(RBH_ROOT(rbt)) = RB_BLACK;
} }
static inline void rbe_remove_color(const struct rb_type *t, static inline void
struct rbt_tree *rbt, rbe_remove_color(const struct rb_type *t, struct rbt_tree *rbt,
struct rb_entry *parent, struct rb_entry *parent, struct rb_entry *rbe)
struct rb_entry *rbe)
{ {
struct rb_entry *tmp; struct rb_entry *tmp;
@ -219,8 +226,8 @@ static inline void rbe_remove_color(const struct rb_type *t,
if (parent == NULL) if (parent == NULL)
return; return;
while ((rbe == NULL || RBE_COLOR(rbe) == RB_BLACK) while ((rbe == NULL || RBE_COLOR(rbe) == RB_BLACK) &&
&& rbe != RBH_ROOT(rbt)) { rbe != RBH_ROOT(rbt)) {
if (RBE_LEFT(parent) == rbe) { if (RBE_LEFT(parent) == rbe) {
tmp = RBE_RIGHT(parent); tmp = RBE_RIGHT(parent);
if (RBE_COLOR(tmp) == RB_RED) { if (RBE_COLOR(tmp) == RB_RED) {
@ -228,16 +235,16 @@ static inline void rbe_remove_color(const struct rb_type *t,
rbe_rotate_left(t, rbt, parent); rbe_rotate_left(t, rbt, parent);
tmp = RBE_RIGHT(parent); tmp = RBE_RIGHT(parent);
} }
if ((RBE_LEFT(tmp) == NULL if ((RBE_LEFT(tmp) == NULL ||
|| RBE_COLOR(RBE_LEFT(tmp)) == RB_BLACK) RBE_COLOR(RBE_LEFT(tmp)) == RB_BLACK) &&
&& (RBE_RIGHT(tmp) == NULL (RBE_RIGHT(tmp) == NULL ||
|| RBE_COLOR(RBE_RIGHT(tmp)) == RB_BLACK)) { RBE_COLOR(RBE_RIGHT(tmp)) == RB_BLACK)) {
RBE_COLOR(tmp) = RB_RED; RBE_COLOR(tmp) = RB_RED;
rbe = parent; rbe = parent;
parent = RBE_PARENT(rbe); parent = RBE_PARENT(rbe);
} else { } else {
if (RBE_RIGHT(tmp) == NULL if (RBE_RIGHT(tmp) == NULL ||
|| RBE_COLOR(RBE_RIGHT(tmp)) == RB_BLACK) { RBE_COLOR(RBE_RIGHT(tmp)) == RB_BLACK) {
struct rb_entry *oleft; struct rb_entry *oleft;
oleft = RBE_LEFT(tmp); oleft = RBE_LEFT(tmp);
@ -266,16 +273,16 @@ static inline void rbe_remove_color(const struct rb_type *t,
tmp = RBE_LEFT(parent); tmp = RBE_LEFT(parent);
} }
if ((RBE_LEFT(tmp) == NULL if ((RBE_LEFT(tmp) == NULL ||
|| RBE_COLOR(RBE_LEFT(tmp)) == RB_BLACK) RBE_COLOR(RBE_LEFT(tmp)) == RB_BLACK) &&
&& (RBE_RIGHT(tmp) == NULL (RBE_RIGHT(tmp) == NULL ||
|| RBE_COLOR(RBE_RIGHT(tmp)) == RB_BLACK)) { RBE_COLOR(RBE_RIGHT(tmp)) == RB_BLACK)) {
RBE_COLOR(tmp) = RB_RED; RBE_COLOR(tmp) = RB_RED;
rbe = parent; rbe = parent;
parent = RBE_PARENT(rbe); parent = RBE_PARENT(rbe);
} else { } else {
if (RBE_LEFT(tmp) == NULL if (RBE_LEFT(tmp) == NULL ||
|| RBE_COLOR(RBE_LEFT(tmp)) == RB_BLACK) { RBE_COLOR(RBE_LEFT(tmp)) == RB_BLACK) {
struct rb_entry *oright; struct rb_entry *oright;
oright = RBE_RIGHT(tmp); oright = RBE_RIGHT(tmp);
@ -385,7 +392,8 @@ color:
return (old); return (old);
} }
void *_rb_remove(const struct rb_type *t, struct rbt_tree *rbt, void *elm) void *
_rb_remove(const struct rb_type *t, struct rbt_tree *rbt, void *elm)
{ {
struct rb_entry *rbe = rb_n2e(t, elm); struct rb_entry *rbe = rb_n2e(t, elm);
struct rb_entry *old; struct rb_entry *old;
@ -395,7 +403,8 @@ void *_rb_remove(const struct rb_type *t, struct rbt_tree *rbt, void *elm)
return (old == NULL ? NULL : rb_e2n(t, old)); return (old == NULL ? NULL : rb_e2n(t, old));
} }
void *_rb_insert(const struct rb_type *t, struct rbt_tree *rbt, void *elm) void *
_rb_insert(const struct rb_type *t, struct rbt_tree *rbt, void *elm)
{ {
struct rb_entry *rbe = rb_n2e(t, elm); struct rb_entry *rbe = rb_n2e(t, elm);
struct rb_entry *tmp; struct rb_entry *tmp;
@ -435,7 +444,8 @@ void *_rb_insert(const struct rb_type *t, struct rbt_tree *rbt, void *elm)
} }
/* Finds the node with the same key as elm */ /* Finds the node with the same key as elm */
void *_rb_find(const struct rb_type *t, struct rbt_tree *rbt, const void *key) void *
_rb_find(const struct rb_type *t, struct rbt_tree *rbt, const void *key)
{ {
struct rb_entry *tmp = RBH_ROOT(rbt); struct rb_entry *tmp = RBH_ROOT(rbt);
void *node; void *node;
@ -456,7 +466,8 @@ void *_rb_find(const struct rb_type *t, struct rbt_tree *rbt, const void *key)
} }
/* Finds the first node greater than or equal to the search key */ /* Finds the first node greater than or equal to the search key */
void *_rb_nfind(const struct rb_type *t, struct rbt_tree *rbt, const void *key) void *
_rb_nfind(const struct rb_type *t, struct rbt_tree *rbt, const void *key)
{ {
struct rb_entry *tmp = RBH_ROOT(rbt); struct rb_entry *tmp = RBH_ROOT(rbt);
void *node; void *node;
@ -478,7 +489,8 @@ void *_rb_nfind(const struct rb_type *t, struct rbt_tree *rbt, const void *key)
return (res); return (res);
} }
void *_rb_next(const struct rb_type *t, void *elm) void *
_rb_next(const struct rb_type *t, void *elm)
{ {
struct rb_entry *rbe = rb_n2e(t, elm); struct rb_entry *rbe = rb_n2e(t, elm);
@ -487,11 +499,12 @@ void *_rb_next(const struct rb_type *t, void *elm)
while (RBE_LEFT(rbe) != NULL) while (RBE_LEFT(rbe) != NULL)
rbe = RBE_LEFT(rbe); rbe = RBE_LEFT(rbe);
} else { } else {
if (RBE_PARENT(rbe) && (rbe == RBE_LEFT(RBE_PARENT(rbe)))) if (RBE_PARENT(rbe) &&
(rbe == RBE_LEFT(RBE_PARENT(rbe))))
rbe = RBE_PARENT(rbe); rbe = RBE_PARENT(rbe);
else { else {
while (RBE_PARENT(rbe) while (RBE_PARENT(rbe) &&
&& (rbe == RBE_RIGHT(RBE_PARENT(rbe)))) (rbe == RBE_RIGHT(RBE_PARENT(rbe))))
rbe = RBE_PARENT(rbe); rbe = RBE_PARENT(rbe);
rbe = RBE_PARENT(rbe); rbe = RBE_PARENT(rbe);
} }
@ -500,7 +513,8 @@ void *_rb_next(const struct rb_type *t, void *elm)
return (rbe == NULL ? NULL : rb_e2n(t, rbe)); return (rbe == NULL ? NULL : rb_e2n(t, rbe));
} }
void *_rb_prev(const struct rb_type *t, void *elm) void *
_rb_prev(const struct rb_type *t, void *elm)
{ {
struct rb_entry *rbe = rb_n2e(t, elm); struct rb_entry *rbe = rb_n2e(t, elm);
@ -509,11 +523,12 @@ void *_rb_prev(const struct rb_type *t, void *elm)
while (RBE_RIGHT(rbe)) while (RBE_RIGHT(rbe))
rbe = RBE_RIGHT(rbe); rbe = RBE_RIGHT(rbe);
} else { } else {
if (RBE_PARENT(rbe) && (rbe == RBE_RIGHT(RBE_PARENT(rbe)))) if (RBE_PARENT(rbe) &&
(rbe == RBE_RIGHT(RBE_PARENT(rbe))))
rbe = RBE_PARENT(rbe); rbe = RBE_PARENT(rbe);
else { else {
while (RBE_PARENT(rbe) while (RBE_PARENT(rbe) &&
&& (rbe == RBE_LEFT(RBE_PARENT(rbe)))) (rbe == RBE_LEFT(RBE_PARENT(rbe))))
rbe = RBE_PARENT(rbe); rbe = RBE_PARENT(rbe);
rbe = RBE_PARENT(rbe); rbe = RBE_PARENT(rbe);
} }
@ -522,14 +537,16 @@ void *_rb_prev(const struct rb_type *t, void *elm)
return (rbe == NULL ? NULL : rb_e2n(t, rbe)); return (rbe == NULL ? NULL : rb_e2n(t, rbe));
} }
void *_rb_root(const struct rb_type *t, struct rbt_tree *rbt) void *
_rb_root(const struct rb_type *t, struct rbt_tree *rbt)
{ {
struct rb_entry *rbe = RBH_ROOT(rbt); struct rb_entry *rbe = RBH_ROOT(rbt);
return (rbe == NULL ? rbe : rb_e2n(t, rbe)); return (rbe == NULL ? rbe : rb_e2n(t, rbe));
} }
void *_rb_min(const struct rb_type *t, struct rbt_tree *rbt) void *
_rb_min(const struct rb_type *t, struct rbt_tree *rbt)
{ {
struct rb_entry *rbe = RBH_ROOT(rbt); struct rb_entry *rbe = RBH_ROOT(rbt);
struct rb_entry *parent = NULL; struct rb_entry *parent = NULL;
@ -542,7 +559,8 @@ void *_rb_min(const struct rb_type *t, struct rbt_tree *rbt)
return (parent == NULL ? NULL : rb_e2n(t, parent)); return (parent == NULL ? NULL : rb_e2n(t, parent));
} }
void *_rb_max(const struct rb_type *t, struct rbt_tree *rbt) void *
_rb_max(const struct rb_type *t, struct rbt_tree *rbt)
{ {
struct rb_entry *rbe = RBH_ROOT(rbt); struct rb_entry *rbe = RBH_ROOT(rbt);
struct rb_entry *parent = NULL; struct rb_entry *parent = NULL;
@ -555,28 +573,32 @@ void *_rb_max(const struct rb_type *t, struct rbt_tree *rbt)
return (parent == NULL ? NULL : rb_e2n(t, parent)); return (parent == NULL ? NULL : rb_e2n(t, parent));
} }
void *_rb_left(const struct rb_type *t, void *node) void *
_rb_left(const struct rb_type *t, void *node)
{ {
struct rb_entry *rbe = rb_n2e(t, node); struct rb_entry *rbe = rb_n2e(t, node);
rbe = RBE_LEFT(rbe); rbe = RBE_LEFT(rbe);
return (rbe == NULL ? NULL : rb_e2n(t, rbe)); return (rbe == NULL ? NULL : rb_e2n(t, rbe));
} }
void *_rb_right(const struct rb_type *t, void *node) void *
_rb_right(const struct rb_type *t, void *node)
{ {
struct rb_entry *rbe = rb_n2e(t, node); struct rb_entry *rbe = rb_n2e(t, node);
rbe = RBE_RIGHT(rbe); rbe = RBE_RIGHT(rbe);
return (rbe == NULL ? NULL : rb_e2n(t, rbe)); return (rbe == NULL ? NULL : rb_e2n(t, rbe));
} }
void *_rb_parent(const struct rb_type *t, void *node) void *
_rb_parent(const struct rb_type *t, void *node)
{ {
struct rb_entry *rbe = rb_n2e(t, node); struct rb_entry *rbe = rb_n2e(t, node);
rbe = RBE_PARENT(rbe); rbe = RBE_PARENT(rbe);
return (rbe == NULL ? NULL : rb_e2n(t, rbe)); return (rbe == NULL ? NULL : rb_e2n(t, rbe));
} }
void _rb_set_left(const struct rb_type *t, void *node, void *left) void
_rb_set_left(const struct rb_type *t, void *node, void *left)
{ {
struct rb_entry *rbe = rb_n2e(t, node); struct rb_entry *rbe = rb_n2e(t, node);
struct rb_entry *rbl = (left == NULL) ? NULL : rb_n2e(t, left); struct rb_entry *rbl = (left == NULL) ? NULL : rb_n2e(t, left);
@ -584,7 +606,8 @@ void _rb_set_left(const struct rb_type *t, void *node, void *left)
RBE_LEFT(rbe) = rbl; RBE_LEFT(rbe) = rbl;
} }
void _rb_set_right(const struct rb_type *t, void *node, void *right) void
_rb_set_right(const struct rb_type *t, void *node, void *right)
{ {
struct rb_entry *rbe = rb_n2e(t, node); struct rb_entry *rbe = rb_n2e(t, node);
struct rb_entry *rbr = (right == NULL) ? NULL : rb_n2e(t, right); struct rb_entry *rbr = (right == NULL) ? NULL : rb_n2e(t, right);
@ -592,7 +615,8 @@ void _rb_set_right(const struct rb_type *t, void *node, void *right)
RBE_RIGHT(rbe) = rbr; RBE_RIGHT(rbe) = rbr;
} }
void _rb_set_parent(const struct rb_type *t, void *node, void *parent) void
_rb_set_parent(const struct rb_type *t, void *node, void *parent)
{ {
struct rb_entry *rbe = rb_n2e(t, node); struct rb_entry *rbe = rb_n2e(t, node);
struct rb_entry *rbp = (parent == NULL) ? NULL : rb_n2e(t, parent); struct rb_entry *rbp = (parent == NULL) ? NULL : rb_n2e(t, parent);
@ -600,7 +624,8 @@ void _rb_set_parent(const struct rb_type *t, void *node, void *parent)
RBE_PARENT(rbe) = rbp; RBE_PARENT(rbe) = rbp;
} }
void _rb_poison(const struct rb_type *t, void *node, unsigned long poison) void
_rb_poison(const struct rb_type *t, void *node, unsigned long poison)
{ {
struct rb_entry *rbe = rb_n2e(t, node); struct rb_entry *rbe = rb_n2e(t, node);
@ -608,11 +633,12 @@ void _rb_poison(const struct rb_type *t, void *node, unsigned long poison)
(struct rb_entry *)poison; (struct rb_entry *)poison;
} }
int _rb_check(const struct rb_type *t, void *node, unsigned long poison) int
_rb_check(const struct rb_type *t, void *node, unsigned long poison)
{ {
struct rb_entry *rbe = rb_n2e(t, node); struct rb_entry *rbe = rb_n2e(t, node);
return ((unsigned long)RBE_PARENT(rbe) == poison return ((unsigned long)RBE_PARENT(rbe) == poison &&
&& (unsigned long)RBE_LEFT(rbe) == poison (unsigned long)RBE_LEFT(rbe) == poison &&
&& (unsigned long)RBE_RIGHT(rbe) == poison); (unsigned long)RBE_RIGHT(rbe) == poison);
} }

213
lib/openbsd-tree.h
View File

@ -60,12 +60,9 @@
} }
#define SPLAY_INITIALIZER(root) \ #define SPLAY_INITIALIZER(root) \
{ \ { NULL }
NULL \
}
#define SPLAY_INIT(root) \ #define SPLAY_INIT(root) do { \
do { \
(root)->sph_root = NULL; \ (root)->sph_root = NULL; \
} while (0) } while (0)
@ -81,44 +78,35 @@
#define SPLAY_EMPTY(head) (SPLAY_ROOT(head) == NULL) #define SPLAY_EMPTY(head) (SPLAY_ROOT(head) == NULL)
/* SPLAY_ROTATE_{LEFT,RIGHT} expect that tmp hold SPLAY_{RIGHT,LEFT} */ /* SPLAY_ROTATE_{LEFT,RIGHT} expect that tmp hold SPLAY_{RIGHT,LEFT} */
#define SPLAY_ROTATE_RIGHT(head, tmp, field) \ #define SPLAY_ROTATE_RIGHT(head, tmp, field) do { \
do { \
SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(tmp, field); \ SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(tmp, field); \
SPLAY_RIGHT(tmp, field) = (head)->sph_root; \ SPLAY_RIGHT(tmp, field) = (head)->sph_root; \
(head)->sph_root = tmp; \ (head)->sph_root = tmp; \
} while (0) } while (0)
#define SPLAY_ROTATE_LEFT(head, tmp, field) \ #define SPLAY_ROTATE_LEFT(head, tmp, field) do { \
do { \
SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(tmp, field); \ SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(tmp, field); \
SPLAY_LEFT(tmp, field) = (head)->sph_root; \ SPLAY_LEFT(tmp, field) = (head)->sph_root; \
(head)->sph_root = tmp; \ (head)->sph_root = tmp; \
} while (0) } while (0)
#define SPLAY_LINKLEFT(head, tmp, field) \ #define SPLAY_LINKLEFT(head, tmp, field) do { \
do { \
SPLAY_LEFT(tmp, field) = (head)->sph_root; \ SPLAY_LEFT(tmp, field) = (head)->sph_root; \
tmp = (head)->sph_root; \ tmp = (head)->sph_root; \
(head)->sph_root = SPLAY_LEFT((head)->sph_root, field); \ (head)->sph_root = SPLAY_LEFT((head)->sph_root, field); \
} while (0) } while (0)
#define SPLAY_LINKRIGHT(head, tmp, field) \ #define SPLAY_LINKRIGHT(head, tmp, field) do { \
do { \
SPLAY_RIGHT(tmp, field) = (head)->sph_root; \ SPLAY_RIGHT(tmp, field) = (head)->sph_root; \
tmp = (head)->sph_root; \ tmp = (head)->sph_root; \
(head)->sph_root = SPLAY_RIGHT((head)->sph_root, field); \ (head)->sph_root = SPLAY_RIGHT((head)->sph_root, field); \
} while (0) } while (0)
#define SPLAY_ASSEMBLE(head, node, left, right, field) \ #define SPLAY_ASSEMBLE(head, node, left, right, field) do { \
do { \ SPLAY_RIGHT(left, field) = SPLAY_LEFT((head)->sph_root, field); \
SPLAY_RIGHT(left, field) = \ SPLAY_LEFT(right, field) = SPLAY_RIGHT((head)->sph_root, field);\
SPLAY_LEFT((head)->sph_root, field); \ SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(node, field); \
SPLAY_LEFT(right, field) = \ SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(node, field); \
SPLAY_RIGHT((head)->sph_root, field); \
SPLAY_LEFT((head)->sph_root, field) = \
SPLAY_RIGHT(node, field); \
SPLAY_RIGHT((head)->sph_root, field) = \
SPLAY_LEFT(node, field); \
} while (0) } while (0)
/* Generates prototypes and inline functions */ /* Generates prototypes and inline functions */
@ -130,8 +118,8 @@
struct type *name##_SPLAY_REMOVE(struct name *, struct type *); \ struct type *name##_SPLAY_REMOVE(struct name *, struct type *); \
\ \
/* Finds the node with the same key as elm */ \ /* Finds the node with the same key as elm */ \
static __inline struct type *name##_SPLAY_FIND(struct name *head, \ static __inline struct type * \
struct type *elm) \ name##_SPLAY_FIND(struct name *head, struct type *elm) \
{ \ { \
if (SPLAY_EMPTY(head)) \ if (SPLAY_EMPTY(head)) \
return(NULL); \ return(NULL); \
@ -141,8 +129,8 @@
return (NULL); \ return (NULL); \
} \ } \
\ \
static __inline struct type *name##_SPLAY_NEXT(struct name *head, \ static __inline struct type * \
struct type *elm) \ name##_SPLAY_NEXT(struct name *head, struct type *elm) \
{ \ { \
name##_SPLAY(head, elm); \ name##_SPLAY(head, elm); \
if (SPLAY_RIGHT(elm, field) != NULL) { \ if (SPLAY_RIGHT(elm, field) != NULL) { \
@ -155,8 +143,8 @@
return (elm); \ return (elm); \
} \ } \
\ \
static __inline struct type *name##_SPLAY_MIN_MAX(struct name *head, \ static __inline struct type * \
int val) \ name##_SPLAY_MIN_MAX(struct name *head, int val) \
{ \ { \
name##_SPLAY_MINMAX(head, val); \ name##_SPLAY_MINMAX(head, val); \
return (SPLAY_ROOT(head)); \ return (SPLAY_ROOT(head)); \
@ -166,23 +154,21 @@
* Moves node close to the key of elm to top * Moves node close to the key of elm to top
*/ */
#define SPLAY_GENERATE(name, type, field, cmp) \ #define SPLAY_GENERATE(name, type, field, cmp) \
struct type *name##_SPLAY_INSERT(struct name *head, struct type *elm) \ struct type * \
name##_SPLAY_INSERT(struct name *head, struct type *elm) \
{ \ { \
if (SPLAY_EMPTY(head)) { \ if (SPLAY_EMPTY(head)) { \
SPLAY_LEFT(elm, field) = SPLAY_RIGHT(elm, field) = \ SPLAY_LEFT(elm, field) = SPLAY_RIGHT(elm, field) = NULL; \
NULL; \
} else { \ } else { \
int __comp; \ int __comp; \
name##_SPLAY(head, elm); \ name##_SPLAY(head, elm); \
__comp = (cmp)(elm, (head)->sph_root); \ __comp = (cmp)(elm, (head)->sph_root); \
if(__comp < 0) { \ if(__comp < 0) { \
SPLAY_LEFT(elm, field) = \ SPLAY_LEFT(elm, field) = SPLAY_LEFT((head)->sph_root, field);\
SPLAY_LEFT((head)->sph_root, field); \
SPLAY_RIGHT(elm, field) = (head)->sph_root; \ SPLAY_RIGHT(elm, field) = (head)->sph_root; \
SPLAY_LEFT((head)->sph_root, field) = NULL; \ SPLAY_LEFT((head)->sph_root, field) = NULL; \
} else if (__comp > 0) { \ } else if (__comp > 0) { \
SPLAY_RIGHT(elm, field) = \ SPLAY_RIGHT(elm, field) = SPLAY_RIGHT((head)->sph_root, field);\
SPLAY_RIGHT((head)->sph_root, field); \
SPLAY_LEFT(elm, field) = (head)->sph_root; \ SPLAY_LEFT(elm, field) = (head)->sph_root; \
SPLAY_RIGHT((head)->sph_root, field) = NULL; \ SPLAY_RIGHT((head)->sph_root, field) = NULL; \
} else \ } else \
@ -192,7 +178,8 @@
return (NULL); \ return (NULL); \
} \ } \
\ \
struct type *name##_SPLAY_REMOVE(struct name *head, struct type *elm) \ struct type * \
name##_SPLAY_REMOVE(struct name *head, struct type *elm) \
{ \ { \
struct type *__tmp; \ struct type *__tmp; \
if (SPLAY_EMPTY(head)) \ if (SPLAY_EMPTY(head)) \
@ -200,12 +187,10 @@
name##_SPLAY(head, elm); \ name##_SPLAY(head, elm); \
if ((cmp)(elm, (head)->sph_root) == 0) { \ if ((cmp)(elm, (head)->sph_root) == 0) { \
if (SPLAY_LEFT((head)->sph_root, field) == NULL) { \ if (SPLAY_LEFT((head)->sph_root, field) == NULL) { \
(head)->sph_root = \ (head)->sph_root = SPLAY_RIGHT((head)->sph_root, field);\
SPLAY_RIGHT((head)->sph_root, field); \
} else { \ } else { \
__tmp = SPLAY_RIGHT((head)->sph_root, field); \ __tmp = SPLAY_RIGHT((head)->sph_root, field); \
(head)->sph_root = \ (head)->sph_root = SPLAY_LEFT((head)->sph_root, field);\
SPLAY_LEFT((head)->sph_root, field); \
name##_SPLAY(head, elm); \ name##_SPLAY(head, elm); \
SPLAY_RIGHT((head)->sph_root, field) = __tmp; \ SPLAY_RIGHT((head)->sph_root, field) = __tmp; \
} \ } \
@ -214,13 +199,13 @@
return (NULL); \ return (NULL); \
} \ } \
\ \
void name##_SPLAY(struct name *head, struct type *elm) \ void \
name##_SPLAY(struct name *head, struct type *elm) \
{ \ { \
struct type __node, *__left, *__right, *__tmp; \ struct type __node, *__left, *__right, *__tmp; \
int __comp; \ int __comp; \
\ \
SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = \ SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = NULL;\
NULL; \
__left = __right = &__node; \ __left = __right = &__node; \
\ \
while ((__comp = (cmp)(elm, (head)->sph_root))) { \ while ((__comp = (cmp)(elm, (head)->sph_root))) { \
@ -229,11 +214,8 @@
if (__tmp == NULL) \ if (__tmp == NULL) \
break; \ break; \
if ((cmp)(elm, __tmp) < 0){ \ if ((cmp)(elm, __tmp) < 0){ \
SPLAY_ROTATE_RIGHT(head, __tmp, \ SPLAY_ROTATE_RIGHT(head, __tmp, field); \
field); \ if (SPLAY_LEFT((head)->sph_root, field) == NULL)\
if (SPLAY_LEFT((head)->sph_root, \
field) \
== NULL) \
break; \ break; \
} \ } \
SPLAY_LINKLEFT(head, __right, field); \ SPLAY_LINKLEFT(head, __right, field); \
@ -243,9 +225,7 @@
break; \ break; \
if ((cmp)(elm, __tmp) > 0){ \ if ((cmp)(elm, __tmp) > 0){ \
SPLAY_ROTATE_LEFT(head, __tmp, field); \ SPLAY_ROTATE_LEFT(head, __tmp, field); \
if (SPLAY_RIGHT((head)->sph_root, \ if (SPLAY_RIGHT((head)->sph_root, field) == NULL)\
field) \
== NULL) \
break; \ break; \
} \ } \
SPLAY_LINKRIGHT(head, __left, field); \ SPLAY_LINKRIGHT(head, __left, field); \
@ -261,8 +241,7 @@
{ \ { \
struct type __node, *__left, *__right, *__tmp; \ struct type __node, *__left, *__right, *__tmp; \
\ \
SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = \ SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = NULL;\
NULL; \
__left = __right = &__node; \ __left = __right = &__node; \
\ \
while (1) { \ while (1) { \
@ -271,11 +250,8 @@
if (__tmp == NULL) \ if (__tmp == NULL) \
break; \ break; \
if (__comp < 0){ \ if (__comp < 0){ \
SPLAY_ROTATE_RIGHT(head, __tmp, \ SPLAY_ROTATE_RIGHT(head, __tmp, field); \
field); \ if (SPLAY_LEFT((head)->sph_root, field) == NULL)\
if (SPLAY_LEFT((head)->sph_root, \
field) \
== NULL) \
break; \ break; \
} \ } \
SPLAY_LINKLEFT(head, __right, field); \ SPLAY_LINKLEFT(head, __right, field); \
@ -285,9 +261,7 @@
break; \ break; \
if (__comp > 0) { \ if (__comp > 0) { \
SPLAY_ROTATE_LEFT(head, __tmp, field); \ SPLAY_ROTATE_LEFT(head, __tmp, field); \
if (SPLAY_RIGHT((head)->sph_root, \ if (SPLAY_RIGHT((head)->sph_root, field) == NULL)\
field) \
== NULL) \
break; \ break; \
} \ } \
SPLAY_LINKRIGHT(head, __left, field); \ SPLAY_LINKRIGHT(head, __left, field); \
@ -303,13 +277,14 @@
#define SPLAY_REMOVE(name, x, y) name##_SPLAY_REMOVE(x, y) #define SPLAY_REMOVE(name, x, y) name##_SPLAY_REMOVE(x, y)
#define SPLAY_FIND(name, x, y) name##_SPLAY_FIND(x, y) #define SPLAY_FIND(name, x, y) name##_SPLAY_FIND(x, y)
#define SPLAY_NEXT(name, x, y) name##_SPLAY_NEXT(x, y) #define SPLAY_NEXT(name, x, y) name##_SPLAY_NEXT(x, y)
#define SPLAY_MIN(name, x) \ #define SPLAY_MIN(name, x) (SPLAY_EMPTY(x) ? NULL \
(SPLAY_EMPTY(x) ? NULL : name##_SPLAY_MIN_MAX(x, SPLAY_NEGINF)) : name##_SPLAY_MIN_MAX(x, SPLAY_NEGINF))
#define SPLAY_MAX(name, x) \ #define SPLAY_MAX(name, x) (SPLAY_EMPTY(x) ? NULL \
(SPLAY_EMPTY(x) ? NULL : name##_SPLAY_MIN_MAX(x, SPLAY_INF)) : name##_SPLAY_MIN_MAX(x, SPLAY_INF))
#define SPLAY_FOREACH(x, name, head) \ #define SPLAY_FOREACH(x, name, head) \
for ((x) = SPLAY_MIN(name, head); (x) != NULL; \ for ((x) = SPLAY_MIN(name, head); \
(x) != NULL; \
(x) = SPLAY_NEXT(name, head, x)) (x) = SPLAY_NEXT(name, head, x))
/* /*
@ -355,12 +330,14 @@ struct rb_entry {
#define RB_ENTRY(_type) struct rb_entry #define RB_ENTRY(_type) struct rb_entry
static inline void _rb_init(struct rbt_tree *rbt) static inline void
_rb_init(struct rbt_tree *rbt)
{ {
rbt->rbt_root = NULL; rbt->rbt_root = NULL;
} }
static inline int _rb_empty(struct rbt_tree *rbt) static inline int
_rb_empty(struct rbt_tree *rbt)
{ {
return (rbt->rbt_root == NULL); return (rbt->rbt_root == NULL);
} }
@ -388,133 +365,137 @@ int _rb_check(const struct rb_type *, void *, unsigned long);
#define RB_PROTOTYPE(_name, _type, _field, _cmp) \ #define RB_PROTOTYPE(_name, _type, _field, _cmp) \
extern const struct rb_type *const _name##_RB_TYPE; \ extern const struct rb_type *const _name##_RB_TYPE; \
\ \
__attribute__((__unused__)) static inline void _name##_RB_INIT( \ __attribute__((__unused__)) static inline void \
struct _name *head) \ _name##_RB_INIT(struct _name *head) \
{ \ { \
_rb_init(&head->rbh_root); \ _rb_init(&head->rbh_root); \
} \ } \
\ \
__attribute__((__unused__)) static inline struct _type \ __attribute__((__unused__)) static inline struct _type * \
*_name##_RB_INSERT(struct _name *head, struct _type *elm) \ _name##_RB_INSERT(struct _name *head, struct _type *elm) \
{ \ { \
return _rb_insert(_name##_RB_TYPE, &head->rbh_root, elm); \ return _rb_insert(_name##_RB_TYPE, &head->rbh_root, elm); \
} \ } \
\ \
__attribute__((__unused__)) static inline struct _type \ __attribute__((__unused__)) static inline struct _type * \
*_name##_RB_REMOVE(struct _name *head, struct _type *elm) \ _name##_RB_REMOVE(struct _name *head, struct _type *elm) \
{ \ { \
return _rb_remove(_name##_RB_TYPE, &head->rbh_root, elm); \ return _rb_remove(_name##_RB_TYPE, &head->rbh_root, elm); \
} \ } \
\ \
__attribute__((__unused__)) static inline struct _type \ __attribute__((__unused__)) static inline struct _type * \
*_name##_RB_FIND(struct _name *head, const struct _type *key) \ _name##_RB_FIND(struct _name *head, const struct _type *key) \
{ \ { \
return _rb_find(_name##_RB_TYPE, &head->rbh_root, key); \ return _rb_find(_name##_RB_TYPE, &head->rbh_root, key); \
} \ } \
\ \
__attribute__((__unused__)) static inline struct _type \ __attribute__((__unused__)) static inline struct _type * \
*_name##_RB_NFIND(struct _name *head, const struct _type *key) \ _name##_RB_NFIND(struct _name *head, const struct _type *key) \
{ \ { \
return _rb_nfind(_name##_RB_TYPE, &head->rbh_root, key); \ return _rb_nfind(_name##_RB_TYPE, &head->rbh_root, key); \
} \ } \
\ \
__attribute__((__unused__)) static inline struct _type \ __attribute__((__unused__)) static inline struct _type * \
*_name##_RB_ROOT(struct _name *head) \ _name##_RB_ROOT(struct _name *head) \
{ \ { \
return _rb_root(_name##_RB_TYPE, &head->rbh_root); \ return _rb_root(_name##_RB_TYPE, &head->rbh_root); \
} \ } \
\ \
__attribute__((__unused__)) static inline int _name##_RB_EMPTY( \ __attribute__((__unused__)) static inline int \
struct _name *head) \ _name##_RB_EMPTY(struct _name *head) \
{ \ { \
return _rb_empty(&head->rbh_root); \ return _rb_empty(&head->rbh_root); \
} \ } \
\ \
__attribute__((__unused__)) static inline struct _type \ __attribute__((__unused__)) static inline struct _type * \
*_name##_RB_MIN(struct _name *head) \ _name##_RB_MIN(struct _name *head) \
{ \ { \
return _rb_min(_name##_RB_TYPE, &head->rbh_root); \ return _rb_min(_name##_RB_TYPE, &head->rbh_root); \
} \ } \
\ \
__attribute__((__unused__)) static inline struct _type \ __attribute__((__unused__)) static inline struct _type * \
*_name##_RB_MAX(struct _name *head) \ _name##_RB_MAX(struct _name *head) \
{ \ { \
return _rb_max(_name##_RB_TYPE, &head->rbh_root); \ return _rb_max(_name##_RB_TYPE, &head->rbh_root); \
} \ } \
\ \
__attribute__((__unused__)) static inline struct _type \ __attribute__((__unused__)) static inline struct _type * \
*_name##_RB_NEXT(struct _type *elm) \ _name##_RB_NEXT(struct _type *elm) \
{ \ { \
return _rb_next(_name##_RB_TYPE, elm); \ return _rb_next(_name##_RB_TYPE, elm); \
} \ } \
\ \
__attribute__((__unused__)) static inline struct _type \ __attribute__((__unused__)) static inline struct _type * \
*_name##_RB_PREV(struct _type *elm) \ _name##_RB_PREV(struct _type *elm) \
{ \ { \
return _rb_prev(_name##_RB_TYPE, elm); \ return _rb_prev(_name##_RB_TYPE, elm); \
} \ } \
\ \
__attribute__((__unused__)) static inline struct _type \ __attribute__((__unused__)) static inline struct _type * \
*_name##_RB_LEFT(struct _type *elm) \ _name##_RB_LEFT(struct _type *elm) \
{ \ { \
return _rb_left(_name##_RB_TYPE, elm); \ return _rb_left(_name##_RB_TYPE, elm); \
} \ } \
\ \
__attribute__((__unused__)) static inline struct _type \ __attribute__((__unused__)) static inline struct _type * \
*_name##_RB_RIGHT(struct _type *elm) \ _name##_RB_RIGHT(struct _type *elm) \
{ \ { \
return _rb_right(_name##_RB_TYPE, elm); \ return _rb_right(_name##_RB_TYPE, elm); \
} \ } \
\ \
__attribute__((__unused__)) static inline struct _type \ __attribute__((__unused__)) static inline struct _type * \
*_name##_RB_PARENT(struct _type *elm) \ _name##_RB_PARENT(struct _type *elm) \
{ \ { \
return _rb_parent(_name##_RB_TYPE, elm); \ return _rb_parent(_name##_RB_TYPE, elm); \
} \ } \
\ \
__attribute__((__unused__)) static inline void _name##_RB_SET_LEFT( \ __attribute__((__unused__)) static inline void \
struct _type *elm, struct _type *left) \ _name##_RB_SET_LEFT(struct _type *elm, struct _type *left) \
{ \ { \
return _rb_set_left(_name##_RB_TYPE, elm, left); \ return _rb_set_left(_name##_RB_TYPE, elm, left); \
} \ } \
\ \
__attribute__((__unused__)) static inline void _name##_RB_SET_RIGHT( \ __attribute__((__unused__)) static inline void \
struct _type *elm, struct _type *right) \ _name##_RB_SET_RIGHT(struct _type *elm, struct _type *right) \
{ \ { \
return _rb_set_right(_name##_RB_TYPE, elm, right); \ return _rb_set_right(_name##_RB_TYPE, elm, right); \
} \ } \
\ \
__attribute__((__unused__)) static inline void _name##_RB_SET_PARENT( \ __attribute__((__unused__)) static inline void \
struct _type *elm, struct _type *parent) \ _name##_RB_SET_PARENT(struct _type *elm, struct _type *parent) \
{ \ { \
return _rb_set_parent(_name##_RB_TYPE, elm, parent); \ return _rb_set_parent(_name##_RB_TYPE, elm, parent); \
} \ } \
\ \
__attribute__((__unused__)) static inline void _name##_RB_POISON( \ __attribute__((__unused__)) static inline void \
struct _type *elm, unsigned long poison) \ _name##_RB_POISON(struct _type *elm, unsigned long poison) \
{ \ { \
return _rb_poison(_name##_RB_TYPE, elm, poison); \ return _rb_poison(_name##_RB_TYPE, elm, poison); \
} \ } \
\ \
__attribute__((__unused__)) static inline int _name##_RB_CHECK( \ __attribute__((__unused__)) static inline int \
struct _type *elm, unsigned long poison) \ _name##_RB_CHECK(struct _type *elm, unsigned long poison) \
{ \ { \
return _rb_check(_name##_RB_TYPE, elm, poison); \ return _rb_check(_name##_RB_TYPE, elm, poison); \
} }
#define RB_GENERATE_INTERNAL(_name, _type, _field, _cmp, _aug) \ #define RB_GENERATE_INTERNAL(_name, _type, _field, _cmp, _aug) \
static int _name##_RB_COMPARE(const void *lptr, const void *rptr) \ static int \
_name##_RB_COMPARE(const void *lptr, const void *rptr) \
{ \ { \
const struct _type *l = lptr, *r = rptr; \ const struct _type *l = lptr, *r = rptr; \
return _cmp(l, r); \ return _cmp(l, r); \
} \ } \
static const struct rb_type _name##_RB_INFO = { \ static const struct rb_type _name##_RB_INFO = { \
_name##_RB_COMPARE, _aug, offsetof(struct _type, _field), \ _name##_RB_COMPARE, \
_aug, \
offsetof(struct _type, _field), \
}; \ }; \
const struct rb_type *const _name##_RB_TYPE = &_name##_RB_INFO; const struct rb_type *const _name##_RB_TYPE = &_name##_RB_INFO;
#define RB_GENERATE_AUGMENT(_name, _type, _field, _cmp, _aug) \ #define RB_GENERATE_AUGMENT(_name, _type, _field, _cmp, _aug) \
static void _name##_RB_AUGMENT(void *ptr) \ static void \
_name##_RB_AUGMENT(void *ptr) \
{ \ { \
struct _type *p = ptr; \ struct _type *p = ptr; \
return _aug(p); \ return _aug(p); \
@ -545,19 +526,23 @@ int _rb_check(const struct rb_type *, void *, unsigned long);
#define RB_CHECK(_name, _elm, _p) _name##_RB_CHECK(_elm, _p) #define RB_CHECK(_name, _elm, _p) _name##_RB_CHECK(_elm, _p)
#define RB_FOREACH(_e, _name, _head) \ #define RB_FOREACH(_e, _name, _head) \
for ((_e) = RB_MIN(_name, (_head)); (_e) != NULL; \ for ((_e) = RB_MIN(_name, (_head)); \
(_e) != NULL; \
(_e) = RB_NEXT(_name, (_e))) (_e) = RB_NEXT(_name, (_e)))
#define RB_FOREACH_SAFE(_e, _name, _head, _n) \ #define RB_FOREACH_SAFE(_e, _name, _head, _n) \
for ((_e) = RB_MIN(_name, (_head)); \ for ((_e) = RB_MIN(_name, (_head)); \
(_e) != NULL && ((_n) = RB_NEXT(_name, (_e)), 1); (_e) = (_n)) (_e) != NULL && ((_n) = RB_NEXT(_name, (_e)), 1); \
(_e) = (_n))
#define RB_FOREACH_REVERSE(_e, _name, _head) \ #define RB_FOREACH_REVERSE(_e, _name, _head) \
for ((_e) = RB_MAX(_name, (_head)); (_e) != NULL; \ for ((_e) = RB_MAX(_name, (_head)); \
(_e) != NULL; \
(_e) = RB_PREV(_name, (_e))) (_e) = RB_PREV(_name, (_e)))
#define RB_FOREACH_REVERSE_SAFE(_e, _name, _head, _n) \ #define RB_FOREACH_REVERSE_SAFE(_e, _name, _head, _n) \
for ((_e) = RB_MAX(_name, (_head)); \ for ((_e) = RB_MAX(_name, (_head)); \
(_e) != NULL && ((_n) = RB_PREV(_name, (_e)), 1); (_e) = (_n)) (_e) != NULL && ((_n) = RB_PREV(_name, (_e)), 1); \
(_e) = (_n))
#endif /* _SYS_TREE_H_ */ #endif /* _SYS_TREE_H_ */