parseb.txt

SNL语言的编译器

/*************************声明部分***********************************/

/********************************************************************/
/* 函数名 declarePart											    */
/* 功  能 声明部分的处理函数								     	*/
/* 产生式 < declarePart > ::= typeDec  varDec  procDec              */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
Cglobal::TreeNode *  Cparse::declarePart(void)
{
     /*类型*/
	 TreeNode * typeP = newDecANode(TypeK);  
	 TreeNode * pp = typeP;  
	 
	 if(typeP!=NULL)
	 {
		 typeP->lineno = 0;
		 TreeNode * tp1 = typeDec();
	     if(tp1!=NULL)
		     typeP->child[0] = tp1;
		 else
		 {
			 free(typeP);
		     typeP=NULL;
		 }
	 }
	 /*变量*/
	 TreeNode * varP = newDecANode(VarK);
	 
	 if(varP != NULL)
	 {
		 varP->lineno = 0;
		 TreeNode * tp2 = varDec();
		 if(tp2 != NULL)
	          varP->child[0] = tp2;
		 else 
		 {
			 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                      */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
Cglobal::TreeNode *  Cparse::typeDec(void)
{
	TreeNode * t = NULL;
	switch (token.Lex)
	{ 
	  case TYPE: t = typeDeclaration(); break;
	  case VAR:
	  case PROCEDURE:
      case BEGIN: break;
      default :
		  ReadNextToken(&token);
		  syntaxError("unexpected token is here!");
		  break;
	}
	return t;
}
		  
	 
/********************************************************************/
/* 函数名 TypeDeclaration									  	    */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < TypeDeclaration > ::= TYPE  TypeDecList                 */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
Cglobal::TreeNode *  Cparse::typeDeclaration(void)
{
	match(TYPE);
	TreeNode * t = typeDecList();
	if (t==NULL)
	{
        syntaxError("a type declaration is expected!");
	}
	return t;
}


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


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


/********************************************************************/
/* 函数名 baseType		 							  	            */
/* 功  能 类型声明部分的处理函数						        	*/
/* 产生式 < baseType > ::=  INTEGER | CHAR                          */
/* 说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点  */
/********************************************************************/
 void  Cparse::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  Cparse::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  Cparse::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  Cparse::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     */ 
/*说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点   */
/********************************************************************/
Cglobal::TreeNode *  Cparse::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                   */ 
/*说  明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点   */
/********************************************************************/
 Cglobal::TreeNode *  Cparse::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  Cparse::idList(TreeNode * t)
{
	if (token.Lex==ID)
	{
		strcpy(t->name[(t->idnum)] ,token.Sem);