第 四 章 课 后 习 题

T 4.1

根据表4.1的语法制导定义，为输入表达式$5\ast (4\ast 3+2)$构造注释分析树。

---

T 4.2

构造表达式$((a\ast b)+(c))$的分析树和语法树：

（a）根据表4.3的语法制导定义。

（b）根据图4.9的翻译方案。

有关“分析树”和“语法树”：

语法分析树和语法树不是一种东西。习惯上，我们把前者叫做“具体语法树”，其能够体现推导的过程；后者叫做“抽象语法树”，其不体现过程，只关心最后的结果。

语法分析树的定义：

对于 CFG G 的句型，分析树被定义为具有下述性质的一棵树：

1. 根由开始符号所标记；
2. 每个叶子由一个终结符、非终结符或 ε 标记；
3. 每个内部节点都是非终结符；
4. 若 $A$ 是某节点的内部标记，且 $X_1$、$X_2$、…、$X_n$ 是该节点从左到右的所有孩子的标记。则：$A\to X_1{X}_2...X_n$ 是一个产生式。若 A→ε，则标记为 $A$ 的节点可以仅有一个标记为 $\epsilon$ 的孩子。若 $A\to \epsilon$ ，则标记为 $A$ 的节点可以仅有一个标记为 $\epsilon$ 的孩子。

简而言之，利用产生式推导出句型G的过程以树的形式表现。

语法树的定义：

对于 CFG G 的句型，语法树被定义为具有下述性质的一棵树：

1. 根与内部节点由表达式中的操作符标记；
2. 叶子由表达式中的操作数标记；
3. 用于改变运算优先级和结合性的括号，被隐含在语法树的结构中。

简而言之，叶子全是操作数，内部全是操作符，树里没有非终结符也不能有括号。

---

T 4.3

为文法
$$\begin{gathered} S\to (L)|a \\ L\to L,S|S \end{gathered}$$
（a）写一个语法制导定义，它输出括号的对数。
$$\begin{array}{lcc}{S}^{\prime }\to S\text{n}& & print(S.val)\\ S\to (L)& & S.val=L.val+1\\ S\to a& & S.val=0\\ S\to L,S_1& & L.val=L.val+S_1.val\\ L\to S& & L.val=S.val\end{array}$$
（b）写一个语法制导定义，它输出括号嵌套的最大深度。
$$\begin{array}{lcc}{S}^{\prime }\to S\text{n}& & print(S.val)\\ S\to (L)& & S.val=L.val+1\\ S\to a& & S.val=0\\ S\to L,S_1& & L.val=max(L.val,S_1.val)\\ L\to S& & L.val=S.val\end{array}$$
红色部分为二者的不同之处。

---

T 4.4

下面的文法定义语言 L = { a n b n c m ∣ m , n ≥ 1 } L= \{a^n b^n c^m| m,n ≥1\} L={anbncm∣m,n≥1}。写一个语法制导定义，其语义规则的作用是：对不属于语言$L$的子集 L 1 = { a n b n c n ∣ n ≥ 1 } L_1= \{a^n b^n c^n| n ≥1\} L1​={anbncn∣n≥1}的句子，打印出错信息。
$$\begin{gathered} S\to DC \\ D\to aDb|ab \\ C\to Cc|c \end{gathered}$$
语法制导定义如下：
$$\begin{array}{lcc}S\to DC& & ifD.length\ne C.lengththenprint(‘‘error”)\\ D\to ab& & D.length=1\\ D\to a{D}_{1}b& & D.length=D_1.length+1\\ C\to c& & D.length=1\\ C\to C_{1}c& & C.length=C_1.length+1\end{array}$$

---

T 4.5

