軟件構造——LL（1）語法分析

【實驗目的】

 

通過完成預測分析法的語法分析程序，了解預測分析法和遞歸子程序法的區別和聯系。使了解語法分析的功能，掌握語法分析程序設計的原理和構造方法，訓練掌握開發應用程序的基本方法。

 

【實驗內容】

u  根據某一文法編制調試 LL （ 1 ）分析程序，以便對任意輸入的符號串進行分析。

u  構造預測分析表，並利用分析表和一個棧來實現對上述程序設計語言的分析程序。

u  分析法的功能是利用LL（1）控制程序根據顯示棧頂內容、向前看符號以及LL（1）分析表，對輸入符號串自上而下的分析過程。

【設計思想】

（1）定義部分：定義常量、變量、數據結構。

（2）初始化：設立LL(1)分析表、初始化變量空間（包括堆棧、結構體、數組、臨時變量等）；

（3）控制部分：從鍵盤輸入一個表達式符號串；

（4）利用LL(1)分析算法進行表達式處理：根據LL(1)分析表對表達式符號串進行堆棧（或其他）操作，輸出分析結果，如果遇到錯誤則顯示錯誤信息。

 

【實驗要求】

（1）編程時注意編程風格：空行的使用、注釋的使用、縮進的使用等。

（2）如果遇到錯誤的表達式，應輸出錯誤提示信息。

（3）畫出流程圖

 

實驗截圖：

 

 

 

 

 

代碼：

Base.sh
#ifndef _BASE_H_
#define _BASE_H_
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <set>

#define maxsize 100

using namespace std;

struct node {  // 產生式的數據結構
    char left;
    string right;
};

class Base {
protected:
    int T;
    node production[maxsize]; // 產生式集

    set<char> firstSet[maxsize];  // First集
    set<char> followSet[maxsize];  // Follow集
    vector<char> terminalNoEmpty; // 去$(空)的終結符
    vector<char> terminal;  // 終結符
    vector<char> nonterminal;  // 非終結符

    bool isNonterminal(char c);
    int getIndex(char target);  // 獲得target在終結符集合中的下標
    int getNIndex(char target);  // 獲得target在非終結符集合中的下標
    void getFirst(char target);  // 得到First(target)
    void getFollow(char target);  // 得到Follow(target)

public:
    Base() {};

    void inputAndSolve();  // 處理和求出First和Follow集
    void displayFirstAndFollow();  // 輸出First和Follow集

};
#endif 

Base.cpp
#include "Base.h"

bool Base::isNonterminal(char c) { // 判斷c是否為非終結符
    if (c >= 'A' && c <= 'Z')
        return true;
    return false;
}
int Base::getNIndex(char target) {  // 獲得target在非終結符集合中的下標
    for (int i = 0; i<nonterminal.size(); i++) {
        if (target == nonterminal[i])
            return i;
    }
    return -1;
}
int Base::getIndex(char target) {  // 獲得target在終結符集合中的下標
    for (int i = 0; i<terminalNoEmpty.size(); i++) {
        if (target == terminalNoEmpty[i])
            return i;
    }
    return -1;
}

