编译原理实验 词法语法分析 附源代码.docx

编译原理实验 词法语法分析 附源代码.docx

《编译原理实验 词法语法分析 附源代码.docx》由会员分享，可在线阅读，更多相关《编译原理实验 词法语法分析 附源代码.docx（21页珍藏版）》请在冰豆网上搜索。

编译原理实验词法语法分析附源代码

编译原理实验报告

*******************************************************************************

*******************************************************************************

PL0语言功能简单、结构清晰、可读性强，而又具备了一般高级程序设计语言的必须部分，因而PL0语言的编译程序能充分体现一个高级语言编译程序实现的基本方法和技术。

PL/0语言文法的EBNF表示如下：

<程序>:

:

=<分程序>.

<分程序>:

:

=[<常量说明>][<变量说明>][<过程说明>]<语句>

<常量说明>:

:

=CONST<常量定义>{，<常量定义>};

<常量定义>:

:

=<标识符>=<无符号整数>

<无符号整数>:

:

=<数字>{<数字>}

<变量说明>:

:

=VAR<标识符>{,<标识符>};

<标识符>:

:

=<字母>{<字母>|<数字>}

<过程说明>:

:

=<过程首部><分程序>{;<过程说明>};

<过程首部>:

:

=PROCEDURE<标识符>;

<语句>:

:

=<赋值语句>|<条件语句>|<当循环语句>|<过程调用语句>

|<复合语句>|<读语句><写语句>|<空>

<赋值语句>:

:

=<标识符>:

=<表达式>

<复合语句>:

:

=BEGIN<语句>{;<语句>}END

<条件语句>:

:

=<表达式><关系运算符><表达式>|ODD<表达式>

<表达式>:

:

=[+|-]<项>{<加法运算符><项>}

<项>:

:

=<因子>{<乘法运算符><因子>}

<因子>:

:

=<标识符>|<无符号整数>|‘（’<表达式>‘）’

<加法运算符>:

:

=+|-

<乘法运算符>:

:

=*|/

<关系运算符>:

:

==|#|<|<=|>|>=

<条件语句>:

:

=IF<条件>THEN<语句>

<过程调用语句>:

:

=CALL标识符

<当循环语句>:

:

=WHILE<条件>DO<语句>

<读语句>:

:

=READ‘（’<标识符>{,<标识符>}‘）’

<写语句>:

:

=WRITE‘（’<表达式>{,<表达式>}‘）’

<字母>:

:

=a|b|…|X|Y|Z

<数字>:

:

=0|1|…|8|9

【预处理】

对于一个pl0文法首先应该进行一定的预处理，提取左公因式，消除左递归（直接或间接），接着就可以根据所得的文法进行编写代码。

【实验一】词法分析

【实验目的】给出PL/0文法规范，要求编写PL/0语言的词法分析程序。

【实验内容】已给PL/0语言文法，输出单词（关键字、专用符号以及其它标记）。

【实验要求】

1.确定编译中使用的表格、标识符与关键字的区分方法等。

2.把词法分析器设计成一个独立一遍的过程。

3.词法分析器的输出形式采用二元式序列，例如：

（ident,a）

（plus,+）

（number,15）

（times,*）

（ident,b）

【输入输出】

输入：

PL/0源程序。

例:

a+15*b

输出：

（ident,a）

（plus,+）

（number,15）

（times,*）

（ident,b）

【实验结果】

实验结果与实验要求相同，没有异议，对输入字符采取一个一个读入，到达句柄时，则采取LL

（1）文法进行规约。

实验结果如下：

实验结果用文本来进行输入输出，所以在工程目录下还会有一个文本输入，输出文件。

分别为in.txtout.txt

【实验体会】

在编写这段代码的过程中，比较麻烦得还是之前的语法预处理阶段，将不满足ll

（1）文法的语法转化为标准的ll

（1）文法。

程序在处理词法分析的过程就是不断通过getsym（）这个函数来条用getch（），不断形成一个一个的词汇，供下面语法分析时使用。

记录词汇类型的sym是一个枚举类型。

使用起来会方便许多，比较系统。

其中还用到了文本输入输出的技巧，把读出的词汇保存起来。

词法分析还是比较简单，在编写代码的时候没有太大的阻碍。

通过此次实验，让我了解到如何设计、编制并调试词法分析程序，加深对词法分析原理的理解；熟悉了构造词法分析程序的手工方式的相关原理，使用某种高级语言（例如C++语言）直接编写此法分析程序。

另外，也让我重新熟悉了C++语言的相关内容，加深了对C++语言的用途的理解。

【实验二】语法分析

【实验目的】给出PL/0文法规范，要求编写PL/0语言的语法分析程序。

【实验内容】已给PL/0语言文法，构造表达式部分的语法分析器。

【实验要求】

1.将实验一“词法分析”的输出结果，作为表达式语法分析器的输入，进行语法解析，对于语法正确的表达式，报告“语法正确”；对于语法错误的表达式，报告“语法错误”，指出错误原因。

2.把语法分析器设计成一个独立一遍的过程。

3.语法分析器的编写方法采用递归子程序法。

【输入输出】

输入：

PL/0表达式，用实验一的输出形式作为输入。

例如:

对于PL/0表达式，a+15*b用下列形式作为输入：

（ident,a）

（plus,+）

（number,15）

（times,*）

（ident,b）

输出：

对于语法正确的表达式，报告“语法正确”；

对于语法错误的表达式，报告“语法错误”，指出错误原因。

【实验结果】

实验结果与实验要求相同，没有异议，对输入字符采取一个一个读入，对输入的一个语句进行判断，判断语法的正误，采用对算法的判断，若全为数字则进行最后的计算

【实验体会】

通过语法分析可以判断当前输入语句是否正确，实验通过对数学式的处理来进行对语句的判断是否正确，若正确则只要输入“语句正确”即可，若语句错误则需要根据错误的原因输出错误的理由，以方便编译员修改自己的代码。

实现方法是通过对文本文件的输入，当前数据与即将输入的字符串进行匹配，若不符合LL

（1）文法则判定为错误，若符合则继续向下完成语法分析。

【源代码】

#include

#include

#include

#include

#include

#include

#include

#include

usingnamespacestd;

ifstreamfin（"in.txt"）;

ofstreamfout（"out.txt"）;

enumsymbol

{//01234567

nul,ident,number,plus,minus,times,slash,oddsym,

eql,neq,lss,leq,gtr,geq,lparen,rparen,

comma,semicolon,period,becomes,beginsym,endsym,ifsym,thensym,

whilesym,writesym,readsym,dosym,callsym,constsym,varsym,procsym

};

#definesymnum32

charsymwork[symnum][10];//单符号

#definenorw13//key_wordnum

#defineal10//maxstr

#definenmax10//numberlong

charword[norw][al];//keyword

charch;//bufferchargetch（）

enumsymbolsym;

charid[al+1];//ident

chara[al+1];//temp

charID[al+1];

intcc=0,ll=0,num;//当前在行的位置cc，行字符的长度ll，num数字的值

intnn=0;

charline[81];

intflg=0;//正数；

//charline[81];

enumsymbolssym[256];

enumsymbolwsym[norw];

//intcc,ll;//ch[cc]

interr;

voidinit（）

{

inti;

for（i=0;i<=255;i++）

ssym[i]=nul;//0

ssym['+']=plus;

ssym['-']=minus;

ssym['*']=times;

ssym['/']=slash;

ssym['（']=lparen;

ssym['）']=rparen;

ssym['=']=eql;

ssym[',']=comma;

ssym['.']=period;

ssym['#']=neq;//notequal

ssym[';']=semicolon;

strcpy（&symwork[plus][0],"plus"）;

strcpy（&symwork[minus][0],"minus"）;

strcpy（&symwork[times][0],"times"）;

strcpy（&symwork[slash][0],"slash"）;

strcpy（&symwork[lparen][0],"lparen"）;

strcpy（&symwork[rparen][0],"rparen"）;

strcpy（&symwork[eql][0],"eql"）;

strcpy（&symwork[comma][0],"comma"）;

strcpy（&symwork[neq][0],"neq"）;

strcpy（&symwork[period][0],"period"）;

strcpy（&symwork[semicolon][0],"semicolon"）;

strcpy（&word[0][0],"begin"）;//关键字小写字母

strcpy（&word[1][0],"call"）;

strcpy（&word[2][0],"const"）;

strcpy（&word[3][0],"do"）;

strcpy（&word[4][0],"end"）;

strcpy（&word[5][0],"if"）;

strcpy（&word[6][0],"odd"）;

strcpy（&word[7][0],"procedure"）;

strcpy（&word[8][0],"read"）;

strcpy（&word[9][0],"then"）;

strcpy（&word[10][0],"var"）;

strcpy（&word[11][0],"while"）;

strcpy（&word[12][0],"write"）;

wsym[0]=beginsym;

wsym[1]=callsym;

wsym[2]=constsym;

wsym[3]=dosym;

wsym[4]=endsym;

wsym[5]=ifsym;

wsym[6]=oddsym;

wsym[7]=procsym;

wsym[8]=readsym;

wsym[9]=thensym;

wsym[10]=varsym;

wsym[11]=whilesym;

wsym[12]=writesym;

}

voidWordAnalyse（）

{

switch（sym）

{

casenul:

//fout<<"（"<<"nul"<<","<

break;

caseident:

fout<<"（"<<"ident"<<","<

cout<<"（"<<"ident"<<","<

casenumber:

fout<<"（"<<"number"<<","<

cout<<"（"<<"number"<<","<

caseplus:

fout<<"（"<<"plus"<<","<

cout<<"（"<<"plus"<<","<

caseminus:

fout<<"（"<<"minus"<<","<

cout<<"（"<<"minus"<<","<

casetimes:

fout<<"（"<<"times"<<","<

cout<<"（"<<"times"<<","<

caseslash:

fout<<"（"<<"slash"<<","<

cout<<"（"<<"slash"<<","<

caseoddsym:

fout<<"（"<<"oddsym"<<","<

cout<<"（"<<"oddsym"<<","<

caselss:

fout<<"（"<<"lss"<<","<

cout<<"（"<<"lsst"<<","<

caseeql:

fout<<"（"<<"eql"<<","<

cout<<"（"<<"eql"<<","<

caseneq:

fout<<"（"<<"neq"<<","<

cout<<"（"<<"neq"<<","<

caseleq:

fout<<"（"<<"leq"<<","<

cout<<"（"<<"leq"<<","<

casegtr:

fout<<"（"<<"gtr"<<","<

cout<<"（"<<"gtr"<<","<

casegeq:

fout<<"（"<<"geq"<<","<

cout<<"（"<<"geqt"<<","<

caselparen:

fout<<"（"<<"lparent"<<","<

cout<<"（"<<"lparent"<<","<

caserparen:

fout<<"（"<<"rparent"<<","<

cout<<"（"<<"rparent"<<","<

casecomma:

fout<<"（"<<"comma"<<","<

cout<<"（"<<"comma"<<","<

casesemicolon:

fout<<"（"<<"semicolon"<<","<

cout<<"（"<<"semicolon"<<","<

caseperiod:

fout<<"（"<<"period"<<","<

cout<<"（"<<"period"<<","<

casebecomes:

fout<<"（"<<"becomes"<<","<

cout<<"（"<<"becomes"<<","<

casebeginsym:

fout<<"（"<<"beginsym"<<","<

cout<<"（"<<"beginsym"<<","<

caseendsym:

fout<<"（"<<"endsym"<<","<

cout<<"（"<<"endsym"<<","<

caseifsym:

fout<<"（"<<"ifsym"<<","<

cout<<"（"<<"ifsym"<<","<

casethensym:

fout<<"（"<<"thensym"<<","<

cout<<"（"<<"thensym"<<","<

casewhilesym:

fout<<"（"<<"whilesym"<<","<

cout<<"（"<<"whilesym"<<","<

casewritesym:

fout<<"（"<<"writesym"<<","<

cout<<"（"<<"writesym"<<","<

casereadsym:

fout<<"（"<<"readsym"<<","<

cout<<"（"<<"readsym"<<","<

casedosym:

fout<<"（"<<"dosym"<<","<

cout<<"（"<<"dosym"<<","<

casecallsym:

fout<<"（"<<"callsym"<<","<

cout<<"（"<<"callsym"<<","<

caseconstsym:

fout<<"（"<<"constsym"<<","<

cout<<"（"<<"constsym"<<","<

casevarsym:

fout<<"（"<<"varsym"<<","<

cout<<"（"<<"varsym"<<","<

caseprocsym:

fout<<"（"<<"procsym"<<","<

cout<<"（"<<"procsym"<<","<

default:

break;

}

}

intgetch（）

{

if（cc==ll）

{

if（fin.eof（））

{

cout<<"programincpmplete"<

return-1;

}

ll=cc=0;

fin.getline（line,81）;

ll=strlen（line）;

ch='';

return0;

}

if（cc==0）cout<

ch=line[cc];

cout<

cc++;

nn=cc;

return0;

}

#definegetchdoif（-1==getch（））return-1

//词法分析部分实验1

intgetsym（）//读符号大写字母不要出现

{

inti,j,k;//用于循环等辅助计数

while（ch==''||ch==9||ch==10）//////////////////////////////////////////

{

getchdo;

}

if（ch>='a'&&ch<='z'）

{

k=0;

while（ch>='a'&&ch<='z'||ch>='0'&&ch<='9'）//名字或保留字以a.z开头

{

if（k

{

ID[k]=ch;

k++;

}

getchdo;

}

ID[k]=0;

i=0;

j=norw;

do/*搜索当前符号是否为保留字*/

{

k=（i+j）/2;

if（strcmp（ID,word[k]）<=0）j=k-1;

if（strcmp（ID,word[k]）>=0）i=k+1;

}while（i<=j）;

if（i-1>j）sym=wsym[k];elsesym=ident;/*搜索失败，则是名字或数字*/

}

else

{

if（ch>='0'&&ch<='9'）

{

k=0;

num=0;

sym=number;

do{

ID[k]=ch;

num=num*10+ch-'0';

k++;

getchdo;

}while（ch>='0'&&ch<='9'）;

if（flg==