编译原理之算符优先分析语法程序

最新推荐文章于 2024-02-04 19:51:09 发布
最新推荐文章于 2024-02-04 19:51:09 发布
阅读量1.2w 收藏 61
点赞数 6
分类专栏： 猿猿杂货铺 文章标签： 编译原理 算符优先分析语法算法
本文为一帆原创文章，欢迎转载，但事先请私信告知以及标明出处 。
本文链接：https://blog.csdn.net/gongsai20141004277/article/details/53063771
版权

声明：本程序只是笔者的第一次构造结果，存在非常多需要改进的地方，笔者会在github上持续重构，大家可以在下面地址中找到最新的重构代码。https://github.com/Ggmatch/The-principle-to-compile

体验算法优先分析法能达到的效果

算符优先分析法只考虑算符（广义为终结符）之间的优先关系，例如若有文法G为：
（1）E->E+E
（2）E->E*E
（3）E->i

对输入串i1+i2*i3的规约过程如表所示：

步骤栈 S当前输入符输入串剩余部分动作
(1)#i1+i2+i3#移进
(2)#i1+i2*i3#规约(3)
(3)#E+i2*i3#移进
(4)#E+i2*i3#移进
(5)#E+i2*i3#规约(3)
(6)#E+E*i3#移进
(7)#E+E*i3#移进
(8)#E+E*i3#规约(3)
(9)#E+E*E#规约(2)
(10)#E+E*E#规约(1)
(11)#E#接受

算符优先文法的定义

定义1：设有一文法G，如果G中没有形如A->…BC…的产生式，其中B和C为非终结符，则称G为算符文法也称OG文法。
定义2：设有一不含空产生式的算符文法G，如果对任意两个终结符对a,b之间至多只有优先级高于、低于和等于三种关系中的一种成立，则称G是一个算符优先文法。

算符优先关系表的构造

  • 首先定义两个集合FIRSTVT(B)和LASTVT(B)
    FIRSTVT(B)={b|B+=>b…或B+=>Cb…}，其中…表示V*中的符号串。
    LASTVT(B)={a|B+=>…a或B+=>…aC}
  • 计算每个终结符之间的优先关系
    对于A->…ab… A->…aBb… 则有a 优先级等于 b 成立。
    对于A->…aB… 对于每一个b属于FIRSTVT(B) 有a优先级低于b成立。
    对于A->…Bb… 对于每一个a属于LASTVT(B) 有a优先级高于b成立。
  • 构造优先关系矩阵
    利用每个终结符之间的优先关系即可构造出来。
构造FIRSTVT集和LASTVT集的算法

定义一个布尔数组F[m,n]（m为非终结符个数，n为终结符个数）和一个后进先出栈STACK。将所有的非终结符排序，用iA表示非终结符A的序号，再将所有的终结符排序，用iA表示非终结符A的序号，再将所有的终结符排序，用ja表示终结符a的序号。算法的目的是要使数组每一个元素最终取值满足：F[iA,ja]的值为真，当前仅当a属于FIRSTVT(A)。

构建FIRSTVT集的伪代码（LASTVT集类似）如下：

PROCEDURE INSERT(A,a);
    IF NOT F[iA,ja]  THEN
        BEGIN
            F[iA,ja] := TRUE
            PUSH[A,a] ONTO STACK
        END
/*主程序*/
BEGIN (MAIN)
    FOR i从1到m,j从1到n
        DO F[iA，ja] := FALSE;
        FOR 每个形如 A->a... 或 A->Ba...的产生式
            DO INSERT(A,a)
        WHILE STACK非空 DO
            BEGIN 
                把STACK的顶项记为(B,a)弹出去
                FOR 每个形如 A->B...的产生式弹出去
                    INSERT(A,a)
            END
    END (MAIN)
构造优先关系表的算法
FPR 每个产生式 A->X1X2...Xn  DO
    FOR i := 1 TO n-1  DO
        BEGIN 
            IF Xi和X(i+1)均为终结符
            THEN 置 Xi优先级等于X(i+1);
            IF i<=n-2 且Xi和X(i+2)都为终结符，但X(i+1)为非终结符
            THEN 置 Xi优先级等于X(i+2);
            IF Xi为终结符而X(i+1)为非终结符
            THEN FOR FIRSTVT(X(i+1))中的每个b DO 置 Xi优先级低于b;
            IF Xi为非终结符而X(i+1)为终结符
            THEN FOR LASTVT(Xi)中的每个a DO 置 a优先级高于X(i+1);
        END