void Base::getFirst(char target) {  // 求FIRST(target）
    int countEmpty = 0;  // 用於最后判斷是否有空
    int isEmpty = 0;
    int targetIndex = getNIndex(target);
    for (int i = 0; i < T; i++) {
        if (production[i].left == target) {  // 匹配產生式左部
            if (!isNonterminal(production[i].right[0])) {  // 對於終結符，直接加入first
                firstSet[targetIndex].insert(production[i].right[0]);
            }
            else {
                for (int j = 0; j < production[i].right.length(); j++) { // X->Y1..Yj..Yk是一個產生式
                    char Yj = production[i].right[j];
                    if (!isNonterminal(Yj)) {  // Yj是終結符(不能產生空),FIRST(Yj)=Yj加入FIRST(X),不能繼續迭代,結束
                        firstSet[targetIndex].insert(Yj);
                        break;
                    }
                    getFirst(Yj);// Yj是非終結符，遞歸 先求出FIRST(Yj)

                    set<char>::iterator it;
                    int YjIndex = getNIndex(Yj);
                    for (it = firstSet[YjIndex].begin(); it != firstSet[YjIndex].end(); it++) {
                        if (*it == '$')  // 遍歷查看FIRST(Yj)中是否含有'$'(能產生空)
                            isEmpty = 1;
                        else
                            firstSet[targetIndex].insert(*it);//將FIRST(Yj)中的非$就加入FIRST(X)
                    }
                    if (isEmpty == 0)  // Yj不能產生空, 迭代結束
                        break;
                    else {   //  Yj能產生空
                        countEmpty += isEmpty;
                        isEmpty = 0;
                    }
                }
                if (countEmpty == production[i].right.length())//所有右部first(Y)都有$(空),將$加入FIRST(X)中
                    firstSet[getNIndex(target)].insert('$');
            }
        }
    }
}

void Base::getFollow(char target) {  // 求FOLLOW(target）
    int targetIndex = getNIndex(target);
    for (int i = 0; i<T; i++) {
        int index = -1;
        int len = production[i].right.length();
        for (int j = 0; j < len; j++) {  // 尋找target在產生式中的位置index
            if (production[i].right[j] == target) {
                index = j;
                break;
            }
        }
        if (index != -1 && index < len - 1) {  // 找到target在產生式中的位置index
            // 存在A->αBβ, 將FIRST(β)中除了空$之外的所有放入FOLLOW(B)中
            // 這里B對應target, β對應nxt
            char nxt = production[i].right[index + 1];
            if (!isNonterminal(nxt)) {  // β是終結符 FIRST(β)=β，直接插入β
                followSet[targetIndex].insert(nxt);
            }
            else {  // β是非終結符
                int hasEmpty = 0;
                set<char>::iterator it;
                int nxtIndex = getNIndex(nxt);  // 插入FIRST(β)中除了空$之外的所有
                for (it = firstSet[nxtIndex].begin(); it != firstSet[nxtIndex].end(); it++) {
                    if (*it == '$')
                        hasEmpty = 1;
                    else
                        followSet[targetIndex].insert(*it);
                }

                if (hasEmpty && production[i].left != target) { // 存在A->αBβ且FIRST(β)->$
                    // FOLLOW(A)放在FOLLOW(B)中
                    getFollow(production[i].left);
                    set<char>::iterator it;
                    char tmp = production[i].left;
                    int tmpIndex = getNIndex(tmp);
                    for (it = followSet[tmpIndex].begin(); it != followSet[tmpIndex].end(); it++)
                        followSet[targetIndex].insert(*it);
                }
            }
        }
        else if (index != -1 && index == len - 1 && target != production[i].left) {  // 存在A->αB ,FOLLOW(A)放在FOLLOW(B)中
            getFollow(production[i].left);
            set<char>::iterator it;
            char tmp = production[i].left;
            int tmpIndex = getNIndex(tmp);
            for (it = followSet[tmpIndex].begin(); it != followSet[tmpIndex].end(); it++)
                followSet[targetIndex].insert(*it);
        }
    }
}

