parse.c

该程序能够实现简单的c语言词法

                       /* printf("erro:采用了非法字符,错误出现在第%d行",linenumber); */
                        fprintf(erro,"erro:采用了非法字符,错误出现在第%d行",linenumber);
                        return ERRO;

                }

                ch = fgetc(fp);
        }
}
int findnumber1(int a)  /*把词法分析返回的字符数字转化成算术表达式分析表数组对应的下标*/
{
   if(a>=1000)
      return ID;
   else if(a==1)
      return add;
   else if(a==2)
      return multy;
   else if(a==3)
      return leftpar;
   else if(a==4)
      return rightpar;
   else if(a==5)/*当输入的值为减号是也把他看作是加号*/
      return 101;
   else if(a==6)/*当输入的值为除号是也把他看作是乘号*/
       return 102;
   else
       return 5;
}

int exp_analyze()
{
    int t[10];  /*用来记录临时变量的栈*/
    int tindex=0;/*临时变量栈索引*/
    int state[300];/*状态栈*/
    int list[300]; /*移进字符栈  */
    int parse_index = 0;/*语法分析栈数组的指针 */
    int judge;/*分析表中的状态 */
    int word;
    int type = 0;/*用来记录ID或NUM的类型*/
    int mark = 0;/*判断是ID还是NUM*/
    int p;/*用来表示当前用到的符号表项的符号表索引*/
    int value= 0;     /*记录当前ID或NUM值*/
    int judge_add,judge_multy; /*在归约时用来判断前面所出现的符号，从而知道用那一个产生式进行归约*/
    state[0]=0;
    while(1)
    {
       word = findnumber1(lex_word[pointer]);
       if( lex_word[pointer]>=1000)
       {
          p = lex_word[pointer]%1000;
          if(symbol[p].mark== NUM)
            mark = 1;
          else
            mark =0;

       }
       if(word ==1||word ==101)
       {
          judge = action1[state[parse_index]][1];
       }
       else if(word == multy||word ==102)
           judge = action1[state[parse_index]][2];
       else
           judge = action1[state[parse_index]][word];
       if(judge == -1)
       {
          printf("arithmetic expression erro exit\n");
          while(findnumber1(lex_word[pointer])!=5)
                 pointer++;
          break;
       }
       else if( judge == acc)
       {
          printf("complete arithmetic expression parse\n");
          break;
       }
       else if( judge >100)
       {
           int a;
           a = judge%100;
           switch(a)
           {
               case 1:
                      parse_index = parse_index - 2;
                      list[parse_index] = E+100; /*为了在四元式中判断栈中的元素是否是终结符*/
                      state[parse_index] = goto1[state[parse_index-1]][E];
                      if(judge_add == 1)
                      {
                          four_element[findex].operate = '+';
                          four_element[findex].arg1 = t[tindex-1];
                          four_element[findex].arg2 = t[tindex];
                          four_element[findex].result = temporary;
                          tindex = tindex -1;
                          t[tindex] = temporary;
                          findex++;
                          temporary++;
                          E_value = E_value + T_value;
                          printf(" use expression: E-->E+T,   E_value = E_value + T_value = %d",E_value);

                      }
                      else
                      {
                          four_element[findex].operate = '-';
                          four_element[findex].arg1 = t[tindex-1];
                          four_element[findex].arg2 = t[tindex];
                          four_element[findex].result = temporary;

                          tindex = tindex -1;
                          t[tindex] = temporary;
                          findex++;
                          temporary++;
                          E_value = E_value - T_value;
                          printf(" use expression: E-->E-T  E_value = E_value - T_value = %d",E_value);
                      }
                      break;
               case 2:
                      list[parse_index] = E+100;
                      state[parse_index] = goto1[state[parse_index-1]][E];
                      E_value = T_value;
                      printf(" use expression: E-->T,   E_value = T_value = %d",E_value);
                      break;
               case 3:
                      parse_index = parse_index - 2;
                      list[parse_index] = T+100;
                      state[parse_index] = goto1[state[parse_index-1]][T];
                      if(judge_multy == 1)
                      {
                          four_element[findex].operate = '*';
                          four_element[findex].arg1 = t[tindex-1];
                          four_element[findex].arg2 = t[tindex];
                          four_element[findex].result = temporary;

                          t[tindex] = temporary;
                          findex++;
                          temporary++;
                          T_value = T_value * F_value;
                          printf(" use expression: T-->T*F,   T_value = T_value * F_value = %d",T_value);
                      }
                      else
                      {
                          four_element[findex].operate = '/';
                          four_element[findex].arg1 = t[tindex-1];
                          four_element[findex].arg2 = t[tindex];
                          four_element[findex].result = temporary;
                          t[tindex] = temporary;
                          findex++;
                          temporary++;
                          T_value = T_value / F_value;
                          printf(" use expression: T-->T/F,   T_value = T_value / F_value = %d",T_value);
                      }
                      break;
               case 4:
                      list[parse_index] = T;
                      state[parse_index] = goto1[state[parse_index-1]][T];
                      T_value = F_value;
                      printf(" use expression: T-->F,  T_value = F_value = %d",T_value);
                      break;
               case 5:
                      parse_index = parse_index - 2;
                      list[parse_index] = F;
                      state[parse_index] = goto1[state[parse_index-1]][F];
                      F_value = E_value;
                      printf(" use expression: F-->(E),     F_value = E_value = %d",F_value);
                      break;
               case 6:
                      list[parse_index] = F;
                      state[parse_index] = goto1[state[parse_index-1]][F];
                      F_value = value;
                      if(mark ==1)
                      printf(" use expression: F-->id,  F_value = NUM.lexvalue = %d",value);
                      else
                      printf(" use expression: F-->id,  F_value = ID.lexvalue = %d",value);
                      break;
               default :
                      printf("erro\n");


            }
       }
       else
       {
           parse_index++;
           pointer++;
           list[parse_index]= lex_word[pointer-1];
           state[parse_index]= judge;
           switch(word)
           {
            case 0:
                   if(mark == 1)
                   {
                      t[++tindex] = lex_word[pointer-1];
                      value = atoi(symbol[p].variable);
                      printf("push NUM into the stack,    NUM.lexvalue = %s",symbol[p].variable);
                   }
                   else
                   {
                       iscreate =1;
                       t[++tindex] = lex_word[pointer-1];
                       if(symbol[p].type ==0)
                         printf("erro: The ID is not define before use it\n");
                       value = symbol[p].value;
                       printf("push %s into stack,   ID.lexvalue = %d",symbol[p].variable,symbol[p].value);
                   }
                   break;
            case 1:
                   printf("push +  into stack");
                   judge_add = 1;
                   break;
            case 2:
                   printf("push *  into stack");
                   judge_multy = 1;
                   break;
            case 3:
                   printf("push ( into stack");
                   break;
            case 4:
                   printf("push ) into stack");
                   break;
            case 101:
                   printf("push - into stack");
                   judge_add = 2;
                   break;
            case 102:
                   printf("push / into stack");
                   judge_multy = 2;
                   break;
            default:
                   break;
           }

       }
       getchar();
    }
       return E;
}
int findnumber2(int a)/*把词法分析返回的字符数字转化成算术表达式分析表数组对应的下标*/
{
  if(a>=1000)
      return ID;
   else if(a==great||a==great_equal||a==small||a==small_equal||a==not_equal||a==equal_equal)
      return 1;
   else if(a==leftpar)
      return 2;
   else if(a==rightpar)
      return 3;
   else if(a==not)
      return 4;
   else if(a==and)
      return 5;
   else if(a==or)
      return 6;
   else
      return 7;
}

