PL/0编译器功能扩充

于 2022-11-29 20:08:23 发布
阅读量1.9k 收藏 35
点赞数 4
分类专栏： 编译原理 文章标签： c语言 编辑器 扩展现实 算法
原文链接：https://fyf2016.github.io/
版权

1 增加语句for(<语句>；<条件>；<语句>)

Step1: 在pl0.h中修改

    pl0.h中在enum symbol { } 符号枚举集中加入
    forsym, 并更改符号的个数 symnum

Step2: 增加保留字名字并增加对应的保留字符号

    名字: strcpy(&(word[6][0]),"for");
    符号: wsym[6]=forsym;
    (注: 顺序按26个字母的顺序重新排列)

Step3: 增加语句开始符号集

    statbegsys[forsym]=true;

Step4: 语句处理函数内添加关于for语句的处理

//int i , cx1 , cx2 , cx3 , cx4 , cx5; (cx3,cx4,cx5为新增加的地址)
if(sym == forsym)
{
    getsymdo;
    if(sym != lparen)  error(34);//没有左括号出错
    else 
    {
        getsymdo;
        statementdo(nxtlev, ptx, lev);  //S1代码
        //语句缺少分号出错
        if(sym != semicolon)  error(10);                 
        else
        {
            /*cx是当前指令的地址 保存判断条件操作的    位置 */
            cx1=cx;
            getsymdo;
            conditiondo(nxtlev, ptx, lev);   //E代码
            if(sym != semicolon)  error(10);                              
            else 
            {   
                cx2=cx;
                gendo(jpc,0,0);
                cx3=cx;
                gendo(jmp,0,0);
                getsymdo;
                cx4=cx;
                //S2代码
                statementdo(nxtlev, ptx, lev);    
                if(sym != rparen)  error(22);  //缺少右括号出错
                else 
                {
                    gendo(jmp,0,cx1); // 回头重新判断条件 
                    getsymdo;
                    cx5=cx;
                    statementdo(nxtlev, ptx, lev);  //S3代码
                    code[cx3].a=cx5;
                    gendo(jmp,0,cx4); 
                    code[cx2].a=cx;  // 反填跳出循环的地址，与if类似
                }
            }
        }
    }
}

2 扩充语句if <条件> then <语句> else <语句>

Step1: 在pl0.h中修改

    pl0.h中在enum symbol { } 符号枚举集中加入
    elsesym, 并更改符号的个数 symnum

Step2: 增加保留字名字并增加对应的保留字符号

    名字: strcpy(&(word[4][0]),"else");
    符号: wsym[4]=elsesym;
    (注: 顺序按26个字母的顺序重新排列)

Step3: 语句处理函数内添加关于if语句的处理

if(sym==ifsym) /*准备按照if语句处理*/
{
    getsymdo;
    memcpy(nxtlev,fsys,sizeof(bool)*symnum);
    nxtlev[thensym]=true;
    nxtlev[dosym]=true; /*后跟符号为then或do*/
    conditiondo(nxtlev,ptx,lev); /*调用条件处理（逻辑运算）函数*/
    if(sym==thensym)
    {
        getsymdo;
    }
    else
    {
        error(16); /*缺少then*/
    }
    cx1=cx; /*保存当前指令地址*/
    gendo(jpc,0,0); /*生成条件跳转指令，跳转地址暂写0*/
    statementdo(fsys,ptx,lev); /*处理then后的语句*/
    if(sym==semicolon)
    {
        getsymdo;
        if(sym==elsesym)    /*then语句后出现else*/
        {
            getsymdo;
            cx2=cx;
            /*cx为当前的指令地址，cx+1即为then语句执行后的else语句的位置，回填地址*/
            code[cx1].a=cx+1; 
            gendo(jmp,0,0);
            statementdo(fsys,ptx,lev);
            /*经statement处理后，cx为else后语句执行
            完的位置，它正是前面未定的跳转地址，回填地址*/
            code[cx2].a=cx; 
        }
        else
        {
            /*经statement处理后，cx为then后语句执行完的位置，它正是前面未定的跳转地址*/
            code[cx1].a=cx; 
        }
    }
    else
    {
        error(5);
    }
}

