用上面的算法写c程序，不允许c99

好的，下面是一个基于 C89 标准的实现，可以消除给定文法中的 ε-产生式、单一产生式和无用符号。

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

#define MAX_RULES 100
#define MAX_SYMBOLS 100

typedef struct {
    char lhs;
    char rhs[MAX_SYMBOLS];
    int len;
} Rule;

void remove_epsilon(Rule rules[], int *num_rules, char nullable[]) {
    int i, j, k, found;

    do {
        found = 0;

        for (i = 0; i < *num_rules; i++) {
            if (rules[i].rhs[0] == '\0') { // ε-产生式
                nullable[rules[i].lhs - 'A'] = 1;

                for (j = 0; j < *num_rules; j++) {
                    if (strchr(rules[j].rhs, rules[i].lhs)) {
                        for (k = 0; k < rules[j].len; k++) {
                            if (rules[j].rhs[k] == rules[i].lhs) {
                                char new_rhs[MAX_SYMBOLS];
                                int new_len;

                                // 生成新的规则，将 ε 替换为 rhs 中的其他符号
                                strcpy(new_rhs, rules[j].rhs);
                                new_rhs[k] = '\0';
                                strcat(new_rhs, &rules[j].rhs[k+1]);
                                new_len = strlen(new_rhs);

                                // 如果新的 rhs 产生式不是 ε，则将其添加到规则中
                                if (new_rhs[0] != '\0') {
                                    rules[*num_rules].lhs = rules[j].lhs;
                                    strcpy(rules[*num_rules].rhs, new_rhs);
                                    rules[*num_rules].len = new_len;
                                    (*num_rules)++;
                                }
                            }
                        }
                    }
                }

                // 将原始规则从列表中删除
                rules[i] = rules[--(*num_rules)];
                found = 1;
                break;
            }
        }
    } while (found);
}

void remove_unit(Rule rules[], int *num_rules) {
    int i, j, k, found;

    do {
        found = 0;

        for (i = 0; i < *num_rules; i++) {
            if (rules[i].len == 1 && isupper(rules[i].rhs[0])) { // 单一产生式
                char unit = rules[i].rhs[0];

                for (j = 0; j < *num_rules; j++) {
                    if (rules[j].lhs == unit) {
                        // 生成新的规则，将单一产生式的 lhs 替换为 unit 的 rhs
                        char new_rhs[MAX_SYMBOLS];
                        int new_len;

                        strcpy(new_rhs, rules[j].rhs);
                        new_len = strlen(new_rhs);

                        for (k = 0; k < *num_rules; k++) {
                            if (rules[k].lhs == rules[i].lhs &&
                                strcmp(rules[k].rhs, new_rhs) == 0) {
                                // 如果新规则已经存在，则不需要添加
                                break;
                            }
                        }

                        if (k == *num_rules) {
                            rules[*num_rules].lhs = rules[i].lhs;
                            strcpy(rules[*num_rules].rhs, new_rhs);
                            rules[*num_rules].len = new_len;
                            (*num_rules)++;
                            found = 1;
                        }
                    }
                }

                // 将原始规则从列表中删除
                rules[i] = rules[--(*num_rules)];
                break;
            }
        }
    } while (found);
}

void remove_unused(Rule rules[], int *num_rules, char nullable[], char reach[]) {
    int i, j, k, found;

    do {
        found = 0;

        for (i = 0; i < *num_rules; i++) {
            if (!isupper(rules[i].lhs)) { // 终结符
                reach[rules[i].lhs - 'a'] = 1;
            } else {
                for (j = 0; j < rules[i].len; j++) {
                    if (isupper(rules[i].rhs[j])) {
                        // 如果 rhs 中存在非终结符，则将 lhs 标记为可达符号
                        reach[rules[i].lhs - 'A'] = 1;

                        for (k = 0; k < *num_rules; k++) {
                            if (rules[k].lhs == rules[i].rhs[j]) {
                                // 如果 rhs 中的非终结符已经标记为可达符号，则跳过
                                if (reach[rules[i].rhs[j] - 'A']) {
                                    break;
                                }

                                // 如果 rhs 中的非终结符未标记为可达符号，则继续处理
                                reach[rules[i].rhs[j] - 'A'] = 1;
                                found = 1;
                            }
                        }
                    }
                }
            }
        }
    } while (found);

    // 删除未标记为可达符号的规则
    for (i = 0; i < *num_rules; i++) {
        if (!reach[rules[i].lhs - 'A']) {
            rules[i] = rules[--(*num_rules)];
            i--;
        }
    }

    // 删除与未标记为可达符号相关的 lhs 和 rhs
    for (i = 0; i < *num_rules; i++) {
        for (j = 0; j < rules[i].len; j++) {
            if (isupper(rules[i].rhs[j]) && !reach[rules[i].rhs[j] - 'A']) {
                rules[i].rhs[j] = '\0';
            }
        }
    }
}

void print_rules(Rule rules[], int num_rules) {
    int i;

    for (i = 0; i < num_rules; i++) {
        printf("%c -> %s\n", rules[i].lhs, rules[i].rhs);
    }
}

int main() {
    Rule rules[MAX_RULES];
    int num_rules = 0;
    char nullable[MAX_SYMBOLS] = {0};
    char reach[MAX_SYMBOLS] = {0};
    char line[MAX_SYMBOLS];
    int i, j;

    // 读取并解析规则
    while (fgets(line, MAX_SYMBOLS, stdin)) {
        if (line[0] == '\n') {
            break;
        }

        rules[num_rules].lhs = line[0];
        j = 0;

        for (i = 3; i < strlen(line); i++) {
            if (isspace(line[i])) {
                continue;
            }

            rules[num_rules].rhs[j++] = line[i];
        }

        rules[num_rules].rhs[j] = '\0';
        rules[num_rules].len = strlen(rules[num_rules].rhs);
        num_rules++;
    }

    remove_epsilon(rules, &num_rules, nullable);
    remove_unit(rules, &num_rules);
    remove_unused(rules, &num_rules, nullable, reach);
    print_rules(rules, num_rules);

    return 0;
}

注意：这个程序假设所有非终结符都是大写字母，所有终结符都是小写字母。如果您的文法中包含其他符号，请根据需要进行修改。