#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#define MAXSIZE 100 	//栈容量
typedef double DataType;	//数据类型，可根据需要改变
typedef enum symbol		//字符枚举变量，用于getsym函数判断读入内容为数字，操作符，等号，还是其他
{
    NUM,
    OPE,
    EQU,
    OTH
} SymType;
typedef enum operator	//操作符枚举变量，用于入栈及根据优先级数列判断优先级
{
    AND,	//与
    XOR,	//疑惑
    OR,		//或
    MORE,   //大于
    LESS,   //小于
    ADD,	
    MIN,
    MUL,
    DIV,
    MOD,	//取模
    NOT,	//非
    LEFT,	//左括号
    RIGHT	//右括号
} OpeType;
int prior[] = {0, -1, -2, 1, 1, 2, 2, 3, 3, 3, 4, 5, 5};	//优先级数列
union sym	//联合变量，用于读取操作符或数字
{
    DataType num;
    OpeType op;
};
OpeType Ope_Stack[MAXSIZE];		//符号栈
int OpeTop = -1;	//栈顶
DataType Num_Stack[MAXSIZE];	//数组栈
int NumTop = -1;
SymType GetSym(union sym *item);	//读取数字或运算符函数,返回值为相应的枚举类型(NUM OPE EQU OHE)
void Push_Ope(OpeType op);		//运算符压栈函数
void Push_Num(DataType num);
OpeType Pop_Ope();	//运算符压栈函数,返回值为弹栈元素枚举类型(ADD MIN MUL DIV)
DataType Pop_Num();
void operate(OpeType op);	//操作函数,对无法压栈的字符串进行操作
void calculate(OpeType op);		//运算函数,对数字栈顶两元素以传入运算符进行运算
int main()
{
    union sym item;		//储存数字或运算符
    SymType s;	//判断getsym返回类型
    while ((s = GetSym(&item)) != EQU)	//返回不为等号循环读取
    {
        if (s == NUM)	//数字直接压栈
            Push_Num(item.num);
        else if (s == OPE)	//符号导入操作函数进行操作
        {
            operate(item.op);
        }
        else	//否则输入有问题
        {
            printf("Error Input!\n");
            return 1;
        }
    }
    while (OpeTop != -1)	//读取操作完成后, 把符号栈剩余符号全部弹栈计算一遍
    {
        calculate(Pop_Ope());
    }
    if (NumTop == 0)	//计算完成符号栈清空,数字栈只剩一个元素,弹栈输出即可
        printf("%g\n", Pop_Num());
    else	//否则输入有问题
    {
        printf("Error Input!\n");
        return 1;
    }
}
SymType GetSym(union sym *item)
{
    char c;
    while ((c = getchar()) != '=')
    {
        if (c >= '0' && c <= '9')
        {
            for (item->num = 0; c >= '0' && c <= '9'; c = getchar())	//多位数字处理
            {
                item->num = item->num * 10 + c - '0';
            }
            ungetc(c, stdin);	//退回缓冲区,防止读入符号丢失
            return NUM;		//返回数字枚举类型
        }
        else	//匹配运算符
        {
            switch (c)
            {
            case '&':
                item->op = AND;
                return OPE;
            case '^':
                item->op = XOR;
                return OPE;
            case '|':
                item->op = OR;
                return OPE;
            case '>':
                item->op =  MORE;
                return OPE;
            case '<':
                item->op =  LESS;
                return OPE;
            case '+':
                item->op =  ADD;
                return OPE;
            case '-':
                item->op =  MIN;
                return OPE;
            case '*':
                item->op =  MUL;
                return OPE;
            case '/':
                item->op =  DIV;
                return OPE;
            case '%':
                item->op = MOD;
                return OPE;
            case '!':
                item->op = NOT;
                return OPE;
            case '(': 
                item->op = LEFT; 
                return OPE;
            case ')': 
                item->op = RIGHT; 
                return OPE;
            case ' ': case '\t': case '\n': break;	//空格直接跳
            default: 
                return OTH;		//读到怪东西,直接报错
            }
        }
    }
    return EQU;		//读到等号,也就是表达式末尾
}
void Push_Ope(OpeType op)
{
    if (OpeTop == MAXSIZE - 1)		//满栈,无法入栈
    {
        printf("operator stack is full!\n");
        exit(1);
    }
    Ope_Stack[++OpeTop] = op;
    return;
}
void Push_Num(DataType num)
{
    if (NumTop == MAXSIZE - 1)
    {
        printf("number stack is full!\n");
        exit(1);
    }
    Num_Stack[++NumTop] = num;
    return;
}
OpeType Pop_Ope()
{
    if (OpeTop == -1)	//栈空,无法弹栈
    {
        printf("Error Input!\n");
        exit(1);
    }
    return Ope_Stack[OpeTop--];
}
DataType Pop_Num()
{
    if (NumTop == -1)
    {
        printf("Error Input!\n");
        exit(1);
    }
    return Num_Stack[NumTop--];
}
void operate(OpeType op)
{
    OpeType t;
    if (op == RIGHT)	//如果读入右括号
    {
        while ((t = Pop_Ope()) != LEFT)		//直到弹到左括号
            calculate(t);	//计算
    }
    else
    {
        while (OpeTop != -1 && prior[op] <= prior[Ope_Stack[OpeTop]] && Ope_Stack[OpeTop] != LEFT)
            				//弹栈计算直到,栈为空 或 栈顶优先级小于读入优先级 或 栈顶为左括号. 能够压栈后再压栈
            calculate(Pop_Ope());
        Push_Ope(op);
    }
}
void calculate(OpeType op)	//弹栈两数字,按照运算顺序计算,计算完成后把结果压栈
{
    DataType temp;	//临时变量储存栈顶元素,防止弹栈顺序问题导致计算先后出错
    switch (op)
    {
    case AND:
        Push_Num((int)Pop_Num() & (int)Pop_Num());
        break;
    case XOR:
        Push_Num((int)Pop_Num() ^ (int)Pop_Num());
        break;
    case OR:
        Push_Num((int)Pop_Num() | (int)Pop_Num());
        break;
    case MORE:
        temp = Pop_Num();
        Push_Num(Pop_Num() > temp);
        break;
    case LESS:
        temp = Pop_Num();
        Push_Num(Pop_Num() < temp);
        break;
    case ADD:
        Push_Num(Pop_Num() + Pop_Num());
        break;
    case MIN:
        temp = Pop_Num();
        Push_Num(Pop_Num() - temp);
        break;
    case MUL:
        Push_Num(Pop_Num() * Pop_Num());
        break;
    case DIV:
        temp = Pop_Num();
        Push_Num(Pop_Num() / temp);
        break;
    case MOD:
        temp = Pop_Num();
        Push_Num((int)Pop_Num() % (int)temp);
        break;
    case NOT:
        Push_Num(!(int)Pop_Num());
        break;
    }
}