编译原理-算符优先

一、实验目的

根据文法求出FirstVT和LastVT，构造算法优先表，根据输入二元组判断正确与否

二、实验内容

2.1任务一：构造FIRSTVT，LASTVT

FIRSTVT计算过程：

(1)若有产生式P->a…或者P->Qa…，则a∈FIRSTVT(P);

(2)若a∈FIRSTVT(Q),且有产生式P->Q…，则a∈FIRSTVT(P);

LASTVT计算过程：

(1)若有产生式P->…a或者P->…aQ，则a∈LASTVT(P);

(2)若a∈LASTVT(Q),且有产生式P->…Q，则a∈LASTVT(P);

2.2任务二：构造算符优先表

(1)对形如 P→…ab…和形如P→…aQb…，有a=b；

(2)对形如 P→…aR…，而b∈FIRSTVT(R)，有a

2.3任务三：根据输入判断结果

(1)读入当前输入符号

(2)若输入符号为数字，则输入符号进OPND，输入指针后移，转第(1)步

(3)若当前输入符号为终结符，则比较当前字符和符号栈栈顶字符的优先级

(4)若输入符号和栈顶的优先级相同，则输入指针后移，符号栈出栈

(5)若输入符号优先级小于栈顶的优先级，则输入符号入符号栈，输入指针后移

(6)若输入符号优先级大于栈顶的优先级，则从数据栈中弹出两个数，符号栈中弹出符号进行计算，结果压入数据栈。继续判断符号栈栈顶和输入符号的优先级

(7)若输入符号为“#”且符号栈只剩一个“#”时，表示判断成功。

三、实验过程

3.1 开发环境

使用Visual Studio 2015开发win32控制台程序

3.2 数据结构设计

3.2.1 使用的宏定义

#define MAXSIZE 10

#define NUM_VT 7

#define NUM_VN 5

3.2.2 定义的结构体

//栈操作

typedef struct Stack

{

char data[MAXSIZE];

int top;

};

3.3 测试数据设计

3.3.1 文法文件“nick.txt”

S->E

E->E+T

E->T

T->T*F

T->F

F->P^F

F->P

P->(E)

P->i

3.3.2 输入文件“Input.txt”

(i,1)

(+,)

(i,2)

(*,)

(i,3)