3 增加语句repeat <语句> until <条件>

Step1: 在pl0.h中修改

    pl0.h中在enum symbol { } 符号枚举集中加入
    repeatsym, untilsym, 并更改符号的个数 symnum

Step2: 增加保留字名字并增加对应的保留字符号

    名字: strcpy(&(word[11][0]),"repeat");
         strcpy(&(word[13][0]),"until");
    符号: wsym[11]=repeatsym;
         wsym[13]=untilsym;
    (注: 顺序按26个字母的顺序重新排列)

Step3: 增加语句开始符号集

    statbegsys[repeatsym]=true;

Step4: 语句处理函数内添加关于repeat语句的处理

else if(sym==repeatsym)
{
    cx1=cx; /*保存当前指令地址*/
    getsymdo;
    memcpy(nxtlev,fsys,sizeof(bool)*symnum);
    nxtlev[untilsym]=true;
    statementdo(fsys,ptx,lev);
    if(sym==semicolon)
    {
        getsymdo;
        if(sym==untilsym)
        {
            getsymdo;
            conditiondo(fsys,ptx,lev);
            /*经condition处理后，cx1为repeat后循环语句的位置，条件为假时一直循环*/
            gendo(jpc,0,cx1); 
        }
    }
    else
    {
        error(5);
    }
}

4. 增加自增自减运算

对于++和–的扩充,分为两种情况:

    作为语句的情况
    例如: ++i,--i,i++,i--;
    作为表达式的因子的情况
    例如:  b:=a++;b:=a--;
           b:=++a;b:=--a;

第一种作为语句情况的扩充:
Step1: 在pl0.h中修改

    pl0.h中在enum symbol { } 符号枚举集中加入
    addadd, subsub, 并更改符号的个数 symnum

Step2: 语句处理函数内添加关于++ 和–的处理

else if(sym==addadd) /*检测到后置++符号*/
 {
     getsymdo; 
     // 如果++后面跟的量可以在名字表中找到 
     if(i!=0)
     {
         gendo(lod,lev-table[i].level,table[i].adr);
         gendo(lit,0,1);
         gendo(opr,0,2);
         gendo(sto,lev-table[i].level,table[i].adr);
     }
 }
 else if(sym==subsub) /*检测到后置--符号*/
 {
     getsymdo;
     // 如果 -- 后面跟的量可以在名字表中找到 
     if(i!=0)
     {
         gendo(lod,lev-table[i].level,table[i].adr);
         gendo(lit,0,1);
         gendo(opr,0,3);
         gendo(sto,lev-table[i].level,table[i].adr);
     }
 }

 if(sym==addadd) /*检测到前置++符号*/
 {
     getsymdo;
     if(sym==ident) /*后面跟的是变量*/
     {
         i=position(id,*ptx);
         if(i==0)
         {
             error(11);
         }
         else
         {
             if(table[i].kind!=variable)
             {         
                 /*++后没跟变量，出错*/
                 error(12);
                 i=0;
             }
             else
             {     
                 /*++后跟变量，处理生成中间代码*/
                 getsymdo;
                 /*先取    值到栈顶*/
                 gendo(lod,lev-table[i].level,table[i].adr);
                 gendo(lit,0,1);  /*将1放到栈顶*/
                 gendo(opr,0,2); /*加法，即+1，栈顶加次栈顶*/
                 /*出栈取值到内存*/
                 gendo(sto,lev-table[i].level,table[i].adr);
             }
         }
     }
 }

 else if(sym==subsub) /*检测到前置--符号*/
 {
     getsymdo;
     if(sym==ident) /*后面跟的是变量*/
     {
         i=position(id,*ptx);
         if(i==0)
         {
             error(11);
         }
         else
         {
             /*--后没跟变量，出错*/
             if(table[i].kind!=variable) 
             {
             error(12);
             i=0;
             }
             else /*--后跟变量，处理生成中间代码*/
             {
                 if(table[i].kind==variable) /*后跟变量*/
                 {
                     getsymdo;
                     /*先取值到栈顶*/
                     gendo(lod,lev-table[i].level,table[i].adr);
                     gendo(lit,0,1); /*将1放到栈顶*/
                     gendo(opr,0,3); /*减法，即-1，栈顶减次栈顶*/
                     /*出栈取值到内存*/
                     gendo(sto,lev-table[i].level,table[i].adr);
                 }
             }
         }
     }
 }

