简单的FIRST集演示程序

 /*
  * 该程序用于计算某个非终结符的 FIRST 集合
  * RexfieldVon
  * 2013年6月29日19:53:45
  * 2013年7月3日22:01:57 修改 GetFIRST 例程以简化驱动例程以及自身结构
  */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 /* 三级指针
  * 第一级指向整个产生式组
  * 第二级指向单个产生式
  * 第三级指向产生式符号单元
  * 约定：所有的大写字母为非终结符
  * 假设：无左递归、FIRST集中不会出现重复符号
  */
 char*** GrammerRule;

 /*
  * 初始化文法序列
  */
 void InitizationGrammerRule()
 {
     // 分配表头空间
     GrammerRule = (char***)malloc(sizeof(int) * );
     memset(GrammerRule, '\0', sizeof(int) * );
     // 分配文法空间并写入产生式
     // G -> E
     GrammerRule['G'] = (char**)malloc(sizeof(int) * );
     GrammerRule['G'][] = (char*)malloc();
     memcpy(GrammerRule['G'][], "E\0", );        // E
     GrammerRule['G'][] = NULL;
     // E -> T F
     GrammerRule['E'] = (char**)malloc(sizeof(int) * );
     GrammerRule['E'][] = (char*)malloc();
     memcpy(GrammerRule['E'][], "TF\0", );        // T F
     GrammerRule['E'][] = NULL;
     // F -> '+' T F | '-' T F | e
     GrammerRule['F'] = (char**)malloc(sizeof(int) * );
     GrammerRule['F'][] = (char*)malloc();
     memcpy(GrammerRule['F'][], "+TF\0", );    // '+' T F
     GrammerRule['F'][] = (char*)malloc();
     memcpy(GrammerRule['F'][], "-TF\0", );    // '-' T F
     GrammerRule['F'][] = (char*)malloc();
     memcpy(GrammerRule['F'][], "\0", );        // e （该产生式存在但是为空）
     GrammerRule['F'][] = NULL;
     // T -> A U
     GrammerRule['T'] = (char**)malloc(sizeof(int) * );
     GrammerRule['T'][] = (char*)malloc();
     memcpy(GrammerRule['T'][], "AU\0", );        // A U
     GrammerRule['T'][] = NULL;
     // U -> '*' A U | '/' A U | e
     GrammerRule['U'] = (char**)malloc(sizeof(int) * );
     GrammerRule['U'][] = (char*)malloc();
     memcpy(GrammerRule['U'][], "*AU\0", );    // '*' A U
     GrammerRule['U'][] = (char*)malloc();
     memcpy(GrammerRule['U'][], "/AU\0", );    // '/' A U
     GrammerRule['U'][] = (char*)malloc();
     memcpy(GrammerRule['U'][], "\0", );        // e （该产生式存在但是为空）
     GrammerRule['U'][] = NULL;
     // A -> '(' E ')' | d | n
     GrammerRule['A'] = (char**)malloc(sizeof(int) * );
     GrammerRule['A'][] = (char*)malloc();
     memcpy(GrammerRule['A'][], "(E)\0", );    // '(' E ')'
     GrammerRule['A'][] = (char*)malloc();
     memcpy(GrammerRule['A'][], "d\0", );        // d
     GrammerRule['A'][] = (char*)malloc();
     memcpy(GrammerRule['A'][], "n\0", );        // n
     GrammerRule['A'][] = NULL;
 }

 int GetTerminalCount()
 {
     int i, TerminalCount = ;
     for (i = ; i < ; i++)
     {
         if (GrammerRule[i] != NULL)
         {
             int k = ;
             while (GrammerRule[i][k] != NULL)
             {
                 int n = ;
                 while (GrammerRule[i][k][n] != '\0')
                 {
                     char c = GrammerRule[i][k][n];
                     if (c < 'A' || c > 'Z')
                     {
                         TerminalCount++;
                     }
                     n++;
                 }
                 k++;
             }
         }
     }
     return TerminalCount;
 }

 /*
  * 递归取得 FIRST 集
  * Token : char 需要打印的符号
  * FIRST : char* FIRST集
  * Ptr : int* FIRST集的位置指针
  */
 void GetFIRST(char Token, char *FIRST, int *Ptr)
 {
     if (Token >= 'A' && Token <= 'Z' && GrammerRule[Token] != NULL)
     {
         int i = ;
         while (GrammerRule[Token][i] != NULL)
         {
             GetFIRST(GrammerRule[Token][i++][], FIRST, Ptr);
         }
     }
     else if (Token < 'A' || Token > 'Z')
     {
         FIRST[*Ptr] = Token;
         *Ptr = *Ptr + ;
     }
 }

 /*
  * 打印指定非终结符的 FIRST 集
  * Token : char 需要打印的符号
  * TerminalCount : int 终结符数量
  */
 void PrintFIRST(char Token, int TerminalCount)
 {
     char *FIRST = (char*)malloc(TerminalCount + );
     memset(FIRST, '\0', TerminalCount + );
     int Ptr = , i;
     GetFIRST(Token, FIRST, &Ptr);
     printf("FIRST(%c): ", Token);
     for (i = ; i < Ptr; i++)
     {
         if (FIRST[i] == '\0')
         {
             printf("<e> ");
         }
         else
         {
             printf("%c ", FIRST[i]);
         }
     }
     printf("\n");
 }

 int main(int argc, char **argv)
 {
     InitizationGrammerRule();    // 初始化文法
     int TerminalCount = GetTerminalCount();
     printf("Terminal Symbol Count: %d\n", TerminalCount);
     PrintFIRST('E', TerminalCount);
     PrintFIRST('F', TerminalCount);
     PrintFIRST('T', TerminalCount);
     PrintFIRST('U', TerminalCount);
     PrintFIRST('A', TerminalCount);
     return ;
 }