void Base::inputAndSolve() {  // 處理和求出First和Follow集
    string s;
    cout << "輸入的產生式的個數：" << endl;
    cin >> T;
    cout << "輸入的產生式：" << endl;
    for (int index = 0; index < T; index++) {  // 處理每一個產生式
        cin >> s;
        string temp = "";  // 存儲去掉空格的產生式
        for (int i = 0; i < s.length(); i++) {  // 去掉產生式中的' '
            if (s[i] != ' ')
                temp += s[i];
        }
        production[index].left = temp[0];  // 產生式的左部
        for (int i = 3; i<temp.length(); i++) // 產生式的右部
            production[index].right += temp[i];

        for (int i = 0; i < temp.length(); i++) {  // 存儲所有終結符和非終結符
            if (i == 1 || i == 2) continue;  // 跳過產生符號->
            if (isNonterminal(temp[i])) {  //插入一個非終結符
                int flag = 0;
                for (int j = 0; j < nonterminal.size(); j++) {
                    if (nonterminal[j] == temp[i]) {
                        flag = 1;
                        break;
                    }
                }
                if (!flag) nonterminal.push_back(temp[i]);
            }
            else {                       //插入一個終結符
                int flag = 0;
                for (int j = 0; j < terminal.size(); j++) {
                    if (terminal[j] == temp[i]) {
                        flag = 1;
                        break;
                    }
                }
                if (!flag) terminal.push_back(temp[i]);
            }
        }
    }
    terminal.push_back('#');

    for (int i = 0; i < terminal.size(); i++) { // 存儲沒有$符號的終結符
        if (terminal[i] != '$')
            terminalNoEmpty.push_back(terminal[i]);
    }

    // 獲得first集
    for (int i = 0; i < nonterminal.size(); i++) {
        getFirst(nonterminal[i]);
    }

    // 獲得follow集
    for (int i = 0; i < nonterminal.size(); i++) {
        if (i == 0)  // 開始符號, 先加入結束符號
            followSet[0].insert('#');
        getFollow(nonterminal[i]);
    }
}

void Base::displayFirstAndFollow() {  // 輸出First和Follow集
    for (int aa = 0; aa < 10; aa++)
    {
        cout << "*********";
    }
    cout << "\n歡迎使用周博 20173599 LL1語法分析器(以下是First集合和Follow集合)" << endl;
    cout << "FIRST集合" << endl;
    for (int i = 0; i<nonterminal.size(); i++) {
        cout << nonterminal[i] << ": ";
        set<char>::iterator it;
        for (it = firstSet[i].begin(); it != firstSet[i].end(); it++)
            cout << *it << "  ";
        cout << endl;
    }
    cout << endl;

    cout << "FOLLOW集合" << endl;
    for (int i = 0; i<nonterminal.size(); i++) {
        cout << nonterminal[i] << ": ";
        set<char>::iterator it;
        for (it = followSet[i].begin(); it != followSet[i].end(); it++)
            cout << *it << "  ";
        cout << endl;
    }
    cout << endl;
}
LL1.h

#include"Base.h"

#define maxsize 100
#ifndef _LL1_H_
#define _LL1_H_
using namespace std;

class LL1 : public Base {
private:
    vector<char> analyStack; // 分析棧
    vector<char> leftExpr;  // 剩余輸入串
    int tableMap[100][100];  // 預測表

public:
    LL1();

    void getTable(); // 生成預測表
    void analyExpression(string s);  // 分析輸入語句s
    void printPredictTable();  // 輸出預測表
    void getResult(); // 綜合處理
};
#endif
LL1.cpp
#include"LL1.h"

LL1::LL1() {
    memset(tableMap, -1, sizeof(tableMap));
}

void LL1::getTable() {
    for (int index = 0; index < T; index++) {                          // 對於每個產生式(編號index):A->α
        int row = getNIndex(production[index].left);
        int emptyCount = 0;
        for (int i = 0; i < production[index].right.size(); i++) { // 1) 對FIRST(α)中的每個終結符號a,將index加入(A, a)中
            char tmp = production[index].right[i];
            if (!isNonterminal(tmp)) { // tmp是終結符          
                if (tmp != '$')
                    tableMap[row][getIndex(tmp)] = index;
                if (tmp == '$') {
                    emptyCount++;
                }
                break;
            }
            else {  // tmp是非終結符
                set<char>::iterator it;
                int tmpIndex = getNIndex(tmp);
                // 對FIRST(tmp)中的每個終結符號a,將i加入(A, a)中
                for (it = firstSet[tmpIndex].begin(); it != firstSet[tmpIndex].end(); it++) {
                    tableMap[row][getIndex(*it)] = index;
                }
                if (firstSet[tmpIndex].count('$') != 0) {      // 2) 如果空$在FIRST(tmp)中,繼續看α中的下一個符號
                    emptyCount++;
                }
                else {
                    break;
                }
            }
        }

        // 2) 如果空$在FIRST(α)中,對FOLLOW(A)中的每個終結符或結束符b,將i加入(A,b)中
        if (emptyCount == production[index].right.size()) {
            set<char>::iterator  it;
            for (it = followSet[row].begin(); it != followSet[row].end(); it++) {
                tableMap[row][getIndex(*it)] = index;
            }
        }
    }
}

