编译原理期末复习

少了代码优化的那道题，那道题是22-秋占分最大的题，也要好好复习。

词法分析

2018

2019

2020

语法分析

2018

2019

2020

语法制导翻译

2018

三.语法制导翻译(10分)
考虑以下文法：
S → id = E | if E then S | while E do S | begin S; S end | break
写出一个翻译方案，其语义动作的作用是：若发现break不是出现在循环语句中，及时报告错误。

S‘ → {S.loop = false} S
S → id = E 
S → if E then {S1.loop = S.loop} S1
S → begin {S1.loop = S.loop} S1; {S2.loop = S.loop} S2 end
S → break {if(S.loop==false) print("Error\n")}

2019

三.语义分析和语法制导翻译（20分）
考虑描述表达式规则的文法CFG，其非终结符集合为{E},终结符集合为{n, true, false}。文法产生式如下:

E -> n    | true    | false    | E + E | E && E

假设其语义规则为：每个表达式E都有一个类型，且E+E类型的表达式中两个子表达式都必须是整型的n，E && E类型的表达式中两个子表达式都必须是布尔型的true或false。
回答以下问题：
1）（10分）给出一段伪代码，能完成上述语言的语义分析，当输入表达式语义错误时报错，否则返回输入表达式的类型（假设抽象语法树已经建立好，词法分析已完成）；
2）（10分）用语法制导定义SDD的方法描述上述语义分析的语义动作，并指出该SDD中的属性哪些是综合属性、哪些是继承属性。

(1)伪代码如下：

Type process(E){
    if(E的类型为int或bool) return E的类型;
    else if(E的类型为加法表达式){
        if(process(E的左子表达式)和process(E的右子表达式)结果均为整型) {
            计算E的值;
            return E的类型;
        }
        else {
            print("Error\n");
            exit(1);
        }
    }
    else{
        if(process(E的左子表达式)和process(E的右子表达式)结果均为布尔型) {
            计算E的值;
            return E的类型;
        }
        else {
            print("Error\n");
            exit(1);
        } 
    }
}

(2)

E → n {E.type = int}
E → true {E.type = bool;E.val = true}
E → false{E.type = bool;E.val = false}
E → E1 + E2 {if(E1.type!=int || E2.type!=int) print("error");
                        else{
                                E.type = int;
                                E.val = E1.val + E2.val
                        }
                        }
E → E1 && E2 {if(E1.type!=bool || E2.type!=bool) print("error");
                        else{
                                E.type = bool;
                                E.val = E1.val && E2.val
                        }
                        }

type和val均为综合属性

样题

E → T {R.i = T.val} R {E.val = R.s}
R → + T {R1.i = R.i + T.val} R1 {R.s = R1.s}
R → - T {R1.i = R.i - T.val} R1 {R.s = R1.s}
R → ε {R.s = R.i}
T → (E) {T.val = E.val}
T → num {T.val = num.val}