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

合集下载

编译原理实验报告(词法分析器语法分析器)

函数 int f(char c) 和 int g(char c) ，判断运算符之间的优先关系，根据不同情况作各种不同操作。流程
图如下：
word 完美格式
专业资料
输入算数表达式，以 #结束初始化 loptr[1]= ’#’ 用 get（）取一个待分析字符 s
Optr[1] 和 s 是否同时为 #
。
2 、而且对词法分析和语法分析在实践中的应用有了深入的掌握
。
3 、更加熟悉了构造词法分析程序和语法分析程序的手工方式的相关原理
，能够实现对词
法分析程序所提供的单词符号序列进行相应的语法检查和结构分析
，达到了学以致用的目的。
word 完美格式
word 完美格式
专业资料
case 'p': case 'q': case 'r': case 's': case 't': case 'u': case 'v': case 'w': case 'x': case 'y': case 'z':
while(letter(s)||digit(s)) {token[j]=s; j=j+1; get(); } retract();k=lookup(token); if(k==0)
-
9
*
10
<=
11
<
11
==
11
=
12
;
13
word 完美格式
助记符 while
if else switch case

编译原理实验报告

编译原理实验报告一、实验目的本次编译原理实验的主要目的是通过实践加深对编译原理中词法分析、语法分析、语义分析和代码生成等关键环节的理解，并提高实际动手能力和问题解决能力。

二、实验环境本次实验使用的编程语言为 C/C+＋，开发工具为 Visual Studio 2019，操作系统为 Windows 10。

三、实验内容（一）词法分析器的设计与实现词法分析是编译过程的第一个阶段，其任务是从输入的源程序中识别出一个个具有独立意义的单词符号。

在本次实验中，我们使用有限自动机的理论来设计词法分析器。

首先，我们定义了单词的种类，包括关键字、标识符、常量、运算符和分隔符等。

然后，根据这些定义，构建了相应的状态转换图，并将其转换为程序代码。

在实现过程中，我们使用了字符扫描和状态转移的方法，逐步读取输入的字符，判断其所属的单词类型，并将其输出。

（二）语法分析器的设计与实现语法分析是编译过程的核心环节之一，其任务是在词法分析的基础上，根据给定的语法规则，判断输入的单词序列是否构成一个合法的句子。

在本次实验中，我们采用了自顶向下的递归下降分析法来实现语法分析器。

首先，我们根据给定的语法规则，编写了相应的递归函数。

每个函数对应一种语法结构，通过对输入单词的判断和递归调用，来确定语法的正确性。

在实现过程中，我们遇到了一些语法歧义的问题，通过仔细分析语法规则和调整函数的实现逻辑，最终解决了这些问题。

（三）语义分析与中间代码生成语义分析的任务是对语法分析所产生的语法树进行语义检查，并生成中间代码。

在本次实验中，我们使用了四元式作为中间代码的表示形式。

在语义分析过程中，我们检查了变量的定义和使用是否合法，类型是否匹配等问题。

同时，根据语法树的结构，生成相应的四元式中间代码。

（四）代码优化代码优化的目的是提高生成代码的质量和效率。

在本次实验中，我们实现了一些基本的代码优化算法，如常量折叠、公共子表达式消除等。

通过对中间代码进行分析和转换，减少了代码的冗余和计算量，提高了代码的执行效率。

编译原理语法分析试验报告

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

本次试验通过使用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中保存，并记录他们的位置。

编译原理-词法语法分析实验报告

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

二、实验要求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 各种单词符号对应的种别码：2.3 词法分析程序的功能：输入：所给文法的源程序字符串。

输出：二元组（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)……三、词法分析程序的C语言程序源代码：#include <stdio.h>#include <string.h>char prog[80],token[8],ch;int syn,p,m,n,sum;char *rwtab[6]={"begin","if","then","while","do","end"};scaner();void scanner_example (FILE *fp);main(){FILE *fp;fp=fopen("D:\\1.txt","r");//打开文件scanner_example (fp);scaner();}void scanner_example (FILE *fp){do{ch=fgetc (fp);prog[p++]=ch;}while (ch!='#');p=0;do{scaner();switch(syn){case 11:printf("( %-10d%5d )\n",sum,syn);break;case -1:printf("you have input a wrong string\n");default: printf("( %-10s%5d )\n",token,syn);break;}}while(syn!=0);}scaner(){ sum=0;for(m=0;m<8;m++)token[m++]=NULL;ch=prog[p++];m=0;while((ch==' ')||(ch=='\n'))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;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 '<':token[m++]=ch;ch=prog[p++];if(ch=='='){ syn=22;token[m++]=ch;}else{ syn=20;p--;}break;case '>':token[m++]=ch;ch=prog[p++];if(ch=='='){ syn=24;token[m++]=ch;}else{ syn=23;p--;}break;case '+': token[m++]=ch;ch=prog[p++];if(ch=='+'){ syn=17;token[m++]=ch;}else{ syn=13;p--;}break;case '-':token[m++]=ch;ch=prog[p++];if(ch=='-'){ syn=29;token[m++]=ch;}else{ syn=14;p--;}break;case '!':ch=prog[p++];if(ch=='='){ syn=21;token[m++]=ch;}else{ syn=31;p--;}break;case '=':token[m++]=ch;ch=prog[p++];if(ch=='='){ syn=25;token[m++]=ch;}else{ syn=18;p--;}break;case '*': syn=15;token[m++]=ch;break;case '/': syn=16;token[m++]=ch;break;case '(': syn=27;token[m++]=ch;break;case ')': syn=28;token[m++]=ch;break;case '{': syn=5;token[m++]=ch;break;case '}': syn=6;token[m++]=ch;break;case ';': syn=26;token[m++]=ch;break;case '\"': syn=30;token[m++]=ch;break;case '#': syn=0;token[m++]=ch;break;case ':':syn=17;token[m++]=ch;break;default: syn=-1;break;}token[m++]='\0';}四、结果分析：输入begin x:=9: if x>9 then x:=2*x+1/3; end # 后经词法分析输出如下序列：(begin 1)(x 10)(：17)(= 18)(9 11)(；26)(if 2)……如图所示：五、总结：词法分析的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号，其基本思想是根据扫描到单词符号的第一个字符的种类，拼出相应的单词符号。

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

编译原理语法分析实验报告编译原理实验报告一、实验目的本实验的主要目的是熟悉编译原理中的语法分析算法及相关知识，并通过实际编码实现一个简单的语法分析器。

二、实验内容1.完成一个简单的编程语言的语法定义，并用BNF范式表示；2.基于给定的语法定义，实现自顶向下的递归下降语法分析器；3.实验所用语法应包含终结符、非终结符、产生式及预测分析表等基本要素；4.实现语法分析器的过程中，需要考虑文法的二义性和优先级等问题。

