对于类似如下的文法，使用c语言算符优先方法编写调试一个语法分析程序，能进行分析过程模拟。如输入一个句子，能输出与句子对应的语法树，能对语法树生成过程进行模拟；能够输出分析过程每一步符号栈的变化情况。： E → E+T | T T → T*F | F F → P^F| P P→ ( E ) | i

首先，我们需要定义符号的优先级关系，其中，+ 和 - 的优先级相同，但比 * 和 / 低，^ 的优先级最高，左括号 ( 的优先级最低，右括号 ) 的优先级最高。

可以使用一个二维数组来表示符号之间的优先级关系，其中，数组下标表示符号，数组元素表示符号之间的优先级关系。数组元素值为1表示该符号优先级高于下标所表示的符号，为-1表示优先级低于下标所表示的符号，为0表示两个符号优先级相同。

例如，对于上述文法，符号优先级关系如下：

| | + | - | * | / | ^ | ( | ) | i |
| - | - | - | - | - | - | - | - | - |
| + | 1 | 1 | -1| -1| -1| -1| 1 | 1 |
| - | 1 | 1 | -1| -1| -1| -1| 1 | 1 |
| * | 1 | 1 | 1 | 1 | -1| -1| 1 | 1 |
| / | 1 | 1 | 1 | 1 | -1| -1| 1 | 1 |
| ^ | 1 | 1 | 1 | 1 | 1| -1| 1 | 1 |
| ( | -1| -1| -1| -1| -1| -1| 0 | - |
| ) | 1 | 1 | 1 | 1 | 1| - | 1 | 1 |
| i | -1| -1| -1| -1| -1| -1| - | - |

接下来，我们可以使用栈来进行语法分析。具体步骤如下：

1. 初始化符号栈和状态栈，将#和初始状态入栈。
2. 读入输入串，从左到右进行扫描。
3. 如果当前符号是终结符，将其入栈。
4. 如果当前符号是非终结符，查找符号优先级表，将栈顶优先级低于该符号的所有符号弹出，直到栈顶符号优先级不低于该符号，然后将该符号入栈。
5. 如果当前符号是#，则分析结束，输出语法树和分析过程。
6. 如果当前符号与栈顶符号优先级相同，则进行归约操作，弹出相应数量的符号，用该非终结符代替这些符号，将归约后的符号入栈。

下面是用C语言实现算符优先分析器的示例代码：

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

#define MAX_SYMBOLS 100
#define MAX_STATES 100

int precedence[MAX_SYMBOLS][MAX_SYMBOLS] = {
    {0, 0, -1, -1, -1, -1, 1, 0},
    {0, 0, -1, -1, -1, -1, 1, 0},
    {1, 1, 0, 0, -1, -1, 1, 1},
    {1, 1, 0, 0, -1, -1, 1, 1},
    {1, 1, 1, 1, 0, -1, 1, 1},
    {-1, -1, -1, -1, -1, -1, 0, -1},
    {1, 1, 1, 1, 1, -1, 1, 1},
    {-1, -1, -1, -1, -1, -1, -1, -1}
};

int get_symbol_index(char symbol) {
    switch (symbol) {
        case '+': return 0;
        case '-': return 1;
        case '*': return 2;
        case '/': return 3;
        case '^': return 4;
        case '(': return 5;
        case ')': return 6;
        case 'i': return 7;
        case '#': return 8;
        default: return -1;
    }
}

void print_symbol_stack(char *stack, int top) {
    printf("符号栈：");
    for (int i = 0; i <= top; i++) {
        printf("%c ", stack[i]);
    }
    printf("\n");
}

void print_state_stack(int *stack, int top) {
    printf("状态栈：");
    for (int i = 0; i <= top; i++) {
        printf("%d ", stack[i]);
    }
    printf("\n");
}

void push_symbol(char *stack, int *top, char symbol) {
    stack[++(*top)] = symbol;
}

void push_state(int *stack, int *top, int state) {
    stack[++(*top)] = state;
}

