V2_evaluate_expression

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdbool.h>
#include<math.h>
#include<ctype.h>
typedef struct stack{
    union {
        float number;
        char operatorToken;
    }Template;
    struct stack *next;
}stack;
void push(stack **dest,stack *holder){
    holder->next=*dest;
    *dest=holder;
}
stack pop(stack **src){
    stack *temp=*src;
    *src=(*src)->next;
    return *temp;
}
stack *createStack(){
    stack *newStack = malloc(sizeof(stack));
    return newStack;
}
bool isEmpty(stack *src){
    if(src==NULL){return true;}
    return false;
}
int priority(char token,bool inStack){
    if(inStack&&token=='('){return 0;}
    switch(token){
        case '+': case '-':return 1;
        case '*': case '/':return 2;
        case '(': case '%': return 3;
        case '^':case '#':case '@':  return 4;
    }
}
float evaluate(char *postfix){
    float prev,next;
    int token=-1;
    stack *numberStack=createStack();
    numberStack=NULL;
    stack *holder=NULL;
    while(postfix[++token]!='\0'){
        holder=createStack();
        if(isdigit(postfix[token])){
            holder->Template.number=(float)(postfix[token]-'0');
            push(&numberStack,holder);
        }
        else{
            switch(postfix[token]){
                case '+':
                    holder->Template.number=pop(&numberStack).Template.number+pop(&numberStack).Template.number;
                    push(&numberStack,holder);
                    break;
                case '-':
                    next=pop(&numberStack).Template.number;
                    prev=pop(&numberStack).Template.number;
                    holder->Template.number=prev-next;
                    push(&numberStack,holder);
                    break;
                case '*':
                    holder->Template.number=pop(&numberStack).Template.number*pop(&numberStack).Template.number;
                    push(&numberStack,holder);
                    break;
                case '/':
                    next=pop(&numberStack).Template.number;
                    prev=pop(&numberStack).Template.number;
                    holder->Template.number=prev/next;
                    push(&numberStack,holder);
                    break;
                case '#':
                    numberStack->Template.number*=-1;
                    break;
                case '@':
                    numberStack->Template.number*=1;
                    break;
                case '^':
                    next=pop(&numberStack).Template.number;//exponent
                    prev=pop(&numberStack).Template.number;//base
                    holder->Template.number=pow(prev,next);
                    push(&numberStack,holder);
                    break;
                case '%':
                    /*watch out you can't have % operator on float*/
                    next=pop(&numberStack).Template.number;
                    prev=pop(&numberStack).Template.number;
                    float temp =(int)prev%(int)(next);
                    holder->Template.number=temp;
                    push(&numberStack,holder);
                    break;
            }

        }
    }
    return pop(&numberStack).Template.number;
}
void main(){
    stack *operatorStack=createStack();
    operatorStack=NULL;
    stack *holder=NULL;
    char postfix[256]={};int tokenPostfix=-1;
    char   infix[256]={};int tokenInfix=-1;
    bool operandInfront;
    //fgets(infix,256,stdin);/*input mode*/
    FILE *fp=fopen("cal3.txt","r");
    while(fgets(infix,256,fp)){
        operandInfront=false;
        for(tokenInfix=0;infix[tokenInfix]!='\n';tokenInfix++){
            if(isdigit(infix[tokenInfix])){
                postfix[++tokenPostfix]=infix[tokenInfix];operandInfront=true;
            }
            else{
                holder=createStack();
                if((priority(infix[tokenInfix],false)==1)&&!operandInfront){
                    if(infix[tokenInfix]=='+'){holder->Template.operatorToken='@';}
                    else{holder->Template.operatorToken='#';}
                    push(&operatorStack,holder);
                    operandInfront=false;continue;
                }
                if(infix[tokenInfix]==')'){
                    while(operatorStack->Template.operatorToken!='('){
                        postfix[++tokenPostfix]=pop(&operatorStack).Template.operatorToken;
                    }
                    pop(&operatorStack);
                    operandInfront=true;continue;
                }
                if(operandInfront&&infix[tokenInfix]=='('){
                    if(isEmpty(operatorStack)){/*bascally do nothing*/}
                    else{
                        while(priority(operatorStack->Template.operatorToken,true)>=priority(infix[tokenInfix],false)){
                            postfix[++tokenPostfix]=pop(&operatorStack).Template.operatorToken;
                            if(isEmpty(operatorStack)){break;}
                        }
                    }
                    holder->Template.operatorToken='*';
                    push(&operatorStack,holder);
                    holder=createStack();
                    holder->Template.operatorToken='(';
                    push(&operatorStack,holder);
                    operandInfront=false;continue;
                }
                if(isEmpty(operatorStack)){
                    holder->Template.operatorToken=infix[tokenInfix];
                    push(&operatorStack,holder);
                }
                else if(priority(operatorStack->Template.operatorToken,true)>=priority(infix[tokenInfix],false)){
                    do{
                        postfix[++tokenPostfix]=pop(&operatorStack).Template.operatorToken;
                        if(isEmpty(operatorStack)){break;}
                    }while(priority(operatorStack->Template.operatorToken,true)>=priority(infix[tokenInfix],false));
                    holder->Template.operatorToken=infix[tokenInfix];
                    push(&operatorStack,holder);
                }
                else{
                    holder->Template.operatorToken=infix[tokenInfix];
                    push(&operatorStack,holder);
                }
                operandInfront=false;
            }
        }
        while(!isEmpty(operatorStack)){
            postfix[++tokenPostfix]=pop(&operatorStack).Template.operatorToken;
        }
        printf("%-20s=%.2f\n",postfix,evaluate(postfix));
        memset(postfix,0,256);
        memset(infix,0,256);
        tokenPostfix=-1;
    }
}