func.cpp

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

TreeNode * Syntax::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();
		syntaxError("unexpected token is here!");
		break;
	}
	return t;
}

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

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

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

		/*函数名的结点也用表达式类型结点*/
		TreeNode * child0 = newExpNode(VariK); 
		if(child0!=NULL)
		{
			child0->lineno = line0;
			strcpy(child0->name[0],temp_name);
			(child0->idnum)++;
			t->child[0] = child0;
		}
		t->child[1] = actParamList();
	}
	match(RPAREN);
	return t;
}

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

	switch(token.Lex)
	{
	case RPAREN:        break;
	case ID:
	case INTC:
		t =exp();
		if(t!=NULL)
			t->sibling = actParamMore();
		break;
	default:
		ReadNextToken();
		syntaxError("unexpected token is here!");
		break;
	}
	return t;
}

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



/*************************表达式部分********************************/
/****************************************************************************/
/* 函数名 exp																*/
/* 功  能 表达式处理函数													*/
/* 产生式 < 表达式 > ::= < 简单表达式 > [< 关系运算符 > < 简单表达式 > ]	*/
/* 说  明 该函数根据产生式调用相应递归处理函数,生成表达式类型语法树节点		*/
/****************************************************************************/
TreeNode * Syntax::exp(void)

{
  /* 调用简单表达式处理函数simple_exp(),返回语法树节点指针给t */
  TreeNode * t = simple_exp();

  /* 当前单词token为逻辑运算单词LT或者EQ */
  if ((token.Lex==LT)||(token.Lex==EQ)) 
  {
    /* 创建新的OpK类型语法树节点，新语法树节点指针赋给p */
    TreeNode * p = newExpNode(OpK);

	/* 新语法树节点p创建成功,初始化p第一个子节点成员child[0]
	 * 并将当前单词token(为EQ或者LT)赋给语法树节点p的运算符成员attr.op*/
    if (p!=NULL) 
	{
      p->lineno = line0;
	  p->child[0] = t;
      p->attr.ExpAttr.op = token.Lex;

	  /* 将新的表达式类型语法树节点p作为函数返回值t */
      t = p;
    }

	/* 当前单词token与指定逻辑运算符单词(为EQ或者LT)匹配 */
    match(token.Lex);

	/* 语法树节点t非空,调用简单表达式处理函数simple_exp()	*
	 * 函数返回语法树节点指针给t的第二子节点成员child[1]	*/
    if (t!=NULL)
      t->child[1] = simple_exp();
  }
  
  /* 函数返回表达式类型语法树节点t */
  return t;
}


/************************************************************************/
/* 函数名 simple_exp													*/
/* 功  能 简单表达式处理函数											*/
/* 产生式 < 简单表达式 >::=	< 项 > { < 加法运算符 > < 项 > }			*/
/* 说  明 该函数根据产生式调用相应递归处理函数,生成表达式类型语法树节点	*/
/************************************************************************/
TreeNode * Syntax::simple_exp(void)

{
  /* 调用元处理函数term(),函数返回语法树节点指针给t */
  TreeNode * t = term();

  /* 当前单词token为加法运算符单词PLUS或MINUS */
  while ((token.Lex==PLUS)||(token.Lex==MINUS))

  {
    /* 创建新OpK表达式类型语法树节点，新语法树节点指针赋给p */
	TreeNode * p = newExpNode(OpK);

 	/* 语法树节点p创建成功,初始化p第一子节点成员child[0]	*
	 * 返回语法树节点指针给p的运算符成员attr.op				*/
    if (p!=NULL) 
	{
      p->lineno = line0;
	  p->child[0] = t;
      p->attr.ExpAttr.op = token.Lex;

	  /* 将函数返回值t赋成语法树节点p */
      t = p;

	  /* 当前单词token与指定加法运算单词(为PLUS或MINUS)匹配 */
      match(token.Lex);

	  /* 调用元处理函数term(),函数返回语法树节点指针给t的第二子节点成员child[1] */
      t->child[1] = term();
    }
  }
  /* 函数返回表达式类型语法树节点t */
  return t;
}



/****************************************************************************/
/* 函数名 term																*/
/* 功  能 项处理函数														*/
/* 产生式 < 项 > ::= < 因子 > { < 乘法运算符 > < 因子 > }					*/
/* 说  明 该函数根据产生式调用相应递归处理函数,生成表达式类型语法树节点		*/
/****************************************************************************/
TreeNode * Syntax::term(void)

{
  /* 调用因子处理函数factor(),函数返回语法树节点指针给t */
  TreeNode * t = factor();

  /* 当前单词token为乘法运算符单词TIMES或OVER */
  while ((token.Lex==TIMES)||(token.Lex==OVER))

  {
    /* 创建新的OpK表达式类型语法树节点,新节点指针赋给p */
	treeNode * p = newExpNode(OpK);

	/* 新语法树节点p创建成功,初始化第一个子节点成员child[0]为t	*
	 * 将当前单词token赋值给语法树节点p的运算符成员attr.op		*/
    if (p!=NULL) 
	{
      p->lineno= line0;
	  p->child[0] = t;
      p->attr.ExpAttr.op = token.Lex;
      t = p;
	}
	
	/* 当前单词token与指定乘法运算符单词(为TIMES或OVER)匹配 */
    match(token.Lex);

	/* 调用因子处理函数factor(),函数返回语法树节点指针赋给p第二个子节点成员child[1] */
    p->child[1] = factor();
    
  }
  /* 函数返回表达式类型语法树节点t */
  return t;
}