编译课设报告.docx
《编译课设报告.docx》由会员分享，可在线阅读，更多相关《编译课设报告.docx（46页珍藏版）》请在冰点文库上搜索。
编译课设报告
北华航天工业学院
《编译原理》课程设计
课程设计题目：
编译程序构造
作者所在系部：
内容摘要
本次课程设计涉及词法分析、自下而上语法分析程序的实现：
SLR
（1）分析器的实现以及生成中间代码。
通过词法分析识别单词和运算符，根据LR分析算法构造SLR
（1）分析程序，并完成语法分析动作，语法分析调用词法分析，然后查找用SLR
（1）构造的ACTION表和GOTO表进行移进或归约，归约时根据不同的产生式进行不同的语义分析，最终输出分析过程，并形成符号表、二元式、四元式文件。
本次程序将本次课程所学的词法分析，语法分析和语义分析结合起来，使我们进一步理解正则表达式，自动机以及语法分析方法。
同时加深掌握语法制导翻译和中间代码生成，在语法分析的同时进行语义加工并产生出中间代码的方法。
关键词：
算数表达式和赋值语句，词法分析，语法分析，语义分析，SLR
（1）
内容摘要2
第一章绪论4
1.1、课程设计目的4
1.2、课程设计意义4
1.3、课程设计要求4
1.4、课程设计内容4
1.4.1、题目4
1.4.2、内容4
1.4.3、具体要求4
1.4.4、程序设计提示5
1.4.5、测试数据5
第二章程序总体设计6
2.1、设计方案介绍6
2.1.1、模块划分及模块调用关系6
2.1.2、程序流程图6
第三章程序源代码8
3.1、识别标识符8
3.2、识别保留字8
3.3、识别常数10
3.4、堆栈设计11
3.5、词法分析11
3.6、语法分析13
3.7、分析过程16
3.8、主函数20
第四章程序测试数据和结果20
4.1、测试输入源文件的内容20
4.2、SLR
（1）分析表20
4.3、测试结果21
第五章总结23
第一章绪论
1.1、课程设计目的
《编译原理》课程设计是编译原理课程必不可少的一个环节，通过课程设计，加深对编译原理的教学内容的了解，以及实现编译原理各部分知识的融合。
进而提高学生分析问题、解决问题，从而运用所学知识解决实际问题的能力。
1.2、课程设计意义
计算机语言之所以能由单一的机器语言发展到现今的数千种高级语言，就是因为有了编译技术，编译技术是计算机科学中发展最迅速，最成熟的技术，它集中了计算机发展的成果与精华，它具有很强的理论性和实践性，本次课设将理论应用到实践，增强学生学习的热情。
1.3、课程设计要求
1．明确课设任务，复习与查阅有关资料
2．按要求完成课设内容，课设报告要求文字和图工整、思路清楚、正确。
3．注意增强程序界面的友好性。
凡用户输入时，给出足够的提示信息使用户感到方便使用。
4．注意提高程序的可读性和可理解性：
程序中应有适当的注释，变量命名应符合实际含义，程序结构清晰，易于阅读和理解。
1.4、课程设计内容
1.4.1、题目
编译程序构造
1.4.2、内容
涉及词法分析、自下而上语法分析程序的实现：
SLR
（1）分析器的实现以及生成中间代码。
1.4.3、具体要求
根据LR分析算法构造SLR
（1）分析程序，并完成语法分析动作（当需要一个单词时，调用词法分析程序获取），同时完成语义分析生成四元式输出。
要求程序具有通用性，改变文法时只需改变程序的数据初值，无需改变程序主体；
（1）基本要求：
完成1条说明语句、2条算数表达式和赋值语句的翻译，生成中间代码。
（2）高级要求：
在完成基本要求的基础上，实现if语句和布尔表达式的翻译。
if语句的文法和翻译方案参见课本。
变量说明语句的文法及相应的语义子程序：
.att表示数据类型属性，fill函数表示将单词id及其类别属性填写符号表。
（0）S→D；{acc}
（1）D→intid{fill（id，int）；D.att=int;}
（2）D→floatid{fill（id,float）;D.att=float;}
（3）D→D
（1），id{fill（id,D
（1）.att）;D.att=D
（1）.att;}
算数表达式和赋值语句的文法及相应的语义子程序。
（1）A→id=E；{p=lookup（id.name）;
emit（E.PALCE,,p）;}
（2）E→E
（1）+T{E.PALCE=newtemp（）;
emit（+，E
（1）.PALCE，T.PALCE，E.PALCE）}
（3）E→T{E.PALCE=T.PALCE;}
（4）T→T
（1）*F{T.PALCE=newtemp（）;
emit（+，T
（1）.PALCE，F.PALCE，T.PALCE）}
（5）T→F{T.PALCE=F.PALCE;}
（6）F→（E）{F.PALCE=E.PALCE;}
（7）F→id{P=LOOKUP（id.name）
F.PALCE=P;}
（8）F→num{P=LOOKUP（num.value）
F.PALCE=P;}
构造其用于SLR
（1）分析的识别活前缀的DFA以及action表和goto表。
然后编程实现。
（关于词法分析部分只需识别出与此文法相关的单词即可（+，*，（，），id，=））。
1.4.4、程序设计提示
（1）分析栈设计时可以用一个栈完成，也可以设计三个栈：
一个符号栈，一个状态栈，一个语义栈，则归约时，则需要在符号栈中退掉n个符号，在状态栈中退掉n个符号（n为产生式符号个数），语义栈中退掉n个符号对应的语义；
（2）终结符表和非终结符表的组织和预测分析程序中相同（将符号对应到一个数字，表示在分析表中对应的下标）。
（3）action表中的错误处理：
简化的错误处理：
当查找action表出现空白时，则当前单词无法移进和规约，可简单的认为当前单词为多余的单词，则抛弃当前单词，读下一单词继续分析。
1.4.5、测试数据
源文件中数据：
intarea,r;r=1;area=r*r+r;
第二章程序总体设计
2.1、设计方案介绍
2.1.1、模块划分及模块调用关系
图2-1：
模块关系图
2.1.2、程序流程图
图2-2：
词法分析流程图
图2-3：
语法分析流程图
第三章程序源代码
3.1、识别标识符
importjava.io.BufferedWriter;
importjava.io.IOException;
publicclassID{
staticintcount=0;//标识符个数;
Stringid;//name;
Stringtype;//类型;
intaddr;//地址;
publicintIn_ID（Strings,IDiid[]）{
inti;
for（i=0;i{
if（s.equalsIgnoreCase（iid[i].id）!
=false）
returni;
}
iid[i]=newID（）;
iid[i].id=s;
iid[i].type="null";
count++;
returni;
};
publicintSearch_ID（Strings,IDiid[]）{
inti=0;
for（;i{
if（s.equalsIgnoreCase（iid[i].id）==true）returni;
}
return-1;
};
publicvoidSavew（Stringstr,IDw[]）
{
BufferedWriterbw=LexAna.WFile（str）;
inti=0;
try{
bw.write（"编号"）;bw.write（"标识符"）;bw.write（"类型"）;bw.write（"地址"）;
bw.newLine（）;
while（i{
bw.write（i+""）;
bw.write（w[i].id+"",0,w[i].id.length（）+2）;
bw.write（w[i].type+"",0,w[i].type.length（）+2）;
bw.write（String.valueOf（w[i].addr）+"",0,String.valueOf（w[i].addr）.length（）+2）;
bw.newLine（）;
i++;
}
bw.flush（）;
bw.close（）;
}catch（IOExceptione）{
e.printStackTrace（）;
}}}
3.2、识别保留字
publicclassKeyWord{
Stringword;//保留字；
Stringmark;//内码值；
Stringvolue;//助记符;
publicintLexList（KeyWordw[],Strings）
{
inti=0;
BufferedReaderbr;
LexAnala=newLexAna（）;
br=la.OFile（s）;
try{
if（br.ready（）!
=true）return-1;
}catch（IOExceptione1）{
e1.printStackTrace（）;
}
Stringb;
try{
while（（b=br.readLine（））!
=null）
{w[i]=newKeyWord（）;
if（b.length（）==0）break;
w[i].word=b;
if（b.charAt（0）=='<'||b.charAt（0）=='>'||b.equals（"!
="）||b.equals（"="））
{w[i].mark=b;w[i].volue="rlop";}
else{w[i].mark="-";w[i].volue=b;}
i++;
}
}catch（IOExceptione）{}
if（s.length（）==13）
{
w[i]=newKeyWord（）;
w[i].word="&&";
w[i].volue="and";
w[i++].mark="-";
w[i]=newKeyWord（）;
w[i].word="||";
w[i].volue="or";
w[i++].mark="-";
w[i]=newKeyWord（）;
w[i].word="!
";
w[i].volue="not";
w[i++].mark="-";
}
returni;
}
publicintSeach_key（intn,Strings,KeyWordw[]）{
inti=0;
for（;i{
if（s.equalsIgnoreCase（w[i].word）==true）returni;
}
return-1;
}
publicvoidSavew（Stringstr,KeyWordw[],intn）
{
BufferedWriterbw=LexAna.WFile（str）;
inti=0;
try{
bw.write（"编号：
"）;bw.write（"单词：
"）;bw.write（"单词助记符：
"）;bw.write（"内码值：
"）;
bw.newLine（）;
while（i{
bw.write（String.valueOf（i）+"",0,String.valueOf（i）.length（）+2）;
bw.write（w[i].word+"",0,w[i].word.length（）+2）;
bw.write（w[i].volue+"",0,w[i].volue.length（）+2）;
bw.write（w[i].mark+"",0,w[i].mark.length（）+2）;
bw.newLine（）;
i++;
}
bw.flush（）;
bw.close（）;
}catch（IOExceptione）{
e.printStackTrace（）;
}
3.3、识别常数
publicclassNum{
Stringname;//名称；
Stringvalue;//值；
publicstaticintcount=0;
publicintIn_Num（Stringm,Numnn[]）
{
inti=0;
for（;i{
if（m.equals（nn[i].name））returni;
}
nn[i]=newNum（）;
nn[i].name=m;
nn[i].value=m;
count++;
returni;
}
publicvoidSavew（Stringstr,Numw[]）
{
BufferedWriterbw=LexAna.WFile（str）;
inti=0;System.out.println（i）;
try{
bw.write（"编号"）;bw.write（"名称"）;bw.write（"值"）;
bw.newLine（）;
while（i{
bw.write（String.valueOf（i）+"",0,String.valueOf（i）.length（）+2）;
bw.write（w[i].name+"",0,w[i].name.length（）+2）;
bw.write（w[i].value+"",0,w[i].value.length（）+2）;
bw.newLine（）;
i++;
}
bw.flush（）;
bw.close（）;
}catch（IOExceptione）{
e.printStackTrace（）;
}
}
}
3.4、堆栈设计
publicclassStack{
intx;//纵坐标;
inty;//横坐标；
publicvoidPushStack（intx,inty,Stackst[],intcount）
{
count++;
st[count]=newStack（）;
st[count].x=y;
st[count].y=x;
}
publicStackPopStack（Stackst[],intcount）
{
Stacks=st[count];
s.x=st[count].x;
s.y=st[count].y;
count--;
returns;
}
}
3.5、词法分析
publicclassSLR1{
privateintaction[][]={
{3,4,0,0,0,0},{0,0,0,0,0,111},{0,0,0,5,6,0},
{0,0,7,0,0,0},{0,0,8,0,0,0},{0,0,0,0,0,-1},
{0,0,9,0,0,0},{0,0,0,-2,-2,0},{0,0,0,-3,-3,0},
{0,0,0,-4,-4,0}};
privateintgo[]={1,2};
privateStackstate=newStack（）;
privateStacksign=newStack（）;
privateString[]Vn={"S","D"};
privateString[]Vt={"int","float","id",";",",","#"};
privateString[]List={"SS","DD","DD","DDD"};
privateStringtype;
privateintnum=1;
publicintsearchVn（Stringstr）
{
for（inti=0;i{
if（str.equals（Vn[i]））returni;
}
return-1;
}
publicintsearchVt（Stringstr）
{
for（inti=0;i{
if（str.equals（Vt[i]））returni;
}
return-1;
}
publicintsearchAction（inti,intj）
{
returnaction[i][j];
}
publicintsearchGO（inti,intj）
{
if（i!
=0）return-1;
elsereturngo[j];
}
privatebooleanfill（inti,Stringtype）
{
if（LexAna.idd[i].type.equals（null））returnfalse;
LexAna.idd[i].type=type;
returntrue;
}
privateintgetInt（Stringstr）
{
inti;
for（i=0;i{
if（Character.isDigit（str.charAt（i）））break;
}
intj=Integer.parseInt（str.substring（i,str.length（）））;
returnj;
}
publicStringtoStackString（Stacks）
{
Stringstring="";
String[]strlist=s.toString（）.split（"[/[/]]"）;
for（inti=0;i{
string+=strlist[i];
}
returnstring;
}
privateStringspiltStr（Stringstr）
{
String[]list=str.split（"[（]"）;
Strings="";
for（inti=0;i{
if（list[i].trim（）.length（）==0）continue;
if（list[i].charAt（0）!
=','）s+=list[i].split（"[,]"）[0]+"";
elses+=",";
}
returns;
}
publicvoidcheck（Stringstring）
{
state.clear（）;
sign.clear（）;
state.add（0）;
sign.add（"#"）;
intflag=-1;
Stringsubstr="";
StringactionSware="";
booleanbool=true;
Stringstr=spiltStr（string）+"#";
Strings="";
inti=0,j=0;
intlength=0;
System.out.println（"词法分析过程如下：
"）;
System.out.printf（"%3s%25s%25s%25s%25s\n","步骤","状态栈","符号栈","输入串","动作说明"）;
Scannersc=newScanner（str）;
do
{
if（i==0）i=state.peek（）;
if（bool&&sc.hasNext（））{
s=sc.next（）;flag++;
length+=s.length（）+1;
substr=str.substring（length,str.length（））;
}
bool=true;
if（s.equals（"int"）||s.equals（"float"））
type=s;
j=searchVt（s）;
i=searchAction（i,j）;
if（i==111）continue;
if（i==0）{
actionSware="出错"+s+"无效";}
elseif（i>0）
{
state.add（i）;
sign.add（s）;
actionSware="S"+i+"移进";
}
else{
if（type.length（）!
=0）
{
intno=getInt（string.split（"[）]"）[flag-1]）;
if（!
fill（no,type））{System.out.println（"重复定义！
"）;
break;
}
}
actionSware="r"+（-i）+"归约";
if（!
Character.isLetter（s.charAt（0）））
if（!
s.equals（","））type="";
for（intp=0;p{
state.pop（）;
sign.pop（）;
}
intl=state.peek（）;
Strings1=List[（-i）-1].substring（0,1）;
i=searchGO（l,searchVn（s1））;
state.add（i）;
sign.add（s1）;
bool=f
升级会员 