Golang 编译器代码浅析
  • 0. Golang 编译器代码浅析
  • 1. golang 编译器 - 前言
    • 1.1 编译器简介
    • 1.2 Golang 编译器
    • 1.3 Go 语言版本
    • 1.4 项目设置
    • 1.5 约定
    • 1.6 写作目的
  • 2. golang 编译器 - 词法分析
    • 2.1 简介
    • 2.2 代码结构
    • 2.3 处理字符
    • 2.4 扫描Token
    • 2.5 总结
  • 3.a 语法分析理论知识
    • 3A.1 语法分析简介
    • 3A.2 文法
    • 3A.3 语法解析
    • 3A.3.1 自顶向下(Top-Down)
    • 3A.3.2 自顶向下 - 递归下降
    • 3A.3.3 自顶向下 - LL(1)文法
    • 3A.3.4 自底向上(Bottom-Up)
    • 3A.3.5 自底向上 - LR(0)项集及SLR预测表
    • 3A.3.6 自底向上 - LR(1)、LALR
    • 3A.4 语法分析工具
    • 3A.5 总结
  • 3B. golang 编译器 - 语法分析
    • 3B.1 简介
    • 3B.2 代码结构
    • 3B.3 数据结构
    • 3B.4 构造语法树
    • 3B.5 Unit Test及AST可视化
  • 4. Golang 编译器 - 类型检查
    • 4.1 简介
    • 4.2 代码结构
    • 4.3 符号解析
    • 4.4.1 数据结构 - 作用域
    • 4.4.2 数据结构 - Package
    • 4.4.3 数据结构 - Object 对象
    • 4.4.4-1 类型数据结构 - 简介
    • 4.4.4-2 类型接口
    • 4.4.4-3 基础类型
    • 4.4.4-4 内置复合类型
    • 4.4.4-5 Struct 类型
    • 4.4.4-6 Interface 类型
    • 4.4.4-7 Named 类型
    • 4.4.4-8 Tuple 类型
    • 4.4.4-9 Sum 类型
    • 4.4.4-10 Function & Method 类型
    • 4.4.4-11 泛型类型
    • 4.4.4-12 类型的等价规则
    • 4.4.4-13 类型的比较规则
    • 4.4.4-14 总结
    • 4.4.5 类型检查器
    • 4.4.6 总结
    • 4.5.1 类型检查逻辑 - 包加载器
    • 4.5.2 类型检查逻辑 - 初始化
    • 4.5.2-1 全局作用域
    • 4.5.2-2 类型检查器
    • 4.5.3 类型检查逻辑 - 流程分析
    • 4.5.3-1.1 总体流程
    • 4.5.3-1.2 类型检查准备工作
    • 4.5.3-1.3 类型检查核心逻辑
    • 4.5.3-1.3a 总体介绍
    • 4.5.3-1.3b 类型表达式的类型检查
    • 4.5.3-1.3c 求值表达式的类型检查
    • 4.5.3-1.3d 类型兼容性检查
    • 4.5.3-1.3e 处理delayed队列
    • 4.5.3-1.4 构建初始化顺序
    • 4.5.3-1.5 总结
    • 4.5.3-2 特定问题分析
    • 4.5.3-2a 对象循环依赖检查
    • 4.5.3-2b 方法与属性查找
    • 4.5.3-2c Underlying Type
    • 4.6 如何测试
    • 4.7 总结
  • 5. Golang 编译器 - IR Tree
    • 5.1 简介
    • 5.2 代码结构
    • 5.3 数据结构
    • 5.4 处理逻辑
    • 5.5 编译日志
    • 5.6 Unit Test
    • 5.7 总结
  • 6. golang 编译器 - 初始化任务
    • 6.1 简介
    • 6.2 代码结构
    • 6.3 总体逻辑
    • 6.4 赋值语句
    • 6.5 编译日志
    • 6.6 Unit Test
    • 6.7 总结
  • 7. golang 编译器 - 清除无效代码
    • 7.1 简介
    • 7.2 处理逻辑
    • 7.3 Unit Test
  • 8. golang 编译器 - Inline
    • 8.1 简介
    • 8.2 Inline的问题
    • 8.3 代码结构
    • 8.4 处理逻辑
    • 8.4.1 遍历调用链
    • 8.4.2 内联判断
    • 8.4.3 内联操作
    • 8.4.4 编译日志
    • 8.4.5 Unit Test
    • 8.4.6 总结
  • 9. golang 编译器 - 逃逸分析
    • 9.1 什么是逃逸分析
    • 9.2 Go 的逃逸分析
    • 9.3 算法思路
    • 9.4 代码结构
    • 9.5 处理逻辑
    • 9.5.1总体逻辑
    • 9.5.2 数据结构
    • 9.5.3 构建数据流有向图
    • 9.5.4 逃逸分析
    • 9.6 编译日志
    • 9.7 Unit Test
    • 9.8 总结
  • 10. golang 编译器 - 函数编译及导出
    • 10.1 简介
    • 10.2 编译函数
    • 10.2.1 SSA
    • 10.2.2 ABI
    • 10.2.3 并发控制
    • 10.3 导出对象文件
    • 10.4 总结
  • 11. Golang 编译器 - 写在最后
