湖南大学编译原理实验四cminus_compiler-2021-fall

于 2022-03-30 23:51:57 发布
阅读量1.1k 收藏 12
点赞数 3
分类专栏： # 编译原理 文章标签： linux c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45890970/article/details/123792309
版权

湖南大学编译原理实验四cminus_compiler-2021-fall

Lab4 实验文档

0. 前言

本次实验和 Lab3 一样，需要使用 LightIR 框架自动产生 cminus-f 语言的LLVM IR。

经过 Lab3 的练手，相信大家已经掌握了 LightIR 的使用，并且对于 LLVM IR 也有了一定理解。在本次实验中，我们要使用访问者模式来实现 IR 自动生成。
对于产生的IR， 我们可以调用 clang 生成可执行文件，这样一个初级的 cminus-f 编译器就完成啦！

主要工作

  1. 阅读cminus-f 的语义规则成为语言律师，我们将按照语义实现程度进行评分
  2. 阅读LightIR 核心类介绍
  3. 阅读实验框架，理解如何使用框架以及注意事项
  4. 修改 src/cminusfc/cminusf_builder.cpp 来实现自动 IR 产生的算法，使得它能正确编译任何合法的 cminus-f 程序
  5. 在 report.md 中解释你们的设计，遇到的困难和解决方案

1. 实验框架

本次实验使用了由C++编写的 LightIR 来生成 LLVM IR。为了便于大家进行实验，该框架自动完成了语法树到 C++ 上的抽象语法树的转换。
我们可以使用访问者模式来设计抽象语法树
中的算法。大家可以参考打印抽象语法树的算法，
以及运行 test_ast 来理解访问者模式下算法的执行流程。

在include/cminusf_builder.hpp中，我还定义了一个用于存储作用域的类Scope。它的作用是辅助我们在遍历语法树时，管理不同作用域中的变量。它提供了以下接口：

// 进入一个新的作用域
void enter();
// 退出一个作用域
void exit();
// 往当前作用域插入新的名字->值映射
bool push(std::string name, Value *val);
// 根据名字，寻找到值
Value* find(std::string name);
// 判断当前是否在全局作用域内
bool in_global();

你们需要根据语义合理调用enter与exit，并且在变量声明和使用时正确调用push与find。在类CminusfBuilder中，有一个Scope类型的成员变量scope，它在初始化时已经将input、output等函数加入了作用域中。因此，你们在进行名字查找时不需要顾虑是否需要对特殊函数进行特殊操作。

2. 运行与调试

运行 cminusfc

mkdir build && cd build
cmake .. -DLLVM_DIR=/path/to/your/llvm/install/lib/cmake/llvm/
make -j
# 安装它以便于链接 libcminus_io.a
make install

编译后会产生 cminusfc 程序，它能将cminus文件输出为LLVM IR，也可以利用clang将IR编译成二进制。程序逻辑写在src/cminusfc/cminusfc.cpp中。

当需要对 .cminus 文件测试时，可以这样使用：

# 假设 cminusfc 的路径在你的$PATH中
# 利用构建好的 Module 生成 test.ll
# 注意，如果调用了外部函数，如 input, output 等，则无法使用lli运行
cminusfc test.cminus -emit-llvm

# 假设libcminus_io.a的路径在$LD_LIBRARY_PATH中，clang的路径在$PATH中
# 1. 利用构建好的 Module 生成 test.ll
# 2. 调用 clang 来编译 IR 并链接上静态链接库 libcminus_io.a，生成二进制文件 test
cminusfc test.cminus

自动测试

助教贴心地为大家准备了自动测试脚本，它在 tests/lab4 目录下，使用方法如下：

# 在 tests/lab4 目录下运行：
./lab4_test.py

如果完全正确，它会输出：

