算术表达式的语法分析及语义分析程序设计 —— LR分析法、输出三元式（续）

最新推荐文章于 2022-05-02 23:56:57 发布
最新推荐文章于 2022-05-02 23:56:57 发布
阅读量5.4k 收藏 50
点赞数 5
分类专栏： 算法 文章标签： 文法分析 语法分析 编译原理 文法 计算器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SkullSky/article/details/52234481
版权 
#include<iostream>
#include<string>
#include<vector>
#include<cmath>
#define MAX 40
using namespace std;

typedef struct code{
    string data;
    int num;
}Code;
Code code[MAX];

struct Gene{//产生式
    string left;
    char* right;
};
vector<Gene> gene;

typedef struct action{
    char para;
    int val;
}Action;
Action action[][MAX]={
    {{'O',0},{'O',0},{'O',0},{'O',0},{'S',3},{'O',0}, {'O',0},{'O',0},{'O',0}},
    {{'O',0},{'O',0},{'O',0},{'O',0},{'O',0},{'O',0},{'O',0},{'O',0},{'A', 0}},
    {{'O',0},{'O',0},{'O',0},{'O',0},{'O',0},{'O',0},{'O',0},{'S', 4},{'O',0}},
    {{'O',0},{'O',0},{'O',0},{'O',0},{'O',0},{'O',0},{'O',0},{'R', 10},{'O',0}},
    {{'O',0},{'O',0},{'O',0},{'O',0},{'S',8},{'S',9},{'O',0},{'O',0},{'O',0}},
    {{'S',10},{'S',11},{'O',0},{'O',0},{'O',0},{'O',0},{'O',0},{'O',0},{'R',1}},
    {{'R', 4},{'R', 4},{'S', 12},{'S', 13},{'O',0},{'O',0},{'R',4},{'O',0},{'R', 4}},
    {{'R', 7},{'R', 7},{'R', 7},{'R', 7},{'O',0},{'O',0},{'R',7},{'O',0},{'R', 7}},
    {{'R', 8},{'R', 8},{'R', 8},{'R', 8},{'O',0},{'O',0},{'R',8},{'O',0},{'R', 8}},
    {{'O',0},{'O',0},{'O',0},{'O',0},{'S', 8},{'S', 9},{'O', 0},{'O',0},{'O',0}},
    {{'O',0},{'O',0},{'O',0},{'O',0},{'S', 8},{'S', 9},{'O', 0},{'O',0},{'O',0}},
    {{'O',0},{'O',0},{'O',0},{'O',0},{'S', 8},{'S', 9},{'O', 0},{'O',0},{'O',0}},
    {{'O',0},{'O',0},{'O',0},{'O',0},{'S', 8},{'S', 9},{'O', 0},{'O',0},{'O',0}},
    {{'O',0},{'O',0},{'O',0},{'O',0},{'S', 8},{'S', 9},{'O', 0},{'O',0},{'O',0}},
    {{'S',10},{'S',11},{'O',0},{'O',0},{'O',0},{'O',0},{'S',19},{'O',0},{'O',0}},
    {{'R',2},{'R',2},{'S',12},{'S',13},{'O',0},{'O',0},{'R',2},{'O', 0},{'R',2}},
    {{'R',3},{'R',3},{'S',12},{'S',13},{'O',0},{'O',0},{'R',3},{'O', 0},{'R',3}},
    {{'R',5},{'R',5},{'R',5},{'R',5},{'O',0},{'O',0},{'R',5},{'O', 0},{'R',5}},
    {{'R',6},{'R',6},{'R',6},{'R',6},{'O',0},{'O',0},{'R',6},{'O', 0},{'R',6}},
    {{'R',9},{'R',9},{'R',9},{'R',9},{'O',0},{'O',0},{'R',9},{'O', 0},{'R',9}},
};
//转移表goto
int Goto[MAX][MAX];
int num;//词法分析得到的单词个数
string str;//输入串
char *key[10]={"main","void","int","char","printf","scanf","else","if","return"};
char Word[20],ch;
string Vn="AETFV";//非终结符
int Seq;//三元式序号
string Equ[MAX][3];//存储三元式
int IsAlpha(char c)
{
    if(((c<='z')&&(c>='a'))||((c<='Z')&&(c>='A')))
        return 1;
    else 
        return 0;
}

int IsNumber(char c)
{
    if(c>='0'&&c<='9')
        return 1;
    else 
        return 0;
}

