| /* |
| * C macro implementation of treaps. |
| * |
| * Usage: |
| * #include <stdint.h> |
| * #include "trp.h" |
| * trp_gen(...) |
| * |
| * Licensed under a two-clause BSD-style license. |
| * See LICENSE for details. |
| */ |
| |
| #ifndef TRP_H_ |
| #define TRP_H_ |
| |
| #define MAYBE_UNUSED __attribute__((__unused__)) |
| |
| /* Node structure. */ |
| struct trp_node { |
| uint32_t trpn_left; |
| uint32_t trpn_right; |
| }; |
| |
| /* Root structure. */ |
| struct trp_root { |
| uint32_t trp_root; |
| }; |
| |
| /* Pointer/Offset conversion. */ |
| #define trpn_pointer(a_base, a_offset) (a_base##_pointer(a_offset)) |
| #define trpn_offset(a_base, a_pointer) (a_base##_offset(a_pointer)) |
| #define trpn_modify(a_base, a_offset) \ |
| do { \ |
| if ((a_offset) < a_base##_pool.committed) { \ |
| uint32_t old_offset = (a_offset);\ |
| (a_offset) = a_base##_alloc(1); \ |
| *trpn_pointer(a_base, a_offset) = \ |
| *trpn_pointer(a_base, old_offset); \ |
| } \ |
| } while (0) |
| |
| /* Left accessors. */ |
| #define trp_left_get(a_base, a_field, a_node) \ |
| (trpn_pointer(a_base, a_node)->a_field.trpn_left) |
| #define trp_left_set(a_base, a_field, a_node, a_left) \ |
| do { \ |
| trpn_modify(a_base, a_node); \ |
| trp_left_get(a_base, a_field, a_node) = (a_left); \ |
| } while (0) |
| |
| /* Right accessors. */ |
| #define trp_right_get(a_base, a_field, a_node) \ |
| (trpn_pointer(a_base, a_node)->a_field.trpn_right) |
| #define trp_right_set(a_base, a_field, a_node, a_right) \ |
| do { \ |
| trpn_modify(a_base, a_node); \ |
| trp_right_get(a_base, a_field, a_node) = (a_right); \ |
| } while (0) |
| |
| /* |
| * Fibonacci hash function. |
| * The multiplier is the nearest prime to (2^32 times (√5 - 1)/2). |
| * See Knuth §6.4: volume 3, 3rd ed, p518. |
| */ |
| #define trpn_hash(a_node) (uint32_t) (2654435761u * (a_node)) |
| |
| /* Priority accessors. */ |
| #define trp_prio_get(a_node) trpn_hash(a_node) |
| |
| /* Node initializer. */ |
| #define trp_node_new(a_base, a_field, a_node) \ |
| do { \ |
| trp_left_set(a_base, a_field, (a_node), ~0); \ |
| trp_right_set(a_base, a_field, (a_node), ~0); \ |
| } while (0) |
| |
| /* Internal utility macros. */ |
| #define trpn_first(a_base, a_field, a_root, r_node) \ |
| do { \ |
| (r_node) = (a_root); \ |
| if ((r_node) == ~0) \ |
| return NULL; \ |
| while (~trp_left_get(a_base, a_field, (r_node))) \ |
| (r_node) = trp_left_get(a_base, a_field, (r_node)); \ |
| } while (0) |
| |
| #define trpn_rotate_left(a_base, a_field, a_node, r_node) \ |
| do { \ |
| (r_node) = trp_right_get(a_base, a_field, (a_node)); \ |
| trp_right_set(a_base, a_field, (a_node), \ |
| trp_left_get(a_base, a_field, (r_node))); \ |
| trp_left_set(a_base, a_field, (r_node), (a_node)); \ |
| } while (0) |
| |
| #define trpn_rotate_right(a_base, a_field, a_node, r_node) \ |
| do { \ |
| (r_node) = trp_left_get(a_base, a_field, (a_node)); \ |
| trp_left_set(a_base, a_field, (a_node), \ |
| trp_right_get(a_base, a_field, (r_node))); \ |
| trp_right_set(a_base, a_field, (r_node), (a_node)); \ |
| } while (0) |
| |
| #define trp_gen(a_attr, a_pre, a_type, a_field, a_base, a_cmp) \ |
| a_attr a_type MAYBE_UNUSED *a_pre##first(struct trp_root *treap) \ |
| { \ |
| uint32_t ret; \ |
| trpn_first(a_base, a_field, treap->trp_root, ret); \ |
| return trpn_pointer(a_base, ret); \ |
| } \ |
| a_attr a_type MAYBE_UNUSED *a_pre##next(struct trp_root *treap, a_type *node) \ |
| { \ |
| uint32_t ret; \ |
| uint32_t offset = trpn_offset(a_base, node); \ |
| if (~trp_right_get(a_base, a_field, offset)) { \ |
| trpn_first(a_base, a_field, \ |
| trp_right_get(a_base, a_field, offset), ret); \ |
| } else { \ |
| uint32_t tnode = treap->trp_root; \ |
| ret = ~0; \ |
| while (1) { \ |
| int cmp = (a_cmp)(trpn_pointer(a_base, offset), \ |
| trpn_pointer(a_base, tnode)); \ |
| if (cmp < 0) { \ |
| ret = tnode; \ |
| tnode = trp_left_get(a_base, a_field, tnode); \ |
| } else if (cmp > 0) { \ |
| tnode = trp_right_get(a_base, a_field, tnode); \ |
| } else { \ |
| break; \ |
| } \ |
| } \ |
| } \ |
| return trpn_pointer(a_base, ret); \ |
| } \ |
| a_attr a_type MAYBE_UNUSED *a_pre##search(struct trp_root *treap, a_type *key) \ |
| { \ |
| int cmp; \ |
| uint32_t ret = treap->trp_root; \ |
| while (~ret && (cmp = (a_cmp)(key, trpn_pointer(a_base, ret)))) { \ |
| if (cmp < 0) { \ |
| ret = trp_left_get(a_base, a_field, ret); \ |
| } else { \ |
| ret = trp_right_get(a_base, a_field, ret); \ |
| } \ |
| } \ |
| return trpn_pointer(a_base, ret); \ |
| } \ |
| a_attr a_type MAYBE_UNUSED *a_pre##nsearch(struct trp_root *treap, a_type *key) \ |
| { \ |
| int cmp; \ |
| uint32_t ret = treap->trp_root; \ |
| while (~ret && (cmp = (a_cmp)(key, trpn_pointer(a_base, ret)))) { \ |
| if (cmp < 0) { \ |
| if (!~trp_left_get(a_base, a_field, ret)) \ |
| break; \ |
| ret = trp_left_get(a_base, a_field, ret); \ |
| } else { \ |
| ret = trp_right_get(a_base, a_field, ret); \ |
| } \ |
| } \ |
| return trpn_pointer(a_base, ret); \ |
| } \ |
| a_attr uint32_t MAYBE_UNUSED a_pre##insert_recurse(uint32_t cur_node, uint32_t ins_node) \ |
| { \ |
| if (cur_node == ~0) { \ |
| return ins_node; \ |
| } else { \ |
| uint32_t ret; \ |
| int cmp = (a_cmp)(trpn_pointer(a_base, ins_node), \ |
| trpn_pointer(a_base, cur_node)); \ |
| if (cmp < 0) { \ |
| uint32_t left = a_pre##insert_recurse( \ |
| trp_left_get(a_base, a_field, cur_node), ins_node); \ |
| trp_left_set(a_base, a_field, cur_node, left); \ |
| if (trp_prio_get(left) < trp_prio_get(cur_node)) \ |
| trpn_rotate_right(a_base, a_field, cur_node, ret); \ |
| else \ |
| ret = cur_node; \ |
| } else { \ |
| uint32_t right = a_pre##insert_recurse( \ |
| trp_right_get(a_base, a_field, cur_node), ins_node); \ |
| trp_right_set(a_base, a_field, cur_node, right); \ |
| if (trp_prio_get(right) < trp_prio_get(cur_node)) \ |
| trpn_rotate_left(a_base, a_field, cur_node, ret); \ |
| else \ |
| ret = cur_node; \ |
| } \ |
| return ret; \ |
| } \ |
| } \ |
| a_attr a_type *MAYBE_UNUSED a_pre##insert(struct trp_root *treap, a_type *node) \ |
| { \ |
| uint32_t offset = trpn_offset(a_base, node); \ |
| trp_node_new(a_base, a_field, offset); \ |
| treap->trp_root = a_pre##insert_recurse(treap->trp_root, offset); \ |
| return trpn_pointer(a_base, offset); \ |
| } \ |
| a_attr uint32_t MAYBE_UNUSED a_pre##remove_recurse(uint32_t cur_node, uint32_t rem_node) \ |
| { \ |
| int cmp = a_cmp(trpn_pointer(a_base, rem_node), \ |
| trpn_pointer(a_base, cur_node)); \ |
| if (cmp == 0) { \ |
| uint32_t ret; \ |
| uint32_t left = trp_left_get(a_base, a_field, cur_node); \ |
| uint32_t right = trp_right_get(a_base, a_field, cur_node); \ |
| if (left == ~0) { \ |
| if (right == ~0) \ |
| return ~0; \ |
| } else if (right == ~0 || trp_prio_get(left) < trp_prio_get(right)) { \ |
| trpn_rotate_right(a_base, a_field, cur_node, ret); \ |
| right = a_pre##remove_recurse(cur_node, rem_node); \ |
| trp_right_set(a_base, a_field, ret, right); \ |
| return ret; \ |
| } \ |
| trpn_rotate_left(a_base, a_field, cur_node, ret); \ |
| left = a_pre##remove_recurse(cur_node, rem_node); \ |
| trp_left_set(a_base, a_field, ret, left); \ |
| return ret; \ |
| } else if (cmp < 0) { \ |
| uint32_t left = a_pre##remove_recurse( \ |
| trp_left_get(a_base, a_field, cur_node), rem_node); \ |
| trp_left_set(a_base, a_field, cur_node, left); \ |
| return cur_node; \ |
| } else { \ |
| uint32_t right = a_pre##remove_recurse( \ |
| trp_right_get(a_base, a_field, cur_node), rem_node); \ |
| trp_right_set(a_base, a_field, cur_node, right); \ |
| return cur_node; \ |
| } \ |
| } \ |
| a_attr void MAYBE_UNUSED a_pre##remove(struct trp_root *treap, a_type *node) \ |
| { \ |
| treap->trp_root = a_pre##remove_recurse(treap->trp_root, \ |
| trpn_offset(a_base, node)); \ |
| } \ |
| |
| #endif |
