编译原理实习（应用预测分析法LL(1)实现语法分析）

#include<iostream>
#include<fstream>
#include<iomanip>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<string>
#include<set>
#include<queue>
#include<stack>
#include<map>
using namespace std;

typedef pair<char, string>PP;
typedef pair<char, pair<string, string> >PPP;


//*代表弧
//~代表空
//输入：
/*
S*MH
S*a
H*LSo
H*~
K*dML
K*~
L*eHf
M*K
M*bLM
*/


class Set{

private:
    multimap<char, string >Grammars;//文法
    multimap<string, char >Re_Grammars; //反向映射
    vector<PP >FIRST;  //FIRST集
    vector<PP >FOLLOW; //FOLLOW集
    set<char >Ok; //能推出空的非终结符的集合
    set<char >Non_terminal; //非终结符集合
    vector<string >Right; //产生式右部
    vector<PPP >SELECT; //SELECT集
    vector<char >Sentence; //要识别的句子

public:
    Set();
    ~Set();
    bool Judge_Ok(char);  //判断一个非终结符是否能推出空
    void Get_Ok();  //求出那些能推出空的非终结符集合
    void First_Solve();  //求解FIRST集
    void Show_First(); //输出FIRST集合
    void Get_First(char, set<char>&);     //求解某个非终结符的FIRST集
    void Follow_Solve(); //求解FOLLOW集
    void Show_Follow(); //输出FOLLOW集
    void Get_Follow(char, set<char>&);   //求解某个非终结符的FOLLOW集
    void Select_Solve(); //求解SELECT集
    void Show_Select();  //输出SELECT集
    void Analysis();   //预测分析程序

};

Set::Set()
{
    ifstream infile;
    infile.open("data.txt");
    if (!infile){
        cout << "can't open the file" << endl;
        return;
    }
    string str;
    while (infile >> str){
        char ch = str[0];
        string ss = "";
        for (int i = 2; i < (int)str.size(); i++)ss += str[i];
        Grammars.insert(make_pair(ch, ss)); //所给文法
        Re_Grammars.insert(make_pair(ss, ch));  //反向映射集合
        Right.push_back(ss); //得到右部产生式
        for (int i = 0; i < (int)str.size(); i++){
            if (isupper(str[i]))Non_terminal.insert(str[i]); //求非终结符集合
        }
    }
    infile.close();
}

Set::~Set()
{
    Grammars.clear();
    Re_Grammars.clear();
    Right.clear();
    Ok.clear();
    FIRST.clear();
    FOLLOW.clear();
    SELECT.clear();
    Non_terminal.clear();
}

//判断一个非终结符是否能推出空
bool Set::Judge_Ok(char ch)
{
    if (Grammars.find(ch) == Grammars.end())return false;//如果找不到这个非终结符所能推出的符号，则返回false.

    multimap<char, string>::iterator iter = Grammars.find(ch);
    int Count =(int)Grammars.count(iter->first);
    for (int i = 0; i < Count; i++){
        bool flag = true;
        for (int j = 0; j < (int)iter->second.size(); j++){
            //如果是大写字母，那么就继续递归
            if (isupper(iter->second[j])){
                //避免重复递归
                if (iter->second[j] == ch){
                    flag = false;
                    break;
                }
                else if (!Judge_Ok(iter->second[j])){
                    flag = false;
                    break;
                }
            }
            //如果不是大写字母，就判断是否是空，如果不是，则也是直接break;
            else if (iter->second[j] != '~'){
                flag = false;
                break;
            }
        }
        if (flag)return true; //在某个非终结符的多重集合中，只要有某个能产生空，那么这个非终结符就能推出空,返回true;
        iter++;
    }
    //如果都不能推出空，那么就返回false;
    return false;

}


//求出那些能推出空的非终结符集合
void Set::Get_Ok()
{
    set<char>::iterator iter;
    for (iter = Non_terminal.begin(); iter != Non_terminal.end(); iter++){
        if(Judge_Ok((*iter))){
            Ok.insert(*iter);
        }
    }
}

//求某一个非终结符的FIRST集
void Set::Get_First(char ch, set<char>&st)
{
    if (Grammars.find(ch) == Grammars.end())return;   //如果没有找到非终结符可以转化的符号，则直接返回

    multimap<char, string>::iterator iter = Grammars.find(ch);
    int Count = (int)Grammars.count(iter->first);
    for (int i = 0; i < Count; i++){
        for (int j = 0; j < (int)(iter->second.size()); j++){
            //此时碰到的是终结符，找到后将其插入到set集合中，并且立马跳出循环，找下一个
            if (!isupper(iter->second[j])){
                st.insert(iter->second[j]);
                break;
            }
            else if (isupper(iter->second[j])){
                //避免重复递归
                if (iter->second[j] == ch){
                    break;
                }
                //如果不重复，那么就从这个非终结符继续找
                Get_First(iter->second[j], st);

                //如果这个非终结符不能推出空，那么就直接break寻找下一个映射
                if (Ok.find(iter->second[j]) == Ok.end()){
                    break;
                }
            }
        }
        iter++;
    }
}