由 GitBook 提供支持
在本页
  • 3.2.1 定义
  • 3.2.2 上下文无关文法 - Context-Free Grammar(CFG)
  • 3.2.3 推导 - Derivation
  • 3.2.4 解析树 - Parse Tree

这有帮助吗?

  1. 3.a 语法分析理论知识

3A.2 文法

3.2.1 定义

自然语言有明确的语法,用来约束如何构建一个合法的句子。程序语言也一样,这个控制程序结构的规则叫着文法。文法是用来定义形式语言结构的规则,其规范的定义如下:

  1. 一个终结符号集合, 例如:英文字母

  2. 一个非终结符号集合,也被叫着文法变量

  3. 产生式,符号的转换规则,通用形式为:α -> β,其中 α 与 β 可以是任意形式的符号串。例如 S ->(),表示任何 S 都可以被一个括号对替换。产生式的右边可以是终结符号与非终结符号的任意组合

  4. 开始符号

概括地说,文法就是生成符号串的规则。

3.2.2 上下文无关文法 - Context-Free Grammar(CFG)

程序语言的文法通常使用一种叫着上下文无关文法的形式来表示。其对产生式做了如下限制:α -> β 中,α 只能是一个非终结符号。这也是“上下文无关”的意义:使用产生式将任意非终结符号 A 替换为其他符号串时,跟 A 所在的位置、以及 A 旁边的符号无关。

例如下面文法就是上下文无关文法,用来生成任意的合法括号对:

S -> (S) | SS | ()

其中:

  1. 终结符号集合:由 "(" 与 ")" 组成

  2. 非中介符号集合:只有 S

  3. 产生式有三个

  4. 开始符号:S

对编译器而言,任何源程序都是一个字符串,程序语言的文法确定了程序的合法结构。只是程序文法中的终结符号不是单个字母,而是词法分析的输出结果:Token

3.2.3 推导 - Derivation

通过文法生成一个字符串的整个过程被称为一个推导。考虑上面生成括号对的文法:S ->(S)-> (SS)->(()S)->(()())就是一个推导。

  • 最左推导 每次都使用最左边的非终结符号进行推倒的过程,例如下面就是一个最左推导:

    S -> SS ->()S ->()(S)->()(())

  • 最右推导 每次都使用最右边的非终结符号进行推倒的过程,例如下面就是一个最右推导:

    S -> SS -> S(S)-> S(())->()(())

3.2.4 解析树 - Parse Tree

解析树是一个推导过程的可视化,其叶子节点都是终结符号,中间节点都是非终结符号,叶子节点从左到右的排列就是被推导的终结符号串。如下例:

推导:S -> SS -> S(S)-> S(())->()(())解析树:

解析树只反映了整个字符串的推导方式,并没有体现其推导顺序。例如根据上面的解析树无法得知采用的是最左推导还是最右推导。

上一页3A.1 语法分析简介下一页3A.3 语法解析

最后更新于3年前

这有帮助吗?

Parse Tree