优先函数f和g的构建

  • 对于每个终结符a属于VT（包括#号在内）令f(a) = g(a) = 1（也可以是其他整数）。

  • 对每一终结符对逐一比较
    如果a优先级高于b，而f(a)<=g(b)则令f(a)=g(b)+1。
    如果a优先级低于b，而f(a)>=g(b)则令g(b)=f(a)+1。
    如果a优先级等于b，而f(a)!=g(b)则令min{f(a),g(b)}=max{f(a),g(b)}。
    重复第二步直到过程收敛。

    算符优先分析算法

  • 最左素短语
    设有文法G[S]，其句型的素短语是一个短语，它至少包含一个终结符，并除自身外不包含其他素短语，最左边的素短语称最左素短语。形如NiaiN(i+1)a(i+1)…ajN(j+)满足：

    （1）a(i-1)优先级低于ai
    （2）ai/a(i+1)/…/aj优先级相同
    （3）aj优先级高于a(j+1)

  • 算法
k := 1;  //栈的深度
S[k] := '#';
REPEAT
    把下一个输入符号读进a中;
    IF S[k]属于VT THEN j:=k ELSE j:=k-1;
    WHILE S[j]优先级高于a DO
    BEGIN
        REPEAT
            Q:=S[j];
            IF S[j-1]属于VT THEN j:=j-1 ELSE j:=j-2
        UNTIL S[j]优先级低于Q;
        把S[j+1]...S[k]规约为某个N;
        k:=j+1;
        S[k]:=N;
    END OF WHILE;
    IF S[j]优先级低于a OR S[j]优先级等于a THEN
        BEGIN k:=k+1; S[k]:=a END
    ELSE ERROR; /*调用出错诊察程序*/
UNTIL a='#'

完整代码

#include <iostream>
#include <string>
#include <fstream>
#include <stack>
#include <algorithm>
#include <sstream>
using namespace std;


#define P_Amount 20
#define RMAX 20
#define CMAX 20
#define NT_AMOUNT 20
#define T_AMOUNT 20
//文法结构体
class G
{
public:
    string T;  //终结符的集合
    string NT;  //非终结符的集合
    string begin;  //文法开始符号
    string P[P_Amount];  //产生式的集合
    int P_Length;  //产生式的个数
    bool FIRSTVT[RMAX][CMAX];  //非终结符的FIRSTVT集合
    bool LASTVT[RMAX][CMAX];  //非终结符的FIRSTVT集合
    int PRIORITY_TABLE[NT_AMOUNT][NT_AMOUNT];  //优先表，表内元素只有4种类型的值，-1代表行<列，1代表行>列，0代表行=列，2代表出错
    int FR;  //记录F的有效行数
    int FC;  //记录F的有效列数
    int f[T_AMOUNT];  //符号栈内的优先级,f优先函数
    int g[T_AMOUNT];  //符号栈外的优先级，g优先函数
    G()
    {
        //初始化
        T = "";
        NT = "";
        begin = "";
        P_Length = 0;
        for (int i = 0; i < P_Amount; i++)
            P[i] = "";
        for (int i = 0; i < RMAX; i++)
        {
            for (int j = 0; j < CMAX; j++)
            {
                FIRSTVT[i][j] = false;
            }
        }
        for (int i = 0; i < RMAX; i++)
        {
            for (int j = 0; j < CMAX; j++)
            {
                LASTVT[i][j] = false;
            }
        }
        for (int i = 0; i < NT_AMOUNT; i++)
        {
            for (int j = 0; j < NT_AMOUNT; j++)
            {
                PRIORITY_TABLE[i][j] = 2;  //默认为出错状态
            }
        }
        //初始状态下f和g内的元素都置为1
        for (int i = 0; i < T_AMOUNT; i++)
        {
            f[i] = 1; 
            g[i] = 1;
        }
    }
    ~G()
    {

    }
};

class Temp
{
public:
    char NT;
    char T;
};