===========TEST START===========
Case 01:	Success
Case 02:	Success
Case 03:	Success
Case 04:	Success
Case 05:	Success
Case 06:	Success
Case 07:	Success
Case 08:	Success
Case 09:	Success
Case 10:	Success
Case 11:	Success
Case 12:	Success
============TEST END============

通过修改脚本，还可以方便地添加自定义测试用例

请注意助教提供的测试样例仅涵盖了最基础的测试情况，请自行设计测试样例进行测试。

logging

logging 是帮助大家打印调试信息的工具，如有需求可以阅读文档后进行使用

建议

  1. 比较你们编写的编译器产生的 IR 和 clang 产生的IR来找出可能的问题或发现新的思路
  2. 使用 logging 工具来打印调试信息
  3. 使用 GDB 等软件进行单步调试来检查错误的原因
  4. 合理分工

3. 提交要求

目录结构

.
├── CMakeLists.txt
├── Documentations
│   ├── ...
│   ├── common
│   |   ├── LightIR.md                  <- LightIR 相关文档
│   |   ├── logging.md                  <- logging 工具相关文档
│   |   └── cminusf.md                  <- cminus-f 的语法和语义文档
│   └── lab4
│       └── README.md                   <- lab4 实验文档说明（你在这里）
├── include                             <- 实验所需的头文件
│   ├── ...
│   ├── lightir/*
│   ├── cminusf_builder.hpp
|   └── ast.hpp
├── Reports
│   ├── ...
│   └── lab4
│       └── report.md                   <- lab4 所需提交的实验报告，请详细说明你们的设计（需要上交）
├── src
│   ├── ...
│   └── cminusfc
│       ├── cminusfc.cpp                <- cminusfc 的主程序文件
│       └── cminusf_builder.cpp         <- lab4 需要修改的文件，你们要在该文件中用访问者模式实现自动 IR 生成的算法（需要上交）
└── tests
    ├── ...
    └── lab4
        ├── testcases                   <- 助教提供的测试样例
        └── lab4_test.py                <- 助教提供的测试脚本

实验报告

实验要求

请按照自己的理解，写明本次实验需要干什么

答 ：在理解cminus-f 语法与语义的基础上，我们需要补充完成 cminusf_builder.cpp 中的16个函数，来实现自动 IR 产生的算法，使得它能正确编译任何合法的 cminus-f 程序。在自动产生 IR 的过程中，利用访问者模式自顶向下遍历抽象语法树的每一个结点，调用我们补充完成的函数对每一个抽象语法树的结点进行分析，如果程序是合法的则编译应该显示Success，否则编译不通过显示Fail。

例如void CminusfBuilder::visit(ASTExpressionStmt &node)函数是对表达式的结点进行访问，在cminus-f 语法与语义中，表达式语句由一个可选的表达式（即可以没有表达式）和一个分号组成。其结构体如下

struct ASTAssignExpression: ASTExpression {
    virtual void accept(ASTVisitor &) override final;
    std::shared_ptr<ASTVar> var;
    std::shared_ptr<ASTExpression> expression;
};

我们则只需要判断表达式是否为空，如果存在表达式，则通过node.expression->accept(*this);递归访问，否则则说明没有表达式。

void CminusfBuilder::visit(ASTExpressionStmt &node) {  //表达式
    if (node.expression != nullptr) node.expression->accept(*this); //递归访问
}

实验难点

实验中遇到哪些挑战

答：

  1. 因为cminusf_builder.cpp 中的16个函数都是void类型的，没有返回值，一时不知道怎么保存计算的结果，后面思考了一段时间察觉到全局变量好像可以实现，每次全局变量的类型或者值发生变化，就更新全局变量，这样在访问下一个结点时获取全局变量就可以取得最新的值，这样信息可以传入或者传出信息给下层或上层时。

  2. 在cminus-f 的语义中，有很多需要注意的小细节，比如五种类型转化，

  • 赋值时
  • 返回值类型和函数签名中的返回类型不一致时
  • 函数调用时实参和函数签名中的形参类型不一致时
  • 二元运算的两个参数类型不一致时
  • 下标计算时

要区分类型转化时是左边的类型进行转化还是右边的类型进行转化，例如：浮点数和整型一起运算时，谁是整型就需要进行类型提升，转换成浮点数类型。而在函数调用时若实参类型和函数形参不相同时，需要把实参的类型转化为形参的类型。本次实验考虑了很多次类型转化，需要很小心。

  1. 对于void CminusfBuilder::visit(ASTVar &node)函数，虽然语法中说了其var 可以是一个整型变量、浮点变量，或者一个取了下标的数组变量，但我在实现的过程中感觉有些困难。

实验设计

答：

全局变量
  1. 正如难点一中所提到的在函数没有返回值的时候，我们需要借助全局变量在上层或下层之间传递值，在本次实验中我存临时值的全局变量为 node_val ，当调用void CminusfBuilder::visit(ASTAdditiveExpression &node)函数进行加减运算时，及时更新全局变量，这样在上层或下层使用时就可以拿到准确的值。实验中要认真严谨思考访问什么结点时会更新这个变量的值，及时更新。
  2. 除此之外，我还定义了二个全局变量：
  • cur_fun指向当前的函数，当访问的结点类型为ASTFunDeclaration时，可以及时更新当前函数，方便IF语句和While语句创建块，比如auto condBB = BasicBlock::create(module.get(), "", cur_fun);，以及void CminusfBuilder::visit(ASTReturnStmt &node)中获取函数返回值类型。
  • require_lvalue判断是否需要左值，在 C 中，赋值对象（即 var ）必须是左值。cminus-f中，唯一的左值就是通过 var 的语法得到的，这个全局变量对我们后续函数补充有用。
Judge函数

为了减少重复的工作，增加了一个Judge函数，用于判断两个变量的类型是否都为整数。因为在进行加减乘除时，要确保两个操作数的类型相同，如果不相同则整型值需要进行类型提升，转换成浮点数类型。这个函数在访问ASTSimpleExpression简单表达式结点、ASTAdditiveExpression加减运算结点、ASTTerm乘除运算结点时用到了。

bool judge(IRBuilder *builder, Value **l_val_p, Value **r_val_p) // 用于判断赋值的左右两边是否为整数
{
	bool is_int= false;  //判断是否为整数
	auto &l_val = *l_val_p;
	auto &r_val = *r_val_p;
    // 赋值时左右两边类型相同
	if (l_val->get_type() == r_val->get_type()) is_int = l_val->get_type()->is_integer_type();
    else{
        // 浮点数和整型一起运算时，整型值需要进行类型提升，转换成浮点数类型，且运算结果也是浮点数类型
		if (l_val->get_type()->is_integer_type()) l_val = builder->create_sitofp(l_val, FloatType);
		else  r_val = builder->create_sitofp(r_val, FloatType);
	}
	return is_int;
}
void CminusfBuilder::visit(ASTVar &node) 函数设计

设计中，最开始没有考虑到var可能为指针的情况，而只考虑了数组的情况，虽然这样也没有报错，但和同学交流后发现这样确实不稳妥，从严谨的角度上说，对于某个变量，类型为数组和指针的取值方法是不一样的。如果是数组，在使用gep时idx需要两个偏移量；而如果这个var是个指针，则只需要一个偏移量。如下所示，

void CminusfBuilder::visit(ASTVar &node) { 
    /*
    var 可以是一个整型变量、浮点变量，或者一个取了下标的数组变量。

    struct ASTVar: ASTFactor {
    virtual void accept(ASTVisitor &) override final;
    std::string id;
    // nullptr if var is of int type
    std::shared_ptr<ASTExpression> expression;
    };

    */
    auto var = scope.find(node.id); //var指向值的地址
	assert(var != nullptr);
    //判断值的类型
	auto is_int = var->get_type()->get_pointer_element_type()->is_integer_type();
	auto is_float = var->get_type()->get_pointer_element_type()->is_float_type();
	auto is_ptr = var->get_type()->get_pointer_element_type()->is_pointer_type();
    //判断是否为赋值的左部，如果是则返回地址，否则返回的是地址中的值。
	bool should_return_lvalue = require_lvalue;
	require_lvalue = false;

	if (node.expression == nullptr){  //expression为nullptr，则为整型变量、浮点变量
		if (should_return_lvalue) //如果var必须为左值，则取地址
		{
			node_val = var;
			require_lvalue = false;
		}
        //否则，node_val存储var地址中的值
		else 
		{
			if (is_int || is_float)  node_val = builder->create_load(var); //获取var的值
		}
	}
     // 如果为数组或者指针
    else{  
		node.expression->accept(*this);
		auto val = node_val;  //获取数组下标
		Value *is_neg;
		auto exceptBB = BasicBlock::create(module.get(), "", cur_fun);
		auto contBB = BasicBlock::create(module.get(), "", cur_fun);
        //数组下标必须为整数，如果不是则要进行类型转化
		if (val->get_type()->is_float_type()) val = builder->create_fptosi(val, Int32Type);
        //判断数组下标是否为非负数 
		is_neg = builder->create_icmp_lt(val, CONST_INT(0)); 
		builder->create_cond_br(is_neg, exceptBB, contBB);

        /*若val<0，一个负的下标会导致程序终止，需要调用框架中的内置函数neg_idx_except 
        （该内部函数会主动退出程序，只需要调用该函数即可），但是对于上界并不做检查。*/
		builder->set_insert_point(exceptBB);   
		builder->create_call(static_cast<Function *>(scope.find("neg_idx_except")), {});
		if (cur_fun->get_return_type()->is_void_type())  builder->create_void_ret();
		else if (cur_fun->get_return_type()->is_float_type()) builder->create_ret(CONST_FP(0.));
		else  builder->create_ret(CONST_INT(0));

		builder->set_insert_point(contBB);  //val>=0
		Value *node_ptr;
		if (is_ptr)  //如果这个var是个指针，则只需要一个偏移量。
		{
			auto array_load = builder->create_load(var); //把var中的值加载出来，即初始地址
			node_ptr = builder->create_gep(array_load, {val}); //进行偏移
		}
        //对于数组，在使用gep时idx需要两个偏移量
		else  node_ptr = builder->create_gep(var, {CONST_INT(0), val});

		if (should_return_lvalue)  //如果var必须为左部，则取地址
		{
			node_val = node_ptr;
			require_lvalue = false;
		}
		else node_val = builder->create_load(node_ptr);  //否则，取node_ptr中的值
	}
    

}
void CminusfBuilder::visit(ASTVarDeclaration &node) 函数设计

在这个函数设计的过程中，首先要确定变量的类型是整型还是浮点型，然后再判断其是声名一个变量还是一个数组，最后再判断其是声名的全局变量还是局部变量。需要注意的点时，在Cminusf语法中，全局变量需要初始化为全 0，且记得通过语句 scope.push(node.id,value);往当前作用域插入新的名字->值映射。

void CminusfBuilder::visit(ASTVarDeclaration &node) {  //变量声名
    /*
    struct ASTVarDeclaration: ASTDeclaration {
    virtual void accept(ASTVisitor &) override final;
    CminusType type;
    std::shared_ptr<ASTNum> num;
    };

    struct ASTDeclaration: ASTNode {
    virtual void accept(ASTVisitor &) override;
    CminusType type;
    std::string id;
    };

    static GlobalVariable *create(std::string name, Module *m, Type* ty, bool is_const, Constant* init );
    */
    Type *type=nullptr;
    //在变量声明中，只有整型和浮点型可以使用
    if(node.type==TYPE_INT)  type=Int32Type;
    else if(node.type==TYPE_FLOAT) type=FloatType;

    //一个变量声明定义一个整型或者浮点型的变量，或者一个整型或浮点型的数组变量
    //这里整型指的是32位有符号整型，浮点数是指32位浮点数

    if(node.num==nullptr) //单个变量声名
    {
        if(scope.in_global())  // 判断当前是否在全局作用域内
        {    //全局变量需要初始化为全 0
            auto value=GlobalVariable::create(node.id,module.get(),type,false,ConstantZero::get(type, module.get()));
            // 往当前作用域插入新的名字->值映射
            scope.push(node.id,value);
        }
        else
        {
            //局部变量
            auto value=builder->create_alloca(type);
            // 往当前作用域插入新的名字->值映射
             scope.push(node.id,value);
        }
    }
    else //数组声名
    {
        auto *array_type=ArrayType::get(type, node.num->i_val);  //参数依次是数组元素的类型,数组元素个数
          if(scope.in_global())  // 判断当前是否在全局作用域内
        {    //全局变量需要初始化为全 0
            auto value=GlobalVariable::create(node.id,module.get(),array_type,false,ConstantZero::get(array_type, module.get()));
            // 往当前作用域插入新的名字->值映射
            scope.push(node.id,value);
        }
        else
        {
            //局部变量
            auto value=builder->create_alloca(array_type);
            // 往当前作用域插入新的名字->值映射
             scope.push(node.id,value);
        }
    }

}
void CminusfBuilder::visit(ASTFunDeclaration &node) 函数设计

