📄 xunh.java
字号:
/*产生三个临时变量*/
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)
{
/*生成else部分入口标号，及其ARG结构*/
int elseL = NewLabel();
ArgRecord ElseLarg=ARGLabel(elseL);
/*生成if语句出口标号，及其ARG结构*/
int outL = NewLabel();
ArgRecord OutLarg = ARGLabel(outL);
/*条件表达式的中间代码生成*/
ArgRecord Earg = GenExpr(t.child[0]);
/*若表达式为假，跳转至else入口标号*/
GenCode("JUMP0",Earg,ElseLarg,null);
/*then部分中间代码生成*/
GenBody(t.child[1]);
/*跳到if出口*/
GenCode("JUMP",OutLarg,null,null);
/*else部分入口标号声明*/
GenCode("LABEL",ElseLarg,null,null);
/*else部分中间代码生成*/
GenBody(t.child[2]);
/*if语句出口标号声明*/
GenCode("LABEL",OutLarg,null,null);
}
/****************************************************/
/* 函数名 GenWhileS */
/* 功 能 循环语句处理函数 */
/* 说 明 将循环入口和出口用不同的中间代码标志，是 */
/* 为了循环不变式外提的需要 */
/****************************************************/
void GenWhileS(TreeNode t)
{
/*生成while语句入口标号，及其ARG结构*/
int inL = NewLabel() ;
ArgRecord InLarg = ARGLabel(inL);
/*生成while语句出口标号，及其ARG结构*/
int outL = NewLabel();
ArgRecord OutLarg = ARGLabel(outL);
/*while语句入口标号声明*/
GenCode("WHILESTART",InLarg,null,null);
/*条件表达式的中间代码生成*/
ArgRecord Earg = GenExpr(t.child[0]);
/*若表达式为假，跳转至while语句出口*/
GenCode("JUMP0",Earg,OutLarg,null);
/*循环体中间代码生成*/
GenBody(t.child[1]);
/*跳到while入口*/
GenCode("JUMP",InLarg,null,null);
/*while出口标号声明*/
GenCode("ENDWHILE",OutLarg,null,null);
}
/********************************************************/
/* 函数名 NewTemp */
/* 功 能 产生一个新的临时变量的ARG结构 */
/* 说 明 临时变量的层数为-1，偏移为编号值，访问方式由 */
/* 参数确定 */
/********************************************************/
ArgRecord NewTemp(String access)
{
ArgRecord newTemp=new ArgRecord();
/*填写临时变量的ARG内容*/
newTemp.form="AddrForm";
newTemp.midAttr.addr=new Addr();
newTemp.midAttr.addr.dataLevel=-1 ;
newTemp.midAttr.addr.dataOff=TempOffset ;
newTemp.midAttr.addr.access=access;
/*临时变量编号加1*/
TempOffset++;
return newTemp;
}
/********************************************************/
/* 函数名 NewLabel */
/* 功 能 产生一个新的标号值 */
/* 说 明 通过全局变量Label加1，产生新的标号值 */
/********************************************************/
int NewLabel()
{
Label++;
return Label;
}
/********************************************************/
/* 函数名 ARGAddr */
/* 功 能 对于给定的变量产生相应的ARG结构 */
/* 说 明 */
/********************************************************/
ArgRecord ARGAddr(String id,int level,int off,String access)
{
ArgRecord arg = new ArgRecord();
/*填写变量ARG结构的内容*/
arg.form = "AddrForm";
arg.midAttr.addr=new Addr();
arg.midAttr.addr.name=id;
arg.midAttr.addr.dataLevel=level;
arg.midAttr.addr.dataOff=off;
arg.midAttr.addr.access=access;
return arg;
}
/********************************************************/
/* 函数名 ARGLabel */
/* 功 能 对于给定的标号产生相应的ARG结构 */
/* 说 明 */
/********************************************************/
ArgRecord ARGLabel(int label)
{
ArgRecord arg = new ArgRecord();
arg.form = "LabelForm";
arg.midAttr.label = label;
return arg;
}
/********************************************************/
/* 函数名 ARGValue */
/* 功 能 对于给定的常数值产生相应的ARG结构 */
/* 说 明 */
/********************************************************/
ArgRecord ARGValue(int value)
{
ArgRecord arg = new ArgRecord();
arg.form = "ValueForm";
arg.midAttr.value = value;
return arg;
}
/********************************************************/
/* 函数名 GenCode */
/* 功 能 根据给定参数，构造一条中间代码 */
/* 说 明 */
/********************************************************/
CodeFile GenCode(String codekind,ArgRecord Arg1,ArgRecord Arg2,ArgRecord Arg3)
{
CodeFile newCode = new CodeFile();
/*填写代码的内容*/
newCode.codeR.codekind = codekind;
newCode.codeR.arg1 = Arg1;
newCode.codeR.arg2 = Arg2;
newCode.codeR.arg3 = Arg3;
/*链入中间代码表中*/
if (firstCode==null)
firstCode = newCode;
else
{
lastCode.next = newCode;
newCode.former = lastCode;
}
lastCode = newCode;
return newCode;
}
/********************************************************/
/* 函数名 FindField */
/* 功 能 查找纪录的域名 */
/* 说 明 返回值为是否找到标志，变量Entry返回此域名在 */
/* 纪录的域表中的位置. */
/********************************************************/
boolean FindField(String Id,FieldChain head,FieldChain Entry)
{
boolean present=false;
/*记录当前节点*/
FieldChain currentItem = head;
/*从表头开始查找这个标识符，直到找到或到达表尾*/
while ((currentItem!=null)&&(!present))
{
if (currentItem.id.equals(Id))
{
present=true;
if (Entry!=null)
{
Entry.id=currentItem.id;
Entry.off=currentItem.off;
Entry.unitType=currentItem.unitType;
Entry.next=currentItem.next;
}
}
else
currentItem=currentItem.next;
}
return present;
}
/********************************************************/
/* 函数名 PrintCodeName */
/* 功 能 打印代码的类别 */
/* 说 明 由函数PrintOneCode调用 */
/********************************************************/
void PrintCodeName(String kind)
{
if (kind.equals("ADD"))
midcode=midcode+"ADD";
else if (kind.equals("SUB"))
midcode=midcode+"SUB";
else if (kind.equals("MULT"))
midcode=midcode+"MULT";
else if (kind.equals("DIV"))
midcode=midcode+"DIV";
else if (kind.equals("EQC"))
midcode=midcode+"EQ";
else if (kind.equals("LTC"))
midcode=midcode+"LT";
else if (kind.equals("READC"))
midcode=midcode+"READ";
else if (kind.equals("WRITEC"))
midcode=midcode+"WRITE";
else if (kind.equals("RETURNC"))
midcode=midcode+"RETURN";
else if (kind.equals("ASSIG"))
midcode=midcode+"ASSIG";
else if (kind.equals("AADD"))
midcode=midcode+"AADD";
else if (kind.equals("LABEL"))
midcode=midcode+"LABEL";
else if (kind.equals("JUMP0"))
midcode=midcode+"JUMP0";
else if (kind.equals("JUMP"))
midcode=midcode+"JUMP";
else if (kind.equals("CALL"))
midcode=midcode+"CALL";
else if (kind.equals("VARACT"))
midcode=midcode+"VARACT";
else if (kind.equals("VALACT"))
midcode=midcode+"VALACT";
else if (kind.equals("PENTRY"))
midcode=midcode+"PENTRY";
else if (kind.equals("ENDPROC"))
midcode=midcode+"ENDPROC";
else if (kind.equals("MENTRY"))
midcode=midcode+"MENTRY";
else if (kind.equals("ENDWHILE"))
midcode=midcode+"ENDWHILE";
else if (kind.equals("WHILESTART"))
midcode=midcode+"WHILESTART";
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -