帮我用C语言在C90标准下写一个可以实现加减乘除并且判断括号优先级的程序，要求使用顺序栈,帮我详细注释每一步

好的，让我来帮您解决这个问题。

首先我们需要明确一下顺序栈的定义和基本操作。顺序栈就是一种顺序存储结构的栈，可以使用数组来实现。其基本操作有入栈(push)和出栈(pop)。入栈即将元素插入到栈顶，出栈即将栈顶元素删除。

接下来我们可以开始写程序。根据您的要求，我们需要实现加减乘除操作并且判断括号的优先级。下面是完整的程序代码，并且每个步骤都有详细注释：

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

// 定义顺序栈结构体
typedef struct stack {
    char data[100];     // 存储栈中元素的数组
    int top;            // 栈顶指针
} Stack;

// 初始化栈
void initStack(Stack *s) {
    s->top = -1;
}

// 判断栈是否为空
int isEmpty(Stack *s) {
    return s->top == -1 ? 1 : 0;
}

// 入栈
void push(Stack *s, char c) {
    s->data[++s->top] = c;
}

// 出栈
char pop(Stack *s) {
    if (isEmpty(s)) {
        printf("Error: stack is empty.\n");
        exit(-1);
    }
    return s->data[s->top--];
}

// 获取栈顶元素
char getTop(Stack *s) {
    if (isEmpty(s)) {
        return '\0';
    }
    return s->data[s->top];
}

// 判断优先级
int priority(char c) {
    switch(c) {
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
            return 2;
        default:
            return 0;
    }
}

// 计算表达式的值
int calculate(int a, int b, char op) {
    switch (op) {
        case '+': return a + b;
        case '-': return a - b;
        case '*': return a * b;
        case '/': return a / b;
        default: return 0;
    }
}

// 计算表达式的值
int expValue(char* exp) {
    Stack opStack, valStack;
    initStack(&opStack);        // 运算符栈初始化
    initStack(&valStack);       // 数值栈初始化

    int i = 0, len = strlen(exp);
    while (i < len) {
        if (isdigit(exp[i])) {             // 如果当前字符是数字，取出完整的数值并入数值栈
            int val = 0;
            while (i < len && isdigit(exp[i])) {
                val = val * 10 + exp[i++] - '0';
            }
            push(&valStack, val);
        } else if (exp[i] == '(') {         // 如果当前字符是左括号，入运算符栈
            push(&opStack, '(');
            i++;
        } else if (exp[i] == ')') {         // 如果当前字符是右括号，计算括号内表达式的值
            while (getTop(&opStack) != '(') {
                char op = pop(&opStack);
                int b = pop(&valStack);
                int a = pop(&valStack);
                int val = calculate(a, b, op);
                push(&valStack, val);
            }
            pop(&opStack);                  // 弹出左括号
            i++;
        } else if (exp[i] == '+' || exp[i] == '-' || exp[i] == '*' || exp[i] == '/') {     // 如果当前字符是运算符
            while (!isEmpty(&opStack) && priority(getTop(&opStack)) >= priority(exp[i])) {   // 判断当前运算符与栈顶运算符的优先级
                char op = pop(&opStack);
                int b = pop(&valStack);
                int a = pop(&valStack);
                int val = calculate(a, b, op);
                push(&valStack, val);
            }
            push(&opStack, exp[i]);         // 当前运算符入栈
            i++;
        } else {                            // 如果当前字符是空格则忽略
            i++;
        }
    }

    while (!isEmpty(&opStack)) {            // 计算剩余表达式的结果
        char op = pop(&opStack);
        int b = pop(&valStack);
        int a = pop(&valStack);
        int val = calculate(a, b, op);
        push(&valStack, val);
    }

    return pop(&valStack);                  // 返回数值栈中的结果
}

int main() {
    char exp[] = "(2+3)*(4-1)/5";
    int result = expValue(exp);
    printf("%s = %d\n", exp, result);
    return 0;
}

以上程序使用顺序栈实现了解析带有括号的四则运算表达式并计算其结果。每个实现步骤都有详细的注释，您可以根据注释来理解程序的实现过程。您只需要将操作数与运算符按照指定的格式输入表达式即可。