语法分析实验报告

合集下载

LL(1)语法分析程序实验报告

LL(1)语法分析程序实验报告

LL1实验报告1.设计原理所谓LL(1)分析法,就是指从左到右扫描输入串(源程序),同时采用最左推导,且对每次直接推导只需向前看一个输入符号,便可确定当前所应当选择的规则。

实现LL(1)分析的程序又称为LL(1)分析程序或LL1(1)分析器。

我们知道一个文法要能进行LL(1)分析,那么这个文法应该满足:无二义性,无左递归,无左公因子。

当文法满足条件后,再分别构造文法每个非终结符的FIRST和FOLLOW 集合,然后根据FIRST和FOLLOW集合构造LL(1)分析表,最后利用分析表,根据LL(1)语法分析构造一个分析器。

LL(1)的语法分析程序包含了三个部分,总控程序,预测分析表函数,先进先出的语法分析栈,本程序也是采用了同样的方法进行语法分析,该程序是采用了C++语言来编写,其逻辑结构图如下:LL(1)预测分析程序的总控程序在任何时候都是按STACK栈顶符号X和当前的输入符号a做哪种过程的。

对于任何(X,a),总控程序每次都执行下述三种可能的动作之一:(1)若X = a =‘#’,则宣布分析成功,停止分析过程。

(2)若X = a ‘#’,则把X从STACK栈顶弹出,让a指向下一个输入符号。

(3)若X是一个非终结符,则查看预测分析表M。

若M[A,a]中存放着关于X的一个产生式,那么,首先把X弹出STACK栈顶,然后,把产生式的右部符号串按反序一一弹出STACK栈(若右部符号为ε,则不推什么东西进STACK栈)。

若M[A,a]中存放着“出错标志”,则调用出错诊断程序ERROR。

事实上,LL(1)的分析是根据文法构造的,它反映了相应文法所定义的语言的固定特征,因此在LL(1)分析器中,实际上是以LL(1)分析表代替相应方法来进行分析的。

2.分析LL ( 1) 分析表是一个二维表,它的表列符号是当前符号,包括文法所有的终结和自定义。

的句子结束符号#,它的表行符号是可能在文法符号栈SYN中出现的所有符号,包括所有的非终结符,所有出现在产生式右侧且不在首位置的终结符,自定义的句子结束符号#表项。

语法法分析实验报告

语法法分析实验报告

一、实验目的1. 理解语法分析的基本概念和原理。

2. 掌握语法分析器的构建方法。

3. 培养实际操作能力,提高编程水平。

二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 开发工具:PyCharm三、实验内容1. 语法分析概述2. 词法分析3. 语法分析4. 实验实现四、实验步骤1. 语法分析概述(1)了解语法分析的定义、作用和意义。

(2)掌握语法分析的基本原理和流程。

2. 词法分析(1)编写词法分析器代码,将源代码分解成单词序列。

(2)实现词法分析器的各个功能,如:识别标识符、关键字、运算符等。

3. 语法分析(1)设计语法分析器,将单词序列转换为抽象语法树(AST)。

(2)实现语法分析器的各个功能,如:识别表达式、语句、函数等。

4. 实验实现(1)创建Python项目,导入相关库。

(2)编写词法分析器代码,实现单词序列的分解。

(3)编写语法分析器代码,实现抽象语法树的构建。

(4)测试语法分析器,验证其正确性。

五、实验结果与分析1. 词法分析结果实验中,我们成功地将源代码分解成单词序列,包括标识符、关键字、运算符等。

词法分析器的输出结果如下:```identifier: akeyword: intoperator: +identifier: boperator: =integer: 5```2. 语法分析结果通过语法分析器,我们将单词序列转换成抽象语法树。

以下是一个示例的抽象语法树:```Program├── Declaration│ ├── Type│ │ ├── Identifier│ │ └── Integer│ └── Identifier│ └── a└── Statement├── Expression│ ├── Identifier│ └── a└── Operator└── =└── Expression├── Identifier└── b└── Integer└── 5```从实验结果可以看出,我们的语法分析器能够正确地将源代码转换为抽象语法树。

PL0语言语法分析器实验报告

PL0语言语法分析器实验报告

PL0语言语法分析器实验报告一、引言编译器是一种用于把高级语言程序转换成机器可执行代码的软件工具。

编译器由多个组件构成,其中语法分析器是编译器中的重要组成部分,其主要功能是对输入的源代码进行解析,并生成一个语法树。

本实验旨在通过使用BNF(巴科斯范式)描述PL0语言的语法规则,并通过实现PL0语言的语法分析器,来深入理解语法分析的原理和过程。

二、PL0语言的语法规则1.程序结构:<程序>::=[<常量说明部分>][<变量说明部分>][<过程说明部分>]<语句>2.常量说明部分:<常量说明部分> ::= const <常量定义> { , <常量定义> };<常量定义>::=<标识符>=<无符号整数>3.变量说明部分:<变量说明部分> ::= var <标识符> { , <标识符> };4.过程说明部分:<过程说明部分>::=<过程首部><分程序>;<过程首部> ::= procedure <标识符> ;5.语句:<语句> ::= <赋值语句> , <if语句> , <while语句> , <调用语句> , <复合语句> , <读语句> , <写语句> , <空><赋值语句>::=<标识符>:=<表达式><if语句> ::= if <条件> then <语句> else <语句><while语句> ::= while <条件> do <语句><调用语句> ::= call <标识符><复合语句> ::= begin <语句> { ; <语句> } end<读语句> ::= read ( <标识符> )<写语句> ::= write ( <表达式> )6.表达式:<表达式>::=[+,-]<项>{(+,-)<项>}<项>::=<因子>{(*,/)<因子>}<因子>::=<标识符>,<无符号整数>,(<表达式>)7.条件:<条件>::=<表达式><关系运算符><表达式><关系运算符>::==,<>,<,<=,>,>=三、PL0语言的语法分析器设计与实现1.设计思路本次实验中,我们将使用自顶向下的递归下降分析法,来对PL0语言进行语法分析。

编译原理实验二LL(1)语法分析实验报告

编译原理实验二LL(1)语法分析实验报告

专题3_LL(1)语法分析设计原理与实现李若森 13281132 计科1301一、理论传授语法分析的设计方法和实现原理;LL(1) 分析表的构造;LL(1)分析过程;LL(1)分析器的构造。

二、目标任务实验项目实现LL(1)分析中控制程序(表驱动程序);完成以下描述算术表达式的 LL(1)文法的LL(1)分析程序。

G[E]:E→TE’E’→ATE’|εT→FT’T’→MFT’|εF→(E)|iA→+|-M→*|/设计说明终结符号i为用户定义的简单变量,即标识符的定义。

加减乘除即运算符。

设计要求(1)输入串应是词法分析的输出二元式序列,即某算术表达式“专题 1”的输出结果,输出为输入串是否为该文法定义的算术表达式的判断结果;(2)LL(1)分析程序应能发现输入串出错;(3)设计两个测试用例(尽可能完备,正确和出错),并给出测试结果。

任务分析重点解决LL(1)表的构造和LL(1)分析器的实现。

三、实现过程实现LL(1)分析器a)将#号放在输入串S的尾部b)S中字符顺序入栈c)反复执行c),任何时候按栈顶Xm和输入ai依据分析表,执行下述三个动作之一。

