util.cpp

学习编译原理

			case 5:
			case 6:
			case 7:
			case 8:
			case 9:
				fprintf(listing,"line:%d",tree->lineno);
				printTab(2);
				break;
			default:
				fprintf(listing,"line:%d",tree->lineno);
				printTab(1);
		}

    /* 调用函数printSpaces,打印相应的空格,进行缩进 */ 
    printSpaces();	
  
  switch ( tree->nodekind)
  {   case ProK : 
		   fprintf(listing,"%s  ","ProK"); break;
      case PheadK:
		  {fprintf(listing,"%s  ","PheadK");
		   fprintf(listing,"%s  ",tree->name[0]);
		  }
		   break;
	  case DecK:
		{  fprintf(listing,"%s  ","DecK"); 
          if (tree->attr.ProcAttr.paramt==varparamType )
			  fprintf(listing,"%s  ","var param:");
		  if (tree->attr.ProcAttr.paramt==valparamType)
			  fprintf(listing,"%s  ","value param:");
		   switch(tree->kind.dec)
		   { case  ArrayK:
		     { 
			   fprintf(listing,"%s  ","ArrayK");
               fprintf(listing,"%d  ",tree->attr.ArrayAttr.up);
			   fprintf(listing,"%d  ",tree->attr.ArrayAttr.low);
			   if (tree->attr.ArrayAttr.childtype == CharK)
				    fprintf(listing,"%s  ","Chark");
			   else if( tree->attr.ArrayAttr.childtype == IntegerK)
				    fprintf(listing,"%s  ","IntegerK");
			 };break;
		     case  CharK:
			 fprintf(listing,"%s  ","CharK");break;
			 case  IntegerK:
			 fprintf(listing,"%s  ","IntegerK");break;
			 case  RecordK:
			 fprintf(listing,"%s  ","RecordK");break;
			 case  IdK:
			 fprintf(listing,"%s  ","IdK");
			 fprintf(listing,"%s  ",tree->attr.type_name);
			 break;
			 default: 
				 fprintf(listing,"error1!");
				 Error = TRUE;
		   };
         if (tree->idnum !=0)
	       for (int i=0 ; i <= (tree->idnum);i++)
		   {
			   fprintf(listing,"%s  ",tree->name[i]);
				
		   }
		else  
			{
				fprintf(listing,"wrong!no var!\n");
				Error = TRUE;	
			}
		} break;
	  case TypeK:
		   fprintf(listing,"%s  ","TypeK");break;
	  
	  case VarK:
		   fprintf(listing,"%s  ","VarK");
		   if(tree->table[0]!=NULL)
			   fprintf(listing,"%d  %d  ",tree->table[0]->attrIR.More.VarAttr.off,tree->table[0]->attrIR.More.VarAttr.level);
		   break;
	  
	  case ProcDecK: 
			fprintf(listing,"%s  ","ProcDecK");
		    fprintf(listing,"%s  ",tree->name[0]);
			if(tree->table[0]!=NULL)
				fprintf(listing,"%d %d %d  ",tree->table[0]->attrIR.More.ProcAttr.mOff,tree->table[0]->attrIR.More.ProcAttr.nOff,tree->table[0]->attrIR.More.ProcAttr.level);
            break;
	  
	  case StmLK:
		   fprintf(listing,"%s  ","StmLk");break;
	  
	  case StmtK:
		  { fprintf(listing,"%s  ","StmtK");
            switch (tree->kind.stmt)
			{ case IfK:
    		       fprintf(listing,"%s  ","If");break;
			  case WhileK:
		           fprintf(listing,"%s  ","While");break;
			  
			  case AssignK:
		           fprintf(listing,"%s  ","Assign");
				   break;
			  
			  case ReadK:
		           fprintf(listing,"%s  ","Read");
				   fprintf(listing,"%s  " , tree->name[0]);
				   if(tree->table[0]!=NULL)
					   fprintf(listing,"%d   %d  ",tree->table[0]->attrIR.More.VarAttr.off,tree->table[0]->attrIR.More.VarAttr.level);
				   break;
			  
			  case WriteK:
		           fprintf(listing,"%s  ","Write");break;
			  
			  case CallK:
		           fprintf(listing,"%s  ","Call");
				   fprintf(listing,"%s  ", tree->name[0]);
				   break;
			  
			  case ReturnK:
		           fprintf(listing,"%s  ","Return");break;
     
			  default: 
				fprintf(listing,"error2!");
				Error = TRUE;	
			}
          };break;
	  case ExpK: 
		  { fprintf(listing,"%s  ","ExpK");
		    switch (tree->kind.exp)
			{ case OpK:
    		      { fprintf(listing,"%s  ","Op");
			        switch(tree->attr.ExpAttr.op)
					{ case EQ:   fprintf(listing,"%s  " , "="); break;
                      case LT:   fprintf(listing,"%s  " , "<"); break;      
                      case PLUS: fprintf(listing,"%s  " , "+"); break;   
                      case MINUS:fprintf(listing,"%s  " , "-"); break;
					  case TIMES:fprintf(listing,"%s  " , "*"); break;  
                      case OVER: fprintf(listing,"%s  " , "/"); break;  
                      default: 
						  fprintf(listing,"error3!");
						  Error = TRUE;
					}

					if(tree->attr.ExpAttr.varkind==ArrayMembV)
					{
						fprintf(listing,"ArrayMember  ");
						fprintf(listing,"%s  ",tree->name[0]);
					}
                  };break;
			  case ConstK:
				    fprintf(listing,"%s  ","Const");
					switch(tree->attr.ExpAttr.varkind)
					{
						case IdV:
					    fprintf(listing,"Id  ");
						fprintf(listing,"%s  ",tree->name[0]);
						break;
						case FieldMembV:
					    fprintf(listing,"FieldMember  ");
					    fprintf(listing,"%s  ",tree->name[0]);
						break;
						case ArrayMembV:
					    fprintf(listing,"ArrayMember  ");
						fprintf(listing,"%s  ",tree->name[0]);
						break;
						default: 
							fprintf(listing,"var type error!");
							Error = TRUE;
					}
					
					fprintf(listing,"%d  ",tree->attr.ExpAttr.val);
					break;
			  case VariK:
		           fprintf(listing,"%s  ","Vari");
                   switch(tree->attr.ExpAttr.varkind)
				   {
						case IdV:
					    fprintf(listing,"Id  ");
						fprintf(listing,"%s  ",tree->name[0]);
						break;
						case FieldMembV:
					    fprintf(listing,"FieldMember  ");
					    fprintf(listing,"%s  ",tree->name[0]);
						break;
						case ArrayMembV:
					    fprintf(listing,"ArrayMember  ");
						fprintf(listing,"%s  ",tree->name[0]);
						break;
						default: 
							fprintf(listing,"var type error!");
							Error = TRUE;
				   }
				   if(tree->table[0]!=NULL)
					   fprintf(listing,"%d   %d  ",tree->table[0]->attrIR.More.VarAttr.off,tree->table[0]->attrIR.More.VarAttr.level);

				   break;
              default: 
				  fprintf(listing,"error4!");
				  Error = TRUE;
			}
		  };break;
   default: 
	   fprintf(listing,"error5!");
	   Error = TRUE;
   }
   
   fprintf(listing,"\n");
   
    /* 对语法树结点tree的各子结点递归调用printTree过程 *
	 * 缩进写入列表文件listing						   */
    for (i=0;i<MAXCHILDREN;i++)
         printTree(tree->child[i]);

	/* 对语法树结点tree的兄弟节点递归调用printTree过程 *
	 * 缩进写入列表文件listing						   */ 
	tree = tree->sibling;			
  }

  /* 减量缩进宏,每次退出语法树节点时减量缩进 */
  UNINDENT;							
}



