「700行手写编译器」Part 3.3：表达式与优先级爬山 笔记

最新推荐文章于 2023-12-20 15:33:00 发布
最新推荐文章于 2023-12-20 15:33:00 发布
阅读量398 收藏 9
点赞数 7
分类专栏： 700行实现C minus编译器 文章标签： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55051321/article/details/135053088
版权

递归下降一直下降到表达式为止。
在这里插入图片描述
语句（statement）：描述做什么，不需要返回值 （if…else…，while…，return… ）
表达式（expression）：为了求值，需要一个返回值 （ 2+3，4*5 ）
但是a = 3的情况很难说是赋值语句还是表达式
例如下面的情况：

if((a=3)!=0){   //这里(a=3)会返回值3，因此3！=0，条件为真
	xxxxx;
}else{
	xxxxx;
}

因此我们把a = 3看成是表达式。

操作符优先级（operator precedence）：
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
优先级爬山算法：也就是遇到的符号的优先级能在栈中的情况一定是从栈底到栈顶，优先级越来越高（>=，也可以同级）的情况（比如+ → * → ++ ）

//表达式的处理过程
*++a++ = i==0 ? 2+3 : 4+5 ;

//operater stack: a
//  number stack: * ++

//下一个要入栈的操作符是后置的++，优先级更低，所以要先出栈

//   number stack: a
// operater stack: * ++
// 先出栈number stack中的++，处理++a，假设原本a = 230230，（64bit的情况下）++a后变成230238.

//   number stack: a
// operater stack: *
// 此时后置的++优先级依然比a低，因此还要继续出栈number stack中的*，给a dereference

//   number stack: *a
// operater stack: ++
// 此时置入=，=的优先级依然比++低，因此还要继续出栈number stack中的++，因此（*a）++

// 然后i进入operater stack
//   number stack: *a  i
// operater stack: ++

// 此时置入=，=的优先级依然比++低，因此还要继续出栈number stack中的++，因此（*a）++
//   number stack: *a  i
// operater stack:  =

// ==的优先级比=高，所以==可以直接入operater stack
//   number stack: *a  i  0
// operater stack:  =  ==

//三元操作符？ ：的优先级很低，不能直接入栈
//先运算栈中的i==0,假设i=0，结果为true，然后操作符==出栈，运算的数字i和0出栈，结果true入栈
//   number stack: *a  true
// operater stack: =    ?:

//运算已经到末尾，此时会对？：做处理，true时是2+3
//   number stack: *a  2  3
// operater stack: =   +

//继续出栈符号和数字
//   number stack: *a  5
// operater stack: = 

//运算的最后一步，赋值操作 *a = 5
//表达式完成求值

上面的
number stack: 可以通过压入stack中实现
operater stack:可以通过递归调用的函数栈实现

parse_expr()函数：

