util.cpp

学习编译原理

			/*从下一条语句开始，进入一个新的基本块*/
			 if (code->next!= NULL)
			 { code = code->next;
			   baseBlock[blocknum++] =code;
			 }
			 break;
		/*变参传递*/
		case VARACT: 
			 /*找到对应的过程调用语句，作为本基本块的结束*/
			 code = code->next;
			 while (code->codeR.codekind != CALL)
				 code = code->next;
			 /*从下一条语句开始，进入一个新的基本块*/
			 if (code->next!= NULL)
			 { code = code->next;
			   baseBlock[blocknum++] =code;
			 }
			 
        default : break;
	   }
       code = code->next;
	}
	return(blocknum);
}
 
/********************************************************/
/* 函数名  PrintBaseBlock								*/
/* 功  能  打印基本块第一条代码,以显示基本块的划分		*/
/* 说  明												*/
/********************************************************/  
void PrintBaseBlock(int  blocknum)
{
	for (int i=0;i<blocknum ;i++)
	{ PrintOneCode(baseBlock[i]);
      fprintf(listing,"\n");
	}
}


/**************用于公共表达式优化*****************/
/********************************************************/
/* 函数名  printValuNum									*/
/* 功  能  输出值编码表									*/
/* 说  明												*/
/********************************************************/  
void   printValuNum()
{ 
	fprintf(listing,"\n************Value  Num **************\n");

	ValuNum  *Item = valuNumT;
	while (Item!=NULL)
	{   
		PrintContent(Item->arg);
		fprintf(listing,"  ");
		if (Item->access == indir )
		{   fprintf(listing ,"(");
			fprintf(listing,"%d",Item->codeInfo.twoCode.valuecode);
			fprintf(listing," , ");
			fprintf(listing,"%d",Item->codeInfo.twoCode.addrcode);
		    fprintf(listing,")");
		}
       else  fprintf(listing,"%d",Item->codeInfo.valueCode);
       
	   fprintf(listing,"\n");
	   Item = Item->next;
	}
}

/********************************************************/
/* 函数名  printUsableExpr								*/
/* 功  能  输出可用表达式编码表							*/
/* 说  明												*/
/********************************************************/  
void   printUsbleExpr()
{
	fprintf(listing,"\n************Usable  Expression**************\n");
	UsableExpr  *Item = usableExprT;
	while (Item!=NULL)
	{ PrintOneCode(Item->code);
	  fprintf(listing, "  :  ");
	  fprintf(listing,"(");
	  fprintf(listing,"%d  ",Item->mirrorC->op1);
	  fprintf(listing,"%d  ",Item->mirrorC->op2);
	  fprintf(listing,"%d  ",Item->mirrorC->result);
	  fprintf(listing,")");
	  
	  fprintf(listing,"\n");
	  Item = Item->next;
	}

}


/********************************************************/
/* 函数名  printTempEqua								*/
/* 功  能  输出临时变量等价表							*/
/* 说  明												*/
/********************************************************/  
void   printTempEqua()
{

	fprintf(listing,"\n************Temp  Equa **************\n");

	TempEqua  * Item = tempEquaT;
	while (Item!=NULL)
	{ PrintContent(Item->arg1);
		fprintf(listing,"   ");
		PrintContent(Item->arg2);

		fprintf(listing,"\n");
		Item = Item->next;
  }
}

/*循环信息栈的压栈实现过程*/
void  PushLoop(LoopInfo  *t)
{
	LoopStack *p = (LoopStack *)malloc (sizeof(LoopStack));
	p->loopInfo = t ;
	p->under=loopTop;
    loopTop = p;
	loopStackEmpty = false;
}

/*循环信息栈的弹栈实现过程*/
LoopInfo *PopLoop()
{     
  LoopStack  *p=NULL;
  LoopInfo   *backpointer = NULL;
  p =loopTop;
  backpointer=p->loopInfo;
  loopTop=loopTop->under;
  free(p);
  if (loopTop==NULL)
	  loopStackEmpty = true;

  return backpointer;
}
 


/***********************************************************/
/***********以下为目标代码生成时所用的函数******************/
/***********************************************************/


