func.cpp

SNL语言编译器源码 小语言的编译器C++实现 包括词法分析

}


/********************************************************************/
/* 函数名 varDecList		 						                */
/* 功  能 变量声明部分的处理函数						        	*/
/* 产生式 < varDecList > ::=  typeName varIdList; varDecMore        */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * Syntax::varDecList(void)
{
	TreeNode * t = newDecNode();
	TreeNode * p = NULL;

	if ( t != NULL )
	{
		t->lineno = line0;
		typeName(t);
	    varIdList(t);
	    match(SEMI);
        p = varDecMore();
	    t->sibling = p;
	}
	return t;
}

/********************************************************************/
/* 函数名 varDecMore		 						                */
/* 功  能 变量声明部分的处理函数						        	*/
/* 产生式 < varDecMore > ::=  ε |  varDecList                      */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * Syntax::varDecMore(void)
{
	TreeNode * t =NULL;

	switch(token.Lex)
	{
	case PROCEDURE:
	case BEGIN:
		    break;
	case INTEGER:
	case CHAR:
	case ARRAY:
	case RECORD:
	case ID:
		t = varDecList();
		break;
	default:
		ReadNextToken();
		syntaxError("unexpected token is here!");
		break;
	}
	return t;
}


/********************************************************************/
/* 函数名 varIdList		 						                    */
/* 功  能 变量声明部分的处理函数						        	*/
/* 产生式 < varIdList > ::=  id  varIdMore                          */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
void Syntax::varIdList(TreeNode * t)
{
	if (token.Lex==ID)
	{
        strcpy(t->name[(t->idnum)] ,token.Sem);
        match(ID);
		t->idnum =(t->idnum ) + 1;
	}
	else 
	{
		syntaxError("a varid is expected here!");
		ReadNextToken();
	}
	varIdMore(t);
}

 
/********************************************************************/
/* 函数名 varIdMore		 						                    */
/* 功  能 变量声明部分的处理函数						        	*/
/* 产生式 < varIdMore > ::=  ε |  , varIdList                      */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/     
void Syntax::varIdMore(TreeNode * t)
{
	switch(token.Lex)
	{
	case SEMI:  break;
	case COMMA:
		match(COMMA);
		varIdList(t);
		break;
	default:
		ReadNextToken();
		syntaxError("unexpected token is here!");
		break;
	}
}

/****************************过程声明部分****************************/

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

/********************************************************************/
/* 函数名 procDeclaration		 						            */
/* 功  能 函数声明部分的处理函数						        	*/
/* 产生式 < procDeclaration > ::=  PROCEDURE                        */
/*                                 ProcName(paramList);             */
/*                                 procDecPart                      */
/*                                 procBody                         */
/*                                 procDec                          */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/*        函数的根节点用于记录该函数的名字；第一个子节点指向参数节  */
/*        点，第二个节点指向函数中的声明部分节点；第三个节点指向函  */
/*        数体。
/********************************************************************/
TreeNode * Syntax::procDeclaration(void)
{
	TreeNode * t = newProcNode();
	match(PROCEDURE);
	if (t!=NULL)
	{
		t->lineno = line0;
		if (token.Lex==ID)
		{
			strcpy(t->name[0],token.Sem);
			(t->idnum)++;
			match(ID);
		}
		match(LPAREN);
		paramList(t);
		match(RPAREN);
        match(SEMI);
		t->child[1] = procDecPart();
		t->child[2] = procBody();
		t->sibling = procDec();
	}
	return t;
}


/********************************************************************/
/* 函数名 paramList		 						                    */
/* 功  能 函数声明中参数声明部分的处理函数	        	        	*/
/* 产生式 < paramList > ::=  ε |  paramDecList                     */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
void Syntax::paramList(TreeNode * t)     
{
	TreeNode * p = NULL;
	
	switch(token.Lex)
	{
	case RPAREN:  break;
	case INTEGER:
	case CHAR:
	case ARRAY:
	case RECORD:
	case ID:
	case VAR:
		p = paramDecList();
		t->child[0] = p;
		break;
	default:
		ReadNextToken();
		Syntax::syntaxError("unexpected token is here!");
		break;
	}
}


/********************************************************************/
/* 函数名 paramDecList		 			    	                    */
/* 功  能 函数声明中参数声明部分的处理函数	        	        	*/
/* 产生式 < paramDecList > ::=  param  paramMore                    */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * Syntax::paramDecList(void)
{
	TreeNode * t = param();
	TreeNode * p = paramMore();
	if (p!=NULL)
	{
		t->sibling = p;
	}
	return t;
}

