grammar_analyse.cpp

C-语言的编译器中的词法分析和语法分析VC++开发

   Error = true;
}
void match(TokenType expected)
{  if(token==expected) token = getToken();
   else
   {  syntaxError("unexpected token ->");
      printToken(token,tokenString);
      fprintf(listing,"         ");
   }
}
   
TreeNode * parse(void)
{  TreeNode * t;
   token = getToken();
   t = declaration_list();
   if(token!=ENDFILE) syntaxError("Code ends before file\n");
   return t;
}
   
/*1**********declaration_list***************/
TreeNode * declaration_list(void)
{  TreeNode * t = declaration();
   TreeNode * p = t;
   while(token==INT||token==VOID)
   {  TreeNode *q;
      q = declaration();
      if(q!=NULL)
      {  if(t==NULL) t = p = q;
         else
         {  p->sibling = q;
            p = q;
         }
      }
   }
   return t;
}

/*2**********declaration********************/
TreeNode * declaration(void)
{  TreeNode * t = newExpNode(IdK);
   if(token==INT) match(INT);
   else match(VOID);
   if((t!=NULL)&&(token==ID)) t->attr.name = copyString(tokenString);
   match(ID);
   if(token==SEMICOLON)match(SEMICOLON);
   else if(token==LMP)
   {  match(LMP);
      if((t!=NULL)&&(token==ID)) t->attr.val = atoi(tokenString);
      match(NUM);
      match(RMP);
      match(SEMICOLON); 
   }
   else
   {
      match(LSP);
      if(t!=NULL) t->child[0] = params();
      match(RSP);
      if(t!=NULL) t->child[1] = compound_stmt();
   }
   return t;
}

/*3**********var_declaration****************/
TreeNode * var_declaration(void)
{  TreeNode * t = newExpNode(IdK);
   if(token==INT) match(INT);
   else match(VOID);
   if((t!=NULL)&&(token==ID)) t->attr.name = copyString(tokenString);
   match(ID);
   if(token==SEMICOLON) match(SEMICOLON);
   else
   {  match(LMP);
      if((t!=NULL)&&(token==ID)) t->attr.val = atoi(tokenString);
      match(NUM);
      match(RMP);
      match(SEMICOLON);
   }
   return t;
}

/*4**********params*************************/
TreeNode * params(void)
{  TreeNode * t = newExpNode(IdK);
   int i=0;
   if(token==INT)
   {  match(INT);
      if((t!=NULL)&&(token==ID)) t->attr.name = copyString(tokenString);
      match(ID);
      if(token==LMP) { match(LMP);match(RMP); }
      TreeNode * p = t;
      while(token==COMMA)
      {  TreeNode * q;
         match(COMMA);
         q = param();
         if(q!=NULL)
         {  if(t==NULL) t = p =q;
            else
            {  p->sibling = q;
               p = q;
            }
         }
      }
   }
   else
   {  match(VOID);
      if(token==ID)
      {  if(t!=NULL) t->attr.name = copyString(tokenString);
         match(ID);
         if(token==LMP) { match(LMP);match(RMP); }
         TreeNode * p = t;
         while(token==COMMA)
         {  TreeNode * q;
            match(COMMA);
            q = param();
            if(q!=NULL)
            {  if(t==NULL) t = p =q;
               else
               {  p->sibling = q;
                  p = q;
               }
            }
         }
      }
   }
   return t;
}     

/*5**********param**************************/
TreeNode * param(void)
{  TreeNode * t = newExpNode(IdK);
   if(token==INT) match(INT);
   else match(VOID);
   if((t!=NULL)&&(token==ID)) t->attr.name = copyString(tokenString);
   match(ID);
   if(token==LMP) { match(LMP);match(RMP); }
   return t;
}

/*6**********compound_stmt******************/
TreeNode * compound_stmt(void)
{  TreeNode * t = newStmtNode(CompK);
   match(LLP);
   if(t!=NULL)
   {  t->child[0] = local_declarations();
      t->child[1] = statement_list();
   }
   match(RLP);
   return t;
}

