parse.cpp

上课时老师用过的SNL编译器

					    fprintf(listing,"FieldMember  ");
					    fprintf(listing,"%s  ",tree->name[0]);
						break;
						case ArrayMembV:
					    fprintf(listing,"ArrayMember  ");
						fprintf(listing,"%s  ",tree->name[0]);
						break;
						default: 
							fprintf(listing,"var type error!");
							Error = TRUE;
				   }
				   if(tree->table[0]!=NULL)
					   fprintf(listing,"%d   %d  ",tree->table[0]->attrIR.More.VarAttr.off,tree->table[0]->attrIR.More.VarAttr.level);

				   break;
              default: 
				  fprintf(listing,"error4!");
				  Error = TRUE;
			}
		  };break;
   default: 
	   fprintf(listing,"error5!");
	   Error = TRUE;
   }
   
   fprintf(listing,"\n");
   
    /* 对语法树结点tree的各子结点递归调用printTree过程 *
	 * 缩进写入列表文件listing						   */
    for (i=0;i<MAXCHILDREN;i++)
         printTree(tree->child[i]);

	/* 对语法树结点tree的兄弟节点递归调用printTree过程 *
	 * 缩进写入列表文件listing						   */ 
	tree = tree->sibling;			
  }

  /* 减量缩进宏,每次退出语法树节点时减量缩进 */
  UNINDENT;		
  
}


/****************************************************/
/* 文件   parse.c									*/
/* 说明   递归下降的语法分析程序					*/
/* 主题   TINY编译器的语法分析器实现				*/
/****************************************************/

/************ 语法分析功能函数 **************/

/********************************************************************/
/* 函数名 syntaxError												*/
/* 功  能 语法错误处理函数											*/
/* 说  明 将函数参数message指定的错误信息格式化写入列表文件listing	*/
/*		  设置错误追踪标志Error为TRUE								*/
/********************************************************************/
void  Cparse::syntaxError(char * message)

{ 
	fprintf(listing,"\n>>> error :   ");
    
	fprintf(listing,"Syntax error at line %d: %s\n",token.lineshow,message);

	Error = TRUE;
	
}

/********************************************************************/
/* 函数名 match														*/
/* 功  能 终极符匹配处理函数										*/
/* 说  明 函数参数expected给定期望单词符号与当前单词符号token相匹配	*/
/*        如果不匹配,则报非期望单词语法错误							*/
/********************************************************************/
 void  Cparse::match(LexType expected)

{ 
  if (token.Lex == expected)   
  {
	  ReadNextToken(&token);
	  line0 = token.lineshow;
  }
  else 
  {
	  syntaxError("not match error ");
	  fprintf(listing,"'%s'\n",token.Sem);
	  ReadNextToken(&token);

      //问题：遇到错误，要终止程序的执行，应该怎么做？？？？？？
	  // exit(0);
  }
  
}

/********************************************************************/
/* 函数名 program												    */
/* 功  能 总程序的处理函数								        	*/
/* 产生式 < program > ::= programHead declarePart programBody .     */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/*        语法树的根节点的第一个子节点指向程序头部分programHead,    */
/*        DeclaraPart为programHead的兄弟节点,程序体部分programBody  */
/*        为declarePart的兄弟节点.                                  */
/********************************************************************/
Cglobal::TreeNode *  Cparse::program(void)
{
	TreeNode * t=programHead();
	TreeNode * q=declarePart();
	TreeNode * s=programBody();
	
	TreeNode * root = newRootNode();
    if(root!=NULL)
	{
		root->lineno = 0;
		if(t!=NULL) root->child[0] = t;
	      else syntaxError("a program head is expected!");
	    if(q!=NULL) root->child[1] = q;
	    if(s!=NULL) root->child[2] = s;
	      else syntaxError("a program body is expected!");
	}
	match(DOT);

	return root;
}

/********************************************************************/
/* 函数名 programHead											    */
/* 功  能 程序头的处理函数								        	*/
/* 产生式 < programHead > ::= PROGRAM  ProgramName                  */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
Cglobal::TreeNode *  Cparse::programHead(void)
{
    TreeNode * t = newPheadNode();
	match(PROGRAM);
    if((t!=NULL)&&(token.Lex==ID))
	{   
		t->lineno = 0;
		strcpy(t->name[0], token.Sem);
	}
    match(ID);
    return t;
}	
    
/*************************声明部分***********************************/

/********************************************************************/
/* 函数名 declarePart											    */
/* 功  能 声明部分的处理函数								     	*/
/* 产生式 < declarePart > ::= typeDec  varDec  procDec              */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
Cglobal::TreeNode *  Cparse::declarePart(void)
{
     /*类型*/
	 TreeNode * typeP = newDecANode(TypeK);  
	 TreeNode * pp = typeP;  
	 
	 if(typeP!=NULL)
	 {
		 typeP->lineno = 0;
		 TreeNode * tp1 = typeDec();
	     if(tp1!=NULL)
		     typeP->child[0] = tp1;
		 else
		 {
			 free(typeP);
		     typeP=NULL;
		 }
	 }
	 /*变量*/
	 TreeNode * varP = newDecANode(VarK);
	 
	 if(varP != NULL)
	 {
		 varP->lineno = 0;
		 TreeNode * tp2 = varDec();
		 if(tp2 != NULL)
	          varP->child[0] = tp2;
		 else 
		 {
			 free(varP);
		     varP=NULL;
		 }
     }
	 /*函数*/
	 TreeNode * s = procDec();
     
	 if(s==NULL){}
	 
	 if(varP==NULL){varP=s;}
	 
     if(typeP==NULL){pp=typeP=varP;}
	 
	 if(typeP!=varP)
	 {
		typeP->sibling = varP;
        typeP = varP;
	 }
	 if(varP!=s)
	 {
		varP->sibling = s;
		varP = s;
	 }
	 return pp;
}

