parseb.txt

SNL语言的编译器

		match(ID);
		t->idnum = (t->idnum) + 1;
	}
	idMore(t);
}


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


/********************************************************************/
/* 函数名 varDecList		 						                */
/* 功  能 变量声明部分的处理函数						        	*/
/* 产生式 < varDecList > ::=  typeName varIdList; varDecMore        */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
 Cglobal::TreeNode *  Cparse::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                      */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
 Cglobal::TreeNode *  Cparse::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  Cparse::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  Cparse::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                    */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
 Cglobal::TreeNode *  Cparse::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                          */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/*        函数的根节点用于记录该函数的名字；第一个子节点指向参数节  */
/*        点，第二个节点指向函数中的声明部分节点；第三个节点指向函  */
/*        数体。
/********************************************************************/
 Cglobal::TreeNode *  Cparse::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  Cparse::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		 			    	                    */
/* 功  能 函数声明中参数声明部分的处理函数	        	        	*/
/* 产生式 < paramDecList > ::=  param  paramMore                    */ 
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
 Cglobal::TreeNode * Cparse:: paramDecList(void)
{
	TreeNode * t = param();
	TreeNode * p = paramMore();
	if (p!=NULL)
	{
		t->sibling = p;
	}
	return t;
}

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