设计一个简单的语法分析器，能够将输入的单词序列分析成语法树，支持语法规则、优先级等特性

设计一个简单的语法分析器需要考虑以下步骤：

1. 定义语法规则：定义符号、终结符号、非终结符号、语法规则等等。

2. 词法分析：将输入的字符流转换成一个个的单词（token），并且为每个单词加上词法类型（例如标识符、数字、运算符等等）。

3. 语法分析：根据语法规则将单词序列分析成语法树。可以使用自上而下的解析方法（例如递归下降分析法）或自下而上的解析方法（例如LR分析法）。

4. 语义分析：对语法树进行语义分析，例如类型检查、常量折叠、变量声明等等。

5. 代码生成：根据语法树生成目标代码。

下面是一个示例的语法规则（以四则运算为例）：

<expr> ::= <expr> + <term> | <expr> - <term> | <term>
<term> ::= <term> * <factor> | <term> / <factor> | <factor>
<factor> ::= <number> | ( <expr> )

其中，`<expr>`、`<term>`、`<factor>`是非终结符号，`+`、`-`、`*`、`/`、`(`、`)`是终结符号，`<number>`是数字的非终结符号。

可以使用递归下降分析法来实现语法分析器。具体步骤如下：

1. 实现一个词法分析器，将输入的字符流转换成一个个的单词，并为每个单词加上词法类型。

2. 实现一个`parse_expr()`函数，用于解析`<expr>`语法规则。该函数的基本思路是：先解析`<term>`，然后根据下一个单词的类型判断是加法还是减法，最后递归解析剩余的表达式。

3. 实现一个`parse_term()`函数，用于解析`<term>`语法规则。该函数的基本思路是：先解析`<factor>`，然后根据下一个单词的类型判断是乘法还是除法，最后递归解析剩余的表达式。

4. 实现一个`parse_factor()`函数，用于解析`<factor>`语法规则。该函数的基本思路是：判断下一个单词的类型是数字还是左括号，如果是数字则返回该数字的节点，如果是左括号则递归解析剩余的表达式，最后需要匹配右括号。

5. 实现一个`parse()`函数，用于启动语法分析器。该函数的基本思路是：调用`parse_expr()`函数解析整个表达式，返回语法树的根节点。

下面是示例代码：

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

#define MAX_TOKEN_LEN 100

typedef enum {
    TOKEN_NUMBER,
    TOKEN_PLUS,
    TOKEN_MINUS,
    TOKEN_MULTIPLY,
    TOKEN_DIVIDE,
    TOKEN_LPAREN,
    TOKEN_RPAREN,
    TOKEN_EOF
} TokenKind;

typedef struct Token {
    TokenKind kind;
    char value[MAX_TOKEN_LEN];
} Token;

typedef struct Node {
    char op;
    int value;
    struct Node *left;
    struct Node *right;
} Node;

char *input;
int pos = 0;

Token *get_token() {
    Token *token = (Token *)malloc(sizeof(Token));
    token->kind = TOKEN_EOF;
    token->value[0] = '\0';

    while (isspace(input[pos])) {
        pos++;
    }

    if (isdigit(input[pos])) {
        int i = 0;
        while (isdigit(input[pos])) {
            token->value[i] = input[pos];
            i++;
            pos++;
        }
        token->kind = TOKEN_NUMBER;
    } else if (input[pos] == '+') {
        token->kind = TOKEN_PLUS;
        token->value[0] = '+';
        pos++;
    } else if (input[pos] == '-') {
        token->kind = TOKEN_MINUS;
        token->value[0] = '-';
        pos++;
    } else if (input[pos] == '*') {
        token->kind = TOKEN_MULTIPLY;
        token->value[0] = '*';
        pos++;
    } else if (input[pos] == '/') {
        token->kind = TOKEN_DIVIDE;
        token->value[0] = '/';
        pos++;
    } else if (input[pos] == '(') {
        token->kind = TOKEN_LPAREN;
        token->value[0] = '(';
        pos++;
    } else if (input[pos] == ')') {
        token->kind = TOKEN_RPAREN;
        token->value[0] = ')';
        pos++;
    }

    token->value[strlen(token->value)] = '\0';
    return token;
}

Node *new_node(char op, int value, Node *left, Node *right) {
    Node *node = (Node *)malloc(sizeof(Node));
    node->op = op;
    node->value = value;
    node->left = left;
    node->right = right;
    return node;
}

Node *parse_expr();
Node *parse_term();
Node *parse_factor();

Node *parse_expr() {
    Node *left = parse_term();

    Token *token = get_token();
    while (token->kind == TOKEN_PLUS || token->kind == TOKEN_MINUS) {
        Node *right = parse_term();
        left = new_node(token->value[0], 0, left, right);
        free(token);
        token = get_token();
    }
    pos--;
    return left;
}

Node *parse_term() {
    Node *left = parse_factor();

    Token *token = get_token();
    while (token->kind == TOKEN_MULTIPLY || token->kind == TOKEN_DIVIDE) {
        Node *right = parse_factor();
        left = new_node(token->value[0], 0, left, right);
        free(token);
        token = get_token();
    }
    pos--;
    return left;
}

Node *parse_factor() {
    Token *token = get_token();

    if (token->kind == TOKEN_NUMBER) {
        int value = atoi(token->value);
        return new_node('\0', value, NULL, NULL);
    } else if (token->kind == TOKEN_LPAREN) {
        Node *node = parse_expr();
        free(token);
        token = get_token();
        if (token->kind != TOKEN_RPAREN) {
            printf("Syntax error: expected ')'\n");
            exit(1);
        }
        return node;
    } else {
        printf("Syntax error: unexpected token '%s'\n", token->value);
        exit(1);
    }
}

Node *parse(char *str) {
    input = str;
    return parse_expr();
}

void print_tree(Node *node, int depth) {
    if (node == NULL) {
        return;
    }

    print_tree(node->right, depth + 1);

    for (int i = 0; i < depth; i++) {
        printf("  ");
    }

    if (node->op == '\0') {
        printf("%d\n", node->value);
    } else {
        printf("%c\n", node->op);
    }

    print_tree(node->left, depth + 1);
}

int main() {
    Node *root = parse("1+2*3");

    printf("Syntax tree:\n");
    print_tree(root, 0);

    return 0;
}

这个示例代码实现了一个简单的四则运算语法分析器，支持加减乘除运算和括号。它使用递归下降分析法来解析输入的单词序列，并将其转换成语法树。可以根据需要修改语法规则和解析函数来支持更复杂的语法特性。