int test_top ( void )
{
Stack_t *sp = NULL;
Stack_t *sp1 = NULL;
printf("*** test_top\n");
sp = StackCreate(4);
(void)push(sp,100);
(void)push(sp,200);
(void)push(sp,300);
(void)push(sp,700);
StackDump(sp, 0);
printf("\tTest01 return 700 %d\n", top(sp));
printf("\tTest02 return -1 %d NULL stack\n", top(NULL));
sp1 = StackCreate(4);
printf("\tTest02 return -1 %d Empty Stack\n", top(sp1));
(void)StackDestroy(sp);
(void)StackDestroy(sp1);
printf("test_top - Ends\n");
return 0;
}
CPU_t* CPU_Create ( int StackSize )
{
CPU_t* NewCPU = ( CPU_t* ) calloc ( 1, sizeof ( CPU_t ) );
if ( NewCPU == NULL )
{
CPU_Errno = ENOMEM;
return NULL;
}
NewCPU->ProgramCounter = 0;
NewCPU->CPUStack = StackCreate( StackSize );
if ( NewCPU->CPUStack == NULL )
{
CPU_Errno = ENOMEM;
return NULL;
}
NewCPU->RAM = ( double* ) calloc ( MaxRAM, sizeof ( double ) );
if ( NewCPU->RAM == NULL )
{
CPU_Errno = ENOMEM;
return NULL;
}
NewCPU->CPURegister = ( double* ) calloc ( MaxRegisters, sizeof ( double ) );
if ( NewCPU->CPURegister == NULL )
{
CPU_Errno = ENOMEM;
return NULL;
}
CPU_Errno = 0;
return NewCPU;
}
bool hasPathSum(struct TreeNode* root, int sum) {
if(!root) return false;
SumStackNode *stackTop = StackCreate();
stackTop = StackPush(NULL, root, 0);
while(!isStackEmpty(stackTop)){
int summary = stackTop->currentSum;
TreeNode *currentNode = stackTop->treeNode;
stackTop = StackPop(stackTop);
while(currentNode->left || currentNode->right){
if(currentNode->left && currentNode->right){
stackTop = StackPush(stackTop, currentNode->right, summary);
currentNode->right = NULL;
}
currentNode = (currentNode->left)?currentNode->left:currentNode->right;
summary += currentNode->val;
}
if(summary == sum) return true;
}
return false;
}
int ABPMultSum (PtABPNode proot, int pvalue)
{
PtABPNode node = proot;
PtStack stack;
int sum = 0;
if (proot == NULL) {
Error = ABP_EMPTY;
return -1;
}
if ((stack = StackCreate(sizeof(PtABPNode))) == NULL) {
Error = NO_MEM;
return -1;
}
StackPush(stack, &node);
while (!StackIsEmpty(stack)) {
StackPop(stack, &node);
if (!(node->Elem % pvalue))
sum += node->Elem;
if (node->PtRight != NULL)
StackPush(stack, &(node->PtRight));
if (node->PtLeft != NULL)
StackPush(stack, &(node->PtLeft));
}
StackDestroy(&stack);
Error = OK;
return sum;
}
void ABPPostOrderRep (PtABPNode proot) /* travessia em pós-ordem repetitiva - repetitive post-order traversal */
{
PtABPNode Node = proot, Last = proot; PtStack Stack;
if (proot == NULL) { Error = ABP_EMPTY; return; } /* arvore vazia - empty tree */
if ((Stack = StackCreate (sizeof (PtABPNode))) == NULL) { Error = NO_MEM ; return; }
while (1) /* enquanto houver elementos para visitar - while there are nodes */
{
/* travessia pela esquerda até atingir a folha mais à esquerda - left traversal until the left most leaf */
while (Node->PtLeft != NULL)
{ StackPush (Stack, &Node); Node = Node->PtLeft; }
/* se não tem subarvore direita ou já completou a sua travessia - without right subtree or already completed the traversal */
while (Node->PtRight == NULL || Node->PtRight == Last)
{
printf ("%d ", Node->Elem); /* imprimir o elemento - printing the element */
Last = Node; /* assinalar último elemento visitado - marking the last visited element */
/* terminar quando não há mais elementos na pilha - terminate when there are no more elments in the stack */
if (StackIsEmpty (Stack)) { StackDestroy (&Stack); Error = OK; return; }
StackPop (Stack, &Node); /* retirar o elemento anterior - retrieve the preview element */
}
StackPush (Stack, &Node); /* recolocar o elemento na pilha - restore the element in the stack */
Node = Node->PtRight; /* iniciar travessia da subarvore direita - start the right subtree traversal */
}
}
void ABPInOrderRep (PtABPNode proot) /* travessia em in-ordem repetitiva - repetitive in-order traversal */
{
PtABPNode Node = proot; PtStack Stack;
if (proot == NULL) { Error = ABP_EMPTY; return; } /* arvore vazia - empty tree */
if ((Stack = StackCreate (sizeof (PtABPNode))) == NULL) { Error = NO_MEM ; return; }
StackPush (Stack, &Node); /* armazenar a raiz - storing the root */
while (!StackIsEmpty (Stack))
{
if (Node != NULL) /* não é um no externo - not an external node */
{
Node = Node->PtLeft;
StackPush (Stack, &Node); /* subarvore esquerda - left subtree */
}
else /* é um no externo */
{
StackPop (Stack, &Node); /* retirar e descartar o no externo - retrieve and ignore the external node */
if (!StackIsEmpty (Stack))
{
StackPop (Stack, &Node); /* recuperar o no anterior - retrieve and preview node */
printf ("%d ", Node->Elem); /* imprimir o elemento - printing the element */
Node = Node->PtRight; /* subarvore direita - right subtree */
StackPush (Stack, &Node);
}
}
}
StackDestroy (&Stack); /* destruir a pilha - releasing the stack */
Error = OK;
}
unsigned int ABPSizeRep (PtABPNode proot) /* cálculo do número de elementos repetitiva - repetitive number of nodes */
{
PtABPNode Node = proot; PtStack Stack; unsigned int Number = 0;
if (proot == NULL) { Error = ABP_EMPTY; return 0; } /* arvore vazia - empty tree */
if ((Stack = StackCreate (sizeof (PtABPNode))) == NULL) { Error = NO_MEM ; return 0; }
StackPush (Stack, &Node); /* armazenar a raiz - storing the root */
while (!StackIsEmpty (Stack)) /* enquanto existirem nos - while there are nodes */
{
StackPop (Stack, &Node); /* recuperar o no - retrieve the node */
Number++; /* contar o no - counting the node */
/* armazenar a raiz da subarvore esquerda - storing the left subtree root */
if (Node->PtLeft != NULL) StackPush (Stack, &Node->PtLeft);
/* armazenar a raiz da subarvore direita - storing the right subtree root */
if (Node->PtRight != NULL) StackPush (Stack, &Node->PtRight);
}
StackDestroy (&Stack); /* destruir a pilha - releasing the stack */
Error = OK;
return Number;
}
/** Creates an instance of stacked memory.
*
* @param StackedMemory Address of variable that, in case of success, receives
* address of new stacked memory object.
*
* @return
* The function returns NTSTATUS value indicating success or failure of the operation.
*/
NTSTATUS StackedMemoryCreate(POOL_TYPE PoolType, PUTILS_STACK *StackedMemory)
{
PUTILS_STACK tmpStackedMemory = NULL;
NTSTATUS status = STATUS_UNSUCCESSFUL;
DEBUG_ENTER_FUNCTION("PoolType=%u; StackedMemory=0x%p", PoolType, StackedMemory);
*StackedMemory = NULL;
status = StackCreate(PoolType, &tmpStackedMemory);
if (NT_SUCCESS(status))
*StackedMemory = tmpStackedMemory;
DEBUG_EXIT_FUNCTION("0x%x, *StackedMemory=0x%p", status, *StackedMemory);
return status;
}
stk_stack* RBEnumerate(rb_red_blk_tree* tree, void* low, void* high) {
stk_stack* enumResultStack;
rb_red_blk_node* nil=tree->nil;
rb_red_blk_node* x=tree->root->left;
rb_red_blk_node* lastBest=nil;
enumResultStack=StackCreate();
while(nil != x) {
if ( 1 == (tree->comp_func(x->key,high)) ) { /* x->key > high */
x=x->left;
} else {
lastBest=x;
x=x->right;
}
}
while ( (lastBest != nil) && (1 != tree->comp_func(low,lastBest->key))) {
StackPush(enumResultStack,lastBest);
lastBest=TreePredecessor(tree,lastBest);
}
return(enumResultStack);
}
int ABPEvenOrderSum (PtABPNode proot)
{
PtABPNode node = proot;
PtStack stack;
int order = 0, sum = 0;
if (proot == NULL) {
Error = ABP_EMPTY;
return -1;
}
if ((stack = StackCreate(sizeof(PtABPNode))) == NULL) {
Error = NO_MEM;
return -1;
}
StackPush(stack, &node);
while(!StackIsEmpty(stack)) {
if (node != NULL) {
node = node->PtLeft;
StackPush(stack, &node);
} else {
StackPop(stack, &node);
if (!StackIsEmpty(stack)) {
StackPop(stack, &node);
if (order++ & 1)
sum += node->Elem;
node = node->PtRight;
StackPush(stack, &node);
}
}
}
StackDestroy(&stack);
Error = OK;
return sum;
}
STKSTACK
RbEnumerate (RBTREE tree, RBKEY low, RBKEY high)
{
STKSTACK enumResultStack=0;
RBNODE nil=tree->nil;
RBNODE x=tree->root->left;
RBNODE lastBest=nil;
enumResultStack=StackCreate();
while(nil != x) {
if ( 0 < (TreeCompare(tree, x->key, high)) ) { /* x->key > high */
x=x->left;
} else {
lastBest=x;
x=x->right;
}
}
while ( (lastBest != nil) && (0 >= TreeCompare(tree, low,lastBest->key))) {
StackPush(enumResultStack,lastBest);
lastBest=RbTreePredecessor(tree,lastBest);
}
return(enumResultStack);
}
void ABPPreOrderRep (PtABPNode proot) /* travessia em pré-ordem repetitiva - repetitive pre-order traversal */
{
PtABPNode Node = proot; PtStack Stack;
if (proot == NULL) { Error = ABP_EMPTY; return; } /* arvore vazia - empty tree */
if ((Stack = StackCreate (sizeof (PtABPNode))) == NULL) { Error = NO_MEM ; return; }
StackPush (Stack, &Node); /* armazenar a raiz - storing the root */
while (!StackIsEmpty (Stack)) /* enquanto existirem nos - while there are nodes */
{
StackPop (Stack, &Node); /* recuperar o no - retrieve the node */
printf ("%d ", Node->Elem); /* imprimir o elemento - printing the element */
/* colocar a raiz da subarvore direita, caso exista - storing the right subtree root if it exists */
if (Node->PtRight != NULL) StackPush (Stack, &Node->PtRight);
/* colocar a raiz da subarvore esquerda, caso exista - storing the left subtree root if it exists */
if (Node->PtLeft != NULL) StackPush (Stack, &Node->PtLeft);
}
StackDestroy (&Stack); /* destruir a pilha - releasing the stack */
Error = OK;
}
int main(int argc, char* argv[], char** envp)
{
int i = 0;
int count = 20;
char *s1 = "abcdefg";
char *s2 = "g";
size_t len1 = 0;
size_t n = 3;
char dest[20];
node_t *node1 = NULL;
node_t *node2 = NULL;
node_t *node3 = NULL;
node_t *node4 = NULL;
node_t *node5 = NULL;
char *t = NULL;
stack_t *stack = NULL;
size_t n1 = 1;
size_t n2 = 2;
size_t n3 = 3;
size_t n4 = 4;
size_t n5 = 5;
/*__________ RecFibonacci __________*/
printf("\n[%s %s %d]RecFibonacci\n", __FILE__, __func__, __LINE__);
for (i = 0; i < count; ++i)
{
printf("RecFibonacci(%i):%i\n", i , RecFibonacci(i));
}
/*__________ RecStrlen __________*/
printf("\n[%s %s %d]RecStrlen\n", __FILE__, __func__, __LINE__);
len1 = RecStrlen(s1);
printf("len1:%lu\n", len1);
/*__________ RecStrcmp __________*/
printf("\n[%s %s %d]RecStrcmp\n", __FILE__, __func__, __LINE__);
printf("RecStrcmp(s1, s2): %i\n", RecStrcmp(s1, s2));
/*__________ RecStrncmp __________*/
printf("\n[%s %s %d]RecStrncmp\n", __FILE__, __func__, __LINE__);
printf("RecStrncmp(s1, s2, n): %i\n", RecStrncmp(s1, s2, n));
/*__________ RecStrstr __________*/
printf("\n[%s %s %d]RecStrstr\n", __FILE__, __func__, __LINE__);
printf("RecStrstr(s1, s2):%s\n", RecStrstr(s1, s2));
/*__________ RecStrcpy __________*/
printf("\n[%s %s %d]RecStrcpy\n", __FILE__, __func__, __LINE__);
t = RecStrcpy(dest, s1);
printf("RecStrcpy(dest, s1):%s expected result:%s\n", t, dest);
/*__________ RecStrcat __________*/
printf("\n[%s %s %d]RecStrcat\n", __FILE__, __func__, __LINE__);
printf("RecStrcat(dest, s1):%s expected result:%s\n",
RecStrcat(dest, s1), "abcgefgabcdefg");
/*__________ RecSlistFlip __________*/
printf("\n[%s %s %d]RecSListFlip\n", __FILE__, __func__, __LINE__);
node5 = SListCreateNode((void*)5, NULL);
node4 = SListCreateNode((void*)4, node5);
node3 = SListCreateNode((void*)3, node4);
node2 = SListCreateNode((void*)2, node3);
node1 = SListCreateNode((void*)1, node2);
printf("SListCount(node1):%lu\n", SListCount(node1));
RecSListFlip(node1);
printf("SListCount(node1):%lu\n", SListCount(node5));
SListFreeAll(node5);
/*__________ Compere __________*/
printf("\n[%s %s %d]Compere\n", __FILE__, __func__, __LINE__);
printf("Compere(&n1, &n2):%i expected result:1\n", Compere(&n1, &n2));
printf("Compere(&n1, &n1):%i expected result:1\n", Compere(&n1, &n2));
printf("Compere(&n2, &n1):%i expected result:0\n", Compere(&n2, &n1));
/*_________________________ END Compere _______________________*/
/*________________________________________________________________*/
printf("\n[%s %s %d]RecStackSort\n", __FILE__, __func__, __LINE__);
/*_________________________ RecStackSort _______________________*/
stack = StackCreate(sizeof(size_t), 5);
assert(stack);
StackPush(stack, &n3);
StackPush(stack, &n2);
StackPush(stack, &n5);
StackPush(stack, &n4);
StackPush(stack, &n1);
RecStackSort(stack, &Compere, sizeof(size_t));
for( ; StackSize(stack); StackPop(stack))
{
printf("StackPeek(stack):%lu\n", *(size_t*)StackPeek(stack));
}
StackDestroy(stack);
return(0);
}
/* compile all rules */
EtalisExecTree* buildExecTree()
{
printf("--- Generating Rule Tree ...\n");
EtalisExecTree* tree = calloc(1,sizeof(EtalisExecTree));
tree->size=3; /* TODO (hafsi#4#): fixme */ /*if more than one rule, find out how many complex events*/
tree->exec=print_event;
tree->complexEvents = (EtalisExecNode*)calloc(tree->size,sizeof(EtalisExecNode));
EtalisBatch* temp_batch = (EtalisBatch*)malloc(sizeof(EtalisBatch));
int i=0;
static predicate_t p;
term_t _args_binary_event_rule = PL_new_term_refs(3);
atom_t name;
int temp_arity;
if ( !p )
p = PL_predicate("binary_event_rule", 3, NULL);
qid_t qid = PL_open_query(NULL, PL_Q_NORMAL, p, _args_binary_event_rule);
while(PL_next_solution(qid) != FALSE)
{
EtalisEventNode* temp_event = tree->complexEvents+i; /* next complex event */
EtalisExecNode* temp_operator =(EtalisExecNode*)malloc(sizeof(EtalisExecNode));
memset(temp_operator,0,sizeof(EtalisExecNode));
assert( temp_event != NULL && temp_operator != NULL);
temp_event->parentNode=NULL; /*a complex event does not have a parent*/
temp_event->childNode=temp_operator;
temp_event->trigger=_cep_print_event; /* by default, triggering a complx event would print it */
temp_operator->parentEvent=temp_event;
temp_batch->batchSize=1;
temp_batch->nodes=temp_operator;
/*get label*/
PL_get_name_arity(_args_binary_event_rule, &name, &temp_arity);
strcpy(temp_batch->label,PL_atom_chars(name));
/*get complex event*/
PL_get_name_arity(_args_binary_event_rule+1, &name, &temp_arity);
strcpy(temp_event->event.name,PL_atom_chars(name));
temp_event->event.arity = temp_arity;
/*get rule*/
construct_rule(temp_batch,_args_binary_event_rule+2);
/* init a stack for each event*/
/* query the tree in the depth */
EtalisEventNode* temp_event_index = temp_operator->leftChild;
for (temp_event_index = temp_operator->leftChild;temp_event_index->childNode != NULL;temp_event_index = temp_event_index->childNode->leftChild)
{
temp_event_index->eventStack = StackCreate();
if(temp_event_index->parentNode->op_type == binary)
temp_event_index->parentNode->rightChild->eventStack = StackCreate();
}
/* Create stack for leaf nodes*/
temp_event_index->eventStack = StackCreate();
if(temp_event_index->parentNode->op_type == binary)
temp_event_index->parentNode->rightChild->eventStack = StackCreate();
/* build argument logical models */
/*
if(temp_operator->has_condition == ETALIS_TRUE)
{
;
build_args_map(temp_operator,_args_binary_event_rule+1,_args_binary_event_rule+2);
}
else
{
build_args_map(temp_operator,_args_binary_event_rule+1,_args_binary_event_rule+2);
}
*/
/*print the rule*/ /* only if debugging */
#ifdef DEBUG
/*print_rule(temp_event);*/
#endif
/*add to event hash*/
addToEventHash(temp_operator);
i++; /*next rule*/
};
PL_close_query(qid);
/*from the rules build the tree*/
printf("--- Done!\n");
return tree;
}
int test_swap ( void )
{
Stack_t *sp = NULL;
Stack_t *sp1= NULL;
Stack_t *sp2 = NULL;
Stack_t *sp3 = NULL;
Stack_t *sp4 = NULL;
Stack_t *sp5 = NULL;
Stack_t *sp6 = NULL;
Stack_t *sp7 = NULL;
Stack_t *sp8 = NULL;
Stack_t *sp9 = NULL;
printf("test_swap - create <int> stack\n");
sp = StackCreate(4);
sp1= StackCreate(4);
(void)push(sp,100);
(void)push(sp,200);
(void)push(sp,300);
(void)push(sp,700);
(void)push(sp1,101);
(void)push(sp1,201);
(void)push(sp1,301);
(void)push(sp1,701);
(void)StackDestroy(sp);
printf("\tTest01 swap - same size, but stack freed -1 = %d\n", swap(sp,sp1));
/*
* Test02 positive swap - same size
*/
sp2 = StackCreate(4);
sp3 = StackCreate(4);
(void)push(sp2,1);
(void)push(sp2,2);
(void)push(sp2,3);
(void)push(sp2,4);
printf("\tTest02 - before sp2\n");
StackDump(sp2,0);
(void)push(sp3,5);
(void)push(sp3,6);
(void)push(sp3,7);
(void)push(sp3,8);
printf("\tTest02 - before sp3\n");
StackDump(sp3,0);
printf("Test02 swap same size, but ok 0 = %d\n", swap(sp2,sp3));
printf("\tTest02 - after sp2\n");
StackDump(sp2,0);
printf("\tTest02 - after sp3\n");
StackDump(sp3,0);
/*
* Test04 positive swap - src size is less than dst, will need to increase src
*/
sp6 = StackCreate(2); /* src */
sp7 = StackCreate(4); /* dst */
(void)push(sp6,1);
(void)push(sp6,2);
printf("\tTest04 - before sp6, size %d\n", size(sp6));
StackDump(sp6,0);
(void)push(sp7,3);
(void)push(sp7,4);
(void)push(sp7,5);
(void)push(sp7,4);
printf("\tTest04 - before sp7, size %d\n", size(sp7));
StackDump(sp7,0);
printf("Test04 swap dst size less than src size, but ok 0 = %d\n", swap(sp6,sp7));
printf("\tTest04 - after sp6, size %d\n", size(sp6));
StackDump(sp6,0);
printf("\tTest04 - after sp7, size %d\n", size(sp7));
StackDump(sp7,0);
/*
* Test05 positive swap - dst size is less than src, will need to increase dst
*/
sp8 = StackCreate(2); /* dst */
sp9 = StackCreate(4); /* src */
(void)push(sp8,101);
(void)push(sp8,201);
printf("\tTest05 - before dst sp8, size %d\n", size(sp8));
StackDump(sp8,0);
(void)push(sp9,301);
(void)push(sp9,401);
(void)push(sp9,501);
(void)push(sp9,401);
printf("\tTest05 - before src sp9, size %d\n", size(sp9));
StackDump(sp9,0);
printf("Test05 swap dst size less than src size, but ok 0 = %d\n", swap(sp9,sp8));
printf("\tTest05 - after dst sp8, size %d\n", size(sp8));
StackDump(sp8,0);
printf("\tTest05 - after src sp9, size %d\n", size(sp9));
StackDump(sp9,0);
printf("test_swap - Ends\n");
StackDestroy(sp );
StackDestroy(sp1);
StackDestroy(sp2);
StackDestroy(sp3);
StackDestroy(sp4);
StackDestroy(sp5);
StackDestroy(sp6);
StackDestroy(sp7);
StackDestroy(sp8);
StackDestroy(sp9);
return 0;
}
foreign_t
make_buffer(void){
event_stack = StackCreate();
return (event_stack) ? TRUE : FALSE;
}
