文章目录
一 实验目的和要求
1.理解自下而上分析算法的构造思想。
2.理解算符文法和算符优先文法的概念。
3.掌握 FIRSTVT 集、LASTVT 集和算符优先关系表的构造方法。
4.理解素短语和最左素短语的概念，并掌握其寻求方法。
5.理解算符优先分析算法，能够使用某种高级语言实现一个算符优先分析程序。
二 实验内容
编写一个算符优先分析程序，能实现以下功能：
1.输入文法，判断是否为算符文法；
2.构造并输出该文法的每个非终结符的 FIRSTVT 集和 LASTVT 集；
3.构造并输出算符优先分析表，判断是否为算符优先文法，若不是提示无法进行分析；
4.任意输入一个输入串，可得到成功的分析或错误的提示，输出其分析过程或打印语法 分析树。
三 实验过程
产生式为：
E→E+T|T
T→T*F|F
F-> P^ F|P
P→(E)|i
3.1什么是算符文法？
如果一个文法G中的任何产生式的右部候选项都不含两个连续的非终结符，即不含形如 P->…QR…
3.2FIRSTVT和LASTVT
3.2.1构造FIRSTVT
1，FIRSTVT（P）
对算符文法G的每个非终结符P
定义：FIRSTVT（P）={a|P=>a…,或P=>Qa…,a属于VT,Q 属于VN}
2，集合FIRSTVT（P）的构造方法
规则一：若有产生式P→a…或 P→Qa…，则a∈FIRSTVT（P）；
规则二：若a∈FIRSTVT(Q)且有产生式P→Q…，则a∈FIRSTVT（P） ；
规则三：反复使用以上两条规则，直到FIRSTVT（P）不再增大为止。
3.2.3构造LASTVT
1，LASTVT（P）
对算符文法G的每个非终结符P
定义：LASTVT（P）={a|P=>…a,或P=>…aQ,a含于VT,Q 含于VN}
2，集合LASTVT（P）的构造方法
规则一：若有产生式P→…a或 P→…aQ，则a∈LASTVT（P）；
规则二：若a∈LASTVT(Q)且有产生式 P→…Q，则a∈LASTVT（P） ；
规则三：反复使用以上两条规则，直到LASTVT( P)不再增大为止。
3.2.4思路
这个实验和上个实验LL(1)分析，差不多，思路方法都一样。 首先为了提高效率，将产生式进行化简，为了不考虑产生式中的"- 和>"符号 化简如下。
E->E+T
E->T
T->T*F
T->F
F->P^F
F->P
P->(E)
P->i
对于判断是不是算符文法，只要遍历一下产生式 然后if判断一下。对于FIRSTVT集，对每一条产生式使用以上规则，再结合if判断，LASTVT集和FIRSTVT集求法一样。
3.3优先分析表
1，算符优先关系表的构造方法
利用文法G中的每个非终结符P的FIRSTVT集和LASTVT集，我们就能方便地构造文法G的算符优先关系表，其构造方法如下：
规则一：对形如P→…ab…或P→…aQb…的产生式，有a=b；
规则二：对形如P→…aR…的产生式，若有b∈FIRSTVT®，则a<b；
规则三：对形如P→…Rb…的产生式，若有a∈LASTVT®，则a>b；
规则四：对于语句括号#，有#=#，且若a∈FIRSTVT(S)和b∈LASTVT(S)，则有#<a且b>#。
2，思路
首先定义一个char类型的二维数组来存发优先关系（<,>,=）使用之前进行初始化一下，然后遍历产生式，根据上面四个规则进行判断，对表赋值。
在以上算法描述中，为了能够计算#与其它终结符之间的关系，一般在文法的产生式中添加一个新的产生式Z ->#E#
3.4分析过程
一个算符优先文法G的任何句型#N1a1N2a2 … NmamNm+1#的最左素短语是满足如下条件的最左子串：Njaj … NiaiNi+1 :（其中, ai是终结符, Ni是可有可无的非终结符）
aj-1<aj
aj=aj+1，aj+1=aj+2 ，…，ai-1=ai
ai>ai+1
实际分析时，为了便于识别符号串，一般首先将“#”压入分析栈，当分析成功时，分 析栈中只剩下文法的开始符号和“#”。这里，将“#”作为输入串的结束符，并非文法中的 符号。
①移进：将输入串的一个符号移进分析栈。
②归约：发现栈顶呈“可归约串”，并用适当的相应符号去替换这个串。
③接受：宣布最终分析成功，可看作是归约的一种特殊形式。
④报错：发现栈顶内容与输入串相悖，调用出错处理程序进行诊察和校正，并对栈顶内容和输入符号进行调整
最后结果
思路: 栈顶的终结符或者次栈顶的终结符和输入字符a的优先级比较，a的优先级低于栈顶的优先级，就规约。a的优先级高于或者等于栈顶的就移进.
四 使用代码
1，Base.h文件
#ifndef BASE_H_
#define BASE_H_
#include<iostream>
#include<fstream>
using namespace std;
struct Proce{ //用结构体数组来存放产生式
char Left;//存放产生式的左部
char Right[100];//存放产生式的右部
};
struct Myset{
char VN;//用于存放FIRSTVT(P)和LASTVT(P)的非终结符
char VT[100]; //用于存放FIRSTVT(P)和LASTVT(P)的终结符
};
class Base
{
public:
int flag;
struct Proce pro[100]; //产生式
struct Myset firstvt[100]; //firstvt集合
struct Myset lastvt[100]; //lastvt集合
public:
Base() :flag(0){
memset(firstvt, 0, sizeof(firstvt)); //置空字符串
memset(lastvt, 0, sizeof(lastvt));
memset(pro, 0, sizeof(pro));
}
int is_VN(char ch); //判断是否是非终结符，默认大写字母为非终结符，其他为终结符
void is_gram(Proce pro[], int length); //判断文法是否为算符文法
void NoAdd(Myset VNT[], int length1); //去掉集合中重复部分
void FIRSTVT(Proce pro[], Myset firstvt[], int length);//求各非终结符的FIRSTVT集合
void LASTVT(Proce pro[], Myset lastvt[], int length);//求各非终结符的FIRSTVT集合
};
#endif
2，Base.cpp文件
#include "Base.h"
int Base::is_VN(char ch) //判断是否是非终结符，默认大写字母为非终结符，其他为终结符
{
if (ch >= 'A'&&ch <= 'Z')
return 1;
else
return 0;
}
void Base::is_gram(Proce pro[], int length) //判断文法是否为算符文法
{
for (int i = 0; i < length; i++)
{
for (int j = 0; j < strlen(pro[i].Right) - 1; j++)
if (is_VN(pro[i].Right[j]) == 1 && is_VN(pro[i].Right[j + 1]) == 1)//两个非终结符在一起了；
{
flag = 1;
break;
}
}
if (flag == 1)
{
cout << "该文法不是算符文法！" << endl;
return;
}
else
cout << "该文法是算符文法！" << endl;
}
void Base::NoAdd(Myset VNT[], int length1) //去掉集合中重复部分
{
char str1[20];//非终结符
char str2[20][100];//终结符
int length;
for (int i = 0; i < length1; i++)
{
str1[i] = VNT[i].VN;
strcpy(str2[i], VNT[i].VT);//把终结符复制给str2
}
for (int i = 0; i < length1; i++)
memset(VNT[i].VT, 0, sizeof(VNT[i].VT));//清空
for (int i = 0; i < length1; i++)
{
int t = 0;
for (int j = 0; j < strlen(str2[i]); j++)
{
flag = 1;
for (int k = 0; k < t; k++)
if (VNT[i].VT[k] == str2[i][j])//重复了
flag = 0;
if (flag == 1)
VNT[i].VT[t++] = str2[i][j];
}
length = strlen(VNT[i].VT);
}
}
//求各非终结符的FIRSTVT集合
void Base::FIRSTVT(Proce pro[], Myset firstvt[], int length)
{
int m = 0;//非终结符个数，flag记录产生式个数
int j, k;
while (flag < length)//length=9产生式总个数
{
j = 0;
firstvt[m].VN = pro[flag].Left;
while (firstvt[m].VN == pro[flag].Left)
{
if (is_VN(pro[flag].Right[0]) == 0) //P->a...则将a加入firstvt(P)中
firstvt[m].VT[j++] = pro[flag].Right[0];
else if (is_VN(pro[flag].Right[0]) == 1 && is_VN(pro[flag].Right[1]) == 0) //P->Qa...则将a加入firstvt(P)中
firstvt[m].VT[j++] = pro[flag].Right[1];
flag++;
}
m++;
}
for (int i = length - 1; i >= 0; i--) //P->Q...，则将Q中的终结符加入P中
if (is_VN(pro[i].Right[0]) == 1 && pro[i].Left != pro[i].Right[0])
{
for (j = 0; j < m; j++) //E->E跳出
if (firstvt[j].VN == pro[i].Right[0])
break;
for (k = 0; k < m; k++)
if (firstvt[k].VN == pro[i].Left)
break;
strcat(firstvt[k].VT, firstvt[j].VT);//firstvt[j].VT添加到firstvt[k].VT后面（strcat字符串连接函数)
}
NoAdd(firstvt, m);//去重
for (int i = 1; i < m; i++) //集合输出
{
cout << "FIRSTVT(";
cout << firstvt[i].VN << ")" << "=" << "{";
cout << firstvt[i].VT[0];
for (int j = 1; j < strlen(firstvt[i].VT); j++)
cout << "," << firstvt[i].VT[j];
cout << "}" << endl;
}
}
void Base::LASTVT(Proce pro[], Myset lastvt[], int length)//求各非终结符的FIRSTVT集合
{
int m = 0;//非终结符个数，flag记录产生式个数
int j, k, t;
while (flag < length)
{
j = 0;
lastvt[m].VN = pro[flag].Left;//把非终结符赋给VN
while (lastvt[m].VN == pro[flag].Left)
{
t = strlen(pro[flag].Right) - 1;
if (is_VN(pro[flag].Right[t]) == 0) //P->...a则将a加入lastvt(P)中
lastvt[m].VT[j++] = pro[flag].Right[t];
else if (is_VN(pro[flag].Right[t]) == 1 && is_VN(pro[flag].Right[t - 1]) == 0) //P->...aQ则将a加入lastvt(P)中
lastvt[m].VT[j++] = pro[flag].Right[t - 1];
flag++;
}
m++;
}
for (int i = length - 1; i >= 0; i--) //P->...Q，则将Q中的终结符加入P中
{
t = strlen(pro[flag].Right) - 1;
if (is_VN(pro[i].Right[t]) == 1 && pro[i].Left != pro[i].Right[t])
{
for (j = 0; j < m; j++)
if (lastvt[j].VN == pro[i].Right[t])
break;
for (k = 0; k < m; k++)
if (lastvt[k].VN == pro[i].Left)
break;
strcat(lastvt[k].VT, lastvt[j].VT);
}
}
NoAdd(lastvt, m);
for (int i = 0; i < m; i++) //集合输出
{
cout << "LASTVT(";
cout << lastvt[i].VN << ")" << "=" << "{";
cout << lastvt[i].VT[0];
for (j = 1; j < strlen(lastvt[i].VT); j++)
cout << "," << lastvt[i].VT[j];
cout << "}" << endl;
}
}
3，TableStack.h文件
#ifndef TABLESTACK_H_
#define TABLESTACK_H_
#include"Base.h"
class TableStack :public Base
{
char table[50][50]; //存放优先表
int step; //序号
char S[100]; //符号栈
public:
TableStack() :step(1)
{
memset(table, 0, sizeof(table));//置空字符串
memset(S, 0, sizeof(S));
}
void Table(Proce pro[], Myset firstvt[], Myset lastvt[], int length); //优先关系表 //返回非终结符个数
char GetIndex(char a, char b); //找到a，b对应的关系
void control(char *str);
void out();
};
#endif
4，TableStack.cpp文件
#include "TableStack.h"
#include<string>
void TableStack::Table(Proce pro[], Myset firstvt[], Myset lastvt[], int length) //优先关系表
{
char str[50]; //存放终结符
int i, k, i1, i2;
int t = 0;
memset(str, 0, sizeof(str));//初始化
for (i = 0; i < length; i++) //遍历所有的产生式
{
flag = 1;
for (k = 0; k <strlen(pro[i].Right); k++)//找终结符
if (is_VN(pro[i].Right[k]) == 0)
{
for (i1 = 0; i1 < t; i1++)
if (pro[i].Right[k] == str[i1])//已经存在了flag = 0;
flag = 0;
if (flag == 1)
str[t++] = pro[i].Right[k];
}
}
for (i = 0; i < strlen(str); i++)//与习惯保持一致，将#置于最后一个
{
if (str[i] == '#')
swap(str[i], str[strlen(str) - 1]);//#和最后一个交换，把#放最后一个
}
for (i = 1; i <= strlen(str); i++)
{
table[0][i] = str[i - 1]; //第一列的终结符
table[i][0] = str[i - 1]; //第一行的终结符
}
for (int i = 0; i < length; i++)//遍历所有的产生式
{
int length1 = strlen(pro[i].Right);
for (int j = 0; j < length1 - 1; j++)//遍历产生式的右部
{
if (is_VN(pro[i].Right[j]) == 0 && is_VN(pro[i].Right[j + 1]) == 0)//P->...ab...
{
for (i1 = 0; i1 <= strlen(str); i1++)//遍历终结符
for (i2 = 0; i2 <= strlen(str); i2++)
if (table[0][i1] == pro[i].Right[j] && table[i2][0] == pro[i].Right[j + 1])//a=b
{
if (table[i1][i2] != 0) //刚开始表里面的值都为0
{
cout << "该文法不是算符优先文法！" << endl;
return;
}
else//赋值=
table[i1][i2] = '=';
}
}
if (j < length1 - 2 && is_VN(pro[i].Right[j]) == 0 && is_VN(pro[i].Right[j + 2]) == 0 && is_VN(pro[i].Right[j + 1]) == 1)//P->...aQb... #E#,(E)
{
for (i1 = 0; i1 <= strlen(str); i1++)//遍历终结符
for (i2 = 0; i2 <= strlen(str); i2++)
if (table[0][i1] == pro[i].Right[j] && table[i2][0] == pro[i].Right[j + 2])//a=b
{
if (table[i1][i2] != 0)
{
cout << "该文法不是算符优先文法！" << endl;
return;
}
else
{
table[i1][i2] = '=';
}
}
}
if (is_VN(pro[i].Right[j]) == 0 && is_VN(pro[i].Right[j + 1]) == 1)//P->...aQ...且Q=>b...或Q=>Rb...
{ //P->X1 X2...Xi Xi+1.....Xn
for (i1 = 0; table[0][i1] != pro[i].Right[j]; i1++);//a不等于b
for (k = 0; firstvt[k].VN != pro[i].Right[j + 1]; k++);//非终结符P,Q不相等
for (i2 = 0; i2 <= strlen(str); i2++)//遍历终结符
for (t = 0; t < strlen(firstvt[k].VT); t++)//遍历firstvt集合
if (table[i2][0] == firstvt[k].VT[t]) //firstvt(Xi+1)中的每个a Xi<a
{
if (table[i1][i2] != 0)
{
cout << "该文法不是算符优先文法！" << endl;
return;
}
else
table[i1][i2] = '<';
}
}
if (is_VN(pro[i].Right[j]) == 1 && is_VN(pro[i].Right[j + 1]) == 0)//P->...Qb...且Q=>..a或Q=>..aR
{ //P->X1 X2...Xi Xi+1.....Xn
for (t = 0; lastvt[t].VN != pro[i].Right[j]; t++);//非终结符P,Q不相等
for (int k = 0; k < strlen(lastvt[t].VT); k++)//遍历lastvt集合
for (i1 = 0; i1 <= strlen(str); i1++)//遍历终结符
for (i2 = 0; i2 <= strlen(str); i2++)
if (table[0][i1] == lastvt[t].VT[k] && table[i2][0] == pro[i].Right[j + 1])
{ //lastvt(Xi)中的每个a >b
if (table[i1][i2] != 0)
{
cout << "该文法不是算符优先文法！" << endl;
return;
}
else
table[i1][i2] = '>';
}
}
}
}
for (int i = 0; i <= strlen(str); i++)
{
for (int j = 0; j <= strlen(str); j++)
cout << table[i][j] << " ";
cout << endl;
}
cout << "---------------------------------------" << endl;
}
char TableStack::GetIndex(char a, char b) //找到a，b对应的关系
{
int i, j;
for (i = 0; table[0][i] != a; i++);
for (j = 0; table[j][0] != b; j++);
return table[i][j];
}
void TableStack::control(char *str)
{
char a; //输入串里面的每个字符
int flag = 0;
char Q;
int j, k;
cout << "步骤" << "\t\t符号栈" << "\t\t输入串" << "\t\t动作" << endl;
a = str[0];//输入串的第一个字符赋给a
k = 1; //栈顶指针 栈S的深度
S[k] = '#'; //栈里面压#
while (a != '#')
{
a = str[flag++]; //把下一个输入字符读入a中 //N1a1N2a2...aj-1Nj
if (is_VN(S[k]) == 0)//j指向栈顶的终结符
j = k;
else //栈顶是非终结符 j指向它下面的终结符
j = k - 1; //j指向栈的最上面的终结符
while (GetIndex(S[j], a) == '>')//外面a的优先级低于栈顶的 就规约
{
do{ //自栈顶向栈底方向找出最左子串S[i]<S[i+1]…S[j]>a
Q = S[j];
if (is_VN(S[j - 1]) == 0) //j从最左素短语末逐步移向首
j = j - 1;
else
j = j - 2;
} while (S[j] == Q); //S[j]<Q时表明找到了最左素短语的首部
cout << step++ << "\t\t" << S + 1 << "\t\t" << str + flag - 1 << "\t\t归约" << endl;
for (int i = j + 2; i <= k; i++)
S[i] = 0;
k = j + 1;
S[k] = 'N'; //栈顶的这些符号与某一个候选对应相等，就规约到N上
}
if (GetIndex(S[j], a) == '<' || GetIndex(S[j], a) == '=')//外面a的优先级高于或者等于栈顶的 就移进
{
cout << step++ << "\t\t" << S + 1 << "\t\t" << str +flag - 1;
if (a != '#')
{
cout << "\t\t移进" << endl;
}
k = k + 1; //移进来的a就变成了栈顶终结符
S[k] = a;
}
else
{
cout << "抱歉，输入的句子有误" << endl;
return;
}
}
cout << "\t\t接受" << endl << "恭喜您，分析成功" << endl;
cout << "---------------------------------------------------" << endl;
}
void TableStack::out()
{
char str3[100] = { 0 };//用于存放一个产生式子
char str2[100];//用于存放待检测的字符串
char filename[10];//文件名
int length = 0; //记录产生式个数
cout << "请输入文件名：";
cin >> filename;
ifstream fin(filename);
if (!fin)
{
cout << "Cannot open the file.\n"; //未找到对应的文件名的文件
exit(1);
}
while (fin)
{
fin.getline(str3, 100); //读出一个产生式
cout << str3 << endl;
pro[length].Left = str3[0];//产生式的左部
strcpy(pro[length].Right, str3 + 3);
length++;
}
length -= 1;
is_gram(pro, length);
cout << "各非终结符的FIRSTVT集合如下：" << endl;
FIRSTVT(pro, firstvt, length);
cout << "各非终结符的LASTVT集合如下：" << endl;
LASTVT(pro, lastvt, length);
cout << "-------------构造分析表如下------------" << endl;
Table(pro, firstvt, lastvt, length);
cout << "---------------------分析表过程---------------------" << endl;
cout << "请任意输入一个输入串(以#号键结束)：" << endl;
cin >> str2;
control(str2);
}
5，main.cpp文件
//编译器VS2013
#include"TableStack.h"
int main()
{
TableStack s;
s.out();
system("pause");
return 0;
}
五 实验结果
代码总共406行
六 总结
文法存放用，每一条文法都以->为界限，可以分为左半部分和右半部分，左半部分就一个非终结符，所以用结构体来存放。每个文法它是由终结符和非终结符组成，所以用结构体来存放终结符与非终结符。最主要的是分析表的构造，算符优先算符的实现。