int IsKey(char *word)
{
    int m,i;
    for(i=0;i<9;i++)
    {
        if((m=strcmp(word,key[i]))==0)
        {
            if(i==0)
                return 2;
            return 1;
        }
    }
    return 0;
}

char* scanner(char *fp,int ii)
{
    char Word[20]={'\0'};
    char ch;
    int i,c,sign=9;
    ch=*fp;
    if(IsAlpha(ch))
    {
        Word[0]=ch;
        fp++;
        ch=*fp;
        i=1;
        while(IsNumber(ch)||IsAlpha(ch))
        {
            Word[i]=ch;
            i++;
            fp++;
            ch=*fp;
        }
        Word[i]='\0';
        c=IsKey(Word);
        if(c==0)
        {
            sign=4;
            printf("%s\t普通标识符\t%d\n",Word,sign);
        }
        else if(c==2)
            printf("%s\t主函数  \t%d\n",Word,sign);
        else
            printf("%s\t关键字  \t%d\n",Word,sign);
    }
    else 
        if(IsNumber(ch))
        {
            Word[0]=ch;
            fp++;
            ch=*fp;
            i=1;
            while(IsNumber(ch))
            {
                Word[i]=ch;
                i++;
                fp++;
                ch=*fp;
            }
            Word[i]='\0';
            sign=4;
            printf("%s\t无符号实数\t%d\n",Word,sign);
        }
        else
        {
            Word[0]=ch;
            switch(ch)
            {
            case '[':
            case '(':
            case '{':
                fp++;
                sign=5;
                printf("%s\t界符      \t%d\n",Word,sign); 
                break;
            case ',':
            case '"':
            case ';':
                fp++;
                printf("%s\t界符      \t%d\n",Word,sign); 
                break;
            case ']':
            case ')':
            case '}':
                fp++;
                sign=6;
                printf("%s\t界符      \t%d\n",Word,sign); 
                break;
            case '+':
                fp++;
                ch=*fp;
                if(ch=='=')
                {
                    Word[1]=ch;
                    fp++;
                    printf("%s\t运算符  \t%d\n",Word,sign);
                }
                else if(ch=='+')
                {
                    Word[1]=ch;
                    fp++;
                    printf("%s\t运算符  \t%d\n",Word,sign);
                }
                else
                {
                    sign=0;
                    printf("%s\t运算符  \t%d\n",Word,sign);
                }
                break;
            case '-':
                fp++;
                ch=*fp;
                if(ch=='=')
                {
                    Word[1]=ch;
                    fp++;
                    printf("%s\t运算符  \t%d\n",Word,sign);
                }
                else if(ch=='-')
                {
                    Word[1]=ch;
                    fp++;
                    printf("%s\t运算符  \t%d\n",Word,sign);
                }
                else
                {
                    sign=1;
                    printf("%s\t运算符  \t%d\n",Word,sign);
                }
                break;
            case '*':
                fp++;
                ch=*fp;
                if(ch=='=')
                {
                    Word[1]=ch;
                    fp++;
                    printf("%s\t运算符  \t%d\n",Word,sign);
                }
                else
                {
                    sign=2;
                    printf("%s\t运算符  \t%d\n",Word,sign);

                }
                break;
            case '/':
                fp++;
                ch=*fp;
                if(ch=='=')
                {
                    Word[1]=ch;
                    fp++;
                    printf("%s\t运算符  \t%d\n",Word,sign);
                }
                else
                {
                    sign=3;
                    printf("%s\t运算符  \t%d\n",Word,sign);

                }
                break;
            case '!':
            case '=':
                fp++;
                ch=*fp;
                if(ch=='=')
                {
                    Word[1]=ch;
                    fp++;
                    printf("%s\t运算符  \t%d\n",Word,sign);
                }
                else
                {
                    sign=7;
                    printf("%s\t运算符  \t%d\n",Word,sign);

                }
                break;
            case '<':
                fp++;
                ch=*fp;
                if(ch=='=')
                {
                    Word[1]=ch;
                    fp++;
                    printf("%s\t运算符  \t%d\n",Word,sign);
                }
                else if(ch=='<')
                {
                    Word[1]=ch;
                    fp++;
                    printf("%s\t运算符  \t%d\n",Word,sign);
                }
                else
                {
                    printf("%s\t运算符  \t%d\n",Word,sign);
                }
                break;
            case '>':
                fp++;
                ch=*fp;
                if(ch=='=')
                {
                    Word[1]=ch;
                    fp++;
                    printf("%s\t运算符  \t%d\n",Word,sign);
                }
                else if(ch=='>')
                {
                    Word[1]=ch;
                    fp++;
                    printf("%s\t运算符  \t%d\n",Word,sign);
                }
                else
                {
                    printf("%s\t运算符  \t%d\n",Word,sign);
                }
                break;
            case '%':
                fp++;
                ch=*fp;
                if(ch=='=')
                {
                    Word[1]=ch;
                    fp++;
                    printf("%s\t运算符  \t%d\n",Word,sign);
                }
                if(IsAlpha(ch))
                {
                    Word[1]=ch;
                    fp++;
                    printf("%s\t类型标识符\t%d\n",Word,sign);
                }
                else
                {
                    printf("%s\t取余运算符\t%d\n",Word,sign);
                }
                break;
            case '\\':
                fp++;
                ch=*fp;
                Word[1]=ch;
                fp++;
                printf("%s\t制表符  \t%d\n",Word,sign);
                break;
            default:
                printf("无法识别字符\n"); 
                break;
        }
    }
    code[ii].data=Word;
    code[ii].num=sign;
    return fp;
}

int Cifafenxi()
{
    int i=-1;//种别码
    printf("请输入表达式(以‘#’号结束):\n");
    cin>>str;   
    cout<<"词法分析：\n";
    char *fp=&str[0];                   
    do{
        i++;                
        if(*fp=='#')
            break;
        else if(*fp==' ')
        {}
        else
        {
            fp=scanner(fp,i);
        }
    }while(*fp!='#');
    return i;
}

void GetWenfa()
{
    Gene gen;
    gen.left='S';
    gen.right="A";
    gene.push_back (gen);           

    gen.left ='A';
    gen.right ="V=E";
    gene.push_back (gen);               

    gen.left ='E';
    gen.right ="E+T";
    gene.push_back (gen);
    gen.right ="E-T";
    gene.push_back (gen);
    gen.right ="T";
    gene.push_back (gen);

    gen.left ='T';
    gen.right ="T*F";
    gene.push_back (gen);
    gen.right ="T/F";
    gene.push_back (gen);
    gen.right ="F";
    gene.push_back (gen);   

    gen.left ='F';
    gen.right ="i";
    gene.push_back (gen);
    gen.right ="(E)";
    gene.push_back (gen);

    gen.left ='V';
    gen.right ="i";
    gene.push_back (gen);

}

void Init()
{
    Goto[13][1]=9; Goto[13][3]=18;
    Goto[12][1]=9; Goto[12][3]=17;
    Goto[11][1]=9; Goto[11][2]=16;Goto[11][3]=7;
    Goto[10][1]=9; Goto[10][2]=15; Goto[10][3]=7; 
    Goto[9][1]=14; Goto[9][2]=6; Goto[9][3]=7;
    Goto[4][1]=5; Goto[4][2]=6; Goto[4][3]=7;
    Goto[0][0]=1; Goto[0][4]=2;;    
}

void error()
{
    cout<<"ERROR!"<<endl;
    cout<<"\n动作不存在！"<<endl;
    exit(-1);
}

void Output(vector<string> str)
{
    int len=str.size();
    for(int i=0;i<len;i++)
        cout<<str[i];
    cout<<"        \t";
}

void Yufafenxi(int num)
{                     
    Init(); 
    GetWenfa();                 
    vector<int> state;//状态栈
    vector<string> ana;//分析栈
    vector<string> an;//输入栈
    state.push_back (0);
    ana.push_back ("#");
    int i,j;
    int k=0;
    do{                                         
        for(int a=0;a<state.size();a++)//输出状态栈
            cout<<state[a];
        cout<<"\t\t";
        Output(ana);//输出分析栈                                         
        for(a=k;a<=num;a++)//输出剩余输入栈
            cout<<code[a].data;
        cout<<"\t";
        i=state[state.size()-1];        
        j=code[k].num ; 
        if(j==9)
            error();
        cout<<"\t"<<action[i][j].para<<action[i][j].val<<"\t";  //输出动作         
        if(action[i][j].para=='O')
            error();
        else if(action[i][j].para=='S')//移进 
        {                                                                       
            cout<<"移进"<<"\n";
            state.push_back (action[i][j].val);    
            ana.push_back (code[k].data);      
            an.push_back (code[k].data);
            k++;                         
        }
        else if(action[i][j].para=='R')//规约
        {                                                               
            cout<<"规约"<<"\t";
            int len;
            int tem=action[i][j].val;
            len=strlen(gene[tem].right);            
            while(len!=0)//将分析栈中的待约项规约
            {
                state.pop_back ();                          
                ana.pop_back ();                    
                len--;
            }
            cout<<gene[action[i][j].val].left<<"->"<<gene[action[i][j].val].right<<endl;//输出规约所用的产生式
            if(action[i][j].val==1||action[i][j].val==2||action[i][j].val==3||action[i][j].val==5||action[i][j].val==6||action[i][j].val==9)//输出三元式
            {   
                int  t=an.size()-1;
                if(action[i][j].val!=9)
                {
                    Seq++;
                    Equ[Seq][0]=an[t-1];
                    Equ[Seq][1]=an[t-2];
                    Equ[Seq][2]=an[t];

                }
                an.pop_back ();
                an.pop_back ();
                an.pop_back ();
                char c=Seq+'1'-1;           
                string str="(";
                str=str+c;
                str=str+")";                    
                an.push_back (str);
            }
            ana.push_back (gene[action[i][j].val].left);    
            int a=state[state.size()-1];            
            string b=ana[ana.size()-1];         
            int dex=0;
            while(Vn[dex]!=b[0])
                dex++;                                      
            if(Goto[a][dex]==0)
                error();
            else
                state.push_back (Goto[a][dex]);         
        }
        else if(action[i][j].para=='A')
        {
            cout<<"\n分析成功！\n";
            break;
        }
    }while(1);
    int n=1;
    cout<<"\n三元式:\n";
    while(n<=Seq)
    {
        cout<<"\n"<<n<<"\t";    
        cout<<"("<<Equ[n][0]<<",\t"<<Equ[n][1]<<",\t"<<Equ[n][2]<<")"<<endl;
        n++;
    }
}
int main(void)
{  
    num=Cifafenxi();        
    cout<<"词法分析结束"<<"\n";
    system("pause");
    code[num+1].data="#";
    code[num+1].num =8;
    num++;
    int i;
    cout<<"语法分析:\n";
    cout<<"状态栈      "<<"\t"<<"分析栈"<<"\t\t"<<"剩余输入栈"<<"\t"<<"   动作   "<<"\t产生式"<<"\n"; 
    Yufafenxi(num);             
    cout<<"语法分析结束\n";
    return 0;
}
SkullSky
关注
专栏目录
【编译原理】实验四：Yacc 分析程序生成器
LJR的博客
01-08 2347
本次实验主要学习了yacc分析程序生成器的用法，yacc输入格式分为三部分，这与lex格式类似，第一部分是定义部分，第二部分是规则部分，第三部分是辅助函数。第一部分声明了头文件、宏以及一些全局变量或外部变量等；第二部分规定了一些记号和符号优先级等，同时以BNF的格式书写产生式（翻译方案）；
程序设计语言——编译原理 第六、七章总结
BuZhiDao_en的博客
06-13 853
程序设计语言——第六、七章总结
实现LR分析法
12-16
LR分析法的实现 一、实验目的 实现一个关于表达式的LR语法分析程序，识别用户输入的包含变量与整数的混合算术表达式（不包含减法与除法运算）。 二、实验主要内容 1、文法如下： 0) SE 1) EE+E 2) EE*E 3) E(E) 4) Ei 2、对应的LR分析表如下： 状态 ACTION GOTO + * ( ) i # E 0 　 　 S2 　 S3 　 1 1 S4 S5 　 　 　 acc 　 2 　 　 S2 　 S3 　 6 3 r4 r4 　 r4 　 r4 　 4 　 　 S2 　 S3 　 7 5 　 　 S2 　 S3 　 8 6 S4 S5 　 S9 　 　 　 7 r1 S5 　 r1 　 r1 　 8 r2 r2 　 r2 　 r2 　 9 r3 r3 　 r3 　 r3 　 3、编程运用上述LR分析表，识别从键盘输入的算术表达式。 4、对于语法错误，要指出错误具体信息。
lr(1)分析法 算数表达式 c语言,编译原理及技术期末考试复习试题整理
weixin_39881387的博客
05-20 235
2.1 考虑文法G[S],其产生式如下:S→(L)|a L→L，S|S(1)试指出此文法的终结符号、非终结符号。终结符号为：{(,),a,,,}非终结符号为：{S,L}开始符号为：S(2)给出下列各句子的分析树：① (a,a)②(a,(a,a))③ (a,((a,a),(a,a)))(3)构造下列各句子的一个最左推导：① (a,a)S (L) (L,S) (S,S) (a,S) (a,a)② (a...
算术表达式的语法分析及语义分析程序设计
04-11
毕业论文引言 随着计算机技术的发展与普及，计算机已经成为各行业最基本的工具之一，迅速进入千家万户。因此，掌握计算机应用的基本技能成为新世纪人才不可缺少的基本素质之一。为使计算机能正常工作, 除了构成计算机各个组成部分的物理设备外, 一般说来, 还必须要有指挥计算机“做什么”和“如何做”的“程序”。程序及其有关文档构成计算机软件, 其中用以书写计算机软件的语言称为计算机程序设计语言。 1 计算机程序设计语言简介 计算机程序设计语言是计算机可以识别的语言，用于描述解决问题的方法，供计算机阅读和执行，通常简称为编程语言，是一组用来定义计算机程序的语法规则。它是一种被标准化的交流技巧，用来向计算机发出指令。一种计算机语言让程序员能够准确地定义计算机所需要使用的数据,并精确地定义在不同情况下所应当采取的行动。使用程序设计语言往往使程序员能够比使用机器语言更准确地表达他们所想表达的目的。对那些从事计算机科学的人来说，懂得程序设计语言是十分重要的，因为所有的程序都需要程序设计语言才能完成，而计算机的工作是用程序来控制的，离开了程序，计算机将一事无成。 2 开发背景及意义 现有计算器不能计算表达式，这是一个缺陷，为此，开发了一个能直接计算表达式的计算器，这为计算提高了更大的方便，可以大幅度提高计算效率。 第二章 第三章 第一节 递归下降法的描述 3．1．1实现思想 它的主要原理是，对每个非终极符按其产生式结构构造相应语法分析子程序，其中终极符产生匹配命令，而非终极符则产生过程调用命令。因为文法递归相应子程序也递归，所以称这种方法为递归子程序下降法或递归下降法。其中子程序的结构与产生式结构几乎是一致的。文法中每个非终结符对应一个递归过程(子程序)，每个过程的功能是识别由该非终结符推出的串，当某非终结符的产生式有多个候选式时能够按LL(1)形式可唯一地确定选择某个候选式进行推导。 3．1．2算法的特点 递归下降法是语法分析中最易懂的一种方法。递归下降法要满足的条件：假设A的全部产生式为Aα1|α2|……|αn ，则必须满足如下条件才能保证可以唯一的选择合适的产生式 predict(Aαi)∩predict(Aαj)=Φ,当i≠j. 3．1．3构造递归下降语法分析程序 采用了递归子程序方法进行语法分析,对文法中的每个非终极符号按其产生式结构产生相应的语法分析子程序,完成相应的识别任务。其中终结符产生匹配命令，非终结符则产生调用命令。每次进入子程序之前都预先读入一个单词。因为使用了递归下降方法,所以程序结构和层次清晰明了,易于手工实现,且时空效率较高。实际的语法分析工作,从调用总程序的分析子程序开始，根据产生式进行递归调用各个分析子程序。 第二节
算术表达式的语法分析及语义分析程序设计 —— LR分析法、输出三元式
SkullSky的博客
08-17 1万+
通过设计、编制、调试一个算术表达式的语法及语义分析程序，加深对语法及语义分析原理的理解，并实现词法分析程序对单词序列的词法检查和分析。
编译原理 LR分析法 表达式
Yang_Xinye的博客
05-24 754
编译原理 LR分析法 表达式 在存储LR分析表时： 移进用1、2、3……来表示（例：S1用1表示） 规约用101、102、103……来表示（例：r1用101表示） 错误用-1表示 接收用-2表示 #include<stdio.h> #include<iostream> #include<string> #include<stack> using namespace std; string expression; stack<int> A; /
编译原理——第六、七章属性文法与语法制导翻译+语义分析和中间代码产生
xmi_hux的博客
06-10 1万+
语义分析及翻译属性文法与语法制导翻译      这两章主要介绍语义分析及翻译问题，都是编译过程的阶段。      语义分析是对经语法分析器处理过后的在结构上正确的源程序进行上下文有关性质的审查，是编译程序最实质的过程。语义描述和语义处理最常用的方法是属性文法与语法制导翻译方法，也是本章主要介绍内容。       属性文法是在上下文无关文法的基础上为每个文法符号（终结符或非终结符）配备若干个相关的“...
四元式生成中间代码C语言程序,编译原理--03 语法制导翻译和中间代码生成复习(清华大学出版社第3版)...
weixin_36225424的博客
05-18 1778
前言第7章 语法制导的语义计算语义分析是上下文有关的，目前较为常见的是用属性文法来描述程序语言语义，并采用语法制导翻译的方法完成对语法成分的翻译工作。属性文法属性 描述文法符号的类型、值等有关的一些信息，它可以被计算或传递。语义动作 指产生式相关联的指定操作条件谓词 指产生式关联的接受条件，或者根据该条件谓词决定做什么语义动作语义规则集 通常是产生式关联的一组语义规则，每个语义规则可以是一个语义动...
编译原理：语法分析（算术表达式的扩充）
weixin_41708020的博客
06-29 3419
实验二 语法分析（算术表达式的扩充） 一·、实验题目 算术表达式文法扩充如下： E→E+E| E-E|E*E |E/E| (E) | I 试根据该文法重新设计LR分析表，并修改语义加工程序，最后验证修改的结果。 二、实验过程 （1）代码设计 由于一开始没有用实验要求的文法设计的表（最主要是实验要求的文法有很多左递归的文法造成对于还没充分认识LR的我来说，存在很大的难度。所以查找一些假设LR构造的表已经设计出来的，看看LR语法分析的流程），所以等我了解了LR构造的流程以后，我就想设计一个更加符合要求的。
算术表达式的LR翻译器
06-28
编译原理课程设计报告，算术表达式的LR翻译器。 其中包括LR分析树和分析表的生成。 报告及C++源码。
编译原理实验（词法分析、LL1分析、LR1分析）
09-04
大三上学期的编译原理实验，自己用C#写的代码。有词法分析、LL1分析、LR1分析这三次实验。
LR1分析表生成程序 c++
07-01
LR1分析表生成程序 c++，注释完整。
JAVAC源码 LR分析法 源代码
04-16
JAVAC源码 LR分析法 以及一个JAVA的词法分析 ，肯定不会后悔的
四大LR分析表
一个平平无奇的人
05-02 2082
四大LR分析表 即 LR(1)文法范围最大，而 LR(0)文法范围最小。同时也说明了四种文法分析过程的强弱，即 LR(1)文法分析最强，而 LR(0)文法分析最弱。 四种文法分析过程基本有三大步：写出自动机（即 LR(0)或 LR(1)项集族，后面都称作自动机） -> 构造文法分析表-> 进行文法分析过程。其中后两步都是类似或者说几乎完全一样的，第一步中的自动机有两种: LR(0)自动机和 LR(1)自动机。LR(0) 和 SLR文法分析用的是 LR(0)自动机，LR(1)和 LALR文法分析
算术表达式解析（第三版）词法分析版
weixin_30611509的博客
02-10 375
　　以前写过两版算术表达式解析代码，但都是基于栈结构或者树模型的，并不是通用的算法。其实算术表达式解析是最基本的词法分析算法，直到我看了《自制编程语言》里面介绍的递归向下分析法，才明白这种问题的终极解决方案是使用词法分析和语法分析。。 //用于词法定界的头文件 token.h 1 #ifndef _TOKEN_H_VERSION_20140930 2 #define _TOKEN_H_V...
大连理工大学编译原理第6次上机——算术表达式的扩充
zmk980305的博客
12-11 2830
1. 实验目的 充分理解语义分析的方法及相关语义计算的执行时机。 掌握LR分析表的设计方法和语义加工程序的扩充。 2. 实验要求 参照算术表达式LR分析表的设计方法，设计扩充后的算术表达式LR分析表，并对原语义加工程序进行修改，加入新添加的内容。写一段程序，打印出计算结果E。 3. 实验内容 假设有以下文法： L->En E->E+T E->E-T E-&gt...
《编译原理》LR 分析法与构造 LR(1) 分析表的步骤 - 例题解析
热门推荐
肖朋伟
06-22 5万+
《编译原理》构造 LR(1) 分析表的步骤与例题解析
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值