三、实验步骤1.设计一个简单的编程语言的语法，用BNF范式进行表达。

例如，可以定义表达式文法为：<exp> ::= <term> { + <term> ， - <term> }<term> ::= <factor> { * <factor> ， / <factor> }<factor> ::= <digit> ， (<exp>) ， <variable><digit> ::= 0，1，2，3，4，5，6，7，8，9<variable> ::= a，b，c，...，z2. 根据所设计的语法，构建语法分析器。

首先定义需要用到的终结符、非终结符和产生式。

例如，终结符可以是+、-、*、/、(、)等，非终结符可以是<exp>、<term>、<factor>等，产生式可以是<exp> ::= <term> + <term> ， <term> - <term>等。

3.实现递归下降语法分析器。

根据语法的产生式，编写相应的递归函数进行递归下降分析。

递归函数的输入参数通常是一个输入字符串和当前输入位置，输出结果通常是一个语法树或语法分析错误信息。

4.在语法分析的过程中，需要处理语法的二义性和优先级问题。

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

char data[20][20]; char s[100]; char lable[20]; char input[100]; char string[20][10]; int k; char a; int j; char q; int r; int r1; char st[10][30]; char first[10][10]; char last[10][10]; int fflag[10]={0}; FIRSTVT集是否已求出 int lflag[10]={0}; LASTVT集是否已求出 int deal(); int zhongjie(char c); int xiabiao(char c);
//输出转化后
的文法规则串
{
printf("%s\n",text[i]);
}
for(i=0;i<x;i++) /*求每个终结符的推导结果(去掉"->"后的转化文
法，用于最后的规约)*/
{ string[i][0]=text[i][0];
for(j=3,l=1;text[i][j]!='\0';j++,l++)
表1-2 G[S]的算符优先关系矩阵表
#
i
+
*
(
)
#
i
+
*
(
)
二．程序设计
1.总体设计
求FIRSTVT模块求LASTVT模块识别终结符模块
读入文法规则创建文法关系表模块
求下标模块
2.子程序设计
识别终结符模块
读取语法分析串输入串分析模块图2-1 总体设计图
求FIRSTVT模块求LASTVT模块

编译原理语法分析器实验报告

西安邮电大学编译原理实验报告学院名称：计算机学院****：***实验名称：语法分析器的设计与实现班级：计科1405班学号：04141152时间：2017年5月12日一．实验目的1.熟悉语法分析的过程2.理解相关文法分析的步骤3.熟悉First集和Follow集的生成二．实验要求对于给定的文法，试编写调试一个语法分析程序：要求和提示：1)可选择一种你感兴趣的语法分析方法（LL(1)、算符优先、递归下降、SLR(1)等）作为编制语法分析程序的依据。

2)对于所选定的分析方法，如有需要，应选择一种合适的数据结构，以构造所给文法的机内表示。

3)能进行分析过程模拟。

如输入一个句子，能输出与句子对应的语法树，能对语法树生成过程进行模拟；能够输出分析过程每一步符号栈的变化情况。

设计一个由给定文法生成First集和Follow集并进行简化的算法动态模拟三．实验内容1.文法：E->TE’E’->+TE’|εT->FT’T’->*FT’|εF->(E)|i:2.程序描述（LL(1)文法）本程序是基于已构建好的某一个语法的预测分析表来对用户的输入字符串进行分析，判断输入的字符串是否属于该文法的句子。

基本实现思想：接收用户输入的字符串（字符串以“#”表示结束）后，对用做分析栈的一维数组和存放分析表的二维数组进行初始化。

然后取出分析栈的栈顶字符，判断是否为终结符，若为终结符则判断是否为“#”且与当前输入符号一样，若是则语法分析结束，输入的字符串为文法的一个句子，否则出错若不为“#”且与当前输入符号一样则将栈顶符号出栈，当前输入符号从输入字符串中除去，进入下一个字符的分析。

若不为“#”且不与当前输入符号一样，则出错。

3.判断是否LL(1)文法要判断是否为LL(1)文法，需要输入的文法G有如下要求：具有相同左部的规则的SELECT集两两不相交，即：SELECT(A→?)∩SELECT(A→?)= ?如果输入的文法都符合以上的要求，则该文法可以用LL(1)方法分析。

编译原理语法分析试验报告

二、语法分析（一）实验题目编写程序，实现对词法分析程序所提供的单词序列进行语法检查和结构分析。

（二）实验内容和要求1.要求程序至少能分析的语言的内容有：1）变量说明语句2）赋值语句3）条件转移语句4）表达式（算术表达式和逻辑表达式）5）循环语句6）过程调用语句2.此外要处理:包括依据文法对句子进行分析;出错处理;输出结果的构造。

3.输入输出的格式：输入：单词文件（词法分析的结果）输出：语法成分列表或语法树（都用文件表示），错误文件（对于不合文法的句子）。

4.实现方法：可以采用递归下降分析法，LL （1）分析法，算符优先法或LR分析法的任何一种，也可以针对不同的句子采用不同的分析方法。

（三）实验分析与设计过程1.待分析的C语言子集的语法：该语法为一个缩减了的C语言文法，估计是整个C语言所有文法的60% （各种关键字的定义都和词法分析中的一样），具体的文法如下：语法：100: program -> declaiationjist101: declarationjist -> declarationjist declaration declaration102: declaiation -> vai_declaiation|fijn_declaration103: vai.declaration -> type_specifier ID;|tvpe_specifier ID [NUM];104: typ Jsp亡cifki -> mt|void|float|chai-|long|double|105: fun_declaration -> type_specifier ID （params）|compound_stmt106: paranis -> params_list|void107: paramjist ->paiam_list.paiam|paiam108: param -> type-spectifier ED|type_specifier LD[]109: compound_stmt -> {locaLdeclaiations statementjist}110: locaLdeclarations -> local_declarations var_declaration|empty111: statementjist -> statementjist statement|emptv112: statement -> epiesion_stmt|conipound_stmtselection.stmt iteration_stmt|retuin_stmt113: expression^stmt -> expression；!;114: selection_stmt -> if{expressionjstatement if(expression)statement elsestatement115: iteration_stmt -> wliile{expression)statement116: return_stmt -> return;|return expression;117: expression -> var = expression|siinple-expression118: var -> ID | ID [expression]119: suuple_expression ->additive_expression relop additive_expression|additive_expression120: relop -> <=|<|>|>=|= =|!=121: additive_expression -> additive_expression addop term | term122: addop -> + | -123: term -> term mulop factor factor124: mulop -> *|/125: factor -> (expression)|var|call|NUM126: call -> ID(aigs)127: args -> aig_list|empty128: arg_list -> arg_list,expression|expression该文法满足了实验的要求，而且多了很多的内容，相当于一个小型的文法说明：把文法标号从100到128是为了程序中便于找到原来的文法。

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

编译原理语法分析实验报告《编译原理》实验报告⼀，实验内容设计、编制并调式⼀个语法分析程序，加深对语法分析原理的理解。

⼆，实验⽬的及要求利⽤C++（或C）编制确定的⾃顶向下预测分析语法分析程序，并对简单语⾔进⾏语法分析。

2.1、待分析的简单语⾔的语法若⽂法G[ E]为:(1) E –> TE’(2) E’ –> +TE’(3) E’ –> ε(4) T –> FT’(5) T’ –> *FT’(6) T’ –> ε(7) F –> (E)(8) F –> i2.2、实验要求及说明具体要求如下：1、⽤可视化界⾯分步骤实现，显⽰输出每⼀步的处理结果。

2、⾸先按照判别步骤判断给定⽂法是否LL(1)⽂法。

3、给出⽂法的预测分析表。

4、编写预测分析程序，输出句⼦的分析过程。

5、输⼊源⽂件串，以“#”结束，如果是⽂法正确的句⼦，则输出成功信息，打印“SUCCESS”,否则输出“ERROR”。

例如：输⼊⽂件：i+i*(i+i) #输出success过程：略；输⼊⽂件：i+ii#输出error三，实验环境Dvc++#include#define MAX 50using namespace std;struct T_NT{int code;char str[MAX];};T_NTT[12]={{0,"i"},{1,"+"},{2,"*"},{3,"("},{4,")"},{5,"#"},{6,"!"},{256,"E"},{257,"E'" },{258,"T"},{259,"T'"},{260,"F"}};T_NTR[8]={{0,"->TR"},{1,"->+TR"},{2,"->e"},{3,"->FW"},{4,"->*FW"},{5,"->e"},{6, "->(E)"},{7,"->i"}};stack stak;int Yy_pushab[7][4]={{257,258,6},{257,258,1,6},{6},{259,260,6},{259,260,2,6},{0,6},{4,256,3,6}};int Yy_d[5][6]={{0,-1,-1,0,-1,-1},{-1,1,-1,-1,2,2},{3,-1,-1,3,-1,-1},{-1,2,4,-1,2,2},{5,-1,-1,6,-1,-1}int main(){char c,t[MAX];int s[MAX];cout<<"请输出要输⼊的字符串：";while(c!='#'){cin>>c;t[l]=c;switch(c){case'i':s[l]=0; break;case'+':s[l]=1; break;case'*':s[l]=2; break;case'(':s[l]=3; break;case')':s[l]=4; break;case'#':s[l]=5; break;case'!':s[l]=6; break;}l++;}cout<<"\n LL1⽂法预测分析表如下：\n"<cout<<" ";for(i=0;i<6;i++)//printf("%10c",T[i].str);cout<<" "<cout<for(i=0;i<5;i++){cout<<" -----------------------------------------------------------------"< //printf("%10c",T[i+7].str);cout<<" "<for(j=0;j<6;j++){//printf("%10c");{case 0:cout<case 1:cout<case 2:cout<case 3:cout<case 4:cout<case 5:cout<case 6:cout<case 7:cout<case-1:cout<<" ";break;}}cout<}cout<cout<<"\n 对输⼊句型的分析如下：\n"<cout<<" 步骤栈顶元素剩余输⼊串推到所⽤产⽣式或匹配"<cout<<"-------------------------------------------------------------------------------\n"; stak.push(5);stak.push(256);while(!stak.empty()){cout<<" "<p=stak.top(); //cout<<"p"<for(i=0;i<12;i++) // 输出栈顶元素{if(T[i].code==p){cout<<" "<break;}}cout<<" ";} //输出剩余字符串if(p>=0&&p<6) // 栈顶是终结符{if(p!=s[h]){cout<<" 语法错误！";break;}else if(p==5){cout<<" 接受"<cout<<"-------------------------------------------------------------------------------\n"; cout<<"\n该句型是该⽂法的句⼦\n";stak.pop();}else{cout<<" 与"<w++;h++;stak.pop();}}else{m=p-256;n=s[h];what=Yy_d[m][n]; //预测分析表if(what==-1){cout<<" 没有可⽤的产⽣式"<cout<<"-------------------------------------------------------------------------------\n"; cout<<"\n该句型不是该⽂法的句⼦\n";{cout<<" "<//cout<stak.pop();k=0;while(Yy_pushab[what][k]!=6) //产⽣式{stak.push(Yy_pushab[what][k]);k++;}}}b++;cout<}system("pause");return 0;}五。

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

实验二语法分析实验报告一、实验内容1.1 实验目的编制一个递归下降分析程序,实现对词法分析程序所提供的单词序列的语法检查和结构分析.1.2 实验要求利用C语言编制递归下降分析程序，并对简单语言进行语法分析1.2.1待分析的简单语言的词法用扩充的BNF表示如下：(1) <程序>::={<声明序列><语句序列>}(2）<语句串>::=<语句>{;<语句>}(3) <语句>::=<赋值语句>(4) <赋值语句>::=ID：= <表达式>(5) <表达式>::=<项>{(+<项>|-<项>}(6) <项>::=<因子>{*<因子>|/<因子>}(7) <因子>::=ID|NUM|（<算术表达式>）1.2.2实验要求说明输入单词串，以“#”结束，如果是文法正确的句子，则输出成功信息，打印“success”，否则输出“error”。

二、实验程序的总体结构框架图1. 语法分析主程序示意图图2.递归下降分析程序示意图图5. expression表达式分析函数示意图图6.term分析函数示意图三、关键技术的实现方法Scanner函数定义已在实验一给出，本实验不再重复给出void Irparser(){kk=0;if(syn==1){scaner();yucu();if(syn==6){scaner();if(syn==0 && (kk==0)) cout<<"success!"<<endl;}else{if(kk!=1)cout<<"缺end!"<<endl;kk=1;}}else {cout<<"缺begin!"<<endl;kk=1;}return;}void yucu(){statement();while(syn==26){scaner();statement();}return;}void statement() {if(syn==10){scaner();if(syn==18){scaner();expression();}else{cout<<"赋值号错误"<<endl;kk=1;}}else{cout<<"语句错误"<<endl;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{cout<<")错误"<<endl;kk=1;}}else{cout<<"表达式错误"<<endl;kk=1;}return;}void main(){p=0;cout<<"Please input string"<<endl;do{cin.get(ch);if(ch!=”\n”)prog[p++]=ch;}while(ch!='#');p=0;scaner();Irparser();}四、实验心得语法分析是编译过程的核心部分,它的主要功能是按照程序语言的语法规则,从由词法分析输出的源程序符号串中识别出各类语法成分,同时进行语法检查,为语义分析和代码生成做准备。

编译原理实验报告

编译原理实验报告一、实验目的编译原理是计算机科学中的重要课程，旨在让学生了解编译器的基本工作原理以及相关技术。

本次实验旨在通过设计和实现一个简单的编译器，来进一步加深对编译原理的理解，并掌握实际应用的能力。

二、实验环境本次实验使用了Java编程语言及相关工具。

在开始实验前，我们需要安装Java JDK并配置好运行环境。

三、实验内容及步骤1. 词法分析词法分析是编译器的第一步，它将源代码分割成一系列词法单元。

我们首先实现一个词法分析器，它能够将输入的源代码按照语法规则进行切割，并识别出关键字、标识符、数字、运算符等。

2. 语法分析语法分析是编译器的第二步，它将词法分析得到的词法单元序列转化为语法树。

我们使用自顶向下的LL(1)语法分析算法，根据文法规则递归地构建语法树。

3. 语义分析语义分析是编译器的第三步，它对语法树进行检查和转换。

我们主要进行类型检查、语法错误检查等。

如果源代码存在语义错误，编译器应该能够提供相应的错误提示。

4. 代码生成代码生成是编译器的最后一步，它将经过词法分析、语法分析和语义分析的源代码翻译为目标代码。

在本次实验中，我们将目标代码生成为Java字节码。

5. 测试与优化完成以上步骤后，我们需要对编译器进行测试，并进行优化。

通过多个测试用例的执行，我们可以验证编译器的正确性和性能。

四、实验心得通过完成这个编译器的实验，我收获了很多。

首先，我对编译原理的知识有了更深入的理解。

在实验过程中，我深入学习了词法分析、语法分析、语义分析和代码生成等关键技术，对编译器的工作原理有了更系统的了解。

其次，我提高了编程能力。

实现一个完整的编译器需要处理复杂的数据结构和算法，这对我的编程能力是一个很好的挑战。

通过实验，我学会了合理地组织代码，优化算法，并注意到细节对程序性能的影响。

最后，我锻炼了解决问题的能力。

在实验过程中，我遇到了很多困难和挑战，但我不断地调试和改进代码，最终成功地实现了编译器。

编译原理实验报告-语法分析

编译原理课程实验报告实验2：语法分析
三、系统设计得分
要求：分为系统概要设计和系统详细设计。

（1）系统概要设计：给出必要的系统宏观层面设计图，如系统框架图、数据流图、功能模块结构图等以及相应的文字说明。

1）系统的数据流图：
说明
说明：本语法分析器是基于上一个实验词法分析器的基础上，通过在界面写或者是导入源程序，词法分析器将源程序识别的词法单元传递给语法分析器，语法分析器验证这个词法单元组成的串是否可以由源语言的文法生成，能够输出语法分析的结果，文法的first集、follow 集和预测分析表，当然也可以以易于理解的方式报告语法错误。

2）系统框架图
本系统框架主要是三部分，一部分是词法分析，负责识别源程序的词法单元识别，并将其存
因为预测分析表实在是过于庞大，因此本处分段截取预测分析表，下面的表是接在上面表的右侧。

（3）针对一测试程序输出其句法分析结果；
测试程序：
语法分析结果：
语法分析树：
（4）输出针对此测试程序对应的语法错误报告；
带错误的测试程序：
语法错误报告：
（5）对实验结果进行分析。

总结：
本语法分析器具有强大的语法分析功能
●允许变量的连续声明，比如int a,b,c；
●允许声明的同时赋值，比如string c = “你好”；
●允许对数组的声明和引用，同时进行赋值，比如char[4] a = {‘a’,’b’,’c’,’d’};a[0] = ‘m’；
●支持多种类型的声明和赋值，比如int，short，long，flaot，double，char，string，boolean
的声明和赋值；
●允许声明和使用一个过程函数，比如：。

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

编译原理语法分析实验报告一、实验目的本实验主要目的是学习和掌握编译原理中的语法分析方法，通过实验了解和实践LR(1)分析器的实现过程，并对比不同的文法对语法分析的影响。

二、实验内容1.实现一个LR(1)的语法分析器2.使用不同的文法进行语法分析3.对比不同文法对语法分析的影响三、实验原理1.背景知识LR(1)分析器是一种自底向上（bottom-up）的语法分析方法。

它使用一个分析栈（stack）和一个输入缓冲区（input buffer）来处理输入文本，并通过移进（shift）和规约（reduce）操作进行语法分析。

2.实验步骤1）构建文法的LR(1)分析表2）读取输入文本3）初始化分析栈和输入缓冲区4）根据分析表进行移进或规约操作，直至分析过程结束四、实验过程与结果1.实验环境本实验使用Python语言进行实现，使用了语法分析库ply来辅助实验。

2.实验步骤1）构建文法的LR(1)分析表通过给定的文法，根据LR(1)分析表的构造算法，构建出分析表。

2）实现LR(1)分析器使用Python语言实现LR(1)分析器，包括读取输入文本、初始化分析栈和输入缓冲区、根据分析表进行移进或规约操作等功能。

3）使用不同的文法进行语法分析选择不同的文法对编写的LR(1)分析器进行测试，观察语法分析的结果。

3.实验结果通过不同的测试案例，实验结果表明编写的LR(1)分析器能够正确地进行语法分析，能够识别出输入文本是否符合给定文法。

五、实验分析与总结1.实验分析本实验通过实现LR(1)分析器，对不同文法进行语法分析，通过实验结果可以观察到不同文法对语法分析的影响。

2.实验总结本实验主要学习和掌握了编译原理中的语法分析方法，了解了LR(1)分析器的实现过程，并通过实验提高了对语法分析的理解。

六、实验心得通过本次实验，我深入学习了编译原理中的语法分析方法，了解了LR(1)分析器的实现过程。

在实验过程中，我遇到了一些问题，但通过查阅资料和请教老师，最终解决了问题，并完成了实验。

编译原理词法分析,语法分析实验报告

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

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

3.流程图开始读入文法有效？是是LL(1)文法？是判断句型报错结束4.源程序/*******************************************语法分析程序作者：xxx学号：xxx********************************************/#include<stdlib.h>#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;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;j<=strlen(point)-1;j++){if(point[n]==point[0]){ /*如果‘|’后的首符号和左部相同*/ for(j=n+1;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;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';printf(" count=%d ",count);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;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];int i,j,k;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;i<=strlen(s)-1;i++){if(type==2&&s[i]=='^');else{for(j=0;;j++){if(j<strlen(d)&&s[i]==d[j])break;if(j==strlen(d)){d[j]=s[i];d[j+1]='\0';}}}}}/*******************************************求所有能直接推出^的符号********************************************/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)return(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)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!");validity=0;return(0);}for(j=0;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])break;if(f[k]=='0'){first2(k);f[k]='1';}merge(first1[i],first1[k],2);for(k=0;k<=strlen(right[j])-1;k++){empt[0]='\0';if(_emp(right[j][k])==1&&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&&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(p[0]=='^'){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)merge(first[i],first1[m],2);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(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;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;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;j<=strlen(v)-1;j++)first2(j); /*求单个符号的FIRST集合*/ printf("\nfirst1:");for(j=0;j<=strlen(v)-1;j++)printf("%c:%s ",v[j],first1[j]);printf("\nempty:%s",empty);printf("\n:::\n_emp:");for(j=0;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;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;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;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;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(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;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）再次输入一个符号串，然后退出程序二．词法分析一、问题描述识别简单语言的单词符号识别简单语言的基本字、标识符、无符号整数、运算符和界符。

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

编译原理语法分析实验报告南华⼤学计算机科学与技术学院实验报告（2007 ~2008 学年度第⼆学期）编译原理课程名称语法分析实验名称姓名寻友旭学号20054350227 专业软件⼯程班级软件⼯程052班地点6—413 教师陈星1.实验⽬的及要求编制⼀个递归下降分析程序，实现对词法分析程序所提供得单词序列得语法检查和结构分析。

软件、硬件环境VC6.0要求：利⽤C语⾔编制递归下降分析程序，并对简单语⾔进⾏语法分析。

待分析的简单语⾔得语法：E→E+T | E-T | TT→T*F | T/F |FF→(E) | i输⼊单词串，以“#”结束，如果是⽂法正确的句⼦，则输出成功信息，打印“Accept! Right Expression!”，否则输出“Error”。

语法分析：a) ∵E=>E+T=>E+T*F=>E+T*(E)即有E=>E+T*(E)存在左递归。

⽤直接改写法消除左递归，得到如下：E →TE’E’ → +TE’ | ?TE’|εT →FT’T’ →*FT’ | /FT’|εF → (E) | ib) 对于以上改进的⽅法。

可得：对于E’:FIRST( E’ )=FIRST(+TE’)∪FIRST(-TE’)∪{ε}={+，?，ε}对于T’:FIRST( T’ )=FIRST(*FT’)∪FIRST(/FT’)∪{ε}={*，⁄，ε}⽽且：FIRST( E ) = FIRST( T ) = FIRST( F )=FIRST((E))∪FIRST(i)={(，i }由此我们容易得出各⾮终结符的FOLLOW集合如下：FOLLOW( E )= { )，#}FOLLOW( T’ ) = FOLLOW( T ) ={+，?，)，#}FOLLOW( F )=FIRST(T’)\ε∪FOLLOW(T’)={*，⁄，+，?，)，#}由以上FOLLOW集可以我们可以得出SELECT集如下：对E SELECT（E→TE’）=F IRST(TE’)=FIRST(T)={ (，i }对E’ SELECT（E’ →+TE’）={ + }SELECT（E’ →?TE’）={ ? }SELECT（E’ →ε）={ε，)，#}对T SELECT（T→FT’）={(，i}对T’ SELECT（T’ →*FT’）={ * }SELECT（T’ →⁄FT’）={ ⁄}SELECT（T’ →ε）={ε，+，?，)，#}对F SELECT（F→(E) ）={ ( }SELECT（F→i）={ i }∴SELECT(E’ →+TE’)∩SELECT（E’ →?TE’）∩SELECT（E’ →ε）=ΦSELECT(T’ →*FT’)∩SELECT（T’ →⁄FT’）∩SELECT（T’ →ε）=ΦSELECT（F→(E) ）∩SELECT（F→i）= Φ由上可知，有相同左部产⽣式的SELECT集合的交集为空，所以⽂法是LL（1）⽂法。

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

编译原理语法分析实验报告编译原理实验报告二、语法分析(一) 实验题目编写程序，实现对词法分析程序所提供的单词序列进行语法检查和结构分析。

(二) 实验内容和要求1. 要求程序至少能分析的语言的内容有:1) 变量说明语句2) 赋值语句3) 条件转移语句4) 表达式(算术表达式和逻辑表达式)5) 循环语句6) 过程调用语句2. 此外要处理:包括依据文法对句子进行分析;出错处理;输出结果的构造。