/**************************类型声明部分******************************/

/********************************************************************/
/* 函数名 typeDec									     		    */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < typeDec > ::= ε | TypeDeclaration                      */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
Cglobal::TreeNode *  Cparse::typeDec(void)
{
	TreeNode * t = NULL;
	switch (token.Lex)
	{ 
	  case TYPE: t = typeDeclaration(); break;
	  case VAR:
	  case PROCEDURE:
      case BEGIN: break;
      default :
		  ReadNextToken(&token);
		  syntaxError("unexpected token is here!");
		  break;
	}
	return t;
}
		  
	 
/********************************************************************/
/* 函数名 TypeDeclaration									  	    */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < TypeDeclaration > ::= TYPE  TypeDecList                 */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
Cglobal::TreeNode *  Cparse::typeDeclaration(void)
{
	match(TYPE);
	TreeNode * t = typeDecList();
	if (t==NULL)
	{
        syntaxError("a type declaration is expected!");
	}
	return t;
}


/********************************************************************/
/* 函数名 TypeDecList		 							  	        */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < TypeDecList > ::= typeId = typeName ; typeDecMore       */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
Cglobal::TreeNode *  Cparse::typeDecList(void)
{
	TreeNode * t = newDecNode();
	if (t != NULL)
	{
		t->lineno = line0;
		typeId(t);                               
	    match(EQ);  
	    typeName(t); 
	    match(SEMI);                           
        TreeNode * p = typeDecMore();
		if (p!=NULL)
			t->sibling = p;
	}
    return t;
}


/********************************************************************/
/* 函数名 typeDecMore		 							            */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < typeDecMore > ::=    ε | TypeDecList                   */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
Cglobal::TreeNode *  Cparse::typeDecMore(void)
{
	TreeNode * t=NULL;
    switch(token.Lex)
	{
	case VAR:         
	case PROCEDURE:
	case BEGIN:
		break;
	case ID:
		t = typeDecList();
		break;
	default:
		  ReadNextToken(&token);
		  syntaxError("unexpected token is here!");
		  break;
	}
	return t;
}


/********************************************************************/
/* 函数名 typeId		 							  	            */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < typeId > ::= id                                         */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
 void Cparse::typeId(TreeNode * t)
{
	int tnum = (t->idnum);
	if ((token.Lex==ID)&&(t!=NULL))
	{
	    strcpy(t->name[tnum] ,token.Sem);
		tnum = tnum+1;
	}
	t->idnum = tnum;
	match(ID);
}


/********************************************************************/
/* 函数名 typeName		 							  	            */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < typeName > ::= baseType | structureType | id            */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
 void  Cparse::typeName(TreeNode * t)
{
      if (t!=NULL)
	      switch (token.Lex)
		  {
		  case INTEGER:
		  case CHAR1:    baseType(t);break;
		  case ARRAY:
		  case RECORD:  structureType(t);break;
		  case ID:      
			      t->kind.dec = IdK;
				  strcpy(t->attr.type_name ,token.Sem);
			      match(ID);
			      break;
		  default:
			  ReadNextToken(&token);
			  syntaxError("unexpected token is here!");
		      break;
		  } 
}


/********************************************************************/
/* 函数名 baseType		 							  	            */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < baseType > ::=  INTEGER | CHAR                          */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
 void  Cparse::baseType(TreeNode * t)
{
	switch(token.Lex)
	{
	case INTEGER:  match(INTEGER);
	               t->kind.dec = IntegerK;
				   break;

	case CHAR1:     match(CHAR1);
		           t->kind.dec = CharK;
				   break;

    default:
	  		  ReadNextToken(&token);
			  syntaxError("unexpected token is here!");
		      break;
	}
}


/********************************************************************/
/* 函数名 structureType		 							            */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < structureType > ::=  arrayType | recType                */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
 void  Cparse::structureType(TreeNode * t)
{
	switch(token.Lex)
	{
	case ARRAY:    
		arrayType(t);               
		break;
    case RECORD:   
		t->kind.dec = RecordK;
		recType(t);
	    break;
    default:
		ReadNextToken(&token);
		syntaxError("unexpected token is here!");
		break;
	}
}


/********************************************************************/
/* 函数名 arrayType		 							                */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < arrayType > ::=  ARRAY [low..top] OF baseType           */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
 void  Cparse::arrayType(TreeNode * t)
{
     match(ARRAY);
	 match(LMIDPAREN);
     if (token.Lex==INTC)
	 {
		 t->attr.ArrayAttr.low = atoi(token.Sem);
	 }
	 match(INTC);
	 match(UNDERANGE);
	 if (token.Lex==INTC)
	 {
		 t->attr.ArrayAttr.up = atoi(token.Sem);