int eval(linkedlist *expr, double *val) {
int i;
stack_t stk; /* operator stack */
stack_init(&stk);
for(i = 0; i < linkedlist_size(expr); i++) {
token_t *t = linkedlist_get(expr, i);
token_t *n2, *n1, *res;
/* if number, push to stack: */
if (t->type == TOKEN_NUMBER) {
stack_push(&stk, t);
continue;
}
/* all operators in the postfix expression are binary. */
if (stack_size(&stk) < 2) {
while(!stack_isEmpty(&stk))
free(stack_pop(&stk));
/* free the remaining tokens in expr: */
while(i < linkedlist_size(expr))
free(linkedlist_get(expr, i++));
return -1; /* error. */
}
n2 = stack_pop(&stk);
n1 = stack_pop(&stk);
res = malloc(sizeof(token_t));
res->type = TOKEN_NUMBER;
res->op = 0;
res->num = do_op(n1->num, n2->num, t->op);
stack_push(&stk, res);
free(n2);
free(n1);
free(t);
}
if (stack_size(&stk) != 1) {
while(!stack_isEmpty(&stk)) {
free(stack_pop(&stk));
}
return -1; /* error. */
}
*val = ((token_t *) stack_peek(&stk))->num;
free(stack_pop(&stk));
return 0;
}
int main(void)
{
struct stack s;
char i;
printf("Initializing stack...\n");
stack_init( s, 4);
for(i='A';i<='Z';i++)
{
printf("push: %c\t%d\t%d\n",i,s.elements,s.kapacitas);
// Itt nézzük a s.pData változót debuggerbol, lépjünk bele a függvénybe
stack_push(s,i);
}
while(!stack_isEmpty(s))
{
// Itt nézzük a s.pData változót debuggerbol, lépjünk bele a függvénybe
//és esetleg ellenõrizzük az elemszámot és a kapacitást
printf("pop: %c\t%d\t%d\n",(char)stack_pop(s),s.elements,s.kapacitas);
}
// Üres stackbol kivétel: hiba (-1)
printf("pop: %d\n",stack_pop(s));
printf("Cleaning up stack...\n");
stack_cleanUp(s);
return 0;
}
void
*stack_pop(Stack *s) {
if (stack_isEmpty(s)) {
fprintf(stderr, "Stack is empty\n");
return NULL;
}
return s->A[s->top--];
}
void exampleStack()
{
// Use pooling for efficiency, if you don't want to use pooling
// then comment out this line.
pool_stack(16);
Stack* S = newStack();
// A stack with strings
stack_push(S, "Out.");
stack_push(S, "First");
stack_push(S, "In");
stack_push(S, "Last");
// Peek at the top of the stack
printf("%s\n", (char*)stack_peek(S));
// Traverse through the stack popping each string
while (!stack_isEmpty(S))
printf("%s ", (char*)stack_pop(S));
printf("\n");
// Fill up the stack and then clear it.
stack_push(S, "A");
stack_push(S, "B");
stack_push(S, "C");
int size = S->size;
stack_clear(S);
if (stack_isEmpty(S))
printf("The Stack had %d items but now has 0\n", size);
// This will clear the stack of any nodes and pool them and then free
// the stack itself from memory
stack_free(S);
// If you're not using pooling this can be commented out. This will
// free all pooled nodes from memory. Always call this at the end
// of using any Stack.
unpool_stack();
}
void
stack_print(Stack *s, void(printFn)(void *)) {
int i;
if (stack_isEmpty(s)) {
fprintf(stderr, "Empty Stack\n");
return;
}
for (i=0;i<s->top;i++) {
printFn(s->A[i]);
}
printf("\n");
}
/*
* return value:
* 1 -- pop success
* 0 -- pop fail due to empty stack
* -1 -- exception
* */
int stack_pop(stack *pstack, bst_node **ppselem)
{
int iRet=1;
bst_node selem;
LOGD("[F:%s, L:%d]\n", __FUNCTION__, __LINE__);
if(pstack == NULL || pstack->pStackHeader == NULL || ppselem == NULL) {
return -1;
}
if(stack_isEmpty(pstack)) {
return 0;
}
*ppselem = *pstack->pStackHeader;
pstack->pStackHeader--;
pstack->nStackCurSize--;
return iRet;
}
static int bst_inorderTraverse(bst *pbst)
{
int iRet=1;
bst_node *pCurNode=NULL;
if(pbst==NULL || pbst->pBstRoot==NULL) {
return -1;
}
pCurNode = pbst->pBstRoot;
do {
//1. find most lest node, visit
while(pCurNode!=NULL && pCurNode->pL!=NULL) {
stack_push(&pbst->stack, pCurNode);
pCurNode = pCurNode->pL;
}
bst_visitNode(pCurNode);
//2. if current node has right tree, stack_push, update current Node
// then goto step1; otherwise goto step3
do {
if(pCurNode->pR != NULL) {
stack_push(&pbst->stack, pCurNode);
pCurNode = pCurNode->pR;
break;
} else{
//3. stack_pop to current node, if current has been visited, goto step3; otherwise visit
// goto step2
do {
iRet = stack_pop(&pbst->stack, &pCurNode);
}while(iRet==1 && pCurNode->nIsVisited);
if(iRet == 1) {
bst_visitNode(pCurNode);
} else{
break;
}
}
}while(1);
}while(stack_isEmpty(&pbst->stack)==0);
return iRet;
}
/*
* return value:
* 1 -- pop success
* 0 -- pop fail due to empty stack
* -1 -- exception
* */
int stack_pop(stack *pstack, stack_elem *pselem)
{
int iRet=1;
stack_elem selem;
printf_dbg("[F:%s, L:%d]\n", __FUNCTION__, __LINE__);
if(pstack == NULL || pstack->pStackHeader == NULL || pstack == NULL) {
return -1;
}
if(stack_isEmpty(pstack)) {
return 0;
}
pselem->x= pstack->pStackHeader->x;
pselem->y= pstack->pStackHeader->y;
pselem->nDir= pstack->pStackHeader->nDir;
pstack->pStackHeader--;
pstack->nStackCurSize--;
return iRet;
}
int main(void)
{
struct stack s;
char i;
printf("Initializing stack...\n");
stack_init( s, 4);
for(i='A';i<='Z';i++)
{
printf("push: %c\t%d\t%d\n",i,s.elements,s.kapacitas);
stack_push(s,i);
}
while(!stack_isEmpty(s))
{
printf("pop: %c\t%d\t%d\n",(char)stack_pop(s),s.elements,s.kapacitas);
}
printf("pop: %d\n",stack_pop(s));
printf("Cleaning up stack...\n");
stack_cleanUp(s);
return 0;
}
int main(int argc, char *argv[])
{
char command[32];
int eventsNr, eventId, procId, priority;
int i, iteration;
TStack **eventsStacks;
TQueue *procQ;
// Daca nu exista destule argumente la rularea programului, atunci opreste executia
if (argc < 3)
{
printf("Argumente insuficiente!\n");
return -1;
}
// Seteaza fisierele de intrare si de iesire
freopen(argv[1], "r", stdin);
freopen(argv[2], "w", stdout);
// Citeste numarul de event-uri si creeaza stivele lor
fscanf(stdin, "%d", &eventsNr);
eventsStacks = calloc(eventsNr, sizeof(TStack*));
for (i = 0; i < eventsNr; i++)
{
eventsStacks[i] = stack_new(sizeof(TProcess));
}
// Creeaza coada de prioritati
procQ = queue_new(sizeof(TProcess), compare_process);
// Citeste si executa comenzile din fisierul de intrare
iteration = 0;
while (fscanf(stdin, "%s", command) != EOF)
{
iteration++;
if (strcmp(command, "start") == 0)
{
fscanf(stdin, "%d", &procId);
fscanf(stdin, "%d", &priority);
// Creeaza un proces
TProcess p;
p.id = procId;
p.priority = priority;
p.iteration = iteration;
// Introduce procesul creat in coada de prioritati
queue_push(procQ, &p);
}
else if (strcmp(command, "wait") == 0)
{
fscanf(stdin, "%d", &eventId);
fscanf(stdin, "%d", &procId);
// Creaza o stiva auxiliara
TStack *aux = stack_new(sizeof(TProcess));
// Muta procesele in stiva auxiliara pana cand procesul
// cautat este gasit si mutat in stiva evenimentului
TProcess *p;
while (!queue_isEmpty(procQ))
{
p = queue_pop(procQ);
if (p->id == procId)
{
stack_push(eventsStacks[eventId], p);
free_process(p);
break;
}
stack_push(aux, p);
free_process(p);
}
// Muta procesele din stiva auxiliara inapoi in coada
// de prioritati
while (!stack_isEmpty(aux))
{
p = stack_pop(aux);
queue_push(procQ, p);
free_process(p);
}
// Distruge stiva auxiliara
stack_destroy(&aux, free_process);
}
else if (strcmp(command, "event") == 0)
{
fscanf(stdin, "%d", &eventId);
// Muta procesele din stiva evenimentului in coada
// de prioritati
TProcess *p;
while (!stack_isEmpty(eventsStacks[eventId]))
{
p = stack_pop(eventsStacks[eventId]);
queue_push(procQ, p);
free_process(p);
}
}
else if (strcmp(command, "end") == 0)
{
fscanf(stdin, "%d", &procId);
// Creaza o stiva auxiliara
TStack *aux = stack_new(sizeof(TProcess));
// Muta procesele in stiva auxiliara pana cand procesul
// cautat este gasit si sters
TProcess *p;
while (!queue_isEmpty(procQ))
{
p = queue_pop(procQ);
if (p->id == procId)
{
free_process(p);
break;
}
stack_push(aux, p);
free_process(p);
}
// Muta procesele din stiva auxiliara inapoi in coada
// de prioritati
while (!stack_isEmpty(aux))
{
p = stack_pop(aux);
queue_push(procQ, p);
free_process(p);
}
// Distruge stiva auxiliara
stack_destroy(&aux, free_process);
}
// Afiseaza iteratia
printf("%d\n", iteration);
// Afiseaza coada de prioritati
if (!queue_isEmpty(procQ))
{
queue_print(procQ, print_process);
}
else
{
printf("\n");
}
// Afiseaza stivele
for (i = 0; i < eventsNr; i++)
{
if (!stack_isEmpty(eventsStacks[i]))
{
printf("%d: ", i);
stack_print(eventsStacks[i], print_process);
}
}
printf("\n");
}
// Elibereaza memoria
queue_destroy(&procQ, free_process);
for (i = 0; i < eventsNr; i++)
{
stack_destroy(&eventsStacks[i], free_process);
}
free(eventsStacks);
return 0;
}
Stack* Recorrer(Maze *m, Point *input){
int i;
Stack *paux = NULL; /*pila auxiliar*/
Stack *pcamino = NULL; /*pila del camino seguido*/
EleStack *pele = NULL; /*punto donde nos encontramos*/
EleStack *pelepoint = NULL; /*Punto vecino*/
Point *ppoint = NULL;
Point *ppoint2 = NULL;
if(!m){
printf("Error pasando el maze\n");
return NULL;
}
if(!input){
printf("Error pasando el input\n");
return NULL;
}
paux = stack_ini();
if (!paux){
printf ("Error en reserva memoria paux\n");
return NULL;
}
pcamino = stack_ini();
if (!pcamino){
printf ("Error reserva memoria pcamino\n");
stack_free (paux);
return NULL;
}
pele = elestack_ini();
if (!pele){
printf ("Error reserva memoria pele\n");
stack_free(paux);
stack_free(pcamino);
return NULL;
}
if (!elestack_setInfo(pele, input)){ /*Guardamos el punto input en pele*/
printf ("Error en setInfo de pele\n");
elestack_free(pele);
stack_free(paux);
stack_free(pcamino);
return NULL;
}
if(!stack_push (paux, pele)){ /*Introducimos pele en la pila auxiliar*/
printf("Error push del input\n");
elestack_free(pele);
stack_free(paux);
stack_free(pcamino);
return NULL;
}
elestack_free(pele);
while (!stack_isEmpty(paux)){ /*mientras la pila auxiliar no esta vacia*/
pele = stack_pop(paux); /*extraemos el punto superior de la pila y nos "situamos" ahi*/
stack_push(pcamino, pele); /*Como visitamos ese punto lo introducimos en el camino*/
point_setSymbol(maze_getPoint(m, point_getCoordinateX((Point *)elestack_getInfo(pele)), point_getCoordinateY((Point *)elestack_getInfo(pele))), VISITADO);
/*Modificamos el simbolo del punto a VISITADO, lo guardamos en el laberinto original*/
for(i = 0; i <= DOWN; i++){ /*Comprobamos las 4 direcciones que se pueden seguir dentro de un laberinto*/
pelepoint = elestack_ini();
if(!pelepoint){
printf("Error en elestack_ini\n");
elestack_free(pele);
stack_free(paux);
stack_free(pcamino);
return NULL;
}
ppoint2 = (Point*)elestack_getInfo(pele); /*Obtenemos el punto de pele*/
if(!ppoint2){
printf("Error al obtener el punto de pele");
elestack_free(pelepoint);
elestack_free(pele);
stack_free(paux);
stack_free(pcamino);
return NULL;
}
ppoint = maze_getNeighborPoint(m, ppoint2, i); /*Obtenemos el punto vecino en la direccion que indica "i"*/
if(!ppoint){
printf("Error ppoint 1\n");
elestack_free(pelepoint);
elestack_free(pele);
stack_free(paux);
stack_free(pcamino);
return NULL;
}
if(!elestack_setInfo(pelepoint, (void*)ppoint)){ /*Asignamos a pelepoint el punto vecino*/
printf("Error setinfo\n");
elestack_free(pelepoint);
elestack_free(pele);
stack_free(paux);
stack_free(pcamino);
return NULL;
}
if(point_getSymbol(ppoint) == SPACE){ /*Introducimos el punto en la pila auxiliar SOLO si es un SPACE*/
if(!stack_push(paux, pelepoint)){
printf("Error al hacer el push de pelepoint");
elestack_free(pelepoint);
elestack_free(pele);
stack_free(paux);
stack_free(pcamino);
return NULL;
}
}
else if(point_getSymbol(ppoint) == OUTPUT){ /*Si el punto es el OUTPUT, lo introduce en el camino y devuelve dicha pila*/
stack_push(pcamino, pelepoint);
elestack_free(pelepoint);
elestack_free(pele);
stack_free(paux);
return pcamino;
}
elestack_free(pelepoint);
}
elestack_free(pele);
}
stack_free(paux);
stack_free(pcamino);
return NULL;
}
void processExpression (token inputToken, FILE *in, int d)
{
/**********************************************/
/* Declare both stack head pointers here */
Stack ops = stack_init( ops);
Stack nums = stack_init( nums);
/* Loop until the expression reaches its End */
while (inputToken.type != EOLN)
{
/* The expression contains an OPERATOR */
if (inputToken.type == OPERATOR)
{
/* make this a debugMode statement */
if( d) printf ("OP:%c, " ,inputToken.op);
// add code to perform this operation here
//if the op is a open paren
if( inputToken.op == '(' )
stack_push_ch( ops, inputToken.op);
//if the op is + or -
else if( inputToken.op == '+' || inputToken.op == '-'){
while( !stack_isEmpty(ops) && (stack_peek_ch(ops) == '+'
|| stack_peek_ch(ops) == '-'
|| stack_peek_ch(ops) == '/'
|| stack_peek_ch(ops) == '*') ){
stack_pop_eval_push( ops, nums);
}
stack_push_ch( ops,inputToken.op);
}
//if the op is * or /
else if( inputToken.op == '*' || inputToken.op == '/'){
while( !stack_isEmpty(ops) && (stack_peek_ch(ops) == '/'
|| stack_peek_ch(ops) == '*') ){
stack_pop_eval_push( ops, nums);
}
stack_push_ch( ops,inputToken.op);
}
//if the op is a closing paren
else if( inputToken.op == ')' ){
while( !stack_isEmpty(ops) && stack_peek_ch(ops) != '(' ){
stack_pop_eval_push( ops, nums);
}
if( stack_isEmpty( ops)) printf("ERROR, no closing parenthesis!\n");
else stack_pop_ch( ops); //pop the open parenthesis
}
}
/* The expression contain a VALUE */
else if (inputToken.type == VALUE)
{
/* make this a debugMode statement */
if(d) printf ("Val: %d, ", inputToken.val);
// add code to perform this operation here
stack_push_i( nums, inputToken.val);
}
/* get next token from input */
inputToken = getInputToken (in);
}
/* The expression has reached its end */
// add code to perform this operation here
while( !stack_isEmpty( ops) ){
stack_pop_eval_push( ops, nums);
}
printf("The top of the val stack: %d\n", stack_peek_i( nums) );
stack_pop_i( nums);
if( !stack_isEmpty( nums) ) printf("ERROR, leftover nums on num stack\n");
stack_free( ops);
stack_free( nums);
printf ("\n");
}