3. 输入输出的格式:输入:单词文件(词法分析的结果)输出:语法成分列表或语法树(都用文件表示)，错误文件(对于不合文法的句子)。

4. 实现方法:可以采用递归下降分析法，LL(1)分析法，算符优先法或LR分析法的任何一种，也可以针对不同的句子采用不同的分析方法。

(三) 实验分析与设计过程1. 待分析的C语言子集的语法:该语法为一个缩减了的C语言文法，估计是整个C语言所有文法的60%(各种关键字的定义都和词法分析中的一样)，具体的文法如下:语法:100: program -> declaration_list101: declaration_list -> declaration_list declaration | declaration 102: declaration -> var_declaration|fun_declaration103: var_declaration -> type_specifier ID;|type_specifier ID[NUM]; 104: type_specifier -> int|void|float|char|long|double|105: fun_declaration -> type_specifier ID (params)|compound_stmt 106: params -> params_list|void107: param_list ->param_list,param|param108: param -> type-spectifier ID|type_specifier ID[]109: compound_stmt -> {local_declarations statement_list}110: local_declarations -> local_declarations var_declaration|empty 111: statement_list -> statement_list statement|empty11编译原理实验报告112: statement -> epresion_stmt|compound_stmt|selection_stmt|iteration_stmt|return_stmt113: expression_stmt -> expression;|;114: selection_stmt -> if{expression)statement|if(expression)statement else statement115: iteration_stmt -> while{expression)statement116: return_stmt -> return;|return expression;117: expression -> var = expression|simple-expression118: var -> ID |ID[expression]119: simple_expression ->additive_expression relop additive_expression|additive_expression 120: relop -> <=|<|>|>=|= =|!=121: additive_expression -> additive_expression addop term | term 122: addop -> + | -123: term -> term mulop factor | factor124: mulop -> *|/125: factor -> (expression)|var|call|NUM126: call -> ID(args)127: args -> arg_list|empty128: arg_list -> arg_list,expression|expression该文法满足了实验的要求，而且多了很多的内容，相当于一个小型的文法说明:把文法标号从100到128是为了程序中便于找到原来的文法。