为下面文法写一个语法制导的定义，它完成一个句子的$while-do$最大嵌套层次的计算并输出这个计算结果。
$$\begin{gathered} S\to E \\ E\to \text{while}E\text{do}E|\text{id}:=E|E+E|\text{id}|(E) \end{gathered}$$
语法制导定义如下：
$$\begin{array}{lcc}S\to E& & print(S.loop)\\ E\to \text{while}{E}_1\text{do}{E}_2& & E.loop=max(E_1.loop,E_2.loop)+1\\ E\to \text{id}:=E& & E.loop=E_1.loop\\ E\to E_1+E2& & E.loop=max(E_1.loop,E_2.loop)\\ E\to \text{id}& & E.loop=0\\ E\to (E_1)& & E.loop:=E_1.loop\end{array}$$

---

T 4.6

下列文法产生由$+$作用于整常数或实常数的表达式。两个整数相加时，结果是整型，否则是实型。
$$\begin{gathered} E\to E+T|T \\ T\to \text{num}.\text{num}|\text{num} \end{gathered}$$
( a）给出决定每个子表达式类型的语法制导定义。
$$\begin{array}{lcc}E\to E_1+T& & if(E_1.type==integer)and(T.type==integer)then\\ & & E.type=integer\\ & & else\\ & & E.type=real\\ E\to T& & E.type=T.type\\ T\to \text{num}.\text{num}& & T.type=real\\ T\to \text{num}& & T.type=integer\end{array}$$
( b）扩充（a）的语法制导定义，既决定类型，又把表达式翻译成后缀表示。使用一元算符$inttoreal$把整数变成等价的实数,使得后缀式中$+$的两个对象有同样的类型。
$$\begin{array}{lcc}E\to E_1+T& & if(E_1.type==integer)and(T.type==integer)then\\ & & E.type=integer\\ & & print{(}^{\prime }{+}^{\prime },E_1.val,T.val)\\ & & else\\ & & E.type=real\\ & & if{E}_1.type=integerthen\\ & & E_1.type=real\\ & & E_1.val=inttoreal(E_1.val)\\ & & ifT.type=integerthen\\ & & T.type=real\\ & & T.val=inttoreal(T.val)\\ & & print{(}^{\prime }{+}^{\prime },E_1.val,T.val)\\ E\to T& & E.type=T.type\\ & & E.val=T.val\\ T\to \text{num}.\text{num}& & T.type=real\\ & & T.val=\text{num}.\text{num}.lexval\\ T\to \text{num}& & T.type=integer\\ & & T.val=\text{num}.lexval\end{array}$$

---

T 4.7

给出对表达式求导数的语法制导定义，表达式由$+$和$\ast$作用于变量x和常数组成，如$x\ast (3\ast x+x\ast x)$，并假定没有任何化简，例如将$3\ast x$翻译成$3\ast 1+0\ast x$。

经分析可知对每个文法符号需要有两个属性

• $.exp$ 用来记录原表达式
• $.s$ 用来记录该表达式求导的结果
• $||$ 用来表示串拼接

$$\begin{array}{lcc}{E}^{\prime }\to E\text{n}& & print(E.s)\\ E\to E_1+T& & E.exp=E_1.exp||{}^{\prime }{+}^{\prime }||T.exp\\ & & E.s=E_1.s||{}^{\prime }{+}^{\prime }T.s\\ E\to T& & E.exp=T.exp\\ & & E.s=T.s\\ T\to T_1\ast F& & T.exp=T_1.exp||{}^{\prime }{\ast }^{\prime }F.exp\\ & & T.s{=}^{\prime }{(}^{\prime }||T_1.s||{}^{\prime }{)}^{\prime }||{}^{\prime }{\ast }^{\prime }||F.exp||{}^{\prime }{+}^{\prime }||T.exp||{}^{\prime }{\ast }^{\prime }||F.s\\ T\to F& & T.exp=F.exp\\ & & T.s=F.s\\ F\to (E)& & F.exp{=}^{\prime }{(}^{\prime }||E.exp||{}^{\prime }{)}^{\prime }\\ & & F.s{=}^{\prime }{(}^{\prime }||E.s||{}^{\prime }{)}^{\prime }\\ F\to \text{num}& & F.exp=\text{num}.lexme\\ & & F.s{=}^{\prime }{0}^{\prime }\\ F\to \text{x}& & F.exp{=}^{\prime }{\text{x}}^{\prime }\\ & & F.s{=}^{\prime }{\text{1}}^{\prime }\end{array}$$

---

T 4.8

给出把中缀表达式翻译成没有冗余括号的中缀表达式的语法制导定义。例如，因为$+$和$\ast$是左结合，$((a\ast (b+c))\ast (d))$可以重写成$a\ast (b+c)\ast d$。

两种方法：

1. 先把表达式的括号都去掉，然后在必要的地方再加括号
2. 去掉表达式中的冗余括号，保留必要的括号

第一种方法：

• $.exp$ 用来记录表达式
• $||$ 用来表示串拼接

$$\begin{array}{lcc}S\to E& & print(E.exp)\\ E\to E_1+T& & ifT.op={=}^{\prime }{+}^{\prime }then\\ & & E.exp=E_1.exp||{}^{\prime }{+}^{\prime }||{}^{\prime }{(}^{\prime }||T.exp||{}^{\prime }{)}^{\prime }\\ & & else\\ & & E.exp=E_1.exp||{}^{\prime }{+}^{\prime }||T.exp\\ & & E.op=T.op\\ E\to T& & E.exp=T.exp\\ & & E.op=T.op\\ T\to T_1\ast F& & if(F.op={=}^{\prime }{+}^{\prime })or(F.op={=}^{\prime }{\ast }^{\prime })then\\ & & if{T}_1.op={=}^{\prime }{+}^{\prime }then\\ & & T.exp{=}^{\prime }{(}^{\prime }||T_1.code||{}^{\prime }{)}^{\prime }||{}^{\prime }{\ast }^{\prime }||{}^{\prime }{(}^{\prime }||F.exp||{}^{\prime }{)}^{\prime }\\ & & else\\ & & T.exp=T_1.exp||{}^{\prime }{\ast }^{\prime }||{}^{\prime }{(}^{\prime }||F.exp||{}^{\prime }{)}^{\prime }\\ & & elseif{T}_1.op={=}^{\prime }{+}^{\prime }then\\ & & T.exp{=}^{\prime }{(}^{\prime }||T_1.exp||{}^{\prime }{)}^{\prime }||{}^{\prime }{\ast }^{\prime }||F.exp\\ & & else\\ & & T.exp=T_1.exp||{}^{\prime }{\ast }^{\prime }||F.exp\\ & & T.op{=}^{\prime }{\ast }^{\prime }\\ T\to F& & T.exp=F.exp\\ & & T.op=F.op\\ F\to \text{id}& & F.exp=\text{id}.lexme\\ & & F.op=\text{id}\\ F\to (E)& & F.exp=E.exp\\ & & F.op=E.op\end{array}$$

第二种方法：

• 给$E$、$T$和$F$两个继承属性$lef{t}_{o}p$和$righ{t}_{o}p$分别表示左右两侧算符的优先级
• 给它们一个综合属性$sel{f}_{o}p$表示自身主算符的优先级
• 再给一个综合属性$code$表示没有冗余括号的表达式
• 分别用1和2表示加和乘的优先级，用3表示$id$和$(E)$的优先级，用0表示左侧或右侧没有运算对象的情况

$$\begin{array}{lcc}S\to E& & E.left\_op=0\\ & & E.right\_op=0\\ & & print(E.exp)\\ E\to E_1+T& & E_1.left\_op=E.left\_op\\ & & E_1.right\_op=1\\ & & T.left\_op=1\\ & & T.right\_op=E.right\_op\\ & & E.exp=E_1.exp||{}^{\prime }{+}^{\prime }||T.exp\\ & & E.self\_op=1\\ E\to T& & T.left\_op=E.left\_op\\ & & T.right\_op=E.right\_op\\ & & E.exp=T.exp\\ & & E.self\_op=T.self\_op\\ T\to T_1\ast F& & if(F.op={=}^{\prime }{+}^{\prime })or(F.op={=}^{\prime }{\ast }^{\prime })then\\ & & if{T}_1.op={=}^{\prime }{+}^{\prime }then\\ & & T.exp{=}^{\prime }{(}^{\prime }||T_1.code||{}^{\prime }{)}^{\prime }||{}^{\prime }{\ast }^{\prime }||{}^{\prime }{(}^{\prime }||F.exp||{}^{\prime }{)}^{\prime }\\ & & else\\ & & T.exp=T_1.exp||{}^{\prime }{\ast }^{\prime }||{}^{\prime }{(}^{\prime }||F.exp||{}^{\prime }{)}^{\prime }\\ & & elseif{T}_1.op={=}^{\prime }{+}^{\prime }then\\ & & T.exp{=}^{\prime }{(}^{\prime }||T_1.exp||{}^{\prime }{)}^{\prime }||{}^{\prime }{\ast }^{\prime }||F.exp\\ & & else\\ & & T.exp=T_1.exp||{}^{\prime }{\ast }^{\prime }||F.exp\\ & & T.op{=}^{\prime }{\ast }^{\prime }\\ T\to F& & T.exp=F.exp\\ & & T.op=F.op\\ F\to \text{id}& & F.exp=\text{id}.lexme\\ & & F.self\_op=3\\ F\to (E)& & E.left\_op=0\\ & & E.right\_op=0\\ & & F.self\_op=\\ & & if(F.left\_op<E.self\_op)and(E.self\_op>=F.right\_op)then\\ & & E.self\_op\\ & & else\\ & & 3\\ & & F.exp=\\ & & if(F.left\_op<E.self\_op)and(E.self\_op>=F.right\_op)then\\ & & E.exp\\ & & else\\ & & {}^{\prime }{(}^{\prime }||E.exp||{}^{\prime }{)}^{\prime }\end{array}$$

---

T 4.9

用$S$的综合属性$val$给出下面文法中$S$产生的二进制数的值。例如，输入$101.101$时，$S.val=5.625$。
$$\begin{gathered} S\to L.L|L \\ L\to LB|B \\ B\to 0|1 \end{gathered}$$
（a）仅用综合属性决定$S.val$。
$$\begin{array}{lcc}S\to L_1.L_2& & S.val=L_1.val+L_2.val/power(2,L_2.length)\\ S\to L& & S.val=L.val\\ L\to L_{1}B& & L.val=L1.val\ast 2+B.val\\ & & L.length=L_1.length+1\\ L\to B& & L.val=B.val\\ & & L.length=1\\ B\to 0& & B.val=0\\ B\to 1& & B.val=1\end{array}$$

（b）用$L$属性定义决定$S.val$。在该定义中，$B$的唯一综合属性是$c$（还需要继承属性），它给出由$B$产生的位对最终值的贡献。例如，$101.101$的最前一位和最后一位对值$5.625$的贡献分别是$4$和$0.125$。

先将文法改写为：
$$\begin{gathered} S\to L.R|L \\ L\to BL|B \\ R\to RB|B \\ B\to 0|1 \end{gathered}$$
所求语法制导定义如下，其中$i$是$B$的继承属性，$val$和$c$是综合属性。
$$\begin{array}{lcc}S\to L.R& & S.val=L.val+R.val\\ S\to L& & S.val=L.val\\ L\to B{L}_1& & B.i=L_1.c\ast 2\\ & & L.c=L_1.c\ast 2\\ & & L.val=L_1.val+B.c\\ L\to B& & B.i=1\\ & & L.c=1\\ & & L.val=B.c\\ R\to R_{1}B& & B.i=R_1.c/2\\ & & R.c=R_1.c/2\\ & & R.val=R_1.val+B.c\\ R\to BB.i=0.5& & \\ & & R.c=0.5\\ & & R.val=B.c\\ B\to 0& & B.c=0\\ B\to 1& & B.c=B.i\end{array}$$
分析：首先，从$B$推出的串是不可能知道这个$B$在串中的具体位置的，因此也不可能计算它的贡献。这样$B$必须有继承属性，它被用来计算$B$的贡献。对于一个二进制数，如$101.101$，对于小数点前的$1$，我们需要知道它处在从右向左数的第几位上；而对于小数点后的$1$，我们需要知道它处在从左向右数的第几位上。考察原来的文法，从下面左图的分析树可以看出，不管是小数点前还是后，它都是一种自左向右的归约，适合于自左向右地计数。这样，小数点左边就需要用继承属性来计数，这就增加了难度。而且，由于小数点左右都是用非终结符$L$，那么，$L$就即要有综合属性来用于从自左向右地计数，又要有继承属性来用于自右向左地计数，显然语法制导定义的难度会大大增加。所以我们采用改写文法的办法，让分析树是右图的形式。这样，小数点两边的归约方式不一样，适合于不同方向的计数，使我们的语法制导定义能简洁得多。

---

T 4.10

重写例4.3语法制导定义的基础文法,然后重新设计语法制导定义，使得仅用综合属性就能把类型信息填入符号表。

改写后文法和语法制导定义为：
$$\begin{array}{lcc}L\to T\text{id}& & L.type=T.type\\ & & addtype(\text{id}.entry,L.type)\\ L\to L_1,\text{id}& & L.type=L1.type\\ & & addtype(\text{id}.entry,L.type)\\ T\to \text{int}& & T.type=integer\\ T\to \text{real}& & T.type=\text{real}\end{array}$$

---

T 4.12

文法如下：
$$\begin{gathered} S\to (L)|a \\ L\to L,S|S \end{gathered}$$
（a）写一个翻译方案，它输出每个$a$的嵌套深度。例如，对于句子$(a,(a,a))$，输出的结果是$122$。
S ′ → { S . d e p t h = 0 } S S → { L . d e p t h = S . d e p t h + 1 } ( L ) S → a { p r i n t ( S . d e p t h ) } L → { L 1 . d e p t h = L . d e p t h } L 1 , { S . d e p t h = L . d e p t h } S L → { S . d e p t h = L . d e p t h } S \left. \begin{array}{l} % 左对齐 S'\rightarrow &&& \{S.depth=0\} \\ & S \\ S\rightarrow &&& \{L.depth = S.depth + 1\} \\ & (L) \\ S\rightarrow a &&& \{print(S.depth)\} \\ L\rightarrow &&& \{L_1.depth=L.depth\} \\ & L_1, && \{S.depth = L.depth\} \\ & S \\ L\rightarrow &&& \{S.depth = L.depth\} \\ & S \\ \end{array} \right. S′→S→S→aL→L→​S(L)L1​,SS​​{S.depth=0}{L.depth=S.depth+1}{print(S.depth)}{L1​.depth=L.depth}{S.depth=L.depth}{S.depth=L.depth}​

（b）写一个翻译方案，它打印出每个$a$在句子中是第几个字符。例如，当句子是$(a,(a,(a,a),(a)))$时，打印的结果是$2581014$。
S ′ → { S . i n = 0 } S S → { L . i n = S . i n + 1 } ( L ) { S . o u t = L . o u t + 1 } S → a { S . o u t = S . i n + 1 ; p r i n t ( S . o u t ) } L → { L 1 . i n = L . i n } L 1 , { S . i n = L 1 . o u t + 1 } S { L . o u t = S . o u t } L → { S . i n = L . i n } S { L . o u t = S . o u t } \left. \begin{array}{l} % 左对齐 S'\rightarrow &&&\{S.in=0\} \\ & S \\ S\rightarrow &&& \{L.in=S.in+1\} \\ & (L) && \{S.out = L.out + 1\} \\ S\rightarrow & a && \{S.out = S.in+1;print(S.out)\} \\ L\rightarrow &&& \{L_1.in=L.in\} \\ & L_1, && \{S.in = L_1.out+1\} \\ & S && \{L.out= S.out\} \\ L\rightarrow &&& \{S.in = L.in\} \\ & S && \{L.out = S.out\} \\ \end{array} \right. S′→S→S→L→L→​S(L)aL1​,SS​​{S.in=0}{L.in=S.in+1}{S.out=L.out+1}{S.out=S.in+1;print(S.out)}{L1​.in=L.in}{S.in=L1​.out+1}{L.out=S.out}{S.in=L.in}{L.out=S.out}​

---

T 4.13

语句的文法如下：
$$S\to \text{id}:=E|\text{if}E\text{then}S|\text{while}E\text{do}S|\text{begin}S;S\text{end}|\text{break}$$
写一个翻译方案，其语义动作的作用是：若发现break不是出现在循环语句中，及时报告错误。
S ′ → { S . l o o p = f a l s e } S S → id : = E S → if   E   then { S 1 . l o o p = S . l o o p } S 1 S → while   E   do { S 1 . l o o p = t r u e } S 1 S → begin { S 1 . l o o p = S . l o o p } S 1 ; { S 2 . l o o p = S . l o o p } S 2   end S → break { i f   n o t   S . l o o p   t h e n   p r i n t ( ′ e r r o r ′ ) } \left. \begin{array}{l} % 左对齐 S'\rightarrow &&& \{S.loop=false\} \\ &S \\ S\rightarrow & \textbf{id}:=E \\ S\rightarrow & \textbf{if}\space E \space \textbf{then} && \{S_1.loop = S.loop\} \\ & S_1 \\ S\rightarrow &\textbf{while} \space E\space \textbf{do} && \{S_1.loop=true\} \\ & S_1 \\ S\rightarrow & \textbf{begin} && \{S_1.loop = S.loop\}\\ & S_1; && \{S_2.loop=S.loop\}\\ & S_2\space \textbf{end} \\ S\rightarrow &\textbf{break} && \{if \space not \space S.loop \space then \space print('error')\} \end{array} \right. S′→S→S→S→S→S→​Sid:=Eif E thenS1​while E doS1​beginS1​;S2​ endbreak​​{S.loop=false}{S1​.loop=S.loop}{S1​.loop=true}{S1​.loop=S.loop}{S2​.loop=S.loop}{if not S.loop then print(′error′)}​

---

T 4.14

程序的文法如下：
$$\begin{gathered} P\to D \\ D\to D;D|\text{id}:T|\text{proc}\text{id};D;S \end{gathered}$$
（a）写一个语法制导定义，打印该程序一共声明了多少个$\text{id}$。

$s$是$D$的综合属性，用于$D$中 $\text{id}$ 的个数。
$$\begin{array}{lcc}P\to D& & print(D.s)\\ D\to D_1;D_2& & print(D.s=D_1.s+D_2.s)\\ D\to \text{id}:T& & D.s=1\\ D\to \text{proc}\text{id};D_1;S& & D.s=D_1.s+1\end{array}$$
（b）写一个翻译方案，打印该程序每个变量$\text{id}$的嵌套深度。

$i$为$D$的继承属性，用于计算$D$所在的程序嵌套深度。
P → { D . i = 1 } D D → { D 1 . i = D . i } D 1 ; { D 2 . i = D . i } D 2 D → id : T { p r i n t ( D . i ) } D → proc   id ; { D 1 . i = D . i + 1 } D 1 ; S \left. \begin{array}{l} % 左对齐 P\rightarrow &&& \{D.i = 1\} \\ & D \\ D\rightarrow &&& \{D_1.i = D.i\} \\ & D_1; && \{D_2.i = D.i\} \\ & D_2 \\ D\rightarrow & \textbf{id} : T && \{print(D.i)\} \\ D\rightarrow & \textbf{proc} \space \textbf{id}; && \{D_1.i = D.i + 1\} \\ & D_1;S\\ \end{array} \right. P→D→D→D→​DD1​;D2​id:Tproc id;D1​;S​​{D.i=1}{D1​.i=D.i}{D2​.i=D.i}{print(D.i)}{D1​.i=D.i+1}​