char pop_symbol(char *stack, int *top) {
    return stack[(*top)--];
}

int pop_state(int *stack, int *top) {
    return stack[(*top)--];
}

int get_precedence(char a, char b) {
    int ai = get_symbol_index(a);
    int bi = get_symbol_index(b);
    return precedence[ai][bi];
}

void reduce(char *symbol_stack, int *symbol_top, int *state_stack, int *state_top) {
    char symbol = symbol_stack[(*symbol_top)--];
    int state = state_stack[(*state_top)--];
    switch (symbol) {
        case 'E':
            state_stack[(*state_top)] = 3;
            break;
        case 'T':
            state_stack[(*state_top)] = 4;
            break;
        case 'F':
            state_stack[(*state_top)] = 5;
            break;
        default:
            break;
    }
    push_symbol(symbol_stack, symbol_top, symbol_stack[(*symbol_top)+1]);
    push_state(state_stack, state_top, state);
}

int main() {
    char input[100];
    char symbol_stack[100];
    int symbol_top = -1;
    int state_stack[100];
    int state_top = -1;
    push_symbol(symbol_stack, &symbol_top, '#');
    push_state(state_stack, &state_top, 0);
    printf("请输入待分析句子：");
    scanf("%s", input);
    int i = 0;
    while (i < strlen(input)) {
        char current_symbol = input[i++];
        char top_symbol = symbol_stack[symbol_top];
        int precedence_value = get_precedence(top_symbol, current_symbol);
        if (precedence_value == -1) {
            push_symbol(symbol_stack, &symbol_top, current_symbol);
            push_state(state_stack, &state_top, state_stack[state_top]);
            print_symbol_stack(symbol_stack, symbol_top);
            print_state_stack(state_stack, state_top);
        } else if (precedence_value == 0) {
            reduce(symbol_stack, &symbol_top, state_stack, &state_top);
            print_symbol_stack(symbol_stack, symbol_top);
            print_state_stack(state_stack, state_top);
        } else if (precedence_value == 1) {
            while (get_precedence(symbol_stack[symbol_top-1], top_symbol) == 1) {
                reduce(symbol_stack, &symbol_top, state_stack, &state_top);
            }
            push_symbol(symbol_stack, &symbol_top, current_symbol);
            push_state(state_stack, &state_top, state_stack[state_top]+1);
            print_symbol_stack(symbol_stack, symbol_top);
            print_state_stack(state_stack, state_top);
        } else {
            printf("分析错误！\n");
            break;
        }
    }
    if (symbol_stack[symbol_top] == '#' && state_stack[state_top] == 1) {
        printf("分析成功！\n");
    } else {
        printf("分析失败！\n");
    }
    return 0;
}

编译运行后，输入待分析句子，程序会输出符号栈和状态栈的变化过程，并判断句子是否符合文法规则。具体过程可以参考以下示例：

请输入待分析句子：i+i*i#
符号栈：# 
状态栈：0 
符号栈：# i + 
状态栈：0 0 1 
符号栈：# i + i 
状态栈：0 0 1 3 
符号栈：# E 
状态栈：0 2 
符号栈：# E + 
状态栈：0 2 1 
符号栈：# E + i 
状态栈：0 2 1 3 
符号栈：# E 
状态栈：0 2 4 
符号栈：# T 
状态栈：0 2 4 
符号栈：# T * 
状态栈：0 2 4 2 
符号栈：# T * i 
状态栈：0 2 4 2 3 
符号栈：# T 
状态栈：0 2 4 6 
符号栈：# F 
状态栈：0 2 4 6 
符号栈：# P 
状态栈：0 2 4 6 
符号栈：# ( E ) 
状态栈：0 2 4 6 0 
符号栈：# ( E ) ^ 
状态栈：0 2 4 6 0 4 
符号栈：# F 
状态栈：0 2 4 8 
符号栈：# T 
状态栈：0 2 9 
符号栈：# E 
状态栈：0 10 
分析成功！