/*7**********local_declarations*************/
TreeNode * local_declarations(void)
{   TreeNode * t = NULL;
    TreeNode * p ;
    while(token==INT||token==VOID)
    {  TreeNode *q;
      q = var_declaration();
      if(q!=NULL)
      {  if(t==NULL) t = p = q;
         else
         {  p->sibling = q;
            p = q;
         }
      }
    }
    return t;
}

/*8**********statement_list*****************/
TreeNode * statement_list(void)
{   TreeNode * t = NULL;
    TreeNode * p ;
    while(token==ID||token==LLP||token==IF||token==WHILE||token==RETURN)
    {  TreeNode *q;
       q = statement();
       if(q!=NULL)
       {  if(t==NULL) t = p = q;
          else
          {  p->sibling = q;
             p = q;
          }
       }
    }
    return t;
} 

/*9**********statement**********************/
TreeNode * statement(void)
{  TreeNode * t = NULL;
   switch(token)
   {  case ID    : t = assign_stmt();break;
      case LLP   : t = compound_stmt();break; 
      case IF    : t = selection_stmt();break;
      case WHILE : t = iteration_stmt();break;
      case RETURN: t = return_stmt();break;
      default    : syntaxError("unexpected token ->");
                   printToken(token,tokenString);
                   token = getToken();break;
   }
   return t;
}
      



/*10*********selection_stmt***************/
TreeNode * selection_stmt(void)
{  TreeNode * t = newStmtNode(IfK);
   match(IF);
   match(LSP);
   if(t!=NULL) t->child[0] = expression();
   match(RSP);
   if(t!=NULL) t->child[1] = statement();
   if(token==ELSE)
   {  match(ELSE);
      if(t!=NULL) t->child[2] = statement();
   }
   return t;
}

/*11*********iteration_stmt***************/
TreeNode * iteration_stmt(void)
{  TreeNode * t = newStmtNode(RepeatK);
   match(WHILE);
   match(LSP);
   if(t!=NULL) t->child[0] = expression();
   match(RSP);
   if(t!=NULL) t->child[1] = statement();
   return t;
}

/*12*********return_stmt*****************/
TreeNode * return_stmt(void)
{  TreeNode * t = newStmtNode(ReturnK);
   match(RETURN);
   if(token==SEMICOLON) match(SEMICOLON);
   else if(t!=NULL)
   {  t->child[0] = expression();
      match(SEMICOLON);
   }
   return t;
}

/*13*********assign_stmt********************/
TreeNode * assign_stmt(void)
{  TreeNode * t = newStmtNode(AssignK);
   if((t!=NULL)&&(token==ID))
   {  t->attr.name = copyString(tokenString);
      match(ID);
      if((t!=NULL)&&(token==LMP))
      {  match(LMP);
         t->child[0] = expression();
         match(RMP);
         match(ASSIGN);
         if(t!=NULL) t->child[1] = expression();
      }
      else
      {  match(ASSIGN);
         if(t!=NULL) t->child[0] = expression();
      }
      match(SEMICOLON);
   }
   return t;
}

/*14*********expression********************/
TreeNode * expression(void)
{  TreeNode * t = additive_expression();
   while((token==LT)||(token==LE)||(token==GT)||(token==EQ)||(token==NEQ))
   {  TreeNode * p= newExpNode(OpK);//ADD,SUB,MUL,DIV,LT,LE,GT,GE,EQ,NEQ
      if(p!=NULL)
      {  p->child[0] = t;
         switch(token)
         {  case ADD : p->attr.op = "+";break;
            case SUB : p->attr.op = "-";break;
            case MUL : p->attr.op = "*";break;
            case DIV : p->attr.op = "/";break;
            case LT  : p->attr.op = "<";break;
            case LE  : p->attr.op = "<=";break;
            case GT  : p->attr.op = ">";break;
            case GE  : p->attr.op = ">=";break;
            case EQ  : p->attr.op = "==";break;
            case NEQ : p->attr.op = "!=";break;
         }
         t = p;
         match(token);
         p->child[1] = additive_expression();
      }
   }
   return t;
}