void findor(string &str, char c, int *pos,int cap,int &len)  //在str中寻找出所有|的位置,pos记录其位置,cap为位置数组的容量，len为pos的有效长度
{
    for (int i = 0; i < cap; i++)
    {
        //初始化
        pos[i] = 0;
    }
    int temp=0;
    for (int i = 0; i < str.length(); i++)
    {
        int j=str.find(c, temp);
        if (j == -1)
        {
            break;
        }
        pos[i] = j;
        len++;
        temp = j+1;
    }
}
//根据产生式得到终结符集合与非终结符集合
void getSyms(string *strs, int len, string &T,string &NT) //strs为产生式集合，len为产生式个数
{
    string strTemp="";  
    for (int i = 0; i < len; i++)
    {
        if (strTemp.find(strs[i][0]) != -1)  //若是找到已存在的符号，跳过
            continue;
        strTemp += strs[i][0];
    }
    NT = strTemp;
    for (int i = 0; i < len; i++)
    {
        for (int j = 3; j < strs[i].length(); j++)
        {
            if (strs[i][j] >= 'A' && strs[i][j] <= 'Z')  //非终结符
            {
                if (NT.find(strs[i][j]) != 0)  //该符号已存在,跳过
                    continue;
                NT += strs[i][j];
            }
            else  //终结符,可能是算符或i
            {
                if (T.find(strs[i][j]) != -1)  //该符号已存在，跳过
                    continue;
                T += strs[i][j];
            }
        }
    }
}

void zero(string *strs, int &len) //strs为输入的文法表达式，len为表达式的个数
{
    string StrTemp[P_Amount];
    int lens,count=0;  //count记录新生成表达式的个数,lens记录每个
    int pos[10];  
    for (int i = 0; i < len; i++)  //将所有产生式按|隔开，生成多个产生式，存储到StrTemp中
    {
        lens = 0;
        findor(strs[i], '|', pos, 10, lens);  //寻找这条表达式中所有“|”的位置，存放到pos中，10为其最大容量,lens为“|”个数

        for (int z = 0; z < lens+1; z++)  //将一个产生式按|隔开，生成多个产生式，存储到StrTemp中，(len+1)代表要生成的表达式个数
        {
            if (z == 0)
            {
                StrTemp[z + count] = strs[i].substr(0, 3) + strs[i].substr(3, (pos[z]-2 - 1));
                continue;
            }

            StrTemp[z + count] = strs[i].substr(0, 3) + strs[i].substr(pos[z - 1]+1, (pos[z] - pos[z - 1] - 1));

            if (z == lens)
            {
                StrTemp[count + lens] = strs[i].substr(0, 3) + strs[i].substr(pos[lens - 1]+1, (strs[i].length() - pos[lens - 1] - 1));
            }
        }

        count += lens + 1;
    }

    //把StrTemp赋给strs
    len = count;
    for (int i = 0; i < count; i++)
    {
        strs[i] = StrTemp[i];
    }
}
void test1(G &gm);  //声明
void first(G &grammer,string strs[],int len)  //grammer为需要构造的文法对象，strs为经过zero后的文法表达式，len为表达式的个数
{
    grammer.begin = strs[0][0];  //开始符号
    grammer.P_Length = len;  //产生式的个数
    for (int i = 0; i < len; i++)  //得到产生式
    {
        grammer.P[i] = strs[i];
    }
    getSyms(strs, len, grammer.T, grammer.NT);  //从产生式中得到非终结符集合与终结符集合

}

void test1(G &gm)  //检测函数,这里检查文法数据结构的正确性
{
    cout << endl << "检测：" << endl;
    cout << "文法的开始符号：" << gm.begin << endl;
    cout << "文法的非终结符集合：" << gm.NT << endl;
    cout << "文法的终结符集合：" << gm.T << endl;
    cout << "文法的产生式：" << endl;
    for (int i = 0; i < gm.P_Length; i++)
    {
        cout << gm.P[i] << endl;
    }
    cout << endl;
}

void insert(G &gm, stack<Temp> &stck, char A, char a)  //
{
    int iA = gm.NT.find(A);
    int ia = gm.T.find(a);
    Temp tmp;
    tmp.NT = A;
    tmp.T = a;

    if (!gm.FIRSTVT[iA][ia])
    {
        gm.FIRSTVT[iA][ia] = true;
        stck.push(tmp);
    }
}

void insert1(G &gm, stack<Temp> &stck, char A, char a)  //
{
    int iA = gm.NT.find(A);
    int ia = gm.T.find(a);
    Temp tmp;
    tmp.NT = A;
    tmp.T = a;

    if (!gm.LASTVT[iA][ia])
    {
        gm.LASTVT[iA][ia] = true;
        stck.push(tmp);
    }
}

void test2(G &gm);  //测试gm的FIRSTVT和LASTVT集合

void second(G &gm)  //gm为文法的四元组
{
    gm.FR = gm.NT.length();
    gm.FC = gm.T.length();
    stack<Temp> stck;  
    Temp tmpBa;

    //得到G的FIRSTVT集合
    for (int i = 0; i < gm.P_Length; i++)
    {
        if (gm.P[i].length() - 4 == 0)  //产生式右边只有一个符号
        {
            if (gm.P[i][3] < 'A' || gm.P[i][3]>'Z')  //这个符号是终结符
            {
                insert(gm, stck, gm.P[i][0], gm.P[i][3]);
            }
        }
        else if (gm.P[i][3] >= 'A' && gm.P[i][3] <= 'Z')  //右部的第一个符号为非终结符，那么加入右部的第二个符号
        {
            insert(gm, stck, gm.P[i][0], gm.P[i][4]);
        }
        else  //右部的第一个符号为终结符
        {
            insert(gm, stck, gm.P[i][0], gm.P[i][3]);
        }
    }

    while (!stck.empty())
    {
        tmpBa = stck.top();
        stck.pop();
        for (int i = 0; i < gm.P_Length; i++)
        {
            if (gm.P[i][0] != tmpBa.NT&&gm.P[i][3] == tmpBa.NT)  //找到形如A->B···的产生式，FIRSTVT(B)必然FIRSTVT(A)
            {
                insert(gm, stck, gm.P[i][0], tmpBa.T);
            }
        }
    }

    //得到G的LASTVT集合
    for (int i = 0; i < gm.P_Length; i++)
    {
        if (gm.P[i].length() - 4 == 0)  //产生式右边只有一个符号
        {
            if (gm.P[i][3] < 'A' || gm.P[i][3]>'Z')  //这个符号是终结符
            {
                insert1(gm, stck, gm.P[i][0], gm.P[i][3]);
            }
        }
        else if (gm.P[i][3] >= 'A' && gm.P[i][3] <= 'Z')  //右部的最后一个符号为非终结符，那么加入右部的倒数第二个符号
        {
            insert1(gm, stck, gm.P[i][0], gm.P[i][gm.P[i].length()-2]);
        }
        else  //右部的最后一个符号为终结符
        {
            insert1(gm, stck, gm.P[i][0], gm.P[i][gm.P[i].length()-1]);
        }
    }

    while (!stck.empty())
    {
        tmpBa = stck.top();
        stck.pop();
        for (int i = 0; i < gm.P_Length; i++)
        {
            if (gm.P[i][0] != tmpBa.NT&&gm.P[i][gm.P[i].length()-1] == tmpBa.NT)  //找到形如A->···B的产生式，LASTVT(B)必然LASTVT(A)
            {
                insert1(gm, stck, gm.P[i][0], tmpBa.T);
            }
        }
    }

}

void test2(G &gm)
{
    cout << "G的FIRSTVT集合：" << endl;
    cout << "\t";
    for (int i = 0; i < gm.T.length(); i++)
    {
        if (i == gm.T.length() - 1)
        {
            cout << gm.T[i] << endl;
            break;
        }
        cout << gm.T[i] << "\t";
    }

    for (int i = 0; i < gm.FR; i++)
    {
        cout << gm.NT[i] << "\t";
        for (int j = 0; j < gm.FC; j++)
        {
            if (j == gm.FC - 1)
            {
                cout << gm.FIRSTVT[i][j] << endl;
                break;
            }
            cout << gm.FIRSTVT[i][j] << "\t";
        }
    }

    cout << "G的LASTVT集合：" << endl;
    cout << "\t";
    for (int i = 0; i < gm.T.length(); i++)
    {
        if (i == gm.T.length() - 1)
        {
            cout << gm.T[i] << endl;
            break;
        }
        cout << gm.T[i] << "\t";
    }
    for (int i = 0; i < gm.FR; i++)
    {
        cout << gm.NT[i] << "\t";
        for (int j = 0; j < gm.FC; j++)
        {
            if (j == gm.FC - 1)
            {
                cout << gm.LASTVT[i][j] << endl;
                break;
            }
            cout << gm.LASTVT[i][j] << "\t";
        }
    }
    cout << endl;
}