ASTFunDeclaration访问函数的设计难度我觉得仅次于ASTVarDeclaration访问函数的
设计。因为函数声名需要考虑的内容东西也很多，函数类型+函数名+参数列表+复合语句（局部声明与语句列表）。

  • 首先需要确定返回值的类型，然后确定参数列表中各个参数的类型，最后才能确定函数的类型。
  • 函数定义后，需要把全局变量中的cur_fun指向当前这个函数，并在创建函数块且执行builder->set_insert_point(BB);后进入新的作用域。
  • 在这个函数块中，我们需要获取函数的形参，给每个参数在内存中分配位置，并把值给对应的内存地址，然后加入当前作用域。
  • 下一步就是访问函数中的复合语句，当访问结束后，函数将根据当前函数返回值的类型执行ret操作。
  • 最后退出当前作用域
void CminusfBuilder::visit(ASTFunDeclaration &node) {  //函数声名
    /*
    函数类型+函数名+参数列表+复合语句（局部声明与语句列表）
    fun-declaration : type-specifier IDENTIFIER LPARENTHESE params RPARENTHESE compound-stmt

    struct ASTFunDeclaration: ASTDeclaration {
    virtual void accept(ASTVisitor &) override final;
    std::vector<std::shared_ptr<ASTParam>> params;
    std::shared_ptr<ASTCompoundStmt> compound_stmt;
     };

    struct ASTParam: ASTNode {
    virtual void accept(ASTVisitor &) override final;
    CminusType type;
    std::string id;
    // true if it is array param
    bool isarray;
    };

    */
    Type *return_type;  //返回值类型
    std::vector<Type *> param_types;
    //找函数返回值类型
    if(node.type==TYPE_INT)  return_type=Int32Type;
    else if(node.type==TYPE_FLOAT) return_type=FloatType;
    else return_type=Void;

    for(auto &p :node.params){ //依次判断参数的类型
        if(p->type==TYPE_INT){  //参数为整型
            if(p->isarray) param_types.push_back(Int32_ptr);  //参数为整型数组
            else param_types.push_back(Int32Type); //整数
        }
        else{ //参数为浮点型
            if(p->isarray) param_types.push_back(Float_ptr);  //参数为浮点数组
            else param_types.push_back(FloatType);  //浮点数
        }
    }
     //FunctionType *get(Type *result,std::vector<Type*> params);
    //确定参数列表和返回值类型后，可确定函数
    FunctionType *fun_type=FunctionType::get(return_type, param_types);
    auto fun=Function::create(fun_type,node.id,module.get()); //声名函数，参数依次是：函数类型，名字， Module *parent
    scope.push(node.id,fun); //加入当前作用域
    cur_fun=fun;
    auto BB=BasicBlock::create(module.get(), "entry", fun);  //一个块
    builder->set_insert_point(BB);
    scope.enter(); //进入一个新的作用域

    std::vector<Value *> args;  // 获取函数的形参,通过Function中的iterator
    for (auto arg = fun->arg_begin(); arg != fun->arg_end(); arg++)  args.push_back(*arg);
    int i=0; //参数
    for(auto p :node.params)  //给每个参数在内存中分配位置，并把值给对应的内存地址
    {
        if(p->type==TYPE_INT)
        {
            Value *i_type;
            if(p->isarray) i_type = builder->create_alloca(Int32_ptr);  //参数为整型数组
            else i_type = builder->create_alloca(Int32Type); //整数

            builder->create_store(args[i], i_type); //将参数的值存储到开辟的空间
            scope.push(p->id, i_type); //加入当前作用域
        }
        else
        {
            Value *f_type;
            if(p->isarray) f_type = builder->create_alloca(Float_ptr);  //参数为浮点数组
            else f_type = builder->create_alloca(FloatType); //浮点数

            builder->create_store(args[i], f_type);  //将参数的值存储到开辟的空间
            scope.push(p->id, f_type);   //加入当前作用域

        }
        i++;

    }

    node.compound_stmt->accept(*this); //复合语句的访问
   //判断返回类型
    if (cur_fun->get_return_type()->is_void_type())  builder->create_void_ret();
    else if (cur_fun->get_return_type()->is_float_type())  builder->create_ret(CONST_FP(0.));
    else builder->create_ret(CONST_INT(0));

    scope.exit();  //退出当前作用域

}