/***********************************************************/
/* 函数名  FindSp                                          */
/* 功  能  找到该变量所在AR的sp                            */
/* 说  明												   */
/***********************************************************/
void findSp(int varlevel)
{
	/*先求该变量层数在AR中的位置，其中varLevel表示变量所在层*/
	emitRM("LDA",ac1,varlevel,displayOff," var process");
	
	/*绝对地址*/
	emitRO("ADD",ac1,ac1,sp," var sp relative address");
    
	/*该变量所在AR的sp地址存在ac1中*/
	emitRM("LD",ac1,0,ac1," var sp");
}

/***********************************************************/
/* 函数名  FindAdd                                         */
/* 功  能  计算基本类型变量、下标变量和域变量的绝对地址    */
/* 说  明  将绝对地址存入ac中		    				   */
/***********************************************************/
void FindAdd(TreeNode * t)
{
	
	int Loc;
	int varLevel;

	fieldChain * fieldMem = NULL;

	if(t!=NULL)
	{
		
		/*得到该变量在符号表中的地址*/
		Loc = t->table[0]->attrIR.More.VarAttr.off;
					
		/*记录该变量所在层*/
		varLevel = t->table[0]->attrIR.More.VarAttr.level;
				
		/*可能是下标类型或者域类型或者是基本变量类型,把地址取出送入ac*/
						
		/*普通变量*/
		if(t->child[0] == NULL)
		{
			emitRM("LDC",ac,Loc,0," base type var relative address");
		}
		/*数组类型变量*/
		else if(t->attr.ExpAttr.varkind==ArrayMembV)
		{
			/*将数组下标值送入ac中*/
			cGen(t->child[0]);
	
			/*数组下届存入ac1中*//*attr.ArrayAttr.low*/
			emitRM("LDC",ac1,t->table[0]->attrIR.idtype->More.ArrayAttr.low,0,"array low bound");
	
			/*要用ac减去数组下届*/
			emitRO("SUB",ac,ac,ac1,"");
				
			/*求出该数组变量的偏移*/
			emitRM("LDA",ac,Loc,ac," array type var relative address");

		}
		/*记录类型变量*/
		else if(t->attr.ExpAttr.varkind==FieldMembV)
		{
			/*处理域变量的偏移*/
			fieldMem = t->table[0]->attrIR.idtype->More.body;
				
			/*在域表中查找该域变量*/
			while(fieldMem != NULL)
			{
				int result = strcmp(t->child[0]->name[0],fieldMem->id);
				/*如果相等*/
				if(result==FALSE)
					break;
				else
				fieldMem = fieldMem->Next;
			}	 
			/*域变量为基本类型变量*/
			if(t->child[0]->child[0]==NULL)
			{
				emitRM("LDC",ac,Loc,0,"");
				emitRM("LDA",ac,fieldMem->off,ac,"field type var relative address");
				/*此时ac中存放的是相对偏移*/
			}
								
			/*域变量是数组变量的情况*/
			else
			{
				genExp(t->child[0]->child[0]);
				emitRM("LDC",ac1,t->child[0]->attr.ArrayAttr.low,0,"array low");
				/*数组下标减去下届*/
				emitRO("SUB",ac,ac,ac1,"");
				emitRM("LDA",ac,fieldMem->off,ac,"");
									
				emitRM("LDA",ac,Loc,ac,"");
								
			}/*ac中存储的是域变量的在当前AR的偏移*/
		}
			
		/*计算该变量的sp*/
		findSp(varLevel);
		/******找到sp*****************/
		  
		/* 计算绝对偏移 */
		emitRO("ADD",ac,ac,ac1," var absolute off");

	}
}



/**************************************************/
/****************释放指针空间部分******************/
/**************************************************/

void freeDec(TreeNode * p);

void freeStm(TreeNode * p);

