精华内容
下载资源
问答
  • 根据对自下而上语法分析的理论知识的学习,可以知道自下而上语法分析的两种实现方法:算符优先分析法和LR分析法,本实验采用后者LR分析法 本实验对PL0文法的表达式文法进行设计自下而上语法分析,表达式巴斯克范式...
    实验三. 自上而下语法分析

    设计思想

    根据对自下而上语法分析的理论知识的学习,可以知道自下而上语法分析的两种实现方法:算符优先分析法和LR分析法,本实验采用后者LR分析法

    本实验对PL0文法的表达式文法进行设计自下而上语法分析,表达式巴斯克范式如下:

    文法的初始化

    <>::=[+]<>{<><>}<>::=<>{<><>}<>::=<><>(<>)<>::=+<>::=/ \begin{aligned} & <表达式> ::= [+|-]<项>\{<加法运算符> <项>\} \\ & <项> ::= <因子>\{<乘法运算符> <因子>\} \\ & <因子> ::= <标识符>|<无符号整数>| '('<表达式>')' \\ & <加法运算符> ::= +|- \\ & <乘法运算符> ::= *|/ \end{aligned}

    对以上文字描述的文法可以给出对应的英文表示,以及对应的非终结符的 FirstFirst集合FollowFollow集合

    <Expression>::=[+]<Term>{<Addop><Term>}<Term>::=<Factor>{<Mulop><Factor>}<Factor>::=<Ident><UnsignInt>(<Expression>)<Addop>::=+<Mulop>::=/ \begin{aligned} & <Expression> ::= [+|-]<Term>\{<Addop> <Term>\} \\ & <Term> ::= <Factor>\{<Mulop> <Factor>\} \\ & <Factor> ::= <Ident> | <UnsignInt> | (<Expression>) \\ & <Addop> ::= + | - \\ & <Mulop> ::= * | / \\ \end{aligned}

    该文法的非终结符结合以及终结符集合如下:
    VT={+,,,/,(,),Ident,UnsignInt}VN={Expression,Term,Addop,Factor,Mulop} \begin{aligned} & V_T = \{+, -, *, /, (, ), Ident, UnsignInt\} \\ & V_N = \{Expression, Term, Addop, Factor, Mulop\} \\ \end{aligned}

    FirstFirst集合 :

    First(Expression)={+,,Ident,UnsignInt,(}First(Term)={Ident,UnsignInt,(}First(Factor)={Ident,UnsignInt,(}First(Addop)={+,}First(Mulop)={,/} \begin{aligned} & First(Expression) = \{+, -, Ident, UnsignInt, (\} \\ & First(Term) = \{Ident, UnsignInt, (\} \\ & First(Factor) = \{Ident, UnsignInt, (\} \\ & First(Addop) = \{+, -\} \\ & First(Mulop) = \{*, /\} \\ \end{aligned}

    FollowFollow集合 :

    Follow(S)={#}Follow(Expression)={#,+,,)}Follow(Term)={#,+,,,/,)}Follow(Factor)={#,+,,,/,)} \begin{aligned} & Follow(S') = \{\#\} \\ & Follow(Expression) = \{\#, +, -, )\} \\ & Follow(Term) = \{\#, +, -, *, /, )\} \\ & Follow(Factor) = \{\#, +, -, *, /, )\} \\ \end{aligned}

    将其简化一下文法:

    ET+TTEE+TETTFTTFT/FFiu(E) \begin{aligned} E & \to T | +T | -T \\ E & \to E + T | E - T\\ T & \to F \\ T & \to T * F | T / F \\ F & \to i | u | (E) \\ \end{aligned}

    对应的终结符和非终结符集合如下:

    VT={+,,,/,(,),i,u}VN={S,E,T,F} \begin{aligned} & V_T = \{+, -, *, /, (, ), i, u\} \\ & V_N = \{S', E, T, F\} \end{aligned}

    拓广文法

    文法的拓广,将文法 G(S)G(S) 拓广为 G(S)G'(S') ,并规定每一个产生式的编号,以便后续的方便使用:

    0:SE1:ET2:E+T3:ET4:EE+T5:EET6:TF7:TTF8:TT/F9:Fi10:Fu11:F(E) \begin{aligned} & 0: & S &' \to E \\ & 1: & E & \to T \\ & 2: & E & \to +T \\ & 3: & E & \to -T \\ & 4: & E & \to E + T \\ & 5: & E & \to E - T \\ & 6: & T & \to F \\ & 7: & T & \to T * F \\ & 8: & T & \to T / F \\ & 9: & F & \to i \\ & 10: & F & \to u \\ & 11: & F & \to (E) \\ \end{aligned}

    构造识别活前缀的DFA

    由此DFA可以看出,某些状态存在“规约-移进”冲突,所以可以通过SLR分析法的方式来尝试构造分析表,构造出此时构造出的分析表显然没有冲突:

    SLR分析表

    +/()iu#ETF0s5s4s8s6s71231s9s10acc2r1r1s11s12r1r13r6r6r6r6r6r64135146r9r9r9r9r9r97r10r10r10r10r10r108s5s4s8s6s715239s8s6s716310s8s6s717311s8s6s71812s8s6s71913r3r3r3r314r2r2r2r215s9s10s2016r4r4s11s12r4r417r5r5s11s12r5r518r7r7r7r7r7r719r8r8r8r8r8r820r11r11r11r11r11r11 \begin{array}{c|c} \hline & + & - & * & / & ( & ) & i & u & \# & E & T & F \\ \hline 0 & s5 & s4 & & & s8 & & s6 & s7 & & 1 & 2 & 3 \\ \hline 1 & s9 & s10 & & & & & & & acc & & & \\ \hline 2 & r1 & r1 & s11 & s12 & & r1 & & & r1 & & & \\ \hline 3 & r6 & r6 & r6 & r6 & & r6 & & & r6 & & & \\ \hline 4 & & & & & & & & & & & 13 & \\ \hline 5 & & & & & & & & & & & 14 & \\ \hline 6 & r9 & r9 & r9 & r9 & & r9 & & & r9 & & & \\ \hline 7 & r10 & r10 & r10 & r10 & & r10 & & & r10 & & & \\ \hline 8 & s5 & s4 & & & s8 & & s6 & s7 & & 15 & 2 & 3 \\ \hline 9 & & & & & s8 & & s6 & s7 & & & 16 & 3 \\ \hline 10 & & & & & s8 & & s6 & s7 & & & 17 & 3 \\ \hline 11 & & & & & s8 & & s6 & s7 & & & & 18 \\ \hline 12 & & & & & s8 & & s6 & s7 & & & & 19 \\ \hline 13 & r3 & r3 & & & & r3 & & & r3 & & & \\ \hline 14 & r2 & r2 & & & & r2 & & & r2 & & & \\ \hline 15 & s9 & s10 & & & & s20 & & & & & & \\ \hline 16 & r4 & r4 & s11 & s12 & & r4 & & & r4 & & & \\ \hline 17 & r5 & r5 & s11 & s12 & & r5 & & & r5 & & & \\ \hline 18 & r7 & r7 & r7 & r7 & & r7 & & & r7 & & & \\ \hline 19 & r8 & r8 & r8 & r8 & & r8 & & & r8 & & & \\ \hline 20 & r11 & r11 & r11 & r11 & & r11 & & & r11 & & & \\ \hline \end{array}

    得到分析表后,就可以根据LR分析的程序框架完成总控程序等的编写,由上一次的 自上而下的SLR分析表法 的代码可以简单的修改一些代码,便可实现整个分析程序的编写。

    算法流程

    源程序

    整个SLR分析程序是由上一实验的预测分析程序修改而来,根据SLR分析的所需,简单的修改了分析表的构成,即由ACTION和GOTO表组成,将原来的分析总控程序中的具体的执行流程根据LR分析法来修改,其他内容保持不变即可:

    整个LR分析程序所设计到的类以及相互的关系如下:

    项目地址

    基础符号类

    基础符号类作为一个符号类的基类,主要用途为使用基类指针来指引子类的终结符或非终结符,简化后续的操作。

    // symbols.h
    #ifndef symbols_h
    #define symbols_h
    #include<iostream>
    /*
    终结符和非终结符的一个共同的基类
    这样可以通过基类来引用终结符和非终结符
    
    */
    class symbols
    {
    private:
        /* data */
    public:
        symbols(){};
        virtual ~symbols(){};
        virtual std::string getClassName(){
            return "symbols";
        }
        virtual void print(){};
    };
    
    #endif /*symbols_h*/
    

    终结符类

    终结符类继承至基础符号类,终结符由终结符的值和编码构成。

    // symbolsVT.h
    #ifndef symbolsVT_h
    #define symbolsVT_h
    #include<iostream>
    #include"symbols.h"
    /*
    一个终结符
    终结符由终结符的值和编码构成
    
    */
    class symbolsVT : public symbols{
    private:
        std::string word;   //终结符的值
        std::string code;   //词法分析后终结符的标识(编码)
    public:
        symbolsVT(){}
        symbolsVT(std::string W, std::string C):word(W), code(C) {
            std::cerr<< "V_T: " << word << " " << code << " created..." << std::endl;
        }
        ~symbolsVT() {}
        std::string getClassName();
        std::string getWord();
        std::string getCode();
        void print();
    };
    
    #endif /*symbolsVT_h*/
    
    // symbolsVT.cpp
    #include<iostream>
    #include"symbolsVT.h"
    
    std::string symbolsVT::getClassName(){
        return "VT";
    }
    std::string symbolsVT::getWord(){
        return word;
    }
    std::string symbolsVT::getCode(){
        return code;
    }
    void symbolsVT::print(){
        std::cerr << "VT: " << word << " " << code << std::endl;
    }
    

    非终结符类

    非终结符类与终结符类一样继承至基础符号类,非终结符由其左部的非终结符和有部一个一些产生式构成,产生式即为一些符号的排列,此处存储的是一些产生式的指针。

    // symbolsVN.h
    #ifndef symbolsVN_h
    #define symbolsVN_h
    #include<iostream>
    #include"symbols.h"
    #include"production.h"
    const int maxnNum = 5;     // 一个终结符所有的产生式的数量
    class production;
    /*
    非终结符
    非终结符由其左部的非终结符和有部一个一些产生式构成
    产生式即为一些符号的排列,此处存储的是一些产生式的指针
    */
    
    class symbolsVN: public symbols{
    private:
        std::string name;							// 非终结符左部名称X
        production *p[maxnNum];						// 产生式集合
        int num;
    public:
        symbolsVN();
        symbolsVN(std::string);
        ~symbolsVN() {}
        std::string getClassName();
        std::string getName();
        void insertProduction(production *newp);	// 加入一个产生式
        production* getProductionIndexOf(int i);	// 获得第i个产生式
        production** getAllProduction();			// 获得所有的产生式
        void print();
    };
    
    #endif /*symbolsVN_h*/
    
    // symbolsVN.cpp
    #include<iostream>
    #include"symbolsVN.h"
    
    symbolsVN::symbolsVN(){
        num = 0;
    }
    symbolsVN::symbolsVN(std::string n):name(n){
        symbolsVN();
        std::cerr << "V_N: " << name << " created..." << std::endl;
    }
    
    std::string symbolsVN::getClassName(){
        return "VN";
    }
    std::string symbolsVN::getName(){
        return name;
    }
    void symbolsVN::insertProduction(production *newp){
        p[num++] = newp;
        return;
    }
    production* symbolsVN::getProductionIndexOf(int i){
        if(i >= num){
            std::cerr << "index overflow..." << std::endl;
            return NULL;
        }
        return p[i];
    }
    production** symbolsVN::getAllProduction(){
        return p;
    }
    void symbolsVN::print(){
        std::cerr << "VN: " << name << std::endl;
        std::cerr << "ALL production: " << std::endl;
        for(int i = 0; i < num; ++i){
            std::cerr << name << " \\to ";
            p[i]->print();
        }
        std::cerr << std::endl;
    }
    

    产生式类

    一个产生式由一个左部的非终结符和一些右部的符号集合构成。

    // production.h
    #ifndef production_h
    #define production_h
    #include<iostream>
    #include"symbols.h"
    #include"symbolsVT.h"
    #include"symbolsVN.h"
    /*
    产生式
    一个产生式由一个左部的非终结符和一些右部的符号集合构成
    */
    
    const int maxnLen = 10;        // 一个产生式的右部符号的数量
    class symbolsVN;
    class production
    {
    private:
        symbolsVN *vn;					// 产生式左部的非终结符
        symbols *pro[maxnLen];			// 产生式,由一些非终结符和终结符构成,故使用符号指针来指引
        int len;
    public:
        production();
        production(symbolsVN *v);
        ~production(){}
        void push_back(symbols *a);		// 为产生式后部插入一个符号
        symbolsVN* getVN();				// 获得左部非终结符符号
        symbols** getProduction();		// 获得产生式指针数组
        int getLen();					// 获得产生式长度
        symbols* getProductionIndexOf(int i); // 获得产生式中第i个位置的符号
        void print();
    };
    
    #endif /*production_h*/
    
    // production.cpp
    #include<iostream>
    #include"production.h"
    #include"symbolsVT.h"
    #include"symbolsVN.h"
    
    production::production(){
        len = 0;
    }
    production::production(symbolsVN *v){
        vn = v;
        production();
        std::cerr << "A production of " << vn->getName() << " has created..." << std::endl;
    }
    void production::push_back(symbols *a){
        pro[len++] = a;
    }
    symbolsVN* production::getVN(){
        return vn;
    }
    symbols** production::getProduction(){
        return pro;
    }
    symbols* production::getProductionIndexOf(int i){
        if(i >= len){
            std::cerr << "index Overflow..." << std::endl;
            return NULL;
        }
        return pro[i];
    }
    int production::getLen(){
        return len;
    }
    void production::print(){
        std::cerr << vn->getName() << "->";
        for(int i = 0; i < len; ++i){
            if(pro[i]->getClassName() == "VT"){
                std::cerr << ((symbolsVT*)pro[i])->getWord();
            }
            else{
                std::cerr << ((symbolsVN*)pro[i])->getName();
            }
        }
        // std::cerr << std::endl;
    }
    

    分析表

    分析表,由ACTION表和GOTO表构成,具体的状态内容由前期的DFA分析等得到:

    // analysisTable.h
    #ifndef analysisTable_h
    #define analysisTable_h
    #include<map>
    #include"symbols.h"
    #include"symbolsVN.h"
    #include"symbolsVT.h"
    #include"production.h"
    const int NUMOFVT = 20;
    const int NUMOFVN = 20;
    const int NUMOFSTATE = 30;
    const int NUMOFPRODUCTIONS = 30;
    /*
    分析表子程序
    由前期的分析得到该文法的分析表,由ACTION表和GOTO表构成
    */
    class ACTIONTable{
    private:
        std::pair<char, int> ACTION[NUMOFSTATE][NUMOFVT];
        int numofstate;						// ACTION表状态的数量
        int numofsymbolsvt;					// ACTION表终结符的数量
        std::map<symbolsVT*, int> vtmap;    // 终结符对应在分析表中的位置
        int getVTMap(symbolsVT*);			// 获得终结符对应的编号
    public:
        ACTIONTable();
        ACTIONTable(int);
        ~ACTIONTable(){}
        void setNumOfState(int);			// GOTO状态数量
        void insertVT(symbolsVT*);			// 插入一个终结符以及给一个对应的编号
        void insertSHIFT(int state, symbolsVT* vt, int numOfPro);       // 插入一个移进状态
        void insertREDUCE(int state, symbolsVT* vt, int numOfPro);      // 插入一个规约状态
        void insertACC(int state, symbolsVT* vt);                       // 插入一个acc状态
        std::pair<char, int> getACTION(int state, symbolsVT* vt);       // 获得一个ACTION信息
        void print();
    };
    class GOTOTable{
    private:
        int GOTO[NUMOFSTATE][NUMOFVN];
        int numofstate;						// GOTO状态数量
        int numofsymbolsvn;
        std::map<symbolsVN*, int> vnmap;    // 非终结符对应在分析表中的位置
        int getVNMap(symbolsVN*);			// 获得非终结符对应的编号
    public:
        GOTOTable();
        GOTOTable(int);
        ~GOTOTable(){}
        void setNumOfState(int);			// 设置GOTO表的状态数
        void insertVN(symbolsVN*);          // 插入一个非终结符
        void insert(int state, symbolsVN* vn, int numOfPro);    // 插入一个GOTO状态
        int get(int state, symbolsVN* vn);                      // 获得一个GOTO状态
        void print();
    };
    class analysisTable
    {
    private:
        ACTIONTable ACTION;                 // ACTION表
        GOTOTable GOTO;                     // GOTO表
        int numofstate;                     // 状态个数I_n
        int numofpro;                       // 产生式数量
        production* productions[NUMOFPRODUCTIONS];  // 产生式数组,下标即为编号
    public:
        analysisTable(int ns);
        // analysisTable(int, int, int);
        ~analysisTable() {}
        void insertSymbols(symbols*);		// 插入一个符号
        void insertProduction(production* p);	// 插入一条产生式,自动编号
        production* getProduction(int i);	// 获得第i条产生式
        void insert(int state, symbols* s, char ch, int numOfPro);	// 插入一个状态
        std::pair<char, int> get(int state, symbols* s);	// 获得一个状态
        void print();
    };
    
    #endif /*analysisTable_h*/
    
    // analysisTable.cpp
    #include<iostream>
    #include<algorithm>
    #include<string.h>
    #include"analysisTable.h"
    
    ACTIONTable::ACTIONTable(){
        numofsymbolsvt = 0;
        vtmap.clear();
        std::pair<char, int> init = std::make_pair('e', -1);
        // fill(begin(ACTION), end(ACTION), std::make_pair('e', -1));
        for(int i = 0; i < NUMOFSTATE; ++i)
            for(int j = 0; j < NUMOFVT; ++j)
                ACTION[i][j] = init;
        std::cerr << "ACTIONTable has created..." << std::endl;
    }
    void ACTIONTable::setNumOfState(int ns){
        numofstate = ns;
    }
    int ACTIONTable::getVTMap(symbolsVT* vt){
        if(vtmap.find(vt) != vtmap.end())return vtmap[vt];
        return -1;
    }
    void ACTIONTable::insertVT(symbolsVT* vt){
        vtmap[vt] = numofsymbolsvt++;
    }
    void ACTIONTable::insertSHIFT(int state, symbolsVT* vt, int numOfPro){
        int nvt = getVTMap(vt);
        if(state < numofstate && ~nvt){
            ACTION[state][nvt] = std::make_pair('s', numOfPro);
        }
    }
    void ACTIONTable::insertREDUCE(int state, symbolsVT* vt, int numOfPro){
        int nvt = getVTMap(vt);
        if(state < numofstate && ~nvt){
            ACTION[state][nvt] = std::make_pair('r', numOfPro);
        }
    }
    void ACTIONTable::insertACC(int state, symbolsVT* vt){
        int nvt = getVTMap(vt);
        if(state < numofstate && ~nvt){
            ACTION[state][nvt] = std::make_pair('a', 0x3f3f3f3f);
        }
    }
    std::pair<char, int> ACTIONTable::getACTION(int state, symbolsVT* vt){
        int nvt = getVTMap(vt);
        if(state < numofstate && ~nvt){
            return ACTION[state][nvt];
        }
        return std::make_pair('e', -1);
    }
    void ACTIONTable::print(){
        std::cerr << "ACTION:" << std::endl;
        std::cerr << numofsymbolsvt << std::endl;
        std::cerr << "\t";
        // for(auto i: vtmap)std::cerr << i.first->getWord() << "\t";
        for(std::map<symbolsVT*, int>::iterator i = vtmap.begin(); i != vtmap.end(); ++i)std::cerr << i->first->getWord() << "\t";
        std::cerr << std::endl;
        for(int i = 0; i < numofstate; ++i){
            std::cerr << i << ": \t";
            for(int j = 0; j < numofsymbolsvt; ++j){
                if(~ACTION[i][j].second)
                    std::cerr << ACTION[i][j].first << ACTION[i][j].second << " \t";
                else
                    std::cerr << "   \t";
            }
            std::cerr << std::endl;
        }
        std::cerr << std::endl;
    }
    
    
    GOTOTable::GOTOTable(){
        numofsymbolsvn = 0;
        vnmap.clear();
        memset(GOTO, -1, sizeof GOTO);
        std::cerr << "GOTOTable has created..." << std::endl;
    }
    void GOTOTable::setNumOfState(int ns){
        numofstate = ns;
    }
    void GOTOTable::insertVN(symbolsVN* vn){
        vnmap[vn] = numofsymbolsvn++;
    }
    int GOTOTable::getVNMap(symbolsVN* vn){
        if(vnmap.find(vn) != vnmap.end())return vnmap[vn];
        return -1;
    }
    void GOTOTable::insert(int state, symbolsVN* vn, int numOfPro){
        int nvn = getVNMap(vn);
        if(state < numofstate && ~nvn){
            GOTO[state][nvn] = numOfPro;
        }
    }
    int GOTOTable::get(int state, symbolsVN* vn){
        int nvn = getVNMap(vn);
        if(state < numofstate && ~nvn){
            return GOTO[state][nvn];
        }
        return -1;
    }
    void GOTOTable::print(){
        std::cerr << "GOTO:" << std::endl;
        std::cerr << numofsymbolsvn << std::endl;
        std::cerr << "\t";
        // for(auto i: vnmap)std::cerr << i.first->getName() << "\t";
        for(std::map<symbolsVN*, int>::iterator i = vnmap.begin(); i != vnmap.end(); ++i)std::cerr << i->first->getName() << "\t";
        std::cerr << std::endl;
        for(int i = 0; i < numofstate; ++i){
            std::cerr << i << ": \t";
            for(int j = 0; j < numofsymbolsvn; ++j){
                if(~GOTO[i][j])
                    std::cerr << GOTO[i][j] << "\t";
                else
                    std::cerr << "   \t";
            }
            std::cerr << std::endl;
        }
        std::cerr << std::endl;
    }
    
    
    analysisTable::analysisTable(int ns):numofstate(ns){
        ACTION.setNumOfState(numofstate);
        GOTO.setNumOfState(numofstate);
        numofpro = 0;
        std::cerr << "An AnalysisTable has created..." << std::endl;
    }
    void analysisTable::insertSymbols(symbols* s){
        if(s->getClassName() == "VT"){
            ACTION.insertVT((symbolsVT*)(s));
        }
        else if(s->getClassName() == "VN"){
            GOTO.insertVN((symbolsVN*)(s));
        }
    }
    void analysisTable::insertProduction(production* p){
        productions[numofpro++] = p;
    }
    production* analysisTable::getProduction(int i){
        if(i < numofpro)return productions[i];
        // return nullptr;
        return NULL;
    }
    void analysisTable::insert(int state, symbols* s, char ch, int numOfPro){
        if(s->getClassName() == "VT"){
            if(ch == 'a'){
                ACTION.insertACC(state, (symbolsVT*)(s));
            }
            else if(ch == 's'){
                ACTION.insertSHIFT(state, (symbolsVT*)(s), numOfPro);
            }
            else if(ch == 'r'){
                ACTION.insertREDUCE(state, (symbolsVT*)(s), numOfPro);
            }
        }
        else if(s->getClassName() == "VN"){
            GOTO.insert(state, (symbolsVN*)(s), numOfPro);
        }
    }
    std::pair<char, int> analysisTable::get(int state, symbols* s){
        if(s->getClassName() == "VT"){
            return ACTION.getACTION(state, (symbolsVT*)(s));
        }
        else if(s->getClassName() == "VN"){
            return std::make_pair('g', GOTO.get(state, (symbolsVN*)(s)));
        }
        return std::make_pair('e', -1);
    }
    void analysisTable::print(){
        std::cerr << "analysisTable: " << std::endl;
        ACTION.print();
        GOTO.print();
        std::cerr << std::endl;
    }
    

    LR分析总控程序

    根据LR分析程序编写的总控程序,包括初始化、读入、分析以及释放资源等:

    // SLRAnalysis.cpp
    #include<iostream>
    #include<cstdio>
    #include<string.h>
    #include"symbols.h"
    #include"symbolsVN.cpp"
    #include"symbolsVT.cpp"
    #include"production.cpp"
    #include"analysisTable.cpp"
    const int maxnAnalysisStack = 1e2 + 5;
    
    // 定义出文法的所有终结符
    symbolsVT* PLUS = new symbolsVT("+", "plus");
    symbolsVT* MINUS = new symbolsVT("-", "minus");
    symbolsVT* times = new symbolsVT("*", "times");
    symbolsVT* slash = new symbolsVT("/", "slash");
    symbolsVT* lparen = new symbolsVT("(", "lapren");
    symbolsVT* rparen = new symbolsVT(")", "rparen");
    symbolsVT* ident = new symbolsVT("i", "ident");
    symbolsVT* unsignint = new symbolsVT("u", "unsignint");
    symbolsVT* END = new symbolsVT("#", "end");
    symbolsVT* epslion = new symbolsVT("e", "epslion");
    // 定义出文法的所有非终结符
    symbolsVN* Sdot = new symbolsVN("S'");
    symbolsVN* E = new symbolsVN("E");
    symbolsVN* T = new symbolsVN("T");
    symbolsVN* F = new symbolsVN("F");
    
    // 构造所有的产生式
    production* Sdotproduction[1];
    production* Eporduction[5];
    production* Tproduction[3];
    production* Fproduction[3];
    
    // 定义出预测分析表
    analysisTable AnalysisTable(21);
    
    // 分析栈
    std::pair<int, symbols*> analysisStack[maxnAnalysisStack];
    int top;
    void init(){
        // 初始化所有变量
    	// 根据文法的不同,得到的分析表的结构也不同,此时初始化部分也不同
    
        // 定义出预测分析表
    	// 为预测分析表插入终结符、非终结符
        AnalysisTable.insertSymbols(PLUS);
        AnalysisTable.insertSymbols(MINUS);
        AnalysisTable.insertSymbols(times);
        AnalysisTable.insertSymbols(slash);
        AnalysisTable.insertSymbols(lparen);
        AnalysisTable.insertSymbols(rparen);
        AnalysisTable.insertSymbols(ident);
        AnalysisTable.insertSymbols(unsignint);
        AnalysisTable.insertSymbols(END);
    
        AnalysisTable.insertSymbols(Sdot);
        AnalysisTable.insertSymbols(E);
        AnalysisTable.insertSymbols(T);
        AnalysisTable.insertSymbols(F);
    
        // 根据文法定义E的三条产生式,同理处理其他的产生式
        for(int i = 0; i < 1; ++i)Sdotproduction[i] = new production(Sdot);
        Sdotproduction[0]->push_back(E);
        Sdotproduction[0]->print();
    
    
        for(int i = 0; i < 5; ++i)Eporduction[i] = new production(E);
    
        Eporduction[0]->push_back(T);
        Eporduction[1]->push_back(PLUS); Eporduction[1]->push_back(T);
        Eporduction[2]->push_back(MINUS); Eporduction[2]->push_back(T);
        Eporduction[3]->push_back(E); Eporduction[3]->push_back(PLUS); Eporduction[3]->push_back(T);
        Eporduction[4]->push_back(E); Eporduction[4]->push_back(MINUS); Eporduction[4]->push_back(T);
        for(int i = 0; i < 5; ++i)E->insertProduction(Eporduction[i]);
        for(int i = 0; i < 5; ++i)Eporduction[i]->print();
        
        for(int i = 0; i < 3; ++i)Tproduction[i] = new production(T);
        Tproduction[0]->push_back(F);
        Tproduction[1]->push_back(T); Tproduction[1]->push_back(times); Tproduction[1]->push_back(F);
        Tproduction[2]->push_back(T); Tproduction[2]->push_back(slash); Tproduction[2]->push_back(F);
        for(int i = 0; i < 3; ++i)T->insertProduction(Tproduction[i]);
        for(int i = 0; i < 3; ++i)Tproduction[i]->print();
    
        
        for(int i = 0; i < 3; ++i)Fproduction[i] = new production(F);
        Fproduction[0]->push_back(ident);
        Fproduction[1]->push_back(unsignint);
        Fproduction[2]->push_back(lparen); Fproduction[2]->push_back(E); Fproduction[2]->push_back(rparen);
        for(int i = 0; i < 3; ++i)F->insertProduction(Fproduction[i]);
        for(int i = 0; i < 3; ++i)Fproduction[i]->print();   
    
        for(int i = 0; i < 1; ++i)AnalysisTable.insertProduction(Sdotproduction[i]);
        for(int i = 0; i < 5; ++i)AnalysisTable.insertProduction(Eporduction[i]);
        for(int i = 0; i < 3; ++i)AnalysisTable.insertProduction(Tproduction[i]);
        for(int i = 0; i < 3; ++i)AnalysisTable.insertProduction(Fproduction[i]);
    
        // 给出LR分析表
        AnalysisTable.insert(0, PLUS, 's', 5); AnalysisTable.insert(0, MINUS, 's', 4); AnalysisTable.insert(0, lparen, 's', 8); AnalysisTable.insert(0, ident, 's', 6); AnalysisTable.insert(0, unsignint, 's', 7); AnalysisTable.insert(0, E, ' ', 1); AnalysisTable.insert(0, T, ' ', 2); AnalysisTable.insert(0, F, ' ', 3);
        AnalysisTable.insert(1, PLUS, 's', 9); AnalysisTable.insert(1, MINUS, 's', 10); AnalysisTable.insert(1, END, 'a', -1);
        AnalysisTable.insert(2, PLUS, 'r', 1); AnalysisTable.insert(2, MINUS, 'r', 1); AnalysisTable.insert(2, times, 's', 11); AnalysisTable.insert(2, slash, 's', 12); AnalysisTable.insert(2, rparen, 'r', 1); AnalysisTable.insert(2, END, 'r', 1);
        AnalysisTable.insert(3, PLUS, 'r', 6); AnalysisTable.insert(3, MINUS, 'r', 6); AnalysisTable.insert(3, times, 'r', 6); AnalysisTable.insert(3, slash, 'r', 6); AnalysisTable.insert(3, rparen, 'r', 6); AnalysisTable.insert(3, END, 'r', 6);
        AnalysisTable.insert(4, T, ' ', 13);
        AnalysisTable.insert(5, T, ' ', 14);
        AnalysisTable.insert(6, PLUS, 'r', 9); AnalysisTable.insert(6, MINUS, 'r', 9); AnalysisTable.insert(6, times, 'r', 9); AnalysisTable.insert(6, slash, 'r', 9); AnalysisTable.insert(6, rparen, 'r', 9); AnalysisTable.insert(6, END, 'r', 9);
        AnalysisTable.insert(7, PLUS, 'r', 10); AnalysisTable.insert(7, MINUS, 'r', 10); AnalysisTable.insert(7, times, 'r', 10); AnalysisTable.insert(7, slash, 'r', 10); AnalysisTable.insert(7, rparen, 'r', 10); AnalysisTable.insert(7, END, 'r', 10);
        AnalysisTable.insert(8, PLUS, 's', 5); AnalysisTable.insert(8, MINUS, 's', 4); AnalysisTable.insert(8, lparen, 's', 8); AnalysisTable.insert(8, ident, 's', 6); AnalysisTable.insert(8, unsignint, 's', 7); AnalysisTable.insert(8, E, ' ', 15); AnalysisTable.insert(8, T, ' ', 2); AnalysisTable.insert(8, F, ' ', 3);
        AnalysisTable.insert(9, lparen, 's', 8); AnalysisTable.insert(9, ident, 's', 6); AnalysisTable.insert(9, unsignint, 's', 7); AnalysisTable.insert(9, T, ' ', 16); AnalysisTable.insert(9, F, ' ', 3);
        AnalysisTable.insert(10, lparen, 's', 8); AnalysisTable.insert(10, ident, 's', 6); AnalysisTable.insert(10, unsignint, 's', 7); AnalysisTable.insert(10, T, ' ', 17); AnalysisTable.insert(10, F, ' ', 3);
        AnalysisTable.insert(11, lparen, 's', 8); AnalysisTable.insert(11, ident, 's', 6); AnalysisTable.insert(11, unsignint, 's', 7); AnalysisTable.insert(11, F, ' ', 18);
        AnalysisTable.insert(12, lparen, 's', 8); AnalysisTable.insert(12, ident, 's', 6); AnalysisTable.insert(12, unsignint, 's', 7); AnalysisTable.insert(12, F, ' ', 19);
        AnalysisTable.insert(13, PLUS, 'r', 3); AnalysisTable.insert(13, MINUS, 'r', 3); AnalysisTable.insert(13, rparen, 'r', 3); AnalysisTable.insert(13, END, 'r', 3);
        AnalysisTable.insert(14, PLUS, 'r', 2); AnalysisTable.insert(14, MINUS, 'r', 2); AnalysisTable.insert(14, rparen, 'r', 2); AnalysisTable.insert(14, END, 'r', 2);
        AnalysisTable.insert(15, PLUS, 's', 9); AnalysisTable.insert(15, MINUS, 's', 10); AnalysisTable.insert(15, rparen, 's', 20);
        AnalysisTable.insert(16, PLUS, 'r', 4); AnalysisTable.insert(16, MINUS, 'r', 4); AnalysisTable.insert(16, times, 's', 11); AnalysisTable.insert(16, slash, 's', 12); AnalysisTable.insert(16, rparen, 'r', 4); AnalysisTable.insert(16, END, 'r', 4);
        AnalysisTable.insert(17, PLUS, 'r', 5); AnalysisTable.insert(17, MINUS, 'r', 5); AnalysisTable.insert(17, times, 's', 11); AnalysisTable.insert(17, slash, 's', 12); AnalysisTable.insert(17, rparen, 'r', 5); AnalysisTable.insert(17, END, 'r', 5);
        AnalysisTable.insert(18, PLUS, 'r', 7); AnalysisTable.insert(18, MINUS, 'r', 7); AnalysisTable.insert(18, times, 'r', 7); AnalysisTable.insert(18, slash, 'r', 7); AnalysisTable.insert(18, rparen, 'r', 7); AnalysisTable.insert(18, END, 'r', 7);
        AnalysisTable.insert(19, PLUS, 'r', 8); AnalysisTable.insert(19, MINUS, 'r', 8); AnalysisTable.insert(19, times, 'r', 8); AnalysisTable.insert(19, slash, 'r', 8); AnalysisTable.insert(19, rparen, 'r', 8); AnalysisTable.insert(19, END, 'r', 8);
        AnalysisTable.insert(20, PLUS, 'r', 11); AnalysisTable.insert(20, MINUS, 'r', 11); AnalysisTable.insert(20, times, 'r', 11); AnalysisTable.insert(20, slash, 'r', 11); AnalysisTable.insert(20, rparen, 'r', 11); AnalysisTable.insert(20, END, 'r', 11);
        AnalysisTable.print();
    	
    	// 初始化分析栈
        top = -1;
    }
    void release(){
    	// 释放所有的动态申请的资源
        delete PLUS;
    	delete MINUS;
    	delete times;
    	delete slash;
    	delete lparen;
    	delete rparen;
    	delete ident;
    	delete unsignint;
    	delete END;
    	delete epslion;
        delete E;
    	delete T;
    	delete F;
        for(int i = 0; i < 1; ++i)delete Sdotproduction[i];
        for(int i = 0; i < 5; ++i)delete Eporduction[i];
        for(int i = 0; i < 3; ++i)delete Tproduction[i];
        for(int i = 0; i < 3; ++i)delete Fproduction[i];
    }
    std::string word, code; 
    // char word[10], code[10];
    char ch;
    symbolsVT* a;
    void ADVANCE(){
    	// 读入一个词法分析的结果项,同时给出对应的终结符a
        // if(scanf("(%s,%s)", code, word) != -1){
        std::cin >> ch;
        if(!std::cin.eof()){
        // if(scanf("%c", &ch) != -1){
            std::getline(std::cin, code, ',');
            std::getline(std::cin, word);
            word.resize(word.size() - 1);
            // std::cin >> ch;
            std::cerr << word << " " << code << std::endl;
            if(code == "plus")a = PLUS;
            else if(code == "minus") a = MINUS;
            else if(code == "times") a = times;
            else if(code == "slash") a = slash;
            else if(code == "lparen") a = lparen;
            else if(code == "rparen") a = rparen;
            else if(code == "ident") a = ident;
            else if(code == "number") a = unsignint;
        }
        else{ 
            a = END;
        // if(std::cin.eof() == EOF){
            std::cerr << "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh" << std::endl;
        }
        std::cerr << word << "_____________" << code << std::endl;
    }
    bool SLRAnalysis(){
    	// 预测分析程序的总控程序
        init();
        bool grammer = true;		// 表示句子是否符合一定的文法
        bool flag = true;			// 总控程序的运行标志
        analysisStack[++top] = std::make_pair(0, (symbols*)END);  // 初始化栈,将状态0和符号#压入
        std::pair<int, symbols*> X;					// 定义一个公共变量:状态和符号的指针
        production *p;				// 定义一个产生式的指针
        std::pair<char, int> state; // 从分析表中获得的状态信息
        ADVANCE();					// 读入一个词法分析的结果项
        while(flag){
    		//************************************************************//
    		// 调试信息:状态栈和符号栈的中内容
            std::cerr << std::endl << std::endl;
            std::cerr << "================" << std::endl;
            a->print();
            std::cerr << "stack: " << std::endl;;
            for(int i = 0; i <= top; ++i){
                std::cerr << analysisStack[i].first << " ";            
            }
            std::cerr << std::endl;
            for(int i = 0; i <= top; ++i){
                if(analysisStack[i].second->getClassName() == "VT")std::cerr << ((symbolsVT*)(analysisStack[i].second))->getWord() << " ";
                else std::cerr << ((symbolsVN*)analysisStack[i].second)->getName() << " ";
            }
            std::cerr << std::endl << "================" << std::endl;
            std::cerr << std::endl;
    		//************************************************************//
    		
            X = analysisStack[top];	// 得到分析栈的栈顶元素,pop操作
            state = AnalysisTable.get(X.first, a);	// 根据栈顶的状态以及分析表中的变化情况来获得下一转换的状态s_i, r_i, acc, i等等
            std::cerr << state.first << "  " << state.second << std::endl;
            if(state.first == 's'){		// 如果是移进状态
                analysisStack[++top] = std::make_pair(state.second, a);
                ADVANCE();
                std::cerr << "One SHIFT..." << std::endl << std::endl;;
            }
            else if(state.first == 'r'){	// 如果是规约状态
                p = AnalysisTable.getProduction(state.second);	// 获得第i个产生式
                p->print();
                int len = p->getLen();
                top -= len;					// 将栈顶的符号按照产生式来规约
                X = analysisStack[top];		// 获得此时的栈顶元素,据此来获得GOTO表的下一状态
                analysisStack[++top] = std::make_pair(AnalysisTable.get(X.first, p->getVN()).second, p->getVN());
                std::cerr << "One REDUCE..." << std::endl << std::endl;;
            }
            else if(state.first == 'a'){	// 如果是acc状态
                std::cerr << "ACC!!!" << std::endl << std::endl;
                flag = false;
            }
            else{							// 到达分析表的其他状态,错误
                grammer = false;
                flag = false;
            }
        }
    
        release();		// 释放资源
        return grammer;	// 返回结果,true表示句子符合一定的语法
    }
    

    程序入口

    项目调用测试入口:

    // main.cpp
    #include<bits/stdc++.h>
    #include"SLRAnalysis.cpp"
    using namespace std;
    typedef long long ll;
    const int mod = 1e9 + 7;
    const int maxn = 1e2 + 5;
    const int inf = 0x3f3f3f3f;
    
    
    int main(int argc, char *argv[]){
        // freopen("in.in", "r", stdin);
        // freopen("out.out", "w", stdout);
    
        if(SLRAnalysis()) cout << "Yes,it is correct." << endl;
        else cout << "No,it is wrong." << endl;
    
        return 0;
    }
    

    调试数据

    给出两组测试数据:

    // in.in
    (lparen,()
    (ident,a)
    (plus,+)
    (number,15)
    (rparen,))
    (times,*)
    
    
    // out.out
    No,it is wrong.
    
    // in.in
    (ident,akldjsfkl)
    (plus,+)
    (lparen,()
    (ident,alk)
    (times,*)
    (ident,askd)
    (minus,-)
    (ident,jfdkj)
    (times,*)
    (ident,ksfj)
    (slash,/)
    (ident,jsadlk)
    (plus,+)
    (lparen,()
    (ident,a)
    (slash,/)
    (ident,v)
    (minus,-)
    (ident,d)
    (plus,+)
    (ident,b)
    (rparen,))
    (rparen,))
    (slash,/)
    (ident,jfj)
    
    // out.out
    Yes,it is correct.
    

    实验体会

    本次实验是完成 LR分析法 的自下而上分析,相比较上一次实验的预测分析法,LR分析法主要的差别是分析表的构造上,通过活前缀DFA的构造,以及由此分析得到SLR分析表,将图的转换变为表内各状态的转换。实验中,自我认为最难的并不是程序的编写,而是构造活前缀DFA以及得到分析表的步骤,这一步中画图花费了很多的时间,同时也再一次的复习了相关的理论知识内容,当这一切准备工作完成后,只需根据此编写相关的代码即可,以为上个实验已经完成了最基础的诸如符号、产生式等类的编写,所以这次只需考虑分析表以及分析程序的编写,这次实验的简化也一定程度上达到了上一次实验中 代码重复使用 的目的。实验整体难度不大,是进一步的对理论知识的复习过程。

    HTML

    展开全文
  • 语法分析:自下而上分析

    千次阅读 2016-11-30 18:35:29
    自下而上分析法就是从输入串开始,逐步进行“归约”,直至归约到文法的开始符号;或者说,从语法树的末端开始,步步向上“归约”,直到根结。

    概述

    介绍自下而上语法分析方法。所谓自下而上分析法就是从输入串开始,逐步进行“归约”,直至归约到文法的开始符号;或者说,从语法树的末端开始,步步向上“归约”,直到根结。

    自下而上分析基本问题

    归约

    我们所讨论的自下而上分析法是一种“移进-归约”法。这种方法的大意是,用一个寄存符号的先进后出栈,把输入符号一个一个地移进到栈里,当栈顶形成某个产生式的一个候选式时,即把栈顶的这一部分替换成(归约为)该产生式的左部符号。

    首先考虑下面的例子:
    假定文法G为

       (1) S→aAcBe
       (2) A→b
       (3) A→Ab
       (4) B→d     <1>
    

    我们希望把输入串abbcde归约到S。每实现一步归约都是把栈顶的一串符号用某个产生式的左部符号来代替。后面我们权且把栈顶上的这样一串符号称为“可归约串” ,存在种种不同的方法刻画“可归约串”。对这个概念的不同定义形成了不同的自下而上分析法。在算符优先分析中,用“最左素短语”来刻画“可归约串”,在“规范归约”分析中,则用“句柄”来刻画“可归约串”。

    自下而上分析的中心问题是,怎样判断栈顶的符号串的可归约性,以及,如何归约。这是算符优先分析LR分析将讨论的问题。各种不同的自下而上分析法的一个共同特点是,边输入单词符号(移进符号栈),边归约。也就是在从左到右移进输入串的过程中,一旦发现栈顶呈现可归约串就立即进行归约。这个过程对于编译实现来说是一个十分自然的过程。

    规范归约简介

    令G是一个文法,S是文法的开始符号,假定abd是文法G的一个句型,如果有

    saAdA+b

    则称b是句型abd相对于非终结符A的短语。特别是,如果有

    AÞb

    则称b是句型abd相对于规则A→b的直接短语, 一个句型的最左直接短语称为该句型的句柄。

    作为“短语”的两个条件均是不可缺少的。仅仅有Ab,未必意味着b就是句型abd的一个短语。因为,还需有SaAd这一条件。

    稍为精确的一点说,假定a是文法G的一个句子,我们称序列

    an,an1,an2,.....,a1,a0

    是a的一个规范归约,如果此序列满足:

    1. an=a
    2. a0为文法的开始符,即a0=S
    3. 对任何i,0<ifn,ai1是从ai经把句柄替换为相应产生式的左部符号而得到的。

    容易看到,规范归约是关于a的一个最右推导的逆过程。因此,规范归约也称最左归约。

    在形式语言中,最右推导常被称为规范推导。由规范推导所得的句型称为规范句型。如果文法G是无二义的,那么,规范推导(最右推导)的逆过程必是规范归约(最左归约)。

    请注意句柄的“最左”特征,这一点对于移进-归约来说是重要的。因为,句柄的“最左”性和符号栈的栈顶两者是相关的。对于规范句型来说,句柄的后面不会出现非终结符号(即,句柄的后面只能出现终结符)。基于这一点,我们可用句柄来刻画移进-归约过程的“可归约串”。因此,规范归约的实质是,在移进过程中,当发现栈顶呈现句柄时就用相应产生式的左部符号进行替换。

    符号栈的使用与语法树的表示

    栈是语法分析的一种基本数据结构。在解释“移进-归约”的自下而上分析过程时我们就已经提到了符号栈。一个“移进-归约”分析器使用了这样的一个符号栈和一个输入缓冲区。今后我们将用一个不属于文法符号的特殊符号‘#’作为栈底符,即在分析开始时预先把它推进栈;同时,也用这个符号作为输入串的“结束符”,即无条件地将它置在输入串之后,以示输入串的结束。

    分析开始时,栈和输入串的初始情形为:

    符号栈 输入串
    w#

    分析器的工作过程是:自左至右把输入串w的符号一一移进符号栈里,一旦发现栈顶形成一个可归约串时,就把这个串用相应的归约符号(在规范归约的情况下用相应产生规则的左部符号)代替。这种替换可能持续多次,直至栈顶不再呈现可归约串为止。然后,就继续移进符号,重复整个过程,直至最终形成如下格局:

    符号栈 输入串
    #S

    此时,栈里只含#与最终归约符S(在规范归约的情形下S为文法开始符号),而输入串w全被吸收,仅剩下结束符。这种格局表示分析成功。如果达不到这种格局,意味着输入串w(源程序)含有语法错误。

    语法分析对符号栈的使用有四类操作:“移进”、“归约”、“接受”和“出错处理”

    • “移进” 指把输入串的一个符号移进栈。
    • “归约”指发现栈顶呈可归约串,并用适当的相应符号去替换这个串(这两个问题都还没有解决)。
    • “接受”指宣布最终分析成功,这个操作可看作是“归约”的一种特殊形式。
    • “出错处理”指发现栈顶的内容与输入串相悖,分析工作无法正常进行,此时需调用出错处理程序进行诊察和校正,并对栈顶的内容和输入符号进行调整。

    对于“归约”而言请留心一个非常重要的事实,任何可归约串的出现必在栈顶,不会在栈的内部。对于规范归约而言,这个事实是明显的。由于规范归约是最右推导的逆过程,因此这种归约具有“最左”性,故可归约串必在栈顶,而不会在栈的内部。正因如此,先进后出栈在归约分析中是一种非常有用的数据结构。

    如果要实际表示一棵语法分析树的话,一般来说,使用穿线表是比较方便的。这只须对每个进栈符号配上一个指示器就可以了。

    当要从输入串移进一个符号a入栈时,我们就开辟一项代表端末结a的数据结构,让这项数据结构的地址(指示器值)连同a本身一起进栈。端末结的数据结构应包括这样一些内容:(1) 儿子个数:0;(2) 关于a自身的信息(如单词内部值,现在暂且不管)。

    当要把栈顶的n个符号,如X1X2Xn归约为A时,我们就开辟一项代表新结A的数据结构。这项数据结构应包含这样一些内容:(1) 儿子个数:n;(2) 指向儿结的n个指示器值;(3) 关于A自身的其它信息。归约时,把这项数据结构的地址连同A本身一起进栈。

    最终,当要执行“接受”操作时,我们将发现一棵用穿线表表示的语法树业已形成,代表根结的数据结构的地址和文法的开始符号(在规范归约情况下)一起留在栈中。

    用这种方法表示语法树是最直截了当的。当然,也可以用别的或许是更加高效的表示方法。

    算符优先分析

    算符优先文法及其优先表构造

    一个文法,如果它的任一产生式的右部都不含两个相继(并列)的非终结符,即不含如下形式的产生式右部:

    QR

    则我们称该文法为算符文法

    在后面的定义中,a、b代表任意终结符;P、Q、R代表任意非终结符;‘…’代表由终结符和非终结符组成的任意序列,包括空字。

    假定G是一个不含e-产生式的算符文法。对于任何一对终结符a、b,我们说:

    1. ab当且仅当文法G中含有形如PabPaQb的产生式;
    2. ab当且仅当G中含有形如PaR的产生式,而RbRQb
    3. ab当且仅当G中含有形如PRb的产生式,而RaRaQ

    如果一个算符文法G中的任何终结符对(a,b)至多只满足下述三关系之一:

    ababab

    则称G是一个算符优先文法。

    现在来研究从算符优先文法G构造优先关系表的算法。

    通过检查G的每个产生式的每个候选式,可找出所有满足ab的终结符对。为了找出所有满足关系的终结符对,我们首先需要对G的每个非终结符P构造两个集合FIRSTVTPLASTVTP

    FIRSTVTPa|PaPQaaÎVTQÎVN

    LASTVTPa|PaPaQaÎVTQÎVN

    算符优先分析算法

    所谓素短语是指这样的一个短语,它至少含有一个终结符,并且,除它自身之外不再含任何更小的素短语。所谓最左素短语是指处于句型最左边的那个素短语。如上例,P*P和i是句型P*P+i的素短语,而P*P是它的最左素短语。

    现在考虑算符优先文法,我们把句型(括在两个#之间)的一般形式写成:

    #N1a1N2a2NnanNn+1# ……………. (4)

    其中,每个ai都是终结符,Ni是可有可无的非终结符。换言之,句型中含有n个终结符,任何两个终结符之间顶多只有一个非终结符。必须记住,任何算符文法的句型都具有这种形式。我们可以证明如下定理:
    一个算符优先文法G的任何句型(4)的最左素短语是满足如下条件的最左子串NjajNiaiNi+1

    aj1aj
    ajaj+1ai1ai
    aiai+1
    根据这个定理,下面我们讨论算符优先分析算法。为了和定理的叙述相适应,我们现在仅使用一个符号栈S,既用它寄存终结符,也用它寄存非终结符。下面的分析算法是直接根据这个定理构造出来的,其中k代表符号栈S的使用深度。

    优先函数

    在实际实现算符优先分析算法时,一般不用表5.1这样的优先表,而是用两个优先函数f和g。我们把每个终结符q与两个自然数fqgq相对应,使得

    • q1q2fq1<gq2
    • q1q2fq1=gq2 …….. (5)
    • q1q2fq1>gq2

    函数f称为入栈优先函数,g称为比较优先函数。使用优先函数有两方面的优点:便于作比较运算,并且节省存储空间,因为优先关系表占用的存储量比较大。其缺点是,原先不存在优先关系的两个终结符,由于与自然数相对应,变成可比较的了。因而,可能会掩盖输入串的某些错误。但是,我们可以通过检查栈顶符号q和输入符号a的具体内容来发现那些原先不可比较的情形。

    如果优先函数存在,那么,从优先表构造优先函数的一个简单方法是:

    1. 对于每个终结符a包括 令其对应两个符号faga,画一张以所有符号faga为结点的方向图,如果ab,那么,就从fa画一箭弧至gb;如果a⋖≖b,就画一条从gbfa的箭弧。
    2. 对每个结点都赋予一个数,此数等于从该结点出发所能到达结点(包括出发结点自身在内)的个数。赋给fa的数作为f(a),赋给gb的数作为g(b)。
    3. 检查所构造出来的函数f和g,看它们同原来的关系表是否有矛盾。如果没有矛盾,则f和g就是所要的优先函数。如果有矛盾,那么,就不存在优先函数。

    现在必须证明:若a≖b,则f(a)=g(b);若a⋖b,则f(a)< g(b);若a⋗b,则f(a)> g(b)。第一个关系可从函数的构造直接获得。因为,若a≖b,则既有从fa到gb的弧,又有从gb到fa的弧。所以,fa和gb所能到达的结是全同的。至于a⋗b和a⋖b的情形,只须证明其一。如果a⋗b,则有从fa到gb的弧。也就是,gb能到达的任何结fa也能到达。因此,f(a)³ g(b)。我们所需证明的是,在这种情况下,f(a)=g(b)不应成立。我们将指出,如果f(a)=g(b),则根本不存在优先函数。假若f(a)=g(b),那么必有

              a⋗b, a1⋖≖b, a1⋗≖b1,…am⋗≖bm, a⋖≖bm
    

    因为对任何优先函数都必须满足(5.5) 所规定的条件,而上面的关系恰恰表明,对任何优先函数f和g来说,必定有

    f(a)> g(b)³ f(a1)³ g(b1)³ … ³ f(am)³ g(bm)³ f(a)

    从而导致f(a)> f(a),产生矛盾。因此,不存在优先函数f和g。

    算符优先分析中的出错处理

    使用算符优先分析法时,可在两种情况下,发现语法错误:

    1. 若在栈顶终结符号与下一输入符号之间不存在任何优先关系;

    2. 若找到某一“句柄”(此处“句柄”指素短语),但不存在任一产生式,其右部为此“句柄”。

    针对上述情况,处理错误的子程序也可分成几类。首先,我们考虑处理类似第2种情况错误的子程序。当发现这种情况时,就应该打印错误信息。子程序要确定该“句柄”与哪个产生式的右部最相似。例如,假定从栈中确定的“句柄”是abc,可是,没有一个产生式,其右部包含a,b,c在一起。此时,可考虑是否删除a,b,c中的一个。例如,假若有一产生式,其右部为aAcB,则可给出错误信息:“非法b”;若另有一产生式,其右部为abdc,则可给出错误信息:“缺少d”。

    LR分析法

    LR分析器

    规范归约(最左归约—最右推导的逆过程)的关键问题是寻找句柄。在一般的“移进-归约”过程中,当一串貌似句柄的符号串呈现于栈顶时,我们有什么方法可以确定它是否为相对于某一产生式的句柄呢?LR方法的基本思想是,在规范归约过程中,一方面记住已移进和归约出的整个符号串,即记住“历史”,另一方面根据所用的产生式推测未来可能碰到的输入符号,即对未来进行“展望”。当一串貌似句柄的符号串呈现于分析栈的顶端时,我们希望能够根据所记载的“历史”和“展望”以及“现实”的输入符号等三方面的材料,来确定栈顶的符号串是否构成相对某一产生式的句柄。

    LR分析法的这种基本思想是很符合哲理的。因而可以想象,这种分析法也必定是非常通用的。正因如此,实现起来也就非常困难。作为归约过程的“历史”材料的积累虽不困难(实际上,这些材料都保存在分析栈中),但是,“展望”材料的汇集却是一件很不容易的事情。这种困难不是理论上的,而是实际实现上的。因为,根据历史推测未来,即使是推测未来的一个符号,也常常存在着非常多的不同可能性。因此,当把“历史”和“展望”材料综合在一起时,复杂性就大大增加。如果简化对“展望”资料的要求,我们就可能获得实际可行的分析算法。

    后面所讨论的LR方法都是带有一定限制的。

    一个LR分析器实质上是一个带先进后出存储器(栈)的确定有限状态自动机。我们将把“历史”和“展望”材料综合地抽象成某些“状态”。分析栈(先进后出存储器)用来存放状态。栈里的每个状态概括了从分析开始直到某一归约阶段的全部“历史”和“展望”资料。任何时候,栈顶的状态都代表了整个的历史和已推测出的展望。因此,在任何时候都可从栈顶状态得知你所想了解的一切,而绝对没有必要从底而上翻阅整个栈。LR分析器的每一步工作都是由栈顶状态和现行输入符号所唯一决定的。为了有助于明确归约手续,我们把已归约出的文法符号串也同时放在栈里(显然它们是多余的,因为它们已被概括在“状态”里了)。于是,我们可以把栈的结构看成是:

    栈的每一项内容包括状态s和文法符号X两部分。(s0,#)为分析开始前预先放到栈里的初始状态和句子括号。栈顶状态为sm,符号串X1X2…Xm是至今已移进归约出的部分。

    LR分析器的核心部分是一张分析表。这张分析表包括两部分,一是“动作”(ACTION)表,另一是“状态转换”(GOTO)表。它们都是二维数组。ACTION[s, a]规定了当状态s面临输入符号a时应采取什么动作。GOTO[s,X]规定了状态s面对文法符号X(终结符或非终结符)时下一状态是什么。显然,GOTO[s,X]定义了一个以文法符号为字母表的DFA。

    每一项ACTION[s,a]所规定的动作不外是下述四种可能之一:

    1. 移进 把(s,a)的下一状态s¢=GOTO[s,a]和输入符号a推进栈,下一输入符号变成现行输入符号。

    2. 归约 指用某一产生式A→b进行归约。假若b的长度为r,归约的动作是A,去除栈顶的r个项,使状态sm-r变成栈顶状态,然后把(sm-r,A)的下一状态s¢=GOTO[sm-r,A]和文法符号A推进栈。归约动作不改变现行输入符号。执行归约动作意味着b(=Xm-r+1…Xm)已呈现于栈顶而且是一个相对于A的句柄。

    3. 接受 宣布分析成功,停止分析器的工作。

    4. 报错 发现源程序含有错误,调用出错处理程序。

    LR分析器的总控程序本身的工作是非常简单的。它的任何一步只需按栈顶状态s和现行输入符号a执行ACTION[s,a]所规定的动作。不管什么分析表,总控程序都是一样地工作。

    一个LR分析器的工作过程可看成是栈里的状态序列、已归约串和输入串所构成的三元式的变化过程。分析开始时的初始三元式为:

    s0, #, a1a2an#)

    其中s0为分析器的初态;#为句子的左括号;a1a2an 为输入串,其后的#为结束符(句子右括号)。分析过程每步的结果可表示为:
    s0s1sm, #X1X2Xm,aiai+1an#)

    分析器的下一步动作是由栈顶状态sm和现行输入符号ai所唯一决定的。即,执行ACTION[sm,ai]所规定的动作。经执行每种可能的动作之后,三元式的变化情形是:
    1. 若ACTION[sm,ai]为移进,且s=GOTO[sm,ai],则三元式变成:
    s0s1sms, #X1X2Xmai,ai+1an#)

    2. 若ACTION[sm,ai]=Ab,则按产生式Ab进行归约。此时三元式变为:
    s0s1smrs, # X1XmrA,aiai+1an #)

    此处s=GOTO[smr,A]rb的长度,bXmr+1Xm
    3. 若ACTION[sm,ai]为“接受”,则三元式不再变化,变化过程终止,宣布分析成功。
    4. 若ACTION[sm,ai]为“报错”,则三元式的变化过程终止,报告错误。

    一个LR分析器的工作过程就是一步一步地变换三元式,直至执行“接受”或“报错”为止。

    对于一个LR分析器来说,栈顶状态提供了所需的一切“历史”和“展望”信息。请注意一个非常重要的事实:如果仅由栈的内容和现实的输入符号就可以识别一个句柄,那么,就可以用一个有限自动机自底向上扫描栈的内容和检查现行输入符号来确定呈现于栈顶的句柄是什么(如果形成一个句柄时)。实际上,LR分析器就是这样的一个有限自动机。只是,因栈顶的状态已概括了整个栈的内容,因此,无需扫描整个栈。栈顶状态就好象已代替我们进行了这种扫描。

    LR文法

    我们主要关心的问题是,如何从文法构造LR分析表。对于一个文法,如果能够构造一张分析表,使得它的每个入口均是唯一确定的,则我们将把这个文法称为LR文法。并非所有上下文无关文法都是LR文法。但对于多数程序语言来说,一般都可用LR文法描述。直观上说,对于一个LR文法,当分析器对输入串进行自左至右扫描时,一旦句柄呈现于栈顶,就能及时对它实行归约。

    一个LR分析器有时需要“展望”和实际检查未来的k个输入符号才能决定应采取什么样的“移进-归约”决策。一般而言,一个文法,如果能用一个每步顶多向前检查k个输入符号的LR分析器进行分析,则这个文法就称为LR(k)文法。但对多数的程序语言来说,k=0或1就足够了。因此,我们只考虑k£1的情形。

    注意,LR方法关于识别产生式右部的条件远不象预测法那样严峻。预测法要求每个非终结符的所有候选的首符均不同,预测分析程序认为,一旦看到首符之后就看准了该用哪一个产生式进行推导。但LR分析程序只有在看到整个右部所推导的东西之后才认为是看准了归约方向。因此,LR方法比预测法应该更加一般化。

    LR(0)项目集族和LR(0)分析表的构造

    对于一个文法G,我们可以构造一个有限自动机,它能识别G的所有活前缀。在这个基础上,我们将讨论如何把这种自动机转变成LR分析表。

    对于一个文法G,我们首先要构造一个NFA,它能识别G的所有活前缀。这个NFA的每个状态是下面定义的一个“项目”。文法G每一个产生式的右部添加一个圆点称为G的一个LR0项目(简称项目)。例如,产生式AXYZ对应有四个项目:
    AXYZ
    AXYZ
    AXYZ
    AXYZ

    但是,产生式Ae只对应一个项目A。在计算机中,每个项目可用一对整数表示,第一个整数代表产生式编号,第二个整数指出圆点的位置。

    直观上说,一个项目指明了在分析过程的某时刻我们看到产生式多大一部分。例如,上面四项的第一个项目意味着,我们希望能从后面输入串中看到可以从XYZ推出的符号串。第二个项目意味着,我们已经从输入串中看到能从X推出的符号串,我们希望能进一步看到可以从YZ推出的符号串。

    我们可以使用这些项目状态构造一个NFA,用来识别这个文法的所有活前缀。这个文法的开始符号S¢仅在第一个产生式的左部出现。使用这个事实,我们规定项目1为NFA的唯一初态。任何状态(项目)均认为是NFA的终态(活前缀识别态)。如果状态i和j出自同一产生式,而且状态j的圆点只落后于状态i的圆点一个位置,如状态i为

    XX1Xi1XiXn

    而状态j为
    XX1XiXi+1Xn

    那么,就从状态i画一条标志为Xi的弧到状态j。假若状态i的圆点之后的那个符号为非终结符,如iXaAbA为非终结符,那么,就从状态i画e弧到所有Ag状态(即,所有那些圆点出现在最左边的A的项目)。

    子集方法,我们能够把识别活前缀的NFA确定化,使之成为一个以项目集合为状态的DFA,这个DFA就是建立LR分析算法的基础。

    构成识别一个文法活前缀的DFA的项目集(状态)的全体称为这个文法的LR(0)项目集规范族。这个规范族提供了建立一类LR(0)和SLR(简单LR)分析器的基础。

    为了便于叙述,我们用一些专门术语来称呼不同的项目。凡圆点在最右端的项目,如A→a·,称为一个“归约项目”。对文法的开始符号S¢的归约项目,如S¢→a·,称为“接受”项目。显然,“接受”项目是一种特殊的归约项目。形如A→a·ab的项目,其中a为终结符,称为“移进”项目。形如A→a·Bb的项目,其中B为非终结符,称为“待约”项目。

    LR(0)项目集规范族的构造

    下面所引进的eCLOSURE(闭包)的办法来构造一个文法G的LR(0)项目集规范族。

    为了使“接受”状态易于识别,我们总把文法G进行拓广。假定文法G是一个以S为开始符号的文法,我们构造一个G¢,它包含了整个G,但它引进了一个不出现在G中的非终结符S¢,并加进一个新产生式S¢S,而这个S¢G¢开始符号。那么,我们称G¢是G的拓广文法。这样,便会有一个仅含项目S¢→S的状态,这就是唯一的“接受”态。

    假定I是文法G¢的任一项目集,定义和构造I的闭包CLOSUREI的办法是:

    1. I的任何项目都属于CLOSUREI
    2. AaBb属于CLOSUREI,那么,对任何关于B的产生式Bg4B→·gCLOSURE(I)$;
    3. 重复执行上述两步骤直至CLOSUREI不再增大为止。

    在构造CLOSUREI时,请注意一个重要的事实,那就是,对任何非终结符B,若某个圆点在左边的项目B→·g进入到CLOSURE(I),则B的所有其它圆点在左边的项目B→·b也将进入同一个CLOSURE集。因此,在某种情况下,并不需要真正列出CLOSURE集里的所有项目B→·g,而只须列出非终结符B就可以了。

    函数GO是一个状态转换函数。GOIX的第一个变元I是一个项目集,第二个变元X是一个文法符号。函数值GOIX定义为:

    GOIXCLOSUREJ

    其中:JAaXb|AaXbI

    直观上说,若I是对某个活前缀g有效的项目集,那么,GO(I,X)便是对gX有效的项目集。通过函数CLOSURE和GO很容易构造一个文法G的拓广文法G¢的LR(0)项目集规范族。构造算法是:

    PROCEDURE  ITEMSETSG¢);
    BEGIN
             C:={CLOSURE({S¢®·S})};
             REPEAT
                       FOR  C中的每个项目集I和G¢的每个符号X  DO
                                IF GO(I,X)非空且不属于C   THEN
                                   把GO(I,X)放入C族中
             UNTIL C   不再增大
    END

    这个算法的工作结果C就是文法G¢的LR(0)项目集规范族。

    有效项目

    我们希望从识别文法的活前缀的DFA建立LR分析器(带栈的确定有限状态自动机)。因此,需要研究这个DFA的每个项目集(状态)中的项目的不同作用。

    我们说项目Ab1b2对活前缀ab1是有效的,其条件是存在规范推导S¢aAwab1b2w。一般而言,同一项目可能对好几个活前缀都是有效的(当一个项目出现在好几个不同的集合中时便是这种情形)。若归约项目A→b1·对活前缀ab1是有效的,则它告诉我们应把符号串b1归约为A,即把活前缀ab1变成aA。若移进项目A→b1·b2对活前缀ab1是有效的,则它告诉我们,句柄尚未形成,因此,下一步动作应是移进。但是,可能存在这样的情形,对同一活前缀,存在若干项目对它都是有效的。而且它们告诉我们应做的事情各不相同,互相冲突。这种冲突通过向前多看几个输入符号,或许能够获得解决。我们在下一节将讨论这种情形,当然,对于非LR文法,这种冲突有些是绝对无法解决的,不论超前多看几个输入符号也无济于事。

    对于每个活前缀,我们可以构造它的有效项目集。实际上,一个活前缀g的有效项目集正是从上述的DFA的初态出发,经读出g后而到达的那个项目集(状态)。换言之,在任何时候,分析栈中的活前缀X1X2…Xm的有效项目集正是栈顶状态Sm所代表的那个集合。这是LR分析理论的一条基本定理。实际上,栈顶的项目集(状态)体现了栈里的一切有用信息—历史。

    LR(0)分析表的构造

    假若一个文法G的拓广文法G¢的活前缀识别自动机中的每个状态(项目集)不存在下述情况:1) 既含移进项目又含归约项目,或者2) 含有多个归约项目,则称G是一个LR(0)文法。换言之,LR(0)文法规范族的每个项目集不包含任何冲突项目。

    对于LR(0)文法,我们可直接从它的项目集规范族C和活前缀识别自动机的状态转换函数GO构造出LR分析表。下面是构造LR(0)分析表的算法。

    假定CI0,I1,,In。前面,我们已习惯用数码表示状态,因此,令每个项目集Ik的下标k作为分析器的状态。特别是,令那个包含项目S¢S的集合Ik的下标k为分析器的初态。分析表的ACTION子表和GOTO子表可按如下方法构造:

    1. 若项目Aaab属于IkGOIk,aIja为终结符,则置ACTION[k,a]为“把(j,a)移进栈”,简记为“sj”。
    2. 若项目Aa属于Ik,那么,对任何终结符a(或结束符#),置ACTION[k,a]为“用产生式Aa进行归约”,简记为“rj”(假定产生式Aa是文法G¢的第j个产生式)。
    3. 若项目S¢S属于Ik,则置ACTION[k,#]为“接受”,简记为“acc”。
    4. GOIk,AIjA为非终结符,则置GOTO[k,A]=j
    5. 分析表中凡不能用规则1至4填入信息的空白格均置上“报错标志”。

    由于假定LR0文法规范族的每个项目集不含冲突项目,因此,按上法构造的分析表的每个入口都是唯一的(即,不含多重定义)。我们称如此构造的分析表是一张LR0表。使用LR0表的分析器叫做一个LR0分析器。

    SLR分析表的构造

    上面所说的LR(0)文法是一类非常简单的文法。这种文法的活前缀识别自动机的每一个状态(项目集)都不含冲突性的项目。但是,即使是定义算术表达式这样的简单文法也不是LR(0)的。因此,本节我们将要研究一种有点简单“展望”材料的LR分析法,即SLR法。

    我们将看到,许多冲突性的动作都可能通过考察有关非终结符的FOLLOW集而获解决。例如,假定一个LR(0)规范族中含有如下的一个项目集(状态)I,

    I={X→a·bb,
     Aa·,
     B→a·}

    其中,第一个项目是移进项目,第二、三项目是归约项目。这三个项目告诉我们应做的动作各不相同,互相冲突。第一个项目告诉我们应该把下一个输入符号b(如果是b)移进。第二个项目告诉我们应把栈顶的a归约为A;第三个项目则说应把a归约为B。解决冲突的一种简单办法是,分析所有含A或B的句型,考察句型中可能直接跟在A或B之后的终结符,也就是说,考察集合FOLLOW(A)和FOLLOW(B),如果这两个集合不相交,而且都不包含b,那么,当状态I面临任何输入符号a时,我们就可以采取如下的“移进-归约”决策:

    1. a=b,则移进;
    2. aÎFOLLOWA,则用产生式Aa进行归约;
    3. aÎFOLLOWB,则用产生式Ba进行归约;
    4. 此外,报错。

    一般而言,假定LR0规范族的一个项目集I中含有m个移进目;
    A1aa1b1A2aa2b2,…,Amaambm
    同时含有n个归约项目:B1aB2a,…,Bna
    如果集合{a1am}FOLLOWB1FOLLOWBn两两不相交(包括不得有两个FOLLOW集合有#),则隐含在I中的动作冲突可通过检查现行输入符号a属于上述n+1个集合中的哪个集合而获得解决。这就是:

    1. 若a是某个ai,i=1,2,…,m,则移进;
    2. 若aÎFOLLOW(Bi),i=1,2,…,n,则用产生式Bi→a进行归约;
    3. 此外,报错。
      冲突性动作的这种解决办法叫做SLR(1)解决办法。

    对任给的一个文法G,我们可用如下的办法构造它的SLR(1)分析表:首先把G拓广为G¢,对G¢构造LR(0)项目集规范族C和活前缀识别自动机的状态转换函数GO。使用C和GO,然后再按下面的算法构造G¢的SLR分析表。

    假定C={I0,I1,…,In},令每个项目集Ik的下标k为分析器的一个状态,因此,G¢的SLR分析表含有状态0,1,…,n。令那个含有项目S¢→·S的Ik的下标为初态。函数ACTION和GOTO可按如下方法构造:

    1. 若项目A→·aab属于Ik且GO(Ik,a)=Ij,a为终结符,则置ACTION[k,a]为“把状态j和符号a移进栈”,简记为“sj”;
    2. 若项目A→a·属于Ik,那么,对任何终结符a,aÎFOLLOW(A),置ACTION[k,a]为“用产生式A→a进行归约”,简记为“rj”;其中,假定A®a为文法G¢的第j个产生式;
    3. 若项目S¢→S·属于Ik,则置ACTION[k,#]为“接受”,简记为“acc”;
    4. 若GO(Ik,A)=Ij,A为非终结符,则置GOTO[k,A]=j;
    5. 分析表中凡不能用规则1至4填入信息的空白格均置上“出错标志”。

    按上述算法构造的含有ACTION和GOTO两部分的分析表,如果每个入口不含多重定义,则称它为文法G的一张SLR表。具有SLR表的文法G称为一个SLR(1)文法。数字1的意思是,在分析过程中顶多只要向前看一个符号。使用SLR表的分析器叫做一个SLR分析器。

    若按上述算法构造的分析表存在多重定义的入口(即含有动作冲突),则说明文法G不是SLR(1)的。在这种情况下,不能用上述算法构造分析器。

    每个SLR(1)文法都是无二义的。但也存在许多无二义文法不是SLR(1)的。

    规范LR分析表的构造

    在SLR方法中,若项目集Ik含有A→a·,那么,在状态k时,只要所面临的输入符号aÎFOLLOW(A),就确定采取“用A→a归约”的动作。但是,在某种情况下,当状态k呈现于栈顶时,栈里的符号串所构成的活前缀ba未必允许把a归约为A,因为可能没有一个规范句型含有前缀bAa。因此,在这种情况下,用A→a进行归约未必有效。

    可以设想让每个状态含有更多的“展望”信息,这些信息将有助于克服动作冲突和排除那种用A→a所进行的无效归约。我们可以设想,必要时,对状态进行分裂,使得LR分析器的每个状态能够确切地指出,当a后跟哪些终结符时才容许把a归约为A。

    我们需要重新定义项目,使得每个项目都附带有k个终结符。现在每个项目的一般形式是[Aab,a1a2ak],此处,Aab是一个LR(0)项目,每一个a都是终结符。这样的一个项目称为一个LR(k)项目。项目中的 a1a2ak 称为它的向前搜索符串(或展望串)。向前搜索符串仅对归约项目[Aaa1a2ak]有意义。对于任何移进或待约项目[Aab,a1a2ak],b¹e,搜索符串a1a2ak 没有作用。归约项目[Aa,a1a2ak]意味着:当它所属的状态呈现在栈顶且后续的k个输入符号为a1a2ak 时,才可以把栈顶上的a归约为A。我们只对k£1的情形感兴趣,因为,对多数程序语言的语法来说,向前搜索(展望)一个符号就多半可以确定“移进”或“归约”。

    形式上我们说一个LR1项目[Aab,a]对于活前缀g是有效的,如果存在规范推导

    SdAwdabw

    其中,1)gda2)a是w的第一个符号,或者a为#而w为e。
    构造有效的LR(1)项目集族的办法本质上和构造LR(0)项目集规范族的办法是一样的。类似地,我们也需要两个函数CLOSURE和GO。

    假定I是一个项目集,它的闭包CLOSURE(I)可按如下方式构造:
    1. I的任何项目都属于CLOSURE(I)。
    2. 若项目[A→a·Bb, a]属于CLOSURE(I),B→x是一个产生式,那么,对于FIRST(ba)中的每个终结符b,如果[B→·x, b]原来不在CLOSURE(I)中,则把它加进去。
    3. 重复执行步骤2,直至CLOSURE(I)不再增大为止。
    因为,[A→a·Bb, a]属于对活前缀g=da有效的项目集意味着存在一个规范推导

    SdAacdaBbac

    因此,若bac可推导出bw,则对于每个形如B®x的产生式,我们有SgBbwgxbw,也就是说,[B→·x, b]对g也是有效的。注意,b可能是从b推出的第一个符号,或者,若b推出e,则b就是a,把这两种可能性结合在一起,我们说bÎFIRST(ba)。
    令I是一个项目集,X是一个文法符号,函数GO(I,X)定义为:

    GOIXCLOSUREJ

    其中
    J[AaXb,a]|[AaXb,a]ÎI

    关于文法G¢的LR(1)项目集族C的构造算法是:

    BEGIN
           C:={CLOSURE({[S¢→·S,#]})};
           REPEAT
                  FOR       C中的每个项目集I和G¢的每个符号X    DO
                         IF    GO(I,X)非空且不属于C,THEN 把GO(I,X)加入C中
           UNTIL    C不再增大
    END

    现在来讨论从文法的LR(1)项目集族C构造分析表的算法。

    假定C={I0, I1,…, In},令每个Ik的下标k为分析表的状态。令那个含有[S¢→·S, #]的Ik的k为分析器的初态。动作ACTION和状态转换GOTO可构造如下:

    1. 若项目[A→a·ab, b]属于Ik且GO(Ik, a)=Ij, a为终结符,则置ACTION[k, a]为“把状态j和符号a移进栈”,简记为“sj”。
    2. 若项目[A→a·,a]属于Ik,则置ACTION[k, a]为“用产生式A→a归约”,简记为“rj”;其中假定A→a为文法G¢的第j个产生式。
    3. 若项目[S¢→S·, #]属于Ik,则置ACTION[k, #]为“接受”,简记为“acc”。
    4. 若GO(Ik,A)=Ij,则置GOTO[k, A]=j。
    5. 分析表中凡不能用规则1至4填入信息的空白栏均填上“出错标志”。

    按上述算法构造的分析表,若不存在多重定义的入口(即,动作冲突)的情形,则称它是文法G的一张规范的LR(1)分析表。使用这种分析表的分析器叫做一个规范的LR分析器。具有规范的LR(1)分析表的文法称为一个LR(1)文法。
    每个SLR(1)文法都是LR(1)文法。一个SLR(1)文法规范的LR分析器比其SLR分析器含有更多的状态。

    LALR分析表的构造

    现在来讨论构造分析表的LALR 方法。这本质上是一种折衷方法。LALR 分析表比规范LR分析表要小得多,能力也差一点。但它却能对付一些SLR所不能对付的情形,例如,文法(5.9)的情形。

    对于同一个文法,LALR 分析表和SLR分析表永远具有相同数目的状态。对于ALGOL一类语言来说,一般要用几百个状态,但若用规范LR分析表,同一类语言,却要用几千个状态。因此,用SLR或LALR要经济得多。

    我们称两个LR(1)项目集具有相同的心,如果除去搜索符之后,这两个集合是相同的。我们将试图把所有同心的LR(1)项目集合并为一。我们还将看到一个心就是一个LR(0)项目集。

    由于GO(I,X)的心仅仅依赖于I的心,因此,LR(1)项目集合并后的转换函数GO可通过GO(I,X)自身的合并而得到。即,在合并项目集时用不着同时考虑修改转换函数的问题。动作ACTION应进行修改,使得能够反映各被合并的集合的既定动作。

    假定有一个LR(1)文法,即,它的LR(1)项目集不存在动作冲突,如果我们把同心集合并为一,就可能导致存在冲突。但是这种冲突不会是“移进—归约”冲突。因为,如存在这种冲突,则意味着,面对当前的输入符号a,有一个项目[A→a·, a]要求采取归约动作,同时又有另一项目[B→b·ag, b]要求把a移进。这两个项目既然同处在合并之后的一个集合中,则意味着,在合并前,必有某个c使得[A→a·, a]和[B→b·ag, b]同处于(合并前的)某一集合中。然而,这一点又意味着,原来的LR(1)项目集就已存在着“移进—归约”冲突。故同假设不符。因此,同心集的合并不会产生新的“移进-归约”冲突。

    但是,同心集的合并有可能产生新的“归约—归约”冲突。例如,考虑文法
    (0) S¢→S
    (1) S→aAd | bBd | aBe | bAe
    (2) A→c
    (3) B→c

    这个文法只产生四个符号串:acd、bcd、ace和bce。如果我们构造这个文法的LR(1)项目集族,那么,将发现不会存在冲突性动作。因而它是一个LR(1)文法。在它的集族中,对活前缀ac有效的项目集为{[A→c·, d], [B→c·, e]},对bc有效的项目集为{[A→c·, e], [B→c·, d]}。这两个集合都不含冲突,它们是同心的。一经合并就变成:{[A→c·, d/e], [B→c·, d/e]。显然,这是一个含有“归约—归约”冲突的集合。因为,当面临e或d时,我们不知道该用A→c还是用B→c进行归约。

    下面,我们将给出构造LALR分析表算法。基本思想是,首先构造LR(1)项目集族,如果它不存在冲突,就把同心集合并在一起。若合并后的集族不存在归约-归约冲突,就按这个集族构造分析表。这个算法的主要步骤是:

    1. 构造文法G的LR(1)项目集族C={I0, I1, …, In}。
    2. 把所有的同心集合并在一起,记C¢={J0, J1, …, Jm}为合并后的新族。那个含有项目[S¢®·S, #]的Jk为分析表的初态。
    3. 从C¢构造ACTION表:
      (1) 若[A→a·ab, b]ÎIk且GO(Jk, a)=Ji,a为终结符,则置ACTION[k, a]为“sj”。
      (2) 若[A→a·,a] ÎJk,则置ACTION[k, a]为“使用A®a归约”,简记为“rj”;其中假定A→a为文法G¢的第j个产生式。
      (3) 若[S¢→S·, #]ÎJk,则置ACTION[k, #]为“接受”,简记为“acc”。
    4. GOTO表的构造:假定Jk是Ii1,Ii2,…,Iit合并后的新集。由于所有这些Ii同心,因此,GO(Ii1, X),GO(Ii2, X),…,GO(Iit, X)也具同心。记Ji为所有这些GO合并后的集。那么,就有GO(Jk, X)=Ji。于是,若GO(Jk,A)=Ji,则置GOTO[k,A]=j。
    5. 分析表中凡不能用3、4填入信息的空白格均填上“出错标志”。

    经上述步骤构造的分析表若不存在冲突,则称它为文法G的LALR分析表。存在这种分析表的文法称为一个LALR(1)文法。

    这个算法的思想虽然简单明确,但实现起来甚费时间和空间。

    二义文法的应用

    任何二义文法决不是一个LR文法,因而也不是SLR或LALR文法。这是一条定理。但是,某些二义文法是非常有用的。例如,若用下面的文法来描述含有+、*的算术表达式:

    EEE|EE|(E)|i .......<1>

    那么,只要对算符+、*赋予优先级和结合规则,这个文法是再简单不过了。这个文法与文法
    EET|T
    TTF|F ......<2>
    F(E)|i

    相比,有两个明显的好处:首先,如需要改变算符的优先级或结合规则无需去改变文法<1>自身。其次,文法<1>的分析表所包含的状态肯定比<2>所包含的状态要少得多。因为<2>中含有单非产生式(右部只含一个单一的非终结符)ETTF,这些旨在定义算符优先级和结合规则的产生式要占用不少状态和消耗不少时间。本节将讨论如何使用LR分析法的基本思想,凭借一些其它条件,来分析二义文法所定义的语言。

    LR分析中的出错处理

    在LR分析过程中,当我们处在这样一种状态下,即输入符号既不能移入栈顶,栈内元素又不能归约时,就意味着发现语法错误。发现错误后,便进入相应的出错处理子程序。处理的方法分为两类:第一类多半使用插入、删除或修改的办法。如在语句a[1,2:=3.14;中插入一个]。如果不可能使用这种办法,则采用第二类办法。第二类处理办法包括在检查到某一不合适的短语时,它不能与任一非终结符可能推导出的符号串相匹配。如语句

    if x>k+2 then go 10 else k is 2;

    由于把保留字goto误写成go,校正程序试图改成goto,但后面还有错误(将‘:=’误为‘is’),故放弃将go换为goto。校正子程序在此种情况下,将go 1跳过,作为非法语句看待。这种方法企图将含有语法错误的短语局部化。分析程序认定含有错误的符号串是由某一非终结符A所推导出的,此时该符号串的一部分已经处理,处理的结果反映在栈顶部一系列状态中,剩下的未处理符号仍在输入串中。分析程序跳过这些剩余符号,直至找到一个符号a,它能合法地跟在A的后面。同时,要把栈顶的内容逐个移去,直至找到某一状态s,该状态与A有一个对应的新状态GOTO[s,A],并将该新状态下推入栈。这样,分析程序就认为它已找到A的某个匹配并已将它局部化,然后恢复正常的分析过程。

    利用这种方法,可以以语句为单位进行处理,也可以把跳过的范围缩小。例如,若在‘if’后面的表达式中遇到某一错误,分析程序可跳至下一个输入符号‘then’而不是‘;’或‘end’。

    与算符优先分析方法比较,用LR分析方法时,设计特定的出错处理子程序比较容易,因为不会发生不正确的归约。在分析表的每一空项内,可以填入一个指示器,指向特定的出错处理子程序。第一类错误的处理一般采用插入、删除或修改的办法,但要注意,不能从栈内移去任何那种状态,它代表已成功地分析了的程序中的某一成分。

    前面讨论的只是很简单的情况。一个可投入实际运行的LR分析程序,需要考虑许多更为复杂的情形。例如,当处在某一状态下遇到各种不合法的符号时,错误诊察子程序需要向前查看几个符号,根据所查看的符号才能确定应采取哪一种处理办法。又如前已述及,分析表中有些状态在遇到不合法的输入符号时,不是立即转到错误诊察子程序,而是进行某些归约,这不仅推迟了发现错误的时间,而且往往会带来一些处理上的困难。试研究下面的一输入符号串:

    a:=b?c];

    这里以‘?’表示在b与c之间有某个错误。如果分析程序遇到‘a:=b’而不向前多看几个符号,则它就会把‘a:=b’先归约成语句,而后我们就再没有机会通过简单地插入符号‘[’进行修补了。但是,即使采用向前查看的办法,查看的符号也不能太多,否则会使分析表变得过分庞大。应该找出一种切实可行的办法,使得在确定处理出错办法时能够参考一些语义信息,以便在向前查看几个符号时,可以避免作出有时从语法上看是正确的,然而却是无意义的校正这一情况。例如,语句

    a[1,2:=3.14;

    中,标识符‘a’是一个数组标识符,这一语义信息将导致插入符号‘]’。

    典型题解

    1. 例题 什么叫句柄?什么叫素短语?(北京航空航天大学1999年硕士生入学考试)
      解答:一个句型的最左直接短语称为该句型的句柄。所谓素短语是指这样的一个短语,它至少含有一个终结符,并且,除它自身之外不再含任何更小的素短语。

    2. 例题 文法G(S):
      SbTc
      Sa
      TR
      RR/S
      RS
      符号串bR/bTc/bSc/ac是不是该文法的一个句型,请证实。若是句型,写出该句型的所有短语、素短语以及句柄。(上海交大1997年试题)
      解答: 由于有推导:
      SÞbTcÞbRcÞbR/Sc
      ÞbR/S/ScÞbR/S/S/ScÞbR/bTc/S/ScÞbR/bTc/bTc/Sc
      ÞbR/bTc/bRc/ScÞbR/bTc/bSc/ScÞbR/bTc/bSc/ac
      所以,bR/bTc/bSc/acG的一个句型。
      句型bR/bTc/bSc/ac中:
      短语:aSbScbTcR/bTcR/bTc/bScR/bTc/bSc/abR/bTc/bSc/ac
      素短语:abScbTc
      句柄:bTc

    3. 例题 给出文法G(S)
      SSaA|A
      AAbB|B
      BcSd|e
      请证实AacAbcBaAdbed是文法G的一个句型;请写出该句型的所有短语、素短语以及句柄。(上海交大2000年试题)
      解答: 由于有推导:
      SÞSaAÞAaAÞAaBÞAacSd
      ÞAacAdÞAacAbBd
      ÞAacAbBbBdÞAacAbcSdbBdÞAacAbcSaAdbBd
      ÞAacAbcAaAdbBdÞAacAbcBaAdbBdÞAacAbcBaAdbed
      所以,AacAbcBaAdbedG的一个句型。
      句型AacAbcBaAdbed中:
      短语:
      eBABaAcBaAdAbcBaAdAbcBaAdbecAbcBaAdbedAacAbcBaAdbed
      素短语:eBaA
      句柄:B

    参考文献

    1. ..1984.
    2. AlfredV.Aho,RaviSethi,JeffreyD.Ullman.Compilers:Principles,Techniques,andTools. AcldisonWesleyPublishingCompany,1986.
    3. A.V.Aho,J.D.Ullman.PrinciplesofCompilerDescign,Addison=Wesley,1977.
    4. 王兵山,吴兵,形式语言. 国防科技大学出版社,1988.
    5. A.Salomaa.FormalLanguages.AcademicPress,1975.
    6. lexyaccJohnR.Levine,TonyMason,DougBrown,,
    7. StephenC.Johnson.Yacc:YetAnotherCompilerCompiler.http://dinosaur.compiler