# 引论

# 什么是编译程序

# 编译程序

编译程序是翻译程序的一种,它将高级语言程序翻译成等价的目标程序。编译程序的输入是高级语言程序,输出是目标程序。编译程序的主要任务是将源程序翻译成目标程序,使得目标程序能够在计算机上正确运行。

# 解释程序

以源程序为输入,直接执行源程序,不生成目标程序。解释程序的主要任务是解释源程序,使得源程序能够在计算机上正确运行。

# 编译程序与解释程序的区别

根本区别:是否生成目标程序。

# 编译系统的组成

  • 编译程序
  • 运行系统
    • 支持环境
    • 运行库

# 编译过程与编译程序的组织结构

# 编译过程

自然语言的翻译 编译
识别出句子中的单词 词法分析
确定单词之间的语法关系 语法分析
根据句子含义初步翻译 语义分析
对译文进行修饰 中间代码生成
将译文翻译成目标语言 目标代码生成

图 0

# 词法分析

输入源程序;扫描、分解字符串,识别出单词;输出单词流。

词法分析由词法分析器完成,词法分析器又叫扫描器。

词法分析器从左到右扫描源程序,并将其转换成单词(Token)串;并检查词法错误,进行标识符的登记 —— 符号表管理。

输入:字符串
输出:(种别码,属性值)

# 语法分析

语法分析由语法分析器完成,语法分析器又叫解析器。

功能:

  • 实现组词成句
  • 构造分析树
  • 检查语法错误
  • 指导翻译

输入:Token 序列
输出:语法成分

语法分析树和抽象语法树的区别:

  • 语法分析树:包含了源程序中的所有细节、语法成分。
  • 抽象语法树:去掉了源程序中的细节,只保留了语法结构的关键信息。(中间代码的一种形式)

# 语义分析

语义分析一般和语法分析一起进行,称为语法制导翻译。

功能:

  • 获取标识符的属性
  • 语义检查
  • 子程序静态绑定
  • 变量的静态绑定

# 中间代码生成

生成四元式、三地址码、P - 代码等。

# 目标代码生成

任务:将中间代码变换成特定机器上的低级语言代码

目标代码形式:绝对指令、可重定位指令、汇编指令

# 表格与表格管理

  • 符号名表
  • 常数表
  • 标号表
  • 入口名表
  • 过程引用表
  • 循环表
  • 等价名表
  • 公用链表
  • 格式表
  • 中间代码表

# 出错处理

  • 语法错误:不符合语法(或词法)规则
  • 语义错误:不符合语义规则

# 遍

遍:编译程序对源程序的从头到尾扫描一次,并作有关的加工处理,生成新的中间结果或目标程序。

图 1

# 前端与后端

  • 前端:词法分析、语法分析、语义分析、中间代码生成,与源语言有关
  • 后端:目标代码生成、优化,与目标机器有关

# 自举技术

编译程序的编译程序完全是由这个语言本身编写的,而且能够编译这门语言的任何代码。

# 自展技术

先对语言的核心部分构造一个小小的编译程序,然后用这个编译程序编译语言的其他部分。

# 移植技术

编译程序的移植性是指编译程序能够在不同的计算机上运行。

# 形式语言与自动机

# 形式语言

# 语言

  • 语言(Language):满足一定条件的句子的集合
  • 句子(Sentence):满足一定规则的单词的序列
  • 单词(Token):满足一定规则的字符串

语言就是字和组合字的规则所产生的字的序列。

# 文法、语言、自动机

图 2

  • 0 型文法:递归可枚举语言,图灵机
  • 1 型文法:上下文相关语言,线性有界自动机

    SA→SSS→aA→aS A \rightarrow S S \\ S \rightarrow a \\ A \rightarrow a

  • 2 型文法:上下文无关语言,下推自动机,例如A→βA\to \beta
  • 3 型文法:正规语言,有限自动机,例如A→αBA\to \alpha B

# 程序语言

程序语言是一个记号系统

# 语法
  • 任何程序语言都可以看成一定字符集上的字符串
  • 语法保障了这串字符的合法性
  • 语法 = 词法规则 + 语法规则
# 词法
  • 单词符号:语言中具有意义的最基本结构
  • 词法规则
    • 规定了字母表中的字符如何组成单词符号
    • 程序语言的单词符号包括:常数、标识符、关键字、运算符、分节符等
    • 使用正规式和有限自动机理论描述词法结构和词法分析
# 语法规则
  • 语法单位:表达式、子句、语句、函数、过程、程序
  • 语法规则
    • 规定了如何从单词符号构成语法单位
    • 使用上下文无关文法描述语法结构和语法分析
    • 语言的词法规则和语法规则共同定义了程序的形式结构,是判断输入字符串是否都成一个形式上正确的程序的依据
# 语义
  • 程序中单词符号和语法单位的含义
  • 不同语言形式上语法单位相似,但含义可能不同
  • 对于某种语言,可以定义一个程序的意义的一组规则,称为语义规则
  • 目前大多数编译程序使用基于属性文法的语法制导翻译来分析语义
# 字母表

字母表是符号的非空有限集合,通常用 Σ\Sigma 表示。

# 字母表的运算

字母表Σ,Σ1,Σ2\Sigma, \Sigma_1, \Sigma_2 的运算:

  • 连接 / 乘积:Σ1Σ2={xy∣x∈Σ1,y∈Σ2}\Sigma_1\Sigma_2 = \{xy | x \in \Sigma_1, y \in \Sigma_2\}
  • 幂:Σn={x1x2⋯xn∣xi∈Σ}\Sigma^n = \{x_1x_2\cdots x_n | x_i \in \Sigma\},其中n=0n=0 时,Σ0={ε}\Sigma^0 = \{\varepsilon\}
  • 正闭包,记作Σ+\Sigma^+:Σ+=Σ1∪Σ2∪⋯\Sigma^+ = \Sigma^1\cup\Sigma^2\cup\cdots
  • Kleene 闭包,记作Σ∗\Sigma^*:Σ∗=Σ0∪Σ+=Σ0∪Σ1∪Σ2∪⋯\Sigma^* = \Sigma^0\cup\Sigma^+=\Sigma^0\cup\Sigma^1\cup\Sigma^2\cup\cdots

# 符号串

由字母表中的符号所组成的任何有穷序列称为符号串。也叫做字母表上的句子。

# 符号串的形式定义
  • 字母表Σ\Sigma 上的字符是Σ\Sigma 上的符号串
  • 若xx 是Σ\Sigma 上的符号串,aa 是Σ\Sigma 上的字符,则x⋅ax\cdot a 是Σ\Sigma 上的符号串
  • yy 是Σ\Sigma 上的符号串,当且仅当它是由上述规则生成的
# 符号串的术语
  • 前缀:移走ss 尾部的零个或多个字符得到的串称为ss 的前缀
  • 后缀:移走ss 头部的零个或多个字符得到的串称为ss 的后缀
  • 子串:从ss 中删去一个前缀和一个后缀得到的串称为ss 的子串
  • 真前缀、真后缀、真子串:不等于ss 和ε\varepsilon 的前缀、后缀、子串
  • 子序列:从ss 中任意删除零个或多个字符得到的串称为ss 的子序列
  • 长度:符号串的字符个数称为该串的长度,记作∣s∣|s|
# 句子和语言
  • 句子:字母表上符合某种规则构成的符号串
  • 语言:确定字母表上字符串的集合,即句子的集合,即∀L⊆Σ∗\forall L\subseteq\Sigma^*
# 符号串的运算
  • 连接:设x,yx,y 是Σ\Sigma 上的符号串,它们的连接xyxy 是xx 后接yy 的符号串
  • 方幂:设xx 是Σ\Sigma 上的符号串,nn 是非负整数,xnx^n 是xx 的nn 次方幂,即xx 连接自身nn 次
# 语言的运算
  • 并:L∪M={x∣x∈Lorx∈M}L\cup M = \{x|x\in L or x\in M\}
  • 连接:LM={xy∣x∈Landy∈M}LM = \{xy|x\in L and y\in M\}
  • 方幂:Ln={xn∣x∈L}L^n = \{x^n|x\in L\}
  • Kleene 闭包:L∗=L0∪L1∪L2∪⋯L^* = L^0\cup L^1\cup L^2\cup\cdots
  • 正闭包:L+=L1∪L2∪⋯L^+ = L^1\cup L^2\cup\cdots

# 文法

字和组合的字规则,是描述语言的语法结构的形式化规则。

# BNF 范式

巴科斯 - 诺尔范式(Backus-Naur Form,BNF)是一种用于表示上下文无关文法的语言。

用 ::= 或 -> 表示 “定义为”,用 | 表示 “或”, | 两边的成分叫做候选式,用 <> 表示非终结符。

# 语法规则的推导

由规则推导句子:从一个要识别的符号开始,用相应规则的右部替换左部,直到推导出句子,每次仅用一个规则。推导一直进行到句子中不再有非终结符为止。

# 文法的形式定义

  • 文法GG 是一个四元组G=(VT,VN,P,S)G=(V_T,V_N,P,S)
    • VTV_T:非空有穷终结符集合
    • VNV_N:非空有穷非终结符集合且VT∩VN=∅V_T\cap V_N=\varnothing
    • SS:开始符号,S∈VNS\in V_N
    • PP:产生式的非空有穷集合,每个产生式是一个形如A→αA\to\alpha 的规则,其中A∈VN,α∈(VT∪VN)∗A\in V_N,\alpha\in(V_T\cup V_N)^*,开始符号SS 必须至少出现在一个产生式的左部
  • A,B,C 等大写字母表示非终结符
  • a,b,c 等小写字母表示终结符
  • α\alpha,β\beta,γ\gamma 等希腊字母表示文法符号串(终结符和非终结符组成的串)

# 直接推导和推导

令G=(VT,VN,S,P),S⇒αAβG=(V_T, V_N, S, P), S\Rightarrow\alpha A\beta,

  • 若A→γ∈PA\rightarrow\gamma\in P,则称αAβ\alpha A\beta 直接推导出αγβ\alpha\gamma\beta,记作αAβ⇒αγβ\alpha A\beta\Rightarrow\alpha\gamma\beta,同时称αγβ\alpha\gamma\beta 直接由αAβ\alpha A\beta 推导出,或称αγβ\alpha\gamma\beta 直接规约为αAβ\alpha A\beta
  • 如果存在一个直接推导的有限序列α0⇒α1⇒α2⇒⋯⇒αn\alpha_0\Rightarrow\alpha_1\Rightarrow\alpha_2\Rightarrow\cdots\Rightarrow\alpha_n,表示成α1⇒+αn\alpha_1\xRightarrow{+}\alpha_n,则称从α0\alpha_0 到αn\alpha_n 的长度为nn 的推导。α0⇒∗αn\alpha_0\xRightarrow{*}\alpha_n 表示从α0\alpha_0 的经 0 步或多步推导得到αn\alpha_n

# 最左推导和最右推导

  • 最左推导:αAβ⇒αγβ(A→γ),α∈VT∗\alpha A\beta\Rightarrow\alpha\gamma\beta(A\rightarrow\gamma),\alpha\in V_T^*,每次推导都是用最左边的非终结符推导
  • 最右推导:αAβ⇒αγβ(A→γ),β∈VT∗\alpha A\beta\Rightarrow\alpha\gamma\beta(A\rightarrow\gamma),\beta\in V_T^*,每次推导都是用最右边的非终结符推导,也称为规范推导

# 语言的形式定义

设文法G=(VT,VN,P,S)G=(V_T,V_N,P,S),如果S⇒∗αS\xRightarrow{*}\alpha,则称α\alpha 是一个句型。仅含终结符的句型称为句子。

语言L(G)L(G) 是文法GG 的所有句子的集合:L(G)={α∣S⇒+α且α∈VT∗}L(G)=\{\alpha|S\xRightarrow{+}\alpha\text{且}\alpha\in V_T^*\}

# 短语、直接短语和句柄

令GG 是一个文法,如果有S⇒∗αAγ且A⇒+βS\xRightarrow{*}\alpha A\gamma\text{且}A\xRightarrow{+}\beta,则称β\beta 是句型αβγ\alpha\beta\gamma 的相对于非终结符AA 的短语

特别是,如果有A→βA\rightarrow\beta,则称β\beta 是句型αβγ\alpha\beta\gamma 的相对于A→βA\rightarrow\beta 的直接短语,一个句型的最左直接短语称为句型的句柄

# 分析树

设G=(VT,VN,P,S)G=(V_T,V_N,P,S) 是一个上下文无关文法,GG 的一个分析树是一个有根树,满足以下条件:

  • 每个节点有个标记,是VT∪VN∪{ε}V_T\cup V_N\cup\{\varepsilon\} 的元素
  • 根节点标记为SS
  • 如果节点是内部节点,则其标记AA 必在VNV_N 中
  • 如果编号为nn 的节点标记为An1,n2,⋯ ,nkA_{n_1,n_2,\cdots,n_k} 是节点nn 从左到右的儿子,并分别标有X1,X2,⋯ ,XkX_1,X_2,\cdots,X_k,则A→X1X2⋯XkA\rightarrow X_1X_2\cdots X_k 必须是PP 中的一个产生式
  • 如果节点nn 有标记ε\varepsilon,则nn 必须是叶节点,且是他父亲的唯一儿子,其他叶子节点是VTV_T 中的元素(终结符)

# 子树

一棵分析树中一个特有节点连同他的全部后裔,连接这些节点的边和边上的标记称为这个节点的子树。

# 从语法树看短语、直接短语和句柄

  • 短语:一棵子树的所有叶子从左至右排列起来形成一个相对于该子树根节点的串。
  • 直接短语:如果一棵子树只有两代,它的叶子从左至右排列起来形成的串。
  • 句柄:一个句型的分析树中,最左那棵两代子树的叶子从左至右的排列。

找到句型的短语:找分析树的所有子树

  1. 最左推导和最右推导的语法树是否相同?

尽管推导顺序不同,两者生成的语法树是一样的,因为语法树表示的是推导过程中应用的规则和它们的结构关系,而不是推导的具体顺序。因此,不管是最左推导还是最右推导,最终语法树的形状和结构都相同,表示句子中的层次关系。

# 二义性

证明二义性最好画出分析树,看看是否有两种不同的分析树。

如果一个文法存在两个不同的分析树,那么这个文法是二义的。如果一个文法包含二义性句子,那么这个文法是二义的。

# 自动机

# 有限自动机

# 有限自动机基本组成
  • 有限自动机(FA)是一种识别装置,能准确识别正规文法,为词法分析程序提供了方法和工具。
  • 离散输入输出系统,具有有限数目的内部状态
  • 根据当前所处的状态和面临的输入字符决定系统的后继行为。

图 3

# 有限自动机工作原理
  • 状态为初始状态、中间状态和终止状态。
  • 可以有若干个终止状态。
  • 只能有一个初始状态。
# 状态转换图

状态用节点表示,输入符号用边表示,两个圈表示终止状态。

图 4

# 确定的有限自动机(DFA)

# DFA 的定义
  • 一个确定的有限自动机是一个五元组M=(Σ,S,S0,Z,f)M=(\Sigma, S, S_0, Z, f)
    • Σ\Sigma:输入字母表
    • SS:有限状态集合
    • S0S_0:初始状态
    • ZZ:终止状态集合
    • ff:状态转移函数,从S×ΣS\times\Sigma 到SS 的映射,f(q,a)=q′f(q,a)=q' 表示从状态qq 经过输入aa 转移到状态q′q',q′q' 称为状态qq 的后继状态
# DFA M 接受的语言
  • 如果对所有的输入字符串w∈Σ∗w\in\Sigma^*,以下述方式递归地对 DFA M 扩充ff 的定义:
    • f(q,ε)=qf(q,\varepsilon)=q
    • f(q,wa)=f(f(q,w),a)f(q,wa)=f(f(q,w),a)
# DFA M 所识别的语言

从状态转换图看,从初态出发,沿任一条路径到达终结状态,这条路径上的弧上的标记符号连接起来构成的符号串是 DFA M 所识别的语言。

DFA M 所识别的符号串的全体记作L(M)L(M),即L(M)={w∣w∈Σ∗,若存在q∈Z使得f(q0,w)=q}L(M)=\{w|w\in\Sigma^*,\text{若存在}q\in Z\text{使得}f(q_0,w)=q\}

# 非确定的有限自动机(NFA)

# NFA 的定义
  • 一个非确定的有限自动机是一个五元组M=(Σ,S,S0,Z,f)M=(\Sigma, S, S_0, Z, f)
    • Σ\Sigma:输入字母表
    • SS:有限状态集合
    • S0S_0:初始状态
    • ZZ:终止状态集合
    • ff:状态转移函数,从S×(Σ∪{ε})S\times(\Sigma\cup\{\varepsilon\}) 到2S2^S 的映射,其中2S2^S 表示SS 的幂集,即SS 的所有子集的集合。

NFA 和 DFA 的区别:

  • 状态转移函数的定义不同,NFA 是一个多值映射;反映到状态转移图上,NFA 对同一弧标记到达的状态可以有多个。
  • NFA 初态集,而 DFA 只有一个初态。NFA 存在ε\varepsilon 转移。
# NFA M 接受的语言

如果f(q,a)={q1,q2,⋯ ,qk}f(q,a)=\{q_1,q_2,\cdots,q_k\},则从状态qq 经过输入aa 可以转移到状态q1,q2,⋯ ,qkq_1,q_2,\cdots,q_k 中的任意一个。

# NFA M 所识别的语言

L(M′)={α∣f(q0,α)=q,q∈Z}L(M')=\{\alpha|f(q_0,\alpha)=q,q\in Z\}

# FA 的等价定理

对于任何 NFA M,都存在一个 DFA M',使得L(M)=L(M′)L(M)=L(M')。

NFA 和 DFA 的区别:

比较项 DFA NFA
初始状态 唯一 多个
弧上的标记 输入符号 输入符号或 ε\varepsilon
转换关系 确定 非确定

# 具有ε\varepsilon - 转移的 NFA 构造 DFA 的方法

集合II 的ε\varepsilon - 闭包定义:

  • 令II 是一个状态集的子集,定义II 的ε-closure(I)\varepsilon\text{-closure}(I)
    • 若s∈Is\in I,则s∈ε-closure(I)s\in \varepsilon\text{-closure}(I)
    • 若s∈Is\in I,则从ss 出发的所有ε\varepsilon - 转移的状态都在ε-closure(I)\varepsilon\text{-closure}(I) 中

设aa 是Σ\Sigma 中的一个符号,定义Ia=ε-closure(J)I_a = \varepsilon\text{-closure}(J),其中J=f(I,a)J=f(I,a)

图 5

# 构造方法

确定化:不失一般性,设字母表Σ\Sigma 中的符号是a,ba,b,

  • 首先,置第一行第一列为ε-closure({X})\varepsilon\text{-closure}(\{X\}),求出这一列的IaI_a 和IbI_b,
  • 然后,检查这两个IaI_a 和IbI_b 是否在第一列中,如果不在,就加入到第一列中,然后求出这两个IaI_a 和IbI_b 的IaI_a 和IbI_b,如此循环下去,直到没有新的II 加入为止。
II IaI_a IbI_b
ε-closure({X})\varepsilon\text{-closure}(\{X\}) _ _
_ _ _
# 等价分析
  • 把表看成状态转移矩阵,子集视为状态
  • 转换表唯一刻画了一个 DFA M
    • 初态是ε-closure({X})\varepsilon\text{-closure}(\{X\})
    • 终态是包含原终态YY 的子集

图 6

# DFA 的最小化

# DFA 的最小化定义

DFA M=(Σ,S,S0,Z,f)(\Sigma, S, S_0, Z, f) 的化简是指寻找一个状态数比较少的 DFA M',使L(M)=L(M′)L(M) = L(M')

一个 DFA M 的最小化是指他没有多余状态并且没有相互等价的状态。

# DFA 的多余状态(无关状态)
  1. 从开始状态出发,任何输入串也不能到达的那个状态
  2. 从该状态出发没有通向终态的道路
# DFA 的等价状态

设p,q∈Sp,q \in S,如果对于任何输入符号w∈Σ∗w\in\Sigma^*,f(p,w)f(p,w) 和f(q,w)f(q,w) 同时到达终态或同时不到达终态,则称状态pp 和qq 是等价的。

判断pp 和qq 不等价:只要存在一个输入符号w∈Σ∗w\in\Sigma^*,使得f(p,w)∈Zf(p,w)\in Z 而f(q,w)∉Zf(q,w)\notin Z,或者f(p,w)∉Zf(p,w)\notin Z 而f(q,w)∈Zf(q,w)\in Z。

若SiS_i 为自动机MM 的一个状态集,我们把从SiS_i 出发能导出的所有符号串集合记为L(Si)L(S_i),若有L(Si)=L(Sj)L(S_i)=L(S_j),则称SiS_i 和SjS_j 等价。

picture 7

  • 终结状态和非终结状态不等价
  • 对于∀a∈Σ\forall a\in\Sigma,f(p,a)=rf(p,a) = r,f(q,a)=sf(q,a) = s,若rr 和ss 等价,则pp 和qq 等价
  • 对于∀a∈Σ\forall a\in\Sigma,f(p,a)=rf(p,a) = r,f(q,a)=sf(q,a) = s,若rr 和ss 不等价,则pp 和qq 不等价
# 可区别状态

自动机的两个状态SiS_i 和SjS_j,如果他们不等价,则称他们是可区别的。

picture 8

# 分割法

把一个 DFA(不含多余状态)的状态分割成一些不相关的子集,使得任何不同的两个子集状态都是可区别的,而同一个子集中的任何状态都是等价的。在各个子集中任取一个状态做代表,删去子集的其余状态。

  1. 首先将终态和非终态分开,分为Π={Z,S−Z}\Pi = \{Z, S-Z\}
  2. 对Π\Pi 中的每个集合GG,GG 中任意两个状态SiS_i 和SjS_j 在同一组中,当且仅当对于∀a∈Σ\forall a\in\Sigma,f(Si,a)f(S_i,a) 和f(Sj,a)f(S_j,a) 在同一组中,否则将SiS_i 和SjS_j 分开,用GG 替换原来的集合
  3. 重复第 2 步,直到不能再分为止
  4. 合并等价状态,在每个GG 中任取一个状态作为代表,删去GG 中其余状态
  5. 删去多余状态,从其他状态到无关状态到转换都成为无定义

# NFA 的最小化

NFA 化为 DFA,然后再对 DFA 进行最小化。

# 词法分析

# 词法分析的功能

对源程序进行从左到右的顺序扫描,按照词法规则从中识别出一个个具有独立意义的单词符号并把源程序转换为等价的内部表示形式(属性字流)。

  • 识别单词符号
  • 过滤掉源程序中的注释和空白符
  • 对数字字符串转换为二进制数
  • 记录读入字符的行号和列号,以便编译程序输出错误信息时能够准确指出错误位置
  • 进行预编译
  • 符号表操作和错误处理

# 实现词法分析的方案

  1. 词法分析单独作为一遍(优点:结构清晰,各遍功能单一;缺点:生成中间文件,效率低)
    picture 9
  2. 词法分析程序作为单独的子程序
    picture 10

# 预处理 —— 扫描缓冲区

  • 两个半区互补使用:搜索指针从单词起点开始搜索,如果遇到半区域的边界,但尚未到达单词的终点时,则可将后续的输入字符装入该缓冲区的另一半
    picture 11
If f at end of first half {
  reload second half;
  F++;
} Else if F at end of second half {
  reload first half;
  move F to beginning of first half;
} Else {
  F++;
}

# 单词的描述和识别

# 单词的种类

  • 保留字
  • 标识符
  • 常数
  • 运算符
  • 界限符

# 词法分析程序的输出形式

常用的单词内部表示形式:

  • 按单词种类分类
  • 保留字和分界符一符一类
  • 标识符和长处的单词属性值作为符号表入口指针(标识符、常数相关属性很多)

# 出错处理

  • 非法字符检查
  • 关键字拼写错误检查
  • 不封闭错误检查
  • 重复说明错误检查
  • 错误恢复与续编译

# 正规式(Regular Expression)

正则表达式是一种描述字符串特征的表达式,是一种用来描述字符串的方法。

正则表达式可以有较小的正则表达式递归地构建,每个正则表达式rr 都可以用来描述一个语言L(r)L(r)。

# 正规集
  1. ∅\varnothing 和ε\varepsilon 都是Σ\Sigma 上的正规表达式,他们所表示的语言分别为{}\{\} 和{ε}\{\varepsilon\}
  2. 对于∀a∈Σ\forall a\in\Sigma,aa 是Σ\Sigma 上的正规表达式,他所表示的语言为{a}\{a\}
  3. 如果rr 和ss 是Σ\Sigma 上的正规表达式,那么r∣sr|s,rsrs,r∗r^* 都是Σ\Sigma 上的正规表达式,他们所表示的语言分别为L(r)∪L(s)L(r)\cup L(s),L(r)L(s)L(r)L(s),L(r)∗L(r)^*

一个由正规表达式定义的语言称为正规集或正规语言。

# 正规式的代数性质
  • 交换律:r∣s=s∣rr|s=s|r
  • 结合律:(r∣s)∣t=r∣(s∣t)(r|s)|t=r|(s|t)
  • 分配律:r(s∣t)=rs∣rtr(s|t)=rs|rt
  • 幂等律:r∣r=rr|r=r,r∗=(r∣r)∗=r∗r∗r^*=(r|r)^*=r^*r^*,(r∗)∗=r∗(r^*)^*=r^*
# 正则定义
  • 正则定义:正规表达式是由正规集上的运算符和正规集中的元素组成的表达式

d1→r1d2→r2⋯dn→rn\begin{aligned} d_1 &\to r_1\\ d_2 &\to r_2\\ &\cdots\\ d_n &\to r_n \end{aligned}

  • 其中d1,d2,⋯ ,dnd_1,d_2,\cdots,d_n 是新符号,都不在Σ\Sigma 中,r1,r2,⋯ ,rnr_1,r_2,\cdots,r_n 是Σ∪{d1,d2,⋯ ,dn}\Sigma\cup\{d_1,d_2,\cdots,d_n\} 上的正规表达式
# 正规文法⇒\Rightarrow 正规式
规则 文法产生式 正规式
1 A→xB,B→yA\to xB, B\to y A=xyA=xy
2 A→xA∣yA\to xA\mid y A=x∗yA=x*y
3 A→x,A→yA\to x, A\to y A=x∣yA=x\mid y
# 正规式⇒\Rightarrow 正规文法
  1. 对任何正规表达式rr,选择一个非终结符SS 作为识别符号。并构建正规定义式S→rS\to r
  2. 若x,yx,y 是正规表达式,A→xyA\to xy 重写为A→xB,B→yA\to xB,B\to y,A→x∗yA\to x*y 重写为A→xA,A→yA\to xA,A\to y,其中BB 是新的非终结符

# 正规式与有限自动机

定理:设rr 是Σ\Sigma 上一个正规表达式,则存在一个 FA MM 接受L(r)L(r)。反之亦然。

正规文法,正规表达式和有限自动机三者之间在表示语言的意义下是等价的。

字母表Σ\Sigma 上的一个正规语言,既可以由某一个正规文法产生,也可以由某一个正规表达式所表示,还可以由某一个有限自动机识别。

# 转换法实现正规式与有限自动机的转换

# 从正规式到 NFA 的转换规则

对于Σ\Sigma 上任一正规表达式rr,一定能构造一个 NFA MM,使得L(r)=L(M)L(r)=L(M)。

  • 首先把转换图的概念拓广,每条弧上可以用一个正规式标记,对 NFA MM 构造一个广义的转换图。其中只有开始状态SS 和终止状态ZZ,连接SS 和ZZ 的有向弧上是正规式rr。
  • 然后按照下面的替换规则对正规式不断进行分解,不断加入状态结点和箭弧,直到转换图上的所有弧标记都是Σ\Sigma 上的元素或ε\varepsilon 为止。

picture 12

# 从 NFA 到正规式的替换规则

对于Σ\Sigma 上任一 NFA MM,能构造Σ\Sigma 上一个正规表达式 rr,使得L(r)=L(M)L(r) = L(M)。

  • 首先,在MM 的转换图上加进SS,ZZ 两个节点。从SS 用ε\varepsilon 弧连接到MM 的所有初态结点,从MM 的所有终结(接受)结点用ε\varepsilon 弧连接到ZZ,从而构成一个新的 NFA M′M',L(M)=L(M′)L(M) = L(M')。
  • 反复使用下面的替换规则逐步消去 NFA M′M' 中的状态结点和弧,直至剩下SS,ZZ 为止。在消去结点的过程中,逐步用正规式标记弧。

picture 13

# 正规文法与 FA 的等价性

如果对于某个正规文法GG 和某个有限自动机MM,有L(G)=L(M)L(G) = L(M)(正规文法GG 所产生的语言和某个有限自动机所识别的语言相同),则称GG 和MM 是等价的。

定理 对每一个右线性正规文法或左线性正规文法 GG,都存在一个 FA MM,使 L(M)=L(G)L(M) = L(G)

定理 对于每一个 FA MM,都存在一个右线性正规文法 GG 和一个左线性正规文法 G′G',使 L(M)=L(G)=L(G′)L(M) = L(G) = L(G').

# 有限自动机⇒\Rightarrow 正规文法(右线性正规文法)
  1. 对转换函数f(A,t)=Bf(A, t) = B,可写成一个产生式:A→tBA \rightarrow tB

  2. 对可接受状态ZZ,增加一个产生式:Z→εZ \rightarrow \varepsilon

  3. 有限自动机的初态对应于文法的开始符号,有限自动机的字母表文法的终结符号集.

# 正规文法(右线性)⇒\Rightarrow 有限自动机
  1. 字母表与 GG 的终结符号相同。
  2. 为 GG 中的每个非终结符生成 MM 的一个状态,GG 的开始符号 SS 是开始状态 SS;
  3. 增加一个新状态 ZZ,作为 NFA 的终态。
  4. 对 GG 中的形如 A→tBA \rightarrow tB,其中 tt 为终结符或 ϵ\epsilon,AA 和 BB 为非终结符的产生式,构造 MM 的一个转换函数 f(A,t)=Bf(A, t) = B。
  5. 对 GG 中的形如 A→tA \rightarrow t 的产生式,构造 MM 的一个转换函数f(A,t)=Zf(A, t) = Z

# 词法分析程序的实现

  • 构造识别单词的状态转换图
    • 对程序语言的单词按种类分别构造对应的状态转换图.
    • 对各类转换图合并,构成一个能识别语言所有单词的状态转换图.
  • 编程实现状态转换图

# 限制条件

  • 所有基本字都是保留字;用户不能用它们作自己的标识
    符
  • 基本字作为特殊的标识符来处理,使用保留字表如果基本字、标识符和常数(或标号)之间没有确定的运算符或界符作间隔,则必须使用一个空白符作间隔

# 状态转换图的代码实现

每个状态节点对应一小段程序

# 不含回路的分叉节点

picture 14

GetChar();
if (IsLetter()) {
  // 状态 j
} else if (IsDigit()) {
  // 状态 k
} else if (ch == '\\') {
  // 状态 m
} else {
  // 错误处理
}
# 含回路的状态节点

picture 15

GetChar();
while (IsLetter() || IsDigit()) {
  GetChar();
}
// 状态 j
# 终态节点

直接返回单词符号

return (C, VAL);

C 是单词种别, VAL 是单词的属性值

# 全局变量与过程
  • ch 字符变量,存放最新读入的源程序字符
  • strToken 字符数组,存放构成单词符号的字符串
  • GetChar 子程序过程,把下一个字符读入到 ch 中
  • GetBC 子程序过程,跳过空白符,直至 ch 中读入一非空白符
  • Concat 子程序,把 ch 中的字符连接到 strToken
  • IsLetter 和 IsDisgital 布尔函数,判断 ch 中字符是否为字母和数字
  • Reserve 整型函数,对于 strToken 中的字符串查找保留字表,若它是保留字则给出它的编码,否则回送 0
  • Retract 子程序,把搜索指针回调一个字符位置
  • Insertld 整型函数,将 strToken 中的标识符插入符号表,返回符号表指针
  • InsertConst 整型函数过程,将 strToken 中的常数插入常数表,返回常数表指针
# 状态图代码一般化
curState = 初态;
GetChar();
while (stateTrans[curState][ch] 有定义) {
  // 存在后继状态,读入,拼接
  Concat();
  // 转换入下一个状态,读入下一个字符
  curState = stateTrans[curState][ch];
  if (curState == 终态) {
    // 返回单词符号
    return (C, VAL);
  }
  GetChar();
}

# 词法分析程序的设计过程

词法规则 -> 正规式 -> 状态转换图 -> 合并状态转换图 -> 编程实现

# 词法分析阶段的错误处理

# 可检测的错误类型

  • 单词拼写错误
  • 非法字符

# 词法错误检测

如果当前状态与当前输入符号在转换表对应项中的信息为空,而当前状态又不是终止状态,则调用错误处理程序

# 词法错误处理的方法

查找已扫描字符串中最后一个对应于某终态字符

  • 如果找到了,将该字符与其前面的字符识别成一个单词。然后将输入指针退回到该字符,扫描器重新回到初始状态,继续识别下一个单词
  • 如果没找到,则确定出错,采用错误恢复策略

# 错误恢复策略

最简单的错误恢复策略!恐慌模式(panic mode)恢复
从剩余的输入中不断删除字符,直到词法分析器能够在剩余输入的开头发现一个正确的字符为止

# 自顶向下语法分析

# 词法、语法的关系

  • 源语言的文法可以分解词法和语法

    • 词法:描述语言单词符号构成的文法
    • 语法:描述语言结构的文法
  • 用正规文法或正规表达式描述单词符号的结构

  • 用上下文无关文法描述语言的结构

  • 词法产生式的终结符号是单个字符

  • 语法产生式的终结符号是单词符号

# 语法分析器的作用

  • 语法分析任务:按照语言规定的语法规则,对词法分析形成的记号(单词)串进行语法检查,识别出相应的语法成分,采用语法树的形式输出,如果不符合语法要求则给出出错的原因。
  • 语法分析程序:执行语法分析的程序,也称语法分析器.
  • 语法分析的关键:句型的识别

picture 16

# 书写格式约定

  • 终结符号
    • 次序靠前的小写字母,如aa, bb, cc
    • 标点符号
    • 黑体的字串 if,for\textbf{if}, \textbf{for}
  • 非终结符号
    • 次序靠前的大写字母和SS
    • 小写的斜体的名字 expr\textit{expr}
  • 文法符号:次序靠后的大写字母 XX, YY, ZZ
  • 终结符号串:次序靠后的小写字母,UU, VV, ...
  • 文法符号串:小写的希腊字母,α\alpha, β\beta, γ\gamma

# 推导

推导:就是用产生式的右部的串来代替左部的非终结符,事实上推导给出了自顶向下构成分析树过程的精确描述。

# 消除二义性

  • 引入新的语法成分,使得原来的文法成为无二义的文法。
  • 增加就近原则,使得文法成为无二义的文法。

# 下推自动机

picture 18

# 消除左递归

一个文法GG,若存在推导A⇒+AαA\xRightarrow{+}A\alpha,则称GG 是左递归的。

消除直接左递归的方法:

若:A→Aα1∣Aα2∣⋯∣Aαn∣β1∣β2∣⋯∣βmA\rightarrow A\alpha_1|A\alpha_2|\cdots|A\alpha_n|\beta_1|\beta_2|\cdots|\beta_m,其中βi\beta_i 不以AA 开头,i=1,2,⋯ ,mi=1,2,\cdots,m,则可将AA 的产生式分为两部分:

A→β1A′∣β2A′∣⋯∣βmA′A′→α1A′∣α2A′∣⋯∣αnA′∣ε\begin{aligned} A &\rightarrow \beta_1A'|\beta_2A'|\cdots|\beta_mA'\\ A' &\rightarrow \alpha_1A'|\alpha_2A'|\cdots|\alpha_nA'|\varepsilon \end{aligned}

消除间接左递归的方法:

  • 非终结符号按照某种次序排列

  • 消除算法

    for i = 1 to n
      for j = 1 to i-1
        用A_i的产生式替换A_j的产生式中的A_i
      end for
      消除A_i的直接左递归
    end for
  • 去除开始符号无法到达的非终结符号的产生式

# 提取左因子

文法GG 的产生式A→α∣βA\rightarrow\alpha|\beta,若α⇒∗α1\alpha\xRightarrow{*}\alpha_1,β⇒∗β1\beta\xRightarrow{*}\beta_1,α1\alpha_1 和β1\beta_1 有一个最长的公共左因子γ\gamma

若A→αβ1∣αβ2A\rightarrow\alpha\beta_1|\alpha\beta_2,则可将AA 的产生式分为两部分:

A→αA′A′→β1∣β2\begin{aligned} A &\rightarrow \alpha A'\\ A' &\rightarrow \beta_1|\beta_2 \end{aligned}

# 递归下降分析法

# 包含回溯的递归下降分析法

思想:从语法的开始符号出发,试探使用不同产生式,寻找匹配于输入符号串的推导。或者说,从对应文法开始符号的根结点出发,自顶向下为输入符号串建立一棵分析树。

这种分析方法实质上是一种试探过程,是因为文法中,对于某个非终结符号的规则其右部有多个选择,并根据所面临的输入符号不能准确的确定所要选择时,就可能出现回溯。

上述分析称为带回溯的自顶向下分析。对于 w,从文法的开始符号出发,反复使用不同的产生式谋求匹配输入串。当用某个非终结符号的候选式进行匹配失败时,删除这个失败分析建立的分析树分支并回头查输入符号,以便与其它候选式匹配。

这种带回溯的自顶向下分析技术,效率很低,代价极高,因此,它只有理论上的意义。

# 不包含回溯的递归下降分析法

在不含左递归和每个非终结符的所有候选式的终结首符集都两两不相交(不含左因子)条件下,构造一个不带回溯的自上而下分析程序,该分析程序由一组递归过程组成,每个过程对应文法的一个非终结符。这样的一个分析程序称为递归预测分析器。

在推导过程中,根据当前的向前看符号,决定选择哪个产生式往下推导,因此,分析过程是完全确定的。这种分析称为自顶向下的预测分析。

# 终结首符集辅助确定候选式

若当前符号 =aa,对AA 展开,而A→α1∣α2∣…∣αmA\rightarrow \alpha_1|\alpha_2|\dots|\alpha_m,那么,要知道哪一个αi\alpha_i 是获得以aa 开头的串的唯一替换式。
即:选择哪一个αi\alpha_i,亦即通过查看第一个(当前)符号来发现合适的替换式αi\alpha_i。

怎样选择αi\alpha_i?

  • 以aa 为头的αi\alpha_i;
  • 如有多个αi\alpha_i 以aa 为头的,这是文法的问题

定义First(α)\text{First}(\alpha) 为串α\alpha 的首符号集合;

First(α)={a∣α⇒∗a…,a∈VT}\textrm{First}(\alpha) = \{a|\alpha\xRightarrow{*}a\dots,a\in V_T\}

若α⇒∗ε\alpha\xRightarrow{*}\varepsilon,则ε∈First(α)\varepsilon\in\text{First}(\alpha)
若有产生式A→αA\rightarrow\alpha,且α⇒+a…\alpha\xRightarrow{+}a\dots,当遇到输入字符aa 时,选择A→αA\rightarrow\alpha 进行推导。

若一个A∈VNA\in V_N 有许多First(αi)\textrm{First}(\alpha_i),如果AA 当任何两个候选式αi\alpha_i 和αj\alpha_j 均有

First(αi)∩First(αj)=∅\textrm{First}(\alpha_i)\cap\textrm{First}(\alpha_j)=\varnothing

意味着AA 每一候选式α\alpha 推导后所得的串的第一个VTV_T 符号都不相同。
于是对输入符号aa,如果a∈First(αi)a\in\textrm{First}(\alpha_i),则a∉First(αj)a \notin \textrm{First}(\alpha_j),因此对于输入符号aa,可以唯一确定AA 的候选式αi\alpha_i。

# 递归的预测分析法

递归的预测分析法是指:在递归下降分析中,对文法中的每个非终结符编写一个函数或子程序,其功能是识别由该非终结符所表示的语法成分,由于语言的文法常常是递归定义的,因此这组函数或子程序必须以递归方式调用。

void A() {
  选择一个A的产生式,A->X1X2...Xn
  for i = 1 to n
    if (Xi是非终结符号)
      调用过程Xi()
    else if (Xi等于当前输入符号)
      GetChar()
    else
      出错处理
}

产生式右部有ε\varepsilon 时,报错会滞后,等到处理完所有候选式后发现表达式没有处理完,才会报错。

# 递归预测分析器的构造

  • 向前看符号决定了选择哪个产生式右部的文法符号串与输入符号串匹配,在程序中由向前看符号可以确定一段程序完成与某一产生式右部的匹配。
  • 每一个非终结符号对应一个函数,函数的功能是根据向前看符号扩展分析树,同时用该非终结符号的儿子结点匹配输入符号串。

# 非递归预测分析法

# 预测分析表

递归分析表是矩阵M[A,a]M[A,a],其中行标AA 是文法的非终结符号,列标aa 是文法的终结符号或串终结符#\#,M[A,a]M[A,a] 是AA 的一个候选式,指出当前栈顶符号是AA,输入符号是aa 时,应该用A→aA\rightarrow a 进行推导,或者存放一个错误标记,指出AA 不该面临输入符号aa。

# 符号栈

把 #\# 和文法开始符号 SS 推进栈,并读入输入串的第一个单词 aa,重复下述过程直到正常结束或出错。

根据栈顶文法符号 XX 和当前单词符号 aa 的关系进行不同的处理:

  • 若 X=a=#X = a = \#,分析成功,停止。匹配输入串成功。
  • 若 X=a≠#X = a \ne \#,把 XX 从栈顶弹出,再读入下一个符号。
  • 若 X∈VnX \in V_n,查分析表 MM。

# 预测分析控制程序

置ip指向输入串w#的第一个符号
REPEAT
令X为栈顶符号,a为ip所指符号
IF X in VT | X == #
  IF X == a
    POP
    ip++
  ELSE
    ERROR
  ENDIF
ELSE
  IF M[X, a] == X -> Y1Y2...Yk
    POP
    PUSH YkYk-1...Y1
  ELSE
    ERROR
  ENDIF
ENDIF
UNTIL X == #
  • 输出的产生式对应了最左推导
  • 栈中: 残缺规范句型<未被匹配的句型>
  • M[X,a]M[X,a]:指出VNV_N 按哪一条产生式扩展,依赖于MM 表指出(栈顶,a)(\text{栈顶},a) 时,如何扩充语法树,出错了可以立即发现。

# 预测分析表的构造

# 什么时候使用ε\varepsilon 产生式

如果当前某非终结符 AA 与当前输入符 aa 不匹配时,若存在 A→εA\rightarrow\varepsilon,可以通过检查 aa 是否可以出现在 AA 的后面,来决定是否使用产生式 A→εA\rightarrow\varepsilon。若文法中无 A→εA\rightarrow\varepsilon,则应报错。

# FIRST 集

令 G[S]={VT,VN,S,P}G[S] = \{ V_T, V_N, S, P \} 是一个文法,则对任意文法串 α,α∈(VT∪VN)∗\alpha, \alpha \in (V_T \cup V_N)^*,定义

FIRST(α)={a∣α⇒∗a…,a∈VT}\textrm{FIRST}(\alpha) = \{ a | \alpha \xRightarrow{*} a\dots , a \in V_T \}

若 α⇒∗ε\alpha \xRightarrow{*} \varepsilon,则规定 ε∈FIRST(α)\varepsilon \in \textrm{FIRST}(\alpha)。

FIRST(α)\textrm{FIRST}(\alpha) 是α\alpha 所有可能推导出的开头终结符号的集合或可能为空串ε\varepsilon 所组成的集合。

# FIRST 集的构造
# 单个符号的 FIRST 集

当 α∈(VT∪VN)\alpha \in (V_T \cup V_N) 时,连续使用下面的规则,直至每个 FIRST\textrm{FIRST} 集不再增大为止:

  • 若 α∈VT\alpha \in V_T,则 FIRST(α)={α}\textrm{FIRST}(\alpha) = \{ \alpha \}
  • 若 α∈VN\alpha \in V_N,且有产生式 α⇒∗a…,a∈VT\alpha \xRightarrow{*} a\dots, a \in V_T,则将 aa 加入到 FIRST(α)\textrm{FIRST}(\alpha) 中, 若 α→ε\alpha \rightarrow \varepsilon,则将 ε\varepsilon 加入到 FIRST(α)\textrm{FIRST}(\alpha) 中。
# 多个符号的 FIRST 集

当α=X1X2…Xn\alpha = X_1X_2\dots X_n 时,把FIRST(X1)\text{FIRST}(X_1) 的所有非ε\varepsilon 元素加入到FIRST(α)\text{FIRST}(\alpha),若ε\varepsilon 在FIRST(X1)\text{FIRST}(X_1) 中,把FIRST(X2)\text{FIRST}(X_2) 的所有非ε\varepsilon 元素也加入到FIRST(α)\text{FIRST}(\alpha),若ε\varepsilon 既在FIRST(X1)\text{FIRST}(X_1) 中也在FIRST(X2)\text{FIRST}(X_2) 中,把FIRST(X3)\text{FIRST}(X_3) 的所有非ε\varepsilon 元素也加入到FIRST(α)\text{FIRST}(\alpha),...,若对所有的FIRST(Xi)\text{FIRST}(X_i),i=1,…,ni=1,\dots,n,都含有ε\varepsilon,把ε\varepsilon 加入到FIRST(α)\text{FIRST}(\alpha)。

# FOLLOW 集

令 G[S]={VT,VN,S,P}G[S] = \{ V_T, V_N, S, P \} 是一个文法,则

FOLLOW(A)={a∣S⇒∗…Aa…,a∈VT,A∈VN}\textrm{FOLLOW}(A) = \{ a | S \xRightarrow{*} \dots Aa \dots, a \in V_T, A \in V_N \}

若S⇒∗…AS \xRightarrow{*} \dots A,则规定#∈FOLLOW(A)\# \in \textrm{FOLLOW}(A),#\#作为输入串的右结束符号。

FOLLOW(A)\textrm{FOLLOW}(A) 是所有句型中AA 后面可能出现的终结符号的集合或串终结符号#\#所组成的集合。

# FOLLOW 集的构造

对于文法 GG 的每个非终结符号 AA,构造 FOLLOW(A)\text{FOLLOW}(A) 的办法是,连续使用下面的规则,直至每个 FOLLOW\text{FOLLOW} 集不再增大为止:

  • 对于文法的开始符号 SS,将符号 #\# 放入 FOLLOW(S)\text{FOLLOW}(S) 中;

  • 若 A→αBβA \rightarrow \alpha B \beta 是一个产生式,则将 FIRST(β)−{ε}\text{FIRST}(\beta) - \{\varepsilon\} 加入到 FOLLOW(B)\text{FOLLOW}(B) 中;

  • 若 A→αBA \rightarrow \alpha B 是一个产生式,或 A→αBβA \rightarrow \alpha B \beta 是一个产生式且 ε∈FIRST(β)\varepsilon \in \text{FIRST}(\beta)(即β⇒∗ε\beta \xRightarrow{*} \varepsilon),则将 FOLLOW(A)\text{FOLLOW}(A) 加入到 FOLLOW(B)\text{FOLLOW}(B) 中。

FOLLOW\text{FOLLOW} 集中不能有ε\varepsilon。

# 预测分析表的构造方法

在对文法GG 的每个非终结符号AA 及其任意候选α\alpha 都构造出FIRST(α)\text{FIRST}(\alpha) 和FOLLOW(A)\text{FOLLOW}(A) 之后,可以构造GG 的分析表M[A,a]M[A,a]。

算法:非递归预测分析表的构造

  1. 对文法GG 的每个产生式A→αA\rightarrow\alpha 执行第 2 步和第 3 步;
  2. 对每个终结符号a∈FIRST(α)a\in\text{FIRST}(\alpha),把A→αA\rightarrow\alpha 加至M[A,a]M[A,a] 中;
  3. 若α⇒∗ε\alpha \xRightarrow{*} \varepsilon,则对任何b∈FOLLOW(A)b\in\text{FOLLOW}(A),把A→αA\rightarrow\alpha 加至M[A,b]M[A,b] 中;
  4. 把所有无定义的M[A,a]M[A,a] 标上错误标记。

# LL (1) 文法

一个文法GG,若他的分析表MM 不含多重定义入口,则称GG 是 LL (1) 文法。

  • L:从左向右扫描输入串
  • L:用最左推导
  • 1:在栈顶符号和输入符号的组合下,只有一个产生式可以被选择

一个文法GG 是 LL (1) 的,当且仅当对于GG 的每一个非终结符号AA 的任何两个不同的产生式A→αA\rightarrow\alpha 和A→βA\rightarrow\beta,满足:

  • FIRST(α)∩FIRST(β)=∅\text{FIRST}(\alpha)\cap\text{FIRST}(\beta)=\varnothing
  • 若β⇒∗ε\beta \xRightarrow{*} \varepsilon,则FIRST(α)∩FOLLOW(A)=∅\text{FIRST}(\alpha)\cap\text{FOLLOW}(A)=\varnothing

# 预测分析法实现步骤

  1. 构造文法
  2. 改造文法:消除二义性、消除左递归、消除回溯
  3. 求每个变量的 FIRST 集和 FOLLOW 集,从而求得每个候选式的 SELECT 集
  4. 检查是不是 LL (1) 文法。若是,构造预测分析表对于递归的预测分析,根据预测分析表为每一个非终结符编写一个过程;对于非递归的预测分析,实现表驱动的预测分析算法。

# 递归的预测分析法 vs. 非递归的预测分析法

比较项 递归的预测分析法 非递归的预测分析法
程序规模 程序规模较大,不需载入分析表 主控程序规模较小,需载入分析表(表较小)
直观性 较好 较差
效率 较低 分析时间大约正比于待分析程序的长度
自动生成 较难 较易

# 预测分析的错误检测

  • 栈顶的终结符和当前输入符号不匹配
  • 栈顶非终结符与当前输入符号在预测分析表对应项中的信息为空
# 预测分析中的错误恢复

恐慌模式

  • 忽略输入中的一些符号,直到输入中出现由设计者选定的同步词法单元(synchronizing token)集合中的某个词法单元
    • 其效果依赖于同步集合的选取。集合的选取应该使得语法分析器能从实际遇到的错误中快速恢复,例如可以把 FOLLOW(A)中的所有终结符放入非终结符的同步记号集合
  • 如果终结符在栈顶而不能匹配,一个简单的办法就是弹出此终结符

synch 表示根据相应非终结符的 FOLLOW 集得到的同步词法单元

  • 如果 M[A,a] 是空,表示检测到错误,根据恐慌模式,忽略输入符号 a
  • 如果 M[A,a] 是 synch ,报错,弹出栈顶的非终结符 A ,试图继续分析后面的语法成分
  • 如果栈顶的终结符和输入符号不匹配,则弹出栈顶的终结符

# 自底向上语法分析

  • 从分析树的底部(叶节点)向顶部(根节点)方向构造分析树
  • 可以看成是将输入串ww 归约为文法开始符号SS 的过程
  • 自顶向下的语法分析采用最左推导方式
  • 自底向上的语法分析采用最左归约方式(反向构造最右推导)
  • 自底向上语法分析的通用框架:移入 - 归约分析(Shift-Reduce Parsing)

# 规约

# 最右推导和最左归约

  • 由最右推导得到的句型称为右句型, 最右推导也称为规范推导。
  • 最左规约是最右推导的逆过程,即由最右推导的句型的某个右部规约到左部的过程,也称为规范规约。

# 规范规约

假定 aa 是文法 GG 的一个句子。称句型序列 an,an−1,…,a1,a0a_n, a_{n-1}, \ldots, a_1, a_0 是 aa 的一个规范归约,如果此序列满足

  1. an=a,a0=Sa_n = a, a_0 = S;
  2. ∀i(0<i≤n)\forall i (0 < i \leq n),ai−1a_{i-1} 是把 aia_{i} 中的句柄替换为相应产生式的左部符号得到的。

如果文法 GG 是无二义的,那么,规范推导(最右推导)的逆过程必是规范归约(最左归约)。

对于规范句型来说,句柄的后面不会出现非终结符号(句柄的后面只能出现终结符号)。

二义性文法的规范归约过程中右句型的句柄可能不唯一。

# 移入 - 归约分析

把一个输入符号串逐步归约到文法的开始符号。

实现这种方法的大致过程是,用一个栈,把输入符号一个一个地移进到栈里,反复查看栈顶符号串,当栈顶形成某个产生式的右部(句柄)时,把栈顶的这一部分替换成(归约为)它的左部符号。直到移进所有的输入符号串时,若栈内是开始符号,则符合语法,否则不是文法的句子,这种分析称作 “移进一归约” 分析。

# 移入 - 归约分析的栈实现

“移进一归约” 分析器使用一个栈和一个存放输入符号串ww 的缓冲器。分析器的初始状态为:

picture 19

工作过程:自左至右把串ww 的符号一一移进栈里,一旦栈顶形成句柄时,就进行归约。这种归约可能持续多次,直至栈顶不再呈现句柄为止。然后,继续向栈里移进符号,重复这个过程,直至最终形成如下格局:

picture 20

# 移入 - 归约分析的动作

  • 移入:将下一个输入符号移到栈的顶端
  • 归约:被归约的符号串的右端必然处于栈顶。语法分析器在栈中确定这个串的左端,并决定用哪个非终结符来替换这个串
  • 接收:宣布语法分析过程成功完成
  • 报错:发现一个语法错误,并调用错误恢复子例
    程

分析过程的每一步骤,栈里的文法符号串加上剩余输入符号串恰好是一个规范句型。

# 规范句型的活前缀

设有文法G[S]G[S],若S⇒∗αAw⇒∗αβwS\xRightarrow{*}\alpha Aw\xRightarrow{*}\alpha\beta w 是文法GG 的一个规范推导,其中α,β∈V+\alpha,\beta\in V^+,w∈VT∗w \in V_T^*,A∈VNA \in V_N,若存在γ\gamma 是αβ\alpha\beta 的一个前缀,则称γ\gamma 是文法的一个活前缀,如果γ\gamma 是含句柄的活前缀,则称γ\gamma 是文法的可归前缀(特殊活前缀)。

  1. 识别活前缀 -> 判断是否规范句型前缀(DFA)
  2. 识别可归前缀 -> 规约(圆点)

一个规范句型的活前缀不含句柄之后的任何符号

  • 活前缀和句柄的关系?
    • 活前缀不含有句柄的任何符号;
    • 活前缀含有句柄的部分符号;
    • 活前缀已含有句柄的全部符号。

因此我们不仅要能够识别出栈内是否活前缀,还要判断当栈内是可归活前缀(包含句柄)时,进行规约。

# 规范句型的活前缀的识别

对于一个文法GG,可以构造一个 DFA,它能够识别GG 的所有活前缀。如果将经过此 DFA 的弧上的文法符号依次入栈,那么栈内就一定是活前缀。

# 规范句型的可归活前缀的识别算法

产生式的右部加上一个圆点指示位置,用于标识产生式右部有多少成分被识别了,并且找到该右部正好被识别的时刻,才能保证此时被识别的部分仅仅包含一个句柄。
如果将产生式右部圆点不同的位置表示上述 DFA 的不同状态,那么就可以确定,经过某个弧后,是否在栈顶正好形成句柄。如果当前状态下圆点在产生式右部的末端,此时栈顶必然出现了句柄,此时的活前缀可以规约操作。

# LR 分析法

LR 分析法是一种有效的自底向上的语法分析技术,一般叫 LR(k)分析技术,其中的 “L” 是指从左至右扫描输入符号串,“R” 是指构造一个最右推导的逆过程,“k” 是指为了作出分析决定而向前看的输入符号的个数。

LR 分析方法是当前最广义的无回溯的 “移进 - 归约” 方法。根据栈中的符号串和向右查看输入串的 k(k≥0)个符号,就能唯一确定分析器的动作是移进还是归约,以及用哪个产生式进行归约。

# LR 分析法的优缺点

  1. 适合文法类足够大,适用于绝大多数上下文无关文法
  2. 分析效率高
  3. 报错及时
  4. 可以自动生成
  5. 手工实现工作量大

# LR 分析法的本质 —— 状态法

由于句柄是逐步形成的,用状态来描述形成句柄到达什么程度。

采用此方法,语法分析程序根据当前分析状态就可以确定句柄的头和尾,从而进行正确的归约。

LR 分析方法的关键就是根据上述状态,设计状态转换规则,从而实现识别活前缀的 NFA,进而实现识别活前缀的 DFA。

# 项目与状态

定义:对于文法 G,其产生式的右部添加一个特殊符号 · 就构成文法的一个项目。后面也称为 LR(0)项目。

书写文法中所有产生式的项目,而每个项目都为识别活前缀的 NFA 的一个状态。