编译原理教程实验报告

一、实验目的本次实验旨在使学生通过编译原理的学习，了解编译程序的设计原理及实现技术，掌握编译程序的各个阶段，并能将所学知识应用于实际编程中。

二、实验内容1. 词法分析2. 语法分析3. 语义分析4. 中间代码生成5. 代码优化6. 目标代码生成三、实验步骤1. 词法分析（1）设计词法分析器，识别输入源代码中的各种词法单元；（2）使用C语言实现词法分析器，并进行测试。

2. 语法分析（1）根据文法规则设计语法分析器，识别输入源代码的语法结构；（2）使用C语言实现语法分析器，并进行测试。

3. 语义分析（1）设计语义分析器，检查语法分析后的语法树，确保语义正确；（2）使用C语言实现语义分析器，并进行测试。

4. 中间代码生成（1）设计中间代码生成器，将语义分析后的语法树转换为中间代码；（2）使用C语言实现中间代码生成器，并进行测试。

5. 代码优化（1）设计代码优化器，对中间代码进行优化，提高程序性能；（2）使用C语言实现代码优化器，并进行测试。

6. 目标代码生成（1）设计目标代码生成器，将优化后的中间代码转换为特定目标机的汇编语言；（2）使用C语言实现目标代码生成器，并进行测试。