int type; // pass type in recursive parse expr
void parse_expr(int precd) {   //precd会传入一个优先级，就是目前栈顶的operater的优先级，是个枚举变量对应的数值
    int tmp_type, i;
    int* tmp_ptr;
    // const number
    if (token == Num) {
        tokenize();
        *++code = IMM;
        *++code = token_val;
        type = INT;
    } 
    // const string
    else if (token == '"') {
        *++code = IMM;
        *++code = token_val; // string addr
        assert('"'); while (token == '"') assert('"'); // handle multi-row
        data = (char*)((int)data + 8 & -8); // add \0 for string & align 8
        type = PTR;
    }
    else if (token == Sizeof) { //这里把sizeof当成一个数据，因为sizeof的返回值是int
        tokenize(); assert('(');
        type = parse_base_type();
        while (token == Mul) {assert(Mul); type = type + PTR;}
        assert(')');
        *++code = IMM;
        *++code = (type == CHAR) ? 1 : 8; 
        type = INT;
    }
    // handle identifer: variable or function all
    else if (token == Id) { //如果token=Id，那么可能是变量，也有可能是函数调用
        tokenize();
        tmp_ptr = symbol_ptr; // for recursive parse
        // function call 函数调用
        if (token == '(') {
            assert('(');
            i = 0; // number of args
            while (token != ')') {
                parse_expr(Assign);
                *++code = PUSH; i++;
                if (token == ',') assert(',');
            } assert(')');
            // native call
            if (tmp_ptr[Class] == Sys) *++code = tmp_ptr[Value];
            // fun call
            else if (tmp_ptr[Class] == Fun) {*++code = CALL; *++code = tmp_ptr[Value];}
            else {printf("line %lld: invalid function call\n", line); exit(-1);}
            // delete stack frame for args
            if (i > 0) {*++code = DARG; *++code = i;}
            type = tmp_ptr[Type];
        }
        // handle enum value 存储数据的变量名
        else if (tmp_ptr[Class] == Num) {
            *++code = IMM; *++code = tmp_ptr[Value]; type = INT;
        }
        // handle variables
        else {
            // local var, calculate addr base ibp
            if (tmp_ptr[Class] == Loc) {*++code = LEA; *++code = ibp - tmp_ptr[Value];}
            // global var
            else if (tmp_ptr[Class] == Glo) {*++code = IMM; *++code = tmp_ptr[Value];}
            else {printf("line %lld: invalid variable\n", line); exit(-1);}
            type = tmp_ptr[Type];
            *++code = (type == CHAR) ? LC : LI;
        }
    }
    // cast or parenthesis
    else if (token == '(') {
        assert('(');
        if (token == Char || token == Int) {
            tokenize();
            tmp_type = token - Char + CHAR;
            while (token == Mul) {assert(Mul); tmp_type = tmp_type + PTR;}
            // use precedence Inc represent all unary operators
            assert(')'); parse_expr(Inc); type = tmp_type;
        } else {
            parse_expr(Assign); assert(')');
        }
    }
    // derefer
    else if (token == Mul) {
        tokenize(); parse_expr(Inc);
        if (type >= PTR) type = type - PTR;
        else {printf("line %lld: invalid dereference\n", line); exit(-1);}
        *++code = (type == CHAR) ? LC : LI;
    }
    // reference
    else if (token == And) {
        tokenize(); parse_expr(Inc);
        if (*code == LC || *code == LI) code--; // rollback load by addr
        else {printf("line %lld: invalid reference\n", line); exit(-1);}
        type = type + PTR;
    }
    // Not
    else if (token == '!') {
        tokenize(); parse_expr(Inc);
        *++code = PUSH; *++code = IMM; *++code = 0; *++code = EQ;
        type = INT;
    }
    // bitwise
    else if (token == '~') {
        tokenize(); parse_expr(Inc);
        *++code = PUSH; *++code = IMM; *++code = -1; *++code = XOR;
        type = INT;
    }
    // positive
    else if (token == And) {tokenize(); parse_expr(Inc); type = INT;}
    // negative
    else if (token == Sub) {
        tokenize(); parse_expr(Inc);
        *++code = PUSH; *++code = IMM; *++code = -1; *++code = MUL;
        type = INT;
    }
    // ++var --var 前置的++，--
    else if (token == Inc || token == Dec) {
        i = token; tokenize(); parse_expr(Inc);
        // save var addr, then load var val
        if (*code == LC) {*code = PUSH; *++code = LC;}
        else if (*code == LI) {*code = PUSH; *++code = LI;}
        else {printf("line %lld: invalid Inc or Dec\n", line); exit(-1);}
        *++code = PUSH; // save var val
        *++code = IMM; *++code = (type > PTR) ? 8 : 1;
        *++code = (i == Inc) ? ADD : SUB; // calculate
        *++code = (type == CHAR) ? SC : SI; // write back to var addr
    }
    else {printf("line %lld: invalid expression\n", line); exit(-1);}
    // use [precedence climbing] method to handle binary(or postfix) operators
    // 如果token优先级是比栈顶更高的话，就进入while循环
    while (token >= precd) {
        tmp_type = type;    
        // assignment 赋值
        if (token == Assign) {
            tokenize();
            if (*code == LC || *code == LI) *code = PUSH;
            else {printf("line %lld: invalid assignment\n", line); exit(-1);}
            parse_expr(Assign); type = tmp_type; // type can be cast
            *++code = (type == CHAR) ? SC : SI;
        }
        // ? :, same as if stmt
        else if (token == Cond) {
            tokenize(); *++code = JZ; tmp_ptr = ++code;
            parse_expr(Assign); assert(':');
            *tmp_ptr = (int)(code + 3);
            *++code = JMP; tmp_ptr = ++code; // save endif addr
            parse_expr(Cond);
            *tmp_ptr = (int)(code + 1); // write back endif point
        }
        // logic operators, simple and boring, copy from c4
        else if (token == Lor) {
            tokenize(); *++code = JNZ; tmp_ptr = ++code;
            parse_expr(Land); *tmp_ptr = (int)(code + 1); type = INT;}
        else if (token == Land) {
            tokenize(); *++code = JZ; tmp_ptr = ++code;
            parse_expr(Or); *tmp_ptr = (int)(code + 1); type = INT;}
        //                                   ↓ 把ax压入栈中  ↓递归调用，解析剩下的表达式 ↓完成递归回到这里就要计算对应operater的操作符了
        else if (token == Or)  {tokenize(); *++code = PUSH; parse_expr(Xor); *++code = OR;  type = INT;}
        else if (token == Xor) {tokenize(); *++code = PUSH; parse_expr(And); *++code = XOR; type = INT;}
        else if (token == And) {tokenize(); *++code = PUSH; parse_expr(Eq);  *++code = AND; type = INT;}
        else if (token == Eq)  {tokenize(); *++code = PUSH; parse_expr(Lt);  *++code = EQ;  type = INT;}
        else if (token == Ne)  {tokenize(); *++code = PUSH; parse_expr(Lt);  *++code = NE;  type = INT;}
        else if (token == Lt)  {tokenize(); *++code = PUSH; parse_expr(Shl); *++code = LT;  type = INT;}
        else if (token == Gt)  {tokenize(); *++code = PUSH; parse_expr(Shl); *++code = GT;  type = INT;}
        else if (token == Le)  {tokenize(); *++code = PUSH; parse_expr(Shl); *++code = LE;  type = INT;}
        else if (token == Ge)  {tokenize(); *++code = PUSH; parse_expr(Shl); *++code = GE;  type = INT;}
        else if (token == Shl) {tokenize(); *++code = PUSH; parse_expr(Add); *++code = SHL; type = INT;}
        else if (token == Shr) {tokenize(); *++code = PUSH; parse_expr(Add); *++code = SHR; type = INT;}
        // arithmetic operators
        else if (token == Add) {   // 加
            tokenize(); *++code = PUSH; parse_expr(Mul);
            // int pointer * 8
            if (tmp_type > PTR) {*++code = PUSH; *++code = IMM; *++code = 8; *++code = MUL;}
            *++code = ADD; type = tmp_type;
        }
        else if (token == Sub) {   // 减
            tokenize(); *++code = PUSH; parse_expr(Mul);
            if (tmp_type > PTR && tmp_type == type) {
                // pointer - pointer, ret / 8
                *++code = SUB; *++code = PUSH;
                *++code = IMM; *++code = 8;
                *++code = DIV; type = INT;}
            else if (tmp_type > PTR) {
                *++code = PUSH;
                *++code = IMM; *++code = 8;
                *++code = MUL;
                *++code = SUB; type = tmp_type;}
            else *++code = SUB;
        }
        else if (token == Mul) {tokenize(); *++code = PUSH; parse_expr(Inc); *++code = MUL; type = INT;}
        else if (token == Div) {tokenize(); *++code = PUSH; parse_expr(Inc); *++code = DIV; type = INT;}
        else if (token == Mod) {tokenize(); *++code = PUSH; parse_expr(Inc); *++code = MOD; type = INT;}
        // var++, var--   后置的++，--
        else if (token == Inc || token == Dec) {
            if (*code == LC) {*code = PUSH; *++code = LC;} // save var addr
            else if (*code == LI) {*code = PUSH; *++code = LI;}
            else {printf("%lld: invlid operator=%lld\n", line, token); exit(-1);}
            *++code = PUSH; *++code = IMM; *++code = (type > PTR) ? 8 : 1;
            *++code = (token == Inc) ? ADD : SUB;
            *++code = (type == CHAR) ? SC : SI; // save value ++ or -- to addr
            *++code = PUSH; *++code = IMM; *++code = (type > PTR) ? 8 : 1;
            *++code = (token == Inc) ? SUB : ADD; // restore value before ++ or --
            tokenize();
        }
        // a[x] = *(a + x)
        else if (token == Brak) {
            assert(Brak); *++code = PUSH; parse_expr(Assign); assert(']');
            if (tmp_type > PTR) {*++code = PUSH; *++code = IMM; *++code = 8; *++code = MUL;}
            else if (tmp_type < PTR) {printf("line %lld: invalid index op\n", line); exit(-1);}
            *++code = ADD; type = tmp_type - PTR;
            *++code = (type == CHAR) ? LC : LI;
        }
        else {printf("%lld: invlid token=%lld\n", line, token); exit(-1);}
    }
}
爱吃小酥肉的小波
关注
  • 7
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
手写C语言编译器，学习编译原理，写编译器（第六天)
lixiemang8887的博客
12-29 1364
实战flex和bison
手写一个C语言编译器
qq_23114283的博客
05-27 821
记录一个很好的C语言编译器项目地址 手把手教你构建 C 语言编译器（0）- 前言 | 三点水
手写编译器
qq_35975367的博客
01-27 448
假期没事想搞搞编译器，但学校课程未教过编译原理，自己只好在b站看了stanford的CS143《编译原理》，并结合相关资料，打算寒假期间自己手写一个简易的编译器 网络课程链接 网络教材相关资料链接 ...
【手写编译器】手写带图像界面GUI的简单编译器 C# C++混合编码 项目介绍 （DFA词法分析器+LR1语法分析
Taneeyo的博客
05-12 1990
【手写MIPS编译器】手写带图像界面GUI的简单编译器 C# C++混合编码 项目介绍 （DFA词法分析器+LR1语法分析 最终实现效果看这里 设计目标： 任务 1：创建一个词法分析程序，该程序支持分析常规单词。 任务 2：创建一个使用 LL(1) 方法或 LR(1) 方法的语法分析程序。 最终实现： 实验环境：Win10 IDE: VScode 、Visual Studio2019 编程语言：C++、C# 混合编程 (DLL) 一、简述 1.1 任务一：词法分析器 创建一个词法分析程序，它支持对正规
「700行手写编译器」Part 4：再看代码生成 笔记
最新发布
qq_55051321的博客
12-20 415
代码生成：解析完源代码，形成了相应的VM指令，在正式执行VM指令之前。 上图的左边的code区域会有这些数据，data区的数据在图的中间，除此之外其他的东西应该都是处在初始化的状态，比如寄存器、stack等。 上图的右边是symbol table，在代码解析完成之后，实际上就不会有任何意义或任何作用了，它的作用只是在衔接定义和使用lexeme，让函数执行过程中，该lexeme前后关系和属性对应起来。
简易编译器.rar_C编译器_site:www.pudn.com_手写编译器_简易编译器_编译器源码
07-15
C#手写源码简易编译器.rar，还是C#语言编写的。
compiler:用于类似 C++ 的语言的手写编译器
06-29
这是一个编译器。 它编译了一种非常类似 c++ 的语言，我称之为 c3。 它没有特定的目标，实际上只是一个我喜欢时不时参与的有趣项目。 在其当前状态下，它可以为 os x 编译功能程序（请参阅测试目录中的一些示例...
手写数学表达识别：手写数学表达式的分割，分类和解析。 适用于inkml格式
02-04
该项目旨在识别，划分，分类和解析手写数学表达式。 *项目的第一阶段，即单个数学符号的分类以及垃圾拒绝已于2018年3月5日完成。 *项目的第二阶段，即将表达式分割成单个符号并传递给分类器引擎，已于2018年4月8日...
离散数学手写笔记，建议收藏
11-02
本资源为离散数学的手写笔记，是作者精心整理的精华版，适合学习和复习使用。以下是笔记中可能涵盖的主要知识点： 1. **集合论**： - 集合的基本概念：集合、元素、子集、全集、空集。 - 集合的运算：并集、交集...
分析化学手写笔记.zip
07-09
这份“分析化学手写笔记.zip”压缩包包含了对这一领域的详细记录和理解，通过手写笔记的形式，可能更加直观地展示了学习者对分析化学概念的掌握和思考过程。 笔记可能涵盖以下几个关键知识点： 1. **化学分析方法*...
自己动手写的编译器
05-12
有分词处理，语义分析，语法分析，词法分析，错误提示等功能
树的搜索问题1（深度优先、广度优先，爬山法和best-first）
筱羊冰冰
12-27 4333
前言 我们在解决问题中经常使用到的数据结构一定少不了树，在数据结构这一大块中，我们对每一个结构都会讲各种形形色色的操作，比如栈的压栈出栈，树的各种遍历，但其实数据结构最重要的操作其实是搜索。如果我们不知道链表的搜索，如何插入删除？不知道图的搜索，如何寻找最小生成树？ 虽然我们讲的是树的搜索，但是本篇文章探讨的问题并非是树，而是将问题转化为树结构来处理。 树的几种常见搜索方式 我们先给出几种常用的例子吧。 布尔表达式，给一组布尔变量和一个用这些变量组成的布尔表达式，需要寻找一种赋值方式使表达式为真 8
「700行手写编译器」Part 1：项目背景与设计思路 笔记
qq_55051321的博客
12-17 909
因为视频的作者说原本是想让编译器实现比基础的C编译器更多的内容，但是实际上实现的比C编译要缩减，B站视频的作者说实际上应该是C minus，看到评论区里有人说C - -，蛮好玩的，遂给专栏起名C - -编译器。
「700行手写编译器」Part 3.2：语法分析与递归下降 笔记
qq_55051321的博客
12-18 415
我们在tokenize之后，看拿到的token是否符合S的解析规则，如果符合的话就逐步的解析它剩下的部分，①剩下的部分如果依然是S，那么就递归的调用parse_s继续做解析②如果剩下的部分是S’，那就调用parse_s’③或者不符合，就输出Symtax error。而token会把变量名a，b都记为Id，因此a，b的token是一样的。另外上面的Grammar没有带终结符，实际的Grammar中需要带终结符，这样解析的过程中，每一层解析都能至少解析掉一部分的token。：句子背后实际的含义。
手写SQL编译器 - Chapter 1
TCP404
10-24 1030
数据库是怎么工作的？ 当你打开这篇文章的时候你一定也好奇： SQL语句为什么能对数据库操作 事务回滚是怎么滚的？ 数据是怎么被保存到硬盘里的？ … 接下来我们将一步步搭建一个框架并逐渐完善，并尝试着把这些问题讲明白。 我选择基于 SQLite ，因为 SQLite 体积小又功能齐全，整个数据库就存储在一个文件中。 我认为可以以此为起点以小见大，启发大家对数据库有更多的思考。 一个 SQL 语句需要经过一连串的过程才能检索或修改数据。 前端包括： tokenizer 词法解析器 parser 语法解析
NO.79——BFS,DFS,Astar,爬山法,最抖爬山法,模拟退火法解决八数码问题Python实现
ghl1390490928的博客
02-09 1816
问题描述 无非就是将无序数列变成有序数列。 之间写过关于这个问题的解决办法，但是当时对各种算法理解的不是很透彻，比如广度优先算法和深度优先算法，同样都是维护一个open表，怎么用列表实现队列和栈的操作，那时候理解的不是很深，终于现在有些理解了。 Astar算法同样是维护一个open表，不过这个open表示一个优先级队列，每次取出的是代价最低的元素，然后再拓展它的邻居，然后再更新这个op...
21分钟学会写编译器
weixin_34220834的博客
08-20 998
本文来自网易云社区。   知乎上有一种说法是「编译器、图形学、操作系统是程序员的三大浪漫」。   先不管这个说法是对是错，我们假设一个程序员在国内互联网公司写代码，业余时间不看相关书籍。那么三年之后，他的这些知识会比在校时损耗多少？   很显然，损耗的比例肯定非常高，毕竟国内互联网公司日常开发工作中，程序员基本很少接触这三块知识。大部分程序员工作几年后对编译原理相关的概念只能生理上起反...
lol匹配算法
weixin_30876945的博客
12-08 983
这是Riot的Design Director Tom Cadwell专门为中国玩家写的讲解匹配系统工作原理的帖子。 同时为了让大家更好的理解匹配系统，如果您觉得您遇到了特别不公平的匹配，请回复游戏开始时间和比赛结束截图，我们会调查该局匹配是如何完成的，坑爹的玩家是为何加入到这一局的。 很多人抱怨看不懂，我来个精简比喻版的： 有个篮球联盟，有无数个球员和大概20个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

爱吃小酥肉的小波

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

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

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

打赏作者

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

抵扣说明：

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

余额充值