编译原理 | 第三章课后习题答案

已于 2023-07-14 11:55:15 修改
阅读量4w 收藏 601
点赞数 65
分类专栏： 编译原理 文章标签： 算法 c语言 学习方法 学习 经验分享
于 2023-05-27 15:50:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sun80760/article/details/130896512
版权

本文为编译原理（第三版）【清华大学出版社】部分课后答案
本答案均截取自网络，如有错误，望指正

编译原理（第三版）【清华大学出版社】
编译原理（第三版）【清华大学出版社】

📌第1题

【题目】

 【答案】

 

 

1.void MatchToken(char expected)  
2.{
3.   if (lookahead != expected)  
4.    {  
5.        printf("syntax error \n");  
6.        exit(0);  
7.    }  
8.    else  
9.    {  
10.        lookahead = getToken();  
11.    }  
12.}  
13.// 解析非终结符T:T→ST’
14.void ParseT()  
15.{  
16.    if (lookahead == 'a' || lookahead == '⋀' || lookahead == '(')  
17.      ParseS();
18.      ParseT′();
19.   else {  
20.        printf("syntax error \n");  
21.        exit(0);
22.      } 
23.}
24.// 解析非终结符T’:T’→,ST’|
25.void ParseT′()
26.{
27.   if (lookahead == ',')
28.         {
29.          MatchToken(',');  
30.          ParseS();
31.          ParseT′();
32.        }
33.    else if (lookahead == ')')  
34.       {  
35.       }  
36.    else {  
37.        printf("syntax error \n");  
38.        exit(0);
39.      } 
40.}
41.// 解析非终结符S→a||(T)
42.void ParseS()  
43.{  
44.    switch (lookahead)  
45.    {  
46.    case 'a':  
47.        MatchToken('a');;  
48.        break;  
49.    case '⋀':  
50.        MatchToken('⋀');;  
51.        break;  
52.    case '(':  
53.        MatchToken('(');  
54.        ParseT();  
55.        MatchToken(')');  
56.       break;  
57.default:  
58.       printf("syntax error \n");  
59.        exit(0);
        }

📌第2题

【题目】

 【答案】 

1.void MatchToken(char expected)  
2.{
3.   if (lookahead != expected)  
4.    {  
5.        printf("syntax error \n");  
6.        exit(0);  
7.    }  
8.    else  
9.    {  
10.        lookahead = getToken();  
11.    }  
12.}  
13.// 解析非终结符E
14.void ParseE()  
15.{  
16.    if (lookahead == '(' || lookahead == 'a' || lookahead == 'b' || lookahead == '⋀')  
17.    {  
18.        ParseT();  
19.        ParseE′();  
20.    }  
21.    else  
22.    {  
23.        printf("syntax error \n");  
24.        exit(0);  
25.    }  
26.}  
27.// 解析非终结符E′
28.void ParseE′()  
29.{  
30.    if (lookahead == '+')  
31.    {  
32.        MatchToken(')');  
33.        ParseE();  
34.    }  
35.    else if (lookahead == ')' || lookahead == '#')  
36.    {  
37.    }  
38.    else  
39.    {  
40.        printf("syntax error \n");  
41.        exit(0);  
42.    }  
43.}
44.// 解析非终结符T
45.void ParseT()  
46.{  
47.    switch (lookahead)  
48.    {  
49.    case '(', 'a', 'b', ' ⋀':  
50.        ParseF();  
51.        ParseT′();  
52.        break;  
53.    default:  
54.        printf("syntax error \n");  
55.        exit(0);  
56.    }  
57.}  
58.// 解析非终结符T′ 
59.void ParseT′()  
60.{  
61.    switch (lookahead)  
62.    {  
63.    case '(', 'a', 'b', ' ⋀':  
64.        ParseT();  
65.        break;  
66.    case '+', ' )', '#':  
67.        break;  
68.    default:  
69.        printf("syntax error \n");  
70.        exit(0);  
71.    }  
72.}  
73.// 解析非终结符F
74.void ParseF()  
75.{  
76.    switch (lookahead)  
77.    {  
78.    case '(', 'a', 'b', ' ⋀':  
79.        ParseP();  
80.        break;  
81.    default:  
82.        printf("syntax error \n");  
83.        exit(0);  
84.    }  
85.}  
86.// 解析非终结符F′
87.void ParseF′()  
88.{  
89.    switch (lookahead)  
90.    {  
91.    case '*':  
92.        MatchToken('*');  
93.        ParseF’();  
94.        break;  
95.    case '+', '(', ')', 'a', 'b', ' ⋀', '#':  
96.        break;  
97.    default:  
98.        printf("syntax error \n");  
99.        exit(0);  
100.    }  
101.}  
102.// 解析非终结符P
103.void ParseP()  
104.{  
105.    switch (lookahead)  
106.    {  
107.    case '(':  
108.        MatchToken('(');  
109.        ParseE();  
110.        MatchToken(')');  
111.        break;  
112.    case 'a':  
113.        MatchToken('a');  
114.        break;  
115.    case 'b':  
116.        MatchToken('b');  
117.        break;  
118.    case '⋀':  
119.        MatchToken('⋀');  
120.        break;  
121.    default:  
122.        printf("syntax error \n");  
123.        exit(0);  
124.    }  
}

📌第3题

【题目】

 【答案】

📌第4题

【题目】

 【答案】

📌第5题

【题目】

 【答案】

📌第6题

【题目】

【部分答案】

1.void MatchToken(char expected)  
2.{  
3.    if (lookahead != expected)  
4.    {  
5.        printf("syntax error\n");  
6.        exit(0);  
7.    }  
8.    else  
9.    {  
10.        lookahead = getToken();  
11.    }  
12.}  
13.// 解析非终结符S  
14.void ParseS()  
15.{  
16.    switch (lookahead)  
17.    {  
18.    case 'a':  ParseA(); break;
19.    case 'b': ParseB(); break; 
20.    default:   printf("syntax error\n");  exit(0); 
21.       }  
22.}  
23.// 解析非终结符A  
24.void ParseA()  
25.{  
26.      if (lookahead == 'a')  
27.        { MatchToken('a');  
28.          ParseA’();  
29.       }
30.       else
31.       {   printf("syntax error\n");  
32.            exit(0);
33.        }  
34.}
35.// 解析非终结符B  
36.void ParseB()  
37.{  
38.      if (lookahead == 'b')  
39.        { MatchToken('b');  
40.          ParseB();  
41.       }
42.       else
43.       {     printf("syntax error\n");  
44.            exit(0);
45.        }  
46.}
47.void ParseA’()  // 解析非终结符A’ 
48.{  
49.    switch (lookahead)  
50.    {  
51.        case 'a':   ParseA();   break;  
52.        case '#':    break;  
53.        default:  
54.            printf("syntax error\n");  
55.            exit(0);  
56.        }  
57.}  
58.// 解析非终结符B′  
59.void ParseB′()  
60.{  
61.    switch (lookahead)  
62.    {  
63.    case 'b':   ParseB();   break;  
64.    case '#':    break;   
65.      default:  
66.         printf("syntax error\n");    
67.         exit(0);  
68.   } 
}  

 

1.void MatchToken(char expected)  
2.{  
3.    if (lookahead != expected)  
4.    {  
5.        printf("syntax error\n");  
6.        exit(0);  
7.    }  
8.    else  
9.    {  
10.        lookahead = getToken();  
11.    }  
12.}  
13.// 解析非终结符S  
14.void ParseS()  
15.{  
16.    if (lookahead == 'd' || lookahead == 'b' || lookahead == 'a' || lookahead == '#')  
17.    {  
18.        ParseB();  
19.        ParseS′();  
20.    }  
21.    else  
22.    {  
23.        printf("syntax error\n");  
24.        exit(0);  
25.    }  
26.}  
27.
28.// 解析非终结符S′  
29.void ParseS′()  
30.{  
31.    switch (lookahead)  
32.    {  
33.    case 'a':  
34.        MatchToken('a');  
35.        break;  
36.    case '#':  
37.        break;  
38.    default:  
39.        printf("syntax error\n");  
40.        exit(0);  
41.    }  
42.}  
43.// 解析非终结符B  
44.void ParseB()  
45.{  
46.    switch (lookahead)  
47.    {  
48.    case 'a', 'd', 'b', '#':  
49.        ParseD();  
50.        ParseB′();  
51.        break;  
52.    default:  
53.        printf("syntax error\n");  
54.        exit(0);  
55.    }  
56.}  
57.// 解析非终结符B′  
58.void ParseB′()  
59.{  
60.    switch (lookahead)  
61.    {  
62.    case 'b':  
63.        MatchToken('b');  
64.        break;  
65.    case '#', 'a':  
66.        break;  
67.    default:  
68.        printf("syntax error\n");  
69.        exit(0);  
70.    }  
71.}
72.// 解析非终结符D  
73.void ParseD()  
74.{  
75.    switch (lookahead)  
76.    {  
77.    case 'd':  
78.        MatchToken('d');  
79.        break;  
80.    case 'b', 'a', '#':  
81.        break;  
82.    default:  
83.        printf("syntax error\n");  
84.        exit(0);  
85.    }  
} 

 

1.void MatchToken(char expected)  
2.{  
3.    if (lookahead != expected)  
4.    {  
5.        printf("syntax error\n");  
6.        exit(0);  
7.    }  
8.    else  
9.    {  
10.        lookahead = getToken();  
11.    }  
12.}  
13.// 解析非终结符S  
14.void ParseS()  
15.{  
16.    switch (lookahead)  
17.    {  
18.    case 'a': 
19.             // 
20.         MatchToken('a'); 
21.          ParseA();
22.          MatchToken('a'); 
23.          ParseB();
24.         break;
25.      Case 'b': // 
26.          MatchToken('b'); 
27.          ParseA();
28.          MatchToken('b'); 
29.          ParseB();
30.         break;
31.          default:  
32.             printf("syntax error\n");  
33.             exit(0);  
34.   }        
35. }
36.// 解析非终结符A 
37. 
38.void ParseA()  
39.{  
40.      switch (lookahead )  
41.       case 'a':   ParseS();break;
42.       case 'b':   ParseS(); break;
43.       case 'd':   MatchToken('d'); MatchToken('b'); break;
44.       default: 
45.       {   printf("syntax error\n");  
46.            exit(0);
47.        }  
48.} 
49.// 解析非终结符B  
50.void ParseB()  
51.{  
52.      switch (lookahead )   
53.       { 
54.         case 'a':   MatchToken('a');break; 
55.         case 'b':   MatchToken('b'); ParseB(); break;
56.         default:
57.       {     printf("syntax error\n");  
58.            exit(0);
59.        }  
}  

1.void MatchToken(char expected)  
2.{  
3.    if (lookahead != expected)  
4.    {  
5.        printf("syntax error\n");  
6.        exit(0);  
7.    }  
8.    else  
9.    {  
10.        lookahead = getToken();  
11.    }  
12.}  
13.// 解析非终结符S  
14.void ParseS()  
15.{  
16.    switch (lookahead)  
17.    {  
18.    case 'i':  
19.        MatchToken('i');  
20.        break;  
21.    case '(':  
22.        MatchToken('(');  
23.        ParseE();  
24.        MatchToken(')');  
25.        break;  
26.    default:  
27.        printf("syntax error\n");  
28.        exit(0);  
29.    }  
30.}  
31.// 解析非终结符E  
32.void ParseE()  
33.{  
34.    switch (lookahead)  
35.    {  
36.    case 'i', '(':  
37.        ParseS();  
38.        ParseE’();  
39.        break;  
40.    default:  
41.        printf("syntax error\n");  
42.        exit(0);  
43.    }  
44.}  
45.// 解析非终结符E′  
46.void ParseE′()  
47.{  
48.    switch (lookahead)  
49.    {  
50.    case '+':  
51.        MatchToken('+');  
52.        ParseS();  
53.        ParseE′();  
54.        break;  
55.    case '-':  
56.        MatchToken('-');  
57.        ParseS();  
58.        ParseE′();  
59.        break;  
60.    case ')':  
61.        break;  
62.    default:  
63.        printf("syntax error\n");  
64.        exit(0);  
65.    }  
} 

1.void MatchToken(char expected)  
2.{  
3.    if (lookahead != expected)  
4.    {  
5.        printf("syntax error\n");  
6.        exit(0);  
7.    }  
8.    else  
9.    {  
10.        lookahead = getToken();  
11.    }  
12.}  
13.// 解析非终结符S  
14.void ParseS()  
15.{  
16.     if (lookahead == 'b')  
17.        { MatchToken('b');  
18.          ParseB();  
19.          ParseS’();  }
20.       else
21.       {     printf("syntax error\n");  
22.            exit(0);
23.        }  
24.} 
25.// 解析非终结符S’  
26.void ParseS’()  
27.{  
28.     switch (lookahead)   
29.  {  
30.         case 'a':   MatchToken('a'); ParseA();ParseS’();break;
31.       case '#':     break;  
32.        default:  
33.            printf("syntax error\n");  
34.            exit(0);  
35.        }  
36.}
37. // 解析非终结符A  
38.void ParseA()  
39.{  
40.     switch (lookahead)   
41.  {  
42.         case 'a':   MatchToken('a'); ParseB();break;
43.         case 'c':    MatchToken('c'); break;  
44.        default:  
45.            printf("syntax error\n");  
46.            exit(0);  
47.        }  
48.}
49.void ParseB()  // 解析非终结符B 
50.{  
51.    if (lookahead=='d')  
52.    {  
53.        MatchToken('d'); 
54.        ParseB();  
55.       }
56.       else  
57.            { printf("syntax error\n");  
58.              exit(0);  
59.         }  
60.}  
61.// 解析非终结符B′  
62.void ParseB′()  
63.{  
64.    switch (lookahead)  
65.    {  
66.    case 'a', '#':    break;  
67.    case 'b':   MatchToken('b'); ParseB’();  break;   
68.    default:  
69.         printf("syntax error\n");    
70.         exit(0);  
71.   } 
} 

1.void MatchToken(char expected)  
2.{  
3.    if (lookahead != expected)  
4.    {  
5.        printf("syntax error\n");  
6.        exit(0);  
7.    }  
8.    else  
9.    {  
10.        lookahead = getToken();  
11.    }  
12.}  
13.// 解析非终结符M  
14.void ParseM()  
15.{  
16.    switch (lookahead)  
17.    {  
18.    case 'b', '(':  
19.        ParseH();  
20.        ParseM′();  
21.        break;  
22.    default:  
23.        printf("syntax error\n");  
24.        exit(0);  
25.    }  
26.}  
27.// 解析非终结符M′  
28.void ParseM′()  
29.{  
30.    switch (lookahead)  
31.    {  
32.    case 'a':  
33.        MatchToken('a');  
34.        ParseH();  
35.        ParseM′();  
36.        break;  
37.    case ')','#':  
38.        break;  
39.    default:  
40.        printf("syntax error\n");  
41.        exit(0);  
42.    }  
43.}  
44.// 解析非终结符H  
45.void ParseH()  
46.{  
47.    switch (lookahead)  
48.    {  
49.        case 'b':  
50.             MatchToken('b');  
51.             ParseH’();  
52.             break;  
53.        case '(':  
54.            MatchToken('(');  
55.            ParseM();  
56.            MatchToken(')');  
57.            break;  
58.        default:  
59.            printf("syntax error\n");  
60.            exit(0);  
61.        }  
62.}  
63.// 解析非终结符H′  
64.void ParseH′()  
65.{  
66.    switch (lookahead)  
67.    {  
68.    case '(':  
69.        MatchToken('(');  
70.        ParseM();  
71.        MatchToken(')');  
72.        break;  
73.    case ')', 'a', '#':  
74.        break;  
75.    default:  
76.        printf("syntax error\n");  
77.        exit(0);  
78.    }  
}

📌第7题

【题目】

 【答案】

 

 

《编译原理》课后习题答案
10-24
《编译原理》课后习题答案第一章 第 1 章引论 第 1 题 解释下列术语： （1）编译程序 （2）源程序 （3）目标程序 （4）编译程序的前端 （5）后端 （6）遍 答案： （1） 编译程序：如果源语言为高级语言，目标语言为某台计算机上的汇编语言或机器语 言，则此翻译程序称为编译程序。 （2） 源程序：源语言编写的程序称为源程序。 （3） 目标程序：目标语言书写的程序称为目标程序。 （4） 编译程序的前端：它由这样一些阶段组成：这些阶段的工作主要依赖于源语言而与 目标机无关。通常前端包括词法分析、语法分析、语义分析和中间代码生成这些阶 段，某些优化工作也可在前端做，也包括与前端每个阶段相关的出错处理工作和符 号表管理等工作。 （5） 后端：指那些依赖于目标机而一般不依赖源语言，只与中间代码有关的那些阶段， 即目标代码生成，以及相关出错处理和符号表操作。 （6） 遍：是对源程序或其等价的中间语言程序从头到尾扫视并完成规定任务的过程。 第 2 题 一个典型的编译程序通常由哪些部分组成？各部分的主要功能是什么？并画出编译程 序的总体结构图。 答案： 一个典型的编译程序通常包含 8 个组成部分，它们是词法分析程序、语法分析程序、语 义分析程序、中间代码生成程序、中间代码优化程序、目标代码生成程序、表格管理程序和 错误处理程序。其各部分的主要功能简述如下。 词法分析程序：输人源程序，拼单词、检查单词和分析单词，输出单词的机内表达形式。 语法分析程序：检查源程序中存在的形式语法错误，输出错误处理信息。 语义分析程序：进行语义检查和分析语义信息，并把分析的结果保存到各类语义信息表 中。 中间代码生成程序：按照语义规则，将语法分析程序分析出的语法单位转换成一定形式 的中间语言代码，如三元式或四元式。 中间代码优化程序：为了产生高质量的目标代码，对中间代码进行等价变换处理。 盛威网（www.snwei.com）专业的计算机学习网站1 《编译原理》课后习题答案第一章 目标代码生成程序：将优化后的中间代码程序转换成目标代码程序。 表格管理程序：负责建立、填写和查找等一系列表格工作。表格的作用是记录源程序的 各类信息和编译各阶段的进展情况，编译的每个阶段所需信息多数都从表格中读取，产生的 中间结果都记录在相应的表格中。可以说整个编译过程就是造表、查表的工作过程。需要指 出的是，这里的“表格管理程序”并不意味着它就是一个独立的表格管理模块，而是指编译 程序具有的表格管理功能。 错误处理程序：处理和校正源程序中存在的词法、语法和语义错误。当编译程序发现源 程序中的错误时，错误处理程序负责报告出错的位置和错误性质等信息，同时对发现的错误 进行适当的校正（修复），目的是使编译程序能够继续向下进行分析和处理。 注意：如果问编译程序有哪些主要构成成分，只要回答六部分就可以。如果搞不清楚， 就回答八部分。 第 3 题 何谓翻译程序、编译程序和解释程序？它们三者之间有何种关系？ 答案： 翻译程序是指将用某种语言编写的程序转换成另一种语言形式的程序的程序，如编译程 序和汇编程序等。 编译程序是把用高级语言编写的源程序转换（加工）成与之等价的另一种用低级语言编 写的目标程序的翻译程序。 解释程序是解释、执行高级语言源程序的程序。解释方式一般分为两种：一种方式是， 源程序功能的实现完全由解释程序承担和完成，即每读出源程序的一条语句的第一个单词， 则依据这个单词把控制转移到实现这条语句功能的程序部分，该部分负责完成这条语句的功 能的实现，完成后返回到解释程序的总控部分再读人下一条语句继续进行解释、执行，如此 反复；另一种方式是，一边翻译一边执行，即每读出源程序的一条语句，解释程序就将其翻 译成一段机器指令并执行之，然后再读人下一条语句继续进行解释、执行，如此反复。无论
编译原理 第三章课后习题答案
05-16
这是原版教材 的课后习题答案，第三章的，很全，很准确
编译原理课后第三章答案
05-16
编译原理及实现第三章的课后答案 有详细的图文解说 简单易懂
编译原理课后习题答案
06-08
编译原理课后答案 清华大学版 编译原理的课后作业可以有效帮助我们学习这门课
编译原理第三版课后习题及答案
06-08
不可多得，适合学习的编译原理资料
编译原理第三版课后习题答案
04-27
编译原理第三版课后习题答案编译原理第三版课后习题答案编译原理第三版课后习题答案编译原理第三版课后习题答案编译原理第三版课后习题答案
编译原理课后答案（第三版）
11-07
程序设计语言（编译原理）第三版，课后习题答案，国防工业出版社，内容包括词法分析，语法分析，自上而下分析文法，自下而上分析文法等
编译原理陈火旺版第三章课后题答案
热门推荐
capture3333的博客
03-14 4万+
编译原理第三版陈火旺第三章课后题答案
编译原理(第3版-王生原)课后习题答案-第三章
Beatr1ce的博客
02-13 2万+
编译原理(第3版-王生原)课后习题答案-第三章1-4题
编译原理（第三版）课后习题答案
09-22
程序设计语言——编译原理（第三版），国防工业出版社，课后习题答案
编译原理（第三版）答案
05-28
编译原理（第三版）答案编译原理（第三版）答案编译原理（第三版）答案
编译原理 第三版 课后习题 答案 陈火旺
11-08
编译原理 第三版 课后习题 答案 陈火旺
编译原理 | 第二章课后习题答案
鷾
03-02 2万+
本文为编译原理（第三版）【清华大学出版社】第二章部分课后习题答案。本答案均截取自网络，如有错误，望指正
编译原理 | 第五章课后习题答案
鷾
05-27 8473
本文为编译原理（第三版）【清华大学出版社】第五章部分课后习题答案。本答案均截取自网络，如有错误，望指正
编译原理 课后答案 第六章 清华
05-07
编译原理 课后答案 第六章 清华 张素琴 第二版
Execution failed for task ':app:shrinkReleaseRes'.
最新发布
01-11
### 构建任务失败解决方案 当遇到 `Execution failed for task ':app:shrinkReleaseRes'` 错误时，这通常意味着资源压缩过程中出现了问题。此错误可能由多种原因引起，包括但不限于配置不正确、依赖冲突或特定于项目的其他因素。 #### 可能的原因分析 1. **ProGuard 或 R8 配置不当** ProGuard 和 R8 是用于优化和混淆代码以及减少 APK 大小的工具。如果这些工具的配置存在问题，可能会导致资源无法正常处理[^1]。 2. **重复资源** 如果项目中有多个模块定义了相同的资源名称，可能导致冲突并引发该错误。检查是否存在重名的 drawable、string 等资源文件[^2]。 3. **第三方库兼容性** 某些第三方库可能与当前使用的 Gradle 插件版本或其他库存在兼容性问题，从而影响到资源打包过程中的行为[^3]。 4. **Gradle 缓存问题** 有时旧缓存数据会干扰新编译的结果，尝试清理本地仓库和重新同步项目可以帮助排除此类潜在障碍[^4]。 #### 推荐的操作方法 为了有效解决问题，建议按照以下步骤逐一排查： ```bash # 清理项目构建目录 ./gradlew clean # 删除 .gradle 文件夹下的所有内容以清除缓存 rm -rf ~/.gradle/caches/ ``` 调整 `build.gradle` 中的相关设置也是一个重要环节： ```groovy android { ... buildTypes { release { minifyEnabled true // 是否启用代码缩减 shrinkResources true // 是否开启资源压缩 proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' // 尝试禁用 shrinkResources 来测试是否为资源压缩引起的错误 // shrinkResources false } } } ``` 此外，在 `proguard-rules.pro` 文件内添加必要的保留规则，防止关键类被意外移除: ```text -keep class com.example.yourpackage.** { *; } # 替换为你自己的包路径 -dontwarn androidx.**,com.google.** # 忽略警告信息 ``` 最后，确保所使用的 Android Studio 版本是最新的稳定版，并且已经应用了所有的补丁更新。
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值