四、实验结果与分析1. 词法分析实验结果：成功识别输入源代码中的各种词法单元，包括标识符、关键字、运算符、常量等。

2. 语法分析实验结果：成功识别输入源代码的语法结构，包括表达式、语句、程序等。

3. 语义分析实验结果：成功检查语法分析后的语法树，确保语义正确。

4. 中间代码生成实验结果：成功将语义分析后的语法树转换为中间代码，为后续优化和目标代码生成提供基础。

5. 代码优化实验结果：成功对中间代码进行优化，提高程序性能。

6. 目标代码生成实验结果：成功将优化后的中间代码转换为特定目标机的汇编语言，为程序在目标机上运行做准备。

五、实验心得1. 编译原理是一门理论与实践相结合的课程，通过本次实验，我对编译程序的设计原理及实现技术有了更深入的了解。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

编译原理语法分析实验报告-班级:XXX学号:XXX姓名:XXX年月日1、摘要:用递归子程序法实现对pascal的子集程序设计语言的分析程序2、实验目的:通过完成语法分析程序，了解语法分析的过程和作用3、任务概述实验要求:对源程序的内码流进行分析，如为文法定义的句子输出”是”否则输出”否”,根据需要处理说明语句填写写相应的符号表供以后代码生成时使用4、实验依据的原理递归子程序法是一种自顶向下的语法分析方法，它要求文法是LL(1)文法。

通过对文法中每个非终结符编写一个递归过程，每个过程的功能是识别由该非终结符推出的串，当某非终结符的产生式有多个候选式时，程序能够按LL(1)形式唯一地确定选择某个候选式进行推导，最终识别输入串是否与文法匹配。

递归子程序法的缺点是:对文法要求高，必须满足LL(1)文法，当然在某些语言中个别产生式的推导当不满足LL(1)而满足LL(2)时，也可以采用多向前扫描一个符号的办法;它的另一个缺点是由于递归调用多，所以速度慢占用空间多，尽管这样，它还是许多高级语言，例如PASCAL，C等编译系统常常采用的语法分析方法。

为适合递归子程序法，对实验一词法分析中的文法改写成无左递归和无左共因子的,,,如下:<程序>?<程序首部><分程序>。

由于单词在语法分析中作为一个整体，故在语法识别中仅使用其内码。

在这里将词法分析作为语法分析的一个子程序，当语法分析需要单词时，就调用相应的词法分析程序获得一个单词。

语法分析的作用是识别输入符号串是否是文法上定义的句子，即判断输入符号串是否是满足“程序”定义的要求。

也就是当语法识别程序从正常退出表示输入符号串是正确的“程序”;若从出错退出，则输入符号串不是正确的“程序”。

出错时，可以根据读字符的位置判断出错的位置。

表2-1为非终结符和函数名对照表。

表2-1 非终符和函数名对照表非终结符函数名非终结符函数名 <程序> <程序首部> program proghead <分程序> <常量说明部分> block consexpl <常量定义> <变量说明部分> consdefi varexl <常量定义后缀> <变量定义> conssuff vandefi <变量定义后缀> <>过程说明部分> varsuff procdefi <类型> <过程首部> typeil procedh <过程说明部分后缀> <赋值或调用语句> procsuff assipro <语句> <后缀> sentence suffix <条件语句> <读语句> ifsent read <当型循环语句> <标识符后缀> whilsent idsuff <写语句> <复合语句> write compsent <表达式后缀> <语句后缀> exprsuff sentsuff <条件> <项后缀> conditio termsuff <表达式> <项> express term <因子后缀> <参数部分> factsuff argument <因子> <加型运算符> factor addoper <乘型运算符> <关系运算符> muloper respoper 表2-2为词法分析中的内码单词对照表。

表2-2 内部码对照表内码单词内码单词内码单词内码单词 1 PROGRAM 2 CONST 3 VAR 4 INTEGER 5 LONG 6 PROCEDURE 7 IF 8 THEN 9 WHILE 10 DO 11 READ 12 WRITE 13 BEGIN 14 END 15 ODD 16 + 17 - 18 * 19 / 20 = 21 <> 22 < 23 <= 24 > 25 >= 26 . 27 , 28 ; 29 : 30 := 31 ( 32 )无符号整数标识符 33 34 35 #6、实验结果分析样例1:正确的pascal子集程序代码PROGRAM test;CONST b=3;VAR x:INTEGER;y:LONG; PROCEDURE c(d:INTEGER); BEGINd(5);x:=d+4;y:=b*2+2;END;BEGINWHILE x<10 DO x:=x+b;IF x>5 THEN x:=2*x-b;END.运行结果1:样例2:错误的pascal子集程序代码test;CONST b=3;VAR x:INTEGER;y:; PROCEDURE c(d:INTEGER); BEGINd(5);x:=d+4;y:=b*2+;END;BEGINWHILE x<10 DO x:=x+b; IF x>5 x:=2*x-b;END运行结果2:7、总结通过本次实验，我能够用递归子程序法设计、编制、调试一个典型的语法分析程序，实现对词法分析程序所提供的单词序列进行语法检查和结构分析，更加了解了语法分析的过程和作用。