//求所有非终结符的FIRST集
void Set::First_Solve()
{
    set<char >First;
    for (set<char >::iterator iter = Non_terminal.begin(); iter != Non_terminal.end(); iter++){
        First.clear();
        Get_First(*iter, First); //求某一个非终结符的FIRST集
        string str = "";
        for (set<char>::iterator it = First.begin(); it != First.end(); it++)str += (*it);
        FIRST.push_back(make_pair(*iter, str));
    }
}

//输出FIRST集
void Set::Show_First()
{
    cout << "  " << "FIRST集" << " " << endl << endl;
    for (int i = 0; i <(int) FIRST.size(); i++){
        cout << FIRST[i].first << " ：  ";
        for (int j = 0; j <(int) FIRST[i].second.size(); j++){
            cout << FIRST[i].second[j] << " ";
        }
        cout << endl;
    }
    cout << endl;
}


//求某一个非终结符的FOLLOW集
void Set::Get_Follow(char ch, set<char>&st)
{
    if (ch == 'S')st.insert('#');//如果是开始符;
    for (int i = 0; i < (int)Right.size(); i++){
        string str = Right[i];
        for (int j = 0; j < (int)Right[i].size(); j++){
            //如果不是当前产生式的最后一个
            if (Right[i][j] == ch&&j !=(int) Right[i].size() - 1){
                //如果后面紧跟着的是终结符
                if (!isupper(Right[i][j + 1])){
                    if (Right[i][j + 1] != '~'){
                        st.insert(Right[i][j + 1]);
                    }
                }
                else{
                    //后面紧跟着是非终结符，就把这个非终极符的FIRST集（除了空）加入到当前ch的FOLLOW集中
                    vector<PP>::iterator iter = FIRST.begin();
                    while (iter != FIRST.end()){
                        if (iter->first == Right[i][j+1]){
                            break;
                        }
                        iter++;
                    }
                    for (int k = 0; k < (int)iter->second.size(); k++){
                        if (iter->second[k] != '~')st.insert(iter->second[k]);
                    }
                    //如果对形如“…UP”(P是非终结符的组合)的组合；
                    //如果这些非终结符都能推出空，就么就要把左部（假设是S）的Follow（S）送入到Follow（U）中
                    bool flag = true;
                    for (int pos = j + 1; pos < (int)Right[i].size(); pos++){
                        if (isupper(Right[i][pos]) && Ok.find(Right[i][pos]) != Ok.end()){
                            vector<PP>::iterator ii = FIRST.begin();
                            while (ii != FIRST.end()){
                                if (ii->first == Right[i][pos]){
                                    break;
                                }
                                ii++;
                            }
                            for (int k = 0; k < (int)ii->second.size(); k++){
                                if (ii->second[k] != '~')st.insert(ii->second[k]);
                            }
                            continue;
                        }
                        flag = false;
                        break;
                    }
                    if (flag){
                        multimap<string, char>::iterator it = Re_Grammars.find(str);
                        int Count = Re_Grammars.count(it->first);
                        while (Count--){
                            if (it->second != ch){
                                Get_Follow(it->second, st);
                            }
                        }
                    }
                }
            }
            //如果刚好是当前产生式的最后一个字符
            else if (Right[i][j] == ch&&j == (int)Right[i].size() - 1){
                //反向映射找到推出str这个产生式的左部字符
                multimap<string, char>::iterator iter = Re_Grammars.find(str);
                int Count = Re_Grammars.count(iter->first);
                while (Count--){
                    if (iter->second != ch){
                        Get_Follow(iter->second, st);
                    }
                }
            }
        }
    }
}


//求所有非终结符的FOLLOW集
void Set::Follow_Solve()
{
    set<char>Follow;
    for (set<char>::iterator iter = Non_terminal.begin(); iter != Non_terminal.end(); iter++){
        Follow.clear();
        if (*iter == 'S')Follow.insert('#'); //如果是开始符
        Get_Follow(*iter, Follow);
        string str = "";
        for (set<char>::iterator it = Follow.begin(); it != Follow.end(); it++)str += (*it);
        FOLLOW.push_back(make_pair(*iter, str));
    }
}


//输出所有非终结符的FOLLOW集
void Set::Show_Follow()
{
    cout << "  " << "FOLLOW集" << " " << endl << endl;
    for (int i = 0; i < (int) FOLLOW.size(); i++){
        cout << FOLLOW[i].first << " ：  ";
        for (int j = 0; j <(int) FOLLOW[i].second.size(); j++){
            cout << FOLLOW[i].second[j] << " ";
        }
        cout << endl;
    }
    cout << endl;
}


