static inline s_splay_tree_t *
splay_tree_find_i(s_splay_tree_t **tree, sint64 nice)
{
s_splay_tree_t **iterator;
s_splay_tree_t *splay_node;
s_array_stack_t *path_stack;
assert_exit(NON_NULL_PTR_P(tree));
assert_exit(splay_tree_structure_legal_ip(*tree));
iterator = tree;
splay_node = *tree;
path_stack = array_stack_create();
while (splay_node) {
if (nice < splay_node->nice) {
array_stack_push(path_stack, TREE_PATH_L_ENCODE(iterator));
iterator = &splay_node->left;
} else if (nice > splay_node->nice) {
array_stack_push(path_stack, TREE_PATH_R_ENCODE(iterator));
iterator = &splay_node->right;
} else {
splay_tree_splaying(path_stack);
assert_exit(*tree = splay_node);
break;
}
splay_node = *iterator;
}
array_stack_destroy(&path_stack);
return splay_node;
}
static inline s_splay_tree_t *
splay_tree_find_max_i(s_splay_tree_t **tree)
{
s_splay_tree_t *max_node;
s_splay_tree_t **iterator;
s_array_stack_t *path_stack;
assert_exit(NON_NULL_PTR_P(tree));
assert_exit(splay_tree_structure_legal_ip(*tree));
iterator = tree;
max_node = *tree;
path_stack = array_stack_create();
while (max_node->right) {
array_stack_push(path_stack, TREE_PATH_R_ENCODE(iterator));
iterator = &max_node->right;
max_node = *iterator;
}
splay_tree_splaying(path_stack);
array_stack_destroy(&path_stack);
assert_exit(*tree == max_node);
return max_node;
}
boolean
check_parantheses_match(const char *expr)
{
int i = 0;
array_stack_t pstack;
boolean valid = TRUE;
array_stack_init(&pstack, MAX_EXPR_SIZE);
for (i=0; expr[i]; i++) {
if (is_opening_parantheses(expr[i])) {
array_stack_push(&pstack, expr[i]);
} else if (is_closing_parantheses(expr[i])) {
if (array_stack_isEmpty(&pstack)) {
valid = FALSE;
break;
}
int symb = array_stack_pop(&pstack);
/** 'symb' must be matching opener for expr[i] */
if (! is_matching_parantheses(symb, expr[i]) ) {
valid = FALSE;
break;
}
}
}
if (!array_stack_isEmpty(&pstack)) {
valid = FALSE;
}
array_stack_destroy(&pstack);
return valid;
}
static inline s_splay_tree_t *
splay_tree_insert_i(s_splay_tree_t **tree, s_splay_tree_t *node)
{
s_array_stack_t *path_stack;
s_splay_tree_t *splay_node, **iterator;
assert_exit(NON_NULL_PTR_P(tree));
assert_exit(splay_tree_structure_legal_ip(node));
assert_exit(splay_tree_structure_legal_ip(*tree));
assert_exit(splay_tree_ordered_p(*tree));
iterator = tree;
splay_node = *iterator;
path_stack = array_stack_create();
while (splay_node) {
if (node == splay_node) {
pr_log_warn("Insert node exist, nothing will be done.\n");
array_stack_destroy(&path_stack);
return splay_node;
} else if (node->nice < splay_node->nice) {
array_stack_push(path_stack, TREE_PATH_L_ENCODE(iterator));
iterator = &splay_node->left;
} else if (node->nice > splay_node->nice) {
array_stack_push(path_stack, TREE_PATH_R_ENCODE(iterator));
iterator = &splay_node->right;
} else {
splay_tree_node_merge(splay_node, node);
splay_tree_splaying(path_stack);
array_stack_destroy(&path_stack);
return splay_node;
}
splay_node = *iterator;
}
*iterator = node;
splay_tree_splaying(path_stack);
array_stack_destroy(&path_stack);
assert_exit(*tree == node);
assert_exit(splay_tree_ordered_p(*tree));
return node;
}
static inline void
stacked_queue_stack_dump(s_array_stack_t *from, s_array_stack_t *to)
{
assert_exit(array_stack_structure_legal_p(to));
assert_exit(array_stack_structure_legal_p(from));
assert_exit(array_stack_empty_p(to));
assert_exit(array_stack_capacity(from) == array_stack_capacity(to));
while (!array_stack_empty_p(from)) {
array_stack_push(to, array_stack_pop(from));
}
}
int main (void)
{
array_stack_t mystack;
int i;
assert(array_stack_init(&mystack, MAX_STACK_SIZE) == 0);
assert(array_stack_isEmpty(&mystack) == TRUE);
array_stack_print(&mystack, printAsInt);
for(i=0; i<MAX_STACK_SIZE; i++) {
assert(array_stack_push(&mystack, (void *)(i+1)) == 0);
array_stack_print(&mystack, printAsInt);
assert((int)array_stack_peek(&mystack) == (i+1));
assert(array_stack_len(&mystack) == (i+1));
}
assert(array_stack_isFull(&mystack) == TRUE);
assert(array_stack_isEmpty(&mystack) == FALSE);
assert(array_stack_push(&mystack, (void *)(11)) == -EINVAL);
for(i=0; i<MAX_STACK_SIZE; i++) {
assert((int)array_stack_peek(&mystack) == (MAX_STACK_SIZE-i));
assert(array_stack_len(&mystack) == (MAX_STACK_SIZE-i));
assert(array_stack_pop(&mystack) == (MAX_STACK_SIZE-i));
array_stack_print(&mystack, printAsInt);
}
assert(array_stack_isFull(&mystack) == FALSE);
assert(array_stack_isEmpty(&mystack) == TRUE);
array_stack_destroy(&mystack);
printf("All tests succeed!\n");
return 0;
}
void
stacked_queue_enter(s_stacked_queue_t *queue, void *member)
{
if (stacked_queue_structure_legal_p(queue) && !NULL_PTR_P(member)) {
if (array_stack_full_p(queue->enter) && array_stack_empty_p(queue->leave)) {
pr_log_info("Empty leave stack, will dump enter stack to leave.\n");
stacked_queue_stack_dump(queue->enter, queue->leave);
} else if (array_stack_full_p(queue->enter)) {
pr_log_info("Fail to dump enter stack, will expand enter space.\n");
stacked_queue_resize_i(queue, queue->dim * 2);
}
array_stack_push(queue->enter, member);
}
}
static inline void
trie_tree_sequence_remove_i(s_trie_tree_t *trie, uint32 *sequence, uint32 len)
{
uint32 *seq;
s_array_stack_t *stack;
s_trie_tree_t *trie_node;
assert_exit(!complain_zero_size_p(len));
assert_exit(trie_tree_root_node_p(trie));
assert_exit(trie_tree_structure_legal_p(trie));
assert_exit(!NULL_PTR_P(sequence));
seq = sequence;
trie_node = trie;
stack = array_stack_create();
while (seq < sequence + len) {
trie_node = trie_tree_sub_queue_find(trie_node, *seq);
if (trie_node == NULL) {
array_stack_destroy(&stack);
return;
} else {
array_stack_push(stack, trie_node);
seq++;
}
}
while (!array_stack_empty_p(stack)) {
trie_node = array_stack_pop(stack);
if (trie_tree_sub_queue_empty_p(trie_node)) {
trie_node->is_deleted = true;
}
}
array_stack_destroy(&stack);
}
