在基于算符优先分析法的自底向上语法分析中，计算文法中所有变量的FIRSTOP 集，用c语言编写

算符优先分析法的自底向上语法分析中，计算文法中所有变量的FIRSTOP集，可以采取以下步骤：

1. 定义一个结构体用于表示文法中的产生式，结构体中包含产生式左部和右部的符号序列。

typedef struct {
    char left;   // 产生式左部
    char right[MAX_RIGHT_LEN];  // 产生式右部
} Production;

2. 定义一个数组用于存储文法中的所有产生式。

Production productions[MAX_PRODUCTION_NUM];

3. 定义一个函数用于计算指定变量的FIRSTOP集，函数接受一个参数表示要计算的变量。

void calc_firstop(char var);

4. 在函数中，遍历所有产生式，找到左部为当前变量的产生式，并计算它的FIRSTOP集。

5. 对于每个右部符号，如果是终结符，则直接将该符号加入FIRSTOP集；如果是非终结符，则将该符号的FIRSTOP集加入当前产生式的FIRSTOP集中，直到找到一个终结符或者所有非终结符的FIRSTOP集都包含空串。

6. 如果当前产生式的右部FIRSTOP集包含空串，则将当前产生式的左部的FIRSTOP集加入当前产生式的FIRSTOP集中。

7. 最终得到的FIRSTOP集即为当前变量的FIRSTOP集。

下面是完整的C语言代码实现，仅供参考：

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

#define MAX_RIGHT_LEN 10  // 产生式右部最大长度
#define MAX_PRODUCTION_NUM 100  // 最大产生式数量

typedef struct {
    char left;   // 产生式左部
    char right[MAX_RIGHT_LEN];  // 产生式右部
} Production;

Production productions[MAX_PRODUCTION_NUM];   // 存储所有产生式
int production_num; // 产生式数量

char firstop[256][256]; // 存储所有变量的FIRSTOP集

// 查找指定变量的FIRSTOP集
void calc_firstop(char var) {
    int i, j, k, found;
    char firstop_set[256] = ""; // 当前变量的FIRSTOP集
    char cur_var;
    int right_len;

    // 遍历所有产生式
    for (i = 0; i < production_num; i++) {
        // 找到左部为当前变量的产生式
        if (productions[i].left == var) {
            right_len = strlen(productions[i].right);

            // 遍历产生式的右部符号
            for (j = 0; j < right_len; j++) {
                cur_var = productions[i].right[j];
                found = 0;

                // 如果是终结符，则直接将该符号加入FIRSTOP集
                if (cur_var >= 'a' && cur_var <= 'z') {
                    firstop_set[cur_var] = 1;
                    break;
                }

                // 如果是非终结符，则将该符号的FIRSTOP集加入当前产生式的FIRSTOP集中
                for (k = 0; k < strlen(firstop[cur_var]); k++) {
                    if (firstop[cur_var][k] == '\0') {
                        found = 1;
                        break;
                    }
                    firstop_set[firstop[cur_var][k]] = 1;
                }

                // 如果该非终结符的FIRSTOP集不包含空串，则停止向后扩展
                if (!found) {
                    break;
                }
            }

            // 如果当前产生式的右部FIRSTOP集包含空串，则将左部的FIRSTOP集加入当前产生式的FIRSTOP集中
            if (j == right_len) {
                for (k = 0; k < strlen(firstop[var]); k++) {
                    if (firstop[var][k] == '\0') {
                        break;
                    }
                    firstop_set[firstop[var][k]] = 1;
                }
            }
        }
    }

    // 将当前变量的FIRSTOP集存入数组中
    for (i = 0, j = 0; i < 256; i++) {
        if (firstop_set[i]) {
            firstop[var][j++] = i;
        }
    }
}

int main() {
    int i, j;
    char var;

    // 读入产生式
    printf("请输入产生式（以#结束）：\n");
    while (scanf("%c", &var) != EOF && var != '#') {
        productions[production_num].left = var;
        scanf("%s", productions[production_num].right);
        production_num++;
        getchar();  // 读取回车符
    }

    // 计算所有变量的FIRSTOP集
    for (i = 0; i < 256; i++) {
        if (productions[0].left == '\0') {
            continue;
        }
        calc_firstop(i);
    }

    // 输出所有变量的FIRSTOP集
    printf("所有变量的FIRSTOP集：\n");
    for (i = 0; i < 256; i++) {
        if (firstop[i][0] != '\0') {
            printf("%c:\t{", i);
            for (j = 0; j < strlen(firstop[i]); j++) {
                printf("%c", firstop[i][j]);
                if (j != strlen(firstop[i]) - 1) {
                    printf(", ");
                }
            }
            printf("}\n");
        }
    }

    return 0;
}