📄 analyuyi.java
字号:
curentry.attrIR.var.level=attribP.var.level;
curentry.attrIR.var.off=attribP.var.off;
curentry.attrIR.var.access=attribP.var.access;
}
else if (attribP.kind.equals("prockind"))
{
curentry.attrIR.proc=new Proc();
curentry.attrIR.proc.level=attribP.proc.level;
curentry.attrIR.proc.param=attribP.proc.param;
}
copy(entry,curentry);
return present;
}
/********************************************************/
/* 函数名 FindEntry */
/* 功 能 查找一个标识符是否在符号表中 */
/* 说 明 根据flag决定是查找当前符号表，还是所有符号表 */
/* 返回值决定是否找到，变量Entry返回此标识符在 */
/* 符号表中的位置 */
/********************************************************/
boolean FindEntry(String id,SymbTable entry)
{
boolean present=false; /*返回值*/
boolean result = false; /*标识符名字比较结果*/
int lev = Level; /*临时记录层数的变量*/
SymbTable findentry = scope[lev];
while((lev!=-1)&&(!present))
{
while ((findentry!=null)&&(!present))
{
result = id.equals(findentry.idName);
if (result)
present = true;
/*如果标识符名字相同，则返回TRUE*/
else
findentry = findentry.next;
/*如果没找到，则继续链表中的查找*/
}
if(!present)
{
lev = lev-1;
if(lev!=-1)
findentry = scope[lev];
}
}/*如果在本层中没有查到，则转到上一个局部化区域中继续查找*/
if (!present)
entry = null;
else
copy(entry,findentry);
return present;
}
/********************************************************/
/* 函数名 copy */
/* 功 能 复制函数 */
/* 说 明 将b中的内容复制给a */
/********************************************************/
void copy(SymbTable a,SymbTable b)
{
a.idName=b.idName;
a.attrIR=b.attrIR;
a.next=b.next;
}
/********************************************************/
/* 函数名 Fcopy */
/* 功 能 复制函数 */
/* 说 明 将b中的内容复制给a */
/********************************************************/
void Fcopy(FieldChain a,FieldChain b)
{
a.id=b.id;
a.off=b.off;
a.unitType=b.unitType;
a.next=b.next;
}
/********************************************************/
/* 函数名 PrintFieldChain */
/* 功 能 打印纪录类型的域表 */
/* 说 明 */
/********************************************************/
void PrintFieldChain(FieldChain currentP)
{
FieldChain t=currentP;
ytable=ytable+"\n--------------Field chain--------------------\n";
while (t!=null)
{
/*输出标识符名字*/
ytable=ytable+t.id;
/*输出标识符的类型信息*/
if (t.unitType.kind.equals("intTy"))
ytable=ytable+" intTy ";
else if (t.unitType.kind.equals("charTy"))
ytable=ytable+" charTy ";
else if (t.unitType.kind.equals("arrayTy"))
ytable=ytable+" arrayTy ";
else if (t.unitType.kind.equals("recordTy"))
ytable=ytable+" recordTy ";
else
ytable=ytable+"error type! ";
ytable=ytable+" off = ";
ytable=ytable+String.valueOf(t.off);
ytable=ytable+"\n";
t = t.next;
}
}
/********************************************************/
/* 函数名 PrintOneLayer */
/* 功 能 打印符号表的一层 */
/* 说 明 有符号表打印函数PrintSymbTable调用 */
/********************************************************/
void PrintOneLayer(int level)
{
SymbTable t = scope[level];
ytable=ytable+"\n--------------SymbTable in level "+String.valueOf(level)+"--------------------\n";
while (t!=null)
{
/*输出标识符名字*/
ytable=ytable+t.idName;
AttributeIR Attrib = t.attrIR;
/*输出标识符的类型信息，过程标识符除外*/
if (Attrib.idtype!=null) /*过程标识符*/
{
if (Attrib.idtype.kind.equals("intTy"))
ytable=ytable+" intTy ";
else if (Attrib.idtype.kind.equals("charTy"))
ytable=ytable+" charTy ";
else if (Attrib.idtype.kind.equals("arrayTy"))
ytable=ytable+" arrayTy ";
else if (Attrib.idtype.kind.equals("recordTy"))
ytable=ytable+" recordTy ";
else
ytable=ytable+" error type! ";
}
/*输出标识符的类别，并根据不同类型输出不同其它属性*/
if (Attrib.kind.equals("typekind"))
ytable=ytable+"typekind ";
else if (Attrib.kind.equals("varkind"))
{
ytable=ytable+"varkind "+String.valueOf(Attrib.var.level)+" "+String.valueOf(Attrib.var.off);
if (Attrib.var.access.equals("dir"))
ytable=ytable+" dir ";
else if (Attrib.var.access.equals("indir"))
ytable=ytable+" indir ";
else
ytable=ytable+" errorkind ";
}
else if (Attrib.kind.equals("prockind"))
{
ytable=ytable+" prockind "+String.valueOf(Attrib.proc.level)+" "+String.valueOf(Attrib.proc.nOff);
}
else
ytable=ytable+" error ";
ytable=ytable+"\n";
t = t.next;
}
}
/********************************************************/
/* 函数名 PrintSymbTable */
/* 功 能 打印生成的符号表 */
/* 说 明 */
/********************************************************/
void PrintSymbTable()
{
/*层数从0开始*/
int level=0;
while (scope[level]!=null)
{
PrintOneLayer(level);
level++;
}
}
}
/********************************************************************/
/************************语 法 分 析*********************************/
/********************************************************************/
/********************************************************************/
/* 类 名 Recursion */
/* 功 能 总程序的处理 */
/* 说 明 建立一个类，处理总程序 */
/********************************************************************/
class Recursion
{
TokenType token=new TokenType();
int MAXTOKENLEN=10;
int lineno=0;
String temp_name;
StringTokenizer fenxi;
boolean Error=false;
String serror;
TreeNode yufaTree;
Recursion(String s)
{
yufaTree=Program(s);
}
/********************************************************************/
/********************************************************************/
/********************************************************************/
/* 函数名 Program */
/* 功 能 总程序的处理函数 */
/* 产生式 < Program > ::= ProgramHead DeclarePart ProgramBody . */
/* 说 明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点 */
/* 语法树的根节点的第一个子节点指向程序头部分ProgramHead, */
/* DeclaraPart为ProgramHead的兄弟节点,程序体部分ProgramBody */
/* 为DeclarePart的兄弟节点. */
/********************************************************************/
TreeNode Program(String ss)
{
fenxi=new StringTokenizer(ss,"\n");
ReadNextToken();
TreeNode root = newNode("ProcK");
TreeNode t=ProgramHead();
TreeNode q=DeclarePart();
TreeNode s=ProgramBody();
if (t!=null)
root.child[0] = t;
else
syntaxError("a program head is expected!");
if (q!=null)
root.child[1] = q;
if (s!=null)
root.child[2] = s;
else syntaxError("a program body is expected!");
match("DOT");
if (!(token.Lex.equals("ENDFILE")))
syntaxError("Code ends before file\n");
return root;
}
/**************************函数头部分********************************/
/********************************************************************/
/********************************************************************/
/* 函数名 ProgramHead */
/* 功 能 程序头的处理函数 */
/* 产生式 < ProgramHead > ::= PROGRAM ProgramName */
/* 说 明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点 */
/********************************************************************/
TreeNode ProgramHead()
{
TreeNode t = newNode("PheadK");
match("PROGRAM");
if (token.Lex.equals("ID"))
t.name[0]=token.Sem;
match("ID");
return t;
}
/**************************声明部分**********************************/
/********************************************************************/
/********************************************************************/
/* 函数名 DeclarePart */
/* 功 能 声明部分的处理 */
/* 产生式 < DeclarePart > ::= TypeDec VarDec ProcDec */
/* 说 明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点 */
/********************************************************************/
TreeNode DeclarePart()
{
/*类型*/
TreeNode typeP = newNode("TypeK");
TreeNode tp1 = TypeDec();
if (tp1!=null)
typeP.child[0] = tp1;
else
typeP=null;
/*变量*/
TreeNode varP = newNode("VarK");
TreeNode tp2 = VarDec();
if (tp2 != null)
varP.child[0] = tp2;
else
varP=null;
/*函数*/
TreeNode procP = ProcDec();
if (procP==null) {}
if (varP==null) { varP=procP; }
if (typeP==null) { typeP=varP; }
if (typeP!=varP)
typeP.sibling = varP;
if (varP!=procP)
varP.sibling = procP;
return typeP;
}
/**************************类型声明部分******************************/
/********************************************************************/
/* 函数名 TypeDec */
/* 功 能 类型声明部分的处理 */
/* 产生式 < TypeDec > ::= ε | TypeDeclaration */
/* 说 明 根据文法产生式,调用相应的递归处理函数,生成语法树节点 */
/********************************************************************/
TreeNode TypeDec()
{
TreeNode t = null;
if (token.Lex.equals("TYPE"))
t = TypeDeclaration();
else if ((token.Lex.equals("VAR"))||(token.Lex.equals("PROCEDURE"))
||(token.Lex.equals("BEGIN"))) {}
else
ReadNextToken();
return t;
}
/********************************************************************/
/* 函数名 TypeDeclaration */
/* 功 能 类型声明部分的处理函数 */
/* 产生式 < TypeDeclaration > ::= TYPE TypeDecList */
/* 说 明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点 */
/********************************************************************/
TreeNode TypeDeclaration()
{
match("TYPE");
TreeNode t = TypeDecList();
if (t==null)
syntaxError("a type declaration is expected!");
return t;
}
/********************************************************************/
/* 函数名 TypeDecList */
/* 功 能 类型声明部分的处理函数 */
/* 产生式 < TypeDecList > ::= TypeId = TypeName ; TypeDecMore */
/* 说 明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点 */
/********************************************************************/
TreeNode TypeDecList()
{
TreeNode t = newNode("DecK");
if (t != null)
{
TypeId(t);
match("EQ");
TypeName(t);
match("SEMI");
TreeNode p = TypeDecMore();
if (p!=null)
t.sibling = p;
}
return t;
}
/********************************************************************/
/* 函数名 TypeDecMore */
/* 功 能 类型声明部分的处理函数 */
/* 产生式 < TypeDecMore > ::= ε | TypeDecList */
/* 说 明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点 */
/********************************************************************/
TreeNode TypeDecMore()
{
TreeNode t=null;
if (token.Lex.equals("ID"))
t = TypeDecList();
else if ((token.Lex.equals("VAR"))||(token.Lex.equals("PROCEDURE"))||(token.Lex.equals("BEGIN"))) {}
else
ReadNextToken();
return t;
}
/********************************************************************/
/* 函数名 TypeId */
/* 功 能 类型声明部分的处理函数 */
/* 产生式 < TypeId > ::= id */
/* 说 明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点 */
/********************************************************************/
void TypeId(TreeNode t)
{
if ((token.Lex.equals("ID"))&&(t!=null))
{
t.name[(t.idnum)]=token.Sem;
t.idnum = t.idnum+1;
}
match("ID");
}
/********************************************************************/
/* 函数名 TypeName */
/* 功 能 类型声明部分的处理 */
/* 产生式 < TypeName > ::= BaseType | StructureType | id */
/* 说 明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点 */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -