BITMINICC——lab6+lab7

最新推荐文章于 2022-06-28 15:49:15 发布
最新推荐文章于 2022-06-28 15:49:15 发布
阅读量4.3k 收藏 8
点赞数 12
分类专栏： 编译原理实验
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43877853/article/details/117349299
版权

在做lab6和lab7之前，先确保你已经有了一个结构完整的AST树。

如果你还没有生成AST，参考下面这篇文章

(5条消息) BITMINICC——利用Antlr的Listener生成AST_寒士°、的博客-CSDN博客

下面开始lab6和lab7具体的实验

这两个实验放在一起做，当做完lab7时，lab6就非常简单了，所以先说lab7

1.BITMINICC都给了什么？

ExampleCPrinter：打印你所生成的Quat

TemporaryValue：继承自ASTNode，用于生成临时的变量（例子中给的%1，%2之类的）

Quat：定义的四元式类，（op，res，opnd1，opnd2），op为String，其余为ASTNode（这也是TemporaryValue定义为ASTNode的原因。

所以，中间代码生成就是将你的AST树翻译为一个个的四元式，其中，中间变量由TemporaryValue来给出。

2.理解递归

递归大家都很熟悉，理解了ExampleICBuilder中的递归生成四元式，lab7就完成了大半了。

	@Override
	public void visit(ASTBinaryExpression binaryExpression) throws Exception {
		String op = binaryExpression.op.value;
		ASTNode res = null;
		ASTNode opnd1 = null;
		ASTNode opnd2 = null;
		
		if (op.equals("=")) {
			// 赋值操作
			// 获取被赋值的对象res
			visit(binaryExpression.expr1);
			res = map.get(binaryExpression.expr1);
			// 判断源操作数类型, 为了避免出现a = b + c; 生成两个四元式：tmp1 = b + c; a = tmp1;的情况。也可以用别的方法解决
			if (binaryExpression.expr2 instanceof ASTIdentifier) {
				opnd1 = binaryExpression.expr2;
			}else if(binaryExpression.expr2 instanceof ASTIntegerConstant) {
				opnd1 = binaryExpression.expr2;
			}else if(binaryExpression.expr2 instanceof ASTBinaryExpression) {
				ASTBinaryExpression value = (ASTBinaryExpression)binaryExpression.expr2;
				op = value.op.value;
				visit(value.expr1);
				opnd1 = map.get(value.expr1);
				visit(value.expr2);
				opnd2 = map.get(value.expr2);
			}else {
				// else ...
			}
			
		}else if (op.equals("+")) {
			// 加法操作，结果存储到中间变量
			res = new TemporaryValue(++tmpId);
			visit(binaryExpression.expr1);
			opnd1 = map.get(binaryExpression.expr1);
			visit(binaryExpression.expr2);
			opnd2 = map.get(binaryExpression.expr2);
		}else {
			// else..
		}
		
		// build quat
		Quat quat = new Quat(op, res, opnd1, opnd2);
		quats.add(quat);
		map.put(binaryExpression, res);
	}

对于一个二元表达式，如a=b+(c+5)而言，在你的AST树上是这样的

        "exprs" : [ {
          "type" : "BinaryExpression",
          "op" : {
            "type" : "Token",
            "value" : "=",
            "tokenId" : 6
          },
          "expr1" : {
            "type" : "Identifier",
            "value" : "a",
            "tokenId" : 5
          },
          "expr2" : {
            "type" : "BinaryExpression",
            "op" : {
              "type" : "Token",
              "value" : "+",
              "tokenId" : 8
            },
            "expr1" : {
              "type" : "Identifier",
              "value" : "b",
              "tokenId" : 7
            },
            "expr2" : {
              "type" : "BinaryExpression",
              "op" : {
                "type" : "Token",
                "value" : "+",
                "tokenId" : 11
              },
              "expr1" : {
                "type" : "Identifier",
                "value" : "c",
                "tokenId" : 10
              },
              "expr2" : {
                "type" : "IntegerConstant",
                "value" : 5,
                "tokenId" : 12
              }
            }
          }
        } ]

即a=%1，%1=b+%2，%2=c+5

这其实就是我们要生成的四元式，不过为了避免出现多个四元式，所以特殊处理了一下而已。

再比如，res=~a

它再AST树上就是，一个ASTBinaryExpression，expr1=identifier（res），expr2=UnaryExpression。

所以你只需要添加

else if(astBinaryExpression.expr2 instanceof ASTUnaryExpression){
                ASTUnaryExpression value = (ASTUnaryExpression) astBinaryExpression.expr2;
                op = value.op.value;
                visit(value);
                opnd1 = map.get(value.expr);
            }

以及对应的访问函数即可。

@Override
	public void visit(ASTUnaryExpression unaryExpression) throws Exception {
		// TODO Auto-generated method stub
		
	}

3.语句翻译

因为Example中没有语句翻译的例子，所以我另外补充一个语句翻译。

语句翻译如表达式翻译一样，也是遍历你的AST树即可，唯一需要增加的是一个Label来标记语句块。

如翻译这样一个SelectStatement

int main()
{
    if(a>0){
        c=a+b;
    }
    else{
        c=a-b;
    }
}

它生成的AST树是

"type" : "SelectionStatement",
        "cond" : [ {
          "type" : "BinaryExpression",
          "op" : {
            "type" : "Token",
            "value" : ">",
            "tokenId" : 8
          },
          "expr1" : {
            "type" : "Identifier",
            "value" : "a",
            "tokenId" : 7
          },
          "expr2" : {
            "type" : "IntegerConstant",
            "value" : 0,
            "tokenId" : 9
          }
        } ],
        "then" : {
          "type" : "CompoundStatement",
          "blockItems" : [ {
            "type" : "ExpressionStatement",
            "exprs" : [ {
              "type" : "BinaryExpression",
              "op" : {
                "type" : "Token",
                "value" : "=",
                "tokenId" : 13
              },
              "expr1" : {
                "type" : "Identifier",
                "value" : "c",
                "tokenId" : 12
              },
              "expr2" : {
                "type" : "BinaryExpression",
                "op" : {
                  "type" : "Token",
                  "value" : "+",
                  "tokenId" : 15
                },
                "expr1" : {
                  "type" : "Identifier",
                  "value" : "a",
                  "tokenId" : 14
                },
                "expr2" : {
                  "type" : "Identifier",
                  "value" : "b",
                  "tokenId" : 16
                }
              }
            } ]
          } ]
        },
        "otherwise" : {
          "type" : "CompoundStatement",
          "blockItems" : [ {
            "type" : "ExpressionStatement",
            "exprs" : [ {
              "type" : "BinaryExpression",
              "op" : {
                "type" : "Token",
                "value" : "=",
                "tokenId" : 22
              },
              "expr1" : {
                "type" : "Identifier",
                "value" : "c",
                "tokenId" : 21
              },
              "expr2" : {
                "type" : "BinaryExpression",
                "op" : {
                  "type" : "Token",
                  "value" : "-",
                  "tokenId" : 24
                },
                "expr1" : {
                  "type" : "Identifier",
                  "value" : "a",
                  "tokenId" : 23
                },
                "expr2" : {
                  "type" : "Identifier",
                  "value" : "b",
                  "tokenId" : 25
                }
              }
            } ]
          } ]
        }

缩小来观察

SelectionStatement就是由一个ASTExpression(cond)和两个(ASTStatement)构成。

ASTExpression怎么翻译？递归交给你的visit(ASTExpression)函数即可。

ASTStatement同理

那么生成Lable来标记语句块，我的理解其实就是关键字

比如：上面这个例子，我定义(大家可以改改名字)的中间代码为

(Label,,,@1If)
(>,a,0,%1)
(JF,%1,,@1Otherwise)
(+,a,b,c)
(JMP,,,@1Endif)
(Label,,,@1Otherwise)
(-,a,b,c)
(Label,,,@1Endif)

细细一看，是否有点像汇编代码了？其中(JF为如果%1为False，就跳转，JMP为直接跳转)

所以，SelectionStatement的代码结构为

public static void visit(ASTSelectionStatement astSelectionStatement){
        ASTNode StartCheckIfLabel=new LabelGenerator
        quats.add(new Quat("Label",StartCheckIfLabel,null,null));
        for(ASTExpression astExpression:astSelectionStatement.cond){
            visit(astExpression);
        }
        ASTNode res = map.get(astSelectionStatement.cond.get(0));
        ASTNode OtherwiseLabel=new LabelGenerator
        quats.add(new Quat("JF",OtherwiseLabel,res,null));
        visit(astSelectionStatement.then);
        ASTNode EndifLabel=new LabelGenerator
        if(astSelectionStatement.otherwise!=null){
            quats.add(new Quat("JMP",EndifLabel,null,null));
            quats.add(new Quat("Label",OtherwiseLabel,null,null));
            visit(astSelectionStatement.otherwise);
        }
        quats.add(new Quat("Label",EndifLabel,null,null));
    }

其中LabelGenerator是我自己定义的继承自ASTNode的生成Label的类

以上就是lab7的大致思路

但是缺少了对ASTDeclaration，ASTFunctionDefine的处理。这是因为我们对于定义的变量/函数，一般不放到中间代码中，而是维护一个FunctionTabel，一个Scope以及一个GlobalVaraibleTable

其实也就是对ASTDeclaration和ASTFunctionDefine的处理。

下面是int a的AST树。

"type" : "Declaration",
        "specifiers" : [ {
          "type" : "Token",
          "value" : "int",
          "tokenId" : 5
        } ],
        "initLists" : [ {
          "type" : "InitList",
          "declarator" : {
            "type" : "VariableDeclarator",
            "identifier" : {
              "type" : "Identifier",
              "value" : "a",
              "tokenId" : 6
            }
          },
          "exprs" : null
        } ]

所以我们只需要访问Declaration时，访问需要的节点，并加入你的表里面即可。

如：

public static void visit(ASTDeclaration astDeclaration){
        if(astDeclaration.parent.getClass()==ASTCompilationUnit.class){
            //全局变量或函数声明
        }
        else if(astDeclaration.parent.getClass()==ASTCompoundStatement.class){
            ASTToken astToken = astDeclaration.specifiers.get(0);
            for(ASTInitList astInitList : astDeclaration.initLists){
                
            }
        }
        else{
                   
        }
    }

如果维护了这样一个表，那么lab6中的var_not_defined和var_defined_again就很容易处理了，只需要在访问/插入的时候遍历一下表即可。

以上就是我lab6和lab7的思路，这两个实验本质上是对AST树的操作，所以关键的关键还是如何生成AST树。