void LL1::analyExpression(string s) {

    for (int i = 0; i < s.size(); i++)
        leftExpr.push_back(s[i]);
    leftExpr.push_back('#');

    analyStack.push_back('#');
    analyStack.push_back(nonterminal[0]);  // 加入開始符號

    while (analyStack.size() > 0) {
        //cout<<"分析棧：";
        string outs = "";
        for (int i = 0; i < analyStack.size(); i++)
            outs += analyStack[i];
        cout << setw(15) << outs;

        //cout<<"剩余輸入串：";
        outs = "";
        for (int i = 0; i < leftExpr.size(); i++)
            outs += leftExpr[i];
        cout << setw(15) << outs;

        // 匹配
        char char1 = analyStack.back();
        char char2 = leftExpr.front();
        if (char1 == char2 && char1 == '#') {
            cout << setw(15) << "Accepted!" << endl;
            return;
        }
        if (char1 == char2) {
            analyStack.pop_back();
            leftExpr.erase(leftExpr.begin());
            cout << setw(15) << "匹配：" << char1 << endl;
        }
        else if (tableMap[getNIndex(char1)][getIndex(char2)] != -1) {  // 預測表中有推倒項，可進行推導
            int tg = tableMap[getNIndex(char1)][getIndex(char2)];
            analyStack.pop_back();

            if (production[tg].right != "$") {
                for (int i = production[tg].right.length() - 1; i >= 0; i--) // 注意這里是反向的
                    analyStack.push_back(production[tg].right[i]);
            }

            cout << setw(15) << "推導：" << production[tg].left << "->" << production[tg].right << endl;
        }
        else {  // 錯誤
            cout << setw(15) << "error!" << endl;
            return;
        }
    }
}

void LL1::printPredictTable() {
    // 表頭
    for (int aa = 0; aa < 10; aa++)
    {
        cout << "*********";
    }
    cout << "\n以下是預測分析表" << endl;
    for (int i = 0; i < terminalNoEmpty.size(); i++) {
        cout << setw(10) << terminalNoEmpty[i];
    }
    cout << endl;
    for (int i = 0; i < nonterminal.size(); i++) {
        cout << nonterminal[i] << ": ";
        for (int j = 0; j < terminalNoEmpty.size(); j++) {
            if (tableMap[i][j] == -1)
                cout << setw(10) << "   ";
            else
                cout << setw(10) << production[tableMap[i][j]].right;
        }
        cout << endl;
    }
    cout << endl;
}

void LL1::getResult() {
    inputAndSolve();
    displayFirstAndFollow();
    getTable();
    printPredictTable();
    //棧匹配
    string ss;
    cout << "請輸入符號串：" << endl;
    cin >> ss;
    for (int aa = 0; aa < 10; aa++)
    {
        cout << "*********";
    }
    cout << "\n句子" << ss << "分析過程" << endl;
    cout << setw(15) << "分析棧" << setw(15) << "剩余輸入串" << setw(15) << "推導式" << endl;
    analyExpression(ss);

}


Main.cpp
#include "LL1.h"
#include<stdlib.h>

int main() {
    // $表示空, #表示終止
    LL1 res;
    res.getResult();
    system("pause");
    return 0;
}