parse.cpp

snl语言是一个简单的具有嵌套过程定义的过程式语言

/********************************************************************/
void baseType(TreeNode * t)
{
	switch(token.Lex)
	{
	case INTEGER:  match(INTEGER);
	               t->kind.dec = IntegerK;
				   break;

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

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


/********************************************************************/
/* 函数名 structureType		 							            */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < structureType > ::=  arrayType | recType                */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
void 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 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);
	 }
	 match(INTC);
	 match(RMIDPAREN);
	 match(OF);
     baseType(t);
     t->attr.ArrayAttr.childtype = t->kind.dec;
	 t->kind.dec = ArrayK;
}


/********************************************************************/
/* 函数名 recType		 							                */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < recType > ::=  RECORD fieldDecList END                  */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
void recType(TreeNode * t)
{
	TreeNode * p = NULL;
	match(RECORD);
    p = fieldDecList();
	if(p!=NULL)
		t->child[0] = p;
	else
		syntaxError("a record body is requested!");
    match(END);
}


/********************************************************************/
/* 函数名 fieldDecList		 							            */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < fieldDecList > ::=   baseType idList ; fieldDecMore     */
/*                             | arrayType idList; fieldDecMore     */ 
/*说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点   */
/********************************************************************/
TreeNode * fieldDecList(void)
{

	TreeNode * t = newDecNode();
	TreeNode * p = NULL;
	if (t!=NULL)
	{
	    t->lineno = line0;
		switch(token.Lex)
		{
		case INTEGER:
	    case CHAR:
           baseType(t);
	       idList(t);
	       match(SEMI);
	       p = fieldDecMore();
	       break;
	    case ARRAY: 
	       arrayType(t);
	       idList(t);
	       match(SEMI);
	       p = fieldDecMore();
	       break;
        default:
		   ReadNextToken(&token);
		   syntaxError("unexpected token is here!");
		   break;
		}
	    t->sibling = p;
	}
	return t;
}


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


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


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


/**************************变量声明部分******************************/

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


/********************************************************************/
/* 函数名 varDeclaration		 						            */
/* 功  能 变量声明部分的处理函数						        	*/
/* 产生式 < varDeclaration > ::=  VAR  varDecList                   */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * varDeclaration(void)
{
	match(VAR);
	TreeNode * t = varDecList();
    if(t==NULL)
		syntaxError("a var declaration is expected!");
	return t;
}


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


/********************************************************************/
/* 函数名 varIdList		 						                    */
/* 功  能 变量声明部分的处理函数						        	*/
/* 产生式 < varIdList > ::=  id  varIdMore                          */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
void 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(&token);
	}
	varIdMore(t);
}

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

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

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

/********************************************************************/
/* 函数名 procDeclaration		 						            */
/* 功  能 函数声明部分的处理函数						        	*/
/* 产生式 < procDeclaration > ::=  PROCEDURE                        */
/*                                 ProcName(paramList);             */
/*                                 procDecPart                      */
/*                                 procBody                         */
/*                                 procDec                          */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/*        函数的根节点用于记录该函数的名字；第一个子节点指向参数节  */
/*        点，第二个节点指向函数中的声明部分节点；第三个节点指向函  */
/*        数体。
/********************************************************************/
TreeNode * 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 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(&token);
		syntaxError("unexpected token is here!");
		break;
	}
}


/********************************************************************/
/* 函数名 paramDecList		 			    	                    */