parse.cpp

学习编译原理

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

/********************************************************************/
/* 函数名 paramMore		 			    	                        */
/* 功  能 函数声明中参数声明部分的处理函数	        	        	*/
/* 产生式 < paramMore > ::=  ε | ; paramDecList                     */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * 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(&token);
		syntaxError("unexpected token is here!");
		break;
	}
	return t;
}

/********************************************************************/
/* 函数名 param		 			    	                            */
/* 功  能 函数声明中参数声明部分的处理函数	        	        	*/
/* 产生式 < param > ::=  typeName formList | VAR typeName formList  */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * 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(&token);
			 syntaxError("unexpected token is here!");
		     break;
		}
	}
	return t;
}

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

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

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

/********************************************************************/
/* 函数名 stmMore		 			  	                            */
/* 功  能 语句部分的处理函数	                    	        	*/
/* 产生式 < stmMore > ::=   ε |  ; stmList                         */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * 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(&token);
		syntaxError("unexpected token is here!");
		break;
	}
	return t;
}

/********************************************************************/
/* 函数名 stm   		 			  	                            */
/* 功  能 语句部分的处理函数	                    	        	*/
/* 产生式 < stm > ::=   conditionalStm   {IF}                       */
/*                    | loopStm          {WHILE}                    */
/*                    | inputStm         {READ}                     */
/*                    | outputStm        {WRITE}                    */
/*                    | returnStm        {RETURN}                   */
/*                    | id  assCall      {id}                       */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * stm(void)
{
	
	TreeNode * t = NULL;
	switch(token.Lex)
	{
	case IF:  
		t = conditionalStm();
		break;
	case WHILE:
		t = loopStm();
		break;
	case READ:
		t = inputStm();
		break;
	case WRITE:
		t = outputStm();
		break;
	case RETURN:
		t = returnStm();
		break;
	case ID:
		temp_name = copyString(token.Sem);
		match(ID);              
        t = assCall();
		break;
	default:
		ReadNextToken(&token);
		syntaxError("unexpected token is here!");
		break;
	}
	return t;
}

/********************************************************************/
/* 函数名 assCall		 			  	                            */
/* 功  能 语句部分的处理函数	                    	        	*/
/* 产生式 < assCall > ::=   assignmentRest   {:=,LMIDPAREN,DOT}     */
/*                        | callStmRest      {(}                    */  
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * assCall(void)
{
	TreeNode * t = NULL;
	switch(token.Lex)
	{
	case ASSIGN:
	case LMIDPAREN:
	case DOT:
		t = assignmentRest();
		break;
	case LPAREN:
		t = callStmRest();
		break;
	default:
		ReadNextToken(&token);
		syntaxError("unexpected token is here!");
		break;
	}
	return t;
}

/********************************************************************/
/* 函数名 assignmentRest		 			                        */
/* 功  能 赋值语句部分的处理函数	                    	        */
/* 产生式 < assignmentRest > ::=  variMore : = exp                  */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * assignmentRest(void)
{
	TreeNode * t = newStmtNode(AssignK);
	
	/* 赋值语句节点的第一个儿子节点记录赋值语句的左侧变量名，*
	/* 第二个儿子结点记录赋值语句的右侧表达式*/
	if(t!=NULL)
    {
		t->lineno = line0;
		
		/*处理第一个儿子结点，为变量表达式类型节点*/
		TreeNode * child1 = newExpNode(VariK);
		if(child1!=NULL)
		{
			child1->lineno = line0;
			strcpy(child1->name[0],temp_name);
			(child1->idnum)++;
			variMore(child1);
			t->child[0] = child1;
		}
		
		/*赋值号匹配*/
		match(ASSIGN);
	  
		/*处理第二个儿子节点*/
		t->child[1] = exp(); 
				
	}
	return t;
}

/********************************************************************/
/* 函数名 conditionalStm		 			                        */
/* 功  能 条件语句部分的处理函数	                    	        */
/* 产生式 < conditionalStm > ::= IF exp THEN stmList ELSE stmList FI*/ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * conditionalStm(void)
{
	TreeNode * t = newStmtNode(IfK);
	match(IF);
	if(t!=NULL)  
	{
		t->lineno = line0;
		t->child[0] = exp();
	}
	match(THEN);
	if(t!=NULL)  t->child[1] = stmList();
	if(token.Lex==ELSE)
	{
		match(ELSE);
		if(t!=NULL)   
			t->child[2] = stmList();
	}
	match(FI);
	return t;
}


/********************************************************************/
/* 函数名 loopStm          		 			                        */
/* 功  能 循环语句部分的处理函数	                    	        */
/* 产生式 < loopStm > ::=      WHILE exp DO stmList ENDWH           */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * loopStm(void)
{
	TreeNode * t = newStmtNode(WhileK);
	match(WHILE);
	if (t!=NULL)  
	{
		t->lineno = line0;
		t->child[0] = exp();
	    match(DO);
	    t->child[1] = stmList();
	    match(ENDWH);
	}
	return t;
}

/********************************************************************/
/* 函数名 inputStm          		     	                        */
/* 功  能 输入语句部分的处理函数	                    	        */
/* 产生式 < inputStm > ::=    READ(id)                              */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * inputStm(void)
{
	TreeNode * t = newStmtNode(ReadK);
	match(READ);
	match(LPAREN);
	if((t!=NULL)&&(token.Lex==ID))	
	{
		t->lineno = line0;
		strcpy(t->name[0] ,token.Sem);
        (t->idnum)++;
	}
	match(ID);
	match(RPAREN);
	return t;
}

/********************************************************************/
/* 函数名 outputStm          		     	                        */
/* 功  能 输出语句部分的处理函数	                    	        */
/* 产生式 < outputStm > ::=   WRITE(exp)                            */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * outputStm(void)
{
	TreeNode * t = newStmtNode(WriteK);
	match(WRITE);
	match(LPAREN);
	if(t!=NULL)  
	{
		t->lineno = line0;
		t->child[0] = exp();
	}
	match(RPAREN);
	return t;
}

/********************************************************************/
/* 函数名 returnStm          		     	                        */
/* 功  能 返回语句部分的处理函数	                    	        */
/* 产生式 < returnStm > ::=   RETURN                                */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * returnStm(void)
{
	TreeNode * t = newStmtNode(ReturnK);
	match(RETURN);
	if(t!=NULL)
		t->lineno = line0;
	return t;
}

/********************************************************************/
/* 函数名 callStmRest          		     	                        */
/* 功  能 函数调用语句部分的处理函数	                  	        */
/* 产生式 < callStmRest > ::=  (actParamList)                       */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * callStmRest(void)
{
	TreeNode * t=newStmtNode(CallK);
	match(LPAREN);
	/*函数调用时，其子节点指向实参*/
	if(t!=NULL)  
	{
		t->lineno = line0;