Gnash 0.8.9
Defines

jemtree.h File Reference

Go to the source code of this file.

Defines

#define SPLAY_HEAD(name, type)
#define SPLAY_INITIALIZER(root)   { NULL }
#define SPLAY_INIT(root)
#define SPLAY_ENTRY(type)
#define SPLAY_LEFT(elm, field)   (elm)->field.spe_left
#define SPLAY_RIGHT(elm, field)   (elm)->field.spe_right
#define SPLAY_ROOT(head)   (head)->sph_root
#define SPLAY_EMPTY(head)   (SPLAY_ROOT(head) == NULL)
#define SPLAY_ROTATE_RIGHT(head, tmp, field)
#define SPLAY_ROTATE_LEFT(head, tmp, field)
#define SPLAY_LINKLEFT(head, tmp, field)
#define SPLAY_LINKRIGHT(head, tmp, field)
#define SPLAY_ASSEMBLE(head, node, left, right, field)
#define SPLAY_PROTOTYPE(name, type, field, cmp)
#define SPLAY_GENERATE(name, type, field, cmp)
#define SPLAY_NEGINF   -1
#define SPLAY_INF   1
#define SPLAY_INSERT(name, x, y)   name##_SPLAY_INSERT(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_NEXT(name, x, y)   name##_SPLAY_NEXT(x, y)
#define SPLAY_MIN(name, x)
#define SPLAY_MAX(name, x)
#define SPLAY_FOREACH(x, name, head)
#define RB_HEAD(name, type)
#define RB_INITIALIZER(root)   { NULL }
#define RB_INIT(root)
#define RB_BLACK   0
#define RB_RED   1
#define RB_ENTRY(type)
#define RB_LEFT(elm, field)   (elm)->field.rbe_left
#define RB_RIGHT(elm, field)   (elm)->field.rbe_right
#define RB_PARENT(elm, field)   (elm)->field.rbe_parent
#define RB_COLOR(elm, field)   (elm)->field.rbe_color
#define RB_ROOT(head)   (head)->rbh_root
#define RB_EMPTY(head)   (RB_ROOT(head) == NULL)
#define RB_SET(elm, parent, field)
#define RB_SET_BLACKRED(black, red, field)
#define RB_AUGMENT(x)   do {} while (0)
#define RB_ROTATE_LEFT(head, elm, tmp, field)
#define RB_ROTATE_RIGHT(head, elm, tmp, field)
#define RB_PROTOTYPE(name, type, field, cmp)   RB_PROTOTYPE_INTERNAL(name, type, field, cmp,)
#define RB_PROTOTYPE_STATIC(name, type, field, cmp)   RB_PROTOTYPE_INTERNAL(name, type, field, cmp, __unused static)
#define RB_PROTOTYPE_INTERNAL(name, type, field, cmp, attr)
#define RB_GENERATE(name, type, field, cmp)   RB_GENERATE_INTERNAL(name, type, field, cmp,)
#define RB_GENERATE_STATIC(name, type, field, cmp)   RB_GENERATE_INTERNAL(name, type, field, cmp, static)
#define RB_GENERATE_INTERNAL(name, type, field, cmp, attr)
#define RB_NEGINF   -1
#define RB_INF   1
#define RB_INSERT(name, x, y)   name##_RB_INSERT(x, y)
#define RB_REMOVE(name, x, y)   name##_RB_REMOVE(x, y)
#define RB_FIND(name, x, y)   name##_RB_FIND(x, y)
#define RB_NFIND(name, x, y)   name##_RB_NFIND(x, y)
#define RB_NEXT(name, x, y)   name##_RB_NEXT(y)
#define RB_PREV(name, x, y)   name##_RB_PREV(y)
#define RB_MIN(name, x)   name##_RB_MINMAX(x, RB_NEGINF)
#define RB_MAX(name, x)   name##_RB_MINMAX(x, RB_INF)
#define RB_FOREACH(x, name, head)
#define RB_FOREACH_REVERSE(x, name, head)

Define Documentation