void freeExp(TreeNode * t);
/***********************************************************/
/* 函数名  freeTree                                        */
/* 功  能  通过递归调用释放指针空间                        */
/* 说  明                    		    				   */
/***********************************************************/
void freeTree(TreeNode * t)
{
	TreeNode * p = NULL;

	if(t!=NULL)
		free(t->child[0]);
	
	p = t->child[1];
	
	freeDec(p);
				
	p = t->child[2]->child[0];
	
	freeStm(p);

}
/***********************************************************/
/* 函数名  freeDec                                         */
/* 功  能  通过递归调用释放声明类型指针空间                */
/* 说  明                    		    				   */
/***********************************************************/
void freeDec(TreeNode * p)
{
	TreeNode * p1 = NULL;
	TreeNode * p2 = NULL;
	
	while(p!=NULL)
	{	
		switch(p->nodekind)
		{
			case TypeK:
			case VarK:
				/*p1指向类型声明节点链或者变量声明节点链*/
				p1 = p->child[0];
				while(p1!=NULL)
				{
					p2 = p1->sibling;
					free(p1);
					p1 = p2;
				}
				break;
			case ProcDecK:
				/*p1指向函数声明节点的第一个儿子节点－－形参节点*/
				p1 = p->child[0];
				while(p1!=NULL)
				{
					p2 = p1->sibling;
					free(p1);
					p1 = p2;
				}
				/*p1指向函数声明节点的第二个儿子结点－－声明节点*/
				p1 = p->child[1];
				freeDec(p1);
				/*p1指向函数声明节点的三个儿子节点－－函数体节点*/
				p1 = p->child[2];
				freeStm(p1);
				break;
		}
		p1 = p->sibling;
		free(p);
		p = p1;
	}
}

/***********************************************************/
/* 函数名  freeStm                                         */
/* 功  能  通过递归调用释放语句类型指针空间                */
/* 说  明                    		    				   */
/***********************************************************/
void freeStm(TreeNode * p)
{
	TreeNode * t = p;
	TreeNode * p1 = NULL;
	TreeNode * p2 = NULL;
	while(t!=NULL)
	{
		switch(t->kind.stmt)
		{
			case IfK:
				/*删除条件表达式节点*/
				freeExp(t->child[0]);
				/*删除then语句序列部分*/
				freeStm(t->child[1]);
				/*删除else语句序列部分*/
				freeStm(t->child[2]);
				break;
			case WhileK:
				/*删除条件表达式节点*/
				freeExp(t->child[0]);
				/*删除while语句序列部分*/
				freeStm(t->child[1]);
				break;
			case AssignK:
				/*删除赋值号左侧*/
				p1 = t->child[0];
				freeExp(p1);
				/*删除赋值号右侧*/
				p1 = t->child[1];
				freeExp(p1);
				break;
			case ReadK:
				break;
			case WriteK:
				/*删除儿子节点*/
				freeExp(t->child[0]);
				break;
			case CallK:
				/*删除左儿子(调用函数名)*/
				freeExp(t->child[0]);
				/*删除右儿子节点(实参链)*/
				p1 = t->child[1];
				while(p1 !=NULL)
				{
					p2 = p1->sibling;
					freeExp(p1);
					p1 = p2;
				}
				break;

			case ReturnK:
				break;
		}
		p1 = t->sibling;
		free(t);
		t = p1;
	}
}

/***********************************************************/
/* 函数名  freeExp                                         */
/* 功  能  通过递归调用释放表达式类型指针空间              */
/* 说  明                    		    				   */
/***********************************************************/
void freeExp(TreeNode * t)
{
	TreeNode * p1 = NULL;
	TreeNode * p2 = NULL;

	switch(t->kind.exp)
	{
	case OpK:
		/*删除左操作数*/
		freeExp(t->child[0]);
		/*删除右操作数*/
		freeExp(t->child[1]);
		break;
	case ConstK:
		/*直接删除该节点*/
		free(t);
		break;
	case VariK:
		p1 = t;
		while (p1!=NULL)
		{
			p2 = p1->child[0];
			free(p1);
			p1 = p2;
		}
		break;
	}
}

/***********************************************************/
/* 函数名  freeTable                                       */
/* 功  能  通过递归调用释放符号表空间                      */
/* 说  明                    		    				   */
/***********************************************************/
void freeTable(void)
{
	 SymbTable * p1=NULL;
	 SymbTable * p2=NULL;
	 int i = 0;

	 while(scope[i]!=NULL)
	 {
		 p1 = scope[i];
		 while(p1!=NULL)
		 {
			 p2 = p1->next;
			 free(p1);
			 p1 = p2;
		 }
		 i++;
	 }
}


/***********************************************************/
/* 函数名  freeMidCode                                     */
/* 功  能  释放中间代码空间			                       */
/* 说  明                    		    				   */
/***********************************************************/
void freeMidCode(void)
{
	 CodeFile  *code = firstCode;
     CodeFile  *code1 = NULL;
	 while(code!=NULL)
	 {
        code1 = code;
		code = code->next;
		free(code1);
	 }		 
}