寒士°、
关注
  • 12
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
BIT-MiniCC:编译原理课程实践（BIT Mini C编译器）参考https
03-31
微型卡 编译原理课程实践，设计实现C语言编译器。 参考老师提供的框架（Java实现），实现完整的语言规范的子集（C ++实现）。 1个待办事项清单 预先 词法分析 语法分析 语义分析 中间代码生成 代码优化 代码生成 2实现思路 2.1词法分析 对应代码： 目前能正确识别标识符，关键字，常量（整型，浮点型，字符常量，字符串字面量），符号（运算符，限定符） ）
BIT-MiniCC——semantic+icgen(lab6语义分析6+lab7中间代码生成)
weixin_43877853的博客
02-27 7234
lab6的语义分析要求能够识别出3种C语言错误即可，本次实验选择的是0_var_not_defined，1_var_defined_again，2_break_not_in_loop三种错误。 lab7的中间代码生成是将AST树翻译成四元式，对于变量的寄存器分配方法选择的是不进行分配，统一设置为全局变量。 实验思路在BITMINICC——lab6+lab7_寒士°、的博客-CSDN博客中，本篇给出详细代码，可以结合起来看。 1.在BIT-MiniCC-master\src\bit\minisys\mi
【编译】北京理工大学BITMINICC lab8+lab7 中间代码 & 目标代码生成
Falller的博客
06-28 1650
生成x86汇编
编译原理实验——BIT-MiniCC
weixin_43877853的博客
03-02 7014
实验目录
AST学习笔记 至少入个大门
arr的博客
07-23 1788
我的理解:AST相当于把js代码所有语法解析为抽象的树.用处大概就是逆向的时候把混淆的代码还原逻辑,方便看逻辑. 一. 直观地看AST AST在线解析 用这个网站输入JS源码就可以看到AST解析出来的语法树了 type节点类型 start,end节点起始.结尾位置 program源代码 comments注释 具体还是输入代码到网站上看对应的类型,这样比较快速学习 二.代码框架 来源:悦来客栈的老板的星球 //babel库及文件模块导入 const fs = require('fs'); //ba.
编译原理词法分析器实验报告_编译原理-第一章-引论
weixin_39653361的博客
12-02 693
第一章 引论1.1 什么是编译程序编译程序: 将C或者Java(源语言)这样高级语言转化为低级语言(目标语言)的翻译程序称为编译程序。高级语言分为两种: 编译程序：先编译成二进制文件然后执行，例如c或者java等。 解释程序：边解释边执行，例如JavaScript或者Python等。 本书主要讨论编译程序不对解释程序讲解，实际上许多编译程序的构造和实现同样适用于解释程序。交叉编译: 如果一个...
BIT-Minicc编译原理实验-MIPS汇编目标代码生成最傻瓜的思路+问题记录
weixin_42939529的博客
06-26 2330
编译原理课程实验要求为BIT-Minicc编译器开发目标代码生成部分，本文针对开发过程中的一些问题做记录，主要是寄存器分配和函数调用相关的问题。 中间代码 中间代码采用我之前在中间代码生成实验中编写的阉割版Maple IR中间代码生成器生成的代码，在此基础上做了一些修改。主要是把缺的几种运算符，以及循环和条件的集中模式补上，另外记录好常量字符串方便在目标代码直接放在数据区。 中间代码生成目标代码比直接从AST要方便许多，前提是中间代码生成时要解决变量读取和运算过程中临时变量的问题，即将所有操作数都放入寄存器
BIT-MiniCC——scanner(lab3词法分析器)
weixin_43877853的博客
02-26 4158
词法分析器
BIT-MiniCC——parser(lab5语法分析器)
weixin_43877853的博客
02-27 4025
本次实验要求生成代码的抽象语法树(AST)，具体的算法原理在BITMINICC——利用Antlr的Listener生成AST_寒士°、的博客-CSDN博客中有详细的介绍，此处就不再过多介绍了，这篇博客将给出详细代码，参考着看相信能够更加理解。 而其中提到的文法再编译原理Antlr教程_寒士°、的博客-CSDN博客中也提到了。 ——————————————————————————————————————————— 那么现在就开始语法分析器的编写 一、 1.在BIT-MiniCC-master\src
BITMiniCC-Parser-master_BITMiniCC_bit-Minicc_bit-minicc语法_语义分析_w
09-11
预处理，词法分析，语法分析，语义分析，中间代码生成
miniCC:适用于一小部分C语言的小型编译器。 正在开发中..
04-14
迷你C编译器 正在开发中... 目标 能够将简单的C函数（例如tests / frontend / algorithm-gcd.c）编译为汇编代码。 目标将是ARM64，但还计划了其他目标，例如RISC-V。 （完毕） 能够编译我的俄罗斯方块应用程序的主要部分。 实施很少的目标独立优化。 建造 mkdir build cd build cmake ../ make 用法 AST倾销 miniCC ../tests/fronted/algorithm-gcd.c -dump-ast 其中algorithm-gcd.c是 int gcd ( int a, int b) { int R; while ((a % b) > 0 ) { R = a % b; a = b; b = R; } return b; } 输出： TranslationUnit
word源码java-BITMiniCC-Scanner:BITMiniCC词法分析器
06-05
word源码java 词法分析器 实验目的 利用高级语言设计并实现一个词法分析程序，加深对词法分析原理的理解。并在实验中掌握扫描器的工作原理，以及对输入的程序设计语言源代码进行扫描过程中将其分解为各类不同属性的单词的词法分析方法。 实验内容 以C语言作为源语言，构建C语言的词法分析器，对于给定的测试程序，输出XML格式的属性字符流。词法分析器的构建按照C语言的词法规则进行。 实验过程 本次实验中的C语言词法分析器基于现行的ISO C11标准（ISO/IEC 9899:2011 Programming languages C）。标准中将C语言中的词法元素分为5类，分别是关键字（keyword）、标识符（identifier)、常量（constant）、字符串字面量（string-literal）和分隔符（punctuator），本次实验也严格按这5类进行识别，唯一的不同就是实验中把ISO标准中的分隔符进一步分为了限界符（delimiter）和运算符（operator），限界符包含了只有分隔作用没有运算作用的6个符号(,),[,],{,},.,->，其余符号均识别位运算符，以方便后续的处理
minicC语言的解释器源代码
11-19
该C语言解释器本身采用标准C语言实现，可以在各种C平台下编译执行。主要特色如下： 1. 完美支持各种标准C语言语法，如if-else结构语句, ?:结构求值语句，for循环，while循环，do...while循环等。 2. 支持各种数据类型包括: char,short,int,string,float。 3. 支持多维数组及指针。 4. 支持自定义函数以及系统函数。 5. 支持局部变量以及全局变量，允许在变量定义时直接初始化。 6. 支持局部变量层次化作用域 7. 允许定义系统常量 8 支持系统内部定义数据类型，但不支持用户在脚本中自定义数据类型. 9 支持行注释符//及段注释符/*...*/ 10. 支持通过include加载其它源文件。 11. 支持各种条件运算符 || && 12. 支持各种逻辑运算及位操作符: + - * / % ! ~ ^ > < <>,并按照C语言标准来规范运算优先级。 13. 支持单目运算!(not)及~(位取反)的嵌套。 14. 支持 += -= *= /= %= &= |= >>= <<= 的赋值形式。 15. 支持++
BIT-MiniCC——negen(lab8目标代码生成)
weixin_43877853的博客
03-02 3095
终于来到了最后一步——目标代码生成 本次的实验目标是将生成的中间代码四元式翻译成x86汇编语言 原理其实就是根据不同的四元式对应不同的语句输出为汇编代码即可 根据要求是只需要满足3个测试用例即可，再多只需要继续添加翻译语句就行 一、 1. 由于本次实验提供的测试用例的输入输出函数，Mars_PrintInt，Mars_PrintStr，Mars_GetInt在x86中并未定义。所以需要通过借用对应的c语言函数，又由于x86中对应的printf和scanf的调用处理较为特殊，所以在此处对于这一类函
BITMINICC——利用Antlr的Listener生成AST
weixin_43877853的博客
05-28 4312
BITMINICC生成AST 首先请花一定的时间阅读下面的参考方法，本文是我对下面文章的一个理解和踩坑记录。 参考方法：https://zhuanlan.zhihu.com/p/369250644?utm_source=qq&utm_medium=social&utm_oi=732535204933025792 1.一个好的文法 因为要用Antlr生成Lexer以及Listener，所以一个定义完整的文法是最重要的。因为当你用一个缺陷的文法，重写好了Listener，分析好了上一个实
遍历AST过程中解释执行代码--java实现
热门推荐
JZ
06-06 2万+
本人博客内编译原理文章的配套资源jar包，包括词法分析，语法分析，中间代码生成，静态语义检查，代码解释执行以及抽象语法树的手动生成：https://download.csdn.net/download/as1072966956/10448935转载请注明出处。Lab5Main.javapackage sch.cauc.edu.token; import java.io.File; import ...
从零写一个编译器（十三）：代码生成之遍历AST
weixin_30432579的博客
08-21 752
项目的完整代码在 C2j-Compiler 前言 在上一篇完成对JVM指令的生成，下面就可以真正进入代码生成部分了。通常现代编译器都是先把生成IR，再经过代码优化等等，最后才编译成目标平台代码。但是时间水平有限，我们没有IR也没有代码优化，就直接利用AST生成Java字节码 入口 进行代码生成的入口在CodeGen，和之前解释器一样：先获取main函数的头节点，从这个节点开始，先进入...
把你自己的代码生成TVM 
weixin_42164269的博客
02-13 1646
把你自己的代码生成要TVM 随着深度学习工作负载所针对的硬件设备的数量不断增加，用户在各种设备上实现高性能所需的知识也在不断增加。为了使数据科学家不必担心开发新模型时的性能，硬件后端提供程序要么为MKLDNN或cuDNN之类的库提供许多常用的深度学习运算符，要么提供诸如TensorRT的框架以使用户以某种方式描述其模型实现高性能。但是，用户尝试在新的库或设备上工作时必须学习新的编程界面。结果，...
一文助你搞懂 AST
程序员成长指北
06-22 2133
好朋友在团队分享的文章作者：fecym原文地址：https://chengyuming.cn/views/webpack/AST.html什么是 AST抽象语法树（Abstract Sy...
DeepLab V3+
最新发布
09-05
DeepLab V3是一个语义分割网络，它基于DeepLab V2，并通过添加一个简单有效的Decoder来细化分割结果，尤其是沿着目标对象边界的分割结果。此外，它还采用了空间金字塔池模块或编解码结构二合一的方式进行实现。 ...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值