#define RB_AUGMENT (   x)    do {} while (0)
#define RB_BLACK   0
#define RB_COLOR (   elm,
  field 
)    (elm)->field.rbe_color
#define RB_EMPTY (   head)    (RB_ROOT(head) == NULL)
#define RB_ENTRY (   type)
Value:
struct {                                                                \
        struct type *rbe_left;          /* left element */              \
        struct type *rbe_right;         /* right element */             \
        struct type *rbe_parent;        /* parent element */            \
        int rbe_color;                  /* node color */                \
}
#define RB_FIND (   name,
  x,
 
)    name##_RB_FIND(x, y)
#define RB_FOREACH (   x,
  name,
  head 
)
Value:
for ((x) = RB_MIN(name, head);                                  \
             (x) != NULL;                                               \
             (x) = name##_RB_NEXT(x))
#define RB_FOREACH_REVERSE (   x,
  name,
  head 
)
Value:
for ((x) = RB_MAX(name, head);                                  \
             (x) != NULL;                                               \
             (x) = name##_RB_PREV(x))
#define RB_GENERATE (   name,
  type,
  field,
  cmp 
)    RB_GENERATE_INTERNAL(name, type, field, cmp,)
#define RB_GENERATE_INTERNAL (   name,
  type,
  field,
  cmp,
  attr 
)
#define RB_GENERATE_STATIC (   name,
  type,
  field,
  cmp 
)    RB_GENERATE_INTERNAL(name, type, field, cmp, static)
#define RB_HEAD (   name,
  type 
)
Value:
struct name {                                                           \
        struct type *rbh_root; /* root of the tree */                   \
}
#define RB_INF   1
#define RB_INIT (   root)
Value:
do {                                            \
        (root)->rbh_root = NULL;                                        \
} while (/*CONSTCOND*/ 0)
#define RB_INITIALIZER (   root)    { NULL }
#define RB_INSERT (   name,
  x,
 
)    name##_RB_INSERT(x, y)
#define RB_LEFT (   elm,
  field 
)    (elm)->field.rbe_left
#define RB_MAX (   name,
 
)    name##_RB_MINMAX(x, RB_INF)
#define RB_MIN (   name,
 
)    name##_RB_MINMAX(x, RB_NEGINF)
#define RB_NEGINF   -1
#define RB_NEXT (   name,
  x,
 
)    name##_RB_NEXT(y)
#define RB_NFIND (   name,
  x,
 
)    name##_RB_NFIND(x, y)
#define RB_PARENT (   elm,
  field 
)    (elm)->field.rbe_parent
#define RB_PREV (   name,
  x,
 
)    name##_RB_PREV(y)
#define RB_PROTOTYPE (   name,
  type,
  field,
  cmp 
)    RB_PROTOTYPE_INTERNAL(name, type, field, cmp,)
#define RB_PROTOTYPE_INTERNAL (   name,
  type,
  field,
  cmp,
  attr 
)
Value:
attr void name##_RB_INSERT_COLOR(struct name *, struct type *);         \
attr void name##_RB_REMOVE_COLOR(struct name *, struct type *, struct type *);\
attr struct type *name##_RB_REMOVE(struct name *, struct type *);       \
attr struct type *name##_RB_INSERT(struct name *, struct type *);       \
attr struct type *name##_RB_FIND(struct name *, struct type *);         \
attr struct type *name##_RB_NFIND(struct name *, struct type *);        \
attr struct type *name##_RB_NEXT(struct type *);                        \
attr struct type *name##_RB_PREV(struct type *);                        \
attr struct type *name##_RB_MINMAX(struct name *, int);                 \
                                                                        \
#define RB_PROTOTYPE_STATIC (   name,
  type,
  field,
  cmp 
)    RB_PROTOTYPE_INTERNAL(name, type, field, cmp, __unused static)
#define RB_RED   1
#define RB_REMOVE (   name,
  x,
 
)    name##_RB_REMOVE(x, y)
#define RB_RIGHT (   elm,
  field 
)    (elm)->field.rbe_right
#define RB_ROOT (   head)    (head)->rbh_root
#define RB_ROTATE_LEFT (   head,
  elm,
  tmp,
  field 
)
Value:
do {                    \
        (tmp) = RB_RIGHT(elm, field);                                   \
        if ((RB_RIGHT(elm, field) = RB_LEFT(tmp, field)) != NULL) {     \
                RB_PARENT(RB_LEFT(tmp, field), field) = (elm);          \
        }                                                               \
        RB_AUGMENT(elm);                                                \
        if ((RB_PARENT(tmp, field) = RB_PARENT(elm, field)) != NULL) {  \
                if ((elm) == RB_LEFT(RB_PARENT(elm, field), field))     \
                        RB_LEFT(RB_PARENT(elm, field), field) = (tmp);  \
                else                                                    \
                        RB_RIGHT(RB_PARENT(elm, field), field) = (tmp); \
        } else                                                          \
                (head)->rbh_root = (tmp);                               \
        RB_LEFT(tmp, field) = (elm);                                    \
        RB_PARENT(elm, field) = (tmp);                                  \
        RB_AUGMENT(tmp);                                                \
        if ((RB_PARENT(tmp, field)))                                    \
                RB_AUGMENT(RB_PARENT(tmp, field));                      \
} while (/*CONSTCOND*/ 0)
#define RB_ROTATE_RIGHT (   head,
  elm,
  tmp,
  field 
)
Value:
do {                    \
        (tmp) = RB_LEFT(elm, field);                                    \
        if ((RB_LEFT(elm, field) = RB_RIGHT(tmp, field)) != NULL) {     \
                RB_PARENT(RB_RIGHT(tmp, field), field) = (elm);         \
        }                                                               \
        RB_AUGMENT(elm);                                                \
        if ((RB_PARENT(tmp, field) = RB_PARENT(elm, field)) != NULL) {  \
                if ((elm) == RB_LEFT(RB_PARENT(elm, field), field))     \
                        RB_LEFT(RB_PARENT(elm, field), field) = (tmp);  \
                else                                                    \
                        RB_RIGHT(RB_PARENT(elm, field), field) = (tmp); \
        } else                                                          \
                (head)->rbh_root = (tmp);                               \
        RB_RIGHT(tmp, field) = (elm);                                   \
        RB_PARENT(elm, field) = (tmp);                                  \
        RB_AUGMENT(tmp);                                                \
        if ((RB_PARENT(tmp, field)))                                    \
                RB_AUGMENT(RB_PARENT(tmp, field));                      \
} while (/*CONSTCOND*/ 0)
#define RB_SET (   elm,
  parent,
  field 
)
Value:
do {                                    \
        RB_PARENT(elm, field) = parent;                                 \
        RB_LEFT(elm, field) = RB_RIGHT(elm, field) = NULL;              \
        RB_COLOR(elm, field) = RB_RED;                                  \
} while (/*CONSTCOND*/ 0)
#define RB_SET_BLACKRED (   black,
  red,
  field 
)
Value:
do {                            \
        RB_COLOR(black, field) = RB_BLACK;                              \
        RB_COLOR(red, field) = RB_RED;                                  \
} while (/*CONSTCOND*/ 0)
#define SPLAY_ASSEMBLE (   head,
  node,
  left,
  right,
  field 
)
Value:
do {            \
        SPLAY_RIGHT(left, field) = SPLAY_LEFT((head)->sph_root, field); \
        SPLAY_LEFT(right, 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 (/*CONSTCOND*/ 0)
#define SPLAY_EMPTY (   head)    (SPLAY_ROOT(head) == NULL)
#define SPLAY_ENTRY (   type)
Value:
struct {                                                                \
        struct type *spe_left; /* left element */                       \
        struct type *spe_right; /* right element */                     \
}
#define SPLAY_FIND (   name,
  x,
 
)    name##_SPLAY_FIND(x, y)
#define SPLAY_FOREACH (   x,
  name,
  head 
)
Value:
for ((x) = SPLAY_MIN(name, head);                               \
             (x) != NULL;                                               \
             (x) = SPLAY_NEXT(name, head, x))
