target.java

这是编译原理的目标代码生成器java代码

ArgRecord varTable[] = new ArgRecord[100];
int TotalNum = 0;

/*循环信息栈*/
LoopStack loopTop=null;
boolean loopStackEmpty;

boolean Error=false;
boolean Error1=false;
String yerror;
String serror;
CodeFile mid;

public Opt(String s)
{
    AnalYuyi a=new AnalYuyi(s);
    StoreNoff=a.StoreNoff;
    if (a.Error1)
    {
        Error1=true;
        serror=a.serror;
    }
    else if (a.Error)
    {
        Error=true;
        yerror=a.yerror;
    }
    else
    {
        mid=GenMidCode(a.yuyiTree);
        ConstOptimize();
        ECCsave();
        LoopOpti();
    }
}
 
/********************************************************/
/* 函数名  GenMidCode 	  				*/
/* 功  能  中间代码生成主函数				*/
/* 说  明  若有过程声明，调用过程声明的代码声明函数；   */
/*         调用程序体的代码生成函数			*/
/********************************************************/
CodeFile GenMidCode(TreeNode t)
{  
    /*若有过程声明，调用相应函数，产生过程声明的中间代码*/
    TreeNode t1=t.child[1];
    while (t1!=null)
    { 
        if (t1.nodekind.equals("ProcDecK"))
            GenProcDec(t1);
        t1=t1.sibling; 
    }
  
    /*display表相对于sp的偏移*/
    ArgRecord Noff = ARGValue(StoreNoff);

    /*生成主程序入口声明代码*/
    CodeFile code = GenCode("MENTRY",null,null,Noff);

    /*初始化临时变量的开始编号,为临时变量区的第一个地址*/
    TempOffset = StoreNoff + 1;

    /*调用语句序列的代码生成函数*/
    GenBody(t.child[2]);

    /*回填主程序的AR的大小到主程序入口中间代码*/
    int size = TempOffset;
    ArgRecord sizeArg = ARGValue(size);
    code.codeR.arg2= sizeArg;

    return firstCode;
}
/****************************************************/
/* 函数名  GenProcDec				    */
/* 功  能  过程声明中间代码生成函数		    */
/* 说  明  生成过程入口中间代码，生成过程体的中间   */
/*	   代码，生成过程出口的中间代码		    */	
/****************************************************/
void GenProcDec(TreeNode t)
{  
    /*得到过程的入口标号*/
    int ProcEntry = NewLabel();
  
    /*过程名在符号表中的地址*/
    SymbTable Entry = t.table[0];
    /*过程入口标号，回填入节点中*/
    Entry.attrIR.proc.codeEntry = ProcEntry;

    /*过程的display表的偏移量*/
    int noff = Entry.attrIR.proc.nOff;
 
    /*得到过程的层数及其ARG结构*/
    int procLevel = Entry.attrIR.proc.level;
    ArgRecord levelArg = ARGValue(procLevel);
  
    /*若过程内部仍有过程声明，调用相应函数，产生过程声明的中间代码*/
    TreeNode t1=t.child[1];
    while (t1!=null)
    { 
        if (t1.nodekind.equals("ProcDecK"))
            GenProcDec(t1);
        t1=t1.sibling; 
    }

    /*产生过程入口中间代码*/ 
    ArgRecord arg1 = ARGLabel(ProcEntry);
    CodeFile code = GenCode("PENTRY",arg1,null,levelArg);
  
    /*初始化临时变量的开始编号,为过程临时变量区的第一个地址*/
    TempOffset =  noff + procLevel+1;

    /*调用语句序列的代码生成函数处理过程体*/
    GenBody(t.child[2]);

    /*得到过程的AR的大小,回填入过程入口中间代码*/
    int size = TempOffset;
    ArgRecord sizeArg = ARGValue(size);
    code.codeR.arg2 = sizeArg;

    /*产生过程出口中间代码*/
    GenCode("ENDPROC",null,null,null);
}
/****************************************************/
/* 函数名  GenBody				    */
/* 功  能  语句序列中间代码生成函数		    */
/* 说  明  用于处理过程体或者程序体，		    */
/*	   循环处理各个语句			    */	
/****************************************************/
void GenBody(TreeNode t)
{  
    TreeNode t1 = t;
    /*令指针指向第一条语句*/
    if (t1.nodekind.equals("StmLK"))
	t1=t1.child[0];

   while (t1!=null)
   { 
       /*调用语句处理函数*/
       GenStatement(t1);
       t1= t1.sibling;
   }
}
/****************************************************/
/* 函数名  GenStatement				    */
/* 功  能  语句处理函数	        		    */
/* 说  明  根据语句的具体类型，分别调用相应的	    */
/*	   语句处理函数				    */
/****************************************************/
void GenStatement(TreeNode t) 
{  
    if (t.kind.equals("AssignK"))
	GenAssignS(t);  
    else if (t.kind.equals("CallK"))
	GenCallS(t);   
    else if (t.kind.equals("ReadK"))     
        GenReadS(t);   
    else if (t.kind.equals("WriteK"))     
        GenWriteS(t);	
    else if (t.kind.equals("IfK"))       
        GenIfS (t);	   
    else if (t.kind.equals("WhileK"))  	
        GenWhileS(t);		
    else if (t.kind.equals("ReturnK"))    /*直接生成中间代码*/  	
        GenCode("RETURNC",null,null,null);
}
/****************************************************/
/* 函数名  GenAssignS				    */
/* 功  能  赋值语句处理函数        	            */
/* 说  明  处理左部变量，处理右部表达式，生成       */
/*         赋值语句中间代码 			    */
/****************************************************/
void GenAssignS(TreeNode t)
{   
    /*调用赋值左部变量的处理函数*/
    ArgRecord Larg = GenVar(t.child[0]);
    /*调用赋值右部表达式的处理函数*/
    ArgRecord Rarg = GenExpr(t.child[1]);
    /*生成赋值语句中间代码*/
    GenCode("ASSIG",Rarg,Larg,null);
}
/****************************************************/
/* 函数名  GenVar				    */
/* 功  能  变量处理函数        		            */
/* 说  明					    */
/****************************************************/
ArgRecord GenVar(TreeNode t)
{ 
    int low,size;
    FieldChain head;

    /*生成变量名的ARG结构, Entry为标识符在符号表中的地址*/
    SymbTable Entry = t.table[0];
    ArgRecord V1arg = ARGAddr(t.name[0],Entry.attrIR.var.level,
Entry.attrIR.var.off,Entry.attrIR.var.access);
    
    /*返回的ARG结构*/
    ArgRecord Varg=null;
    if (t.attr.expAttr.varkind.equals("IdV"))
        /*标识符变量情形*/
 	Varg = V1arg; 
    else if (t.attr.expAttr.varkind.equals("ArrayMembV"))
    {    
	/*数组成员变量情形*/
	/*构造数组下届和数组大小的ARG结构*/
	low = Entry.attrIR.idtype.array.low;
	size = Entry.attrIR.idtype.array.elementTy.size;
        Varg = GenArray(V1arg,t,low,size);
    }
    else if (t.attr.expAttr.varkind.equals("FieldMembV"))
    {
        /*域变量情形*/    
	head = Entry.attrIR.idtype.body;
	Varg = GenField(V1arg,t,head);
    }
    return Varg;
}
/****************************************************/
/* 函数名  GenArray				    */
/* 功  能  数组成员变量处理函数    		    */
/* 说  明  由函数GenVar或函数GenField调用	    */
/****************************************************/      	  
ArgRecord GenArray(ArgRecord V1arg,TreeNode t,int low,int size)  		  
{   
    /*处理下标表达式*/
    ArgRecord Earg= GenExpr(t.child[0]);

    ArgRecord lowArg = ARGValue(low);
    ArgRecord sizeArg= ARGValue(size);
    /*产生三个临时变量*/
    ArgRecord temp1= NewTemp("dir");
    ArgRecord temp2= NewTemp("dir");
    /*注：表示复杂变量的临时变量属于间接访问*/
    ArgRecord temp3= NewTemp("indir"); 
	      
    /*生成中间代码*/
    GenCode("SUB", Earg, lowArg ,temp1);
    GenCode("MULT",temp1,sizeArg,temp2);
    GenCode("AADD",V1arg,temp2, temp3);

    return temp3;
}		  		  		  
/****************************************************/
/* 函数名  GenField				    */
/* 功  能  域变量处理函数    			    */
/* 说  明  由函数GenVar调用			    */
/****************************************************/		  
ArgRecord GenField(ArgRecord V1arg,TreeNode t,FieldChain head)		  
{   
    ArgRecord FieldV;
    /*t1指向当前域成员*/
    TreeNode t1 = t.child[0];
    FieldChain Entry2=new FieldChain();

    FindField(t1.name[0],head,Entry2);
    /*域名在域表中的偏移*/
    int off = Entry2.off;
    ArgRecord offArg = ARGValue(off);
    /*注：表示复杂变量的临时变量属于间接访问*/
    ArgRecord temp1 = NewTemp("indir");
    GenCode("AADD",V1arg,offArg,temp1);
    /*域是数组变量*/
    if (t1.attr.expAttr.varkind.equals("ArrayMembV"))
    {  
        int low = Entry2.unitType.array.low;
 	int size= Entry2.unitType.array.elementTy.size;
	FieldV = GenArray(temp1,t1,low,size);
    }
    else  /*域是标识符变量*/
   	FieldV = temp1;

    return FieldV;
}
/****************************************************/
/* 函数名  GenExpr				    */
/* 功  能  表达式处理函数        		    */
/* 说  明					    */
/****************************************************/
ArgRecord GenExpr(TreeNode t)
{ 
    ArgRecord arg=null;
    ArgRecord Larg;
    ArgRecord Rarg;
    ArgRecord temp;

    if (t.kind.equals("VariK"))
        arg = GenVar(t);
    else if (t.kind.equals("ConstK"))
	/*得到值的ARG结构*/
	arg = ARGValue(t.attr.expAttr.val);
    else if (t.kind.equals("OpK"))
    {
	/*处理左部和右部*/
	Larg = GenExpr(t.child[0]);
	Rarg = GenExpr(t.child[1]);

	/*根据操作符类别，得到中间代码的类别*/
	String op=null;
	if (t.attr.expAttr.op.equals("LT"))
	    op = "LTC"; 
	else if (t.attr.expAttr.op.equals("EQ"))	
            op = "EQC"; 
	else if (t.attr.expAttr.op.equals("PLUS"))		
            op = "ADD";
	else if (t.attr.expAttr.op.equals("MINUS"))   
            op = "SUB"; 
	else if (t.attr.expAttr.op.equals("TIMES"))    
            op = "MULT"; 
	else if (t.attr.expAttr.op.equals("OVER"))    
            op = "DIV"; 
	/*产生一个新的临时变量*/	
        temp = NewTemp("dir");
	/*生成中间代码*/
	GenCode(op,Larg,Rarg,temp);
	arg = temp ;
    }
    return arg;
}
/****************************************************/
/* 函数名  GenCall				    */
/* 功  能  过程调用处理函数        		    */
/* 说  明  分别调用表达式处理函数处理各个实参，并   */
/*	   生成相应的形实参结合中间代码；从符号表中 */
/*	   过程标识符属性中，查到入口标号，产生过程 */
/*	   调用中间代码				    */
/****************************************************/
void GenCallS(TreeNode t)
{
    /*取得过程标志符在符号表中的地址*/
    SymbTable Entry = t.child[0].table[0];
    ParamTable param = Entry.attrIR.proc.param;
    /*调用表达式处理函数处理各个实参，
      并生成相应的形实参结合中间代码*/
    TreeNode t1 = t.child[1];
    ArgRecord Earg;
    while (t1!=null)
    { 
        Earg = GenExpr(t1);

        /*记录参数的偏移*/
        int paramOff = param.entry.attrIR.var.off;
	ArgRecord OffArg = ARGValue(paramOff);
        /*形实参结合中间代码*/
	if (param.entry.attrIR.var.access.equals("dir")) 
	    /*值参结合中间代码*/
            GenCode("VALACT",Earg,OffArg,null);
	else  /*变参结合中间代码*/
	    GenCode("VARACT",Earg,OffArg,null);
	
	t1 = t1.sibling;
        param = param.next;
    } 
    /*过程入口标号及其ARG结构*/
    int label = Entry.attrIR.proc.codeEntry;
    ArgRecord labelarg = ARGLabel(label);
   
    /*过程的display表的偏移量*/
    int Noff = Entry.attrIR.proc.nOff;
    ArgRecord Noffarg = ARGValue(Noff);

    /*生成过程调用中间代码*/
    GenCode ("CALL",labelarg,null,Noffarg);
}
/****************************************************/
/* 函数名  GenReadS				    */
/* 功  能  读语句处理函数        		    */
/* 说  明  得到读入变量的ARG结构，生成读语句中间代码*/
/****************************************************/
void GenReadS(TreeNode t)
{ 
    SymbTable Entry = t.table[0];
    ArgRecord Varg = ARGAddr(t.name[0],Entry.attrIR.var.level,
Entry.attrIR.var.off,Entry.attrIR.var.access);
    /*生成读语句中间代码*/
    GenCode("READC",Varg,null,null);
}
/****************************************************/
/* 函数名  GenWrite				    */
/* 功  能  写语句处理函数        		    */
/* 说  明  调用表达式的中间代码生成函数，并产生写   */
/*	   语句的中间代码			    */
/****************************************************/
void GenWriteS(TreeNode t)
{   
    /*调用表达式的处理*/
    ArgRecord Earg = GenExpr(t.child[0]);
    /*生成写语句中间代码*/
    GenCode("WRITEC",Earg,null,null);
}
/****************************************************/
/* 函数名  GenIfs				    */
/* 功  能  条件语句处理函数        	            */
/* 说  明					    */
/****************************************************/
void GenIfS(TreeNode t)