已有预测分析表时的语法分析

这篇是编译原理的课堂作业实验题

• 题目要求
  为给定文法写预测分析程序，预测分析表已知（虽然求取预测分析表更重要，但是老师要求是给定预测分析表的情况下写预测分析程序），文法如下：
  E–>TE’
  E’–> +TE’|ε
  T–>FT’
  T’–> *FT’|ε
  F–>(E) | i
  预测分析表（太难打了）：

表格	i	+	*	(	)	#
E	E–>TE’			E–>TE’
E’		E’–> +TE’			E’–>ε	E’–>ε
T	T–>FT’			T–>FT’
T’		T’–>ε	T’–> *FT’		T’–>ε	T’–>ε
F	F–>i			F–>(E)

• 设计分析
  预测分析程序的重点应该是预测分析表的创建，但是我猜老师的意思应该是考察我们的编程能力，时间有限，我们只做老师要求的在给定预测分析表的情况下写预测分析程序，关于预测分析表的生成等内容可以在任意编译原理课本上找到，这里不再赘述。
  虽然给定预测分析表，但是编程时还是有很多东西需要考虑，首先是预测分析表用什么存储，我是用了一个Node结构体

struct Node{
    char vn;        //非终结符
    char vt[VT];    //所有终结符
    int p[VT];      //产生式规则
    Node(){
        memset(p,-1,sizeof(p));
    }
};

“vn”用于存储非终结符，“vt”数组存储所有的终结符号，在 p数组中存储预测分析表中，确定非终结符和确定终结符所需要的产生式规则，这里所找到的是产生式规则的索引，我们将产生式存放在一个字符指针数组中

const char* production[]

我们得到的索引就是对应的数组下标（这样存储在数据更多的时候可以节省很多空间）。
数据结构定义好之后，程序实现就很简单了，源代码如下：

• 代码实现

#include<iostream>
#include<cstring>
#include<ctype.h>
#include<cstdio>
#define VT 6    //终结符号个数
#define VN 5    //非终结符号个数
#define MAXLINE 100
using namespace std;
struct Node{
    char vn;        //非终结符
    char vt[VT];    //所有终结符
    int p[VT];      //产生式规则
    Node(){
        memset(p,-1,sizeof(p));
    }
};
Node MTable[VN];
const char* production[]={"Te","Ft","i","+Te","$","*Ft","(E)"}; //所有的产生式右部
void getTable(Node *);      //获得预测分析表
void out(int cnt,const char* st,const char *tex,int j,int k,char c);   //输出当前状态
char st[MAXLINE];       //栈
int sp=0;               //栈顶指针
int main()
{
    int c,l;
    getTable(MTable);
    char tex[MAXLINE];
    memset(st,' ',sizeof(st));
    gets(tex);
    /*
    while((c=getchar())!='#'&& c!=-1)
        *(p++)=c;
    *(p++)=c;
    *p='\0';
    */

    l=strlen(tex);
    tex[l]='#'; tex[l+1]='\0';
    st[sp++]='#';
    st[sp++]='E';
    int cnt=1,i,j,k=0;
    cout<<"步骤"<<"    "<<"分析栈"<<"               "<<"剩余输入串"<<"         "<<"指导所用产生式或函数"<<endl;
    char cur,pd[MAXLINE],*pp;  //pd:production缩写,cur当前栈顶元素
    for(i=0;sp>0;cnt++){
        cur=st[--sp];
        if(st[sp]=='#'){
            st[sp+1]='\0';
            out(cnt,st,tex+i,j,-1,'#');
            continue;
        }
        if(cur==(c=tex[i])&&i<l){
            i++;
            st[sp+1]='\0';
            out(cnt,st,tex+i-1,j,-1,c);
            continue;
        }
        pp=pd;  memset(pd,0,sizeof(pd));
        for(j=0;j<VN;j++)                       //查找该非终结符对应哪个结点
            if(MTable[j].vn==cur)    break;
        if(MTable[j].vn!=cur){
            cout<<"error:不能识别输入的字符串"<<endl;
            break;
        }
        k=0;
        while(k<VT&&MTable[j].vt[k]!=c) k++;    //当前非终结符遇到该终结符对应的产生式规则
        if(k==VT) { cout<<"Error:输入有误"<<endl;    break;}
        k=MTable[j].p[k];       //重用
        st[sp+1]='\0';
        out(cnt,st,tex+i,j,k,'a');


        memcpy(pp,production[k],sizeof(production[k]));
        if(k!=4){       //产生式不为空串'$'
            int len=strlen(pp);
            while(--len>=0) st[sp++]=*(pp+len); //逆序入栈
        }
    }
    return 0;
}
void getTable(Node*t)        //获得预测分析表
{
    t[0].vn='E',t[1].vn='e',t[2].vn='T',t[3].vn='t',t[4].vn='F';    //非终结符
    for(int i=0;i<VT;i++){          //终结符
        t[i].vt[0]='i';     t[i].vt[1]='+';   t[i].vt[2]='*';
        t[i].vt[3]='(';     t[i].vt[4]=')';   t[i].vt[5]='#';
    }
    //下面用来存储相应的产生式的索引
    t[0].p[0]=0;    t[0].p[3]=0;
    t[1].p[1]=3;    t[1].p[4]=4;    t[1].p[5]=4;
    t[2].p[0]=1;    t[2].p[3]=1;
    t[3].p[1]=4;    t[3].p[2]=5;    t[3].p[4]=4;    t[3].p[5]=4;
    t[4].p[0]=2;    t[4].p[3]=6;
}
/*cnt是步骤计数，st是栈底指针，tex是剩余输入符号指针，j表示第j个Node，k表示运用的产生式
 *的索引号，如果k=-1表示一个非终结符匹配成功或者完成接受*/
void out(int cnt,const char* st,const char *tex,int j,int k,char ac)    输出当前状态
{
    char s[MAXLINE],*p,cu[3],cur=MTable[j].vn,pd[MAXLINE],*q;
    p=s;    q=pd;
    int i=0,c;
    while((c=*(st+i))!='\0'){
        if(islower(c)&&c!='i'){
            *(p++)=toupper(c);
            *(p++)='\'';
        }else
            *(p++)=c;
        i++;
    }
    *p='\0';    i=0;
    if(k!=-1){
        while((c=*(production[k]+i))!='\0'){
            if(islower(c)&&c!='i'){
                *(q++)=toupper(c);
                *(q++)='\'';
            }else
                *(q++)=c;
            i++;
        }
    }else
        *(q++)=ac;
    *q='\0';    i=0;
    if(islower(cur)&&cur!='i'){
        cu[i++]=toupper(cur);
        cu[i++]='\'';
    }else
        cu[i++]=cur;
    cu[i]='\0';
    if(k!=-1)
        printf("%4d    %-15s %15s        %-2s-->%s\n",cnt,s,tex,cu,pd);
    else if(ac!='#')
        printf("%4d    %-15s %15s        %s匹配\n",cnt,s,tex,pd);
    else
        printf("%4d    %-15s %15s        接受\n",cnt,s,tex,cu,pd);
}

这个程序可以接受所有的 + *的表达式（要求表达式的字母只能为i）如：
i+i*i、 (i+i)*(i+i)+i 等等

• 程序测试 输入 (i+i)*(i+i)+i
  注意括号为英文符号
  
  

所有的函数都有我编写的时候留下的注释，应该可以看得明白，如有疑问，可以留言，力所能及 乐意解答