/********************************************************************/
/* 函数名 paramMore		 			    	                        */
/* 功  能 函数声明中参数声明部分的处理函数	        	        	*/
/* 产生式 < paramMore > ::=  ε | ; paramDecList                     */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * Syntax::paramMore(void)
{
	TreeNode * t = NULL;
	switch(token.Lex)
	{
	case RPAREN:   break;
	case SEMI:
		match(SEMI);
		t = paramDecList();
		if (t==NULL)
			syntaxError("a param declaration is request!");
		break;
    default:
		ReadNextToken();
		syntaxError("unexpected token is here!");
		break;
	}
	return t;
}

/********************************************************************/
/* 函数名 param		 			    	                            */
/* 功  能 函数声明中参数声明部分的处理函数	        	        	*/
/* 产生式 < param > ::=  typeName formList | VAR typeName formList  */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * Syntax::param(void)
{
	TreeNode * t = newDecNode();
	if (t!=NULL)
	{
		t->lineno = line0;
		switch(token.Lex)
		{
	     case INTEGER:
	     case CHAR:
	     case ARRAY:
	     case RECORD:
	     case ID:
	    	 t->attr.ProcAttr.paramt = valparamType;
			 typeName(t);
	    	 formList(t);
			 break;
		 case VAR:
			 match(VAR);
			 t->attr.ProcAttr.paramt = varparamType;
			 typeName(t);
			 formList(t);
			 break;
         default:
			 ReadNextToken();
			 syntaxError("unexpected token is here!");
		     break;
		}
	}
	return t;
}

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

/********************************************************************/
/* 函数名 fidMore		 			    	                        */
/* 功  能 函数声明中参数声明部分的处理函数	        	        	*/
/* 产生式 < fidMore > ::=   ε |  , formList                        */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
void Syntax::fidMore(TreeNode * t)
{
	switch(token.Lex)
	{
	case SEMI:
	case RPAREN:   break;
	case COMMA:
		match(COMMA);
		formList(t);
		break;
	default:
		ReadNextToken();
		syntaxError("unexpected token is here!");
		break;
	}
}
			
/********************************************************************/
/* 函数名 procDecPart		 			  	                        */
/* 功  能 函数中的声明部分的处理函数	             	        	*/
/* 产生式 < procDecPart > ::=  declarePart                          */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * Syntax::procDecPart(void)
{
     TreeNode * t = declarePart();
	 return t;
}

/********************************************************************/
/* 函数名 procBody		 			  	                            */
/* 功  能 函数体部分的处理函数	                    	        	*/
/* 产生式 < procBody > ::=  programBody                             */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * Syntax::procBody(void)
{
	TreeNode * t = programBody();
	if (t==NULL)
		syntaxError("a program body is requested!");
	return t;
}

/********************************************************************/
/* 函数名 programBody		 			  	                        */
/* 功  能 程序体部分的处理函数	                    	        	*/
/* 产生式 < programBody > ::=  BEGIN  stmList   END                 */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * Syntax::programBody(void)
{
	TreeNode * t = newStmlNode();
    match(BEGIN);
	if(t!=NULL)
	{
		t->lineno = 0;
		t->child[0] = stmList();
	}
    match(END);
    return t;
}


/********************************************************************/
/* 函数名 stmList		 			  	                            */
/* 功  能 语句部分的处理函数	                    	        	*/
/* 产生式 < stmList > ::=  stm    stmMore                           */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * Syntax::stmList(void)
{
	TreeNode * t = stm();
    TreeNode * p = stmMore();
	if(t!=NULL)
		if ( p!= NULL)
			t->sibling = p;
	return t;
}

/********************************************************************/
/* 函数名 stmMore		 			  	                            */
/* 功  能 语句部分的处理函数	                    	        	*/
/* 产生式 < stmMore > ::=   ε |  ; stmList                         */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * Syntax::stmMore(void)
{
	TreeNode * t = NULL;
	switch(token.Lex)
	{
	case ELSE:
	case FI:
	case END:
	case ENDWH:	break;
	case SEMI:
		match(SEMI);
		t = stmList();
		break;
	default:
		ReadNextToken();
		syntaxError("unexpected token is here!");
		break;
	}
	return t;
}

/********************************************************************/
/* 函数名 stm   		 			  	                            */
/* 功  能 语句部分的处理函数	                    	        	*/
/* 产生式 < stm > ::=   conditionalStm   {IF}                       */
/*                    | loopStm          {WHILE}                    */
/*                    | inputStm         {READ}                     */
/*                    | outputStm        {WRITE}                    */
/*                    | returnStm        {RETURN}                   */
/*                    | id  assCall      {id}                       */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/