第二种作为语句情况的扩充:

Step1: 添加因子开始符号集

   facbegsys[addadd]=true; /*前置++*/
   facbegsys[subsub]=true; /*前置--*/

Step2: 在因子处理函数factor中添加 ++和–相关处理

if(sym==addadd) /*因子出2现b:=a++类型*/
{
    gendo(lit,lev-table[i].level,1); /*将值入栈*/
    /*加法，即+1，栈顶加次栈顶*/
    gendo(opr,lev-table[i].level,2);         
    /*出栈取值到内存*/                                                    
    gendo(sto,lev-table[i].level,table[i].adr); 
    /*取值到栈顶*/

    gendo(lod,lev-table[i].level,table[i].adr); 
    gendo(lit,0,1);
    gendo(opr,0,3); /*栈顶值减*/
    getsymdo;
}
else if(sym==subsub) /*因子出现b:=a--类型*/
{
    gendo(lit,lev-table[i].level,1); /*将值入栈*/
    /*减法，即-1，栈顶减次栈顶*/
    gendo(opr,lev-table[i].level,3); 
    /*出栈取值到内存*/    
    gendo(sto,lev-table[i].level,table[i].adr);                         
    gendo(lod,lev-table[i].level,table[i].adr);
    gendo(lit,0,1);
    gendo(opr,0,2); /*栈顶值加*/
    getsymdo;
}
else if(sym==addadd) /*因子出现b:=++a类型*/
{
    getsymdo;
    if(sym==ident)
    {
        getsymdo;
        i=position(id,*ptx);
        if(i==0)
        {
            error(11);
        }
        else
        {
            if(table[i].kind==variable) /*变量*/
            {     
                /*先加后再用a*/
                /*先取值到栈顶*/
                gendo(lod,lev-table[i].level,table[i].adr);
                gendo(lit,0,1);/*将值入栈*/
                gendo(opr,0,2);/*加法，即+1，栈顶加次栈顶*/
                /*出栈取值到内存*/
                gendo(sto,lev-table[i].level,table[i].adr);
                /*取值到栈顶*/
                gendo(lod,lev-table[i].level,table[i].adr);
            }
        }
    }
}
else if(sym==subsub) /*因子出现b:=--a类型*/
{
    getsymdo;
    if(sym==ident)
    {
        getsymdo;
        i=position(id,*ptx);
        if(i==0)
        {
            error(11);
        }
        else
        {
            if(table[i].kind==variable) /*变量*/
            { 
                /*先减后再用a*/
                /*先取值到栈顶*/
                gendo(lod,lev-table[i].level,table[i].adr);
                gendo(lit,0,1); /*将值入栈*/
                gendo(opr,0,3); /*减法，即-1，栈顶减次栈顶*/
                /*出栈取值到内存*/
                gendo(sto,lev-table[i].level,table[i].adr);
                /*取值到栈顶*/
                gendo(lod,lev-table[i].level,table[i].adr); 
            }
        }
    }
}

5. 增加+=，-=，*=，/=运算

Step1: 在pl0.h中修改

    pl0.h中在enum symbol { } 符号枚举集中加入
    addequal,subequal, timeseql, slasheql,, 并更
    改符号的个数 symnum

Step2: 在getSym()函数中处理:

if(ch=='+')
{
    getchdo;
    if(ch=='=')
    {
        sym=addequal;
        getchdo;
    }
    else{
        sym=plus;
    }
}
else
{
    if(ch=='-')
    {
        getchdo;
        if(ch=='=')
        {
            sym=subequal;
            getchdo;
        }else{
            sym=minus;
        }
    }
    else 
    {
        if(ch=='*')
        {
            getchdo;
            if(ch=='=')
            {
                sym=timeseql;
                getchdo;
            }
            else
            {
                sym=times;
            }
        } 
        else
        {
            if(ch=='/')
            {
                getchdo;
                if(ch=='=')
                {
                    sym=slasheql;
                    getchdo;
                }
                getchdo;
            } else{
                sym=slash;
            }
        }else{
            /*当符号不满足上述条件时，全部按照单字符号处理*/
            sym=ssym[ch]; 
            if(sym!=period)
            {
                getchdo;
            }
        }
    }
}

