func.cpp

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

			 free(varP);
		     varP=NULL;
		 }
     }
	 /*函数*/
	 TreeNode * s = procDec();
     
	 if(s==NULL){}
	 
	 if(varP==NULL){varP=s;}
	 
     if(typeP==NULL){pp=typeP=varP;}
	 
	 if(typeP!=varP)
	 {
		typeP->sibling = varP;
        typeP = varP;
	 }
	 if(varP!=s)
	 {
		varP->sibling = s;
		varP = s;
	 }
	 return pp;
}



/**************************类型声明部分******************************/

/********************************************************************/
/* 函数名 typeDec									     		    */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < typeDec > ::= ε | TypeDeclaration                      */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * Syntax::typeDec(void)
{
	TreeNode * t = NULL;
	switch (token.Lex)
	{ 
	  case TYPE: t =typeDeclaration(); break;
	  case VAR:
	  case PROCEDURE:
      case BEGIN: break;
      default :
		 ReadNextToken();
		 syntaxError("unexpected token is here!");
		  break;
	}
	return t;
}
		  
	 
/********************************************************************/
/* 函数名 TypeDeclaration									  	    */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < TypeDeclaration > ::= TYPE  TypeDecList                 */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * Syntax::typeDeclaration(void)
{
	match(TYPE);
	TreeNode * t =typeDecList();
	if (t==NULL)
	{
        syntaxError("a type declaration is expected!");
	}
	return t;
}


/********************************************************************/
/* 函数名 TypeDecList		 							  	        */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < TypeDecList > ::= typeId = typeName ; typeDecMore       */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
TreeNode * Syntax::typeDecList(void)
{
	TreeNode * t = newDecNode();
	if (t != NULL)
	{
		t->lineno = line0;
		typeId(t);                               
	    match(EQ);  
	    typeName(t); 
	    match(SEMI);                           
        TreeNode * p =typeDecMore();
		if (p!=NULL)
			t->sibling = p;
	}
    return t;
}


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


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


/********************************************************************/
/* 函数名 typeName		 							  	            */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < typeName > ::= baseType | structureType | id            */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
void Syntax::typeName(TreeNode * t)
{
      if (t!=NULL)
	      switch (token.Lex)
		  {
		  case INTEGER:
		  case CHAR:    baseType(t);break;
		  case ARRAY:
		  case RECORD:  structureType(t);break;
		  case ID:      
			      t->kind.dec = IdK;
				  strcpy(t->attr.type_name ,token.Sem);
			      match(ID);
			      break;
		  default:
			  ReadNextToken();
			  syntaxError("unexpected token is here!");
		      break;
		  } 
}


/********************************************************************/
/* 函数名 baseType		 							  	            */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < baseType > ::=  INTEGER | CHAR                          */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
void Syntax::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();
			  syntaxError("unexpected token is here!");
		      break;
	}
}


/********************************************************************/
/* 函数名 structureType		 							            */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < structureType > ::=  arrayType | recType                */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
void Syntax::structureType(TreeNode * t)
{
	switch(token.Lex)
	{
	case ARRAY:    
		arrayType(t);               
		break;
    case RECORD: 
		t->kind.dec = RecordK;
		recType(t);
	    break;
    default:
		ReadNextToken();
		syntaxError("unexpected token is here!");
		break;
	}
}


/********************************************************************/
/* 函数名 arrayType		 							                */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < arrayType > ::=  ARRAY [low..top] OF baseType           */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
void Syntax::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 Syntax::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 * Syntax::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();
		   syntaxError("unexpected token is here!");
		   break;
		}
	    t->sibling = p;
	}
	return t;
}


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


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


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

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


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