构造LL(1)分析表构造LL(1)分析表需要得到文法G[E]的FIRST集和FOLLOW集。

构造FIRST(α)构造FOLLOW(A)构造LL(1)分析表算法根据上述算法可得G[E]的LL(1)分析表,如表3-1所示:表3-1 LL(1)分析表主要数据结构pair<int, string>:用pair<int, string>来存储单个二元组。

该对照表由专题1定义。

map<string, int>:存储离散化后的终结符和非终结符。

vector<string>[][]:存储LL(1)分析表函数定义init:void init();功能:初始化LL(1)分析表,关键字及识别码对照表,离散化(非)终结符传入参数:(无)传出参数:(无)返回值:(无)Parse:bool Parse( const vector<PIS> &vec, int &ncol );功能:进行该行的语法分析传入参数:vec:该行二元式序列传出参数:emsg:出错信息epos:出错标识符首字符所在位置返回值:是否成功解析。

语法分析实验报告

语法分析实验报告

语法分析实验报告一、实验目的:. 了解单词(内部编码)符号串中的短语句型结构形成规律。

. 理解和掌握语法分析过程中语法分析思想(,)的智能算法化方法。

二、实验内容:构造自己设计的小语言的语法分析器:. 小语言的语法描述(语法规则)的设计即文法的设计;. 把文法形式符号中所隐含的信息内容挖掘出来并用或的资料形式(分析表)表示出来;. 语法分析的数据输入形式和输出形式的确定;. 语法分析程序各个模块的设计与调试。

主要设备和材料:电脑、操作系统、语言系统三、实验分工:学号姓名实验分工实验代码设计及编写检查校对代码写电子版实验报告查找、分析、整理资料查找、分析、整理资料四、实验步骤:、语法规则①<程序> {<变量定义语句><赋值语句><条件语句> <循环语句> }②<变量定义语句>变量{,变量};③<赋值语句>变量:<表达式>;④<表达式>标识符{运算符标识符};⑤<标识符>变量常量⑥<运算符> * > <⑦<条件语句><语句>[<语句>]⑧<语句> (表达式) [] {赋值语句条件语句循环语句}[]⑨<语句> [] {赋值语句条件语句循环语句} []⑩<循环语句>(表达式) [] {赋值语句条件语句循环语句} []<输出语句>表达式注:若语句、语句、循环语句中出现,后面的必须出现,即与同对出现注:、后的"(",")"表示终结符,而不是定义成分优先的说明符号、分析表:( ) : 变量常量,;运算符变量定义>②>②>②>②赋值语句>③>③>③>③ >③条件语句>⑦>⑦>⑦>⑦>⑦>⑦>⑦循环语句>⑩>⑩>⑩>⑩>⑩>⑩>⑩输出语句>>>分析表(续):变量定义>②赋值语句条件语句>⑦>⑦>⑦>⑦循环语句>⑩>⑩>⑩输出语句> 3、调试和测试五、源代码(见附录):六、实验总结:本实验在词法分析的基础上,对提取出的标识符进行语法判断。

语法分析器实验报告

语法分析器实验报告

词法分析器实验报告实验名称:语法分析器实验内容:利用LL(1)或LR(1)分析语句语法,判断其是否符合可识别语法。

学会根据状态变化、first、follow或归约转移思想构造状态分析表,利用堆栈对当前内容进行有效判断实验设计:1.实现功能可对一段包含加减乘除括号的赋值语句进行语法分析,其必须以$为终结符,语句间以;隔离,判断其是否符合语法规则,依次输出判断过程中所用到的产生式,并输出最终结论,若有错误可以报错并提示错误所在行数及原因2.实验步骤3.算法与数据结构a)LLtable:left记录产生式左端字符;right记录产生式右端字符;ln记录产生式右端字符长度Status:记录token分析情况Token:category,类型;value,具体内容b)根据LL(1)算法,手工构造分析表,并将内容用数组存储,便于查找c)先将当前语句的各token按序存储,当前处理语句最后一个token以#标记,作为输入流与产生式比较,堆栈中初始放入#,x,a为处理输入流中当前读头内容✓若top=a=‘#‘表示识别成功,退出分析程序✓若top=a!=‘#‘表示匹配,弹出栈顶符号,读头前进一个✓若top为i或n,但top!=a,出错,输出当前语句所在行,出错具体字符✓若top不为i或n,查预测分析表,若其中存放关于top产生式,则弹出top,将产生式右部自右向左压入栈内,输出该产生式,若其中没有产生式,出错,输出当前语句所在行,出错具体字符d)以;作为语句终结,每次遇到分号则处理之前语句并清空后预备下语句处理,当遇到$表示该段程序结束,停止继续处理4.分析表构造过程a)x->i=ee->e+t|e-t|tt->t*f|t/f|ff->(e)|i|nnote: i表示变量,n表示数字,!表示空串b)提取左公因子x->i=ee->ea|ta->+t|-tt->tb|fb->*f|/ff->(e)|i|nc)消除左递归x->i=ee->tcc->ac|!a->+t|-tt->fdd->bd|!b->*e|/ff->(e)|i|n5.类class parser{public:LLtable table[100][100]; //LL(1)表void scanner(); //扫描输入流中内容并分析parser(istream& in); //初始化,得到输入文件地址int getLine() const; //得到当前行数private:int match(); //分析语法stack <char> proStack; //分析堆栈void constructTable(); //建立LL(1)表int getRow(char ch); //取字符所在表中行int getCol(char ch); //取字符所在表中列istream* pstream; //输入流void insertToken(token& t); //插入当前tokenstatus getToken(token& t); //找到tokenint getChar(); //得到当前字符int peekChar(); //下一个字符void putBackChar(char ch); //将字符放回void skipChar(); //跳过当前字符void initialization(); //初始化堆栈等int line; //当前行数token tokens[1000]; //字符表int counter; //记录当前字符表使用范围}6.主要代码void parser::constructTable() //建立LL(1)表{for (int i=0;i<8;i++){for (int j=0;j<9;j++){table[i][j].left=' ';for (int k=0;k<3;k++)table[i][j].right[k]=' ';}}table[0][6].left='x';table[0][6].ln=3;table[0][6].right[0]='i';table[0][6].right[1]='=';table[0][6].right[2]='e';table[1][4].left='e';table[1][4].ln=2;table[1][4].right[0]='t';table[1][4].right[1]='c';table[1][6].left='e';table[1][6].ln=2;table[1][6].right[0]='t';table[1][6].right[1]='c';table[1][7].left='e';table[1][7].ln=2;table[1][7].right[0]='t';table[1][7].right[1]='c';table[2][0].left='c';table[2][0].ln=2;table[2][0].right[0]='a';table[2][0].right[1]='c';table[2][1].left='c';table[2][1].ln=2;table[2][1].right[0]='a';table[2][1].right[1]='c';table[2][5].left='c';table[2][5].ln=0;table[2][5].right[0]='!';table[2][8].left='c';table[2][8].ln=0;table[2][8].right[0]='!';table[3][0].left='a';table[3][0].ln=2;table[3][0].right[0]='+'; table[3][0].right[1]='t'; table[3][1].left='a';table[3][1].ln=2;table[3][1].right[0]='-'; table[3][1].right[1]='t'; table[4][4].left='t';table[4][4].ln=2;table[4][4].right[0]='f'; table[4][4].right[1]='d'; table[4][6].left='t';table[4][6].ln=2;table[4][6].right[0]='f'; table[4][6].right[1]='d'; table[4][7].left='t';table[4][7].ln=2;table[4][7].right[0]='f'; table[4][7].right[1]='d'; table[5][0].left='d';table[5][0].ln=0;table[5][0].right[0]='!'; table[5][1].left='d';table[5][1].ln=0;table[5][1].right[0]='!'; table[5][2].left='d';table[5][2].ln=2;table[5][2].right[0]='b'; table[5][2].right[1]='d'; table[5][3].left='d';table[5][3].ln=2;table[5][3].right[0]='b'; table[5][3].right[1]='d'; table[5][5].left='d';table[5][5].ln=0;table[5][5].right[0]='!'; table[5][8].left='d';table[5][8].ln=0;table[5][8].right[0]='!'; table[6][2].left='b';table[6][2].ln=2;table[6][2].right[0]='*'; table[6][2].right[1]='f'; table[6][3].left='b';table[6][3].ln=2;table[6][3].right[0]='/'; table[6][3].right[1]='f'; table[7][4].left='f';table[7][4].ln=3;table[7][4].right[0]='(';table[7][4].right[1]='e';table[7][4].right[2]=')';table[7][6].left='f';table[7][6].ln=1;table[7][6].right[0]='i';table[7][7].left='f';table[7][7].ln=1;table[7][7].right[0]='n';}int parser::match() //分析语法{ofstream ofs("out.txt",ios::app);char a;int i=0;for (int p=0;p<counter;p++){cout<<tokens[p].value;ofs<<tokens[p].value;}cout<<endl;ofs<<endl<<"ANALYSIS:"<<endl;while(1){if(tokens[i].category=='n' || tokens[i].category=='i')a=tokens[i].category;elsea=(tokens[i].value)[0];if(a==proStack.top()){if(a=='#'){cout<<"This is valid!"<<endl<<endl;ofs<<"This is valid!"<<endl<<endl;return 0;}else{proStack.pop();i++;}}else{if(proStack.top() =='n'|| proStack.top() =='i'){if(a!='#'){cout<<"ERROR(LINE "<<getLine()<<" ): "<<a<<" cannot be matched"<<endl;ofs<<"ERROR(LINE "<<getLine()<<" ): "<<a<<" cannot be matched"<<endl;}else{cout<<"ERROR(LINE "<<getLine()<<" ): Unexpected ending"<<endl;ofs<<"ERROR(LINE "<<getLine()<<" ): Unexpected ending"<<endl;}cout<<"This is invalid!"<<endl<<endl;ofs<<"This is invalid!"<<endl<<endl;return 0;}else{if((table[getRow(proStack.top())][getCol(a)]).left!=' '){char pst=proStack.top();int n=table[getRow(pst)][getCol(a)].ln;int k=0;ofs<<table[getRow(pst)][getCol(a)].left<<"->"<<table[getRow(pst)][getCol(a)].right[0]<<table[getRow(pst)][g etCol(a)].right[1]<<table[getRow(pst)][getCol(a)].right[2]<<endl;proStack.pop();while (n>0){//cout<<n<<" "<<table[getRow(pst)][getCol(a)].right[n-1]<<endl;proStack.push(table[getRow(pst)][getCol(a)].right[n-1]);n--;}}else{if(a!='#'){cout<<"ERROR(LINE "<<getLine()<<" ): "<<a<<" cannot be matched"<<endl;ofs<<"ERROR(LINE "<<getLine()<<" ): "<<a<<" cannot be matched"<<endl;}else{cout<<"ERROR(LINE "<<getLine()<<" ): Unexpected ending"<<endl;ofs<<"ERROR(LINE "<<getLine()<<" ): Unexpected ending"<<endl;}cout<<"This is invalid!"<<endl<<endl;ofs<<"This is invalid!"<<endl<<endl;return 0;}}}}}实验结果:●输入(in.txt)●输出1输出2(out.txt)实验总结:原本以为处理四则运算赋值将会很困难,但在使用LL(1)后发现,思路还是挺清晰简单的,但在实验过程中,由于LL(1)不能出现左递归和左公因子,不得不将其消除,原本简单的产生式一下变多了,而在产生式理解上也没有原来直观,不过其状态复杂度没有LR高,故仍选择该方法。

语法分析实验报告

语法分析实验报告

语法分析实验报告语法分析实验报告引言语法分析是自然语言处理中的一项重要任务,它旨在根据给定的语法规则和输入句子,确定句子的结构和语法成分,并进行语义解析。

本实验旨在探索语法分析的基本原理和方法,并通过实际操作来加深对其理解。

实验目标本实验的主要目标是实现一个简单的自底向上的语法分析器,即基于短语结构文法的分析器。

具体而言,我们将使用Python编程语言来实现一个基于CYK 算法的语法分析器,并对其进行评估和分析。

实验过程1. 语法规则的定义在开始实验之前,我们首先需要定义一个适当的语法规则集。

为了简化实验过程,我们选择了一个简单的文法,用于分析包含名词短语和动词短语的句子。

例如,我们定义了以下语法规则:S -> NP VPNP -> Det NVP -> V NP2. 实现CYK算法CYK算法是一种自底向上的语法分析算法,它基于动态规划的思想。

我们将使用Python编程语言来实现CYK算法,并根据定义的语法规则进行分析。

具体而言,我们将根据输入的句子和语法规则,构建一个二维的表格,用于存储句子中各个子串的语法成分。

通过填充表格并进行推导,我们可以确定句子的结构和语法成分。

3. 实验结果与分析我们使用几个示例句子来测试我们实现的语法分析器,并对其结果进行分析。

例如,对于句子"the cat eats fish",我们的语法分析器可以正确地识别出该句子的结构,并给出相应的语法成分。

具体而言,我们的分析器可以识别出句子的主语是"the cat",谓语是"eats",宾语是"fish"。

通过对多个句子的测试,我们可以发现我们实现的语法分析器在大多数情况下都能正确地分析句子的结构和语法成分。

然而,在一些复杂的句子中,我们的分析器可能会出现一些错误。

这可能是由于语法规则的不完备性或者算法的限制所致。

结论与展望通过本实验,我们深入了解了语法分析的基本原理和方法,并实现了一个简单的自底向上的语法分析器。

语法分析实验报告

语法分析实验报告

语法分析实验报告一: 实验内容:编写语法分析程序, 实现对算术表达式的语法分析, 要求所分析的算术表达式由如下的文法产生。

E->E+T|E-T|TT->T*F|T/F|FF->id|(E)|num二: 实验要求:在对表达式进行分析的同时, 输出所采用的产生式。

1.编写LL(1)语法分析程序, 要求:编程实现算法4.2, 为给定的文法自动构造预测分析表编程实现算法4.1, 构造LL(1)预测分析程序,2.编写语法分析程序, 实现自底向上的分析, 要求:构造识别所有活前缀的DFA构造LR分析表编程实现算法4.3, 构造LR分析程序1.三: 实验分析:2.方法二(编写LL(1)语法分析程序)1.步骤:(1)根据题目所给出的文法构造相应的无左递归文法, 并求出该文法各非终结符的FIRST、FOLLOW集合;(2)构造文法的LL(1)分析表;(3)由此构造LL分析程序。

2.实现方法:1.输入缓冲区为一个字符型数组, 读入输入的算术表达式并保存在此, 以’$’结束;2.为构造文法的LL(1)分析表, 构建一个相对应的字符串数组;3.在实际程序中P代表E', Q代表T', e代表ε,i代表id, n代表num;4.处理输入表达式中代表id和num的子串, 分别将它们转化为'i'和'n'进行分析;5.LL(1)预测分析程序的总控程序在任何时候都是按STACK栈顶符号X和当前的输入符号a做哪种过程的。

对于任何(X,a),总控程序每次都执行下述三种可能的动作之一:(1)若X = a =‘$’, 则宣布分析成功, 停止分析过程。

(2)若X = a!=‘$’, 则把X从STACK栈顶弹出, 让a指向下一个输入符号。

①如果是终结符合, 则栈不加入新符号②如果是非终结符合, 则把表达式右边入栈(3)若M[A, a]中存放着“出错标志”, 则调用出错诊断程序ERROR。

语法分析器设计实验报告

语法分析器设计实验报告

学号《编译原理》实验2:语法分析器设计学生姓名专业、班级指导教师赵璐成绩计算机与信息工程学院2018 年11 月27 日一、实验目的1.理解语法分析程序的功能。

2.熟悉语法分析程序的设计原理和构造方法。

3.掌握递归下降语法分析程序的构造方法。

4.设计一个递归下降的语法分析器,作为实验一构造的词法分析器的下一步编译工具,能语法分析前一步词法分析器输出的单词符号序列。

二、实验要求1.根据书P206给出的简单语言的语法规则,编写C或C++语言源程序,实现针对该简单语言的递归下降的语法分析器;2.独立做实验,输入、调试所编程序;3.实验结束后,根据实验报告模板编写实验报告。

三、实验内容和步骤用Visual C++作为实验开发环境,创建一个Win32 Console Application工程,工程名为你的学号,添加三个文件:(1)存储结构定义:以ParserDef.h和LexerDef.h为文件名;(2)基本操作的算法:以ParserAlgo.h和LexerAlgo.h为文件名;(3)调用基本操作的主程序:以ParserMain.cpp为文件名。

编写程序:(1)文件LexerDef.h和LexerAlgo.h为实验一的内容。

(2)文件ParserDef.h定义语法分析所需的全局变量等。

(3)文件ParserAlgo.h实现对语法规则中各语法成分的分析子算法。

(4)文件ParserMain.cpp实现针对P206简单语言语法规则的递归下降语法分析器。

源程序代码:=============================ParserDef.h================================ int kk;#define _KEY_WORD_END "waiting for your expanding"char * rwtab[]={"begin","if","then","while","do","end",_KEY_WORD_END};char input[255];char token[255]="";int p_input;int p_token;char ch;============================ParserAlgo.h================================ char prog[80];int syn,p,m,n,sum=0;void scaner() {m=0;for(n=0; n<8; n++) token[n]=NULL;ch=prog[p++];while(ch==' ') ch=prog[p++];if((ch>='a' && ch<='z') ||(ch>='A' && ch<='Z')) {while((ch>='a' && ch<='z') ||(ch>='A' && ch<='Z')||(ch>='0' && ch<='9')) {token[m++]=ch;ch=prog[p++];}token[m++]='\0';syn=10;p=p-1; //回退一个字符for(n=0; n<6; n++) {if(strcmp(token,rwtab[n])==0) {syn=n+1;break;}}} else if(ch>='0' && ch<='9') {sum=0;while(ch>='0' && ch<='9') {sum=sum*10+ch-'0';ch=prog[p++];}p=p-1;syn=11;} else {switch(ch) {case '<':m=0;token[m++]=ch;ch=prog[p];if(ch=='>') {syn=21;token[m++]=ch;} else if(ch=='=') {syn=22;token[m++]=ch;} else {syn=20;p=p-1;}p=p+1;token[m]='\0';break;case '>':m=0;token[m++]=ch;ch=prog[p++];if(ch=='=') {syn=24;token[m++]=ch;} else {syn=23;p=p-1;}break;case ':':m=0;token[m++]=ch;ch=prog[p++];if(ch=='=') {syn=18;token[m++]=ch;} else {syn=17;p=p-1;}break;case '+':syn=13;token[0]=ch;break;case '-':syn=14;token[0]=ch;break;case '*':syn=15;token[0]=ch;break;case '/':syn=16;token[0]=ch;break;case ';':syn=26;token[0]=ch;break;case '(':syn=27;token[0]=ch;break;case ')':syn=28;token[0]=ch;break;case '=':syn=25;token[0]=ch;break;case '#':syn=0;token[0]=ch;break;default:syn=-1;}}}============================ParserMain.cpp============================== #include<stdio.h>#include<stdlib.h>#include<string.h>#include"LexerDef.h"#include"ParserDef.h"#include"LexerAlgo.h"#include"ParserAlgo.h"void lrparser();void yucu();void statement();void expression();void term();void factor();void lrparser() {if (syn==1) { //beginscaner();yucu();if (syn==6) { //endscaner();if (syn==0 && kk==0) printf("success \n");} else {if(kk!=1) printf("error,lose 'end' ! \n");kk=1;}} else {printf("error,lose 'begin' ! \n");kk=1;}return;}void yucu() {statement();while(syn==26) {scaner();statement();}return;}void statement() {if (syn==10) { //为标识符scaner();if (syn==18) { //为:=scaner();expression();} else {printf("error!");kk=1;}} else {printf("error!");kk=1;}return;}void expression() {term();while(syn==13 || syn==14) {scaner();term();}return;}void term() {factor();while(syn==15 || syn==16) {scaner();factor();}return;}void factor() {if(syn==10 || syn==11)scaner(); //为标识符或整常数时,读下一个单词符号else if(syn==27) {scaner();expression();if(syn==28)scaner();else {printf(" ')' 错误\n");kk=1;}} else {printf("表达式错误\n");kk=1;}return;}void main() {p=0;printf("********************语法分析程序***************\n");printf("请输入源程序:\n");do {scanf("%c",&ch);prog[p++]=ch;} while(ch!='#');p=0;scaner();lrparser();printf("语法分析结束!\n");}四、解答下列问题(1)简述该语法分析器的算法思想。

语法分析器实验报告

语法分析器实验报告

语法分析器的设计实验报告一、实验内容语法分析程序用LL(1)语法分析方法。

首先输入定义好的文法书写文件(所用的文法可以用LL(1)分析),先求出所输入的文法的每个非终结符是否能推出空,再分别计算非终结符号的FIRST集合,每个非终结符号的FOLLOW集合,以及每个规则的SELECT集合,并判断任意一个非终结符号的任意两个规则的SELECT集的交集是不是都为空,如果是,则输入文法符合LL(1)文法,可以进行分析。

对于文法:G[E]:E->E+T|TT->T*F|FF->i|(E)分析句子i+i*i是否符合文法。

二、基本思想1、语法分析器实现语法分析是编译过程的核心部分,它的主要任务是按照程序的语法规则,从由词法分析输出的源程序符号串中识别出各类语法成分,同时进行词法检查,为语义分析和代码生成作准备。

这里采用自顶向下的LL(1)分析方法。

语法分析程序的流程图如图5-4所示。

语法分析程序流程图该程序可分为如下几步:(1)读入文法(2)判断正误(3)若无误,判断是否为LL(1)文法(4)若是,构造分析表;(5)由句型判别算法判断输入符号串是为该文法的句型。

三、核心思想该分析程序有15部分组成:(1)首先定义各种需要用到的常量和变量;(2)判断一个字符是否在指定字符串中;(3)读入一个文法;(4)将单个符号或符号串并入另一符号串;(5)求所有能直接推出&的符号;(6)求某一符号能否推出‘& ’;(7)判断读入的文法是否正确;(8)求单个符号的FIRST;(9)求各产生式右部的FIRST;(10)求各产生式左部的FOLLOW;(11)判断读入文法是否为一个LL(1)文法;(12)构造分析表M;(13)句型判别算法;(14)一个用户调用函数;(15)主函数;下面是其中几部分程序段的算法思想:1、求能推出空的非终结符集Ⅰ、实例中求直接推出空的empty集的算法描述如下:void emp(char c){ 参数c为空符号char temp[10];定义临时数组int i;for(i=0;i<=count-1;i++)从文法的第一个产生式开始查找{if 产生式右部第一个符号是空符号并且右部长度为1,then将该条产生式左部符号保存在临时数组temp中将临时数组中的元素合并到记录可推出&符号的数组empty中。

词法分析、语法分析、语义分析实例解析及实验报告

词法分析、语法分析、语义分析实例解析及实验报告

词法分析一、实验目的设计、编制并调试一个词法分析程序,加深对词法分析原理的理解。

二、实验要求2.1 待分析的简单的词法(1)关键字:begin if then while do end所有的关键字都是小写。

(2)运算符和界符:= + - * / < <= <> > >= = ; ( ) #(3)其他单词是标识符(ID)和整型常数(SUM),通过以下正规式定义:ID = letter (letter | digit)*NUM = digit digit*(4)空格有空白、制表符和换行符组成。

空格一般用来分隔ID、SUM、运算符、界符和关键字,词法分析阶段通常被忽略。

2.2 各种单词符号对应的种别码:输入:所给文法的源程序字符串。

输出:二元组(syn,token或sum)构成的序列。

其中:syn为单词种别码;token为存放的单词自身字符串;sum为整型常数。

例如:对源程序begin x:=9: if x>9 then x:=2*x+1/3; end #的源文件,经过词法分析后输出如下序列:(1,begin)(10,x)(18,:=)(11,9)(26,;)(2,if)……标识符(需进一步判断是否为关键字)数字+=+-=-词法分析状态转换图(终结状态右上角*表示多读一个符号)三、词法分析程序的算法思想:算法的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号,其基本思想是根据扫描到单词符号的第一个字符的种类,拼出相应的单词符号。

3.1 主程序示意图:主程序示意图如图3-1所示。

其中初始包括以下两个方面: ⑴ 关键字表的初值。

关键字作为特殊标识符处理,把它们预先安排在一张表格中(称为关键字表),当扫描程序识别出标识符时,查关键字表。

如能查到匹配的单词,则该单词为关键字,否则为一般标识符。

关键字表为一个字符串数组,其描述如下:Char *rwtab[6] = {“begin ”, “if ”, “then ”, “while ”, “do ”, “end ”,};图3-1(2)程序中需要用到的主要变量为syn,token 和sum 3.2 扫描子程序的算法思想:首先设置3个变量:①token 用来存放构成单词符号的字符串;②sum 用来存放整型单词;③syn 用来存放单词符号的种别码。

语法分析实验报告

语法分析实验报告

一、实验目的1. 了解语法分析的基本概念和原理。

2. 掌握语法分析的方法和步骤。

3. 提高对自然语言处理领域中语法分析技术的理解和应用能力。

二、实验内容1. 语法分析的基本概念语法分析是指对自然语言进行结构分析,将句子分解成词、短语和句子成分的过程。

通过语法分析,可以了解句子的结构、语义和语用信息。

2. 语法分析方法语法分析方法主要有两种:句法分析和语义分析。

(1)句法分析:句法分析是指根据语法规则,对句子进行分解和组合的过程。

常见的句法分析方法有:词法分析、短语结构分析、句法分析。

(2)语义分析:语义分析是指对句子进行分析,以揭示句子所表达的意义。

常见的语义分析方法有:词汇语义分析、句法语义分析、语用语义分析。

3. 语法分析步骤(1)词法分析:将句子中的单词进行分类,提取词性、词义和词形变化等特征。

(2)短语结构分析:将词法分析得到的词组进行分类,提取短语结构、短语成分和短语关系等特征。

(3)句法分析:根据短语结构分析的结果,将句子分解成句子成分,分析句子成分之间的关系。

(4)语义分析:根据句法分析的结果,分析句子所表达的意义。

三、实验过程1. 实验环境:Python 3.8,NLTK(自然语言处理工具包)。

2. 实验步骤:(1)导入NLTK库。

(2)加载句子数据。

(3)进行词法分析,提取词性、词义和词形变化等特征。

(4)进行短语结构分析,提取短语结构、短语成分和短语关系等特征。

(5)进行句法分析,分解句子成分,分析句子成分之间的关系。

(6)进行语义分析,揭示句子所表达的意义。

四、实验结果与分析1. 词法分析结果实验句子:“我喜欢吃苹果。

”词性标注:我/代词,喜欢/动词,吃/动词,苹果/名词。

2. 短语结构分析结果实验句子:“我喜欢吃苹果。

”短语结构:主语短语(我),谓语短语(喜欢吃苹果)。

3. 句法分析结果实验句子:“我喜欢吃苹果。

”句子成分:主语(我),谓语(喜欢),宾语(吃苹果)。

4. 语义分析结果实验句子:“我喜欢吃苹果。

编译原理算符优先算法语法分析实验报告

编译原理算符优先算法语法分析实验报告

编译原理算符优先算法语法分析实验报告实验报告:算符优先算法的语法分析一、实验目的本次实验旨在通过算符优先算法对给定的文法进行语法分析,实现对给定输入串的分析过程。

通过本次实验,我们能够了解算符优先算法的原理和实现方式,提升对编译原理的理解和应用能力。

二、实验内容1.完成对给定文法的定义和构造2.构造算符优先表3.实现算符优先分析程序三、实验原理算符优先算法是一种自底向上的语法分析方法,通过构造算符优先表来辅助分析过程。

算符优先表主要由终结符、非终结符和算符优先关系组成,其中算符优先关系用1表示优先关系,用2表示不优先关系,用0表示无关系。

算符优先分析程序的基本思路是:根据算符优先关系,依次将输入串的符号压栈,同时根据优先关系对栈内符号进行规约操作,最终判断输入串是否属于给定文法。

四、实验步骤1.定义和构造文法在本次实验中,我们假设给定文法如下:1)E->E+T,T2)T->T*F,F3)F->(E),i2.构造算符优先表根据给定文法,构造算符优先表如下:+*()i#+212112*222112(111012222122i222222#1112203.实现算符优先分析程序我们可以用C语言编写算符优先分析程序,以下是程序的基本框架:```c#include <stdio.h>//判断是否为终结符int isTerminal(char c)//判断条件//匹配符号int match(char stack, char input)//根据算符优先关系表进行匹配//算符优先分析程序void operatorPrecedence(char inputString[]) //定义栈char stack[MAX_SIZE];//初始化栈//将#和起始符号入栈//读入输入串//初始化索引指针//循环分析输入串while (index <= inputLength)//判断栈顶和输入符号的优先关系if (match(stack[top], inputString[index])) //栈顶符号规约} else//符号入栈}//计算新的栈顶}//判断是否成功分析if (stack[top] == '#' && inputString[index] == '#')printf("输入串符合给定文法!\n");} elseprintf("输入串不符合给定文法!\n");}```五、实验结果经过实验,我们成功实现了算符优先算法的语法分析。

编译原理——语法分析程序设计实验报告

编译原理——语法分析程序设计实验报告

实验二语法分析程序设计[实验目的]:1.了解语法分析的主要任务。

2.熟悉编译程序的编制。

[实验内容]:根据某文法,构造一基本递归下降语法分析程序。

给出分析过程中所用的产生式序列。

[实验要求]:1.选择一个文法,进行实验,可选的文法包括以下三个:P190 4.8P190 4.9P190 4.102.设计语法分析程序的输出形式(输出应为语法树或推导),一个可以参考的例子,可见图1。

3.编写递归下降语法分析程序(参考P148-149 Topdown parsing byrecursive-descent),实现基本的递归下降分析器,能够分析任给的符号串是否为该文法所定义的合法句子。

实验报告中要说明分析使用的方法。

4.根据所作业题选项e所给出的input,生成并输出分析过程中所用的产生式序列(show the actions of parser):1 产生式12 产生式2……5.自已设计一个不合法的句子,作为输出进行分析,给出结果。

[实验过程]本次实验选择的文法为P190 4.8lexp->atom|listatom->number|identifierlist->(lexp-seq)lexp-seq->lexp lexp-seq1.写出实现的算法,并画流程图。

本次实验采用递归下降算法,算法流程图如下图1-1:图1-1 算法流程图2.根据你选择的文法,分析左递归或左因子是否会影响本算法的结果。

会影响本算法的结果。

递归下降分析法要求的文法是LL(1)文法,需要消除左递归和左因子的影响。

如果存在左因子,对相同的字符跳转到不同的函数,无法实现递归。

3.列举实验设计过程中出现的问题及解决的方法(至少3条,选择实验中最困扰的问题)。

1).会多次输出accept/error结果解决方案:所有的递归函数返回类型为int,若accept返回1,error返回0,在main主函数中统一判断输出语句。

语法分析实验报告(实验二)

语法分析实验报告(实验二)

编译原理语法分析实验报告软工082班兰洁4一、实验容二、实验目的三、实验要求四、程序流程图●主函数;●scanner();●irparser()函数●yucu() /*语句串分析*/●statement()/*语句分析函数*/●expression()/*表达式分析函数*/●term()/*项分析函数*/●factor()/*因子分析函数*/五、程序代码六、测试用例七、输出结果八、实验心得一、实验容:编写为一上下文无关文法构造其递归下降语法分析程序,并对任给的一个输入串进行语法分析检查。

程序要求能对输入串进行递归下降语法分析,能判别程序是否符合已知的语法规则,如果不符合(编译出错),则输出错误信息。

二、实验目的:构造文法的语法分析程序,要求采用递归下降语法分析方法对输入的字符串进行语法分析,实现对词法分析程序所提供的单词序列的语法检查和结构分析,进一步掌握递归下降的语法分析方法。

三、实验要求:利用C语言编制递归下降分析程序,并对Training语言进行语法分析。

1.待分析的Training语言语法。

用扩充的表示如下:<程序>-->function<语句串>endfunc<语句串>--><语句>{;<语句>}<语句>→<赋值语句><赋值语句>→ID→<表达式><表达式>→<项>{+<项>|-<项>}<项>→<因子>{*<因子>|/<因子>}<因子>→ID|NUM|(<表达式>)备注:实验当中我对程序进行了扩展,增加了程序识别if条件判断语句,while循环语句的功能2.实验要求说明输入单词串以“#”结束,如果是文确的句子,则输出成功信息,打印“success”,否则输出“error”。

语法分析器实验报告

语法分析器实验报告

杭州电子科技大学班级: 12052312 专业: 计算机科学与技术实验报告【实验名称】实验二语法分析一. 实验目的编写一个语法分析程序, 实现对词法分析程序所提供的单词序列的语法检查和结构分析。

二. 实验内容利用编程语言实现语法分析程序, 并对简单语言进行语法分析。

2.1 待分析的简单语言的语法用扩充的BNF表示如下:⑴<程序>: : =begin<语句串>end⑵<语句串>: : =<语句>{;<语句>}⑶<语句>: : =<赋值语句>⑷<赋值语句>: : =ID: =<表达式>⑸<表达式>: : =<项>{+<项> | -<项>}⑹<项>: : =<因子>{*<因子> | /<因子>⑺<因子>: : =ID | NUM | (<表达式>)2.2 实验要求说明输入单词串, 以“#”结束, 如果是文法正确的句子, 则输出成功信息, 打印“success”, 否则输出“error”。

例如:输入begin a:=9; x:=2*3; b:=a+x end #输出success!输入x:=a+b*c end #输出error测试以上输入的分析, 并完成实验报告。

2.3 语法分析程序的算法思想(1)主程序示意图如图2-1所示。

图2-1 语法分析主程序示意图(2)递归下降分析程序示意图如图2-2所示。

(3)语句串分析过程示意图如图2-3所示。

图2-3 语句串分析示意图图2-2 递归下降分析程序示意图(4)statement 语句分析程序流程如图2-4.2-5.2-6.2-7所示。

图2-4 statement 语句分析函数示意图 图2-5 expression 表达式分析函数示意图图2-7 factor 分析过程示意图三.个人心得一、 通过该实验, 主要有以下几方面收获: 二、 对实验原理有更深的理解。

LR分析——精选推荐

LR分析——精选推荐

LR分析LR(1)语法分析实验报告⼀、实验需求:构造LR(1)分析程序,利⽤它进⾏语法分析,判断给出的符号串是否为该⽂法识别的句⼦。

⼆、实验预习:1、设计思想:为了使⼀个⽂法是LR的,只要保证当句柄出现在栈顶时,⾃左向右扫描的移进-归约分析器能够及时识别它便⾜够了。

当句柄出现在栈顶时,LR分析器必须要扫描整个栈就可以知道这⼀点,栈顶的状态符号包含了所需要的⼀切信息。

如果仅知道栈内的⽂法符号就能确定栈顶是什么句柄。

LR分析表的转移函数本质上就是这样的有限⾃动机。

不过,这个有限⾃动机不需要根据每步动作读栈,因为,如果这个识别句柄的有限⾃动机⾃底向上读栈中的⽂法符号的话,它达到的状态正是这时栈顶的状态符号所表⽰的状态,所以,LR分析器可以从栈顶的状态确定它需要从栈中了解的⼀切。

2、LR分析器组成:(1)总控程序,也可以称为驱动程序。

对所有的LR分析器总控程序都是相同的。

(2)分析表或分析函数,不同的⽂法分析表将不同,同⼀个⽂法采⽤的LR分析器不同时,分析表将不同,分析表⼜可以分为动作表(ACTION)和状态转换(GOTO)表两个部分,它们都可⽤⼆维数组表⽰。

(3)分析栈,包括⽂法符号栈和相应的状态栈,它们均是先进后出栈。

分析器的动作就是由栈顶状态和当前输⼊符号所决定。

程序输⼊/输出⽰例:对下列⽂法,⽤LR(1)分析法对任意输⼊的符号串进⾏分析:(1)E->E+T(2)E->E—T(3)T->T*F(4)T->T/F(5)F->(E)(6)F->i输出结果:主要源程序代码及注释#include#include#include#define NVT 8#define NVN 3#define NLR 9char *action[16][8]={"s4",NULL,NULL,NULL,NULL,"s5",NULL,NULL,//ACTION表NULL,"s6","s7",NULL,NULL,NULL,NULL,"acc",NULL,"r3","r3","s8","s9",NULL,"r3","r3",NULL,"r6","r6","r6","r6",NULL,"r6","r6",NULL,"r8","r8","r8","r8",NULL,"r8","r8","s4",NULL,NULL,NULL,NULL,NULL,NULL,NULL,"s4",NULL,NULL,NULL,NULL,"s5",NULL,NULL,"s4",NULL,NULL,NULL,NULL,"s5",NULL,NULL,"s4",NULL,NULL,"s10",NULL,"s5",NULL,NULL,"s4",NULL,NULL,NULL,"s13","s5",NULL,NULL,NULL,"r4","r4","r4","r4",NULL,"r4","r4",NULL,"r1","r1","s8","s9",NULL,"r1","r1",NULL,"r2","r2","s8","s9",NULL,"r2","r2",NULL,"r5","r5","r5","r5",NULL,"r5","r5",NULL,"s6","s7",NULL,NULL,NULL,"s15",NULL,NULL,"r7","r7","r7","r7",NULL,"r7","r7"};int goto1[16][3]={1,2,3, /*GOTO表*/0,0,0,0,0,0,0,0,0,0,0,0,14,2,3,0,11,3,0,12,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};char vt[NVT]={'i','+','-','*','/','(',')','#'}; /*存放终结符*/char vn[NVN]={'E','T','F'}; /*存放⾮终结符*/char *LR[NLR]={"S->E","E->E+T","E->E-T","E->T","T->T*F","T->T/F","T->F","F->(E)","F->i"};/*存放产⽣式*/ int a[16];//状态栈char b[16],c[16],c1;//符号栈,输⼊栈void main(){int top1,top2,top3,top;int i,j,k,y,z,count,m;char x,copy[4],copy1[7];top1=0;//状态栈栈顶top2=0;//符号栈栈顶top3=0;//输⼊栈栈顶top=0;//⽬前输⼊串的位置a[0]=0;y=a[0];b[0]='#';count=0;z=0;printf("请输⼊表达式\n");scanf("%c",&c1);c[top3]=c1;top3=top3+1;}while(c1!='#');printf("步骤\t状态栈\t\t符号栈\t\t输⼊串\t\tACTION\tGOTO\n"); do{ y=z;m=0; /*y,z指向状态栈栈顶*/j=0;k=0;x=c[top];count++;printf("%d\t",count);while(m<=top1){ /*输出状态栈*/printf("%d",a[m]);m=m+1;}printf("\t\t");m=0;while(m<=top2){ /*输出符号栈*/printf("%c",b[m]);m=m+1;}printf("\t\t");m=top;while(m<=top3){ /*输出输⼊串*/printf("%c",c[m]);m=m+1;}printf("\t\t");while(x!=vt[j]&&jj++;if(j==NVT&&x!=vt[j]){printf("\n输⼊字符串不是由终结符组成\n"); system("pause");return;}if(action[y][j]==NULL)printf("error\n");system("pause");return;}elsestrcpy(copy,action[y][j]);if(copy[0]=='s'){ /*处理移进*/if(copy[2]!='\0')z=(copy[1]-'0')*10+copy[2]-'0';elsez=copy[1]-'0';top1=top1+1;top2=top2+1;a[top1]=z;b[top2]=x;top=top+1;i=0;while(copy[i]!='\0'){printf("%c",copy[i]);i++;}printf("\n");}if(copy[0]=='r'){ /*处理归约*/i=0;while(copy[i]!='\0'){printf("%c",copy[i]);i++;}strcpy(copy1,LR[copy[1]-'0']); while(copy1[0]!=vn[k])k++;top1=top1-(strlen(LR[copy[1]-'0'])-4); top2=top2-(strlen(LR[copy[1]-'0'])-4); y=a[top1-1];a[top1]=goto1[y][k];b[top2]=copy1[0];z=goto1[y][k];printf("\t");printf("%d\n",goto1[y][k]);}}while(action[y][j]!="acc");printf("acc\n");system("pause");}。

北邮编译原理实验 LR语法分析 实验报告

北邮编译原理实验  LR语法分析 实验报告

LR语法分析实验报告班级:2010211308 姓名:杨娜学号:10211369一.题目:LR语法分析程序的设计与实现二.设计目的:(1)了解语法分析器的生成工具和编译器的设计。

(2)了解自上而下语法分析器的构造过程。

(3). 理解和掌握LR语法分析方法的基本原理;根据给出的LR)文法,掌握LR分析表的构造及分析过程的实现。

(4)掌握预测分析程序如何使用分析表和栈联合控制实现LR分析。

三.实验内容:编写语法分析程序,实现对算术表达式的语法分析,要求所分析算数表达式由如下的文法产生:E->E+T|E-T|TT->T/F|T*F|FF->i|n|(E)四.实验要求:编写LR语法分析程序,要求如下:(1)构造识别所有活动的DFA(2)构造LR分析表(3)编程实现算法4.3,构造LR分析程序五.算法流程分析程序可分为如下几步:六.算法设计1.数据结构s :文法开始符号line :产生式的个数G[i][0] :产生式的标号Vt[] :终结符Vn[] :非终结符id :项目集编号Prjt *next :指示下一个项目集Prjt[]:存储项目的编号,prjt[0]项目编号的个数Pointafter[] :圆点后的字符,pointafter[0]为字符个数Prjset*actorgo[]:存储出度Pointbefore:圆点前面的字符Form:动态数组下标,同时作为符号的编号Vn[] :非终结符序列Vt[]:终结符序列2.LR分析器由三个部分组成(1)总控程序,也可以称为驱动程序。

对所有的LR分析器总控程序都是相同的。

(2)分析表或分析函数,不同的文法分析表将不同,同一个文法采用的LR分析器不同时,分析表将不同,分析表又可以分为动作表(ACTION)和状态转换(GOTO)表两个部分,它们都可用二维数组表示。

(3)分析栈,包括文法符号栈和相应的状态栈,它们均是先进后出栈。

分析器的动作就是由栈顶状态和当前输入符号所决定。

语法分析

语法分析

实验二语法分析一、实验目的:通过本实验理解语法分析的作用,分析对象、分析的方式和处理的结果,是重点内容。

二、实验学时:6学时。

三、实验内容根据给出的简单语言的语法构成规则(见五),编制语法分析程序,要求能将词法分析输出的单词文件用给定的语法规则书写的源程序进行语法分析,输出相应的语法分析结果和错误信息。

关于错误信息:不要求错误种类,可以只给出出错位置。

四、实验方法使用LL(1)分析法,或LR分析法实现。

要先构造分析表再编写程序实现。

五、文法定义简单的表达式文法如下:E->E+T|E-T|TT->T*F|T/F|FF->(E)|i、六、处理程序例例1: 正确源程序例:i+(i+i)*i-i例2: 错误源程序例:i+(i+)-i附录、实验报告格式:编译原理实验报告一、实验内容和程序名称实验内容:根据给出的简单语言的语法构成规则(见五),编制语法分析程序,要求能将词法分析输出的单词文件用给定的语法规则书写的源程序进行语法分析,输出相应的语法分析结果和错误信息。

关于错误信息:不要求错误种类,可以只给出出错位置。

程序名称:grammarAnalysis.cpp 二、主要方法说明scanner()函数: 读入一个单词符号 judge()函数: 进行语法分析 三、你的程序的使用手册介绍如何使用你的程序和结果样式,要求的使用环境等。

1.图2-1 语法分析主程序示意图2. judge()函数结构分析示意图如下:(2)递归下降分析程序示意图如图2-2所示。

(3)语句串分析过程示意图如图2-3所示。

否图2-3 语句串分析示意图图2-2 递归下降分析程序示意图(4)ZF语句分析程序流程如图2-4、2-5、2-6、2-7所示。

图2-4 ZF语句分析函数示意图图2-5 JJ表达式分析函数示意图否 否是是否否是图 2-6 CC 分析函数示意图否 是图2-7 ZS 分析过程示意图3. 运行结果是否整常数?是否(?调用scanner调用JJ 函数是否)?调用调用scanner出错处理四、实验过程分析实验过程中发生的问题分析,解决过程及方法。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
《编译原理》 实验报告 编译原理》
2008 年 11 月 20 日 姓名 课程 名称 孙丽君 编译原理 班 级 实验项目 名 称 06 行知计算 机网络技术 语法分析 学 号 指导教师 06202135 郑豪
一、实验目的: 实验目的:
编制一个递归下降分析程序,实现对词法分析程序所提供的单词序列的语法检查和结构分析。 编制一个递归下降分析程序 实现对词法分析程序所提供的单词序列的语法检查和结构分析。 实现对词法分析程序所提供的单词序列的语法检查和结构分析 语言编制递归下降分析程序,并对简单语言进行语法分析 并对简单语言进行语法分析。 利用 C 语言编制递归下降分析程序 并对简单语言进行语法分析。
语句串分析过程示意图如图C 5所示。 (3) 语句串分析过程示意图如图C.5所示。 语句分析函数流程如图C 所示。 (4) statement 语句分析函数流程如图C.6. C.7. C.8 C.9 所示。
否 是否begin? 是 调用scaner
调用语句串分析函数
是否end? 是 调用scaner 否
二、实验原理(可以流程图的形式出现,加以文字说明) 实验原理(可以流程图的形式出现,加以文字说明)
1.待分析的简单语言的语法 . 2.用扩充的 BNF 表示如下: . 表示如下: (1)<程序 : 程序>: :=begin<语句串 语句串>end 程序 := 语句串 (2)<语句串 : 语句串>: :=<语句 语句>{; 语句 语句>} 语句串 := 语句 ;<语句 (3)<语句 : 语句>: :=<赋值语句 赋值语句> 语句 := 赋值语句 (4)<赋值语句 : 赋值语句>: :=ID:= 表达式> :=<表达式 赋值语句 := := 表达式 (5)<表达式 : 表达式>: :=<项 {+ {+<项 表达式 := 项>{+ 项> | —项>} } (6)<项>: 项 : :=<因子 := 因子>{*<因子 | /<因子 因子> 因子>} 因子 因子 因子 (7)<因子 : 因子>: :=ID 表达式>) 因子 := | NUM | (<表达式 表达式 3.实验要求说明 . 输入单词串, 输入单词串,以“#”结束,如果是文法正确的句子,则输出成功信息,打印“success”,否则输 结束,如果是文法正确的句子,则输出成功信息,打印“ ” 否则输 出“error” ” 。 例如: 例如:
出错处理
图 c.6statement 语句分析函数示意图
调用 term 函数
否 是否+,-? 是 调用 scaner 出错处理
调用 term 函数 图 c.7 expression 表达式分析函数示意图
调用 factor 函数
否 是否*,/?
是 调用 scaner 出错处理
调用 factor 函数
syn=0&&kk=0? 是 打印分析成功
出错处理
图 c.4 递归下降分析程序示意图
调用statement函数 否
是否;? 是 调用scaner
调用statement函数
出错处理
图 c.5 语句串分析示意图
是否标识?
是 调用 scaner
否 是否:=? 是 调用 scaner
调用 expression 函数
置初值 调用scaner读下一个单词符号 调用lrParser 结束
语法分析主程序示意图 图 c.3 语法分析主程序示意图 输入 begin a:=9;x:=2*3;b:=a+x end # 输出 success 输入 x:=a+b*c 输出 error 4.语法分析程序的算法思想 . 主程序示意图如图C 3所示。 (1) 主程序示意图如图C.3所示。 递归下降分析程序示意图如图C 4所示。 (2) 递归下降分析程序示意图如图C.4所示。 end #
四、实验过程原始记录(数据、图表、计算等) 实验过程原始记录(数据、图表、计算等)
输入 begin a:=9;x:=2*3;b:=a+x end # 输出 success
输入 x:=a+b*c 输出 error
end #
五、实验结果及分析,以及心得体会 实验结果及分析,
通过学习了语法分析,再经过实验,让我对语法分析有了深刻的认识和了解。递归下降分析法,是 一种确定的自顶向下分析技术,它的实现思想是,对文法中分别代表一种语法成分的每个非终结符号编写 一个子程序,已完成非终结符号所对应的语法成分的分析任务。在分析过程中调用一系列过程或函数,对 源程序进行语法语义分析直到整个程序处理结束。
1. 语法分析的主程序 void main()
{p=0; printf("********************语 printf("********************语 printf("请输 printf("请输 do { scanf("%c",&ch); prog[p++]=ch; }while(ch!='#'); p=0; scaner(); lrparser(); printf("语 printf("语 } 2. { if (syn==1) //begin { scaner(); yucu(); if (syn==6) { scaner(); if (syn==0 && kk==0) printf("success \n"); } else { if(kk!=1) printf("error,lose 'end' ! \n"); kk=1; } } else { printf("error,lose 'begin' ! \n"); kk=1; } return; } void yucu() { statement(); while(syn==26) //; { scaner(); statement(); //end 编写扫 void lrparser() 结 !\n"); :\n"); ***************\ ***************\n");
图 c.8term 分析函数示意图
是否标识符?

是否整常数 否 否 是否? 是 调用scaner 调用expression函数 否 是否)? 是 出错处理 调用图 c.9factor 分析过程示意图
三、实验步骤
(介绍关键的步骤,至少 10 步,并简要说明其工作原理) 介绍关键的步骤, 并简要说明其工作原理)
} return; } void statement() { if (syn==10) { scaner(); if (syn==18) { scaner(); expression(); } else { printf("error!"); kk=1; } } else { printf("error!"); kk=1; } return; } void expression() { term(); while(syn==13 || syn==14) { scaner(); term(); } return; } void term() { factor(); while(syn==15 || syn==16) { scaner(); factor(); }
return; } void factor() { if(syn==10 || syn==11) else if(syn==27) { scaner(); expression(); if(syn==28) } 错误\ else { printf(" 达 错误\n"); kk=1;} return;} 3.调试程序,验证实验结果。 3.调试程序,验证实验结果。 调试程序 scaner(); 错误\ else {printf(" ')' 错误\n"); kk=1;} //为标识 scaner(); //为标识 数时, 数时,读 个单词 号

师 评



指 导 教 师 评 语
成 绩
指导教师 年 月 日
相关文档
最新文档