void test3(G &gm);  //测试third函数

void third(G &gm)  //gm为文法的数据结构
{
    for (int i = 0; i < gm.P_Length; i++)
    {
        int lens = gm.P[i].length();
        for (int j = 3; j <= lens-2; j++)
        {
            if ((gm.P[i][j]<'A'||gm.P[i][j]>'Z')&&(gm.P[i][j + 1]<'A'||gm.P[i][j + 1]>'Z'))  //Xi和X(i+1)都为终结符
            {
                int temp = gm.T.find(gm.P[i][j]);
                int temp1 = gm.T.find(gm.P[i][j + 1]);
                gm.PRIORITY_TABLE[temp][temp1] = 0;  //置为同等优先级
            }
            if (j <= (lens - 3) && (gm.P[i][j]<'A' || gm.P[i][j]>'Z') && (gm.P[i][j + 2]<'A' || gm.P[i][j + 2]>'Z') && (gm.P[i][j + 1] >= 'A'&&gm.P[i][j + 1] <= 'Z'))  //Xi和X(i+2)为终结符，但X(i+1)为非终结符
            {
                int temp = gm.T.find(gm.P[i][j]);
                int temp1 = gm.T.find(gm.P[i][j + 2]);
                gm.PRIORITY_TABLE[temp][temp1] = 0;  //置为同等优先级
            }
            if ((gm.P[i][j]<'A' || gm.P[i][j]>'Z') && (gm.P[i][j + 1] >= 'A' && gm.P[i][j + 1] <= 'Z'))  //Xi为终结符而X(i+1)为非终结符
            {
                for (int z = 0; z < gm.T.length(); z++)
                {
                    if (gm.FIRSTVT[gm.NT.find(gm.P[i][j + 1])][z])
                    {
                        int temp = gm.T.find(gm.P[i][j]);
                        int temp1 = z;
                        gm.PRIORITY_TABLE[temp][temp1] = -1;  //置于列优先于行
                    }
                }
            }
            if ((gm.P[i][j+1]<'A' || gm.P[i][j+1]>'Z') && (gm.P[i][j] >= 'A' && gm.P[i][j] <= 'Z'))  //X(i+1)为终结符而Xi为非终结符
            {
                for (int z = 0; z < gm.T.length(); z++)
                {
                    if (gm.LASTVT[gm.NT.find(gm.P[i][j])][z])
                    {
                        int temp = z;
                        int temp1 = gm.T.find(gm.P[i][j+1]);
                        gm.PRIORITY_TABLE[temp][temp1] = 1;  //置于行优先于列
                    }
                }
            }
        }
    }
}

void test3(G &gm)
{
    cout << "G的优先分析表：" << endl;
    cout << "\t";
    for (int i = 0; i < gm.T.length(); i++)
    {
        if (i == gm.T.length() - 1)
        {
            cout << gm.T[i] << endl;
            break;
        }
        cout << gm.T[i] << "\t";
    }
    int lens = gm.T.length();
    for (int i = 0; i < lens; i++)
    {
        cout << gm.T[i] << "\t";
        for (int j = 0; j < lens; j++)
        {
            if (j == gm.T.length() - 1)
            {
                cout << gm.PRIORITY_TABLE[i][j] << endl;
                break;
            }
            cout << gm.PRIORITY_TABLE[i][j] << "\t";
        }
    }
}

void test4(G &gm);  //检测优先函数f和g