# 项目的分类

  • 移进项目:A→α⋅aβ,a∈VTA\rightarrow\alpha\cdot a\beta, a\in V_T,这类 LR(0)项目表示aa 出现在符号栈中,活前缀包含句柄的部分符号,为构成可归前缀,需继续将圆点后的终结符号aa 移进符号栈。因此这种形式的 LR(0)项目称为移进项目,它对应的状态为移进状态。
  • 待约项目:A→α⋅Bβ,B∈VNA\rightarrow\alpha\cdot B \beta, B\in V_N,这类 LR(0)项目表示aa 出现在符号栈中,活前缀包含句柄的部分符号,为构成可归前缀,期待着把当前输入字符串中的相应内容先归约到BB。因此这种形式的 LR(0)项目称为待约项目,它对应的状态为待约状态。
  • 归约项目:A→α⋅A\rightarrow\alpha\cdot,这类 LR(0)项日表示句柄 a 刚好出现在符号栈栈顶,活前缀刚好包含句柄,即当前符号栈中的符号串正好为可归前缀,应按A→αA\rightarrow \alpha 进行归约。因此这种形式的 LR(0)项目称归约项目,它对应的状态为归约状态。
  • 接受项目:对于拓广文法 G[S′]G[S'],有项目 S′→S⋅S' \rightarrow S \cdot,它是一个特殊的归约项目,我们称它为接受项目,它对应的状态为接受状态。

# 状态的转移规则

  • 若文法中有项目i:X→x1x2…xi−1⋅xixi+1…xni: X\rightarrow x_1 x_2 \dots x_{i-1} \cdot x_i x_{i+1} \dots x_n,项目j:X→x1x2…xi−1xi⋅xi+1…xnj: X\rightarrow x_1 x_2 \dots x_{i-1} x_i \cdot x_{i+1} \dots x_n,那么从状态ii 到状态jj 连接一条有向弧,标记为xix_i。

picture 21

  • 若项目i:X→γ⋅Aδ,A∈VNi: X\rightarrow \gamma \cdot A \delta, A\in V_N,项目K:A→⋅βK: A\rightarrow \cdot \beta,那么从状态ii 到状态kk 连接一条有向弧,标记为ε\varepsilon。

picture 22

# 拓广文法

对任何文法 GG,在 GG 中加进一个新的符号 S′S' 和一个产生式 S′→SS' \rightarrow S,并以 S′S' 代替 SS 作为文法的开始符号,这样得到的一个与 GG 等价的文法 G′G' 称为 GG 的拓广文法。

目的:构造 NFA 时开始状态唯一。

# 构造识别活前缀 NFA 的原则

  1. NFA 的状态集:由每个项目所对应的状态组成;
  2. 输入字符集合:由文法的文法符号组成包括终结符、非终结符和 ε\varepsilon;
  3. 初态:对于文法 G[S]G[S] 的拓广文法 G[S′]G[S'],有项目 S′→⋅SS' \rightarrow \cdot S,由于 S′S' 仅在第一个产生式的左部出现,所以规定它为初态;
  4. 终态:对于拓广文法 G[S′]G[S'],有项目 A→α⋅A \rightarrow \alpha \cdot(即圆点在最后的项目),作为 NFA 的终态;
  5. 设计转换规则

# LR 分析器的实现

LR 分析器是带有下推栈的确定的有限状态自动机。将所设计的识别活前缀的 NFA,转换成等价的 DFA,并根据 DFA 设计分析表,并通过主控程序,查找分析表,完成了移进规约的分析过程。

由于分析表来自 NFA,LR 分析过程 结合输入的符号,执行分析表中涵盖的移进、规约等动作,保障了符号栈内一定是某个规范句型的活前缀,且能够判定当前活前缀尾部是否包含句柄。

# LR 分析器的逻辑结构

picture 23

  • 总控程序:LR 分析器在总控程序的控制下自左至右扫描输人串,根据当前分析栈顶所存放的文法符号状态及当前扫描读人的符号,查询 LR 分析表完成分析动作。
  • 分析表:分析表是 LR 分析器的核心,它跟具体文法有关,包括动作表(action)和状态转换表(goto)两部分,均使用二维数组表示,为总控程序提供决策依据。
  • 分析栈:包括文法符号栈 X[i] 和相应的状态栈 S[i] 两部分(状态是指能识别活前缀的自动机状态),LR 分析器通过判断栈顶元素和输入符号查分析表确定下步分析动作。栈顶状态符号概括了在栈中位于它下边的全部信息,即从分析开始直到某一归约阶段的全部历史和展望

# LR 分析表的组成

picture 25

# action 表

分析动作表以一个二维数组表示,行代表分析栈栈顶状态,列代表当前的输入符号,数组元素表示当前栈顶为状态为 SiS_i,而输入符号为 aja_j 时,所执行的分析动作 Action[Sj,a]\text{Action}[S_j, a]。

  • 移进:新状态 SiS_i 进状态栈,输入符号 aa 进符号栈
  • 归约:用相应的产生式进行归约 rjr_j;
  • 接受:当文法符号归约到只剩下开始符号,且输入串结束时(当前输入为 #\#),分析成功;
  • 报警:当状态栈顶为某一状态下,出现了不该出现的文法符号时,报错。
# goto 表

状态转换表也用一个二维数组表示,行代表分析栈栈顶状态,列代表文法符号(非终结符),数组元素表示当前栈顶为状态为SiS_i;面对文法符号为XjX_j 时,应转去的新状态为SkS_k。Goto[S,Xj]=Sk\text{Goto}[S, X_j] = S_k

# LR 分析算法

  • 将初始状态SS,和输入串的左边界(#\#)分别进分析栈;
  • 根据状态栈栈顶和当前输入符号查动作表进行如下工作:
    • 移进:若动作表中对应 “移进”,那么当前输入符号移入符号栈,并将所对应的新的状态进状态栈,继续扫描,即下一个输入符号变成当前的输入符号;
    • 归约:若动作表中对应 “归约”,则按指定产生式进行归约,若产生式右部的符号串长度nn,则符号栈栈顶的nn 个符号为句柄,所以符号栈栈顶nn 个符号出栈,同时,状态栈顶的nn 个元素也出栈,归约后的文法符号(非终结符)进符号栈,并根据状态转换表查归约后的文法符号所对应的新状态进状态栈;
    • 接受:若动作表中对应 “acc”,则分析成功;
    • 出错:若动作表中对应空白,则报告错误信息。
  • 重复以上(2)的工作直到接受或出错为止。

同行的符号栈和输入缓冲区的内容构成文法的一个右句型

# LR 文法

泛泛地讲,一个上下文无关文法,若构造出无冲突的 LR 分析表,则说明该文法是 LR 文法。
具体说,一个上下文无关文法,若构造出无冲突的 LR(k)分析表,则说明该文法是 LR(k)文法。(k=0,1 )
LR 分析法是一种基本分析思想,LR 文法是一种泛泛的文法,当 k 具体有确定值时,其文法和分析方法就具体了。

中心思想:从给定的文法去构造一个识别该文法所有活前缀的确定的有限自动机(DFA),然后根据 DFA 去构造它的分析表。

# 构造识别文法所有活前缀的 DFA

  • 手工操作:根据文法的所有项目,构造一个 NFA,然后将 NFA 转换成 DFA
  • 机器操作:直接构造 LR(0)项目集规范族,然后根据项目集规范族构造 DFA

# 闭包和转移函数

# 闭包 - 形成项目集

定义 设 II 是文法 G’G’ 的一个 LR (0) 项目集合,closure(I)\text{closure}(I) 是从 II 出发用下面三个规则构造的项目集:

  1. II 中每一个项目都属于 closure(I)\text{closure}(I)。
  2. 若项目 A→α⋅Bβ∈closure(I)A \rightarrow \alpha \cdot B \beta \in \text{closure}(I) 且 B→γB\rightarrow \gamma,则将所有 B→⋅γB \rightarrow\cdot \gamma 的项目加入到 closure(I)\text{closure}(I) 中。
  3. 重复执行(2)直到 closure(I)\text{closure}(I) 不再增大为止。
# 转移函数 - 后继项目集

若 II 是文法 GG 的一个 LR (0) 项目集,X∈{VT∪VN}X\in \{V_T \cup V_N\},

go(I,X)=closure(J)\text{go}(I, X) = \text{closure}(J)

其中 J={A→αX⋅β∣A→α⋅Xβ∈I}J = \{ A \rightarrow \alpha X \cdot \beta | A \rightarrow \alpha \cdot X \beta \in I \},go(I,X)\text{go}(I, X) 称为转移函数。项目 A→αX⋅βA \rightarrow \alpha X \cdot \beta 称为项目 A→α⋅XβA \rightarrow \alpha \cdot X \beta 的后继项目。

# LR (0) 项目集规范族的构造算法
PROCEDURE items(G');
BEGIN
    C := {closure({S' -> .S})};
    REPEAT
        FOR 任意 I in C and 任意 X in {V_T ∪ V_N}
            把go(I, X)加入到C中;
    UNTIL C 不再增大;
END;

如何求项目集规范族?

先画出 DFA, DFA 的每个状态就是一个项目集。

# LR (0) 分析表的构造

  1. 对于 A→α⋅xβ∈Si,go(Si,x)=SjA \rightarrow \alpha \cdot x \beta \in S_i, \text{go}(S_i, x) = S_j,若 x∈VTx \in V_T,则置 action[Si,x]=Sj\text{action}[S_i, x] = S_j;若 x∈VNx \in V_N,则置 goto[Si,x]=j\text{goto}[S_i, x] = j。
  2. 对于 A→α⋅∈SiA \rightarrow \alpha \cdot \in S_i,若 A→αA \rightarrow \alpha 是 GG 的第 kk 个产生式,则对于所有 x∈VTx \in V_T(包括 #\#),置 action[Si,x]=rk\text{action}[S_i, x] = r_k。
  3. 若 S′→S⋅∈SiS' \rightarrow S \cdot \in S_i,则置 action[Si,#]=acc\text{action}[S_i, \#] = acc。
  4. 其他情况均置错

# LR (0) 文法

  • 项目集的相容性:我们已知,项目有 4 种类型,但在一个项目集中,不能有以下情况存在:

    • 移进项目和归约项目并存;
    • 多个归约项目并存;
      若项目集能满足以上条件,则称相容的项目集。
  • 冲突:项目集中含有的项目若符合以上两个条件,则称为项目集中含有冲突。若移进项目和归约项目并存,则称为移进 — 归约冲突,若多个归约项目并存,则称为归约一归约冲突。

  • LR(0)文法:若一个文法 G 的项目集规范族中的所有项目都是相容的,则称文法 G 为 LR(0)文法。

判断一个文法是否是 LR(0)文法?

分析表中,没有出现的多重定义。即:LR(0)项目集内部没有冲突。

# SLR (1) 分析法

SLR (1) 分析法是对 LR (0) 分析法的改进,增加了 FOLLOWFOLLOW 集的信息,减少了规约的数量,以解决 LR (0) 分析法中的移进 - 归约冲突和归约 - 归约冲突。

# SLR (1) 分析表的构造

为了构造 SLR(1)分析表,将刚才例中的情况一般化:根据不同的向前看符号将状态 SS 中的各个项目所对应的动作加以区分,从而解决冲突动作。

设有一个 LR(0)的规范族中有如下项目集(状态)

Si={x→α⋅bβ,A→γ⋅,B→δ⋅,α,β,γ,δ∈V∗,b∈VT}S_i = \{x \rightarrow \alpha \cdot b\beta, A \rightarrow \gamma \cdot, B \rightarrow \delta \cdot, \alpha, \beta, \gamma, \delta\in V^*, b\in V_T\}

项目集中含有一个移进项目和两个归约项目。就是说 SS 是不相容的项目集,如果用 LR(0)分析表的构造规则来构造分析表,将出现动作冲突,可用下面方法解决:

对于归约项目:A→γ⋅A \rightarrow \gamma \cdot 和 B→δ⋅B \rightarrow \delta \cdot,分别求 Follow(A)\text{Follow}(A) 和 Follow(B)\text{Follow}(B)。若 Follow(A)\text{Follow}(A),Follow(B)\text{Follow}(B) 和 {b}\{b\} 互不相交,则冲突可以解决。

构造规则如下

  1. 对于 A→α⋅bβ∈Si,go(Si,b)=SjA \rightarrow \alpha \cdot b\beta \in S_i, \text{go}(S_i, b) = S_j,若 b∈VTb \in V_T,则置 action[Si,b]=Sj\text{action}[S_i, b] = S_j;若 b∈VNb \in V_N,则置 goto[Si,b]=j\text{goto}[S_i, b] = j。
  2. 对于规约项目:A→α⋅∈SiA \rightarrow \alpha \cdot \in S_i,若 A→αA \rightarrow \alpha 是 GG 的第 jj 个产生式,则对于任意输入符号 a∈Follow(A)a \in \text{Follow}(A),置 action[Si,a]=rj\text{action}[S_i, a] = r_j。
  3. 若 S′→S⋅∈SiS' \rightarrow S \cdot \in S_i,则置 action[Si,#]=acc\text{action}[S_i, \#] = acc。
  4. 其他情况均置错

SLR 只是简单地考察下一个输入符号 bb 是否属于与归约项目 A→αA \rightarrow \alpha 相关联的 FOLLOW(A)\text{FOLLOW}(A),但 b∈FOLLOW(A)b \in \text{FOLLOW}(A) 只是归约 α\alpha 的一个必要条件,而非充分条件。

# LR (1) 分析法

对于当前分析状态 SS;
S→a⋅AβA→⋅γS \rightarrow a \cdot A\beta \quad A \rightarrow \cdot \gamma 注意 SS 为开始符号

把 First(β)\text{First}(\beta) 作为用产生式 A→γA \rightarrow \gamma 进行归约的搜索符,用于替代 SLR(1)分析法中的 Follow(A)\text{Follow}(A),并把搜索符号的集合放在项目的后面([A→⋅γ,a][A \rightarrow \cdot \gamma, a] a∈First(β)a \in \text{First}(\beta))。这种处理方法称为 LR(1)方法。

一般的 LR(1)方法的功能在于集合 First(β)\text{First}(\beta) 可能是 Follow(A)\text{Follow}(A) 的一个怡当的子集。

# LR (1) 项目

在 LR(0)项目中放置一个向前搜索的符号 aa,形成[A→α⋅β,al][A \rightarrow \alpha \cdot \beta , a_l]

A→α⋅βA \rightarrow \alpha \cdot \beta 是一个 LR(0)项目,aa 是一个终结符号,这种形式的项目称为 LR(1)项目,aa 称向前搜索符。

向前搜索符仅对归约项目 [A→α⋅,a][A \rightarrow \alpha\cdot, a] 有意义,当当前输入符号是 aa 时,才能用 A→αA \rightarrow \alpha 进行归约。

[S→α⋅Aβ,a]A→γ则[A→⋅γ,b]b∈First(βa)\begin{align*} &[S \rightarrow \alpha \cdot A\beta, a] \quad A \rightarrow \gamma \\ \text{则} &[A \rightarrow \cdot \gamma, b] \quad b \in \text{First}(\beta a) \\ \end{align*}

# LR (1) 项目集的构造

LR(1)分析过程中的每个状态,就是包含若干 LR(1)项目的一个 LR(1)项目集,特殊的,[S′→⋅S,#][S' \rightarrow \cdot S,\#] 属于初始项目集中的一个 LR(1)项目,即[S′→⋅S,#]∈S0[S' \rightarrow \cdot S,\#]\in S_0,它表示:归约到最后一步,必须面临输入符号#\#才行。所以文法的所有项目集的获得,就是从初始项目[S′→⋅S,#][S' \rightarrow \cdot S, \#] 出发,通过求其闭包再用转换函数逐步求出整个文法的 LR(1)项目集。

# LR (1) 项目集的闭包

算法:设 II 是文法 GG 的一个 LR(1)项目集,closure(I)\text{closure}(I) 是通过以下三个规则构造出的项目集:

  1. II 中的每个项目都属于 closure(I)\text{closure}(I)。
  2. 若有项目 [A→α⋅Bβ,a][A \rightarrow \alpha \cdot B\beta, a] 属于 closure(I)\text{closure}(I),且 B→η∈PB \rightarrow \eta \in P 是一个产生式,则对于任意 b∈FIRST(βa)b \in \text{FIRST}(\beta a),将 [B→⋅η,b][B \rightarrow \cdot \eta, b] 加入到 closure(I)\text{closure}(I) 中。
  3. 重复执行(2),直到 closure(I)\text{closure}(I) 不再增大为止。
# LR (1) 项目集的转移函数

设 II 是文法 GG 的一个 LR(1)项目集,X∈{VT∪VN}X \in \{V_T \cup V_N\},go(I,X)=closure(J)\text{go}(I, X) = \text{closure}(J),其中 J={[A→αX⋅β,a]∣[A→α⋅Xβ,a]∈I}J = \{[A \rightarrow \alpha X \cdot \beta, a] | [A \rightarrow \alpha \cdot X \beta, a] \in I\},go(I,X)\text{go}(I, X) 称为转移函数。项目 [A→αX⋅β,a][A \rightarrow \alpha X \cdot \beta, a] 称为项目 [A→α⋅Xβ,a][A \rightarrow \alpha \cdot X \beta, a] 的后继项目。

# LR (1) 分析表的构造

对于文法 G[S]G[S],其 LR(1) 分析表的构造规则为:

  1. 对于每个项目 [A→α⋅aβ,b][A \rightarrow \alpha \cdot a \beta, b],如果 go(i,a)=jgo(i, a) = j,则设置 action[i,a]=Sj\text{action}[i, a] = S_j。

  2. 对于每个项目 [A→α⋅,a][A \rightarrow \alpha \cdot,a],如果该产生式是 GG 的第 kk 个产生式,则设置 action[i,a]=rk\text{action}[i, a] = r_k。(其中 A≠S′A \neq S')

  3. 如果 [S′→S⋅,#][S' \rightarrow S \cdot, \#],则设置 action[i,#]=acc\text{action}[i, \#] = \text{acc}。

  4. 对于每个非终结符号 AA,如果 go(i,A)=jgo(i, A) = j,则设置 goto[i,A]=j\text{goto}[i, A] = j。

  5. 分析表中的空白处填入 error。

# LR (1) 文法

按上述算法构造的分析表,如果每个入口是唯一确定的,则称它为文法 G 的一张 LR(1)分析表。具有 LR(1)分析表的文法称为 LR(1)文法。使用 LR(1)分析表的分析器称作一个 LR(1)分析器。

# LALR (1) 分析法

LALR(1)分析的思想是对 LR(1)中能够合并的项目集进行合并,从而减少状态,对同一个文法,合并 LR(1)项目集之后得到的 LALR(1)分析表比 LR(1)分析表状态数少,具有和 SLR 分析表相同数目的状态,但却能胜任 SLR(1)所不能解决的问题。

# 同心集

若 LR(1)的两个项目集的 LR(0)项目全部相同,则称两个 LR(1)项目集具有相同的心。具有相同心的项目集称为同心集。

合并方法

  • 相同的心(LR(0)项目)不变
  • 合并后项目集的搜索符等于合并前 LR(0)项目搜索符的并集

# LALR (1) 文法

若合并同心集后项目集规范族无分析动作冲突,则此表称为 LALR(1)分析表。相应的文法称为 LALR(1)文法。

# LR 分析的错误处理

# 恐慌模式

  • 从栈顶向下扫描,直到发现某个状态 SiS_i,它有一个对应于某个非终结符 AA 的 GOTO 目标,可以认为从这个 AA 推导出的串中包含错误。
  • 然后丢弃 0 个或多个输入符号,直到发现一个可能合法地跟在 AA 之后的符号 aa 为止。
  • 之后将 Si+1=GOTO(Si,A)S_{i+1} = \text{GOTO}(S_i, A) 压入栈中,继续进行正常的语法分析。

S0S1…Si Si+1…Sm#X1,…,X;A…Xm\begin{align*} &S_0S_1 \dots S_i \ S_{i+1} \dots S_m\\ &\# X_1, \dots, X; A \dots X_{m} \end{align*}

# 短语层次

  • 检查 LR 分析表中的每一个报错条目,并根据语言的使用方法来决定程序员所犯的何种错误最有可能引起这个语法错误
  • 然后构造出适当的恢复过程

# LR 和 LL 的比较

  • A→α1∣α2A \rightarrow \alpha_1 | \alpha_2

    LL(kk) 根据 FIRST(αi)\text{FIRST}(\alpha_i) 和 FOLLOW(A)\text{FOLLOW}(A) 确定使用哪条产生式;而 LR (kk) 是在识别出整个 α\alpha 后,再往后看 kk 个符号,然后确定使用哪条产生式。

    LL(kk) 文法都是 LR (kk) 文法。

  • 都能用形式化方法实现;

  • LR(kk) 分析用手工构造是不可能的。

# 语法制导翻译与中间代码生成

# 语法制导翻译

# 语法制导翻译的基本思想

  • 为上下文无关文法中的文法符号设置语义属性,用来表示语法成分对应的语义信息
  • 文法符号是用与文法符号所在产生式(语法规则)相关联的语义属性值的计算规则来计算的
  • 对于给定的输入串xx,构建xx 的语法分析树,并利用与产生式(语法规则)相关联的语义规则来计算分析树中各结点对应的语义属性值

# 语法制导翻译的处理方法

# 语法制导定义(SDD)

对上下文无关文法的推广

  • 将每个文法符号和一个语义属性集合相关联
  • 将每个产生式和一组语义规则相关联,这些规则用于计算该产生式中各文法

符号的属性值如果 X 是一个文法符号, a 是 X 的一个属性,则用 X.a 表示属性 a 在某个标号为 X 的分析树结点上的值
picture 26

# 语法制导翻译方案(SDT)

语法制导翻译方案是在产生式右部嵌入了若干组程序片段的上下文无关文法,这些程序片段称为语义动作。按照惯例,语义动作放在花括号内。
picture 27

# 语法制导定义

# 文法中的属性

  • 属性通常分为两类:综合属性和继承属性。
    • 综合属性用于 “自下而上” 传递信息
    • 继承属性用于 “自上而下” 传递信息。
  • 另一类属性:固有属性:词法分析器得到的值,如常量 5 的值

# 语法制导定义的属性

在一个 SDD 中,∀A→α∈P\forall A \rightarrow \alpha \in P 都有与之相关联的一套语义规则,规则形式为

b:=f(c1,c2,…,ck)b:= f(c_1, c_2, \dots, c_k)

ff 是一个函数,而且或者

  1. bb 是AA 的一个综合属性并且c1,c2,…,ckc_1,c_2,\dots,c_k 是α\alpha 中文法符号的属性,或者
  2. bb 是α\alpha 中文法符号的一个继承属性并且c1,c2,…,ckc_1,c_2,\dots,c_k 是AA 或α\alpha 中的任何文法符号的属性。

在两种情况下,都说属性 b 依赖于属性c1,c2,…,ckc_1,c_2,\dots,c_k。

# 属性文法

  • 属性文法是在上下文无关文法的基础上,为文法每个终结符和非终结符配备若干相关的属性及其计算规则
  • 没有副作用的语法制导定义,有时又称属性文法
  • 副作用:除了属性计算的语义动作

# 综合属性

在分析树中,一个结点的综合属性值是从其子结点的属性值计算出来的;结点属性值的计算正好和自底向上分析建立分析树结点同步进行。

只使用综合属性的语法制导定义称为 S - 属性定义,也叫 S - 属性文法。

# 继承属性

每个文法符号可以和一个继承属性值联系,属性值的设置和语法结构的语义以及翻译程序的需要有关。

一个结点的继承属性值是由该结点兄弟结点和 / 或父结点的属性值计算出来的。

# 综合属性和继承属性的区别

  1. 非终结符既可有综合属性也可有继承属性,文法开始符号的所有继承属性作为属性计算前的初始值(或者开始符号没有继承属性)
  2. 终结符只有综合属性,它们由词法程序提供.

# 语义规则

  • 对出现在产生式右边的继承属性和出现在产生式左边的综合属性都必须提供一个计算规则。属性计算规则中只能使用相应产生式中的文法符号的属性。
  • 出现在产生式左边的继承属性和出现在产生式右边的综合属性不由所给的产生式的属性计算规则进行计算,由其它产生式的属性规则计算或者由属性计算器的参数提供。
  • 语义规则所描述的工作可以包括属性计算、静态语义检查、符号表操作、代码(中间)生成等等。有些语义规则可能产生副作用(如产生代码),通常把这样的语义规则写成函数调用。

# SDD 的属性计算

# 依赖图
for 分析树中每一结点 n do
  for 结点 n 的文法符号的每一个属性 a do
    为 a 在依赖图中建立一个结点;
for 分析树中每一个结点 n do
  for 结点 n 所用产生式对应的每一条语义规则 b := f(c1, c2, ..., ck) do
    for i := 1 to k do
      从结点 ci 到结点 b 构造一条有向边;

若依赖图无环,则可以按照拓扑排序的顺序计算属性值。

  • 优点
    • 计算思路清晰
    • 不受语法分析方法的限制
  • 缺点
    • 效率低,复杂
    • 无法解决环路的依赖图问题
# 树遍历
  • 通过树遍历的方法计算属性的值
    • 假设语法树已建立,且树中已带有开始符号的继承属性和终结符的综合属性
    • 以某种次序遍历语法树,直至计算出所有属性
    • 深度优先,从左到右的遍历
    • 如果需要的话,可使用多次遍历。
While 还有未被计算的属性 do
  VisitNode(S)
  /* S是开始符号 */
procedure VisitNode (N:Node);
begin
  if N是一个非终结符 then
    /* 假设其产生式为 N -> X1 X2 ⋯ Xm */
    for i := 1 to m do
      if Xi ∈ Vn then
        /* 即 Xi 是非终结符 */
        begin
          计算 Xi 的所有能够计算的继承属性;
          VisitNode (Xi)
        end
    计算 N 的所有能够计算的综合属性
end
# 一遍扫描
  • 与树遍历的属性计算文法不同,一遍扫描的处理方法是在语法分析的同时计算属性值,而不是语法分析构造语法树之后进行属性的计算,而且并无需构造实际的语法树。
  • 语义规则被计算的时机:
    • 在自上而下的分析中,一个产生式匹配输入串成功时计算
    • 在自下而上的分析中,一个产生式被用于归约时计
# 抽象语法树(AST)

抽象语法树(Abstract Syntax Tree,AST),在语法树中去掉那些对翻译不必要的信息,从而获得更有效的源程序中间表示。

  • mknode(op, left, right) :建立一个运算符号结点,标号是 op ,两个域 left 和 right 分别指向左子树和右子树。
  • mkleaf(id, entry) :建立一个标识符结点,标号为 id ,一个域 entry 指向标识符在符号表中的入口。
  • mkleaf(num, val) :建立一个数结点,标号 num ,一个域 val 用于存放数的值。
# S - 属性文法与自底向上翻译
  • S - 属性文法,它只含有综合属性(S-SDD)。
  • 综合属性可以在分析输入符号串的同时自下而上计算。
  • 分析器可以保存与栈中文法符号有关的综合属性值,每当进行归约时,新的属性值就由栈中正在归约的产生式右边符号的属性值来计算。
  • S - 属性文法的翻译器通常可借助于 LR 分析器实现。
  • 在 S - 属性文法的基础上,LR 分析器可以改造为一个翻译器,在对输入串进行语法分析的同时对属性进行计算。
# L - 属性文法与语法制导定义

一个属性文法是 L - 属性文法(L-SDD),如果对于产生式 ∀A→X1X2…Xn∈P\forall A \rightarrow X_1 X_2 \dots X_n \in P,其每一个语义规则中的每一个属性都是一个综合属性,或者XjX_j(1≤j≤n1 \leq j \leq n)的一个继承属性仅依赖于:

  1. AA 的继承属性(不能是 AA 的综合属性);
  2. 产生式XjX_j 左边符号X1,X2,…,Xj−1X_1, X_2, \dots, X_{j-1} 的属性。

注:每一个 S - 属性文法都是 L - 属性文法。

L - 属性文法可以按照深度优先顺序计算属性

PROCEDURE Deepvisit(n:node);
BEGIN
  FOR n 的每个子结点 m,从左至右 DO
  BEGIN
    计算 m 的继承属性;
    Deepvisit(m)
  END;
  计算 n 的综合属性
END;

对于 L - 属性文法,Deepvisit 过程中既需要计算综合属性,又需要计算继承属性。根据 L - 属性文法,必须先判断哪些属性是继承属性,哪些是综合属性,在编程中容易混淆或出错。因此,有必要针对综合属性和继承属性设计一种表示方法,使得我们在编程时可以直观确定什么时候该计算哪种属性。

# 语法制导翻译方案

语法制导翻译方案是语法制导定义的一种便于翻译的书写形式。其中语义规则或语义动作用花括号{} 括起来,可被插入到产生式右部的任何合适的位置上。
这是一种语法分析和语义动作交错的表示法,它表达在按深度优先遍历分析树的过程中何时执行语义动作。
翻译模式给出了使用语义规则进行计算的顺序。可看成是分析过程中翻译的注释。

# 设计翻译模式(根据属性文法)

前提:语法制导定义是 L - 属性文法 / 定义保证语义动作不会引用还没有计算的属性值。

# 只有综合属性的情况

为每一个语义规则建立一个包含赋值的动作,并把这个动作放在相应的产生式右边的末尾。

# 既有综合属性又有继承属性
  • 产生式右边的符号的继承属性必须在这个符号以前的动作中计算出来,放在紧靠该符号的前面位置。
  • 一个动作不能引用这个动作右边符号的综合属性。
  • 产生式左边非终结符号的综合属性只有在它所引用的所有属性都计算出来以后才能计算。计算这种属性的动作通常可放在产生式右端的末尾。

# 翻译方案的设计

  • 只有综合属性的语法制导翻译方案
    • 适用于自底向上
    • 有左递归,可以改造成下一类 L 属性文法
  • 既有综合属性又有继承属性的语法制导翻译方案
    • 适用于自顶向下
    • 可以通过改造文法自底向上

# S - 属性文法与语法制导翻译

# S - 属性文法与自底向上的翻译

# 实现方法

LR 分析器增加语义栈,在对输入串进行语法分析的同时对属性进行计算。

picture 28

定义式 A→XYZ,A.a=f(X.x,Y.y,Z.z)A \rightarrow XYZ, A.a = f(X.x, Y.y, Z.z) 归约时对应的翻译是 val[ntop] = f(val[top-2] , val[top-1], val[top]) (具体可执行代码)。

在执行代码段之前找到归约后新的栈顶:

ntop := top - r + 1

其中, r 是句柄的长度。

执行代码后:

top = ntop

# S - 属性文法与自顶向下的翻译

  • 消除左递归、提取公因子
  • 将语义动作看成终结符,在其处于栈顶将要被弹出时执行该动作。
# 关于左递归翻译模式更一般化的讨论
  • 左递归 SDD

    A→A1Y{A.a:=g(A1.a,Y.y)}A→X{A.a:=f(X.x)}\begin{align*} A&\rightarrow A_1 Y \quad \{A.a := g(A_1.a, Y.y)\}\\ A&\rightarrow X \quad \{A.a := f(X.x)\} \end{align*}

    每一个文法符号都有一个综合属性,用相应的小写字母表示,gg 和ff 是任意函数。

  • 消除左递归,文法转换成

    A→XRR→YR∣ε\begin{align*} A&\rightarrow X R \\ R&\rightarrow Y R | \varepsilon \end{align*}

  • 再考虑语义动作,SDT 变为:

    A→X{R.i:=f(X.x)}R{A.a:=R.s}R→Y{R1.i:=g(R.i,Y.y)}R1{R.s:=R1.s}R→ε{R.s:=R.i}\begin{align*} A\rightarrow X& \quad \{R.i := f(X.x)\} \\ R& \quad \{A.a := R.s\} \\ R\rightarrow Y& \quad \{R_1.i := g(R.i, Y.y)\} \\ R_1& \quad \{R.s := R_1.s\} \\ R\rightarrow \varepsilon& \quad \{R.s := R.i\} \end{align*}

    经过转换的 SDT 引入了RR 的继承属性ii 和综合属性ss。

# L - 属性文法与语法制导翻译

# 递归下降翻译器的设计

L - 属性文法允许一次遍历就计算出所有属性值。

自上而下分析文法的分析过程,从概念上说可以看成是深度优先遍历语法树的过程,因此,可以在自上而下语法分析的同时实现 L 属性文法的计算。

# 在递归的预测分析过程中进行语义翻译

  • 为每个非终结符 A 构造一个函数,A 的每个继承属性对应该函数的一个形参,函数的返回值是 A 的综合属性值
  • 对出现在 A 产生式右部中的每个文法符号的每个属性都设置一个局部变量
  • 对于每个动作,将其代码复制到语法分析器,并把对属性的引用改为对相应变量的引用

# 在非递归的预测分析过程中进行语义翻译

  • 与 S 属性文法的自顶向下翻译类似
  • 注意文法具有左递归的处理
  • 处理方法
    • L 属性文法本身具有的继承属性,不做处理
    • 对综合属性,消除左递归时,计算顺序发生变化,因此要增加继承属性来辅助传递结果
    • 改成 SDT,进行分析(见 “S 属性文法与自顶向下的翻译” 一节)
  • 注意:语义动作看成终结符,并当其在栈顶将要弹出时,执行语义动作。属性计算结果放在另一个栈内。
  • 此时,语法栈和语义属性栈不同步。

# LR 分析过程中的语义翻译

一种可以自下而上的 L-SDD 的语法制导翻译方案

  • 可以实现任何基于 LL(1)文法的 L 属性文法
  • 也能实现许多(但不是所有)基于 LR(1)文法 L 属性文
    法
  • 给定一个以 LL 文法为基础的 L 属性文法,可以修改这个文法,并在 LR 语法分析过程中计算这个新文法之上的语义属性。
  • 修改后的属性文法,要求所有语义动作都位于产生式末尾(保证在归约的同时进行语义动作处理)

变换准则:引入新的标记性非终结符NN 和产生式N→εN\rightarrow \varepsilon,把嵌入在产生式中间的动作用非终结符NN 代替,并把这个动作放在产生式N→εN\rightarrow \varepsilon 后面.

# 中间代码生成

  • “中间代码生成” 程序的任务是:把经过语法分析和语义分析而获得的源程序中间表示翻译为中间代码表示。
  • 方法:语法制导翻译。
  • 采用独立于机器的中间代码的好处:
    • 便于进行与机器无关的代码优化;
    • 使编译程序改变目标机更容易;易于编译器的移植
    • 使编译程序的结构在逻辑上更为简单明确,以中间语言为界面,编译前端和后端的接口更清晰。

# 中间代码的表示

# 后缀式(逆波兰式)
  • 后缀式:把操作数写在前面,把算符写在后面。
  • 后缀式的构造方法:
    1. 如果 EE 是一个变量或常量,则 EE 的后缀式是 EE 自身。
    2. 如果 EE 是 E1 op E2E_1 \ \text{op} \ E_2 形式的表达式,这里 op\text{op} 是任何二元操作符,则 EE 的后缀式为 E1′ E2′ opE_1' \ E_2' \ \text{op},这里 E1′E_1' 和 E2′E_2' 分别为 E1E_1 和 E2E_2 的后缀式。
    3. 如果 EE 是 (E1)(E_1) 形式的表达式,则 EE 的后缀式就是 E1E_1 的后缀式。
# 图表示法
  • 图表示法包括 DAG(有向无环图)与 AST(抽象语法树)。
  • 相同点:对于表达式中的每个子表达式,图中都有一个结点。一个内部结点代表一个操作符,它的孩子代表操作数。
  • 不同点:在 DAG 图中代表公共子表达式的结点具有多个父结点,而在一棵抽象语法树中公共子表达式被表示为重复的子树。
    picture 29
# 三地址指令
  • 三地址代码是由下面一般形式的语句构成的序列: x:=y op z
  • 每条语句通常包含三个地址:两个操作数地址,一个操作结果地址
  • 地址可以是变量名、常量和编译器生成的临时变量
# 三地址指令的基本思想
  • 给每个中间变量和计算结果命名
    • 没有复合表达式
  • 只有最基本的控制流
    • 没有各种控制结构
    • 只有 goto , call 等
  • 所以三地址码可以看成是抽象的指令集
    • 通用的 RISC
# 常用三地址码
  • 形如 x := y op z 或 x := op z 的赋值指令;
  • 形如 x := y 的赋值指令;
  • 无条件跳转指令 goto L ;
  • 形如 if x goto L 的条件跳转指令;
  • 形如 if x relop y goto L 的条件跳转指令;
  • 过程调用和返回:
    • param x 用来指明参数;
    • 过程调用 call p, n 和函数调用 y = call p, n ;
    • return y 函数返回;
  • 形如 x := y[i] 和 x[i] := y 的变址赋值指令;
  • 形如 x := &y 、 x := *y 、 *x := y 的地址和指针赋值指令。
# 三地址码的具体形式
  1. 四元式: [op, arg1, arg2, result]
  2. 三元式: [op, arg1, arg2]
  3. 间接三元式:间接码表 + 三元式表

# 声明语句

  • 对于声明语句,语义分析的主要任务就是收集标识符的类型等属性信息,并为每一个名字分配一个相对地址
    • 相对地址:相对静态数据区基址或活动记录中局部数据区基址的一个偏移量。
    • 名字的类型和相对地址信息保存在相应的符号表记录中
  • 过程中的说明语句:一个过程中的所有说明语句作为一组来处理。用一个全程变量 Offset 来记录下一个数据在活动记录中的位置。

# 赋值语句

表达式的类型可以是整型、实型、字符型、数组。

  1. lookup(id.name)= id.entry | nil ,检查是否在符号表中存在相应此名字的表项,返回值为空或标识符在符号表的入口.
  2. emit ,将生成的三地址代码送到输出文件上。

# 布尔表达式

  • 布尔表达式:用布尔运算符号( and , or , not )作用到布尔变量或关系表达式上而组成。

  • 布尔表达式的作用:

    1. 用作计算逻辑值。
    2. 用作控制流语句如 if-then , if-then-else 和 while-do 等之中的条件表达式。
  • 本节考虑由如下文法生成的布尔表达式:

    E -> E or E
       | E and E
       | not E
       | (E)
       | id relop id
       | true
       | false
# 数值表示布尔值

用数值 1 和 0 分别表示真和假,从而对布尔表达式的求值可以像对算术表达式的求值那样一步一步地来计算

  • 用 1 和 0 表示真和假
  • a < b 改成 if a < b then 1 else 0
# 布尔表达式的数值表示法的 SDT
  • emit 用于将一个三地址语句输送到文件中
  • nextstat 给出下一条即将生成的三地址语句在输出序列中的序号
  • 每执行一次 emit 后, nextstat 自动加 1
# 用真假出口表示的翻译

作为其他语句的条件改变控制流程时使用,隐含着程序的位置。例: A or B 如果 A 为真,那么 B 的值就不必计算,此时 A or B 的值已定,为真。同理, A and B 如果 A 为假,那么 B 的值就不必计算,此时 A and B 的值已定,为假。用于翻译控制流语句中的布尔表达式尤其方便。

  • 条件语句 if E then S1 else S2 ,赋予 E 两个出口,一个为真,一个为假
    picture 30

  • if a > c or b < d then S1 else S2 翻译成三地址代码

if a > c goto L2  // “真”出口
    goto L1
L1: if b < d goto L2  // “真”出口
    goto L3  // “假”出口
L2: (关于 S1 的三地址代码序列)
    goto Lnext
L3: (关于 S2 的三地址代码序列)
Lnext:
# 真假出口布尔表达式三地址代码的属性文法
  • 语义函数 newlabel ,返回一个新的符号标号
  • 对于一个布尔表达式 E ,设置两个继承属性
    • E.true 是 E 为‘真’时控制流转向的标号
    • E.false 是 E 为‘假’时控制流转向的标号
  • E.code 记录 E 生成的三地址代码序列
  • S.next 记录 S 紧跟在后面的三地址码指令的标号

a < b 如何翻译?

if a < b goto E.true
goto E.false
产生式 语义规则
E → id₁ relop id₂ E.code := gen('if ' id₁.place relop.op id₂.place 'goto' E.true) + gen('goto' E.false)
E → E₁ or E₂ E₁.true := E.true;
E₁.false := newlabel;
E₂.true := E.true;
E₂.false := E.false;
E.code := E₁.code + gen(E₁.false ':') + E₂.code
E → E₁ and E₂ E₁.true := newlabel;
E₁.false := E.false;
E₂.true := E.true;
E₂.false := E.false;
E.code := E₁.code + gen(E₁.true ':') + E₂.code
# 回填
  • 两遍扫描:
    • 从给定的输入构造出一棵语法树;
    • 对语法树按深度优先遍历,来进行定义中给出的翻译。
  • 一遍扫描:
    • 先产生暂时没有填写目标标号的转移指令。
    • 对于每一条这样的指令作适当的记录,一旦目标标号被确定下来,再将它 “回填” 到相应的指令中。

要解决的问题:在一遍扫描中,生成跳转语句时,不知道控制要转向的语句标号。

解决方法:生成跳转语句时,将其 E.true 和 E.false 分别链成一个链表,记录在 E.truelist 和 E.falselist 中。等到转移目标确定以后,再将转移出口填入 E.truelist 和 E.falselist 中。

插入非终结符号 M 是为了引入一个语义动作,以便在适当的时候获得即将产生的下一个四元式的索引,或说四元式的序号。

SDT 用到如下三个函数:

  • makelist(i) :创建一个仅包含 i 的新表, i 是一个四元式的序号。其实, makelist(i) 的返回值就是 i 。

  • merge(p1, p2) :连接由指针 p1 和 p2 指向的两个表并且返回一个指向连接后的表的指针。

    function merge(p1, p2): pointer {
      if p2 = 0 then
        merge = p1
      else {
        p = p2 // 使指针 p 指向 p2 的尾部
        while 四元式 p 的第 4 分量内容 != 0 do {
          p = 四元式 p 的第 4 分量内容
        }
        把 p1 填入四元式 p 的第 4 分量
        merge = p2
      }
    }
  • backpatch(p, t) :把 t 作为目标标号回填到 p 所指向的表中的每一个转移指令中去。此处的 “表” 都是为 “反填” 所拉的链。代码如下:

    Procedure BACKPATCH(P, t)
    {
      Q = P;
      while (Q) {
        L = 四元式 Q 的第 4 分量内容;
        把 t 填入四元式 Q 的第 4 分量;
        Q = L;
      }
    }
# 使用一遍扫描的布尔表达式的翻译模式

布尔表达式文法:

E→E1 or M E2∣E1 and M E2∣not E1∣(E1)∣id1 relop id2∣true∣falseM→ε\begin{align} E \rightarrow &E_1 \ \text{or} \ M \ E_2 \\ &|E_1 \ \text{and} \ M \ E_2 \\ &|\text{not} \ E_1 \\ &|(E_1) \\ &|\text{id}_1 \ \text{relop} \ \text{id}_2 \\ &|\text{true} \\ &|\text{false} \\ M \rightarrow &\varepsilon \end{align}

8 M -> ε { M.quad := nextquad }
1 E -> E1 or M E2
  { backpatch(E1.falselist, M.quad);
    E.truelist := merge(E1.truelist, E2.truelist);
    E.falselist := E2.falselist; }
2 E -> E1 and M E2
  { backpatch(E1.truelist, M.quad);
    E.truelist := E2.truelist;
    E.falselist := merge(E1.falselist, E2.falselist); }
3 E -> not E1
  { E.truelist := E1.falselist;
    E.falselist := E1.truelist; }
4 E -> (E1)
  { E.truelist := E1.truelist;
    E.falselist := E1.falselist; }
5 E -> id1 relop id2
  { E.truelist := makelist(nextquad);
    E.falselist := makelist(nextquad + 1);
    emit('if' + id1.place + relop.op + id2.place + 'goto - ');
    emit('goto - '); }
6 E -> true
  { E.truelist := makelist(nextquad);
    emit('goto - '); }
7 E -> false
  { E.falselist := makelist(nextquad);
    emit('goto - '); }

# 控制流语句

S→if E then S1∣if E then S1 else S2∣while E do S1\begin{align*} S \rightarrow &\text{if} \ E \ \text{then} \ S_1 \\ &|\text{if} \ E \ \text{then} \ S_1 \ \text{else} \ S_2 \\ &|\text{while} \ E \ \text{do} \ S_1 \\ \end{align*}

# if-then 语句

picture 31

S → if E then S1
  { E.true := newlabel;
    E.false := S.next;
    S1.next := S.next;
    S.code := E.code || emit(E.true, ':') || S1.code }
# if-then-else 语句

picture 32

S → if E then S1 else S2
  { E.true := newlabel;
    E.false := newlabel;
    S1.next := S.next;
    S2.next := S.next;
    S.code := E.code || emit(E.true, ':') || S1.code
              || emit('goto', S.next) || emit(E.false, ':') || S2.code }
# while-do 语句

picture 33

S -> while E do S1
  { S.begin := newlabel;
    E.true := newlabel;
    E.false := S.next;
    S1.next := S.begin;
    S.code := emit(S.begin, ':') || E.code || emit(E.true, ':') || S1.code || emit('goto', S.begin) }
总访问量:加载中...更新于