#define SPLAY_GENERATE (   name,
  type,
  field,
  cmp 
)
#define SPLAY_HEAD (   name,
  type 
)
Value:
struct name {                                                           \
        struct type *sph_root; /* root of the tree */                   \
}
#define SPLAY_INF   1
#define SPLAY_INIT (   root)
Value:
do {                                            \
        (root)->sph_root = NULL;                                        \
} while (/*CONSTCOND*/ 0)
#define SPLAY_INITIALIZER (   root)    { NULL }
#define SPLAY_INSERT (   name,
  x,
 
)    name##_SPLAY_INSERT(x, y)
#define SPLAY_LEFT (   elm,
  field 
)    (elm)->field.spe_left
#define SPLAY_LINKLEFT (   head,
  tmp,
  field 
)
Value:
do {                            \
        SPLAY_LEFT(tmp, field) = (head)->sph_root;                      \
        tmp = (head)->sph_root;                                         \
        (head)->sph_root = SPLAY_LEFT((head)->sph_root, field);         \
} while (/*CONSTCOND*/ 0)
#define SPLAY_LINKRIGHT (   head,
  tmp,
  field 
)
Value:
do {                            \
        SPLAY_RIGHT(tmp, field) = (head)->sph_root;                     \
        tmp = (head)->sph_root;                                         \
        (head)->sph_root = SPLAY_RIGHT((head)->sph_root, field);        \
} while (/*CONSTCOND*/ 0)
#define SPLAY_MAX (   name,
 
)
Value:
(SPLAY_EMPTY(x) ? NULL  \
                                        : name##_SPLAY_MIN_MAX(x, SPLAY_INF))
#define SPLAY_MIN (   name,
 
)
Value:
(SPLAY_EMPTY(x) ? NULL  \
                                        : name##_SPLAY_MIN_MAX(x, SPLAY_NEGINF))
#define SPLAY_NEGINF   -1
#define SPLAY_NEXT (   name,
  x,
 
)    name##_SPLAY_NEXT(x, y)
#define SPLAY_PROTOTYPE (   name,
  type,
  field,
  cmp 
)
#define SPLAY_REMOVE (   name,
  x,
 
)    name##_SPLAY_REMOVE(x, y)
#define SPLAY_RIGHT (   elm,
  field 
)    (elm)->field.spe_right
#define SPLAY_ROOT (   head)    (head)->sph_root
#define SPLAY_ROTATE_LEFT (   head,
  tmp,
  field 
)
Value:
do {                    \
        SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(tmp, field);  \
        SPLAY_LEFT(tmp, field) = (head)->sph_root;                      \
        (head)->sph_root = tmp;                                         \
} while (/*CONSTCOND*/ 0)
#define SPLAY_ROTATE_RIGHT (   head,
  tmp,
  field 
)
Value:
do {                    \
        SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(tmp, field);  \
        SPLAY_RIGHT(tmp, field) = (head)->sph_root;                     \
        (head)->sph_root = tmp;                                         \
} while (/*CONSTCOND*/ 0)