void four(G &gm)  //构造优先函数f和g
{
    bool isChanged = true;  //isChanged代表上一次迭代f和g函数有没有发生变化，有为true
    int lens = gm.T.length();
    while (isChanged)
    {
        isChanged = false;
        for (int i = 0; i < lens; i++)
        {
            for (int j = 0; j < lens; j++)
            {
                if (gm.PRIORITY_TABLE[i][j] == 2)
                    continue;
                if (gm.PRIORITY_TABLE[i][j] == 1 && (gm.f[i] <= gm.g[j]))
                {
                    gm.f[i] = gm.g[j] + 1;
                    isChanged = true;
                    continue;
                }
                if (gm.PRIORITY_TABLE[i][j] == -1 && (gm.f[i] >= gm.g[j]))
                {
                    gm.g[j] = gm.f[i] + 1;
                    isChanged = true;
                    continue;
                }
                if (gm.PRIORITY_TABLE[i][j] == 0 && (gm.f[i] != gm.g[j]))
                {
                    if (gm.f[i] > gm.g[j])
                    {
                        gm.g[j] = gm.f[i];
                    }
                    else
                    {
                        gm.f[i] = gm.g[j];
                    }
                    isChanged = true;
                    continue;
                }
            }
        }
    }
}

void test4(G &gm)  //检测four函数
{
    cout << "\t";
    for (int i = 0; i < gm.T.length(); i++)
    {
        if (i == gm.T.length() - 1)
        {
            cout << gm.T[i] << endl;
            break;
        }
        cout << gm.T[i] << "\t";
    }
    int lens = gm.T.length();
    cout << "f函数： ";
    for (int i = 0; i < lens; i++)
    {
        if (i == lens - 1)
        {
            cout << gm.f[i] << endl;
            break;
        }
        cout << gm.f[i] << "\t";
    }
    cout << "g函数： ";
    for (int i = 0; i < lens; i++)
    {
        if (i == lens - 1)
        {
            cout << gm.g[i] << endl;
            break;
        }
        cout << gm.g[i] << "\t";
    }
}

void test5(bool b);  //检测GuiYueQi是否识别出待规约串,b为true，则说明能识别

bool GuiYueQi(G &gm, string str)  //gm为文法的数据结构，str为待规约串,能识别为true，否则为false
{
    string strStck="";  //用string对象做符号栈，方便取值
    strStck.append("#");  //初始化
    int k = 0,num=0;
    int j;  //j表示最左素短语的开头位置
    string a="";  //读入单元
    string Q = "";  //作为待审查的最左素短语的开头符号
    while (a!="#")  //到了输入串的最后一个字符，跳出
    {
        a = str[num++];  //把下一个输入符号读进a中
        if (gm.T.find(strStck[k]) != gm.T.npos)  //如果栈顶的符号为终结符
        {
            j = k;
        }
        else
        {
            j = k - 1;
        }
        while (gm.f[gm.T.find(strStck[j])] > gm.g[gm.T.find(a)])  //往下找，直到找到栈内符号优先级小于或等于当前输入符号的优先级
        {
            do
            {
                Q = strStck[j];
                if (gm.T.find(strStck[j - 1]) != gm.T.npos)  //
                {
                    j = j - 1;
                }
                else
                {
                    j = j - 2;
                }
            } while (gm.f[gm.T.find(strStck[j])] >= gm.g[gm.T.find(Q)]);

            //把strStck[j+1]~strStck[k]规约为某个N
            strStck.erase(strStck.begin() + j + 1, strStck.begin() + k);  //把规约的符号退栈
            strStck.append("N");  //压入某个非终结符N
            k = j + 1;
            break;
        }

        if (gm.f[gm.T.find(strStck[j])] <= gm.g[gm.T.find(a)])  
        {
            k = k + 1;
            strStck.append(a);
        }
        else
        {
            return false;
        }
    }


    return true;  //
}

void test5(bool b)
{
    if (b)
    {
        cout << "acc!" << endl;
    }
    else
    {
        cout << "fail!" << endl;
    }
}