/*************下面的函数用于中间代码生成**************************/ 

/********************************************************/
/* 函数名  NewTemp		  								*/
/* 功  能  产生一个新的临时变量的ARG结构				*/
/* 说  明  临时变量的层数为-1，偏移为编号值，访问方式由 */
/*		   参数确定										*/
/********************************************************/
ArgRecord  *NewTemp (AccessKind  access )
{  
   ArgRecord  *newTemp=(ArgRecord *)malloc(sizeof(ArgRecord)) ;
   /*填写临时变量的ARG内容*/
   
   newTemp->form = AddrForm ;
   newTemp->Attr.addr.dataLevel = -1 ;
   newTemp->Attr.addr.dataOff=TempOffset ;
   newTemp->Attr.addr.access= access;
   /*临时变量编号加1*/   
   TempOffset++;
      
   return (newTemp);
}

/********************************************************/
/* 函数名  NewLabel		  								*/
/* 功  能  产生一个新的标号值							*/
/* 说  明  通过全局变量Label加1，产生新的标号值			*/
/********************************************************/
int  NewLabel()
{  Label++;  
   return (Label);
}

/********************************************************/
/* 函数名  ARGAddr		  								*/
/* 功  能  对于给定的变量产生相应的ARG结构				*/
/* 说  明  												*/
/********************************************************/

