[master] 08d8a294a Rename VRB_ -> VRBT_ for red/black tree macros
Nils Goroll
nils.goroll at uplex.de
Mon Nov 5 17:04:11 UTC 2018
commit 08d8a294a8970def12fa044cfb074ce59306f8b3
Author: Nils Goroll <nils.goroll at uplex.de>
Date: Mon Nov 5 17:47:24 2018 +0100
Rename VRB_ -> VRBT_ for red/black tree macros
sed 's:VRB_:VRBT_:g' -i "$FILES_CHANGED[@]"
Closes #2812
diff --git a/bin/varnishtop/flint.lnt b/bin/varnishtop/flint.lnt
index 696ce2d6f..20b82091e 100644
--- a/bin/varnishtop/flint.lnt
+++ b/bin/varnishtop/flint.lnt
@@ -8,8 +8,8 @@
-e732 // Loss of sign (arg. no. 2) (int to unsigned
-e713 // Loss of precision (assignment) (unsigned long long to long long)
--sem(t_order_VRB_INSERT, custodial(2))
--sem(t_key_VRB_INSERT, custodial(2))
+-sem(t_order_VRBT_INSERT, custodial(2))
+-sem(t_key_VRBT_INSERT, custodial(2))
///////////////////////////////////////////////////////////////////////
// Varnishstat specific
diff --git a/bin/varnishtop/varnishtop.c b/bin/varnishtop/varnishtop.c
index afe0dad92..2d72eadfe 100644
--- a/bin/varnishtop/varnishtop.c
+++ b/bin/varnishtop/varnishtop.c
@@ -70,8 +70,8 @@ struct top {
char *rec_buf;
int clen;
unsigned hash;
- VRB_ENTRY(top) e_order;
- VRB_ENTRY(top) e_key;
+ VRBT_ENTRY(top) e_order;
+ VRBT_ENTRY(top) e_key;
double count;
};
@@ -85,8 +85,8 @@ static const char *ident;
static volatile sig_atomic_t quit = 0;
-static VRB_HEAD(t_order, top) h_order = VRB_INITIALIZER(&h_order);
-static VRB_HEAD(t_key, top) h_key = VRB_INITIALIZER(&h_key);
+static VRBT_HEAD(t_order, top) h_order = VRBT_INITIALIZER(&h_order);
+static VRBT_HEAD(t_key, top) h_key = VRBT_INITIALIZER(&h_key);
static inline int
cmp_key(const struct top *a, const struct top *b)
@@ -110,10 +110,10 @@ cmp_order(const struct top *a, const struct top *b)
return (cmp_key(a, b));
}
-VRB_PROTOTYPE_STATIC(t_order, top, e_order, cmp_order)
-VRB_GENERATE_STATIC(t_order, top, e_order, cmp_order)
-VRB_PROTOTYPE_STATIC(t_key, top, e_key, cmp_key)
-VRB_GENERATE_STATIC(t_key, top, e_key, cmp_key)
+VRBT_PROTOTYPE_STATIC(t_order, top, e_order, cmp_order)
+VRBT_GENERATE_STATIC(t_order, top, e_order, cmp_order)
+VRBT_PROTOTYPE_STATIC(t_key, top, e_key, cmp_key)
+VRBT_GENERATE_STATIC(t_key, top, e_key, cmp_key)
static int v_matchproto_(VSLQ_dispatch_f)
accumulate(struct VSL_data *vsl, struct VSL_transaction * const pt[],
@@ -155,12 +155,12 @@ accumulate(struct VSL_data *vsl, struct VSL_transaction * const pt[],
t.rec_data = VSL_CDATA(tr->c->rec.ptr);
AZ(pthread_mutex_lock(&mtx));
- tp = VRB_FIND(t_key, &h_key, &t);
+ tp = VRBT_FIND(t_key, &h_key, &t);
if (tp) {
- VRB_REMOVE(t_order, &h_order, tp);
+ VRBT_REMOVE(t_order, &h_order, tp);
tp->count += 1.0;
/* Reinsert to rebalance */
- VRB_INSERT(t_order, &h_order, tp);
+ VRBT_INSERT(t_order, &h_order, tp);
} else {
ntop++;
tp = calloc(1, sizeof *tp);
@@ -172,8 +172,8 @@ accumulate(struct VSL_data *vsl, struct VSL_transaction * const pt[],
tp->rec_buf = strdup(t.rec_data);
tp->rec_data = tp->rec_buf;
AN(tp->rec_data);
- VRB_INSERT(t_key, &h_key, tp);
- VRB_INSERT(t_order, &h_order, tp);
+ VRBT_INSERT(t_key, &h_key, tp);
+ VRBT_INSERT(t_order, &h_order, tp);
}
AZ(pthread_mutex_unlock(&mtx));
@@ -226,8 +226,8 @@ update(int p)
else
AC(mvprintw(0, len - 1, "%s", q));
AC(mvprintw(0, 0, "list length %u", ntop));
- for (tp = VRB_MIN(t_order, &h_order); tp != NULL; tp = tp2) {
- tp2 = VRB_NEXT(t_order, &h_order, tp);
+ for (tp = VRBT_MIN(t_order, &h_order); tp != NULL; tp = tp2) {
+ tp2 = VRBT_NEXT(t_order, &h_order, tp);
if (++l < LINES) {
len = tp->clen;
@@ -243,8 +243,8 @@ update(int p)
continue;
tp->count += (1.0/3.0 - tp->count) / (double)n;
if (tp->count * 10 < t || l > LINES * 10) {
- VRB_REMOVE(t_key, &h_key, tp);
- VRB_REMOVE(t_order, &h_order, tp);
+ VRBT_REMOVE(t_key, &h_key, tp);
+ VRBT_REMOVE(t_order, &h_order, tp);
free(tp->rec_buf);
free(tp);
ntop--;
@@ -316,8 +316,8 @@ static void
dump(void)
{
struct top *tp, *tp2;
- for (tp = VRB_MIN(t_order, &h_order); tp != NULL; tp = tp2) {
- tp2 = VRB_NEXT(t_order, &h_order, tp);
+ for (tp = VRBT_MIN(t_order, &h_order); tp != NULL; tp = tp2) {
+ tp2 = VRBT_NEXT(t_order, &h_order, tp);
printf("%9.2f %s %*.*s\n",
tp->count, VSL_tags[tp->tag],
tp->clen, tp->clen, tp->rec_data);
diff --git a/flint.lnt b/flint.lnt
index 0a9d6e9f0..7c7736d3d 100644
--- a/flint.lnt
+++ b/flint.lnt
@@ -142,9 +142,9 @@
///////////////////////////////////////////////////////////////////////
// <vtree.h>
--emacro(801, VRB_*) // goto considered bad
--esym(534, *_VRB_REMOVE) // ignore retval
--esym(534, *_VRB_INSERT) // ignore retval
+-emacro(801, VRBT_*) // goto considered bad
+-esym(534, *_VRBT_REMOVE) // ignore retval
+-esym(534, *_VRBT_INSERT) // ignore retval
///////////////////////////////////////////////////////////////////////
// <vqueue.h>
diff --git a/include/vtree.h b/include/vtree.h
index 649e8221d..064ce00b4 100644
--- a/include/vtree.h
+++ b/include/vtree.h
@@ -291,21 +291,21 @@ void name##_VSPLAY_MINMAX(struct name *head, int __comp) \
(x) = VSPLAY_NEXT(name, head, x))
/* Macros that define a red-black tree */
-#define VRB_HEAD(name, type) \
+#define VRBT_HEAD(name, type) \
struct name { \
struct type *rbh_root; /* root of the tree */ \
}
-#define VRB_INITIALIZER(root) \
+#define VRBT_INITIALIZER(root) \
{ NULL }
-#define VRB_INIT(root) do { \
+#define VRBT_INIT(root) do { \
(root)->rbh_root = NULL; \
} while (/*CONSTCOND*/ 0)
-#define VRB_BLACK 0
-#define VRB_RED 1
-#define VRB_ENTRY(type) \
+#define VRBT_BLACK 0
+#define VRBT_RED 1
+#define VRBT_ENTRY(type) \
struct { \
struct type *rbe_left; /* left element */ \
struct type *rbe_right; /* right element */ \
@@ -313,328 +313,328 @@ struct { \
int rbe_color; /* node color */ \
}
-#define VRB_LEFT(elm, field) (elm)->field.rbe_left
-#define VRB_RIGHT(elm, field) (elm)->field.rbe_right
-#define VRB_PARENT(elm, field) (elm)->field.rbe_parent
-#define VRB_COLOR(elm, field) (elm)->field.rbe_color
-#define VRB_ROOT(head) (head)->rbh_root
-#define VRB_EMPTY(head) (VRB_ROOT(head) == NULL)
-
-#define VRB_SET(elm, parent, field) do { \
- VRB_PARENT(elm, field) = parent; \
- VRB_LEFT(elm, field) = VRB_RIGHT(elm, field) = NULL; \
- VRB_COLOR(elm, field) = VRB_RED; \
+#define VRBT_LEFT(elm, field) (elm)->field.rbe_left
+#define VRBT_RIGHT(elm, field) (elm)->field.rbe_right
+#define VRBT_PARENT(elm, field) (elm)->field.rbe_parent
+#define VRBT_COLOR(elm, field) (elm)->field.rbe_color
+#define VRBT_ROOT(head) (head)->rbh_root
+#define VRBT_EMPTY(head) (VRBT_ROOT(head) == NULL)
+
+#define VRBT_SET(elm, parent, field) do { \
+ VRBT_PARENT(elm, field) = parent; \
+ VRBT_LEFT(elm, field) = VRBT_RIGHT(elm, field) = NULL; \
+ VRBT_COLOR(elm, field) = VRBT_RED; \
} while (/*CONSTCOND*/ 0)
-#define VRB_SET_BLACKRED(black, red, field) do { \
- VRB_COLOR(black, field) = VRB_BLACK; \
- VRB_COLOR(red, field) = VRB_RED; \
+#define VRBT_SET_BLACKRED(black, red, field) do { \
+ VRBT_COLOR(black, field) = VRBT_BLACK; \
+ VRBT_COLOR(red, field) = VRBT_RED; \
} while (/*CONSTCOND*/ 0)
-#ifndef VRB_AUGMENT
-#define VRB_AUGMENT(x) do {} while (0)
+#ifndef VRBT_AUGMENT
+#define VRBT_AUGMENT(x) do {} while (0)
#endif
-#define VRB_ROTATE_LEFT(head, elm, tmp, field) do { \
- (tmp) = VRB_RIGHT(elm, field); \
- if ((VRB_RIGHT(elm, field) = VRB_LEFT(tmp, field)) != NULL) { \
- VRB_PARENT(VRB_LEFT(tmp, field), field) = (elm); \
+#define VRBT_ROTATE_LEFT(head, elm, tmp, field) do { \
+ (tmp) = VRBT_RIGHT(elm, field); \
+ if ((VRBT_RIGHT(elm, field) = VRBT_LEFT(tmp, field)) != NULL) { \
+ VRBT_PARENT(VRBT_LEFT(tmp, field), field) = (elm); \
} \
- VRB_AUGMENT(elm); \
- if ((VRB_PARENT(tmp, field) = VRB_PARENT(elm, field)) != NULL) {\
- if ((elm) == VRB_LEFT(VRB_PARENT(elm, field), field)) \
- VRB_LEFT(VRB_PARENT(elm, field), field) = (tmp);\
+ VRBT_AUGMENT(elm); \
+ if ((VRBT_PARENT(tmp, field) = VRBT_PARENT(elm, field)) != NULL) {\
+ if ((elm) == VRBT_LEFT(VRBT_PARENT(elm, field), field)) \
+ VRBT_LEFT(VRBT_PARENT(elm, field), field) = (tmp);\
else \
- VRB_RIGHT(VRB_PARENT(elm, field), field) = (tmp);\
+ VRBT_RIGHT(VRBT_PARENT(elm, field), field) = (tmp);\
} else \
(head)->rbh_root = (tmp); \
- VRB_LEFT(tmp, field) = (elm); \
- VRB_PARENT(elm, field) = (tmp); \
- VRB_AUGMENT(tmp); \
- if ((VRB_PARENT(tmp, field))) \
- VRB_AUGMENT(VRB_PARENT(tmp, field)); \
+ VRBT_LEFT(tmp, field) = (elm); \
+ VRBT_PARENT(elm, field) = (tmp); \
+ VRBT_AUGMENT(tmp); \
+ if ((VRBT_PARENT(tmp, field))) \
+ VRBT_AUGMENT(VRBT_PARENT(tmp, field)); \
} while (/*CONSTCOND*/ 0)
-#define VRB_ROTATE_RIGHT(head, elm, tmp, field) do { \
- (tmp) = VRB_LEFT(elm, field); \
- if ((VRB_LEFT(elm, field) = VRB_RIGHT(tmp, field)) != NULL) { \
- VRB_PARENT(VRB_RIGHT(tmp, field), field) = (elm); \
+#define VRBT_ROTATE_RIGHT(head, elm, tmp, field) do { \
+ (tmp) = VRBT_LEFT(elm, field); \
+ if ((VRBT_LEFT(elm, field) = VRBT_RIGHT(tmp, field)) != NULL) { \
+ VRBT_PARENT(VRBT_RIGHT(tmp, field), field) = (elm); \
} \
- VRB_AUGMENT(elm); \
- if ((VRB_PARENT(tmp, field) = VRB_PARENT(elm, field)) != NULL) {\
- if ((elm) == VRB_LEFT(VRB_PARENT(elm, field), field)) \
- VRB_LEFT(VRB_PARENT(elm, field), field) = (tmp);\
+ VRBT_AUGMENT(elm); \
+ if ((VRBT_PARENT(tmp, field) = VRBT_PARENT(elm, field)) != NULL) {\
+ if ((elm) == VRBT_LEFT(VRBT_PARENT(elm, field), field)) \
+ VRBT_LEFT(VRBT_PARENT(elm, field), field) = (tmp);\
else \
- VRB_RIGHT(VRB_PARENT(elm, field), field) = (tmp);\
+ VRBT_RIGHT(VRBT_PARENT(elm, field), field) = (tmp);\
} else \
(head)->rbh_root = (tmp); \
- VRB_RIGHT(tmp, field) = (elm); \
- VRB_PARENT(elm, field) = (tmp); \
- VRB_AUGMENT(tmp); \
- if ((VRB_PARENT(tmp, field))) \
- VRB_AUGMENT(VRB_PARENT(tmp, field)); \
+ VRBT_RIGHT(tmp, field) = (elm); \
+ VRBT_PARENT(elm, field) = (tmp); \
+ VRBT_AUGMENT(tmp); \
+ if ((VRBT_PARENT(tmp, field))) \
+ VRBT_AUGMENT(VRBT_PARENT(tmp, field)); \
} while (/*CONSTCOND*/ 0)
/* Generates prototypes and inline functions */
-#define VRB_PROTOTYPE(name, type, field, cmp) \
- VRB_PROTOTYPE_INTERNAL(name, type, field, cmp,)
-#define VRB_PROTOTYPE_STATIC(name, type, field, cmp) \
- VRB_PROTOTYPE_INTERNAL(name, type, field, cmp, v_unused_ static)
-#define VRB_PROTOTYPE_INTERNAL(name, type, field, cmp, attr) \
-/*lint -esym(528, name##_VRB_*) */ \
-attr void name##_VRB_INSERT_COLOR(struct name *, struct type *); \
-attr void name##_VRB_REMOVE_COLOR(struct name *, struct type *, struct type *);\
-attr struct type *name##_VRB_REMOVE(struct name *, struct type *); \
-attr struct type *name##_VRB_INSERT(struct name *, struct type *); \
-attr struct type *name##_VRB_FIND(const struct name *, const struct type *); \
-attr struct type *name##_VRB_NFIND(const struct name *, const struct type *); \
-attr struct type *name##_VRB_NEXT(struct type *); \
-attr struct type *name##_VRB_PREV(struct type *); \
-attr struct type *name##_VRB_MINMAX(const struct name *, int); \
+#define VRBT_PROTOTYPE(name, type, field, cmp) \
+ VRBT_PROTOTYPE_INTERNAL(name, type, field, cmp,)
+#define VRBT_PROTOTYPE_STATIC(name, type, field, cmp) \
+ VRBT_PROTOTYPE_INTERNAL(name, type, field, cmp, v_unused_ static)
+#define VRBT_PROTOTYPE_INTERNAL(name, type, field, cmp, attr) \
+/*lint -esym(528, name##_VRBT_*) */ \
+attr void name##_VRBT_INSERT_COLOR(struct name *, struct type *); \
+attr void name##_VRBT_REMOVE_COLOR(struct name *, struct type *, struct type *);\
+attr struct type *name##_VRBT_REMOVE(struct name *, struct type *); \
+attr struct type *name##_VRBT_INSERT(struct name *, struct type *); \
+attr struct type *name##_VRBT_FIND(const struct name *, const struct type *); \
+attr struct type *name##_VRBT_NFIND(const struct name *, const struct type *); \
+attr struct type *name##_VRBT_NEXT(struct type *); \
+attr struct type *name##_VRBT_PREV(struct type *); \
+attr struct type *name##_VRBT_MINMAX(const struct name *, int); \
\
/* Main rb operation.
* Moves node close to the key of elm to top
*/
-#define VRB_GENERATE(name, type, field, cmp) \
- VRB_GENERATE_INTERNAL(name, type, field, cmp,)
-#define VRB_GENERATE_STATIC(name, type, field, cmp) \
- VRB_GENERATE_INTERNAL(name, type, field, cmp, v_unused_ static)
-#define VRB_GENERATE_INTERNAL(name, type, field, cmp, attr) \
+#define VRBT_GENERATE(name, type, field, cmp) \
+ VRBT_GENERATE_INTERNAL(name, type, field, cmp,)
+#define VRBT_GENERATE_STATIC(name, type, field, cmp) \
+ VRBT_GENERATE_INTERNAL(name, type, field, cmp, v_unused_ static)
+#define VRBT_GENERATE_INTERNAL(name, type, field, cmp, attr) \
attr void \
-name##_VRB_INSERT_COLOR(struct name *head, struct type *elm) \
+name##_VRBT_INSERT_COLOR(struct name *head, struct type *elm) \
{ \
struct type *parent, *gparent, *tmp; \
- while ((parent = VRB_PARENT(elm, field)) != NULL && \
- VRB_COLOR(parent, field) == VRB_RED) { \
- gparent = VRB_PARENT(parent, field); \
- if (parent == VRB_LEFT(gparent, field)) { \
- tmp = VRB_RIGHT(gparent, field); \
- if (tmp && VRB_COLOR(tmp, field) == VRB_RED) { \
- VRB_COLOR(tmp, field) = VRB_BLACK; \
- VRB_SET_BLACKRED(parent, gparent, field);\
+ while ((parent = VRBT_PARENT(elm, field)) != NULL && \
+ VRBT_COLOR(parent, field) == VRBT_RED) { \
+ gparent = VRBT_PARENT(parent, field); \
+ if (parent == VRBT_LEFT(gparent, field)) { \
+ tmp = VRBT_RIGHT(gparent, field); \
+ if (tmp && VRBT_COLOR(tmp, field) == VRBT_RED) { \
+ VRBT_COLOR(tmp, field) = VRBT_BLACK; \
+ VRBT_SET_BLACKRED(parent, gparent, field);\
elm = gparent; \
continue; \
} \
- if (VRB_RIGHT(parent, field) == elm) { \
- VRB_ROTATE_LEFT(head, parent, tmp, field);\
+ if (VRBT_RIGHT(parent, field) == elm) { \
+ VRBT_ROTATE_LEFT(head, parent, tmp, field);\
tmp = parent; \
parent = elm; \
elm = tmp; \
} \
- VRB_SET_BLACKRED(parent, gparent, field); \
- VRB_ROTATE_RIGHT(head, gparent, tmp, field); \
+ VRBT_SET_BLACKRED(parent, gparent, field); \
+ VRBT_ROTATE_RIGHT(head, gparent, tmp, field); \
} else { \
- tmp = VRB_LEFT(gparent, field); \
- if (tmp && VRB_COLOR(tmp, field) == VRB_RED) { \
- VRB_COLOR(tmp, field) = VRB_BLACK; \
- VRB_SET_BLACKRED(parent, gparent, field);\
+ tmp = VRBT_LEFT(gparent, field); \
+ if (tmp && VRBT_COLOR(tmp, field) == VRBT_RED) { \
+ VRBT_COLOR(tmp, field) = VRBT_BLACK; \
+ VRBT_SET_BLACKRED(parent, gparent, field);\
elm = gparent; \
continue; \
} \
- if (VRB_LEFT(parent, field) == elm) { \
- VRB_ROTATE_RIGHT(head, parent, tmp, field);\
+ if (VRBT_LEFT(parent, field) == elm) { \
+ VRBT_ROTATE_RIGHT(head, parent, tmp, field);\
tmp = parent; \
parent = elm; \
elm = tmp; \
} \
- VRB_SET_BLACKRED(parent, gparent, field); \
- VRB_ROTATE_LEFT(head, gparent, tmp, field); \
+ VRBT_SET_BLACKRED(parent, gparent, field); \
+ VRBT_ROTATE_LEFT(head, gparent, tmp, field); \
} \
} \
- VRB_COLOR(head->rbh_root, field) = VRB_BLACK; \
+ VRBT_COLOR(head->rbh_root, field) = VRBT_BLACK; \
} \
\
attr void \
-name##_VRB_REMOVE_COLOR(struct name *head, struct type *parent, struct type *elm) \
+name##_VRBT_REMOVE_COLOR(struct name *head, struct type *parent, struct type *elm) \
{ \
struct type *tmp; \
- while ((elm == NULL || VRB_COLOR(elm, field) == VRB_BLACK) && \
- elm != VRB_ROOT(head)) { \
+ while ((elm == NULL || VRBT_COLOR(elm, field) == VRBT_BLACK) && \
+ elm != VRBT_ROOT(head)) { \
AN(parent); \
- if (VRB_LEFT(parent, field) == elm) { \
- tmp = VRB_RIGHT(parent, field); \
- if (VRB_COLOR(tmp, field) == VRB_RED) { \
- VRB_SET_BLACKRED(tmp, parent, field); \
- VRB_ROTATE_LEFT(head, parent, tmp, field);\
- tmp = VRB_RIGHT(parent, field); \
+ if (VRBT_LEFT(parent, field) == elm) { \
+ tmp = VRBT_RIGHT(parent, field); \
+ if (VRBT_COLOR(tmp, field) == VRBT_RED) { \
+ VRBT_SET_BLACKRED(tmp, parent, field); \
+ VRBT_ROTATE_LEFT(head, parent, tmp, field);\
+ tmp = VRBT_RIGHT(parent, field); \
} \
- if ((VRB_LEFT(tmp, field) == NULL || \
- VRB_COLOR(VRB_LEFT(tmp, field), field) == VRB_BLACK) &&\
- (VRB_RIGHT(tmp, field) == NULL || \
- VRB_COLOR(VRB_RIGHT(tmp, field), field) == VRB_BLACK)) {\
- VRB_COLOR(tmp, field) = VRB_RED; \
+ if ((VRBT_LEFT(tmp, field) == NULL || \
+ VRBT_COLOR(VRBT_LEFT(tmp, field), field) == VRBT_BLACK) &&\
+ (VRBT_RIGHT(tmp, field) == NULL || \
+ VRBT_COLOR(VRBT_RIGHT(tmp, field), field) == VRBT_BLACK)) {\
+ VRBT_COLOR(tmp, field) = VRBT_RED; \
elm = parent; \
- parent = VRB_PARENT(elm, field); \
+ parent = VRBT_PARENT(elm, field); \
} else { \
- if (VRB_RIGHT(tmp, field) == NULL || \
- VRB_COLOR(VRB_RIGHT(tmp, field), field) == VRB_BLACK) {\
+ if (VRBT_RIGHT(tmp, field) == NULL || \
+ VRBT_COLOR(VRBT_RIGHT(tmp, field), field) == VRBT_BLACK) {\
struct type *oleft; \
- if ((oleft = VRB_LEFT(tmp, field)) \
+ if ((oleft = VRBT_LEFT(tmp, field)) \
!= NULL) \
- VRB_COLOR(oleft, field) = VRB_BLACK;\
- VRB_COLOR(tmp, field) = VRB_RED;\
- VRB_ROTATE_RIGHT(head, tmp, oleft, field);\
- tmp = VRB_RIGHT(parent, field); \
+ VRBT_COLOR(oleft, field) = VRBT_BLACK;\
+ VRBT_COLOR(tmp, field) = VRBT_RED;\
+ VRBT_ROTATE_RIGHT(head, tmp, oleft, field);\
+ tmp = VRBT_RIGHT(parent, field); \
} \
- VRB_COLOR(tmp, field) = VRB_COLOR(parent, field);\
- VRB_COLOR(parent, field) = VRB_BLACK; \
- if (VRB_RIGHT(tmp, field)) \
- VRB_COLOR(VRB_RIGHT(tmp, field), field) = VRB_BLACK;\
- VRB_ROTATE_LEFT(head, parent, tmp, field);\
- elm = VRB_ROOT(head); \
+ VRBT_COLOR(tmp, field) = VRBT_COLOR(parent, field);\
+ VRBT_COLOR(parent, field) = VRBT_BLACK; \
+ if (VRBT_RIGHT(tmp, field)) \
+ VRBT_COLOR(VRBT_RIGHT(tmp, field), field) = VRBT_BLACK;\
+ VRBT_ROTATE_LEFT(head, parent, tmp, field);\
+ elm = VRBT_ROOT(head); \
break; \
} \
} else { \
- tmp = VRB_LEFT(parent, field); \
- if (VRB_COLOR(tmp, field) == VRB_RED) { \
- VRB_SET_BLACKRED(tmp, parent, field); \
- VRB_ROTATE_RIGHT(head, parent, tmp, field);\
- tmp = VRB_LEFT(parent, field); \
+ tmp = VRBT_LEFT(parent, field); \
+ if (VRBT_COLOR(tmp, field) == VRBT_RED) { \
+ VRBT_SET_BLACKRED(tmp, parent, field); \
+ VRBT_ROTATE_RIGHT(head, parent, tmp, field);\
+ tmp = VRBT_LEFT(parent, field); \
} \
- if ((VRB_LEFT(tmp, field) == NULL || \
- VRB_COLOR(VRB_LEFT(tmp, field), field) == VRB_BLACK) &&\
- (VRB_RIGHT(tmp, field) == NULL || \
- VRB_COLOR(VRB_RIGHT(tmp, field), field) == VRB_BLACK)) {\
- VRB_COLOR(tmp, field) = VRB_RED; \
+ if ((VRBT_LEFT(tmp, field) == NULL || \
+ VRBT_COLOR(VRBT_LEFT(tmp, field), field) == VRBT_BLACK) &&\
+ (VRBT_RIGHT(tmp, field) == NULL || \
+ VRBT_COLOR(VRBT_RIGHT(tmp, field), field) == VRBT_BLACK)) {\
+ VRBT_COLOR(tmp, field) = VRBT_RED; \
elm = parent; \
- parent = VRB_PARENT(elm, field); \
+ parent = VRBT_PARENT(elm, field); \
} else { \
- if (VRB_LEFT(tmp, field) == NULL || \
- VRB_COLOR(VRB_LEFT(tmp, field), field) == VRB_BLACK) {\
+ if (VRBT_LEFT(tmp, field) == NULL || \
+ VRBT_COLOR(VRBT_LEFT(tmp, field), field) == VRBT_BLACK) {\
struct type *oright; \
- if ((oright = VRB_RIGHT(tmp, field)) \
+ if ((oright = VRBT_RIGHT(tmp, field)) \
!= NULL) \
- VRB_COLOR(oright, field) = VRB_BLACK;\
- VRB_COLOR(tmp, field) = VRB_RED;\
- VRB_ROTATE_LEFT(head, tmp, oright, field);\
- tmp = VRB_LEFT(parent, field); \
+ VRBT_COLOR(oright, field) = VRBT_BLACK;\
+ VRBT_COLOR(tmp, field) = VRBT_RED;\
+ VRBT_ROTATE_LEFT(head, tmp, oright, field);\
+ tmp = VRBT_LEFT(parent, field); \
} \
- VRB_COLOR(tmp, field) = VRB_COLOR(parent, field);\
- VRB_COLOR(parent, field) = VRB_BLACK; \
- if (VRB_LEFT(tmp, field)) \
- VRB_COLOR(VRB_LEFT(tmp, field), field) = VRB_BLACK;\
- VRB_ROTATE_RIGHT(head, parent, tmp, field);\
- elm = VRB_ROOT(head); \
+ VRBT_COLOR(tmp, field) = VRBT_COLOR(parent, field);\
+ VRBT_COLOR(parent, field) = VRBT_BLACK; \
+ if (VRBT_LEFT(tmp, field)) \
+ VRBT_COLOR(VRBT_LEFT(tmp, field), field) = VRBT_BLACK;\
+ VRBT_ROTATE_RIGHT(head, parent, tmp, field);\
+ elm = VRBT_ROOT(head); \
break; \
} \
} \
} \
if (elm) \
- VRB_COLOR(elm, field) = VRB_BLACK; \
+ VRBT_COLOR(elm, field) = VRBT_BLACK; \
} \
\
attr struct type * \
-name##_VRB_REMOVE(struct name *head, struct type *elm) \
+name##_VRBT_REMOVE(struct name *head, struct type *elm) \
{ \
struct type *child, *parent, *old = elm; \
int color; \
- if (VRB_LEFT(elm, field) == NULL) \
- child = VRB_RIGHT(elm, field); \
- else if (VRB_RIGHT(elm, field) == NULL) \
- child = VRB_LEFT(elm, field); \
+ if (VRBT_LEFT(elm, field) == NULL) \
+ child = VRBT_RIGHT(elm, field); \
+ else if (VRBT_RIGHT(elm, field) == NULL) \
+ child = VRBT_LEFT(elm, field); \
else { \
struct type *left; \
- elm = VRB_RIGHT(elm, field); \
- while ((left = VRB_LEFT(elm, field)) != NULL) \
+ elm = VRBT_RIGHT(elm, field); \
+ while ((left = VRBT_LEFT(elm, field)) != NULL) \
elm = left; \
- child = VRB_RIGHT(elm, field); \
- parent = VRB_PARENT(elm, field); \
- color = VRB_COLOR(elm, field); \
+ child = VRBT_RIGHT(elm, field); \
+ parent = VRBT_PARENT(elm, field); \
+ color = VRBT_COLOR(elm, field); \
if (child) \
- VRB_PARENT(child, field) = parent; \
+ VRBT_PARENT(child, field) = parent; \
if (parent) { \
- if (VRB_LEFT(parent, field) == elm) \
- VRB_LEFT(parent, field) = child; \
+ if (VRBT_LEFT(parent, field) == elm) \
+ VRBT_LEFT(parent, field) = child; \
else \
- VRB_RIGHT(parent, field) = child; \
- VRB_AUGMENT(parent); \
+ VRBT_RIGHT(parent, field) = child; \
+ VRBT_AUGMENT(parent); \
} else \
- VRB_ROOT(head) = child; \
- if (VRB_PARENT(elm, field) == old) \
+ VRBT_ROOT(head) = child; \
+ if (VRBT_PARENT(elm, field) == old) \
parent = elm; \
(elm)->field = (old)->field; \
- if (VRB_PARENT(old, field)) { \
- if (VRB_LEFT(VRB_PARENT(old, field), field) == old)\
- VRB_LEFT(VRB_PARENT(old, field), field) = elm;\
+ if (VRBT_PARENT(old, field)) { \
+ if (VRBT_LEFT(VRBT_PARENT(old, field), field) == old)\
+ VRBT_LEFT(VRBT_PARENT(old, field), field) = elm;\
else \
- VRB_RIGHT(VRB_PARENT(old, field), field) = elm;\
- VRB_AUGMENT(VRB_PARENT(old, field)); \
+ VRBT_RIGHT(VRBT_PARENT(old, field), field) = elm;\
+ VRBT_AUGMENT(VRBT_PARENT(old, field)); \
} else \
- VRB_ROOT(head) = elm; \
- VRB_PARENT(VRB_LEFT(old, field), field) = elm; \
- if (VRB_RIGHT(old, field)) \
- VRB_PARENT(VRB_RIGHT(old, field), field) = elm; \
+ VRBT_ROOT(head) = elm; \
+ VRBT_PARENT(VRBT_LEFT(old, field), field) = elm; \
+ if (VRBT_RIGHT(old, field)) \
+ VRBT_PARENT(VRBT_RIGHT(old, field), field) = elm; \
if (parent) { \
left = parent; \
do { \
- VRB_AUGMENT(left); \
- } while ((left = VRB_PARENT(left, field)) != NULL); \
+ VRBT_AUGMENT(left); \
+ } while ((left = VRBT_PARENT(left, field)) != NULL); \
} \
goto color; \
} \
- parent = VRB_PARENT(elm, field); \
- color = VRB_COLOR(elm, field); \
+ parent = VRBT_PARENT(elm, field); \
+ color = VRBT_COLOR(elm, field); \
if (child) \
- VRB_PARENT(child, field) = parent; \
+ VRBT_PARENT(child, field) = parent; \
if (parent) { \
- if (VRB_LEFT(parent, field) == elm) \
- VRB_LEFT(parent, field) = child; \
+ if (VRBT_LEFT(parent, field) == elm) \
+ VRBT_LEFT(parent, field) = child; \
else \
- VRB_RIGHT(parent, field) = child; \
- VRB_AUGMENT(parent); \
+ VRBT_RIGHT(parent, field) = child; \
+ VRBT_AUGMENT(parent); \
} else \
- VRB_ROOT(head) = child; \
+ VRBT_ROOT(head) = child; \
color: \
- if (color == VRB_BLACK) { \
- name##_VRB_REMOVE_COLOR(head, parent, child); \
+ if (color == VRBT_BLACK) { \
+ name##_VRBT_REMOVE_COLOR(head, parent, child); \
} \
return (old); \
} \
\
/* Inserts a node into the RB tree */ \
attr struct type * \
-name##_VRB_INSERT(struct name *head, struct type *elm) \
+name##_VRBT_INSERT(struct name *head, struct type *elm) \
{ \
struct type *tmp; \
struct type *parent = NULL; \
int comp = 0; \
- tmp = VRB_ROOT(head); \
+ tmp = VRBT_ROOT(head); \
while (tmp) { \
parent = tmp; \
comp = (cmp)(elm, parent); \
if (comp < 0) \
- tmp = VRB_LEFT(tmp, field); \
+ tmp = VRBT_LEFT(tmp, field); \
else if (comp > 0) \
- tmp = VRB_RIGHT(tmp, field); \
+ tmp = VRBT_RIGHT(tmp, field); \
else \
return (tmp); \
} \
- VRB_SET(elm, parent, field); \
+ VRBT_SET(elm, parent, field); \
if (parent != NULL) { \
if (comp < 0) \
- VRB_LEFT(parent, field) = elm; \
+ VRBT_LEFT(parent, field) = elm; \
else \
- VRB_RIGHT(parent, field) = elm; \
- VRB_AUGMENT(parent); \
+ VRBT_RIGHT(parent, field) = elm; \
+ VRBT_AUGMENT(parent); \
} else \
- VRB_ROOT(head) = elm; \
- name##_VRB_INSERT_COLOR(head, elm); \
+ VRBT_ROOT(head) = elm; \
+ name##_VRBT_INSERT_COLOR(head, elm); \
return (NULL); \
} \
\
/* Finds the node with the same key as elm */ \
attr struct type * \
-name##_VRB_FIND(const struct name *head, const struct type *elm) \
+name##_VRBT_FIND(const struct name *head, const struct type *elm) \
{ \
- struct type *tmp = VRB_ROOT(head); \
+ struct type *tmp = VRBT_ROOT(head); \
int comp; \
while (tmp) { \
comp = cmp(elm, tmp); \
if (comp < 0) \
- tmp = VRB_LEFT(tmp, field); \
+ tmp = VRBT_LEFT(tmp, field); \
else if (comp > 0) \
- tmp = VRB_RIGHT(tmp, field); \
+ tmp = VRBT_RIGHT(tmp, field); \
else \
return (tmp); \
} \
@@ -643,19 +643,19 @@ name##_VRB_FIND(const struct name *head, const struct type *elm) \
\
/* Finds the first node greater than or equal to the search key */ \
attr struct type * \
-name##_VRB_NFIND(const struct name *head, const struct type *elm) \
+name##_VRBT_NFIND(const struct name *head, const struct type *elm) \
{ \
- struct type *tmp = VRB_ROOT(head); \
+ struct type *tmp = VRBT_ROOT(head); \
struct type *res = NULL; \
int comp; \
while (tmp) { \
comp = cmp(elm, tmp); \
if (comp < 0) { \
res = tmp; \
- tmp = VRB_LEFT(tmp, field); \
+ tmp = VRBT_LEFT(tmp, field); \
} \
else if (comp > 0) \
- tmp = VRB_RIGHT(tmp, field); \
+ tmp = VRBT_RIGHT(tmp, field); \
else \
return (tmp); \
} \
@@ -664,21 +664,21 @@ name##_VRB_NFIND(const struct name *head, const struct type *elm) \
\
/* ARGSUSED */ \
attr struct type * \
-name##_VRB_NEXT(struct type *elm) \
+name##_VRBT_NEXT(struct type *elm) \
{ \
- if (VRB_RIGHT(elm, field)) { \
- elm = VRB_RIGHT(elm, field); \
- while (VRB_LEFT(elm, field)) \
- elm = VRB_LEFT(elm, field); \
+ if (VRBT_RIGHT(elm, field)) { \
+ elm = VRBT_RIGHT(elm, field); \
+ while (VRBT_LEFT(elm, field)) \
+ elm = VRBT_LEFT(elm, field); \
} else { \
- if (VRB_PARENT(elm, field) && \
- (elm == VRB_LEFT(VRB_PARENT(elm, field), field))) \
- elm = VRB_PARENT(elm, field); \
+ if (VRBT_PARENT(elm, field) && \
+ (elm == VRBT_LEFT(VRBT_PARENT(elm, field), field))) \
+ elm = VRBT_PARENT(elm, field); \
else { \
- while (VRB_PARENT(elm, field) && \
- (elm == VRB_RIGHT(VRB_PARENT(elm, field), field)))\
- elm = VRB_PARENT(elm, field); \
- elm = VRB_PARENT(elm, field); \
+ while (VRBT_PARENT(elm, field) && \
+ (elm == VRBT_RIGHT(VRBT_PARENT(elm, field), field)))\
+ elm = VRBT_PARENT(elm, field); \
+ elm = VRBT_PARENT(elm, field); \
} \
} \
return (elm); \
@@ -686,81 +686,81 @@ name##_VRB_NEXT(struct type *elm) \
\
/* ARGSUSED */ \
attr struct type * \
-name##_VRB_PREV(struct type *elm) \
+name##_VRBT_PREV(struct type *elm) \
{ \
- if (VRB_LEFT(elm, field)) { \
- elm = VRB_LEFT(elm, field); \
- while (VRB_RIGHT(elm, field)) \
- elm = VRB_RIGHT(elm, field); \
+ if (VRBT_LEFT(elm, field)) { \
+ elm = VRBT_LEFT(elm, field); \
+ while (VRBT_RIGHT(elm, field)) \
+ elm = VRBT_RIGHT(elm, field); \
} else { \
- if (VRB_PARENT(elm, field) && \
- (elm == VRB_RIGHT(VRB_PARENT(elm, field), field))) \
- elm = VRB_PARENT(elm, field); \
+ if (VRBT_PARENT(elm, field) && \
+ (elm == VRBT_RIGHT(VRBT_PARENT(elm, field), field))) \
+ elm = VRBT_PARENT(elm, field); \
else { \
- while (VRB_PARENT(elm, field) && \
- (elm == VRB_LEFT(VRB_PARENT(elm, field), field)))\
- elm = VRB_PARENT(elm, field); \
- elm = VRB_PARENT(elm, field); \
+ while (VRBT_PARENT(elm, field) && \
+ (elm == VRBT_LEFT(VRBT_PARENT(elm, field), field)))\
+ elm = VRBT_PARENT(elm, field); \
+ elm = VRBT_PARENT(elm, field); \
} \
} \
return (elm); \
} \
\
attr struct type * \
-name##_VRB_MINMAX(const struct name *head, int val) \
+name##_VRBT_MINMAX(const struct name *head, int val) \
{ \
- struct type *tmp = VRB_ROOT(head); \
+ struct type *tmp = VRBT_ROOT(head); \
struct type *parent = NULL; \
while (tmp) { \
parent = tmp; \
if (val < 0) \
- tmp = VRB_LEFT(tmp, field); \
+ tmp = VRBT_LEFT(tmp, field); \
else \
- tmp = VRB_RIGHT(tmp, field); \
+ tmp = VRBT_RIGHT(tmp, field); \
} \
return (parent); \
}
-#define VRB_NEGINF -1
-#define VRB_INF 1
+#define VRBT_NEGINF -1
+#define VRBT_INF 1
-#define VRB_INSERT(name, x, y) name##_VRB_INSERT(x, y)
-#define VRB_REMOVE(name, x, y) name##_VRB_REMOVE(x, y)
-#define VRB_FIND(name, x, y) name##_VRB_FIND(x, y)
-#define VRB_NFIND(name, x, y) name##_VRB_NFIND(x, y)
-#define VRB_NEXT(name, x, y) name##_VRB_NEXT(y)
-#define VRB_PREV(name, x, y) name##_VRB_PREV(y)
-#define VRB_MIN(name, x) name##_VRB_MINMAX(x, VRB_NEGINF)
-#define VRB_MAX(name, x) name##_VRB_MINMAX(x, VRB_INF)
+#define VRBT_INSERT(name, x, y) name##_VRBT_INSERT(x, y)
+#define VRBT_REMOVE(name, x, y) name##_VRBT_REMOVE(x, y)
+#define VRBT_FIND(name, x, y) name##_VRBT_FIND(x, y)
+#define VRBT_NFIND(name, x, y) name##_VRBT_NFIND(x, y)
+#define VRBT_NEXT(name, x, y) name##_VRBT_NEXT(y)
+#define VRBT_PREV(name, x, y) name##_VRBT_PREV(y)
+#define VRBT_MIN(name, x) name##_VRBT_MINMAX(x, VRBT_NEGINF)
+#define VRBT_MAX(name, x) name##_VRBT_MINMAX(x, VRBT_INF)
-#define VRB_FOREACH(x, name, head) \
- for ((x) = VRB_MIN(name, head); \
+#define VRBT_FOREACH(x, name, head) \
+ for ((x) = VRBT_MIN(name, head); \
(x) != NULL; \
- (x) = name##_VRB_NEXT(x))
+ (x) = name##_VRBT_NEXT(x))
-#define VRB_FOREACH_FROM(x, name, y) \
+#define VRBT_FOREACH_FROM(x, name, y) \
for ((x) = (y); \
- ((x) != NULL) && ((y) = name##_VRB_NEXT(x), (x) != NULL); \
+ ((x) != NULL) && ((y) = name##_VRBT_NEXT(x), (x) != NULL); \
(x) = (y))
-#define VRB_FOREACH_SAFE(x, name, head, y) \
- for ((x) = VRB_MIN(name, head); \
- ((x) != NULL) && ((y) = name##_VRB_NEXT(x), (x) != NULL); \
+#define VRBT_FOREACH_SAFE(x, name, head, y) \
+ for ((x) = VRBT_MIN(name, head); \
+ ((x) != NULL) && ((y) = name##_VRBT_NEXT(x), (x) != NULL); \
(x) = (y))
-#define VRB_FOREACH_REVERSE(x, name, head) \
- for ((x) = VRB_MAX(name, head); \
+#define VRBT_FOREACH_REVERSE(x, name, head) \
+ for ((x) = VRBT_MAX(name, head); \
(x) != NULL; \
- (x) = name##_VRB_PREV(x))
+ (x) = name##_VRBT_PREV(x))
-#define VRB_FOREACH_REVERSE_FROM(x, name, y) \
+#define VRBT_FOREACH_REVERSE_FROM(x, name, y) \
for ((x) = (y); \
- ((x) != NULL) && ((y) = name##_VRB_PREV(x), (x) != NULL); \
+ ((x) != NULL) && ((y) = name##_VRBT_PREV(x), (x) != NULL); \
(x) = (y))
-#define VRB_FOREACH_REVERSE_SAFE(x, name, head, y) \
- for ((x) = VRB_MAX(name, head); \
- ((x) != NULL) && ((y) = name##_VRB_PREV(x), (x) != NULL); \
+#define VRBT_FOREACH_REVERSE_SAFE(x, name, head, y) \
+ for ((x) = VRBT_MAX(name, head); \
+ ((x) != NULL) && ((y) = name##_VRBT_PREV(x), (x) != NULL); \
(x) = (y))
#endif /* _VTREE_H_ */
diff --git a/lib/libvarnishapi/vsl_dispatch.c b/lib/libvarnishapi/vsl_dispatch.c
index 6e786d4f7..fa397ae0d 100644
--- a/lib/libvarnishapi/vsl_dispatch.c
+++ b/lib/libvarnishapi/vsl_dispatch.c
@@ -135,9 +135,9 @@ struct vslc_vtx {
struct vtx_key {
unsigned vxid;
- VRB_ENTRY(vtx_key) entry;
+ VRBT_ENTRY(vtx_key) entry;
};
-VRB_HEAD(vtx_tree, vtx_key);
+VRBT_HEAD(vtx_tree, vtx_key);
struct vtx {
struct vtx_key key;
@@ -222,8 +222,8 @@ vtx_keycmp(const struct vtx_key *a, const struct vtx_key *b)
return (0);
}
-VRB_PROTOTYPE_STATIC(vtx_tree, vtx_key, entry, vtx_keycmp)
-VRB_GENERATE_STATIC(vtx_tree, vtx_key, entry, vtx_keycmp)
+VRBT_PROTOTYPE_STATIC(vtx_tree, vtx_key, entry, vtx_keycmp)
+VRBT_GENERATE_STATIC(vtx_tree, vtx_key, entry, vtx_keycmp)
static enum vsl_status v_matchproto_(vslc_next_f)
vslc_raw_next(const struct VSL_cursor *cursor)
@@ -549,7 +549,7 @@ vtx_retire(struct VSLQ *vslq, struct vtx **pvtx)
AZ(vtx->n_child);
AZ(vtx->n_descend);
vtx->n_childready = 0;
- AN(VRB_REMOVE(vtx_tree, &vslq->tree, &vtx->key));
+ AN(VRBT_REMOVE(vtx_tree, &vslq->tree, &vtx->key));
vtx->key.vxid = 0;
vtx->flags = 0;
@@ -594,7 +594,7 @@ vtx_lookup(const struct VSLQ *vslq, unsigned vxid)
AN(vslq);
lkey.vxid = vxid;
- key = VRB_FIND(vtx_tree, &vslq->tree, &lkey);
+ key = VRBT_FIND(vtx_tree, &vslq->tree, &lkey);
if (key == NULL)
return (NULL);
CAST_OBJ_NOTNULL(vtx, (void *)key, VTX_MAGIC);
@@ -611,7 +611,7 @@ vtx_add(struct VSLQ *vslq, unsigned vxid)
vtx = vtx_new(vslq);
AN(vtx);
vtx->key.vxid = vxid;
- AZ(VRB_INSERT(vtx_tree, &vslq->tree, &vtx->key));
+ AZ(VRBT_INSERT(vtx_tree, &vslq->tree, &vtx->key));
VTAILQ_INSERT_TAIL(&vslq->incomplete, vtx, list_vtx);
vslq->n_outstanding++;
return (vtx);
@@ -1080,7 +1080,7 @@ VSLQ_New(struct VSL_data *vsl, struct VSL_cursor **cp,
vslq->query = query;
/* Setup normal mode */
- VRB_INIT(&vslq->tree);
+ VRBT_INIT(&vslq->tree);
VTAILQ_INIT(&vslq->ready);
VTAILQ_INIT(&vslq->incomplete);
VTAILQ_INIT(&vslq->shmrefs);
More information about the varnish-commit
mailing list