int main()
{
    G gm;
    string str[10];
    int len;  //输入的表达式个数
    int i = 0;
    //从文件读入文法
    ifstream ifile("wenfa.txt");  //打开wenfa.txt文件
    while (ifile)
    {
        ifile >> str[i++];  //读入文法
    }
    ifile.close();  //关闭文件
    len = i - 1;
    zero(str, len);  //依据‘|’，拆分表达式
    first(gm, str, len);  //得到文法数据结构
    //test1(gm);  //检查zero()、first()函数

    second(gm);  //得到每个非终结符的FIRSTVT和LASTVT集合
    //test2(gm);  //检测second函数

    third(gm);  //得到优先分析表
    //test3(gm);  //检测third函数

    four(gm);  //得到优先函数f和g
    //test4(gm);  //检测four函数

    string guiyuestr;  //规约串
    ifile.open("guiyuechuan.txt");  
    stringstream io;
    io <<ifile.rdbuf();
    io >> guiyuestr;
    cout << "待规约串为："<< guiyuestr <<endl;
    bool b = GuiYueQi(gm, guiyuestr);  //规约器，规约str
    test5(b);  //检测待规约串被规约器处理后的结果

    return 0;
}

上述代码中wenfa.txt与guiyuechuan.txt的内容如下，自己构建，并放在项目里c++文件所在处，要符合相对路径。
wenfa.txt:
S->#E#
E->E+T
E->T
T->T*F
T->F
F->P!F|P
P->(E)
P->i
guiyuechuan.txt:
i+i#

本文理论部分引用于 《编译原理（第二版）——张素琴——清华大学出版社》

