算符优先分析器设计实验报告--宁剑
算符优先语法分析设计原理与实现技术实验报告
算符优先语法分析设计原理与实现技术实验报告变更说明一、实验目的：本实验的目的在于在教师的引导下以问题回朔与思维启发的方式，使学生在不断的探究过程中掌握编译程序设计和构造的基本原理和实现技术，启迪学生的抽象思维、激发学生的学习兴趣、培养学生的探究精神和专业素养，从而提高学生发现问题、分析问题和解决问题的能力。
二、实验内容：[实验项目]实现算符优先分析算法，完成以下描述算术表达式的算符优先文法的算符优先分析过程。
G[E]:E→E+T∣E-T∣TT→T*F∣T/F∣FF→(E)∣i[实验说明]终结符号i 为用户定义的简单变量,即标识符的定义。
[设计要求]（1）输入串应是词法分析的输出二元式序列，即某算术表达式“实验项目一”的输出结果。
输出为输入串是否为该文法定义的算术表达式的判断结果；（2）算符优先分析过程应能发现输入串出错；（3）设计两个测试用例（尽可能完备，正确和出错），并给出测试结果。
三、实验环境：操作系统：Windows 7软件：VC++6.0四、程序功能描述：●提供了文件输入方式，且输入的内容为二元式序列；●能够对输入的字符串做出正确的算符优先分析判断，并给出判断结果，判断结果输出到文件，并显示在屏幕；●能发现输入串中的错误，包含非法字符，输入不匹配等；●能够处理一些可预见性的错误，如文件不存在，输入非法等。
五、数据结构设计：六、程序结构描述：●设计方法：本程序采用从文件读取的输入方式，输入的内容需为二元式序列，然后按照算符优先分析的方法对输入的字符串进行分析判断，分析完成后输出判断结果到文件，并在屏幕显示。
程序通过对输入串的检查能够发现输入串中的错误。
程序规定的单词符号及其种别码见下表：算符优先矩阵+ - * / ( ) i #+ > > < < < > < >- > > < < < > < >* > > > > < > < >/ > > > > < > < >( < < < < < = < >) > > > > > >i > > > > > ># < < < < < < < =●算符优先分析法简介基本思路是根据既定的规则构建算符优先矩阵，然后根据算符之间的优先关系寻找输入串中的最左素短语，若找到，则寻找与最左素短语匹配的产生式进行规约；否则进行移进操作，及输入的算符进分析栈。
算符优先实验报告
算符优先实验报告《算符优先实验报告》引言算符优先是一种用于解决算术表达式中运算符优先级的算法，它可以帮助我们在计算表达式时确定运算符的优先级，从而得到正确的计算结果。
本实验旨在通过编写算符优先算法的程序，来深入理解算符优先的原理和应用。
实验目的1. 了解算符优先算法的原理和应用。
2. 掌握算符优先算法的程序设计方法。
3. 实现一个能够正确解析算术表达式并计算结果的程序。
实验内容1. 算符优先算法的原理和应用算符优先算法是一种基于文法的算法，它通过分析运算符之间的优先级和结合性来确定表达式的计算顺序。
在算符优先算法中，每个运算符都有一个优先级，高优先级的运算符先进行计算，低优先级的运算符后进行计算。
此外，算符优先算法还要考虑到运算符的结合性，即左结合或右结合。
2. 算符优先算法的程序设计方法为了实现算符优先算法，我们需要首先定义运算符的优先级和结合性，然后编写程序来解析表达式并按照算符优先规则进行计算。
在程序设计中，我们可以使用栈来辅助进行运算符的优先级判断和计算顺序的确定。
3. 实现一个能够正确解析算术表达式并计算结果的程序在本实验中，我们将编写一个简单的算符优先算法程序，该程序能够正确解析算术表达式并按照算符优先规则进行计算，最终得到正确的计算结果。
实验结果通过本次实验，我们成功实现了一个能够正确解析算术表达式并计算结果的程序。
该程序能够正确地处理不同优先级和结合性的运算符，并得到正确的计算结果。
这表明算符优先算法是一种有效的算法，能够帮助我们正确地处理算术表达式中的运算符优先级问题。
结论通过本次实验，我们深入理解了算符优先算法的原理和应用，并掌握了算符优先算法的程序设计方法。
算符优先算法是一种重要的算法，它在计算表达式时能够帮助我们确定运算符的优先级，从而得到正确的计算结果。
在今后的学习和工作中，我们将继续深入研究算符优先算法，并将其应用到更多的实际问题中。
实验三_算符优先分析算法的设计与实现
实验三 算符优先分析算法的设计与实现（8学时）一、 实验目的根据算符优先分析法，对表达式进行语法分析，使其能够判断一个表达式是否正确。
通过算符优先分析方法的实现，加深对自下而上语法分析方法的理解。
二、 实验要求1、输入文法。
可以是如下算术表达式的文法（你可以根据需要适当改变）：E→E+T|E-T|TT→T*F|T/F|FF→（E）|i2、对给定表达式进行分析，输出表达式正确与否的判断。
程序输入/输出示例：输入：1+2;输出：正确输入：(1+2)/3+4-(5+6/7);输出：正确输入：((1-2)/3+4输出：错误输入：1+2-3+(*4/5)输出：错误三、实验步骤1、参考数据结构char *VN=0,*VT=0;//非终结符和终结符数组char firstvt[N][N],lastvt[N][N],table[N][N];typedef struct //符号对(P,a){char Vn;char Vt;} VN_VT;typedef struct //栈{VN_VT *top;VN_VT *bollow;int size;}stack;2、根据文法求FIRSTVT集和LASTVT集给定一个上下文无关文法，根据算法设计一个程序，求文法中每个非终结符的FirstVT 集和LastVT 集。
算符描述如下：/*求 FirstVT 集的算法*/PROCEDURE insert(P,a);IF not F[P,a] thenbeginF[P,a] = true; //(P,a)进栈end;Procedure FirstVT;Beginfor 对每个非终结符 P和终结符 a doF[P,a] = falsefor 对每个形如 P a…或 P→Qa…的产生式 doInsert(P,a)while stack 非空begin栈顶项出栈，记为(Q,a)for 对每条形如 P→Q…的产生式 doinsert(P,a)end;end.同理，可构造计算LASTVT的算法。
实验二语法分析(算符优先)(1)
实验二语法分析实验报告一、实验题目算符优先分析程序二、实验内容及要求（1）根据给定文法，先求出FirstVt和LastVt集合，构造算符优先关系表（要求算符优先关系表输出到屏幕或者输出到文件）；（2）根据算法和优先关系表分析给定表达式是否是该文法识别的正确的算术表达式（要求输出归约过程）（3）给定表达式文法为：G(E’): E’→#E#E→E+T | TT→T*F |FF→(E)|i(4)分析的句子为:(i+i)*i和i+i)*i三、程序源代码：#include<stdlib.h>#include<stdio.h>#include<string.h>#include<iostream.h>#define SIZE 128char priority[6][6]; //算符优先关系表数组char input[SIZE]; //存放输入的要进行分析的句子char remain[SIZE]; //存放剩余串char AnalyseStack[SIZE]; //分析栈void analyse();int testchar(char x); //判断字符X在算符优先关系表中的位置void remainString(); //移进时处理剩余字符串，即去掉剩余字符串第一个字符int k;void init()//构造算符优先关系表，并将其存入数组中{priority[0][0]='>';priority[0][1]='<';priority[0][2]='<';priority[0][3]='<';priority[0][4]='>';priority[0][5]='>';priority[1][0]='>';priority[1][1]='>';priority[1][2]='<';priority[1][3]='<';priority[1][4]='>';priority[1][5]='>';priority[2][0]='>';priority[2][1]='>';priority[2][2]='$';//无优先关系的用$表示priority[2][3]='$';priority[2][4]='>';priority[2][5]='>';priority[3][0]='<';priority[3][1]='<';priority[3][2]='<';priority[3][3]='<';priority[3][4]='=';priority[3][5]='$';priority[4][0]='>';priority[4][1]='>';priority[4][2]='$';priority[4][3]='$';priority[4][4]='>';priority[4][5]='>';priority[5][0]='<';priority[5][1]='<';priority[5][2]='<';priority[5][3]='<';priority[5][4]='$';priority[5][5]='=';}void analyse()//对所输入的句子进行算符优先分析过程的函数{int i,j,f,z,z1,n,n1,z2,n2;int count=0;//操作的步骤数char a; //用于存放正在分析的字符char p,Q,p1,p2;f=strlen(input); //测出数组的长度for(i=0;i<=f;i++){a=input[i];if(i==0)remainString();if(AnalyseStack[k]=='+'||AnalyseStack[k]=='*'||AnalyseStack[k]=='i'||Analys eStack[k]=='('||AnalyseStack[k]==')'||AnalyseStack[k]=='#')j=k;elsej=k-1;z=testchar(AnalyseStack[j]);//从优先关系表中查出s[j]和a的优先关系if(a=='+'||a=='*'||a=='i'||a=='('||a==')'||a=='#')n=testchar(a);else //如果句子含有不是终结符集合里的其它字符，不合法{printf("错误！该句子不是该文法的合法句子！\n");break;}p=priority[z][n];if(p=='$'){printf("错误！该句子不是该文法的合法句子！\n");return;}if(p=='>'){ for( ; ; ){Q=AnalyseStack[j];if(AnalyseStack[j-1]=='+'||AnalyseStack[j-1]=='*'||AnalyseStack[j-1]=='i'||Ana lyseStack[j-1]=='('||AnalyseStack[j-1]==')'||AnalyseStack[j-1]=='#')j=j-1;elsej=j-2;z1=testchar(AnalyseStack[j]);n1=testchar(Q);p1=priority[z1][n1];if(p1=='<') //把AnalyseStack[j+1]~AnalyseStack[k]归约为N{count++;printf("(%d) %s\t%10c\t%5c%17s\t 归约\n",count,AnalyseStack,p,a,remain);k=j+1;i--;AnalyseStack[k]='N';int r,r1;r=strlen(AnalyseStack);for(r1=k+1;r1<r;r1++)AnalyseStack[r1]='\0';break;}elsecontinue;}}else{if(p=='<') //表示移进{count++;printf("(%d) %s\t%10c\t%5c%17s\t 移进\n",count,AnalyseStack,p,a,remain);k=k+1;AnalyseStack[k]=a;remainString();}else{if(p=='='){z2=testchar(AnalyseStack[j]);n2=testchar('#');p2=priority[z2][n2];if(p2=='='){count++;printf("(%d) %s\t%10c\t%5c%17s\t 接受\n",count,AnalyseStack,p,a,remain);printf("该句子是该文法的合法句子。
编译原算符优先分析实验报告 (2)
编译原理实验报告——算符优先文法分析指导教师：***学号：**********姓名：***【实验名称】算符优先文法分析【实验目的】掌握算符优先分析法的原理，利用算符优先分析法将赋值语句进行语法分析，翻译成等价的四元式表示。
【实验内容】1.算术表达式的文法可以是：（1）S->#E# （2）E->E+T （3）E->T （4）T->T*F （5）T->F （6）F->P^F （7）F->P （8）P->(E) （9）P->i2.根据算符优先分析法，将表达式进行语法分析，判断一个表达式是否正确。
【设计思想】（1）定义部分：定义常量、变量、数据结构。
（2）初始化：设立算符优先关系表、初始化变量空间（包括堆栈、结构体、数组、临时变量等）；（3）控制部分：从键盘输入一个表达式符号串；（4）利用算符优先文法分析算法进行表达式处理：根据优先关系表对表达式符号串进行堆栈（或其他）操作，输出分析结果，如果遇到错误则显示错误信息。
【流程图】【源码】#include <iostream>#include <cstdio>#include <cstdlib>#include <cstring>#include <stack>using namespace std;struct Node1{char vn;char vt;char s[10];}MAP[20];//存储分析预测表每个位置对应的终结符，非终结符，产生式int k;//用R代表E',W代表T',e代表空char G[10][10]={"E->TR","R->+TR","R->e","T->FW","W->*FW","W->e","F->(E)","F->i"};//存储文法中的产生式char VN[6]={'E','R','T','W','F'};//存储非终结符char VT[6]={'i','+','*','(',')','#'};//存储终结符char SELECT[10][10]={"(,i","+","),#","(,i","*","+,),#","(","i"};//存储文法中每个产生式对应的SELECT集char Right[10][8]={"->TR","->+TR","->e","->FW","->*FW","->e","->(E)","->i"};stack <char> stak,stak1,stak2;bool compare(char *a,char *b){int i,la=strlen(a),j,lb=strlen(b);for(i=0;i<la;i++)for(j=0;j<lb;j++){if(a[i]==b[j])return 1;}return 0;}char *Find(char vn,char vt){int i;for(i=0;i<k;i++){if(MAP[i].vn==vn && MAP[i].vt==vt)return MAP[i].s;}return "error";}char * Analyse(char * word){char p,action[10],output[10];int i=1,j,l=strlen(word),k=0,l_act,m;while(!stak.empty())stak.pop();stak.push('#');stak.push('E');printf("_________________________________________________________________________ _______\n");printf("\n 对符号串%s的分析过程\n",word);printf(" 步骤栈顶元素剩余输入串推到所用产生式或匹配\n");p=stak.top();while(p!='#'){printf("%7d ",i++);p=stak.top();stak.pop();printf("%6c ",p);for(j=k,m=0;j<l;j++)output[m++]=word[j];output[m]='\0';printf("%10s",output);if(p==word[k]){if(p=='#'){printf(" 接受\n");return "SUCCESS";}printf(" “%c”匹配\n",p);k++;}else{strcpy(action,Find(p,word[k]));if(strcmp(action,"error")==0){printf(" 没有可用的产生式\n");return "ERROR";}printf(" %c%s\n",p,action);int l_act=strlen(action);if(action[l_act-1]=='e')continue;for(j=l_act-1;j>1;j--)stak.push(action[j]);}}if(strcmp(output,"#")!=0)return "ERROR";}int main (){freopen("in.txt","r",stdin);//freopen("out.txt","w",stdout);char source[100];int i,j,flag,l,m;printf("\n为了方便编写程序，用R代表E',W代表T',e代表空\n\n");printf("该文法的产生式如下：\n");for(i=0;i<8;i++)printf(" %s\n",G[i]);printf("\n该文法的SELECT集如下：\n");for(i=0;i<8;i++){printf(" SELECT(%s) = { %s }\n",G[i],SELECT[i]);}//判断是否是LL(1)文法flag=1;for(i=0;i<8;i++){for(j=i+1;j<8;j++){if(G[i][0]==G[j][0]){if(compare(SELECT[i],SELECT[j])){flag=0;break;}}}if(j!=8)break;}if(flag)printf("\n有相同左部产生式的SELECT集合的交集为空，所以文法是LL（1）文法。
算符优先分析报告法设计与实现
算符优先分析法设计与实现一、实验目的加深对语法分析器工作过程的理解；加强对算符优先分析法实现语法分析程序的掌握；能够采用一种编程语言实现简单的语法分析程序；能够使用自己编写的分析程序对简单的程序段进行语法翻译。
二、实验内容在实验1的基础上，用算符优先分析法编制语法分析程序，语法分析程序的实现可以采用任何一种编程语言和工具。
三、实验要求：1.对语法规则有明确的定义；2.编写的分析程序能够对实验一的结果进行正确的语法分析；3.对于遇到的语法错误，能够做出简单的错误处理，给出简单的错误提示，保证顺利完成语法分析过程；四、实验步骤1.定义目标语言的语法规则；2.求解预测分析方法需要的符号集和分析表；3.依次读入实验一的分析结果，根据预测分析的方法进行语法分析，直到源程序结束；4.对遇到的语法错误做出错误处理。
五、实验报告要求详细说明你的程序的设计思路和实现过程。
实验报告要求用文法的形式对语法定义做出详细说明，说明语法分析程序的工作过程，说明错误处理的实现。
算符优先分析器（综合性实验）一、实验目的掌握 FirstVT和 LastVT集的算法，算符优先分析表的构造算法及其分析过程，并掌握中间代码产生过程。
二、实验内容算术表达式和赋值语句的文法可以是（可以根据需要适当改变）：S→i=EE→E+TE→E-TE→TT→T*FT→T/FT→FF→(E)F→i根据算符优先分析法，将赋值语句进行语法语义分析，翻译成等价的一组基本操作，每一基本操作用四元式表示。
三、实验过程和指导1、构造FirstVT和LastVT集合给定一个上下文无关文法，根据算法设计一个程序，求文法中每个非终结符的 FirstVT 集和LastVT 集。
算符描述如下：/*求 FirstVT 集的算法*/PROCEDURE insert(P,a);IF not F[P,a] thenbeginf[p,a] = true; (P,a)进栈end;Procedure FirstVT;Beginfor 对每个非终结符 P和终结符 a doF[P,a] = falsefor 对每个形如 P→a…或 P→Qa…的产生式 doInsert(P,a)while stack 非空begin栈顶项出栈，记为(Q,a)for 对每条形如 P→Q…的产生式 doinsert(P,a)end;end.2、构造算符优先分析表依据文法和求出的相应FirstVT和 LastVT 集生成算符优先分析表。
实验2 语法分析(算符优先分析)
实验2 语法分析（算符优先分析）一、实验任务：算术表达式的文法：E→ E+T | E-T | TT→ T*F | T/F | FF→（E）| i根据算符优先分析法，将表达式进行语法分析，判断一个表达式是否正确。
二、实验时间：上机2次。
三、实验过程和指导：（一）准备：1.确定算术表达式的文法，设计出算符优先关系表；2.考虑好设计方案，设计出模块结构、测试数据；3.初步编制好程序。
（二）上机实验：上机调试，发现错误，分析错误，逐渐修改完善。
（三）程序要求：程序输入/输出示例：如参考C语言的运算符。
输入如下表达式（以分号为结束）和输出结果：（1）10输出：正确（2）1+2*(15-6)输出：正确（3）(1+2)/3+4- (11+6/7)输出：正确（4）((1-2)/3+4输出：错误，出错位置是（5）1+2-3+(*4/5)输出：错误，出错位置是注意：1.为降低难度，表达式中不含变量（只含无符号整数）；2.可以直接调用此法分析程序，取得单词；3.如果遇到错误的表达式，应输出错误提示信息（该信息越详细越好，最好有详细的出错位置和出错性质说明）；4.测试用的表达式事先放在文本文件中，一行存放一个表达式，同时以分号分割。
同时将预期的输出结果写在另一个文本文件中，以便和输出进行对照；5.对学有余力的同学，可增加功能：当判断一个表达式正确时，输出计算结果，计算过程用浮点表示，但要注意不要被0除。
（四）练习该实验的目的和思路：程序比较复杂，需要利用到大量的编译原理，也用到了大量编程技巧和数据结构，通过这个练习可极大提高编程能力。
程序规模大概为300行。
通过练习，掌握对表达式进行处理的一种方法。
（五）为了能设计好程序，注意以下事情：1.模块设计：将程序分成合理的多个模块（函数），每个模块做具体的同一事情。
2.写出（画出）设计方案：模块关系简图、流程图、全局变量、函数接口等。
3.编程时注意编程风格：空行的使用、注释的使用、缩进的使用、变量合理命名等。
算符优先_实验报告
一、实验目的1. 理解算符优先分析法的原理和过程。
2. 掌握算符优先分析法的实现方法。
3. 通过实验加深对自底向上语法分析方法的理解。
二、实验内容1. 算符优先分析法原理介绍算符优先分析法是一种自底向上的语法分析方法，它通过比较相邻算符的优先次序来识别句型中的句柄，进而执行归约。
该方法的核心是确立文法的终结符之间的优先关系。
2. 实验步骤（1）判断文法是否为OG文法：OG文法要求所有产生式右部至少有一个终结符。
（2）判断文法是否为OPG文法：计算FIRSTVT集、LASTVT集，并构建算符优先矩阵。
（3）对句子进行分析：根据分析表判断句子是否为文法的句子。
（4）实现程序：从文件和键盘读取输入，将结果输出到指定文件和屏幕，并具有一致性。
3. 实验数据（1）文法：g[e]:e->e+t|t（2）测试句子：12+t, t+12, 12+13t, 12+t13三、实验过程1. 判断文法是否为OG文法根据给定的文法，我们可以看到所有产生式右部至少有一个终结符，因此该文法为OG文法。
2. 判断文法是否为OPG文法，并构建算符优先矩阵（1）计算FIRSTVT集FIRSTVT(e) = {t}FIRSTVT(t) = {t}（2）计算LASTVT集LASTVT(e) = {t}LASTVT(t) = {t}（3）构建算符优先矩阵| + - ( ) t e $+ > - - - > > -- > - - - > > -> > > > > > >( > > > > > > >) - - - - - - -t - - - - - - -e - - - - - - -$ - - - - - - -3. 对句子进行分析（1）分析句子“12+t”根据分析表，我们可以得到以下分析过程：12+t -> 12+t -> 12+t -> t -> t（2）分析句子“t+12”根据分析表，我们可以得到以下分析过程：t+12 -> t+12 -> t+12 -> t+12 -> t+12 -> t -> t （3）分析句子“12+13t”根据分析表，我们可以得到以下分析过程：12+13t -> 12+13t -> 12+13t -> 12+13t -> 12+13t -> t -> t（4）分析句子“12+t13”根据分析表，我们可以得到以下分析过程：12+t13 -> 12+t13 -> 12+t13 -> 12+t13 -> 12+t13 -> t13 -> t13 -> t13 -> t -> t四、实验结果1. 测试句子“12+t”分析结果：正确2. 测试句子“t+12”分析结果：正确3. 测试句子“12+13t”分析结果：正确4. 测试句子“12+t13”分析结果：正确五、实验总结通过本次实验，我们深入了解了算符优先分析法的原理和实现方法。
算符优先实验报告
算符优先分析实验报告一、程序功能实现算符优先分析算法，完成以下描述算术表达式的算符优先文法的算符优先分析过程。
G[S]:S->#E#E->E+T|TT->T*F|FF->P^F | PP->(E)|i二、主要数据结构char VT[]定义符号表；struct type{char origin; char array[5]; int length;}定义产生式类型；table[][]定义优先关系矩阵。
三、程序结构int locate(char s[],char c) 辅助函数,在一个字符串中查找某特定字符；int Find(type G[],char s[],int m,int n) 查找与已搜索出的短语对应的产生式,返回该产生式的序号；void doScan()对输入串进行分析的主控函数；void print(char s[],int k,int tag,char str[],int i,char action[])输出分析过程的函数。
在find()和doScan()中调用locate()函数，在doScan()中调用find()和print()函数，在main()中调用doScan()函数。
流程图：Y成功四、程序测试测试句子：i+i*i结果：测试句子：（i+i）*i结果：五、实验总结本实验重点解决算符优先矩阵的构造和算符优先算法的实现，我认为难点是构造优先矩阵，这个就需要掌握方法多练习，优先算法只需将PPT上的流程图一步一步地转化为代码就可以了。
总体来说，本实验比较简单。
THANKS !!!致力为企业和个人提供合同协议，策划案计划书，学习课件等等打造全网一站式需求欢迎您的下载，资料仅供参考。
实验报告 算符优先分析器
实验二算符优先分析器#include "stdio.h"#include "stdlib.h"#include "iostream.h"char data[20][20]; //算符优先关系char s[100]; //模拟符号栈schar 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]; //文法非终结符FIRSTVT集char last[10][10]; //文法非终结符LASTVT集int fflag[10]={0}; //标志第i个非终结符的FIRSTVT集是否已求出int lflag[10]={0}; //标志第i个非终结符的LASTVT集是否已求出int deal(); //对输入串的分析int zhongjie(char c); //判断字符c是否是终极符int xiabiao(char c); //求字符c在算符优先关系表中的下标void out(int j,int k,char *s); //打印s栈void firstvt(char c); //求非终结符c的FIRSTVT集void lastvt(char c); //求非终结符c的LASTVT集void table(); //创建文法优先关系表void main(){int i,j,k=0;printf("请输入文法规则数：");scanf("%d",&r);printf("请输入文法规则：\n");for(i=0;i<r;i++){scanf("%s",st[i]); //存储文法规则，初始化FIRSTVT集和LASTVT集*/first[i][0]=0; /*first[i][0]和last[i][0]分别表示st[i][0]非终极符的FIRSTVT集和LASTVT集中元素的个数*/ last[i][0]=0;}for(i=0;i<r;i++) //判断文法是否合法{for(j=0;st[i][j]!='\0';j++){if(st[i][0]<'A'||st[i][0]>'Z'){printf("不是算符文法!\n");exit(-1);}if(st[i][j]>='A'&&st[i][j]<='Z'){if(st[i][j+1]>='A'&&st[i][j+1]<='Z'){printf("不是算符文法!\n");exit(-1);}}}}for(i=0;i<r;i++){for(j=0;st[i][j]!='\0';j++){if((st[i][j]<'A'||st[i][j]>'Z')&&st[i][j]!='-'&&st[i][j]!='>'&&st[i][j]!='| ')lable[k++]=st[i][j];}}lable[k]='#';lable[k+1]='\0';table();printf("每个非终结符的FIRSTVT集为：\n"); //输出每个非终结符的FIRSTVT集for(i=0;i<r;i++){printf("%c: ",st[i][0]);for(j=0;j<first[i][0];j++){printf("%c ",first[i][j+1]);}printf("\n");}printf("每个非终结符的LASTVT集为：\n"); //输出每个非终结符的LASTVT集for(i=0;i<r;i++){printf("%c: ",st[i][0]);for(j=0;j<last[i][0];j++){printf("%c ",last[i][j+1]);}printf("\n");}printf("算符优先分析表如下:\n");for(i=0;lable[i]!='\0';i++)printf("\t%c",lable[i]);printf("\n");for(i=0;i<k+1;i++){printf("%c\t",lable[i]);for(j=0;j<k+1;j++){printf("%c\t",data[i][j]);}printf("\n");}printf("请输入文法输入符号串以#结束:");scanf("%s",input);deal();}void table(){char text[20][10];int i,j,k,t,l,x=0,y=0;int m,n;x=0;for(i=0;i<r;i++){firstvt(st[i][0]);lastvt(st[i][0]);}for(i=0;i<r;i++){text[x][y]=st[i][0];y++;for(j=1;st[i][j]!='\0';j++){if(st[i][j]=='|'){text[x][y]='\0';x++;y=0;text[x][y]=st[i][0];y++;text[x][y++]='-';text[x][y++]='>';}else{text[x][y]=st[i][j];y++;}}text[x][y]='\0';x++;y=0;}r1=x;printf("转化后的文法为:\n");for(i=0;i<x;i++) //输出转化后的文法规则串{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++)string[i][l]=text[i][j];string[i][l]='\0';}for(i=0;i<x;i++){for(j=1;text[i][j+1]!='\0';j++){if(zhongjie(text[i][j])&&zhongjie(text[i][j+1])){m=xiabiao(text[i][j]);n=xiabiao(text[i][j+1]);data[m][n]='=';}if(text[i][j+2]!='\0'&&zhongjie(text[i][j])&&zhongjie(text[i][j+2])&&!zhong jie(text[i][j+1])){m=xiabiao(text[i][j]);n=xiabiao(text[i][j+2]);data[m][n]='=';}if(zhongjie(text[i][j])&&!zhongjie(text[i][j+1])){for(k=0;k<r;k++){if(st[k][0]==text[i][j+1])break;}m=xiabiao(text[i][j]);for(t=0;t<first[k][0];t++){n=xiabiao(first[k][t+1]);data[m][n]='<';}}if(!zhongjie(text[i][j])&&zhongjie(text[i][j+1])){for(k=0;k<r;k++){if(st[k][0]==text[i][j])break;}n=xiabiao(text[i][j+1]);for(t=0;t<last[k][0];t++){m=xiabiao(last[k][t+1]);data[m][n]='>';}}}}m=xiabiao('#');for(t=0;t<first[0][0];t++){n=xiabiao(first[0][t+1]);data[m][n]='<';}n=xiabiao('#');for(t=0;t<last[0][0];t++){m=xiabiao(last[0][t+1]);data[m][n]='>';}data[n][n]='=';}void firstvt(char c) //求FIRSTVT集{int i,j,k,m,n;for(i=0;i<r;i++){if(st[i][0]==c)break;}if(fflag[i]==0){n=first[i][0]+1;m=0;do{if(m==2||st[i][m]=='|'){if(zhongjie(st[i][m+1])){first[i][n]=st[i][m+1];n++;}else{if(zhongjie(st[i][m+2])){first[i][n]=st[i][m+2];n++;}if(st[i][m+1]!=c){firstvt(st[i][m+1]);for(j=0;j<r;j++){if(st[j][0]==st[i][m+1])break;}for(k=0;k<first[j][0];k++){int t;for(t=0;t<n;t++){if(first[i][t]==first[j][k+1])break;}if(t==n){first[i][n]=first[j][k+1];n++;}}}}}m++;}while(st[i][m]!='\0');first[i][n]='\0';first[i][0]=--n;fflag[i]=1;}}void lastvt(char c) //求LASTVT集{int i,j,k,m,n;for(i=0;i<r;i++){if(st[i][0]==c)break;}if(lflag[i]==0){n=last[i][0]+1;m=0;do{if(st[i][m+1]=='\0'||st[i][m+1]=='|'){if(zhongjie(st[i][m])){last[i][n]=st[i][m];n++;}else{if(zhongjie(st[i][m-1])){last[i][n]=st[i][m-1];n++;}if(st[i][m]!=c){lastvt(st[i][m]);for(j=0;j<r;j++){if(st[j][0]==st[i][m])break;}for(k=0;k<last[j][0];k++){int t;for(t=0;t<n;t++){if(last[i][t]==last[j][k+1])break;}if(t==n){last[i][n]=last[j][k+1];n++;}}}}}m++;}while(st[i][m]!='\0');last[i][n]='\0';last[i][0]=--n;lflag[i]=1;}}int deal(){int i,j;int x,y;int z; //输入串的长度k=1;s[k]='#'; //栈置初值for(i=0;input[i]!='\0';i++); //计算输入串的长度z=i--;i=0;while((a=input[i])!='\0'){if(zhongjie(s[k]))j=k;elsej=k-1;x=xiabiao(s[j]);y=xiabiao(a);if(data[x][y]=='>'){out(1,k,s);printf("%c",a);out(i+1,z,input);printf("规约\n");do{q=s[j];if(zhongjie(s[j-1]))j=j-1;else j=j-2;x=xiabiao(s[j]);y=xiabiao(q);}while(data[x][y]!='<');int m,n,N;for(m=j+1;m<=k;m++){for(N=0;N<r1;N++)for(n=1;string[N][n]!='\0';n++){if(!zhongjie(s[m])&&!zhongjie(string[N][n])){if(zhongjie(s[m+1])&&zhongjie(string[N][n+1])&&s[m+1]==string[N][n+1]){s[j+1]=string[N][0];break;}}elseif(zhongjie(s[m]))if(s[m]==string[N][n]){s[j+1]=string[N][0];break;}}}k=j+1;if(k==2&&a=='#'){out(1,k,s);printf("%c",a);out(i+1,z,input);printf("结束\n");printf("输入串符合文法的定义！\n");return 1; //输入串符合文法的定义}}elseif(data[x][y]=='<'||data[x][y]=='='){ //移进out(1,k,s);printf("%c",a);out(i+1,z,input);printf("移进\n");k++;s[k]=a;i++;}else{printf("\nflase");return 0;}}printf("\nflase");return 0;}void out(int j,int k,char *s){int n=0;int i;for(i=j;i<=k;i++){printf("%c",s[i]);n++;}for(;n<15;n++){printf(" ");}}int xiabiao(char c) //求字符c在算符优先关系表中的下标{int i;for(i=0;lable[i]!='\0';i++){if(c==lable[i])return i;}return -1;}int zhongjie(char c) //判断字符c是否是终极符{int i;for(i=0;lable[i]!='\0';i++){if(c==lable[i])return 1;}return 0;}。
算符优先文法实验报告
《编译原理》课程实验报告实验名称：算符优先文法姓名学号：地点：教师院系：计算机与通信工程学院专业：计算机科学与技术09-2一．实验目的设计、编制并调试一个算符优先法分析程序，加深对算符优先法分析原理的理解。
二．实验内容算术表达式的文法：(1).E → E +T | E －T | T(2).T → T * F | T / F | F(3).F → i |（E）转化后的文法：(1).E → E +T(2).E → E －T(3).E → T(4).T → T * F(5).T →T / F(6).T →F(7).F → i(8).F →（E）根据表达式的文法，首先计算每个非终结符的FIRSTVT和LASTVT：执行算法逐条扫描文法规则，从而构造出文法的算符优先关系表如图所示用算符优先分析法法对该文法进行分析，在每次归约成功后则输出四元式。
四元式形式如下：（op,arg1,arg2,result）其中op是运算符，arg1,arg2分别是第一和第二个运算对象，当op是一目运算时，常常将运算对象定义为arg1.例如，表达式-C和赋值语句X=a的四元式可分别表示为（i）（@，C,-,T）（j）（=，a，-，X）三．源代码：#include<stdio.h>#include<string.h>#include<stdlib.h>#define MAXSIZE 64#define N -10typedef char datatype;typedef struct{datatype data[MAXSIZE];int top;}seqstack;seqstack OPR;seqstack OPT;char *p;int matrix[7][7]={{N,-1,-1,-1,-1,N,1},{N,1,-1,-1,-1,1,1},{N,1,1,-1,-1,1,1},{1,1,1,N,N,1,1},{N,-1,-1,-1,-1,0,N},{N,1,1,N,N,1,1},{-1,N,N,-1,N,N,0}}; int row,line;int count=1;int compare(char m,char n){switch(m){case '=':row=0;break;case '+':row=1;break;case '*':row=2;break;case 'i':row=3;break;case '(':row=4;break;case ')':row=5;break;case '$':row=6;break;default: return -100;break;}switch(n){case '=':line=0;break;case '+':line=1;break;case '*':line=2;break;case 'i':line=3;break;case '(':line=4;break;case ')':line=5;break;case '$':line=6;break;default: return -100;break;}return matrix[row][line];}void OPRsetnull(){OPR.top=-1;}bool OPRempty(){if(OPR.top>=0)return false;elsereturn true;}void OPRpush(char x){if(OPR.top==MAXSIZE-1)printf("上溢!");else {OPR.top++;OPR.data[OPR.top]=x;}}datatype OPRpop(){if(OPRempty()){printf("下溢！");return NULL;}else{OPR.top--;return(OPR.data[OPR.top+1]);}}datatype OPRtop(){if(OPRempty()){return NULL;}elsereturn(OPR.data[OPR.top]); }void OPTsetnull(){OPT.top=-1;}bool OPTempty(){if(OPT.top>=0)return false;elsereturn true;}void OPTpush(char x){if(OPT.top==MAXSIZE-1)printf("上溢!");else{OPT.top++;OPT.data[OPT.top]=x;}}datatype OPTpop(){if(OPTempty()){printf("下溢！");return NULL;}else{OPT.top--;return(OPT.data[OPT.top+1]);}}datatype OPTtop(){if(OPTempty()){return NULL;}else return(OPT.data[OPT.top]);}void output(char opt,char op1,char op2,int num){if(op1=='i'&&op2=='i') printf("(%c,%c,%c,t%d)\n",opt,op1,op2,num);if(op1!='i'&&op2=='i') printf("(%c,t%d,%c,t%d)\n",opt,op1,op2,num);if(op2!='i'&&op1=='i') printf("(%c,%c,t%d,t%d)\n",opt,op1,op2,num);if(op1!='i'&&op2!='i') printf("(%c,t%d,t%d,t%d)\n",opt,op1,op2,num); }void scan(){char opt;char op1,op2;if(*p=='$') OPTpush(*p);p++;while(*p!='$'){if(*p=='i') OPRpush(*p);else {opt=OPTtop();P: switch(compare(opt,*p)){case -1: OPTpush(*p); break;case N: break;case 0: OPTpop(); break;case 1: op1=OPRpop();op2=OPRpop();output(opt,op1,op2,count);OPRpush(count);count++;opt=OPTpop();opt=OPTtop();goto P; break;}}p++;}while(!OPTempty()&&!OPRempty()&&(OPTtop()!='$')){ op1=OPRpop();op2=OPRpop();opt=OPTpop();if(opt!='='){output(opt,op1,op2,count);OPRpush(char(count));count++;}if(opt=='=') printf("(%c,t%d, ,i)\n",opt,count-1);}}void main(){int d;OPRsetnull();OPTsetnull();char ch[]="$i=i*(i*(i+i))*i$";printf("分析语句:");printf("%s\n",ch);p=ch;scan();}四．实验步骤调试程序的结果：。
C.4-算符优先分析法-实验报告
学号
成绩
实 验 报 告
实验题目：算符优先分析法
课程名称：编译原理
主讲教师：
班 级：
实验日期：
提交日期：
1、
实验目的：
采用算符优先分析法对表达式（不包含括号运算）进行分析，并给出四元式。
二、实验内容
在实验1、2的基础上，用算符优先分析法编制语法分析程序。
分析过程：先在算符栈置“＄”，然后开始顺序扫描表达式，若读来的单词符号是操作数，这直接进操作数栈，然后继续读下一个单词符号。分析过程从头开始，并重复进行；若读来的是运算符θ2 则将当前处于运算符栈顶的运算符θ1的入栈优先数f与θ2的比较优先函数g进行比较。
结果
四、我的感想
这次试验可以说是前两个试验的综合了，程序中也很多用到了前两次的代码。对于我自己来说，最难的部分在于将这些思想转换成代码实现出来，很大一部分在于自己平时没有多打代码以及就是对算符优先分析的思想理解得还不够透彻。在写main函数时，因为要调用很多函数，刚开始写的时候陷入了死循环，以及栈函数的各种调用发生错误，说明自己思路还不够清晰。因为这次实验是在考完试后做的，之前对算符优先分析以及四元式的理解不够明白，在这个实验实现成功后，自己能够透彻地了解，知道了算符文法的形式，对给定的算符文法能构造算符优先关系分析表，并判别所给出的文法是否为算符优先文法。同时我也算符优先文法的优缺点以及实际应用中的局限性。
三、程序的改写：
因为这次的实验与前面两次的实验有很大的重合，所以会用到很多之前两次的代码。首先，定义函数：
其中本次需要写的函数有：入栈优先函数f，比较优先函数g，compare，middle，栈函数以及主函数。
1.入栈优先函数f
书上已经给出了入栈优先函数的表，根据输入的符号赋予数值，以便后面方便比较。
算符优先实验报告
算符优先实验报告算符优先实验报告引言算符优先是一种用于描述和分析算术表达式的语法分析方法。
在本次实验中，我们将通过编写一个算符优先分析器来深入理解算符优先算法的原理和应用。
实验目的1. 了解算符优先算法的基本原理和概念；2. 掌握算符优先算法的具体实现方法；3. 实现一个简单的算符优先分析器，用于分析和判断输入的算术表达式是否符合文法规则。
实验过程1. 算符优先的基本原理算符优先算法是一种自底向上的语法分析方法，用于判断算术表达式中运算符的优先级关系。
它通过构建一个算符优先关系表来实现对表达式的分析和判断。
2. 算符优先的概念和定义算符优先表是一个二维表格，行和列分别表示算术表达式中的运算符。
表格中的每个元素表示两个运算符之间的优先关系，可以是大于、小于或等于。
根据这个表格，我们可以判断两个相邻的运算符之间的优先级关系。
3. 算符优先分析器的实现为了实现一个算符优先分析器，我们首先需要构建算符优先表。
算符优先表的构建需要根据文法规则和运算符的优先级来确定。
在本次实验中，我们假设算术表达式中只包含加法和乘法运算符，并且加法运算符的优先级高于乘法运算符。
4. 算符优先分析的过程算符优先分析的过程可以分为两个步骤：扫描和规约。
在扫描过程中，我们从左到右扫描输入的算术表达式，并将扫描到的运算符和操作数依次入栈。
在规约过程中，我们根据算符优先表中的优先关系，将栈中的符号进行规约，直到最终得到一个唯一的非终结符号。
实验结果与分析通过实验，我们成功实现了一个简单的算符优先分析器，并对不同的算术表达式进行了分析和判断。
实验结果表明，算符优先分析器能够准确地判断算术表达式的语法正确性，并且能够正确地处理运算符的优先级关系。
结论算符优先算法是一种常用的语法分析方法，能够有效地判断算术表达式的语法正确性。
通过本次实验，我们深入理解了算符优先算法的原理和应用，并成功实现了一个简单的算符优先分析器。
这对我们进一步学习和应用语法分析方法具有重要的意义。
编译原理 实验3 算符优先分析
编译原理实验3 算符优先分析一、实验目的通过设计编制调试构造FIRSTVT集、LASTVT集和构造算符优先表、对给定符号串进行分析的程序，了解构造算符优先分析表的步骤，对文法的要求，生成算符优先关系表的算法，对给定的符号串进行分析的方法。
二、实验内容1. 给定一文法G，输出G的每个非终结符的FIRSTVT集和LASTVT集。
2. 构造算符优先表。
3. 对给定的符号串进行分析，包含符号栈，符号栈栈顶符号和输入串当前符号的优先级，最左素短语和使用的产生式和采取的动作。
三、程序思路在文法框内输入待判断文法产生式，格式E->a|S,注意左部和右部之间是“->”，每个产生式一行，ENTER键换行。
文法结束再输入一行G->#E#1. 先做文法判断，即可判断文法情况。
2. 若是算符优先文法，则在优先表栏显示优先表。
3. 写入要分析的句子，按回车即可。
4. 在分析过程栏，可以看到整个归约过程情况四、实验结果FunctorFirst.h#include<afx.h>#include<iostream>#include<fstream>#include<string>using namespace std;#define rightlength 20#define product_num 20 // 产生式最多个数#define num_noterminal 26 // 非终结符最多个数#define num_terminal 26 // 终结符最多个数struct Production{char Left;char Right[rightlength];int num;};struct VT{bool vt[num_noterminal][num_terminal];};struct Stack{char P;char a;};class CMyDlg{public:CMyDlg();void InputRule();CString showLastVT();CString showFirstVT();CString shownoTerminal(char G[]);CString showTerminal(char g[]);CString showLeftS(char S[], int j, int k);void InitAll();CString showSentence(CString sen, int start);CString showStack(char S[], int n);void Initarry(char arry[], int n);CString ProdtoCStr(Production prod);int selectProd(int i, int j, char S[]);void preFunctor(CString sen);void insertFirstVT(Stack S[], int &sp, char P, char a);void insertLastVT(Stack S[], int &sp, char P, char a);void ShowPreTable();void createPreTable();char pretable[num_terminal][num_terminal];bool like_Q(Production prod, char Q);void createLastVT();bool likeQ_(Production prod, char Q);bool likeQa_(Production prod);bool like_aQ(Production prod);bool like_a(Production prod);bool likea_(Production prod);bool Dignose(char c);int findg(char c);int findG(char c);void createFirstVT();void createTerminal();void createnoTerminal();void buildProduction(CString s);bool test(CString s);void parse(); // 语法分析CString gram; // 存放文法；Production production[product_num];VT FirstVT;VT LastVT;int locProduct; // 已有产生式个数char G[num_noterminal];char g[num_terminal];int i_G;int i_g;CString m_sen;};FunctorFirst.cpp#include"FunctorFirst.h"CMyDlg::CMyDlg(){}bool CMyDlg::test(CString s) // 测试是否是算符优先文法{bool t = 1;for (int i = 0;i < s.GetLength() - 1;i++)if (s[i] > 64 && s[i] < 91 && s[i + 1]>64 && s[i + 1] < 91){t = 0;break;}return t;}void CMyDlg::InputRule(){string infile;string line;cout <<" 请输入语法文件的路径：";cin >> infile;cout << endl;ifstream input(infile.c_str());if (!input){cout << endl <<"###打不开文件，请确认输入的路径有效###"<< endl;cout <<"请再次运行本程序"<< endl << endl;exit(0);}while (getline(input, line)){if (test(line.c_str()) == 0){cout << endl <<"这不是算符优先文法！"<< endl;exit(0);}buildProduction(line.c_str());}cout << endl <<"这是算符优先文法！"<< endl;input.close();}void CMyDlg::buildProduction(CString s){int i = 0;int j = 0;int k = 0;for (k = 0;k < s.GetLength();k++) // 得到左部{if (s[k] != ' '){production[locProduct].Left = s[k];break;}}for (i = k + 1;i < s.GetLength();i++){if (s[i - 1] == '-'&&s[i] == '>')break;}int temp = i;for (i = temp + 1;i < s.GetLength();i++){if (s[i] != '|'){if (s[i] != ' '){production[locProduct].Right[j] = s[i];j++;production[locProduct].num = j;}}else{locProduct++;production[locProduct].Left = production[locProduct - 1].Left;j = 0;}}locProduct++;}void CMyDlg::createnoTerminal() // 建立非终结符索引{i_G = 0; // 最后一个位置的下一个下标int j = 0;for (int i = 0;i < locProduct;i++){for (j = 0;j < i_G;){if (production[i].Left != G[j])j++;elsebreak;}if (j > i_G - 1){G[i_G] = production[i].Left;i_G++;}}}void CMyDlg::createTerminal() // 建立终结符索引{i_g = 0; // 最后一个位置的下一个下标int j = 0;for (int i = 0;i < locProduct;i++){for (int k = 0;k < production[i].num;k++){char temp = production[i].Right[k];if (Dignose(temp)){for (j = 0;j < i_g;){if (temp != g[j])j++;elsebreak;}if (j > i_g - 1){g[i_g] = temp;i_g++;}}}}}void CMyDlg::createFirstVT() // production已完成，创建FirstVT{int i, j;Stack S[100];int sp = 0;for (i = 0;i < i_G;i++) // 初始化FirstVTfor (j = 0;j < i_g;j++)FirstVT.vt[i][j] = false;for (i = 0;i < locProduct;i++){if (likea_(production[i]))insertFirstVT(S, sp, production[i].Left, production[i].Right[0]);if (likeQa_(production[i]))insertFirstVT(S, sp, production[i].Left, production[i].Right[1]);}while (sp > 0){sp--;char Q = S[sp].P;char a = S[sp].a;for (i = 0;i < locProduct;i++){if (likeQ_(production[i], Q))insertFirstVT(S, sp, production[i].Left, a);}}}void CMyDlg::createLastVT() // 创建Last集{int i, j;Stack S[100];int sp = 0;for (i = 0;i < i_G;i++) // 初始化FirstVT for (j = 0;j < i_g;j++)LastVT.vt[i][j] = false;for (i = 0;i < locProduct;i++){if (like_a(production[i]))insertLastVT(S, sp, production[i].Left,production[i].Right[production[i].num - 1]);if (like_aQ(production[i]))insertLastVT(S, sp, production[i].Left,production[i].Right[production[i].num - 2]);}while (sp > 0){sp--;char Q = S[sp].P;char a = S[sp].a;for (i = 0;i < locProduct;i++){if (like_Q(production[i], Q))insertLastVT(S, sp, production[i].Left, a);}}}int CMyDlg::findG(char c) // 定位c在G中的下标{int i = 0;for (i = 0;i < i_G;i++)if (c == G[i])break;return i;}int CMyDlg::findg(char c) // 定位c在g中的下标{int i = 0;for (i = 0;i < i_g;i++)if (c == g[i])break;return i;}bool CMyDlg::Dignose(char c) // 判断c 是终结符还是非终结符，终结符true，非终结符 false{if (c > 64 && c < 91)return false;elsereturn true;}bool CMyDlg::likea_(Production prod){if (Dignose(prod.Right[0]))return true;elsereturn false;}bool CMyDlg::like_a(Production prod) // 形如P->…a型产生式{if (Dignose(prod.Right[prod.num - 1]))return true;else}bool CMyDlg::like_aQ(Production prod) // 形如P->…aQ型产生式{if (prod.num < 1)return false;else{if (Dignose(prod.Right[prod.num - 2]) && (!Dignose(prod.Right[prod.num - 1])))return true;elsereturn false;}}bool CMyDlg::likeQa_(Production prod){if (prod.num < 1)return false;else{if (Dignose(prod.Right[1]) && (!Dignose(prod.Right[0])))return true;elsereturn false;}}bool CMyDlg::likeQ_(Production prod, char Q){if (prod.Right[0] == Q)return true;elsereturn false;}bool CMyDlg::like_Q(Production prod, char Q){if (prod.Right[prod.num - 1] == Q)return true;else}void CMyDlg::createPreTable() // 创建优先表{// 初始化优先表pretableint i, j;for (i = 0;i < i_g;i++)for (j = 0;j < i_g;j++)pretable[i][j] = ' '; // 表错误for (j = 0;j < locProduct;j++){for (i = 0;i < production[j].num - 1;i++){char xi, xi1, xi2;xi = production[j].Right[i];xi1 = production[j].Right[i + 1];xi2 = production[j].Right[i + 2];if (Dignose(xi) && Dignose(xi1))pretable[findg(xi)][findg(xi1)] = '=';if (i < production[j].num - 2 && Dignose(xi) && Dignose(xi2) && (!Dignose(xi1)))pretable[findg(xi)][findg(xi2)] = '=';if (Dignose(xi) && (!Dignose(xi1))){int N = findG(xi1);for (int k = 0;k < i_g;k++)if (FirstVT.vt[N][k] == true)pretable[findg(xi)][k] = '<';}if ((!Dignose(xi)) && Dignose(xi1)){int N = findG(xi);for (int k = 0;k < i_g;k++)if (LastVT.vt[N][k] == true)pretable[k][findg(xi1)] = '>';}}}}void CMyDlg::ShowPreTable() // 显示相关集合和优先表{CString str = "";str = str +"终结符"+ showTerminal(g) +"\r\n";str = str +"非终结符"+ shownoTerminal(G) +"\r\n";str = str +"First集合：\r\n"+ showFirstVT();str = str +"Lasst集合：\r\n"+ showLastVT();str = str +" | ";int i, j;for (i = 0;i < i_g;i++)str = str + g[i] +" | ";str = str +"\r\n";for (j = 0;j < i_g;j++)str = str +"…………";str +="\r\n";for (i = 0;i < i_g;i++){str = str + g[i] +" | ";for (j = 0;j < i_g;j++)str = str + pretable[i][j] +" | ";str +="\r\n";for (j = 0;j < i_g;j++)str = str +"…………";str +="\r\n";}cout << str.GetBuffer(1000);}void CMyDlg::insertFirstVT(Stack S[], int &sp, char P, char a) {if (FirstVT.vt[findG(P)][findg(a)] == false){FirstVT.vt[findG(P)][findg(a)] = true;S[sp].P = P;S[sp].a = a;sp++;}}void CMyDlg::insertLastVT(Stack S[], int &sp, char P, char a){if (LastVT.vt[findG(P)][findg(a)] == false){LastVT.vt[findG(P)][findg(a)] = true;S[sp].P = P;S[sp].a = a;sp++;}}void CMyDlg::preFunctor(CString sen) // 算符优先分析过程实现{bool tagbreak = true;char S[100];int k = 0;S[k] = '#';int i = 0; // 表下次读入位置int j = 0;//char a;CString show = "";CString temp = "";temp.Format("%-15s %s %15s %-15s%-10s%-15s\r\n\r\n", "符号栈", "关系", "输入串", "最左素短语", "使用产生式", "下步动作");show = show + temp;temp ="";CString s_stack, s_sentence, s_lefts, s_prod, s_action;char s_presymbol;do{a = sen[i];if (Dignose(S[k]))j = k;elsej = k - 1;while (pretable[findg(S[j])][findg(a)] == '>'){s_stack = showStack(S, k);s_presymbol = pretable[findg(S[j])][findg(a)];s_sentence = showSentence(sen, i);char Q;do{Q = S[j];if (Dignose(S[j - 1]))j = j - 1;elsej = j - 2;} while (pretable[findg(S[j])][findg(Q)] == '>' ||pretable[findg(S[j])][findg(Q)] == '=');int n = selectProd(j + 1, k, S);if (n > -1 && n < locProduct){s_lefts = showLeftS(S, j + 1, k);k = j + 1;S[k] = production[n].Left;s_prod = ProdtoCStr(production[n]);s_action ="归约";temp.Format("%-15s %c %15s %-15s %-10s %-15s\r\n", s_stack, s_presymbol, s_sentence, s_lefts, s_prod, s_action);show = show + temp;s_stack ="";s_sentence ="";s_lefts ="";s_prod ="";s_action ="";s_presymbol = ' ';}else{s_stack = showStack(S, k);s_presymbol = 'n';s_prod ="出错";s_sentence = showSentence(sen, i);s_action ="无法归约";temp.Format("%-15s %c %15s %-15s %-10s %-15s\r\n",s_stack, s_presymbol, s_sentence, s_lefts, s_prod, s_action);show = show + temp;s_stack ="";s_sentence ="";s_lefts ="";s_prod ="";s_action ="";s_presymbol = ' ';tagbreak = false;break;}}if (!tagbreak)break;if (pretable[findg(S[j])][findg(a)] == '<' ||pretable[findg(S[j])][findg(a)] == '='){s_stack = showStack(S, k);s_presymbol = pretable[findg(S[j])][findg(a)];s_sentence = showSentence(sen, i);s_action ="入栈";temp.Format("%-15s %c %15s %-15s %-10s %-15s\r\n", s_stack, s_presymbol, s_sentence, s_lefts, s_prod, s_action);show = show + temp;k = k + 1;S[k] = a;s_stack ="";s_sentence ="";s_lefts ="";s_prod ="";s_action ="";s_presymbol = ' ';}else{s_stack = showStack(S, k);s_presymbol = 'n';s_prod ="出错";s_sentence = showSentence(sen, i);s_action ="出错";temp.Format("%-15s %c %15s %-15s %-10s %-15s\r\n", s_stack, s_presymbol, s_sentence, s_lefts, s_prod, s_action);show = show + temp;s_stack ="";s_sentence ="";s_lefts ="";s_prod ="";s_action ="";s_presymbol = ' ';break;}i++;} while (a != '#');show = show +"完成";cout << show.GetBuffer(1000) << endl << endl;}void CMyDlg::parse(){string sen;cout << endl << endl <<" 请输入分析的句子：";cin >> sen;cout << endl << endl;m_sen = sen.c_str();}int CMyDlg::selectProd(int i, int j, char S[]) // 查找产生式{int n = -1;int k = 0;for (k = 0;k < locProduct;k++){if (j - i == production[k].num - 1){int si = i;for (int m = 0;m < production[k].num;m++){if (S[si] == production[k].Right[m] || ((!Dignose(S[si])) &&(!Dignose(production[k].Right[m]))))si++;elsebreak;}if (si == j + 1){n = k;break;}}}return n;}CString CMyDlg::ProdtoCStr(Production prod){CString str = "";str = str +prod.Left +"->";for (int i = 0;i < prod.num;i++)str = str +prod.Right[i];return str;}void CMyDlg::Initarry(char arry[], int n)//初始化数组{for (int i = 0;i < n;i++)arry[i] = ' ';}CString CMyDlg::showStack(char S[], int n)//显示符号栈，n表栈大小{CString str = "";for (int i = 0;i <= n;i++)str = str +S[i];return str;}CString CMyDlg::showSentence(CString sen, int start){CString str = "";for (int i = start;i < sen.GetLength();i++)str = str +sen[i];return str;}void CMyDlg::InitAll(){gram ="";i_G = 0;i_g = 0;locProduct = 0;}// 以下是为了便于显示，将数组型转换成CString型CString CMyDlg::showLeftS(char S[], int j, int k) {CString str = "";for (int i = j;i <= k;i++)str = str +S[i];return str;}CString CMyDlg::showTerminal(char g[]){CString str = "{";for (int i = 0;i < i_g;i++)str = str +g[i] +" ";return str +"}";}CString CMyDlg::shownoTerminal(char G[]){CString str = "{";for (int i = 0;i < i_G;i++)str = str +G[i] +" ";return str +"}";}CString CMyDlg::showFirstVT(){CString str = "";for (int i = 0;i < i_G;i++){str = str +"FirstVT( "+ G[i] +" )={ ";for (int j = 0;j < i_g;j++){if (FirstVT.vt[i][j])str = str + g[j] +' ';}str = str +" }\r\n";}return str;}CString CMyDlg::showLastVT(){CString str = "";for (int i = 0;i < i_G;i++){str = str +"LastVT( "+ G[i] +" )={ ";for (int j = 0;j < i_g;j++){if (LastVT.vt[i][j])str = str + g[j] +' ';}str = str +" }\r\n";}return str;}FFmain.cpp#include"FunctorFirst.h"void main(){CMyDlg ff;ff.gram ="";ff.locProduct = 0; // 已有产生式个数ff.InputRule();ff.createnoTerminal(); // 建立非终结符索引ff.createTerminal(); // 建立终结符索引ff.createFirstVT(); // 建立FirstVTff.createLastVT(); // 建立LastVTff.createPreTable(); // 建立优先表ff.ShowPreTable();ff.parse();if (ff.m_sen[ff.m_sen.GetLength() - 1] != '#') ff.m_sen = ff.m_sen +'#';ff.preFunctor(ff.m_sen);}。
编译原理算符优先算法语法分析实验报告
编译原理算符优先算法语法分析实验报告实验报告：算符优先算法的语法分析一、实验目的本次实验旨在通过算符优先算法对给定的文法进行语法分析，实现对给定输入串的分析过程。
通过本次实验，我们能够了解算符优先算法的原理和实现方式，提升对编译原理的理解和应用能力。
二、实验内容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");}```五、实验结果经过实验，我们成功实现了算符优先算法的语法分析。
编译原理算符优先算法语法分析实验报告
数学与计算机学院编译原理实验报告年级专业学号姓名成绩实验题目算符优先分析法分析器的设计实验日期一、实验目的：设计一个算符优先分析器，理解优先分析方法的原理。
二、实验要求：设计一个算符优先分析器三、实验内容：使用算符优先分析算法分析下面的文法：E’→#E#E →E+T | TT →T*F | FF →P^F | PP →(E) | i其中i可以看作是一个终结符，无需作词法分析。
具体要求如下：1、如果输入符号串为正确句子，显示分析步骤，包括分析栈中的内容、优先关系、输入符号串的变化情况；2、如果输入符号串不是正确句子，则指示出错位置。
四、实验结果及主要代码：1.主要代码void operatorp(){char s[100];char a,Q;int k,j,i,l;string input,temp;cin>>input;cout<<"步骤"<<'\t'<<"栈"<<'\t'<<"优先关系"<<'\t'<<"当前符号"<<'\t'<<"剩余输入串"<<'\t'<<"移进或归约"<<endl;k=1;s[k]='#';i=1;do{a=input[0];temp="";for(l=1;l<();l++)temp+=input[l];input=temp;if(svt(s[k])) j=k;else j=k-1;while (search(s[j],a)=='>'){cout<<'('<<i<<')'<<'\t'; //步骤temp="";for(l=1;l<k+1;l++)temp+=s[l];cout<<temp<<'\t'; //栈cout<<'>'<<'\t'<<setw(10); //优先关系cout<<a<<'\t'<<setw(15); //当前符号cout<<input<<'\t'<<setw(15); //剩余输入串i++;for(;;){Q=s[j];if(svt(s[j-1])) j=j-1;else j=j-2;if(search(s[j],Q)=='<'){cout<<"归约"<<endl;//归约break;}}temp="";for(l=j+1;l<k+1;l++)temp+=s[l];for(l=0;l<6;l++)if(temp==key[l]){k=j+1;s[k]=v[l];break;}}cout<<'('<<i<<')'<<'\t'; //步骤temp="";for(l=1;l<k+1;l++)temp+=s[l];cout<<temp<<'\t'; //栈if(search(s[j],a)=='<'){cout<<'<'<<'\t'<<setw(10);; //优先关系cout<<a<<'\t'<<setw(15); //当前符号cout<<input<<'\t'<<setw(15); //剩余输入串cout<<"移进"<<endl;i++;k=k+1;s[k]=a;} //移进else if(search(s[j],a)=='Y'){cout<<'='<<'\t'<<setw(10);; //优先关系cout<<a<<'\t'<<setw(15); //当前符号cout<<input<<'\t'<<setw(15); //剩余输入串cout<<"接受"<<endl;i++;}else{cout<<''<<'\t'<<setw(10);; //优先关系cout<<a<<'\t'<<setw(15); //当前符号cout<<input<<'\t'<<setw(15); //剩余输入串cout<<"出错"<<endl;exit(0);}//出错}while(a!='#');}2.实验结果。
实验三(算符优先分析)
实验三算符优先分析
一．实验目的
1、掌握算符优先分析法——一种自底向上的语法分析方法的思想。
2、领会算符优先关系表转换成优先函数的方法。
二．实验内容
在TINY计算机语言的编译程序的词法分析部分实现的基础上，根据课堂讲授的形式化算法，编制程序实现一个算符优先分析器
语法分析的输入是记号串，按照从左到右扫描，按照文法规则的要求，判断表达式是否符合文法要求，如果符合要求则形成语法树，求出表达式的值，不符合则指出原因。
为了简化程序的编写，对表达式语法有具体如下的要求：
（1）E->E+E | E-E | E*E | E/E | (E) | id
（2）表达式的数只是整数
（3）表达式中没有变量
（4）要分析的表达式满足下面的算符优先矩阵
三．实验要求
要求实现语法分析程序的以下功能：
（1）把表达式首先经过词法分析形成二元式记号提供给语法分析程序
（2）如果符合语法要求，形成一个语法树
（3）如果出现错误，指出错误的位置和类型
（4）把语法树按照树的前序遍历的形式把所有的结点打印输出
（5）按照某种规则计算出表达式的值。
算符优先分析器设计
算符优先分析器设计1实验目的（1）掌握算符优先分析法——一种自底向上的语法分析方法的思想。
（2）能识别算符优先分析法中的可规约串——最左素短语。
（3）领会算符优先关系表转换成优先函数的方法。
2实验内容和实验要求根据形式化算法，编制程序实现一个算符优先分析器，能对常见的算术表达式语句进行分析。
要求实现以下功能：1) 组织算术表达式的输入；2) 组织算符优先关系表或者优先函数的输入；3) 若输入的符号串是一个算术表达式语句，则输出一个分析树骨架（既每一步规约用到的最左素短语），否则输出一个错误信息。
3待分析的语法描述E->E+T|TT->T*F|FF->(E)| I4算法描述4.1算府分析法基本方法实现算法，转化成某种高级语言程序，实现一个算符优先分析器。
其中要用到分析栈和输入缓冲器，本实验采用的方法是一种自底向上的语法分析方法，所以是在词法分析的基础上进行的。
对于表达式结果的计算，要在算法中引入内部变量来保存结果，另外在分析过程中，除了移进、规约、接受、报错等动作外，还要引入计算的动作。
4.2实现方法（1）首先定义char precede（char a,char c），在这里规定算符（终结符之间）的优先规则，在分析文法的时候便于调用。
（2）再定义 isn(char c)，判断是否为非终结符，返回值为1和0，用于循环调用。
（3）主函数，总控算法：1．定义栈堆Stack中的变量，以及控制指针（用于存发归约或者待形成最左素短语的符号串）。
2．用string工作单元存放当前输入的字符，归约成功的标志是当读入的输入字符是句子的结束符号#号时，即栈中只是剩下#T的时候（栈Stack中只剩下开始标志# 和终结符号T的时候）使用判断是否栈顶指针指向的是#，若不是，则继续顺序扫描子过程。
从输入符号串中依次读入字符到string中，调用char precede（char a,char c）中进行分析是否要归约，还是要移进输入符，再栈S中形成最左素短语。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
编译原理实验报告题目： 算符优先分析法分析器学 院 计算机科学与技术 专 业 xxxxxxxxxxxxxxxx 学 号 xxxxxxxxxxxx 姓 名 宁剑 指导教师 xxxx 2015年xx 月xx 日 算符优先分析法分析器装订线一、实验目的1.理解自底向上优先分析，比较和自顶向下优先分析的不同。
2.理解算符优先分析的特点，体会其和简单优先分析方法的不同。
3.加深对编译器语法分析的理解。
二、实验原理1.自底向上优先分析方法，也称移进-归约分析，粗略地说它的思想是对输入符号串自左向右进行扫描，并将输入符号逐个移入一个后进先出栈，边移入边分析，一旦栈顶符号串形成某个句型的句柄或可归约串时，就将该产生式的左部非终极符代替相应的右边文法符号串。
2.算符优先分析法的基本思想首先确定算符（确切地说是终结符）之间的优先关系和结合性质，然后借助这种关系，比较相邻算符之间的优先级来确定句型的可归约串，并进行归约。
注意：算符优先分析过程是自下而上的归约过程，但它的可归约串未必是句柄，也就是说，算符优先分析过程不是一种规归约。
3.终结符号间优先关系的确定，用FIRSTVT和LASTVT计算。
4.最左素短语所谓素短语是指这样一个短语，它至少含有一个终结符，并且除它自身之外不再含有其它素短语。
最左素短语是指处于句型最左边的那个素短语。
最左素短语是算符优先分析算法的可归约串。
5.计算得到所给文法的算符优先矩阵6.算符优先分析的基本过程三、实验要求使用算符优先分析算法分析下面的文法：E’→#E#E→E+T|TT→T*F|FF→P^F|PP→(E)|i其中i可以看作是一个终结符，无需作词法分析。
具体要求如下：1.如果输入符号串为正确句子，显示分析步骤，包括分析栈中的容、优先关系、输入符号串的变化情况；2.如果输入符号串不是正确句子，则指示出错位置。
四、实验结果（程序）及分析#include <stdio.h>#include <cstring>#include <iostream>#include <iomanip>#define MAX 100using namespace std;char S[MAX];char shuru[MAX],yu[MAX];void scanner();int panyouxian(char x);void shengyuchuan();int k;char youxian[7][7]={{'>','<','<','<','<','>','>'},{'>','>','<','<','<','>','>'},{'>','>','<','<','<','>','>'},{'>','>','>','$','$','>','>'},{'<','<','<','<','<','=','$'},{'>','>','>','$','$','>','>'},{'<','<','<','<','<','$','='},}; //优先关系表，其中>为大于，<为小于，=为等于，$为空格int main(){int l,j;cout<<"请输入一个字符串:";cin.get(shuru,MAX); //将输入的字符串存到数组cout<<"步骤栈优先关系当前符号剩余输入串移进或归约"<<endl;k=0;S[k]='#';S[k+1]='\0';l=strlen(shuru); //求输入字符串的长度for(j=0;j<l;j++)yu[j]=shuru[j];yu[j]='\0';scanner();return 0;}void scanner() //扫描分析输入串{int i,j,l,h1,l1,h2,l2,h3,l3,y1,y2,r1,r2;int step=0;//分析步骤数char a; //存放正在分析的字符char p1,Q,p2;l=strlen(shuru); //算出输入串长度for(i=0;i<l;i++){a=shuru[i];if(S[k]=='+'||S[k]=='*'||S[k]=='^'||S[k]=='i'||S[k]=='('||S[k]==')'||S [k]=='#')j=k;elsej=k-1;h1=panyouxian(S[j]);// 从优先关系表中查出S[j]和a的优先关系if(a=='+'||a=='*'||a=='^'||a=='i'||a=='('||a==')'||a=='#') l1=panyouxian(a);else //如果句子含有不是终结符集合里的其它字符，不合法{cout<<"错误!不合法的句子!"<<endl;break;}p1=youxian[h1][l1];if(p1=='>'){loop:Q=S[j];if(S[j-1]=='+'||S[j-1]=='*'||S[j-1]=='^'||S[j-1]=='i'||S[j-1]=='('||S[j-1]= =')'||S[j-1]=='#')j=j-1;elsej=j-2;h2=panyouxian(S[j]);l2=panyouxian(Q);p1=youxian[h2][l2];if(p1=='<') //S[j+1]…S[k]归约为F{k=j+1;shengyuchuan();step++;cout<<left<<"("<<step<<setw(6)<<")"<<setw(10)<<S<<setw(10)< <p1<<setw(10)<<a<<setw(5)<<right<<yu<<setw(15)<<"归约"<<endl;i--;S[k]='F';r1=strlen(S);for(r2=k+1;r2<r2;r2++)S[r2]='\0';//多个字符归约，把栈顶后面的舍弃y1=strlen(yu);for(y2=0;y2<y1;y2++)yu[y1-y2]=yu[y1-y2-1];yu[0]='i';}elsegotoloop;}else{if(p1=='<') //移进如果上一步是不归约，剩余的字符串减少一个{shengyuchuan();shuru[l]='\0';step=step+1;cout<<left<<"("<<step<<setw(6)<<")"<<setw(10)<<S<<setw(10)< <p1<<setw(10)<<a<<setw(5)<<right<<yu<<setw(15)<<"移近"<<endl;k=k+1;S[k]=a;}else{if(p1=='='){h3=panyouxian(S[j]);l3=panyouxian('#');p2=youxian[h3][l3];if(p2=='='){shengyuchuan();step++;cout<<left<<"("<<step<<setw(6)<<")"<<setw(10)<<S<<setw(10)< <p1<<setw(10)<<a<<setw(5)<<right<<yu<<setw(15)<<"接受"<<endl;cout<<"合法的句子!"<<endl;;break;}else{k=k+1;S[k]=a;}}else{cout<<"出错!"<<endl;break;}}}}}void shengyuchuan() {int i,j;i=strlen(yu);for(j=0;j<i;j++)yu[j]=yu[j+1];yu[i-1]='\0';}int panyouxian(char x) {int m;switch(x){case'+':m=0;break;case'*':m=1;break;case'^':m=2;break;case'i':m=3;break;case'(':m=4;break;case')':m=5;break;case'#':m=6;break;}return m;}输入的程序界面如图：输入一个正确的句子，结果如下：输入一个错误的句子，提示为不合法的句子：。