/*15*********additive_expression***********/
TreeNode * additive_expression(void)
{  TreeNode * t = term();
   while((token==ADD)||(token==SUB))
   {  TreeNode * p = newExpNode(OpK);//?????????????
      if(p!=NULL)
      {  p->child[0] = t; 
         switch(token)
         {  case ADD : p->attr.op = "+";break;
            case SUB : p->attr.op = "-";break;
            case MUL : p->attr.op = "*";break;
            case DIV : p->attr.op = "/";break;
            case LT  : p->attr.op = "<";break;
            case LE  : p->attr.op = "<=";break;
            case GT  : p->attr.op = ">";break;
            case GE  : p->attr.op = ">=";break;
            case EQ  : p->attr.op = "==";break;
            case NEQ : p->attr.op = "!=";break;
         }
         t = p;
         match(token);
         p->child[1] = term();
      }
   }
   return t;
}

/*16*********term*************************/
TreeNode * term(void)
{  TreeNode * t = factor();
   while((token==MUL)||(token==DIV))
   {  TreeNode * p = newExpNode(OpK);//??????????????????????????
      if(p!=NULL)
      {  p->child[0] = t;
         switch(token)
         {  case ADD : p->attr.op = "+";break;
            case SUB : p->attr.op = "-";break;
            case MUL : p->attr.op = "*";break;
            case DIV : p->attr.op = "/";break;
            case LT  : p->attr.op = "<";break;
            case LE  : p->attr.op = "<=";break;
            case GT  : p->attr.op = ">";break;
            case GE  : p->attr.op = ">=";break;
            case EQ  : p->attr.op = "==";break;
            case NEQ : p->attr.op = "!=";break;
         }
         t = p;
         match(token);
         p->child[1] = factor();
      }
   }
   return t;
}

/*17*********factor***********************/
TreeNode * factor(void)
{  TreeNode * t = NULL;
   switch(token)
   {  case LSP  : match(LSP);
                  t = expression();
                  match(RSP);break;
      case ID   : t = newExpNode(IdK);
                  if((t!=NULL)&&(token==ID))
                    t->attr.name = copyString(tokenString);
                  match(ID);
                  if((t!=NULL)&&(token==LMP))
                  {  match(LMP);
                     t->child[0] = expression();
                     match(RMP);
                  }
                  else if((t!=NULL)&&(token==LSP))
                  {  match(LSP);
                     t->child[0] = args();
                     match(RSP);
                  }
                  break;
      case NUM  : t = newExpNode(ConstK);
                  if((t!=NULL)&&(token==NUM))
                    t->attr.val = atoi(tokenString);
                  match(NUM);break;
      default   : syntaxError("unexpected token ->");
                   printToken(token,tokenString);
                   token = getToken();break;
   }
   return t;
} 

/*18*********args***********************/
TreeNode * args(void)
{   TreeNode * t = NULL;
    TreeNode * p ;
    if(token==ID||token==LSP||token==NUM)
    {  t = expression();
       p = t;
       while(token==COMMA)
       {  match(COMMA);
          TreeNode *q;
          q = expression();
          if(q!=NULL)
          {  if(t==NULL) t = p = q;
             else
             {  p->sibling = q;
                p = q;
             }
          }
       }
    }
    return t;
}


int main()
{
    int i ;
    cout<< "***************************************"<<endl; 
    cout<<"请输入源文件名（包括路径和后缀名）："<<endl;
    while(cin>>file_in)
    {  if ((source = fopen(file_in,"r")) == NULL) 
           printf("cannot open infile,please input again:\n");
       else break;
    }
    cout<<endl;
    strcpy(file_out,"aa.txt");
    if ((listing = fopen(file_out,"w")) == NULL)
    {
        printf("cannot open outfile\n");
        getch();
        exit(0);
    }
    lineno = 1;
    TreeNode * t = parse();
    printTree(t);
    fclose(source);
    fclose(listing);
    cout<<"****************************************"<<endl;
    listing=fopen(file_out,"r");
    char ch = fgetc(listing);
    while(ch!=EOF){
                   putchar(ch);
                   ch = fgetc(listing);
                   }
    fclose(listing);
    system("pause");
    return 0;
}