程序猿一帆
关注
专栏目录
编译原理语法分析之算符优先分析程序
weixin_43700565的博客
07-05 5427
要求 （1）根据给定文法，先求出FirstVt和LastVt集合，构造算符优先关系表（要求算符优先关系表 输出到显示器或者输出到文件）； （2）根据算法和优先关系表分析给定表达式是否是该文法识别的正确的算术表达式（要求输出归约过程） （3）假如给定表达式文法为： G(E’): E’→#E# E→E+T | T T→T*F |F F→(E)|i (4) 分析的句子可为: (i+i)*i和i+i)*i 结果 注：需要从text文件导入文法 text文件格式： S->#E# E->E+T|
编译原理实验二——算符优先分析法设计与实现
08-29
- **分析程序**：使用算符优先分析法进行语法分析，可能涉及递归下降解析或使用栈操作。 - **表达式求值**：实现表达式的计算逻辑，例如，对于算术表达式，可能需要一个求值函数来处理运算符的优先级和结合性。 - **...
算符优先语法分析程序
07-07
实现算符优先分析算法，完成以下描述算术表达式的算符优先文法的算符优先分析过程。 G[E]:E→E+T∣E-T∣T T→T*F∣T/F∣F F→(E)∣i 说明：终结符号i为用户定义的简单变量,即标识符的定义。 要求： （1）构造该算符优先文法的优先关系矩阵或优先函数； （2）输入串应是词法分析的输出二元式序列，即某算术表达式“实验项目一”的输出结果。输出为输入串是否为该文法定义的算术表达式的判断结果。 （3）算符优先分析过程应能发现输入串出错。 （4）设计两个测试用例（尽可能完备），并给出测试结果。
算符优先分析程序&对着注释理解代码
qq_45893999的博客
05-29 3697
文章目录一 实验目的和要求二 实验内容三 实验过程3.1什么是算符文法？应满足什么条件3.2构造FIRSTVT3.3构造LASTVT3.3思路四 实验结果 一 实验目的和要求 1.理解自下而上分析算法的构造思想。 2.理解算符文法和算符优先文法的概念。 3.掌握 FIRSTVT 集、LASTVT 集和算符优先关系表的构造方法。 4.理解素短语和最左素短语的概念，并掌握其寻求方法。 5.理解算符优先分析算法，能够使用某种高级语言实现一个算符优先分析程序。 二 实验内容 编写一个算符优先分析程序，能实现以下功能
Java编译原理
成都信息工程 周旭(Java学生)
08-28 1564
简单算符优先文法分析程序（编译原理）
12-26
实现算符优先文法分析程序；完成对以下表达式文法的分析程序。 G[E]: E->E+T E->T T->T*F T->F F->(E) F->i
编译原理实验——利用算符优先分析方法设计一个计算器
09-23
（Python实现，注释详细）直接输入：3+4*5，一般的...(1)第一阶段，运用算符优先分析算法完成计算器中对算术表达式的语法分析； (2)第二阶段，设计属性文法，改造第一阶段的程序，完成算术表达式的计算和相关的输出。
编译原理---算浮优先算法.rar_算符优先语法分析器_编译原理_编译原理 语法分析_语法分析器
09-23
Global.h ----- 定义了一些全局变量及宏Parse.h ----- 语法分析器的主要算法Prece.h ----- 定义和实现了一些关于优先级的操作Stack.h ----- 定义和实现了一个栈及其操作编译的时候只要用TC2.0或者WinTC打开Main.c...
【南华大学编译原理】算符优先分析及源码（带源码）
05-13
它的任务是在实验一（词法分析器）的基础上，用算符优先法、递归下降分析法、LL(1)分析法或LR分析法之一，对赋值语句进行语法分析，使其能够判断语句是否正确。通过编制语法分析程序，实现语法分析，加深对自上而下...
基于算符优先分析方法的表达式语法分析器
02-15
了解用算符优先法对表达进行语法分析的方法，掌握自顶向下的预测语法分析程序的手工构造方法。 附加功能： 1. 循环输入表达式和输出结果 2. 输出表达式对应的后缀表达式
编译原理 赋值语句的语法分析程序 算符优先法（使用C++）
11-21
c++语言 编译原理 赋值语句的语法分析程序 算符优先法 有详细的出错提示
带出错处理的算符优先分析算法的程序实现
01-11
编译原理的课程设计，带出错处理的算符优先分析算法的程序实现，绝对正版...欢迎下载参考...
算符优先文法研究（C++程序+报告）
01-17
1、 文法使用产生式来定义； 2、 分别给出每一个非终结符的FIRSTVT和LASTVT集； 3、 画出算符优先关系表； 4、 判定给定的文法是否是算符优先文法； 5、 给定符号串判定是否是文法中的句子，分析过程用分析表格的方式打印出来。 带对话框界面
算符优先文法分析器的设计与实现(java gui 版)
07-05
1． 设计扫描程序，将任何一种整数运算表达式（无变量，操作数为正整数，允许加减乘除四种运算，允许使用括号和多层括号）识别为单词，并能发现单词的拼写错误 2． 设计自底向上分析程序，在栈上实现对单词token串的自底向上分析 3． 根据算符优先文法的分析步骤，展示分析栈、token串的状态变化、相关量的优先级比较(算符优先分析表)结果输出 、判断当前是否进行规约或移进操作、（若须规约）显示当前应规约的串 4． 展示语法树
计算器用算符优先实现
11-28
可以计算加减乘除，输入数据，可以计算结果.
编译原理本科课程 专题4 算符优先语法分析设计原理与实现
最新发布
2301_76616273的博客
02-04 863
本程序由C/C++编写，实现了：算符优先文法、最左素短语、算符优先矩阵、优先函程序等概念的定义及实例。 以专题 1 词法分析程序的输出为语法分析的输入，实现算符优先分析算法，完成以下描述算术表达式的算符优先文法的算符优先分析过程： G[E]: E→E+T∣E-T∣T T→T*F∣T/F∣F F→(E)∣i
编译原理：专题4算符优先语法分析设计原理与实现
Planck Chang' blog
11-05 838
编译原理：专题4算符优先语法分析设计原理与实现
C语言实现算符优先文法源代码（编译原理）
hry1999的博客
05-04 4999
下面教大家用C语言实现编译原理中的算符优先文法。求出FIRSTVT集和LASTVT集，并判断该文法是否是算符优先文法。 一、知识解析 1、定义 算符优先文法是一种自下而上的分析方法，其文法的特点是文法的产生式中不含两个相邻的非终结符。 2、性质 假定G是不含ε- 产生式的算符文法。对于任何一对终结符a、b，我们说： （1）a等于b 当且仅当文法G中含有形如P→ ···ab···或P→···aQb·...
编译原理《算符优先分析法设计与实现》
m0_75073812的博客
10-25 1238
头歌实验：算符优先分析法设计与实现
算符优先的语法分析器实现与编译原理
算符优先分析是一种自底向上的解析策略，它通过维护一个算符栈来决定如何组合符号来构建语法树。 在这个实现中，首先引入了必要的头文件，如`stack.h`、`stack1.h`、`iostream.h`、`string.h`和`iomanip.h`，这些...
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值