(#,)

/*
*功能:算符优先
*作者：王文堃
*创建时间：2016/5/15
*/

#include <iostream>
#include <malloc.h>
#include <stack>
using namespace std;

/*
*任务一：构造FIRSTVT,LASTVT
*任务开始时间：2016/5/15
*任务结束时间：2016/5/16
*/

/*
*任务二：构造算符优先表
*任务开始时间：2016/5/17
*任务完成时间：2016/5/17
*/

/*
*任务三：根据输入判断结果
*任务开始时间：2016/5/17
*任务完成时间：2016/5/17
*/
#define MAXSIZE 10
#define NUM_VT 7
#define NUM_VN 5

char WenFa[MAXSIZE][MAXSIZE]; //存放从文件中读取的文法
int g_num_wenfa = 0; //存放文法的个数，初值为0
char vt[NUM_VT] = {'+','*','^','i','(',')','#'}; //所有终结符
char vn[NUM_VN] = {'E','T','F','P','S'}; //存放所有非终结符
int firstvt[NUM_VN][NUM_VT]; //存放每一个非终结符的firstvt
int lastvt[NUM_VN][NUM_VT]; //存放每一个非终结符的lastvt
int labelofch[MAXSIZE]; //存放已ch打头的所有文法的标号
char OPT[NUM_VT][NUM_VT];  //算符优先表

char Input[MAXSIZE][MAXSIZE]; //保存输入
int g_num_input = 0; //存放输入的个数
stack <char> OPTR; //符号栈
stack <char> OPND; //数据栈

/*-----------------------------------------计算FIRSTVT----------------------------------------*/

//读取文法
bool readfromfile(char* str)
{
FILE* fp = fopen(str, "r");
if (fp) //succeed
{
while (EOF != fscanf(fp, "%s", WenFa[g_num_wenfa]))
{
g_num_wenfa++;
}
fclose(fp);
return true;
}
else
{
printf("error to open the file\n");
return false;
}
}

//判断文法中字符是否为终结符
int isVt(char ch)
{
for (int i = 0; i < NUM_VT; i++)
{
if (ch == vt[i])
{
return true;
}
}
return false;
}

//判断文法中字符是否为非终结符
int isVn(char ch)
{
for (int i = 0; i < NUM_VN; i++)
{
if (ch == vn[i])
{
return true;
}
}
return false;
}

//找到以ch开头的文法的下标
int findit(char ch)
{
int num = 0;
for (int i = 0; i < g_num_wenfa; i++)
{
if (WenFa[i][0] == ch)
labelofch[num++] = i;
}
return num; //返回以ch开头文法的个数
}

//将非终结符转换成下标
int Vn2num(char ch)
{
switch (ch)
{
case 'E':
return 0;
break;
case 'T':
return 1;
break;
case 'F':
return 2;
break;
case 'P':
return 3;
break;
case 'S':
return 4;
break;
default:
return -1;
}
}

//将终结符转换成下标
int Vt2num(char ch)
{
switch (ch)
{
case '+':
return 0;
break;
case '*':
return 1;
break;
case '^':
return 2;
break;
case 'i':
return 3;
break;
case '(':
return 4;
break;
case ')':
return 5;
break;
case '#':
return 6;
break;
default:
return -1;
}
}

//求FIRSTVT(ch)
void get_firstvt(char ch)
{
if (isVn(ch)) //对终非结符ch
{
int firstnum = Vn2num(ch); //ch所对应的编号
int num = findit(ch); //找到以该非终结符开头文法的下标
for (int i = 0; i < num; i++)
{
char rightfirst = WenFa[labelofch[i]][3]; //取出文法推到的第一个字符
if (isVt(rightfirst)) //该文法推出的第一个字符是终结符
{
firstvt[firstnum][Vt2num(rightfirst)] = 1;
}
else //该文法推出的第一个字符是非终结符
{
char rightsc = WenFa[labelofch[i]][4];
if (isVt(rightsc)) //判断该非终结符之后的符号是不是终结符
{
firstvt[firstnum][Vt2num(rightsc)] = 1;
}

if (ch != rightfirst)
{
get_firstvt(rightfirst); //计算这个非终结符的firstvt集
int newvn = Vn2num(rightfirst);
for (int j = 0; j < NUM_VT; j++)
{
if (firstvt[newvn][j] == 1)
{
firstvt[firstnum][j] = 1;
}
}
}
}
}

}
}

//计算所有firstvt
void do_firstvt()
{
for (int i = 0; i < NUM_VN; i++)
{
get_firstvt(vn[i]);
}

}

//输出firstvt表
void output_firstvt()
{
int i = 0;
printf("---------------firstvt----------------\n");
printf(" ");
for (i = 0; i < NUM_VT; i++)
{
printf("%5c", vt[i]);
}
printf("\n");
for (i = 0; i < NUM_VN; i++)
{
printf("%c", vn[i]);
for (int j = 0; j < NUM_VT; j++)
{
printf("%5d", firstvt[i][j]);
}
printf("\n");
}
printf("--------------------------------------\n");
printf("\n");
}

/*-----------------------------------------计算LASTVT----------------------------------------*/
//找到下标为num的文法的最后一个字符的下标
int get_last(int num)
{
for (int i = 0; i < MAXSIZE; i++)
{
if (WenFa[num][i] == '\0')
{
return (i-1);
}
}
}

//求LASTVT(ch)
void get_lastvt(char ch)
{
if (isVn(ch)) //对终非结符ch
{
int lastnum = Vn2num(ch); //ch所对应的编号
int num = findit(ch); //找到以该非终结符开头文法的下标
for (int i = 0; i < num; i++)
{
int ilast = get_last(labelofch[i]);
char rightlast = WenFa[labelofch[i]][ilast]; //获得文法的最后一个字符
if (isVt(rightlast)) //该文法推出的最后一个字符是终结符
{
lastvt[lastnum][Vt2num(rightlast)] = 1;
}
else //该文法推出的最后一个字符是非终结符
{
char rightlastsc = WenFa[labelofch[i]][ilast -1]; //文法倒数第二个字符
if (isVt(rightlastsc)) //判断倒数第二个字符是不是终结符
{
lastvt[lastnum][Vt2num(rightlastsc)] = 1;
}

if (ch != rightlast)
{
get_lastvt(rightlast); //计算这个非终结符的lastvt集
int newvn = Vn2num(rightlast);
for (int j = 0; j < NUM_VT; j++)
{
if (lastvt[newvn][j] == 1)
{
lastvt[lastnum][j] = 1;
}
}
}
}
}

}
}

//计算所有lastvt
void do_lastvt()
{
for (int i = 0; i < NUM_VN; i++)
{
get_lastvt(vn[i]);
}
}

//输出lastvt表
void output_lastvt()
{
int i = 0;
printf("----------------lastvt----------------\n");
printf(" ");
for (i = 0; i < NUM_VT; i++)
{
printf("%5c", vt[i]);
}
printf("\n");
for (i = 0; i < NUM_VN; i++)
{
printf("%c", vn[i]);
for (int j = 0; j < NUM_VT; j++)
{
printf("%5d", lastvt[i][j]);
}
printf("\n");
}
printf("--------------------------------------\n");
printf("\n");
}

/*----------------------------------------构造算符优先表---------------------------------------*/
//处理小于的情况,a<FIRSTVT(R)
void do_less(char vtch1, char vnch2)
{
int x = Vt2num(vtch1); //a
int i = Vn2num(vnch2); //firstvt表中的行
for (int j = 0; j < NUM_VT; j++) //遍历firstvt表
{
if (firstvt[i][j] == 1)
OPT[x][j] = '<';
}
}

//处理大于的情况,LASTVT(R)>a
void do_more(char vnch1, char vtch2)
{
int y = Vt2num(vtch2);
int i = Vn2num(vnch1);
for (int j = 0; j < NUM_VT; j++) //遍历LASTVT表
{
if (lastvt[i][j] == 1)
{
OPT[j][y] = '>';
}
}
}

//处理#号
void dosharp()
{
//添加“#=#”
int temp = Vt2num('#');
OPT[temp][temp] = '=';
//添加'#'<FIRSTVT(S)、LASTVT(S)>'#'
for (int i = 0; i < NUM_VT; i++)
{
int x = Vn2num('S');
int j = Vt2num('#');
if (firstvt[x][i] == 1)
{
OPT[j][i] = '<';
}
if (lastvt[x][i] == 1)
{
OPT[i][j] = '>';
}
}
}

//构造算法优先表
void OperatorPrecedence()
{
int i = 0; //循环变量
for (i = 0; i < g_num_wenfa; i++) //对所有的文法
{
int j = 3; //内部循环变量，从推出来的第一个字符开始

while (WenFa[i][j] != '\0') //该文法没有完
{
char ch = WenFa[i][j];
if (isVt(ch)) //判断当前字符是不是终结符
{
//判断下一个字符是不是终结符
if (isVt(WenFa[i][j + 1]))
{
//若是，则这两个终结符的优先级相等
OPT[Vt2num(ch)][Vt2num(WenFa[i][j + 1])] = '=';
}
else
{
//做小于
do_less(ch, WenFa[i][j + 1]);

//继续判断下一个字符是不是终结符
if (isVt(WenFa[i][j + 2]))
{
//若是，则这两个终结符的优先级依然相等
OPT[Vt2num(ch)][Vt2num(WenFa[i][j + 2])] = '=';
}
}
}
else //当前是非终结符
{
if (isVt(WenFa[i][j + 1])) //判断下一个字符
{
//大于
do_more(ch, WenFa[i][j + 1]);
}
}
j++;
}
}
dosharp(); //处理#
}

//输出算符优先表
void output_OPT()
{
int i = 0;
printf("------------------OPT-----------------\n");
printf(" ");
for (i = 0; i < NUM_VT; i++)
{
printf("%5c", vt[i]);
}
printf("\n");
for (i = 0; i < NUM_VT; i++)
{
printf("%c", vt[i]);
for (int j = 0; j < NUM_VT; j++)
{
printf("%5c", OPT[i][j]);
}
printf("\n");
}
printf("--------------------------------------\n");
printf("\n");
}

/*---------------------------------------处理输入判断结果---------------------------------------*/
//从文件中读取输入
bool inputformfile(char* str)
{
FILE* fp = fopen(str, "r");
if (fp) //succeed
{
while (EOF != fscanf(fp, "%s", Input[g_num_input]))
{
g_num_input++;
}
fclose(fp);
return true;
}
else
{
printf("error to open the file\n");
return false;
}
}

//判断输入字符的类型
int judge(char ch)
{
switch (ch)
{
case 'i':
return 0; //表示数字
break;
case '+':
return 1; //表示'+'号
break;
case '*':
return 2; //表示'*'号
break;
default:
return -1;
}
}

//将int行数字传化成char型
int char2int(char ch)
{
if (ch >= 48 && ch <= 57) //数字
{
return ch - 48;
}
}

//处理输入
bool doinput()
{
int iInput = 0; //指向输入下标
//#入符号栈
OPTR.push('#');
while (iInput != (g_num_input-1)  || OPTR.size() != 0) //将输入遍历完
{
char* str = Input[iInput]; //取出第一个输入
int result = judge(str[1]);
if (result == 0) //数字
{
OPND.push(str[3]);
}
else //是符号
{
//判断符号栈顶的符号和当前符号的优先级
int topofstack = Vt2num(OPTR.top());
int topofinput = Vt2num(str[1]);
if (OPT[topofstack][topofinput] == '<') //栈顶小于输入就入栈
{
OPTR.push(str[1]);
}
else if (OPT[topofstack][topofinput] == '>')//否则运算
{
int i = char2int(OPND.top());
OPND.pop();
int j = char2int(OPND.top());
OPND.pop();

int vtnum = Vt2num(OPTR.top());
if (vtnum == 0) //+
{
OPND.push(i + j);
OPTR.pop();
}
else if (vtnum == 1) //*
{
OPND.push(i*j);
OPTR.pop();
}
}
else //如果相等就出栈
{
OPTR.pop();
}
}
if (iInput != (g_num_input-1))
{
iInput++;
}
}

//判断
if (OPTR.size() == 0)
{
return true;
}
else
{
return false;
}
}

int main()
{
if (readfromfile("nick.txt"))
{
do_firstvt();  //构造firstvt
output_firstvt(); //输出firstvt
do_lastvt();  //构造lastvt
output_lastvt(); //输出lastvt
OperatorPrecedence(); //构造算符优先表
output_OPT(); //输出算符优先表

//---
inputformfile("input.txt");
bool result = doinput();
if (result != 0)
{
printf("最终结果正确\n");
}
else
{
printf("最终结果错误\n");
}

}
getchar();
return 0;
}

最终的运算结果是：