int bool_parse()
{
    int state[300];/*状态栈*/
    int list[300]; /*移进字符栈  */
    int parse_index = 0;/*语法分析栈数组的指针 */
    int judge;/*分析表中的状态 */
    int word;
    state[0]=0;
    while(1)
    {
       word = findnumber2(lex_word[pointer]);
       judge = action2[state[parse_index]][word];
       if(judge == -1)
       {
          printf("bool expression erro exit\n");
          while(findnumber1(lex_word[pointer])!=7)
                 pointer++;
          break;
       }
       else if( judge == acc)
       {
          printf("complete bool expression parse\n");
          break;
       }
       else if( judge >100)
       {
           int a;
           a = judge%100;
           switch(a)
           {
               case 1:
                      list[parse_index] = B;
                      state[parse_index] = goto2[state[parse_index-1]][B];
                      printf(" use expression: B-->ID");
                      break;
               case 2:
                      parse_index = parse_index - 2;
                      list[parse_index] = B;
                      state[parse_index] = goto2[state[parse_index-1]][B];
                      printf(" use expression: B-->ID rop ID. rop is <, <= ,>,>= ,!=,== ");
                      break;
               case 3:
                      parse_index = parse_index - 2;
                      list[parse_index] = B;
                      state[parse_index] = goto2[state[parse_index-1]][B];
                      printf(" use expression: B-->(B)");
                      break;
               case 4:
                      parse_index = parse_index - 1;
                      list[parse_index] = B;
                      state[parse_index] = goto2[state[parse_index-1]][B];
                      printf(" use expression: B-->!B");
                      break;
               case 5:
                      parse_index = parse_index - 1;
                      list[parse_index] = A;
                      state[parse_index] = goto2[state[parse_index-1]][A];
                      printf(" use expression: A-->B &&");
                      break;
               case 6:
                      parse_index = parse_index - 1;
                      list[parse_index] = B;
                      state[parse_index] = goto2[state[parse_index-1]][B];
                      printf(" use expression: B-->AB");
                      break;
               case 7:
                      parse_index = parse_index - 1;
                      list[parse_index] = O;
                      state[parse_index] = goto2[state[parse_index-1]][O];
                      printf(" use expression: O-->B ||");
                      break;
               case 8:
                      parse_index = parse_index - 1;
                      list[parse_index] = B;
                      state[parse_index] = goto2[state[parse_index-1]][B];
                      printf(" use expression: B-->OB");
                      break;
               default :
                      printf("erro\n");


            }
       }
       else
       {
           parse_index++;
           pointer++;
           list[parse_index]= word;
           state[parse_index]= judge;
           switch(word)
           {
            case 0:
                   printf("push id into stack");
                   break;
            case 1:
                   if(lex_word[pointer-1]==small)