实验结果

先在build目录下依次执行cmake ..，make -j和sudo make install，然后在tests/lab4 目录下运行./lab4_test.py，结果如图所示，全部正确。

在这里插入图片描述

实验总结

这次实验整体来说还是有点点小复杂的，因为其涉及到的头文件很多，很难找到正确的切入点，且过程中还经常出现一些小问题不好找原因。需要认真仔细的看cminus-f 的语法与语义以及各个函数之间的联系才能比较顺利的完成这个实验。

通过这个实验，我对cminusf语法语义和访问者模式有了更深入的理解，根据node对象具体类型的不同，编译器在对语法树自顶向下分析时会选择对应的visit函数进行调用，从而较为高效的完成任务。以前写C++代码时，只知道不符合语法会报错，但并不知道计算机内部是如何实现这个过程的，完成这个实验的过程中我知道了答案。此外，本次实现需要阅读大量的.h头文件，所以我阅读理解C代码的能力有所提升，且养成了仔细严谨阅读文档、多思考的好习惯。

焦妮敲代码
关注
专栏目录
湖南大学 编译原理实验一.zip
02-05
湖南大学专业课编译原理实验的相关资料，实验分巨高，另外推荐陈果老师，讲课真的好，祝大家学业有成，代码以及报告仅作参考，不要过分摘抄。
CMinus_Compiler:你好
03-28
CMinus_Compiler是一个基于Python实现的简易C-减小（C-Minus）语言的编译器。这个项目可能是一个教学工具或编程练习，用于帮助学习者理解编译器的工作原理和构建过程。C-Minus是一种简化版的C语言，通常在计算机科学...
湖南大学编译原理实验三cminus_compiler-2021-fall
Concise200的博客
03-29 1016
湖南大学编译原理实验三cminus_compiler-2021-fallLab3 实验文档0. 前言主要工作1. LLVM IR部分1.1 LLVM IR介绍1.2 gcd例子: 利用clang生成的.ll1.3 你的提交1: 手动编写.ll2. LightIR部分2.1 LightIR - LLVM IR的C++接口2.2 gcd例子: 利用LightIR + cpp 生成.ll2.3 你的提交2: 利用LightIR + cpp编写生成.ll的程序3. Lab4的准备3.1 了解Visitor Patt
湖南大学编译原理实验一：词法分析(TINY)
Moyu-42的博客
11-28 980
由于这部分的代码我也是抄的，可以参考给出的 tiny_tm 文件夹中 scan.c 文件的逻辑，所以我这里就不贴啥了，需要代码的可以去 实验1
湖南大学编译原理实验三：词法分析（TINY语言）
Moyu-42的博客
12-06 930
代码链接：编译原理实验三 文章目录实验三 语法分析程序（一）学习经典的语法分析器（1学时）一、实验目的二、实验任务三、实验内容（二）实现一门语言的语法分析器（3学时）一、实验目的二、实验任务三、实验内容实验步骤学习经典的语法分析器（TINY）实现一门语言的语法分析器（TINY）语言确定BNF文法到EBNF文法的转换抽象语法树结构语法分析器LL(1)语法分析器的实现基础数据存储方式解析产生式NULLABLE集合计算FIRST集合计算FOLLOW集合计算FIRST_S集合计算产生预测分析表parse语法分析生成
湖南大学编译原理实验一cminus_compiler-2021-fall
Concise200的博客
03-25 3088
cminus_compiler-2021-fall前言Lab1 实验文档0. 基础知识0.1 cminus-f词法0.2 FLEX简单使用1. 实验要求1.1 目录结构1.2 编译、运行和验证实验报告实验要求实验难点实验设计实验结果验证实验反馈 前言 实验文档来源湖南大学编译原理课程，实验报告是笔者写的。 Lab1 实验文档 0. 基础知识 在本次实验中我们讲重点用到FLEX和以C-为基础改编的cminus-f语言。这里对其进行简单介绍。 0.1 cminus-f词法 C MINUS是C语言的一个子集，
CMinus_Compiler.rar_cminus_cminus 编译器_cminus编译原理_cminus编译器
09-24
下载并解压"CMinus_Compiler.rar"后，你可以通过VC++环境编译并运行源代码。然后，你可以逐步调试和修改代码，以观察不同阶段的变化，加深对编译器原理的理解。 总之，CMinus 编译器是一个优秀的教学工具，可以帮助...
CMinus-Compiler.rar_cminus
09-19
CMinus编译器，以其独特的命名"CMinus-Compiler.rar_cminus"，是用C语言实现的一个简单C语言变体的编译器。这个项目旨在帮助开发者和学生了解编译器的工作原理，特别是词法分析和语法解析这两个关键步骤。在深入探讨...
编译原理实验四 编译器自动生成工具
12-20
在本实验中，我们将深入探讨“编译原理”，这是一个计算机科学的重要领域，主要涉及将高级编程语言转换为机器可理解的二进制代码的过程。实验的主题是“编译器自动生成工具”，它包括了FLEX和BISON这两个关键工具，...
基于C++的湖南大学2021年秋季编译原理课程实验设计源码
最新发布
10-05
该项目是湖南大学信息科学与工程学院2021年秋季编译原理课程实验设计的源码，采用C++作为主要编程语言，同时融入了C、Python和Shell等辅助语言。项目文件总计220个，其中包含58个Cminus源文件、23个C++源文件、20个...
湖南大学编译原理实验四.zip
12-17
根据语法规则建状态图建表 LR（0）实现tiny，验收必高分 文件清单及说明见实验报告里的文件清单及简要说明
CMINUS 编译器
12-12
Ｃ语言实现，ＶＣ　６．０　下调试通过。本实验主要是完成前两个步骤的任务，即词法分析和语法分析。 各文件的设计说明： 为了完成词法分析功能，设计了cminus.h cminus.c 来实现功能（用Lex工具自动生成）； 为了对初始文法消除左递归，提取左因子，设计了del_LR_LF.h del_LR_LF.c 来实现功能； 为了求出First 和Follow集合，设计了getset.h getset.c 来实现功能； 为了建立分析表，设计了createtable.h createtable.c 来实现功能； 为了建立语法树，设计了 constructTree.h constructTree.c 来实现功能。 在globals.h中定义了一些全局变量和全局函数； 在 scan.h 中定义了一些Lex工具需要使用的变量和函数原型； 在 util.c 中实现了printToken 来向屏幕上打印记号序列 ．．．
Compilers_HNU:湖南大学编译原理实验
05-11
Exp1：词法分析 Exp2：正则表达式到NFA到DFA到DFA最小化 Exp3：语法分析 Exp4：使用Yacc和FLEX工具（无对应代码） Exp5：语义分析 Exp6：目标代码生成 Exp1和Exp3使用的是TINY Exp5和Exp6则是使用的CMinus，因为TINY已经给出了源码且没有可以替代的方法。 所以，如果是HNU的，建议从实验1开始就来写CMinus
cminus编译器（c++实现）
06-13
内包含lex实现词法分析,表驱动实现手动词法分析和LL(1)实现语法分析，c++实现
C-Minus编译器
09-13
参照TINY语法分析器的实现，运用所学知识用C语言或者C++语言实现C-MINUS词法分析器,可输出token，再在词法分析的基础上实现C-MINUS语法分析器，可输出语法树。 本资源是运用自顶向下方法中的递归下降分析方法进行语法分析，是学习编译器理解编译器的重要方法，上传本资源帮助大家学习。
编译原理：cminus_compiler-2021-fall Lab4
qq_45795586的博客
01-20 1640
吐槽 第四次实验明明是中科大他们小组四周完成的作业，结果到某湖这里居然让我们一个人用两周的时间完成？？？有没有搞错啊歪歪歪！！！可能是老师知道我们自己写是不可能写出来的吧（X） 我在github上面看了差不多有五篇吧，然后有三篇就是直接用的中科大他们给出的官方答案，有一篇是自己写的但是运行不出来第十二个的结果，然后有一篇是自己写的可以运行全部的结果 然后我就基本上是在最后这个人的基础上修改出来了一个我自己的 0. 前言 本次实验和 Lab3 一样，需要使用 LightIR 框架自动产生 cminus-f 语
湖南大学信息院.编译技术（编译原理）各章节作业参考答案
乔卿的博客
01-29 2390
注：以下各章节作业都是博主自己做的，博主该课程成绩90+，虽难免纰漏，但基本上可以放心参考。 第一章 第三章 第四章 第五章 第六章 第七章 第八章
HNU-编译原理实验-cminus_compiler-2021-fall-master【4】-Lab4
m0_51975364的博客
03-02 1492
Lab4 实验报告 一、实验要求 阅读cminus-f 的语义规则成为语言律师，我们将按照语义实现程度进行评分 阅读LightIR 核心类介绍 阅读实验框架，理解如何使用框架以及注意事项 修改 src/cminusfc/cminusf_builder.cpp 来实现自动 IR 产生的算法，使得它能正确编译任何合法的 cminus-f 程序 在 report.md 中解释你们的设计，遇到的困难和解决方案 二、实验难点 在执行make install指令的时候，权限不够：
cminus-compiler:用 Haskell 编写的 C-Minus 编译器，目标是称为 TM 的体系结构。 我为编译器课程写了这个。 它可以在几个地方重构，但总的来说我很自豪
06-22
有关构建代码的信息，请参阅 doc/report1.pdf。 简短的版本是在简单的情况下，“make”应该可以解决问题。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

焦妮敲代码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值