ArgRecord  *ARGAddr(char  *id ,int level, int off, AccessKind access)
{   
	ArgRecord  *arg = (ArgRecord *)malloc(sizeof(ArgRecord));
	/*填写变量ARG结构的内容*/
    arg->form = AddrForm ;
	strcpy(arg->Attr.addr.name,id);
	arg->Attr.addr.dataLevel=level;
	arg->Attr.addr.dataOff=off;
    arg->Attr.addr.access=access;
		  
    return  (arg);
}
/********************************************************/
/* 函数名  ARGLabel		  								*/
/* 功  能  对于给定的标号产生相应的ARG结构				*/
/* 说  明  												*/
/********************************************************/
ArgRecord *ARGLabel(int  label )
{  ArgRecord  *arg = (ArgRecord *) malloc (sizeof(ArgRecord));
   arg->form = LabelForm ;
   arg->Attr.label = label ;

   return (arg);
}

/********************************************************/
/* 函数名  ARGValue		  								*/
/* 功  能  对于给定的常数值产生相应的ARG结构			*/
/* 说  明  												*/
/********************************************************/
ArgRecord  *ARGValue(int value)
{ ArgRecord  *arg = (ArgRecord *) malloc (sizeof(ArgRecord));
  arg->form = ValueForm ;
  arg->Attr.value = value ;

  return (arg);
}


/********************************************************/
/* 函数名  GenCode 		  								*/
/* 功  能  根据给定参数，构造一条中间代码				*/
/* 说  明												*/
/********************************************************/

CodeFile *GenCode (CodeKind codekind , ArgRecord *Arg1 ,ArgRecord *Arg2 ,ArgRecord *Arg3 )
{ 
    CodeFile  *newCode = (CodeFile  *) malloc (sizeof (CodeFile ));
    /*填写代码的内容*/	
	newCode->codeR.codekind = codekind ;
	newCode->codeR.arg1 = Arg1;  
	newCode->codeR.arg2 = Arg2;
	newCode->codeR.arg3 = Arg3;
	newCode->former = NULL;
	newCode->next = NULL;
    /*链入中间代码表中*/
	if  (firstCode==NULL)
		 firstCode = newCode ;
	else
	{	   lastCode->next=newCode;
		   newCode->former = lastCode;
	}
	lastCode = newCode ;

	return(newCode);
}
/********************************************************/
/* 函数名  PrintCodeName  								*/
/* 功  能  打印代码的类别								*/
/* 说  明  由函数PrintOneCode调用						*/
/********************************************************/
void  PrintCodeName(CodeKind kind)
{
  switch(kind)
  {	case	ADD:		fprintf(listing ,"ADD");     break;
    case    SUB:		fprintf(listing ,"SUB");	 break;
	case	MULT:       fprintf(listing ,"MULT");    break;
	case	DIV:		fprintf(listing ,"DIV");     break;
	case	EQC:		fprintf(listing ,"EQ");      break;
	case	LTC:		fprintf(listing ,"LT");      break;
	case	READC:		fprintf(listing ,"READ");    break;
	case	WRITEC:		fprintf(listing ,"WRITE");	 break;
	case	RETURNC:	fprintf(listing ,"RETURN");  break;
	case	ASSIG:		fprintf(listing ,"ASSIG");   break;
	case    AADD:		fprintf(listing ,"AADD");    break;
	case    LABEL:		fprintf(listing ,"LABEL");   break;
	case    JUMP0:		fprintf(listing ,"JUMP0");   break;
	case    JUMP:		fprintf(listing ,"JUMP");    break;
	case    CALL:		fprintf(listing ,"CALL");    break;
	case    VARACT:		fprintf(listing ,"VARACT");  break;
	case    VALACT:		fprintf(listing ,"VALACT");  break;
	case    PENTRY:		fprintf(listing ,"PENTRY");  break;
	case    ENDPROC:	fprintf(listing ,"ENDPROC"); break;
	case    MENTRY:		fprintf(listing ,"MENTRY");  break;
	case    WHILESTART: fprintf(listing ,"WHILESTART");break;
	case    ENDWHILE:   fprintf(listing ,"ENDWHILE");  break;
	default:  break;
  }
}