//求解SELECT集
void Set::Select_Solve()
{
    multimap<char, string>::iterator iter;
    vector<PP >::iterator it;
    set<char >st;
    for (iter = Grammars.begin(); iter != Grammars.end(); iter++){
        char ch = iter->first;
        string str = iter->second;
        bool flag = true;
        st.clear();
        for (int i = 0; i < (int)str.size(); i++){
            if (Ok.find(str[i]) == Ok.end()&& str[i] != '~'){
                flag = false;
            }
        }
        //求FIRST(a)
        int pos = 0;
        while (pos < (int)str.size() && Ok.find(str[pos]) != Ok.end()){
            for (it = FIRST.begin(); it != FIRST.end(); it++){
                if (str[pos] == it->first)break;
            }
            for (int j = 0; j < (int)it->second.size(); j++){
                st.insert(it->second[j]);
            }
            pos++;
        }
        if (pos < (int)str.size()){
            if (isupper(str[pos])){
                for (it = FIRST.begin(); it != FIRST.end(); it++){
                    if (str[pos] == it->first)break;
                }
                for (int j = 0; j < (int)it->second.size(); j++){
                    st.insert(it->second[j]);
                }
            }else 
                st.insert(str[pos]);
        }
        //如果产生式A->a并且a能推出空,则SELECT（A->a)=(FIRST(a)-{~})U(FOLLOW(A)
        if (flag){
            for (it = FOLLOW.begin(); it != FOLLOW.end(); it++){
                if (ch == it->first)break;
            }
            for (int j = 0; j < (int)it->second.size(); j++){
                st.insert(it->second[j]);
            }
            for (set<char>::iterator ii = st.begin(); ii != st.end(); ){
                if ((*ii) == '~'){
                    ii = st.erase(ii);
                    break;
                }
                ii++;
            }
            string ss = "";
            for (set<char>::iterator ii = st.begin(); ii != st.end(); ii++)ss += (*ii);
            SELECT.push_back(make_pair(ch, make_pair(str,ss)));
        }
        //否则SELECT（A->a)=(FIRST(a)
        else {
            string ss = "";
            for (set<char>::iterator ii = st.begin(); ii != st.end(); ii++)ss += (*ii);
            SELECT.push_back(make_pair(ch, make_pair(str,ss)));
        }
    }
}


//输出SELECT集
void Set::Show_Select()
{
    cout << "  " << "SELECT集" << " " << endl << endl;
    for (int i = 0; i < (int) SELECT.size(); i++){
        cout << SELECT[i].first << " ->";
        cout << setw(4) << SELECT[i].second.first << " :   ";
        for (int j = 0; j < (int) SELECT[i].second.second.size(); j++){
            cout << SELECT[i].second.second[j] << " ";
        }
        cout << endl;
    }
    cout << endl;
}


//预测分析程序
void Set::Analysis()
{
    cout << "请输入要识别的串: " << endl;
    string str;
    cin >> str;
    for (int i = 0; i < (int)str.size(); i++){
        Sentence.push_back(str[i]);
    }
    Sentence.push_back('#');
    vector<char>::iterator iter = Sentence.begin(), ii;
    stack<char>S;
    vector<char>vet;
    S.push('#');
    S.push('S');
    vet.push_back('#');
    vet.push_back('S');
    cout << "分析栈" << "              " << "剩余输入串" << "              " << "推倒所用的产生式或匹配" << endl;
    int EMPTY = 7;
    while (!S.empty()){
        for (int i = 0; i < (int)vet.size(); i++){
            cout << vet[i] << " ";
        }
        for (int i = (int)vet.size(); i <= EMPTY+2; i++)cout << "  ";
        int count = 0;
        for (ii = iter; ii != Sentence.end(); ii++){
            cout << (*ii) << " ";
            count++;
        }
        for (; count <= EMPTY; count++)cout << "  ";
        char ch = S.top();
        if (ch == (*iter)){
            S.pop();
            vet.pop_back();
            iter++;
            for (int i = 0; i <= EMPTY; i++)cout << "  ";
            cout << "匹配" << endl;
        }
        else {
            vector<PPP >::iterator it;
            string ss = "";
            bool flag = false;
            for (it = SELECT.begin(); it != SELECT.end(); it++){
                if (it->first == ch){
                    ss = it->second.first;
                    for (int i = 0; i < (int)it->second.second.size(); i++){
                        if (it->second.second[i] == (*iter)){
                            flag = true;
                            break;
                        }
                    }
                    if (flag)break;
                }
            }
            for (int i = 0; i <= EMPTY; i++)cout << "  ";
            if (!flag){
                cout << "ERROR!!!" << endl;
                return;
            }
            cout << ch << "->" << ss << endl;
            reverse(ss.begin(), ss.end()); //反转
            if (ss == "~"){
                S.pop();
                vet.pop_back();
            }
            else {
                S.pop();
                vet.pop_back();
                for (int i = 0; i < (int)ss.size(); i++){
                    S.push(ss[i]);
                    vet.push_back(ss[i]);
                }
            }
        }
    }
    cout << "SUCCESS" << endl;
}



int main()
{
    Set obj;
    obj.Get_Ok(); 
    obj.First_Solve();
    obj.Show_First();
    obj.Follow_Solve();
    obj.Show_Follow();
    obj.Select_Solve();
    obj.Show_Select();
    obj.Analysis();
    return 0;
}