编译原理实验3_语法分析程序 LL（1）

实验目的：

根据某一文法编制调试 LL（1）分析程序，以便对任意输入的符号串进行分析。本次实验的目的主要是加 深对预测分析 LL（1）分析法的理解。

实验环境：

Windows 10  Clion

实验步骤：

1、改造文法：消除左递归、提取左因子 将文法改造为： E－>TE’ E’－>+TE|ε T－>FT’ T’－>*FT’|ε F－> (E)|i

2、求出 firstt 和 follow FIRST(α)的 构造：

设α∈(VN∪VT)*，α=X1X2…Xn，FIRST(α)：

（1）若α=ε，则FIRST(α)={ε}；

（2）若α≠ε，则FIRST(α) \ {ε} ⊂ FIRST(X)；

（3）若X1X2…Xi－1⇒ * ε , 则： FIRST(Xi) \ {ε} ⊂ FIRST(α);

（4）若X1X2…Xn⇒ *ε , 则ε∈ FIRST(α) 对于X∈(VN∪VT），

FIRST(X) 的构造:

（1）若X∈ VT，则FIRST(X)={X}；

（2）若X∈ VN，且有产生式X→a…，a∈ VT ，则：a∈FIRST(X)，如果X→ ε，那么ε∈FIRST(X)；

（3）若有产生式X→Y…,Y ∈ VN ,则：FIRST(Y)\ {ε} ⊂ FIRST(X)；

（4）如果有产生式X→Y1Y2…YK，其中Y1，Y2，Yi－1 ∈VN 且Y1Y2…Yi－1⇒* ε , 则FIRST(Yi)\ {ε} ⊂ FIRST(X)；

（5）若Y1Y2…YK ⇒* ε，则ε ∈ FIRST(X)。

FOLLOW(U) 的 构造：

（1）# ∈FOLLOW(S)

（2）如果有产生式A→xUy，那么FIRST(y)\{ε} ⇒FOLLOW(U)。

（3）如果有产生式A→xU 或则 A→xUy 且y⇒*ε，那么FOLLOW(A) ⇒FOLLOW(U)

3、LL（1）文法的判定：

对于文法G 的每一个非终结符U 的产生式：U→α1|α2|…|αn 。

如果文法G 是一个LL(1) 文法，则有SELECT(U→αi)∩SELECT(U→αj)=Ф (i≠j，i，j=1，2，…，n)。

4、SELECT 集的构造： SELECT(U→α)= FIRST(α)， 当α 不空 ＝FIRST(α)∪FOLLOW(U)， 当α 为空 对于上面的方法可以得到： first（E）= first（E）= first（E）={(,i} first（E’）={+,ε} first（T’）={*,ε} follow(E)=follow(E’)={ ),#} follow(T)=follow(T’)={+, ),#} follow(F)={*,+,),#}

（3）构造预测分析表

5、LL（1）分析表构造算法：

对于每个产生式U→α，执行下一步骤：

1、对于每个终结符号：a∈FIRST(α)，M[U，a]=‘U→α’.

2、如果e∈FIRST(α )，对于每个终结符号：b∈FOLLOW(U)，M[U，b]=‘U→α’。

3、将其它未定义的分析元素置为 ERROR。

6、自下而上分析技术： 从输入符号串出发，试图把它规约为识别符号。自下而上分析技术是一种“移进－归约”法。从输入符 号串开始，从左到右进行扫描，将输入符号逐个移入一个栈中，边移入边分析，一旦栈顶符号串形成某个 产生式的右部时，就用该产生式的左部非终结符代替，称为归约。重复这一过程，直到归约到栈中只剩下文法的开始符号时，则分析成功， 称为“移进－归约”方法。

程序设计：

#include<iostream>
#include<stdio.h>
#include <string>
#include <stack>
using namespace std;
char Vn[]={'E','e','T','t','F'}; //定义文法的非终结符，小写字母 e 表示 E’
char Vt[]={'i','+','*','(',')','#'}; //定义文法的终结符
int LENVt=sizeof(Vt);
void showstack(stack <char> st) //从栈底开始显示栈中的内容
{
    int i,j;
    char ch[100];
    j=st.size();
    for(i=0;i<j;i++)
    {
        ch[i]=st.top();
        st.pop();
    }
    for(i=j-1;i>=0;i--)
    {
        cout<<ch[i];
        st.push(ch[i]);
    }
}

int find(char c,char array[],int n) //查找函数，返回布尔值
{
    int i;

    int flag=0;
    for(i=0;i<n;i++)
    {
        if(c==array[i])
        flag=1;
    }
    return flag;
}

int location(char c,char array[]) //定位函数,指出字符所在位置，即将字母转换为数组下标值
{
    int i;
    for(i=0;c!=array[i];i++);
    return i;
}
void error()
{
    cout<<" 出错!"<<endl;
}
void analyse(char Vn[],char Vt[],string M[5][6],string str)
{
    int i,j,p,q,h,flag=1;
    char a,X;
    stack <char> st; //定义堆栈
     st.push('#');
    st.push(Vn[0]); //#与识别符号入栈
    j=0; //j 指向输入串的指针
h=1;
    a=str[j];
    cout<<"步骤 "<<"分析栈 "<<"剩余输入串 "<<" 所用产生式"<<endl;
    while(flag==1)
    {
        cout<<h<<" "; //显示步骤
        h++;
        showstack(st); //显示分析栈中内容
        cout<<" ";
        for(i=j;i<str.size();i++) cout<<str[i]; //显示剩余字符串
        X=st.top(); //取栈顶符号放入 X
        if(find(X,Vt,LENVt)==1) //X 是终结符
        if(X==a) //分析栈的栈顶元素和剩余输入串的第一个元素相比较
        if (X!='#')
        {
            cout<<" "<<X<<"匹配"<<endl;

            st.pop();
            a=str[++j]; //读入输入串的下一字符
        }
        else
        {
            cout<<" "<<"接受!"<<endl<<endl; flag=0;
        }
        else
        {
            error();break;
        }
        else
        {
            p=location(X,Vn); //实现下标的转换（非终结符转换为行下标）
            q=location(a,Vt); //实现下标的转换（终结符转换为列下标）
            string S1("NULL"),S2("null");
            if(M[p][q]==S1 || M[p][q]==S2) //查找二维数组中的产生式
                {error();break;} //对应项为空，则出错
            else
            {
                string str0=M[p][q];
                cout<<" "<<X<<"-->"<<str0<<endl; //显示对应的产生式
                st.pop();
                if(str0!="$") //$代表“空”字符
                for(i=str0.size()-1;i>=0;i--) st.push(str0[i]);//产生式右端逆序进栈
            }
        }
    }
}
int main()
{
    string M[5][6]={"Te" ,"NULL","NULL","Te", "NULL","NULL",
 "NULL","+Te" ,"NULL","NULL","$", "$",
"Ft", "NULL","NULL","Ft", "NULL","NULL",
"NULL","$", "*Ft", "NULL","$", "$",
"i", "NULL","NULL","(E)", "NULL","NULL"}; //预测分析表 j
    string str;
    int errflag,i;
    cout<<"文法：E->E+T|T T->T*F|F F->(E)|i"<<endl;
    cout<<"请输入分析串（以#结束）："<<endl;
    do
    {
        errflag=0;
        cin>>str;
        for(i=0;i<str.size();i++)
        if(!find(str[i],Vt,LENVt))
        {
            cout<<"输入串中包含有非终结符"<<str[i]<<"(输入错误)!"<<endl;
            errflag=1;
        }

    } while(errflag==1); //判断输入串的合法性
    analyse(Vn, Vt, M,str);
    return 0;
}

结果展示：

分析：

结论及其设计思路：

1. 改造文法：消除左递归、提取左因子；
2. 求出 first 和 follow；
3. 判定LL（1）文法： 对于文法G 的每一个非终结符U 的产生式；U→α1|α2|…|αn 。如果文法G 是一个LL(1) 文法，则有SELECT(U→αi)∩SELECT(U→αj)=Ф (i≠j，i，j=1，2，…，n)；
4. SELECT 集的构造；
5. LL（1）分析表构造算法；

自下而上分析。