const.java

一个java编译器

             else if (arg.form.equals("ValueForm")) 
                 midcode=midcode+String.valueOf(arg.midAttr.value);
             else if (arg.form.equals("AddrForm")) 
	     {   
		 if (arg.midAttr.addr.dataLevel!=-1)
		     midcode=midcode+arg.midAttr.addr.name;
		 else  
		     midcode=midcode+"temp"+String.valueOf(arg.midAttr.addr.dataOff);
	     }
}
/********************************************************/
/* 函数名  PrintOneCode 				*/
/* 功  能  打印一条中间代码				*/
/* 说  明  由函数PrintMidCode调用			*/
/********************************************************/
void PrintOneCode(CodeFile code)
{ 
             PrintCodeName(code.codeR.codekind);
             midcode=midcode+"    ";
             if (code.codeR.arg1!=null)
	         PrintContent(code.codeR.arg1);
             else  
                 midcode=midcode+"    ";
             midcode=midcode+"    ";
             if (code.codeR.arg2!=null)
	         PrintContent(code.codeR.arg2);
             else  
                 midcode=midcode+"    ";
             midcode=midcode+"    ";
             if (code.codeR.arg3!=null)
	         PrintContent(code.codeR.arg3);
             else                   
                 midcode=midcode+"    ";  
}
/********************************************************/
/* 函数名  PrintMidCode 				*/
/* 功  能  打印中间代码序列				*/
/* 说  明						*/
/********************************************************/
void PrintMidCode(CodeFile firstCode)
{   
    int i = 0;
    CodeFile code = firstCode;
    midcode="\n";
    while (code!=null)
    { 
         midcode=midcode+String.valueOf(i)+":  ";
         PrintOneCode(code);
	 midcode=midcode+"\n";
	 code = code.next;
	 i++;
    }
}

/****************************************************/
/* 函数名  ConstOptimize			    */
/* 功  能  常表达式优化主函数      		    */
/* 说  明  循环对各个基本块进行常表达式优化	    */
/****************************************************/
CodeFile ConstOptimize()
{    
    /*调用划分基本块函数*/
    blocknum = DivBaseBlock();

    /*循环对每个基本块进行常表达式优化*/
    for (int i=0;i<blocknum;i++)
    {  
        /*基本块入口处置常量定值表为空*/
	table = null;
	/*基本块的常表达式优化*/
        OptiBlock(i);
    }
    /*返回优化后的中间代码*/
    return firstCode;
}
/****************************************************/
/* 函数名  OptiBlock				    */
/* 功  能  对一个基本块进行常表达式优化		    */
/* 说  明					    */
/****************************************************/
void OptiBlock(int i)
{   
    boolean delCode;
    /*指向基本块第一条语句*/
    CodeFile currentCode = baseBlock[i] ;
    CodeFile formerCode;
    CodeFile laterCode;
	    
    ArgRecord arg1;
    ArgRecord arg2;

    /*循环处理每条代码，直到当前基本块结束*/
    while ((currentCode!=baseBlock[i+1])&&(currentCode!=null))
    {   
        if ((currentCode.codeR.codekind.equals("ADD"))||(currentCode.codeR.codekind.equals("SUB"))||(currentCode.codeR.codekind.equals("MULT"))||(currentCode.codeR.codekind.equals("DIV"))||(currentCode.codeR.codekind.equals("LTC"))||(currentCode.codeR.codekind.equals("EQC")))
	{ 
            /*算术和关系操作*/ 
	    /*调用算术和关系运算处理函数*/ 
	    delCode = ArithC(currentCode);
	    /*删除标识为真时，删除当前多元式*/
            if (delCode)
	    {  
                formerCode = currentCode.former;
		laterCode = currentCode.next;
		if (formerCode!=null)
		    formerCode.next = laterCode;
		if (laterCode!=null)
		    laterCode.former = formerCode; 
		currentCode = formerCode;
	    }
        }		
        else if (currentCode.codeR.codekind.equals("ASSIG"))
        {
	    /*对第一个ARG结构进行值替换*/
	    SubstiArg(currentCode,1);
	    arg1 = currentCode.codeR.arg1;
	    arg2 = currentCode.codeR.arg2;
	    /*若是常数结构，则将常量定值加入常量定值表*/
	    if (arg1.form.equals("ValueForm"))
		AppendTable(arg2,arg1.midAttr.value);
	    else  /*删除表中含有此变量的定值*/ 
		DelConst(arg2);
	}
        else if (currentCode.codeR.codekind.equals("JUMP0")||currentCode.codeR.codekind.equals("WRITEC"))
	    /*对第一个ARG结构进行值替换*/
	    SubstiArg(currentCode,1);
        else if (currentCode.codeR.codekind.equals("AADD"))
	    /*对第二个ARG结构进行值替换*/
	    SubstiArg(currentCode,2);

	/*令指针指向下一条代码*/
	currentCode = currentCode.next;
    }
}
/****************************************************/
/* 函数名  ArithC				    */
/* 功  能  处理算术操作和关系比较操作		    */
/* 说  明  对运算分量1和运算分量2进行值替换，若都是 */
/*	   常数，将结果写入常量定值表，并置四元式   */
/*	   删除标志为真				    */
/****************************************************/
boolean ArithC(CodeFile code)
{
    boolean delCode = false;
    int value1,value2,result=0;
    /*对分量1进行值替换*/
    SubstiArg(code,1);
    ArgRecord arg1 = code.codeR.arg1;

    /*对分量2进行值替换*/
    SubstiArg(code,2);
    ArgRecord arg2 = code.codeR.arg2;

    String codekind =code.codeR.codekind;
    ArgRecord arg3 = code.codeR.arg3;

    /*操作分量都是常数*/
    if ((arg1.form.equals("ValueForm"))&&(arg2.form.equals("ValueForm")))
    {   
        value1 = arg1.midAttr.value;
	value2 = arg2.midAttr.value;
	if (codekind.equals("ADD"))
            result = value1+value2;
        else if (codekind.equals("SUB"))
            result = value1-value2;
        else if (codekind.equals("MULT"))
            result = value1*value2;
        else if (codekind.equals("DIV"))
            result = value1/value2;	
        else if (codekind.equals("LTC"))
        {   
            if (value1<value2)
		result = 1;
	    else  
                result = 0;
	}
        else if (codekind.equals("EQC"))   
        {
            if (value1==value2)
		result = 1;
	    else 
                result = 0; 
        } 
	/*操作结果写入常量定值表*/
	AppendTable(arg3,result);
	/*当前多元式应删除*/
        delCode = true;
    }
    return delCode;
}
/****************************************************/
/* 函数名  SubstiArg				    */
/* 功  能  对一个ARG结构进行值替换		    */
/* 说  明  参数i指出对中间代码的哪个ARG结构进行替换 */
/****************************************************/
void SubstiArg(CodeFile code,int i)
{   
    ConstDefT Entry=new ConstDefT();
    ArgRecord arg;
    ArgRecord newArg;

    if (i==1)
	arg = code.codeR.arg1;
    else 
        arg = code.codeR.arg2;
    /*若ARG结构是地址类，且常量定值表中有定值，则值替换*/
    if (arg.form.equals("AddrForm"))
    {  
	boolean constflag = FindConstT(arg,Entry);
	if (constflag)
	{ 
            /*创建一个值的ARG结构，替换原有的ARG结构*/
	    newArg = new ArgRecord();
	    newArg.form = "ValueForm";
	    newArg.midAttr.value = Entry.constValue;
	    if (i==1)
		code.codeR.arg1 = newArg;
	    else 
                code.codeR.arg2 = newArg;
        }
    }
}
/****************************************************/
/* 函数名  FindConstT				    */
/* 功  能  在常量定值表中查找当前变量是否有定值	    */
/* 说  明  输入为变量的ARG结构，根据变量是临时变量  */
/*	   还是一般标识符变量，分别处理		    */
/****************************************************/
boolean FindConstT(ArgRecord arg,ConstDefT Entry)
{ 
    boolean present = false;

    int level = arg.midAttr.addr.dataLevel;
    int off = arg.midAttr.addr.dataOff;
	
    ConstDefT t = table;
    while((t!=null)&&(!present))
    {
        if ((t.variable.midAttr.addr.dataLevel==level)
&&(t.variable.midAttr.addr.dataOff==off))
	{	
            present = true;
            /*须逐一赋值，不可直接写为Entry=t*/
            Entry.constValue = t.constValue;
	}
	t = t.next;
    }
    return present;
}
/****************************************************/
/* 函数名  AppendTable				    */
/* 功  能  将变量和其常量值写入常量定值表	    */
/* 说  明  创建一个新的节点，填写常量定值内容，并连 */
/*	   入表中				    */
/****************************************************/
void AppendTable(ArgRecord arg,int result)
{ 
    ConstDefT last = table;
    ConstDefT current = table;
    ConstDefT Entry = new ConstDefT();
    /*查找，若已存在此变量，则改变其值*/
    boolean present =  FindConstT(arg,Entry);
    if (present)
	Entry.constValue = result;
    else
    {	
        /*否则，创建一个新的节点*/
	ConstDefT newConst = new ConstDefT();
	newConst.constValue = result;
        newConst.variable = arg;

	/*当前节点加入常量定值表中*/
	if (table==null)
	    table = newConst;
	else 
	{	 
            while (last.next!=null)
	        last = last.next;
	    last.next = newConst;
	    newConst.former = last ;
	}	
    }
}

/****************************************************/
/* 函数名  DelConst				    */
/* 功  能  删除一个常量定值			    */
/* 说  明  若存在，则从常量定值表中删除，否则结束   */
/****************************************************/
void DelConst(ArgRecord arg)
{   
    ConstDefT Entry = new ConstDefT();
    ConstDefT former;
    ConstDefT later;
    /*查找变量,若存在则删除；否则，结束*/
    boolean present =  FindConstT(arg,Entry) ;
    if (present)
    {	
        former = Entry.former;
	later = Entry.next;
        if (former!=null)
	    former.next = later;
        if (later!=null)
	    later.former = former;
    }
}
/********************************************************/
/* 函数名  DivBaseBlock					*/
/* 功  能  为中间代码划分基本块				*/
/* 说  明  基本块从0开始编号，若有变参传递，则相应过程  */
/*	   调用做为当前基本块的结束			*/
/********************************************************/
int DivBaseBlock()
{   
    /*初始化基本块数目*/
    int blocknum = 0;	
    CodeFile code = firstCode;

    while (code!=null)
    {
	if ((code.codeR.codekind.equals("LABEL"))||(code.codeR.codekind.equals("WHILESTART"))||(code.codeR.codekind.equals("PENTRY"))||(code.codeR.codekind.equals("MENTRY")))
        {
	    /*进入一个新的基本块*/
            baseBlock[blocknum] =code;
            blocknum++;
        } 
	else if ((code.codeR.codekind.equals("JUMP"))||(code.codeR.codekind.equals("JUMP0"))||(code.codeR.codekind.equals("RETURNC"))||(code.codeR.codekind.equals("ENDPROC"))||(code.codeR.codekind.equals("ENDWHILE")))
        {
	    /*从下一条语句开始，进入一个新的基本块*/
	    if (code.next!=null)
	    { 
                code = code.next;
		baseBlock[blocknum] =code;
                blocknum++;
	    }
	}
	else if (code.codeR.codekind.equals("VARACT"))
	{ 
	    /*找到对应的过程调用语句，作为本基本块的结束*/
	    code = code.next;
	    while (!(code.codeR.codekind.equals("CALL")))
		code = code.next;
	    /*从下一条语句开始，进入一个新的基本块*/
	    if (code.next!=null)
	    { 
                code = code.next;
		baseBlock[blocknum] =code;
                blocknum++;
	    }			 
        }
        code = code.next;
    }
    return blocknum;
}
}

/********************************************************************/
/* 类  名 AnalYuyi	                                            */
/* 功  能 总程序的处理					            */
/* 说  明 建立一个类，处理总程序                                    */
/********************************************************************/
class AnalYuyi
{
/* SCOPESIZE为符号表scope栈的大小*/
int SCOPESIZE = 1000;

/*scope栈*/
SymbTable scope[]=new SymbTable[SCOPESIZE];

/*记录当前层数*/
int  Level=-1;
/*记录当前偏移；*/
int  Off;
/*记录主程序的displayOff*/
int mainOff;
/*记录当前层的displayOff*/
int savedOff;

/*注：域成员的偏移量从0开始。*/
int fieldOff = 0;

/*记录主程序display表的偏移量*/
int StoreNoff;

/*根据目标代码生成需要，initOff应为AR首地址sp到形参变量区的偏移7*/	
int initOff=7;

/*分别指向整型，字符型，bool类型的内部表示*/
TypeIR  intptr = new TypeIR();
TypeIR  charptr = new TypeIR();
TypeIR  boolptr = new TypeIR();

/*错误追踪标志*/
boolean Error=false;
boolean Error1=false;
String yerror;
String serror;
TreeNode yuyiTree;

AnalYuyi(String s)
{
    Recursion r=new Recursion(s);
    Error1=r.Error;
    if (Error1)
        serror=r.serror;
    else
    {
        yuyiTree=r.yufaTree;
        Analyze(yuyiTree);
    }
}
/****************************************************/