附件:LEX代码:%{#include <stdio.h>#include <stdlib.h>#include <string.h>FILE *fp;int line = 1;%}delim [" "\t]whitespace {delim}+ backspace [\n]program [pP][rR][oO][gG][rR][aA][mM]const [cC][oO][nN][sS][tT] var [vV][aA][rR]integer [iI][nN][tT][eE][gG][eE][rR]long [lL][oO][nN][gG] procedure [pP][rR][oO][cC][eE][dD][uU][rR][eE] if [iI][fF]then [tT][hH][eE][nN] while [wW][hH][iI][lL][eE] do [dD][oO]read [rR][eE][aA][dD] write [wW][rR][iI][tT][eE] begin[bB][eE][gG][iI][nN] end [eE][nN][dD]odd [oO][dD][dD]add \+minus -multiply \*div \/equal =m21 <>m22 <m23 <=m24 >m25 >=m27 ,m26 \.m28 ;m29 :m30 :=m31 \(m32 \)constant ([0-9])+identfier [A-Za-z]([A-Za-z]|[0-9])*%%{program} {fprintf(fp,"%d %d\n",1,line);} {const} {fprintf(fp,"%d%d\n",2,line);} {var} {fprintf(fp,"%d %d\n",3,line);} {integer}{fprintf(fp,"%d %d\n",4,line);} {long} {fprintf(fp,"%d %d\n",5,line);} {procedure} {fprintf(fp,"%d %d\n",6,line);} {if} {fprintf(fp,"%d%d\n",7,line);} {then} {fprintf(fp,"%d %d\n",8,line);} {while}{fprintf(fp,"%d %d\n",9,line);} {do} {fprintf(fp,"%d %d\n",10,line);} {read} {fprintf(fp,"%d %d\n",11,line);} {write} {fprintf(fp,"%d%d\n",12,line);} {begin} {fprintf(fp,"%d %d\n",13,line);} {end}{fprintf(fp,"%d %d\n",14,line);} {odd} {fprintf(fp,"%d %d\n",15,line);} {add} {fprintf(fp,"%d %d\n",16,line);} {minus} {fprintf(fp,"%d%d\n",17,line);} {multiply} {fprintf(fp,"%d %d\n",18,line);} {div} {fprintf(fp,"%d %d\n",19,line);} {equal} {fprintf(fp,"%d %d\n",20,line);} {m21} {fprintf(fp,"%d %d\n",21,line);} {m22} {fprintf(fp,"%d%d\n",22,line);} {m23} {fprintf(fp,"%d %d\n",23,line);} {m24}{fprintf(fp,"%d %d\n",24,line);} {m25} {fprintf(fp,"%d %d\n",25,line);} {m26} {fprintf(fp,"%d %d\n",26,line);} {m27} {fprintf(fp,"%d%d\n",27,line);} {m28} {fprintf(fp,"%d %d\n",28,line);} {m29}{fprintf(fp,"%d %d\n",29,line);} {m30} {fprintf(fp,"%d %d\n",30,line);} {m31} {fprintf(fp,"%d %d\n",31,line);} {m32} {fprintf(fp,"%d%d\n",32,line);} {constant} {__int64 maxnum=0xffffffff;if(strlen(yytext)>10)printf("line %d constant error:'%s'\n",line,yytext);elsefprintf(fp,"%d %d\n",33,line);}{identfier} {if(strlen(yytext)>20){printf("line %d identfier error:'%s'\n",line,yytext);}elsefprintf(fp,"%d %d\n",34,line);}{whitespace} { }{backspace} { if(strcmp(yytext,"\n")==0){line++;}}%%void main(){yyin=fopen("example.txt","r");fp=fopen("data.txt","w");fclose(fp);fp=fopen("data.txt","a");yylex(); /* start the analysis*/fclose(yyin);fclose(fp);}int yywrap(){return 1;}主程序代码:#include<string>#include<iostream>#include<fstream>#include"lex.yy.c"using namespace std;int token[2000][2] = {NULL}; int h = 0;int i,j,p=0;void program();void block();void consdefi();void conssuff(); void varsuff(); void typeil(); void procsuff(); void sentence(); void ifsent(); void whilsent(); void write(); void exprsuff(); void conditio(); void express(); void factsuff(); void factor(); void muloper(); void proghead(); void consexpl(); voidvarexl(); void vandefi(); void procdefi(); void procedh(); void assipro(); void suffix(); void read();void idsuff(); void compsent(); void sentsuff(); void termsuff(); void term();void argument(); void addoper(); void respoper();void program() {proghead();block();if (token[h][0] ==26){h++;if (token[h][0] == 0){printf("语法分析完成\n");}}else{p=1;printf("第%d行缺少.\n",token[h-1][1]);}return;}void proghead(){if (token[h][0] == 1){h++;if (token[h][0] == 34){h++;if (token[h][0] == 28){h++;}else{p=1;printf("第%d行缺少;\n", token[h-1][1]);}}else{p=1;printf("第%d行缺少标识符\n", token[h-1][1]); }}else{p=1;printf("第%d行缺少PROGRAM\n", token[h][1]); if (token[h][0] == 34){h++;if (token[h][0] == 28){h++;}}}}void block() {consexpl();varexl();procdefi();compsent();return;}void consexpl() {if (token[h][0] != 6 && token[h][0] != 3 && token[h][0] != 13) {if (token[h][0] == 2){h++;consdefi();conssuff();if (token[h][0] == 28){h++;}else{p=1;printf("第%d行缺少;\n", token[h-1][1]);}}else{p=1;printf("第%d行缺少CONST\n", token[h][1]); consdefi();conssuff();if (token[h][0] == 28){h++;}}}return;}void consdefi(){if (token[h][0] == 34){h++;if (token[h][0] == 20){h++;if (token[h][0] == 33){h++;}else{p=1;printf("第%d行缺少无符号整数\n", token[h-1][1]); }}else{p=1;printf("第%d行缺少=\n", token[h-1][1]);}}else{p=1;printf("第%d行缺少标识符\n", token[h-1][1]);if (token[h][0] == 20){h++;if (token[h][0] == 33){h++;}}}return;}void conssuff(){if (token[h][0] != 6 && token[h][0] != 3 && token[h][0] != 13) {if (token[h][0] == 28)return;if (token[h][0] == 27){h++;consdefi();conssuff();}else{p=1;printf("第%d行缺少,\n", token[h-1][1]);consdefi();conssuff();}}return;}void varexl(){if (token[h][0] != 6 && token[h][0] != 13) {if (token[h][0] == 3){h++;vandefi();varsuff();}else{p=1;printf("第%d行缺少VAR\n", token[h][1]); vandefi();varsuff();}}return;}void vandefi(){if (token[h][0] == 34){h++;idsuff();if (token[h][0] == 29){h++;typeil();if (token[h][0] == 28){h++;}else{p=1;printf("第%d行缺少;\n", token[h-1][1]); }}else{p=1;printf("第%d行缺少:\n", token[h-1][1]); }}else{p=1;printf("第%d行缺少标识符\n", token[h-1][1]); idsuff();if (token[h][0] == 29){h++;typeil();if (token[h][0] == 28){h++;}}}return;}void idsuff(){if (token[h][0] == 4 || token[h][0] == 5){return;}if (token[h][0] != 32 && token[h][0] != 29){if (token[h][0] == 27){h++;if (token[h][0] == 34){h++;idsuff();}else{p=1;printf("第%d行缺少标识符\n", token[h-1][1]); }}else{p=1;printf("第%d行缺少,\n", token[h-1][1]);}}return;}void varsuff() {if (token[h][0] != 6 && token[h][0] != 13){vandefi();varsuff();}return;}void typeil() {if (token[h][0] == 4||token[h][0]==5){h++;}else{p=1;printf("第%d行缺少INTEGER或LONG\n", token[h-1][1]); }return;}void procdefi(){if (token[h][0] != 13){procedh();block();if (token[h][0] == 28){h++;procsuff();}else{p=1;printf("第%d行缺少;\n", token[h-1][1]); }}return;}void procedh(){if (token[h][0] == 6){h++;if (token[h][0] == 34){h++;argument();if (token[h][0] == 28){h++;}else{p=1;printf("第%d行缺少;\n", token[h-1][1]);}}else{p=1;printf("第%d行缺少标识符\n", token[h-1][1]); }}else{p=1;printf("第%d行缺少PROCEDURE\n", token[h][1]); if (token[h][0] == 34){h++;argument();if (token[h][0] == 28){h++;}}}return;}void read(){if (token[h][0] == 11){h++;if (token[h][0] == 31){h++;if (token[h][0] == 34){h++;idsuff();if (token[h][0] == 32){h++;}else{p=1;printf("第%d行缺少)\n", token[h-1][1]);}}else{p=1;printf("第%d行缺少标识符\n", token[h-1][1]);}}else{p=1;printf("第%d行缺少(\n", token[h-1][1]);}}else{p=1;printf("第%d行缺少READ\n", token[h-1][1]); exit(0);}return;}void ifsent(){if (token[h][0] == 7){h++;conditio();if (token[h][0] == 8){h++;sentence();}else{p=1;printf("第%d行缺少THEN\n", token[h-1][1]); sentence();}}else{p=1;printf("第%d行缺少IF\n", token[h-1][1]); exit(0);}return;}void assipro(){if (token[h][0] == 34){h++;suffix();}else{p=1;printf("第%d行缺少标识符\n", token[h-1][1]);}return;}void procsuff(){if (token[h][0] != 13){procedh();block();if (token[h][0] == 28){h++;procsuff();}else{p=1;printf("第%d行缺少;\n", token[h-1][1]); }}return;}void sentence(){if (token[h][0] != 14 && token[h][0] != 28){if (token[h][0] == 34){assipro();}else if (token[h][0] == 7) {ifsent();}else if (token[h][0] == 9) {whilsent();}else if (token[h][0] == 11) {read();}else if (token[h][0] == 12) {write();}else if (token[h][0] == 13) {compsent();}}return;}void suffix(){if (token[h][0] != 14 && token[h][0] != 28) {if (token[h][0] == 30){h++;express();}else if (token[h][0] == 31){h++;express();if (token[h][0] == 32){h++;}else{p=1;printf("第%d行缺少)\n", token[h-1][1]);}}else{p = 1; printf("第%d行缺少(\n", token[h - 1][1]); }}return;}void whilsent(){if (token[h][0] == 9){h++;conditio();if (token[h][0] == 10){h++;sentence();}else{p=1;printf("第%d行缺少DO\n", token[h-1][1]);}}else{p=1;printf("第%d行缺少WHILE\n", token[h-1][1]); exit(0);}return;}void write(){if (token[h][0] == 12){h++;if (token[h][0] == 31){h++;express();exprsuff();if (token[h][0] == 32){h++;}else{p=1;printf("第%d行缺少)\n", token[h-1][1]);}}else{p=1;printf("第%d行缺少(\n", token[h-1][1]);}}else{p=1;printf("第%d行缺少WRITE\n", token[h-1][1]); exit(0);}return;}void compsent(){if (token[h][0] == 13){h++;sentence();sentsuff();if (token[h][0] == 14){h++;}else{p=1;printf("第%d行缺少END\n", token[h-1][1]); }}else{p=1;printf("第%d行缺少BEGIN\n", token[h-1][1]); sentence();sentsuff();if (token[h][0] == 14){h++;}}return;}void exprsuff() {if (token[h][0] != 32){if (token[h][0] == 27){h++;express();exprsuff();}else{p=1;printf("第%d行缺少,\n", token[h-1][1]); }}return;}void sentsuff() {if (token[h][0] == 28){h++;if (token[h][0] != 14){sentence();sentsuff();}}else{p=1;printf("第%d行缺少;\n", token[h-1][1]);}return;}void conditio() {if (token[h][0] == 15){h++;express();}else{express();respoper();express();}return;}void termsuff() {if (token[h][0] != 21 && token[h][0] != 22 && token[h][0] != 23 && token[h][0] != 24 && token[h][0] != 25 && token[h][0] != 32 && token[h][0] != 28&& token[h][0] != 14 && token[h][0] != 8 && token[h][0] != 10 && token[h][0] !=34){addoper();term();termsuff();}}void express() {if (token[h][0] == 16||token[h][0]==17) {h++;term();termsuff();}else{term();termsuff();}}void term(){factor();factsuff();}void factsuff(){if (token[h][0] != 21 && token[h][0] != 22 && token[h][0] != 23 && token[h][0] != 24 && token[h][0] != 25 && token[h][0] != 32 && token[h][0] != 28&& token[h][0] != 14 && token[h][0] != 16 && token[h][0] != 17 && token[h][0] !=8 && token[h][0] != 10 && token[h][0] != 34){muloper();factor();factsuff();}}void argument(){if (token[h][0] != 28){if (token[h][0] == 31){h++;if (token[h][0] == 34){h++;if (token[h][0] == 29){h++;typeil();if (token[h][0] == 32){h++;}else{p=1;printf("第%d行缺少)\n", token[h-1][1]);}}else{p=1;printf("第%d行缺少:\n", token[h-1][1]);}}else{p=1;printf("第%d行缺少标识符\n", token[h-1][1]); }}else{p=1;printf("第%d行缺少(\n", token[h-1][1]); }}return;}void factor(){if (token[h][0] != 33 && token[h][0] != 34) {if (token[h][0] == 31){h++;express();if (token[h][0] == 32){h++;}else{p=1;printf("第%d行缺少)\n", token[h-1][1]); }}else{p = 1; printf("第%d行缺少标识符或无符号整数\n", token[h - 1][1]); }}else{h++;}return;}void addoper(){if (token[h][0] == 16 || token[h][0] == 17){h++;}else{p=1;printf("第%d行缺少+或-\n", token[h-1][1]);}return;}void muloper(){if (token[h][0] == 18 || token[h][0] == 19){h++;}else{p=1;printf("第%d行缺少*或/\n", token[h-1][1]);}return;}void respoper(){if (token[h][0] == 21 || token[h][0] == 22 || token[h][0] == 23 || token[h][0] == 25|| token[h][0] == 24){h++;}else{p=1;printf("第%d行缺少关系运算符\n", token[h-1][1]);}return;}void main(){mainf();FILE *p1 = fopen("data.txt", "r");if (!p1){printf("文件打开失败～\n");}else{printf("文件打开成功～\n语法分析开始\n"); }i = 0;while (!feof(p1)){for (j = 0; j < 2; j++){fscanf(p1, "%d", &token[i][j]);}i++;}fclose(p1);program();if (p == 0){printf("Success!\n"); }else{printf("Fail!\n");}}。