gongg.java

一个java编译器

package mycompiler.youhua.gonggong;
import java.io.*;
import java.awt.*;
import java.util.*;
class TokenType
{ 
    int lineshow;
    String Lex;
    String Sem;
} 
class ChainNodeType  
{
    TokenType  Token=new TokenType();      //单词
    ChainNodeType nextToken=null;          //指向下一个单词的指针
}
/******************************************/
class SymbTable  /* 在语义分析时用到 */
{
    String idName;
    AttributeIR  attrIR=new AttributeIR();
    SymbTable next=null;
}
class AttributeIR
{
    TypeIR  idtype=new TypeIR();
    String kind;	
    Var var;
    Proc proc;
}
class Var
{
    String access;
    int level;
    int off;
    boolean isParam;
}
class Proc
{
    int level;
    ParamTable param;
    int mOff;
    int nOff;
    int procEntry;
    int codeEntry;
}
class ParamTable
{
    SymbTable entry=new SymbTable();
    ParamTable next=null;
}
class TypeIR
{
    int size;
    String kind;
    Array array;
    FieldChain body;
}
class Array
{
    TypeIR indexTy=new TypeIR();
    TypeIR elementTy=new TypeIR();
    int low;
    int up;
}
class FieldChain
{
    String id;
    int off;
    TypeIR unitType=new TypeIR();
    FieldChain next=null;
}
/*******************************************/
class TreeNode   /* 语法树结点的定义 */
{
    TreeNode child[]=new TreeNode[3];
    TreeNode sibling=null;
    int lineno;
    String nodekind;
    String kind;
    int idnum;
    String name[]=new String[10];
    SymbTable table[]=new SymbTable[10];
    Attr attr=new Attr();
}   
class Attr
{
    ArrayAttr arrayAttr=null;  /* 只用到其中一个，用到时再分配内存 */
    ProcAttr procAttr=null;
    ExpAttr expAttr=null;
    String type_name;
}
class ArrayAttr
{
    int low;
    int up;
    String childtype;
}
class ProcAttr
{
    String paramt;
}
class ExpAttr
{
    String op;
    int val;
    String varkind;
    String type;
}
/*源程序对应的中间代码序列表示*/
class CodeFile
{   
    CodeR codeR=new CodeR();
    CodeFile former=null;
    CodeFile next=null;
}
/*中间代码的结构*/
class CodeR
{    
    String codekind;
    ArgRecord arg1;  
    ArgRecord arg2;
    ArgRecord arg3;
}  
class ArgRecord  
{  
    String form;
    MidAttr midAttr=new MidAttr();  /*变量的ARG结构需要纪录的信息*/
}  
class MidAttr		
{  
    int value;  /*纪录整数值*/
    int label;  /*纪录标号的值*/
    Addr addr;
}
class Addr
{ 
    String name;    /*注：变量名字已经没用，这里保留只是为了显示结果清晰*/
    int dataLevel;
    int dataOff;
    String access;  /*类型AccessKind在前面定义*/
}
/*值编码表ValuNum*/
class ValuNum
{
    ArgRecord arg=new ArgRecord();
    String access;
    CodeInfo codeInfo=new CodeInfo();
    /*指向下一个节点指针*/
    ValuNum next=null;
}
class CodeInfo
{
    int valueCode;   /*直接变量，存储值编码*/
    TwoCode twoCode=null;
}
class TwoCode
{
    int valuecode;
    int addrcode;         /*间接临时变量，存储值编码和地址码*/
}
/*中间代码对应的映象码结构*/
class MirrorCode
{  
    int op1;
    int op2;
    int result;
} 
/*可用表达式代码表UsableExpr*/
class UsableExpr
{ 
    CodeFile code=null;	   /*中间代码地址*/
    MirrorCode mirrorC=null;    /*映象码*/
    UsableExpr next=null;  /*指向下一个节点*/
} 
/*临时变量的等价表TempEqua*/
class TempEqua
{
    ArgRecord arg1=null; /*被替换的临时变量*/
    ArgRecord arg2=null; /*用于替换的临时变量*/
    TempEqua next=null;
} 

/********************************************************************/
/* 类  名 Gongg                                                     */
/* 功  能 总程序的处理					            */
/* 说  明 建立一个类，处理总程序                                    */
/********************************************************************/
public class Gongg
{
CodeFile baseBlock[]=new CodeFile[100];
int blocknum;

/*临时变量编号，全局变量,每个过程开始都对TempOffset进行
  初始化，注：所以，不同过程中，可能有编号相同的临时变量，但是
  由于他们互不相干，所以不会有问题；而且优化部分是对基本块进行优化，
  每个基本块最大是一个过程，也不会有问题 */
int TempOffset=0;

/*标号值，全局变量*/
int Label=0;

/*指向第一条中间代码*/
CodeFile firstCode;

/*指向当前最后一条中间代码*/
CodeFile lastCode;

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

ValuNum valuNumT;
UsableExpr usableExprT;
TempEqua tempEquaT;
/*记录值编码*/
int Vnumber=0;

CodeFile mid;

public boolean Error=false;
public boolean Error1=false;
public String yerror;
public String serror;
public String midcode;

public Gongg(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);
        ECCsave();
        PrintMidCode(mid);
    }
}
 
/********************************************************/
/* 函数名  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;