/********************************************************/
/* 函数名  PrintCotent  								*/
/* 功  能  打印ARG结构的内容							*/
/* 说  明  由函数PrintOneCode调用						*/
/********************************************************/
void PrintContent(ArgRecord  *arg)
{
	switch(arg->form)
	{case  LabelForm : fprintf(listing ,"%d",arg->Attr.label); break;
	 case  ValueForm : fprintf(listing ,"%d",arg->Attr.value); break;
	 case  AddrForm: 
		 //d:fprintf(listing ,"(");
		 if (arg->Attr.addr.dataLevel!=-1)
		      fprintf(listing ,arg->Attr.addr.name);
		 else 
		 { fprintf(listing ,"temp");
		        fprintf(listing ,"%d",arg->Attr.addr.dataOff);
		 }
		 /*
		 fprintf(listing ," , ");
		 fprintf(listing ,"%d",arg->Attr.addr.dataLevel);
		 fprintf(listing ," , ");
		 fprintf(listing ,"%d",arg->Attr.addr.dataOff);
		 fprintf(listing ," , ");
		 switch( arg->Attr.addr.access)
		 { case dir :  fprintf(listing ,"dir");   break;
		   case indir: fprintf(listing ,"indir"); break;
		   default  : break;
		  }
		 fprintf(listing ,")");
	     */
		 break;
	 default:  break;
	}
}

/********************************************************/
/* 函数名  PrintOneCode 								*/
/* 功  能  打印一条中间代码								*/
/* 说  明  由函数PrintMidCode调用						*/
/********************************************************/
void PrintOneCode(CodeFile  *code)
{ 
    PrintCodeName(code->codeR.codekind);
	fprintf(listing ,"    ");
	if (code->codeR.arg1!=NULL)
		PrintContent(code->codeR.arg1);
	else  fprintf(listing, "  ");
	fprintf(listing ,"    ");
	if (code->codeR.arg2!=NULL)
		PrintContent(code->codeR.arg2);
	else  fprintf(listing ,"  ");
	fprintf(listing ,"    ");
	if (code->codeR.arg3!=NULL)
		PrintContent(code->codeR.arg3);
	else  fprintf(listing, "  ");
}

/********************************************************/
/* 函数名  PrintMidCode 								*/
/* 功  能  打印中间代码序列								*/
/* 说  明												*/
/********************************************************/
void  PrintMidCode(CodeFile  *firstCode)
{   int i = 0;
	CodeFile  *code = firstCode ;
	while (code!=NULL)
	{ fprintf(listing ,"           ");
    	fprintf(listing ,"%d%s",  i, ":  ");
	  PrintOneCode(code);
	  fprintf(listing,"\n");
	  code = code ->next;
	  i++;
	}
}


/*************下面的函数用于中间代码优化**************************/ 

/********************************************************/
/* 函数名  DivBaseBlock									*/
/* 功  能  为中间代码划分基本块							*/
/* 说  明  基本块从0开始编号，若有变参传递，则相应过程  */
/*	       调用做为当前基本块的结束						*/
/********************************************************/
int  DivBaseBlock()
{   
	/*初始化基本块数目*/
	int blocknum = 0;
	
	CodeFile  *code = firstCode ;
    /*初始化基本块指针*/
	for (int i=0;i<100;i++)
		baseBlock[i]=NULL;

    baseBlock[blocknum++] =code;
	if (code->next != NULL)
	   code = code->next;

	while (code != NULL)
	{
	   switch(code->codeR.codekind)
	   {/*声明类的代码*/ 
	    case LABEL:
		case WHILESTART:
        case PENTRY:
		case MENTRY:
			 /*进入一个新的基本块*/
			 baseBlock[blocknum++] =code;  
			 break;
        /*跳转类的代码*/
		case JUMP:
		case JUMP0:
		case RETURNC:
		case ENDPROC:
		case ENDWHILE: