语法分析程序实验报告及代码

编译原理语法分析试验报告语法分析是编译原理中的重要内容之一，主要用于对源程序进行语法检查，判断其是否符合给定的语法规则。

本次试验通过使用ANTLR工具，对C语言的子集进行了语法分析的实现。

一、实验目的：1.了解语法分析的基本概念和方法；2.使用ANTLR工具生成语法分析器；3.掌握ANTLR工具的基本使用方法；4.实现对C语言子集的语法分析。

二、实验内容：本次试验主要内容是使用ANTLR工具生成C语言子集的语法分析器，并对给定的C语言子集进行语法分析。

三、实验步骤：1.学习ANTLR工具的基本概念和使用方法；2.根据C语言子集的语法规则，编写ANTLR的语法文件（.g文件）；3.使用ANTLR工具生成语法分析器；4.编写测试代码，对给定的C语言子集进行语法分析。

四、实验结果：经过以上的步骤，得到了一个完整的C语言子集的语法分析器，并且通过测试代码对给定的C语言子集进行了语法分析。

五、实验总结：通过本次实验，我对语法分析有了更深入的了解，掌握了使用ANTLR工具生成语法分析器的基本方法，同时也巩固了对C语言的基本语法规则的理解。

在实验过程中，遇到了一些问题，例如在编写ANTLR的语法文件时，对一些特殊语法规则的处理上有些困惑，但通过查阅资料和与同学的探讨，最终解决了这些问题。

本次试验对于我的学习有很大的帮助，我了解到了编译原理中的重要内容之一，也更深入地理解了语法分析的基本原理和方法。

通过实验，我发现使用ANTLR工具能够更方便地生成语法分析器，大大提高了开发效率。

总之，本次试验让我对编译原理中的语法分析有了更深入的了解，并且提高了我的编程能力和分析问题的能力。

在今后的学习和工作中，我将继续深入研究编译原理相关的知识，并应用到实际项目中。

编译原理语法分析实验报告第一篇：编译原理语法分析实验报告实验2：语法分析1.实验题目和要求题目：语法分析程序的设计与实现。

实验内容：编写语法分析程序，实现对算术表达式的语法分析。

要求所分析算术表达式由如下的文法产生。

E→E+T|E-T|TT→T*F|T/F|F F→id|(E)|num实验要求：在对输入表达式进行分析的过程中，输出所采用的产生式。

方法1：编写递归调用程序实现自顶向下的分析。

方法2：编写LL(1)语法分析程序，要求如下。

(1)编程实现算法4.2，为给定文法自动构造预测分析表。

(2)编程实现算法4.1，构造LL(1)预测分析程序。

方法3：编写语法分析程序实现自底向上的分析，要求如下。

(1)构造识别所有活前缀的DFA。

(2)构造LR分析表。

(3)编程实现算法4.3，构造LR分析程序。

方法4：利用YACC自动生成语法分析程序，调用LEX自动生成的词法分析程序。

实现（采用方法1）1.1.步骤：1)对文法消除左递归E→TE'E'→+TE'|-TE'|εT→FT'T'→*FT'|/FT'|εF→id|(E)|num2)画出状态转换图化简得：3)源程序在程序中I表示id N表示num1.2.例子：a)例子1 输入:I+(N*N)输出：b)例子2 输入：I-NN 输出：第二篇：编译原理实验报告编译原理实验报告报告完成日期 2018.5.30一．组内分工与贡献介绍二．系统功能概述；我们使用了自动生成系统来完成我们的实验内容。

我们设计的系统在完成了实验基本要求的前提下，进行了一部分的扩展。

增加了声明变量类型、类型赋值判定和声明的变量被引用时作用域的判断。

从而使得我们的实验结果呈现的更加清晰和易懂。

三．分系统报告；一、词法分析子系统词法的正规式：标识符(|)* 十进制整数0 |(1|2|3|4|5|6|7|8|9)(0|1|2|3|4|5|6|7|8|9)* 八进制整数0(1|2|3|4|5|6|7)(0|1|2|3|4|5|6|7)* 十六进制整数0x(0|1|2|3|4|5|6|7|8|9|a|b|c|d|e|f)(0|1|2|3|4|5|6|7|8|9|a|b|c|d|e|f)* 运算符和分隔符 +| * | / | > | < | = |(|)| <=|>=|==；对于标识符和关键字: A5—〉 B5C5 B5—〉a | b |⋯⋯| y | z C5—〉(a | b |⋯⋯| y | z |0|1|2|3|4|5|6|7|8|9)C5|ε综上正规文法为: S—〉I1|I2|I3|A4|A5 I1—〉0|A1 A1—〉B1C1|ε C1—〉E1D1|ε D1—〉E1C1|εE1—〉0|1|2|3|4|5|6|7|8|9 B1—〉1|2|3|4|5|6|7|8|9 I2—〉0A2 A2—〉0|B2 B2—〉C2D2 D2—〉F2E2|ε E2—〉F2D2|εC2—〉1|2|3|4|5|6|7 F2—〉0|1|2|3|4|5|6|7 I3—〉0xA3 A3—〉B3C3 B3—〉0|1|2|3|4|5|6|7|8|9|a|b|c|d|e|f C3—〉(0|1|2|3|4|5|6|7|8|9|a|b|c|d|e|f)|C3|εA4—〉+ |-| * | / | > | < | = |(|)| <=|>=|==； A5—〉 B5C5 B5—〉a | b |⋯⋯| y | z C5—〉(a | b |⋯⋯| y | z |0|1|2|3|4|5|6|7|8|9)C5|ε状态图流程图：词法分析程序的主要数据结构与算法考虑到报告的整洁性和整体观感，此处我们仅展示主要的程序代码和算法，具体的全部代码将在整体的压缩包中一并呈现另外我们考虑到后续实验中，如果在bison语法树生成的时候推不出目标的产生式时，我们设计了报错提示，在这个词的位置出现错误提示，将记录切割出来的词在code.txt中保存，并记录他们的位置。

语法分析一、实验目的编制一个递归下降分析程序，实现对词法分析程序所提供的单词序列的语法检查和结构分析。

二、实验要求利用C语言编制递归下降分析程序，并对简单语言进行语法分析。

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 #输出error2.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分析过程示意图三、语法分析程序的C语言程序源代码：#include "stdio.h"#include "string.h"char prog[100],token[8],ch;char *rwtab[6]={"begin","if","then","while","do","end"};int syn,p,m,n,sum;int kk;factor();expression();yucu();term();statement();lrparser();scaner();main(){p=kk=0;printf("\nplease input a string (end with '#'): \n");do{ scanf("%c",&ch);prog[p++]=ch;}while(ch!='#');p=0;scaner();lrparser();getch();}lrparser(){if(syn==1){scaner(); /*读下一个单词符号*/yucu(); /*调用yucu()函数；*/if (syn==6){ scaner();if ((syn==0)&&(kk==0))printf("success!\n");}else { if(kk!=1) printf("the string haven't got a 'end'!\n");kk=1;}}else { printf("haven't got a 'begin'!\n");kk=1;}return;}yucu(){statement(); /*调用函数statement();*/while(syn==26){scaner(); /*读下一个单词符号*/if(syn!=6)statement(); /*调用函数statement();*/}return;}statement(){ if(syn==10){scaner(); /*读下一个单词符号*/if(syn==18){ scaner(); /*读下一个单词符号*/ expression(); /*调用函数statement();*/ }else { printf("the sing ':=' is wrong!\n");kk=1;}}else { printf("wrong sentence!\n");kk=1;}return;}expression(){ term();while((syn==13)||(syn==14)){ scaner(); /*读下一个单词符号*/ term(); /*调用函数term();*/}return;}term(){ factor();while((syn==15)||(syn==16)){ scaner(); /*读下一个单词符号*/ factor(); /*调用函数factor(); */ }return;}factor(){ if((syn==10)||(syn==11)) scaner();else if(syn==27){ scaner(); /*读下一个单词符号*/expression(); /*调用函数statement();*/ if(syn==28)scaner(); /*读下一个单词符号*/else { printf("the error on '('\n");kk=1;}}else { printf("the expression error!\n");kk=1;}return;}scaner(){ sum=0;for(m=0;m<8;m++)token[m++]=NULL;m=0;ch=prog[p++];while(ch==' ')ch=prog[p++];if(((ch<='z')&&(ch>='a'))||((ch<='Z')&&(ch>='A'))){ while(((ch<='z')&&(ch>='a'))||((ch<='Z')&&(ch>='A'))||((ch>='0')&&(ch<='9'))) {token[m++]=ch;ch=prog[p++];}p--;syn=10;token[m++]='\0';for(n=0;n<6;n++)if(strcmp(token,rwtab[n])==0){ syn=n+1;break;}}else if((ch>='0')&&(ch<='9')){ while((ch>='0')&&(ch<='9')){ sum=sum*10+ch-'0';ch=prog[p++];}p--;syn=11;}else switch(ch){ case '<':m=0;ch=prog[p++];if(ch=='>'){ syn=21;}else if(ch=='='){ syn=22;}else{ syn=20;p--;}break;case '>':m=0;ch=prog[p++];if(ch=='='){ syn=24;}else{ syn=23;p--;}break;case ':':m=0;ch=prog[p++];if(ch=='='){ syn=18;}else{ syn=17;p--;}break;case '+': syn=13; break;case '-': syn=14; break;case '*': syn=15;break;case '/': syn=16;break;case '(': syn=27;break;case ')': syn=28;break;case '=': syn=25;break;case ';': syn=26;break;case '#': syn=0;break;default: syn=-1;break;}}四、结果分析：输入begin a:=9; x:=2*3; b:=a+x end # 后输出success！如图4-1所示：图4-1输入x:=a+b*c end # 后输出error 如图4-2所示：图4-2五、总结：通过本次试验，了解了语法分析的运行过程，主程序大致流程为：“置初值”→调用scaner 函数读下一个单词符号→调用IrParse→结束。

编译原理语法分析报告+代码1000字一、语法分析语法分析是编译器的重要部分，它的作用是对源程序进行分析和判断，判断源程序是否符合语法规则，把源程序划分为一个个语法单元，并建立语法树，这里介绍一种常见的语法分析方法——LR(1)分析。

1.LR(1)分析LR(1)分析是一种自底向上的语法分析方法，它是以LR语法分析机为基础的。

LR(1)分析是在扫描整个输入的基础上作出决策的，名字中的1表示当扫描到一个符号时，它会读下一个符号来做决策并且仅仅读一个符号。

2.LR(1)分析器构建构建LR(1)分析器首先需要构建LR(1)自动机，然后对其进行分析，得到一个分析表。

分析表有两个函数：action和goto。

分析表的行是状态，列是终结符或非终结符，如果分析表的项中既包含action又包含goto，那么这个表就是一个LR(1)分析表。

3.核心算法核心算法就是通过分析表进行分析，具体步骤如下：（1）创建一个栈，将一个状态push入栈。

（2）循环扫描输入，每扫描一个符号就执行一个操作，直到栈为空。

（3）在栈的顶部状态上查找action表。

如果输入符号是一个终结符，那么应该执行的动作是shift。

如果输入符号是一个结束符号，那么说明输入已经结束，执行acc（accept）操作。

（4）如果找到了一个shift，就将其作为下一个状态push入栈，并将上次扫描到的符号作为标记push入栈。

（5）否则，在栈的顶部状态上查找goto表。

在状态表中查找新状态，并将其push入栈。

常见的错误处理：（1）在action表中找不到适当的输入：语法错误，报错。

（2）在goto表中找不到适当的输入：一个状态不能在当前符号的词法单元下产生任何变化。

4.算法实现这里提供一个简单的C++代码实现。

1）自动机的结构体声明:struct Automaton {int status; // 状态编号char symbol; // 符号int go_to; // 跳转状态int move_type; // 移动类型Automaton() : status(-1), symbol(0), go_to(-1),move_type(-1) {}};2）分析表结构体声明:struct AnalyzeTable {static const int ROWS = 100; // 分析表行数static const int COLS = 100; // 分析表列数Automaton analyze_table[ROWS][COLS]; // 分析表};3）LR(1)分析器的实现:class LR1Parser {public:LR1Parser(const std::string& grammar_file); // 构造函数~LR1Parser();void parse(const std::string& input_file); // 解析函数private:std::map<char, std::vector<std::string>> productions_; // 产生式std::map<char, std::set<char>> first_; // First集合std::map<char, std::set<char>> follow_; // Follow集合AnalyzeTable analyze_table_; // 分析表};4）分析表构建函数实现:void LR1Parser::build_analyze_table() {// 对于每个项A -> α.Bβ, a，把它添加到一个集合中。

实验报告课程名称编译原理实验项目语法分析实验专业计算机科学与技术班级2班姓名学号指导教师实验成绩2011年6月13日目录1．语法分析方法 (1)1) 文法G[S] (1)2) FIRST集和FOLLOW集 (1)3) 判断是否为LL（1）文法 (1)4) 预测分析表 (1)2．程序设计 (2)1) 总体设计 (2)2) 子程序设计 (3)3．程序中的结构说明 (4)1) 读入模块 (4)2) 判断模块 (9)3) 输出模块 (26)4．程序测试 (27)1) 输入文法 (27)2) 输出预测分析表 (28)3) 相应文法的句式分析 (28)5. 实验总结 (30)1．语法分析方法1)文法G[S]S->bNN->BaN|εB->ab2)FIRST集和FOLLOW集3)判断是否为LL（1）文法SELECT(S->bN)= FIRST(S)={b}SELECT(B->ab)=FIRST(B)={a}SELECT（N->BaN）=FIRST(N)= {a, ε}SELECT(N->ε)={FIRST(ε)-ε} FOLLOW(N)={#}SELECT（N->BaN） SELECT(N->ε)=φ∴该文法为LL(1)文法。

4)预测分析表1)总体设计A.读入模块首先该模块是主函数调用读入文法函数；其次，当对文法分析完成之后，主函数会要求输入该文法的句型；语法分析完成之后，命令窗口提示“是否继续！<y or n>”，程序读入用户的选择。

B.判断模块该模块判断文法是否正确；判断文法是否含有左递归，并将其文法分解；求出FIRST、FOLLOW集，并判断相应的是否为LL(1)文法。

C.输出模块当判断用户所输入的文法为LL(1)文法，则会输出预测分析表；当检查文法的正确性时，会输出“文法正确！”（“文法错误！”）或“语法正确！”（“语法错误！”）。

A.读入模块B.判断模块C.输入模块3．程序中的结构说明1)读入模块此部分函数包括读入文法函数、句子分析函数和命令窗口提示函数。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

LL(1)语法分析设计原理与实现技术实验计科100X班 10284XXX程序设计功能实现LL(1)分析中控制程序（表驱动程序）；完成以下描述算术表达式的LL(1)文法的LL(1)分析程序。

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

主要数据结构描述由文法可得：对于E：FIRST( E )= {(, i }对于E’: FIRST( E’ ) ={+，−，ε}对于T: FIRST( T )= ={(, i }对于T’: FIRST( T’)= ={*，∕，ε}对于F: FIRST( F )= ={(, i }对于A: FIRST( A )= ={+, - }对于M: FIRST(M)= ={*, / }由此我们容易得出各非终结符的FOLLOW集合如下：FOLLOW( E )= { )，#}FOLLOW(E’) ={ )，#}FOLLOW( T ) ={+，−，)，#}FOLLOW( T’ ) = FOLLOW( T ) ={+，−，)，#}FOLLOW( F )=FIRST(T’)\ε∪FOLLOW(T’)={*，∕，+，−，)，#}FOLLOW( A )= { (, i }FOLLOW( M )= { (, i}文法LL(1)的预测分析表(表1)：表1. LL(1)预测分析表注：为编程方便，在程序中，将E’、T’改为G、S程序结构描述1.设计方法:程序通过从文本文档读入数据，将所读数据以空格、回车或者退格为标示符，分为字符串，对字符串进行词法分析，最后将所有字符串按序输出到结果文档中，并在结果文档中标明每个字符串的类别序号。

2、程序中主要函数定义和调用关系如下：函数：void print()作用：输出分析栈void print1();作用：输出剩余串int main();作用：主要逻辑功能程序执行图如下：实验结果测试用例1：i+i*i#测试用例2：i-i++#实验总结相对于递归下降分析法，LL(1)分析法更为有效．采用此种方法的分析器由一张预测分析表（LL(1)分析表）、一个控制程序（表驱动程序）和一个分析栈组成，预测分析表中个元素的含义是：或者指出当前推到所应使用过的产生式，或者指出输入符号串中存在语法错误．LL(1)分析法的局限在于：只能分析LL(1)文法或者某些非LL(1)文法，但需先将其改造成LL(1)文法。

编译原理实验报告******************************************************************************* ******************************************************************************* 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文法首先应该进行一定的预处理，提取左公因式，消除左递归（直接或间接），接着就可以根据所得的文法进行编写代码。

语法分析器设计实验报告一、引言语法分析器是编译器中的重要组成部分，其主要功能是根据给定的文法规则，对输入的程序代码进行语法分析，判断其是否符合语法规范。

本实验旨在设计一个简单的语法分析器，通过实际实现一个基于LL(1)文法的语法分析器，深入了解语法分析的原理和实现方法。

二、实验目标本实验的目标是设计一个能够接受一个输入的程序代码并进行语法分析的程序。

具体而言，需要实现以下功能：1. 构建一个文法规则集合，用于描述程序代码的语法规范；2. 设计并实现一个LL(1)分析表，用于存储语法分析所需的预测分析表；3. 实现语法分析器，能够根据输入的程序代码，逐步地进行语法分析，并输出相应的结果。

三、实验环境本实验使用的是Java语言进行实现，操作系统环境为Windows 10。

使用的集成开发环境为Eclipse。

四、实验步骤1. 设计文法规则集合在语法分析器设计中，首先需要设计一个文法规则集合，用于描述需要分析的程序代码的语法规范。

文法规则集合的设计要符合LL(1)文法的要求，即每个非终结符的产生式至多有一个与输入符号串首符号相关的产生式。

2. 构建LL(1)分析表根据文法规则集合，构建一个LL(1)分析表，用于存储语法分析所需的预测分析表。

LL(1)分析表是一个二维表，其中行表示非终结符，列表示终结符。

表中的每个元素表示相应的产生式编号，用于指示语法分析器在分析过程中应该使用哪个产生式。

构建LL(1)分析表的方法包括：- 遍历文法规则集合，计算每个非终结符的FIRST集合和FOLLOW集合；- 根据计算得到的FIRST集合和FOLLOW集合，填充LL(1)分析表。

3. 实现语法分析器根据LL(1)分析表，实现一个语法分析器。

语法分析器的输入是一个程序代码，输出是语法分析器的分析结果。

实现语法分析器的主要过程包括：- 初始化分析栈，将文法规则的开始符号入栈；- 从输入的程序代码中读取下一个终结符；- 如果分析栈的栈顶是非终结符，根据LL(1)分析表中对应的产生式编号，将产生式右部的符号依次入栈；- 如果分析栈的栈顶是终结符，并且与输入的终结符相同，则将该终结符出栈，并继续读取下一个终结符；- 重复上述过程，直到分析栈为空或者无法继续推导。

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

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。

一、实验目的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. 语义分析结果实验句子：“我喜欢吃苹果。

LL(1)语法分析实验报告一、实验题目 LL（1）语法分析二、实验目的通过设计、编制、调试一个典型的语法分析程序，实现对词法分析程序所提供的单词序列进行语法检查和结构分析，检查语法错误，进一步掌握常用的语法分析方法。

三、实验内容构造LL(1)语法分析程序，任意输入一个文法符号串，并判断它是否为文法的一个句子。

程序要求为该文法构造预测分析表，并按照预测分析算法对输入串进行语法分析，判别程序是否符合已知的语法规则，如果不符合则输出错误信息。

消除递归前的文法消除递归和提取公因子后的等价文法S →S ∨ a T | a T | ∨ a T S→aTS’ |vaTS’T →∧ a T | ∧a S’→ vaTS’ |εT→∧ a T’T’→∧ aT’ |ε根据已建立的分析表，对下列输入串：a∧ a∧ a进行语法分析，判断其是否符合文法。

四、实验要求1.根据已由的文法规则建立LL（1）分析表；2.输出分析过程。

请输入待分析的字符串: a∧ a∧ a符号栈输入串所用产生式#S a∧ a∧ a##S’Ta a∧ a∧ a# S→aTS’#S’T ∧ a∧ a## S’T’a∧∧ a∧ a# T→∧ a T’# S’T’a a∧ a## S’T’∧ a## S’T’a∧∧ a# T’→∧ aT’# S’ T’a a## S’ T’## S’ # T’→ε# # S’→ε五、程序思路模块结构：1、定义部分：定义常量、变量、数据结构。

2、初始化：设立LL(1)分析表、初始化变量空间（包括堆栈、结构体等）；3、运行程序：让程序分析一个text文件，判断输入的字符串是否符合文法定义的规则；4、利用LL(1)分析算法进行表达式处理：根据LL(1)分析表对表达式符号串进行堆栈（或其他）操作，输出分析结果，如果遇到错误则显示简单的错误提示。

六、程序源代码/* 程序名称： LL(1)文法分析程序 *//* S->S>aT|aT|>aT *//* T-> <aT|<a*//************************************//********************************************//* 程序相关说明 *//* A=S’ B=T’ *//* 0=S 1=S’ 2=T 3=T’*//* 0=a 1=< 2=#*//************************************/#include"iostream.h"#include "stdio.h"#include "malloc.h"#include "conio.h"struct Lchar{char char_ch;struct Lchar *next;}Lchar,*p,*h,*temp,*top,*base;char curchar;char curtocmp;int right;int table[4][3]={{1,0,0},{0,0,1},{0,1,0},{0,1,1}};int i,j;void push(char pchar){temp=(struct Lchar*)malloc(sizeof(Lchar));temp->char_ch=pchar;temp->next=top;top=temp;}void pop(void){curtocmp=top->char_ch;if(top->char_ch!='#')top=top->next;}void doforpush(int t){switch(t){case 3:push('A');push('T');push('a');push('<');break; case 0:push('A');push('T');push('a');break;case 6:push('T');push('a');push('<');break;case 21:push('B');push('a');push('<');break;case 31:push('T');break;}}void changchartoint(){switch(curtocmp)case 'S':i=0;break;case 'A':i=1;break;case 'T':i=2;break;case 'B':i=3;break;}switch(curchar){case 'a':j=0;break;case '<':j=1;break;case '#':j=2;}}void dosome(void){int t;for(;;){pop();curchar=h->char_ch;printf("\n%c\t%c",curchar,curtocmp);if(curtocmp=='#' && curchar=='#')break;if(curtocmp=='S'||curtocmp=='A'||curtocmp=='T'||curtocmp=='B')if(curtocmp!='#') {changchartoint();if(table[i][j]){t=10*i+j;doforpush(t); continue;}else{right=0;break;}}elseif(curtocmp!=curchar) {right=0;break;}elsebreak;elseif(curtocmp!=curchar){right=0;break;}else{h=h->next;continue;}}}void main(void){char ch;cout<<"* 文件名称: 语法分析"<<endl;cout<<" "<<endl;cout<<"/* 程序相关说明 */"<<endl;cout<<"---------------------------------------------------------------------"<<endl;cout<<"-/* A=S’ B=T’ */"<<endl;cout<<"-* 目的: 对输入LL(1)文法字符串，本程序能自动判断所给字符串是 -"<<endl;cout<<"-* 否为所给文法的句子，并能给出分析过程。

《编译原理》上机实验报告题目：LL(1)语法分析程序1.设计要求（1）对输入文法，它能判断是否为LL(1)文法，若是，则转（2）；否则报错并终止；（2）输入已知文法，由程序自动生成它的LL(1)分析表；（3）对于给定的输入串，应能判断识别该串是否为给定文法的句型。

2.分析该程序可分为如下几步：（1）读入文法（2）判断正误（3）若无误，判断是否为LL(1)文法（4）若是，构造分析表；（5）由总控算法判断输入符号串是否为该文法的句型。

3.流程图4.源程序LL1语法分析程序#include<stdio.h>#include<string.h>int count=0; /*分解的产生式的个数*/int number; /*所有终结符和非终结符的总数*/char start; /*开始符号*/char termin[50]; /*终结符号*/char non_ter[50]; /*非终结符号*/char v[50]; /*所有符号*/char left[50]; /*左部*/char right[50][50]; /*右部*/char first[50][50],follow[50][50]; /*各产生式右部的FIRST和左部的FOLLOW集合*/ char first1[50][50]; /*所有单个符号的FIRST集合*/char select[50][50]; /*各单个产生式的SELECT集合*/char f[50],F[50]; /*记录各符号的FIRST和FOLLOW是否已求过*/char empty[20]; /*记录可直接推出^的符号*/char TEMP[50]; /*求FOLLOW时存放某一符号串的FIRST集合*/int validity=1; /*表示输入文法是否有效*/int ll=1; /*表示输入文法是否为LL(1)文法*/int M[20][20]; /*分析表*/char choose; /*用户输入时使用*/char empt[20]; /*求_emp()时使用*/char fo[20]; /*求FOLLOW集合时使用*//*******************************************判断一个字符是否在指定字符串中********************************************/int in(char c,char *p){//int i;size_t i;if(strlen(p)==0)return(0);for(i=0;;i++){if(p[i]==c)return(1); /*若在，返回1*/if(i==strlen(p))return(0); /*若不在，返回0*/}}/*******************************************得到一个不是非终结符的符号********************************************/char c(){char c='A';while(in(c,non_ter)==1)c++;return(c);}分解含有左递归的产生式********************************************/void recur(char *point){ /*完整的产生式在point[]中*/int j,m=0,n=3,k;char temp[20],ch;ch=c(); /*得到一个非终结符*/k=strlen(non_ter);non_ter[k]=ch;non_ter[k+1]='\0';for(j=0;size_t(j)<=strlen(point)-1;j++){if(point[n]==point[0]){ /*如果'|'后的首符号和左部相同*/ for(j=n+1;size_t(j)<=strlen(point)-1;j++){while(point[j]!='|'&&point[j]!='\0')temp[m++]=point[j++];left[count]=ch;memcpy(right[count],temp,m);right[count][m]=ch;right[count][m+1]='\0';m=0;count++;if(point[j]=='|'){n=j+1;break;}}}else{ /*如果'|'后的首符号和左部不同*/ left[count]=ch;right[count][0]='^';right[count][1]='\0';count++;for(j=n;size_t(j)<=strlen(point)-1;j++){if(point[j]!='|')temp[m++]=point[j];else{left[count]=point[0];memcpy(right[count],temp,m);right[count][m]=ch;right[count][m+1]='\0';m=0;count++;}}left[count]=point[0];memcpy(right[count],temp,m);right[count][m]=ch;right[count][m+1]='\0';count++;m=0;}}}/*******************************************分解不含有左递归的产生式********************************************/void non_re(char *point){int m=0,j;char temp[20];for(j=3;size_t(j)<=strlen(point)-1;j++){if(point[j]!='|')temp[m++]=point[j];else{left[count]=point[0];memcpy(right[count],temp,m);right[count][m]='\0';m=0;count++;}}left[count]=point[0];memcpy(right[count],temp,m);right[count][m]='\0';count++;m=0;}/*******************************************读入一个文法********************************************/char grammer(char *t,char *n,char *left,char right[50][50]) {char vn[50],vt[50];char s;char p[50][50];printf("\n请输入文法的非终结符号串：");scanf("%s",vn);getchar();i=strlen(vn);memcpy(n,vn,i);n[i]='\0';printf("请输入文法的终结符号串：");scanf("%s",vt);getchar();i=strlen(vt);memcpy(t,vt,i);t[i]='\0';printf("请输入文法的开始符号：");scanf("%c",&s);getchar();printf("请输入文法产生式的条数：");scanf("%d",&i);getchar();for(j=1;j<=i;j++){printf("请输入文法的第%d条（共%d条）产生式：",j,i);scanf("%s",p[j-1]);getchar();}for(j=0;j<=i-1;j++)if(p[j][1]!='-'||p[j][2]!='>'){ printf("\ninput error!");validity=0;return('\0');} /*检测输入错误*/for(k=0;k<=i-1;k++){ /*分解输入的各产生式*/if(p[k][3]==p[k][0])recur(p[k]);elsenon_re(p[k]);}return(s);}/*******************************************将单个符号或符号串并入另一符号串********************************************/void merge(char *d,char *s,int type){ /*d是目标符号串，s是源串，type＝1，源串中的' ^ '一并并入目串；type＝2，源串中的' ^ '不并入目串*/int i,j;for(i=0;size_t(i)<=strlen(s)-1;i++)if(type==2&&s[i]=='^');else{for(j=0;;j++){if(size_t(j)<strlen(d)&&s[i]==d[j])break;if(size_t(j)==strlen(d)){d[j]=s[i];d[j+1]='\0';break;}}}}}/*******************************************求所有能直接推出^的符号********************************************/void emp(char c){ /*即求所有由' ^ '推出的符号*/ char temp[10];int i;for(i=0;i<=count-1;i++){if(right[i][0]==c&&strlen(right[i])==1){temp[0]=left[i];temp[1]='\0';merge(empty,temp,1);emp(left[i]);}}}/*******************************************求某一符号能否推出' ^ '********************************************/int _emp(char c){ /*若能推出，返回1；否则，返回0*/ int i,j,k,result=1,mark=0;char temp[20];temp[0]=c;temp[1]='\0';merge(empt,temp,1);if(in(c,empty)==1)for(i=0;;i++){if(i==count)return(0);if(left[i]==c) /*找一个左部为c的产生式*/{j=strlen(right[i]); /*j为右部的长度*/if(j==1&&in(right[i][0],empty)==1)return(1);else if(j==1&&in(right[i][0],termin)==1)return(0);else{for(k=0;k<=j-1;k++)if(in(right[i][k],empt)==1)mark=1;if(mark==1)continue;else{for(k=0;k<=j-1;k++){result*=_emp(right[i][k]);temp[0]=right[i][k];temp[1]='\0';merge(empt,temp,1);}}}if(result==0&&i<count)continue;else if(result==1&&i<count)return(1);}}}/*******************************************判断读入的文法是否正确********************************************/int judge(){int i,j;for(i=0;i<=count-1;i++){if(in(left[i],non_ter)==0){ /*若左部不在非终结符中，报错*/ printf("\nerror1!");return(0);}for(j=0;size_t(j)<=strlen(right[i])-1;j++){if(in(right[i][j],non_ter)==0&&in(right[i][j],termin)==0&&right[i][j]!='^'){ /*若右部某一符号不在非终结符、终结符中且不为' ^ '，报错*/ printf("\nerror2!");validity=0;return(0);}}}return(1);}/*******************************************求单个符号的FIRST********************************************/void first2(int i){ /*i为符号在所有输入符号中的序号*/char c,temp[20];int j,k,m;c=v[i];char ch='^';emp(ch);if(in(c,termin)==1) /*若为终结符*/{first1[i][0]=c;first1[i][1]='\0';}else if(in(c,non_ter)==1) /*若为非终结符*/{for(j=0;j<=count-1;j++){if(left[j]==c){if(in(right[j][0],termin)==1||right[j][0]=='^'){temp[0]=right[j][0];temp[1]='\0';merge(first1[i],temp,1);}else if(in(right[j][0],non_ter)==1){if(right[j][0]==c)continue;for(k=0;;k++)if(v[k]==right[j][0])if(f[k]=='0'){first2(k);f[k]='1';}merge(first1[i],first1[k],2);for(k=0;size_t(k)<=strlen(right[j])-1;k++){empt[0]='\0';if(_emp(right[j][k])==1&&size_t(k)<strlen(right[j])-1){for(m=0;;m++)if(v[m]==right[j][k+1])break;if(f[m]=='0'){first2(m);f[m]='1';}merge(first1[i],first1[m],2);}else if(_emp(right[j][k])==1&&size_t(k)==strlen(right[j])-1){temp[0]='^';temp[1]='\0';merge(first1[i],temp,1);}elsebreak;}}}}}f[i]='1';}/*******************************************求各产生式右部的FIRST********************************************/void FIRST(int i,char *p){int length;int j,k,m;char temp[20];length=strlen(p);if(length==1) /*如果右部为单个符号*/{{if(i>=0){first[i][0]='^';first[i][1]='\0';}else{TEMP[0]='^';TEMP[1]='\0';}}else{for(j=0;;j++)if(v[j]==p[0])break;if(i>=0){memcpy(first[i],first1[j],strlen(first1[j]));first[i][strlen(first1[j])]='\0';}else{memcpy(TEMP,first1[j],strlen(first1[j]));TEMP[strlen(first1[j])]='\0';}}}else /*如果右部为符号串*/{for(j=0;;j++)if(v[j]==p[0])break;if(i>=0)merge(first[i],first1[j],2);elsemerge(TEMP,first1[j],2);for(k=0;k<=length-1;k++){empt[0]='\0';if(_emp(p[k])==1&&k<length-1){for(m=0;;m++)if(v[m]==right[i][k+1])break;if(i>=0)elsemerge(TEMP,first1[m],2);}else if(_emp(p[k])==1&&k==length-1){temp[0]='^';temp[1]='\0';if(i>=0)merge(first[i],temp,1);elsemerge(TEMP,temp,1);}else if(_emp(p[k])==0)break;}}}/*******************************************求各产生式左部的FOLLOW********************************************/void FOLLOW(int i){int j,k,m,n,result=1;char c,temp[20];c=non_ter[i]; /*c为待求的非终结符*/temp[0]=c;temp[1]='\0';merge(fo,temp,1);if(c==start){ /*若为开始符号*/temp[0]='#';temp[1]='\0';merge(follow[i],temp,1);}for(j=0;j<=count-1;j++){if(in(c,right[j])==1) /*找一个右部含有c的产生式*/{for(k=0;;k++)if(right[j][k]==c)break; /*k为c在该产生式右部的序号*/for(m=0;;m++)if(v[m]==left[j])break; /*m为产生式左部非终结符在所有符号中的序号*/ if(size_t(k)==strlen(right[j])-1){ /*如果c在产生式右部的最后*/if(in(v[m],fo)==1){merge(follow[i],follow[m],1);continue;}if(F[m]=='0'){FOLLOW(m);F[m]='1';}merge(follow[i],follow[m],1);}else{ /*如果c不在产生式右部的最后*/for(n=k+1;size_t(n)<=strlen(right[j])-1;n++){empt[0]='\0';result*=_emp(right[j][n]);}if(result==1){ /*如果右部c后面的符号串能推出^*/if(in(v[m],fo)==1){ /*避免循环递归*/merge(follow[i],follow[m],1);continue;}if(F[m]=='0'){FOLLOW(m);F[m]='1';}merge(follow[i],follow[m],1);}for(n=k+1;size_t(n)<=strlen(right[j])-1;n++)temp[n-k-1]=right[j][n];temp[strlen(right[j])-k-1]='\0';FIRST(-1,temp);merge(follow[i],TEMP,2);}}}F[i]='1';}/*******************************************判断读入文法是否为一个LL(1)文法********************************************/int ll1(){int i,j,length,result=1;char temp[50];for(j=0;j<=49;j++){ /*初始化*/first[j][0]='\0';follow[j][0]='\0';first1[j][0]='\0';select[j][0]='\0';TEMP[j]='\0';temp[j]='\0';f[j]='0';F[j]='0';}for(j=0;size_t(j)<=strlen(v)-1;j++)first2(j); /*求单个符号的FIRST集合*/ printf("\nfirst1:");for(j=0;size_t(j)<=strlen(v)-1;j++)printf("%c:%s ",v[j],first1[j]);printf("\nempty:%s",empty);printf("\n:::\n_emp:");for(j=0;size_t(j)<=strlen(v)-1;j++)printf("%d ",_emp(v[j]));for(i=0;i<=count-1;i++)FIRST(i,right[i]); /*求FIRST*/printf("\n");for(j=0;size_t(j)<=strlen(non_ter)-1;j++){ /*求FOLLOW*/if(fo[j]==0){fo[0]='\0';FOLLOW(j);}}printf("\nfirst:");for(i=0;i<=count-1;i++)printf("%s ",first[i]);printf("\nfollow:");for(i=0;size_t(i)<=strlen(non_ter)-1;i++)printf("%s ",follow[i]);for(i=0;i<=count-1;i++){ /*求每一产生式的SELECT集合*/ memcpy(select[i],first[i],strlen(first[i]));select[i][strlen(first[i])]='\0';for(j=0;size_t(j)<=strlen(right[i])-1;j++)result*=_emp(right[i][j]);if(strlen(right[i])==1&&right[i][0]=='^')result=1;if(result==1){for(j=0;;j++)if(v[j]==left[i])break;merge(select[i],follow[j],1);}}printf("\nselect:");for(i=0;i<=count-1;i++)printf("%s ",select[i]);memcpy(temp,select[0],strlen(select[0]));temp[strlen(select[0])]='\0';for(i=1;i<=count-1;i++){ /*判断输入文法是否为LL(1)文法*/length=strlen(temp);if(left[i]==left[i-1]){merge(temp,select[i],1);if(strlen(temp)<length+strlen(select[i]))return(0);}else{temp[0]='\0';memcpy(temp,select[i],strlen(select[i]));temp[strlen(select[i])]='\0';}}return(1);}/*******************************************构造分析表M********************************************/void MM(){int i,j,k,m;for(i=0;i<=19;i++)for(j=0;j<=19;j++)M[i][j]=-1;i=strlen(termin);termin[i]='#'; /*将#加入终结符数组*/termin[i+1]='\0';for(i=0;i<=count-1;i++){for(m=0;;m++)if(non_ter[m]==left[i])break; /*m为产生式左部非终结符的序号*/ for(j=0;size_t(j)<=strlen(select[i])-1;j++){if(in(select[i][j],termin)==1){for(k=0;;k++)if(termin[k]==select[i][j])break; /*k为产生式右部终结符的序号*/ M[m][k]=i;}}}}/*******************************************总控算法********************************************/void syntax(){int i,j,k,m,n,p,q;char ch;char S[50],str[50];printf("请输入该文法的句型：");scanf("%s",str);getchar();i=strlen(str);str[i]='#';str[i+1]='\0';S[0]='#';S[1]=start;S[2]='\0';j=0;ch=str[j];while(1){if(in(S[strlen(S)-1],termin)==1){if(S[strlen(S)-1]!=ch){printf("\n该符号串不是文法的句型！");return;}else if(S[strlen(S)-1]=='#'){printf("\n该符号串是文法的句型.");return;}else{S[strlen(S)-1]='\0';j++;ch=str[j];}}else{for(i=0;;i++)if(non_ter[i]==S[strlen(S)-1])break;for(k=0;;k++){if(termin[k]==ch)break;if(size_t(k)==strlen(termin)){printf("\n词法错误！");return;}}if(M[i][k]==-1){printf("\n语法错误！");return;}else{m=M[i][k];if(right[m][0]=='^')S[strlen(S)-1]='\0';else{p=strlen(S)-1;q=p;for(n=strlen(right[m])-1;n>=0;n--)S[p++]=right[m][n];S[q+strlen(right[m])]='\0';}}}printf("\nS:%s str:",S);for(p=j;size_t(p)<=strlen(str)-1;p++)printf("%c",str[p]);printf(" ");}}/*******************************************一个用户调用函数********************************************/void menu(){syntax();printf("\n是否继续？(y or n):");scanf("%c",&choose);getchar();while(choose=='y'){menu();}}/*******************************************主函数********************************************/void main(){int i,j;start=grammer(termin,non_ter,left,right); /*读入一个文法*/ printf("count=%d",count);printf("\nstart:%c",start);strcpy(v,non_ter);strcat(v,termin);printf("\nv:%s",v);printf("\nnon_ter:%s",non_ter);printf("\ntermin:%s",termin);printf("\nright:");for(i=0;i<=count-1;i++)printf("%s ",right[i]);printf("\nleft:");for(i=0;i<=count-1;i++)printf("%c ",left[i]);if(validity==1)validity=judge();printf("\nvalidity=%d",validity);if(validity==1){printf("\n文法有效");ll=ll1();printf("\nll=%d",ll);if(ll==0)printf("\n该文法不是一个LL1文法！");else{MM();printf("\n");for(i=0;i<=19;i++)for(j=0;j<=19;j++)if(M[i][j]>=0)printf("M[%d][%d]=%d ",i,j,M[i][j]);printf("\n");menu();}}}5.执行结果（1）输入一个文法（2）输入一个符号串（3）再次输入一个符号串，然后退出程序。

语法分析实验报告一、实验目的语法分析是编译原理中的重要环节，本次实验的目的在于深入理解和掌握语法分析的基本原理和方法，通过实际操作和实践，提高对编程语言语法结构的分析能力，为进一步学习编译技术和开发相关工具打下坚实的基础。

二、实验环境本次实验使用的编程语言为 Python，使用的开发工具为 PyCharm。

三、实验原理语法分析的任务是在词法分析的基础上，根据给定的语法规则，将输入的单词符号序列分解成各类语法单位，并判断输入字符串是否符合语法规则。

常见的语法分析方法有自顶向下分析法和自底向上分析法。

自顶向下分析法包括递归下降分析法和预测分析法。

递归下降分析法是一种直观、简单的方法，但存在回溯问题，效率较低。

预测分析法通过构建预测分析表，避免了回溯，提高了分析效率，但对于复杂的语法规则，构建预测分析表可能会比较困难。

自底向上分析法主要包括算符优先分析法和 LR 分析法。

算符优先分析法适用于表达式的语法分析，但对于一般的上下文无关文法，其适用范围有限。

LR 分析法是一种功能强大、适用范围广泛的方法，但实现相对复杂。

四、实验内容（一）词法分析首先，对输入的源代码进行词法分析，将其分解为一个个单词符号。

单词符号包括关键字、标识符、常量、运算符、分隔符等。

（二）语法规则定义根据实验要求，定义了相应的语法规则。

例如，对于简单的算术表达式，可以定义如下规则：｀｀｀Expression ＞ Term ｜ Expression ＇＋＇ Term ｜ Expression ＇＇TermTerm ＞ Factor ｜ Term ＇＇ Factor ｜ Term ＇／＇ FactorFactor ＞＇（＇ Expression ＇）＇｜ Identifier ｜ Number｀｀｀（三）语法分析算法实现选择了预测分析法来实现语法分析。

首先，根据语法规则构建预测分析表。

然后，从输入字符串的起始位置开始，按照预测分析表的指导进行分析。

语法分析实验报告一．实验目的1. 在语法分析器原理学习和词法分析器实验基础上，自行实现一个高级语言语法分析器，通过实验能够把原理和实现方法应用到如描述语言语法分析等词法分析器的设计中去。

2. 利用c语言编制递归下降分析程序，并对简单语言进行语法分析。

二．实验原理1. 待分析的简单语言的语法：0.txt：ghy.txt2. TEST语法规则：(1)<program>::={<declaration_list><statement_list>}(2) <declaration_list>::=<declaration_list><declaration_stat>|ε(3) <declaration_stat>::=int ID;(4) <statement_list>::=<statement_list><statement>|ε(5)<statement>::=<if_stat>|<while_stat>|<for_stat>|<compound_stat>|<expression_stat>(6) <if_stat>::=if(<expression>)<statement>[else<statement>](7) <while_stat)::=while(<expr>)<statement>(8)<for_stat>::=for(<expression>;<expression>;<expression>)<statement>(9) <write_stat>::=write<expression>(10) <read_stat>::=read<ID>(11) <compound_stat>::={<statement_list>}(12) <expression_stat>::=<exxprssion>;|;(13) <expression>::=ID=<bool_expr>|<bool_expr>(14)<bool_expr>::=<additive_expr>|<additive_expr>(<|>|<=|>=|==|!=)<additive_expr >(15) <additive_expr>::=<term>{+|-)<term>}(16) <term>::=<factor>{*|/)<factor>)(17) <factor>::=(<expression>)|ID|NUM三．实验步骤：1.用VC++编辑、编译和运行教材P221~230的语法分析程序。

语法分析器实验报告实验报告：语法分析器的设计与实现摘要：语法分析器是编译器的一个重要组成部分，主要负责将词法分析器输出的词法单元序列进行分析和解释，并生成语法分析树。

本实验旨在设计与实现一个基于上下文无关文法的语法分析器，并通过实现一个简单的编程语言的解释器来验证其功能。

1.引言在计算机科学中，编译器是将高级程序语言转化为机器语言的一种工具。

编译器通常由词法分析器、语法分析器、语义分析器、中间代码生成器、优化器和目标代码生成器等多个模块组成。

其中，语法分析器负责将词法分析器生成的词法单元序列进行进一步的分析与解释，生成语法分析树，为后续的语义分析和中间代码生成提供基础。

2.设计与实现2.1上下文无关文法上下文无关文法（CFG）是指一类形式化的语法规则，其中所有的产生式规则都具有相同的左部非终结符，且右部由终结符和非终结符组成。

语法分析器的设计与实现需要依据给定的上下文无关文法来进行，在本实验中，我们设计了一个简单的CFG，用于描述一个名为"SimpleLang"的编程语言。

2.2预测分析法预测分析法是一种常用的自顶向下的语法分析方法，它利用一个预测分析表来决定下一步的推导选择。

预测分析表的构造依赖于给定的上下文无关文法，以及文法的FIRST集和FOLLOW集。

在本实验中，我们使用了LL(1)的预测分析法来实现语法分析器。

2.3语法分析器实现在实现语法分析器的过程中，我们首先需要根据给定的CFG构造文法的FIRST集和FOLLOW集，以及预测分析表。

接下来，我们将词法分析器输出的词法单元序列作为输入，通过不断地匹配输入符号与预测分析表中的预测符号，进行语法分析和推导。

最终，根据CFG和推导过程，构建语法分析树。

3.实验结果与分析通过实验发现，自顶向下的预测分析法在对简单的编程语言进行语法分析时具有较高的效率和准确性。

语法分析器能够正确地识别输入程序中的语法错误，并生成相应的错误提示信息。

语法分析实验报告一、语法分析功能与目的语法分析是编译过程的核心部分，它的主要任务是按照程序语言的语法规则，从由词法分析输出的源程序符号串中识别出各类语法成分，同时进行语法检查，为语义分析和代码生成作准备。

执行语法分析任务的程序叫语法分析程序或语法分析器。

语法分析程序以词法分析输出的符号串作为输入，在分析过程中检查这个符号串是否为该程序语言的句子。

如是，则输出该句子的分析数，否则就表示源程序存在语法错误，需要报告错误的性质和位置。

二、TEST语法规则①<程序>∶∶={<声明序列><语句序列>}②<声明序列>∶∶=<声明序列><声明语句>|ε③<声明语句>∶∶=int <标识符>；④<语句序列>::=<语句序列><语句>|ε⑤<语句>::=<if语句>|<while语句>|<do语句>|<for语句>|<read语句>|<write语句>|<复合语句>|<表达式语句>⑥<if语句>::=if(<表达式>)<语句>[else<语句>]⑦<while语句>::=while(<表达式>)<表达式>⑧<for语句>:=for(<表达式>；<表达式>；<表达式>)<语句>⑨<write语句>::=write<表达式>；⑩<read语句>::=read<标识符>；⑴<复合语句>::={<语句序列>}⑵<表达式语句>:=<表达式>；|；⑶<表达式>::=<标识符>=<布尔表达式>|<布尔表达式>⑷<布尔表达式>:=<算术表达式>|<算术表达式>(>|<|>=|<=|==|!=)<算术表达式>⑸<算术表达式>::=<项>{(+|-)<项>}⑹<项>::=<因子>{(*|/)<因子>}⑺<因子>::=(<表达式>)|<标识符>|<无符号整数>⑻<do语句>::=do<语句>while(<表达式>)；三、实验四要求及改进思路实验要求：修改词法分析程序TESTscan.c和语法分析程序TESTparse.c这二个文件，使该程序能分析：(1) do语句（有关文法规则参见P77的习题8。