Step3: 在语句处理函数中添加处理

else if(sym==addequal) /*检测到+=符号*/
{
    getsymdo;
    /*找到变量地址并将其值入栈*/
    gendo(lod,lev-table[i].level,table[i].adr); 
    if(sym==semicolon)
    {
        getsymdo;
        printf("+=后面直接跟了分号");
    }
    memcpy(nxtlev,fsys,sizeof(bool)* symnum);
    expressiondo(nxtlev,ptx,lev);
    gendo(opr,0,2);
    if(i!=0)
    {
        gendo(sto,lev-table[i].level,table[i].adr);
    }
}
else if(sym==subequal) /*检测到-=符号*/
{
    getsymdo;
    /*找到变量地址并将其值入栈*/
    gendo(lod,lev-table[i].level,table[i].adr);                          
    if(sym==semicolon)
    { 
        getsymdo;
    }
    memcpy(nxtlev,fsys,sizeof(bool)* symnum);
    expressiondo(nxtlev,ptx,lev);
    gendo(opr,0,3);
    if(i!=0)
    {
        gendo(sto,lev-table[i].level,table[i].adr);
    }
}
else if(sym==timeseql) /*检测到*=符号*/
{
    getsymdo;
    /*找到变量地址并将其值入栈*/
    gendo(lod,lev-table[i].level,table[i].adr);                        
    if(sym==semicolon)
    {
        getsymdo;
    }
    memcpy(nxtlev,fsys,sizeof(bool)* symnum);
    expressiondo(nxtlev,ptx,lev);
    gendo(opr,0,4);
    if(i!=0)
    { 
        gendo(sto,lev-table[i].level,table[i].adr);
    }
}
else if(sym==slasheql) /*检测到/=符号*/
{
    getsymdo;
     /*找到变量地址并将其值入栈*/
    gendo(lod,lev-table[i].level,table[i].adr);
    if(sym==semicolon)
    {
        getsymdo;
    }
    memcpy(nxtlev,fsys,sizeof(bool)* symnum);
    expressiondo(nxtlev,ptx,lev);
    gendo(opr,0,5);
    if(i!=0)
    {
        gendo(sto,lev-table[i].level,table[i].adr);
    }
}
X蟹黄灌汤包
关注
  • 4
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
[编译原理]PL/0 编译器的设计与实现
RegulusF的博客
04-21 1万+
一.程序基本任务及结构 其编译过程采用一趟扫描方式 以语法、语义分析程序为核心 词法分析程序和代码生成程序都作为一个过程，当语法分析需要读单词时就调用词法分析程序，而当语法、语义分析正确，需要生成相应的目标代码时，则调用代码生成程序。 表格管理程序实现变量，常量和过程标识符的信息的登录与查找。 出错处理程序，对词法和语法、语义分析遇到的错误给出在源程序中出错的位置和与错误 性质有关的编号，并进行错...
pl0编译器的扩充与改进
12-09
pl0编译器，扩展了++、--、+=、-+、一维数组等不少功能
Pl0编译器扩充
qq_41979507的博客
01-12 2311
PL0编译器扩充（注释 else 数组） 注释的扩充 注释的扩充写在getch中，就是词法分析，在getch中每次会读取一行放入数组line中然后进行读取，那么注释的基本思想就是遇到注释就不放入line中，直接跳过就好。 int getch() { if (cc == ll) /* getch使用的计数器，cc表示当前字符(ch)的位置 */ { /* feof()只用于测试流文件的结束，...
编译原理三级项目pl0扩展
04-05
扩展了一些功能，++，--，*=，/=，取反，取余，一维数组，for循环，while循环，write包含换行，可以输出文本等功能，里面有具体的测试例子
编译原理 编译源程序 2C版本
wlj_czy的博客
11-11 833
pl0.h #ifndef PL0_H_INCLUDED #define PL0_H_INCLUDED #endif // PL0_H_INCLUDED /* * PL/0 complier program for win32 platform (implemented in C) * * The program has been test on Visual C++ 6.0, ...
PL/0编译程序的研究与改进
weixin_51187996的博客
11-11 2796
在本次改进中，通过对PL/0程序的头文件，源文件的更新以及定义新的头文件，小组共实现15个功能，包括一维数组，++，--，+=，-=，*=，/=，%（取余），！（取反），repeat，for（to，downto），else，处理注释，错误提示，标识符或变量中可以有下划线。添加了12个保留字，添加了两条opr指令。在原有的语法基础上，更新了EBNF。错误处理上，新增了对数组，repeat语句等的错误处理。
PL/0语言编译器
wzzzj的博客
10-06 1386
本实验可以分成两部分： 1，PL/0语言的编译器—compiler 2.中间代码的解析器----interpreter #include<iostream> #include<cstring> #include<string> #include<vector> #include<stack> #include<fstream> using namespace std; const string KeyWordlist[]={"","CO
基于PL/0语言的扩充——if-then-else,do-while-until,for
06-21
在这个基于PL/0语言的扩充项目中，我们主要关注了三个重要的控制结构：if-then-else，do-while-until，以及for循环。这些结构是高级编程语言中不可或缺的部分，它们提供了条件执行和迭代的能力。 首先，让我们深入...
PL/0编译器--编译原理课程设计
10-27
- 测试用例：用于验证编译器功能的PL/0程序样本。 - 工程配置文件：包含了编译和运行编译器所需的环境设置。 - 文档：可能包括项目说明、编译器设计文档、使用指南等。 通过这个项目，学生不仅可以了解编译器的整体...
pl/0 编译器
12-20
**PL/0 编译器实现详解** PL/0是一种简化的编程语言，主要用于教学目的，它是Pascal语言的一个简化版本。实现一个PL/0编译器需要理解编译器的基本构造块，包括词法分析、语法分析、语义分析以及代码生成。以下是...
编译原理课设和实验：PL0编译器扩充
09-25
课设要求： （1）扩充赋值运算：+= 和 -= （2）扩充语句（Pascal的FOR语句）: FOR <变量>:=<表达式> STEP <表达式>UNTIL <表达式> DO <语句> （3）增加运算：++ 和 --。 实验要求： 对PL/0作以下修改扩充： （1）增加单词：保留字 ELSE，FOR，STEP，UNTIL，RETURN 运算符 +=，-=，++，--，&&，||，！ （2）修改单词：不等号# 改为 <> （3）增加条件语句的ELSE子句，要求：写出相关文法，语法图，语义规则。 含源代码，注释，可执行文件，完美实验报告和完美课设报告
编译原理课程设计PL0扩充
02-19
2． 课程设计 基本内容（成绩范围：“中”、“及格”或“不及格”） （1）扩充赋值运算：+= 和 -= （2）扩充语句 REPEAT DOWHILE 其中，是循环条件，即条件成立时，重复执行循环体的 选做内容（成绩评定范围扩大到：“优”和“良”） （1）增加运算：++ 和 --。 （2）增加类型：① 字符类型； ② 实数类型。 （3）扩充函数：① 有返回值和返回语句；② 有参数函数。 （4）增加一维数组类型（可增加指令）。 （5）其他典型语言设施。 3． 要求和说明 （1）放假前完成，提交课程设计报告和光盘 （各班统一制作一张光盘，每人的目录名：xxx姓名，xxx是学号末3位）。 （2）在程序运行界面突出显示： 设计者的班级、学号和姓名； 开始调试时间； 完成调试时间。 （3）实验报告内容 1）完成的实验内容及说明 2）概述: 源、目标语言，实现工具(平台)，运行平台 3）结构设计说明 各功能模块描述 4）主要成分描述 ① 符号表 ② 运行时存储组织和管理 ③ 语法分析方法 ④ 中间代码表示 5）测试用例 6）开发过程和完成情况 （4）光盘内含： ① 扩充后的PLO编译程序的源程序文件和可执行程序文件； ② 测试用例的PL0语言源程序和编译运行结果； ③ 课程设计报告文档（令需交打印文档一份）。 （5）成绩分五档：优，良，中，及格和不及格。 根据完成的程序和报告的质量评定成绩。 只完成基本内容者，成绩至高为“中”。 鼓励完成选做内容，可获得加分：“良”，直到“优”。 如果有下列情况，则视情节严重程度，成绩下降若干档次，直至不及格： • 光盘文件含有病毒或者内容不能正确读出； • 抄袭、复制别人程序或文档； • 未能按时提交报告和光盘文件。
PL0(包括对其的扩充)
01-05
　　（1）扩充赋值运算：*= 和 /= 　　（2）扩充语句（Pascal的FOR语句）: 　　　①FOR := TO DO 　　　②FOR := DOWNTO DO 其中，语句①的循环变量的步长为2， 　　　语句②的循环变量的步长为-2。 　　　（3）增加运算：++ 和 --。 　　　选做内容： （1）增加类型：① 字符类型； ② 实数类型。 （2）扩充函数：① 有返回值和返回语句；② 有参数函数。 （3）增加一维数组类型（可增加指令）。 （4）其他典型语言设施。
pl/0编译器源码及文档
09-18
用C语言写的pl/0编译器，其中包含很多设计资料，对于编译原理的理解很有帮助，希望对大家有帮助。
PL0编译器源程序分析
03-16
PL/0语言是Pascal语言的一个子集，我们这里分析的PL/0的编译程序包括了对PL/0语言源程序进行分析处理、编译生成类PCODE代码，并在虚拟机上解释运行生成的类PCODE代码的功能。
对PL0语言及其编译器进行扩充和修改
05-13
本项目针对“PL0语言及其编译器进行扩充和修改”这一主题，旨在深入理解和实践编译原理，同时也为Pascal语言的爱好者提供了一个学习和研究的基础平台。 PL0语言是Pascal语言的一个简化版本，它主要包含了基本的语法...
Compilers_2getsym
Coding呆呆的博客
12-12 363
首次调用 首次调用 getsym() 进行词法分析。 进行词法分析 调用 block() 过程 ，block() 中包括了词法分析和语法分析等 最后调用interpret() 解释执行目标程序
pl0运行栈中间代码类P-code解析
weixin_42815846的博客
06-23 3196
目录PL/0源程序分析中间代码及注释 PL/0源程序 var n,i,apple; procedure fordiy; const a=7; var b,c; begin while i>0 do begin apple:=(apple+1)*2; i:=i-1; end; end; begin read(n); i:=n; apple:=1; call fordiy; write(apple);
编译原理PL0语法分析实验1
qq_44709970的博客
12-15 2336
语法分析程序与词法分析程序共同点 语法分析程序又叫下推自动机，词法分析程序又叫有穷自动机。 1，待分析的简单语言的词法 相同点：都是分析种别码 不同点：词法分析器分析的是字符串中的单词的种别码（单词） 语法分析器分析的是字符串的文法是否正确（句子） 待分析的简单语言的语法 BNF：（1）<程序>::=begin<语句串>end （2）<语句串>::=<语句>{;<语句>} ...
PL/0 编译器功能的扩展增加“字符串”语法单位仿C++的输出格式
最新发布
06-07
好的，让我来回答你的问题。 首先，PL/0 编译器是一个简单的编译器，它的语法不包括字符串类型。要扩展 PL/0 编译器的功能，使其支持字符串类型，我们需要对其语法进行修改。 其次，为了实现类似 C++ 的输出格式，我们需要添加一个新的语法单位，例如 `print` 语句。 `print` 语句接受一个字符串参数，并将其输出到控制台。 下面是一个示例 PL/0 程序，其中包含了字符串类型和 `print` 语句的使用： ``` var str: string; begin str := "Hello, world!"; print(str); end. ``` 在这个示例程序中，我们定义了一个字符串变量 `str`，并将其初始化为 `"Hello, world!"`。然后，我们使用 `print` 语句输出了这个字符串。 当程序执行时，它将输出以下内容： ``` Hello, world! ``` 希望这个回答能够解决你的问题。如果你还有其他问题，请随时提出。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值