顶部
收藏

编译原理

“十一五”国家规划教材

作者:
蒋宗礼 姜守旭
定价:
38.00 元
版面字数:
640千字
开本:
16开
装帧形式:
平装
版次:
1
最新版次
印刷时间:
2014年
ISBN:
978-7-04-029058-5
物料号:
29058-00
出版时间:
2010-02-25
读者对象:
高等教育
一级分类:
计算机/教育技术类
二级分类:
计算机类专业核心课程
三级分类:
编译原理

“编译原理”是计算机科学与技术专业重要的专业(基础)课程。本书是普通高等教育“十一五”国家级规划教材,也是国家精品课程主讲教材,是作者结合近三十年在哈尔滨工业大学、北京工业大学讲授该课程的经验和体会,根据本科生教学的实际需要选择和组织有关内容撰写而成的,包含了“编译原理”课程所需涵盖的知识。本书将以知识为载体,对本学科问题求解的典型思想和方法进行探讨,致力于学生四大专业基本能力的培养,为“能力导向”的课程教学提供有力支持。为了便于读者学习和掌握有关内容,面向工程应用型学生的培养,在附录中给出了相应的课程设计。

本书适合于高等学校计算机科学与技术学科本科生“编译原理”课程教学使用,也可供有关专业的学生、教师和科研人员参考。

  • 目录
    • 第1章 引论
      • 1.1 程序设计语言
        • 1.2 程序设计语言的翻译
          • 1.3 编译程序的总体结构
            • 1.4 编译程序的组织
              • 1.5 编译程序的生成
                • 1.6 本章小结
                  • 习题
                  • 第2章 高级语言及其文法
                    • 2.1 语言概述
                      • 2.2 基本定义
                        • 2.3 文法的定义
                          • 2.4 文法的分类
                            • 2.5 CFG的语法树
                              • 2.6 CFG的二义性
                                • 2.7 本章小结
                                  • 习题
                                  • 第3章 词法分析
                                    • 3.1 词法分析器的功能
                                      • 3.1.1 单词的分类与表示
                                        • 3.1.2 词法分析器的输出
                                          • 3.1.3 源程序的输入缓冲与预处理
                                            • 3.1.4 词法分析阶段的错误处理
                                              • 3.1.5 词法分析器的位置
                                              • 3.2 单词的描述
                                                • 3.2.1 正则文法
                                                  • 3.2.2 正则表达式
                                                    • 3.2.3 正则表达式与正则文法的等价性
                                                      • 3.2.4 有穷状态自动机
                                                        • 3.2.5 状态转换图
                                                          • 3.2.6 正则表达式转换为状态转换图
                                                          • 3.3 单词的识别
                                                            • 3.3.1 有穷状态自动机与单词识别的关系
                                                              • 3.3.2 单词识别的状态转换图表示
                                                                • 3.3.3 几种典型的单词识别问题
                                                                  • 3.3.4 状态转换图的实现
                                                                    • 3.3.5 词法分析程序的编写
                                                                    • 3.4 词法分析程序的自动生成
                                                                      • 3.4.1 Lex源程序
                                                                        • 3.4.2 Lex的实现原理
                                                                        • 3.5 本章小结
                                                                          • 习题
                                                                          • 第4章 自顶向下的语法分析
                                                                            • 4.1 语法分析概述
                                                                              • 4.2 自顶向下的语法分析面临的问题与文法的改造
                                                                                • 4.2.1 自顶向下分析面临的问题
                                                                                  • 4.2.2 对上下文无关文法的改造
                                                                                    • 4.2.3 LL(1)文法
                                                                                    • 4.3 预测分析法
                                                                                      • 4.3.1 预测分析器的构成
                                                                                        • 4.3.2 预测分析表的构造
                                                                                          • 4.3.3 预测分析中错误的处理
                                                                                          • 4.4 递归下降分析法
                                                                                            • 4.4.1 递归下降分析法的基本思想
                                                                                              • 4.4.2 语法图和递归子程序法
                                                                                                • 4.4.3 基于语法图的语法分析器的工作方式
                                                                                                  • 4.4.4 语法图的化简与实现
                                                                                                    • 4.4.5 递归子程序法的实现步骤
                                                                                                    • 4.5 本章小结
                                                                                                      • 习题
                                                                                                      • 第5章 自底向上的语法分析
                                                                                                        • 5.1 自底向上的语法分析概述
                                                                                                          • 5.1.1 移进-归约分析
                                                                                                            • 5.1.2 优先法
                                                                                                              • 5.1.3 状态法
                                                                                                              • 5.2 算符优先分析法
                                                                                                                • 5.2.1 算符优先文法
                                                                                                                  • 5.2.2 算符优先矩阵的构造
                                                                                                                    • 5.2.3 算符优先分析算法
                                                                                                                      • 5.2.4 优先函数
                                                                                                                        • 5.2.5 算符优先分析的出错处理
                                                                                                                        • 5.3 LR分析法
                                                                                                                          • 5.3.1 LR分析算法
                                                                                                                            • 5.3.2 LR(0)分析表的构造
                                                                                                                              • 5.3.3 SLR(1)分析表的构造
                                                                                                                                • 5.3.4 LR(1)分析表的构造
                                                                                                                                  • 5.3.5 LALR(1)分析表的构造
                                                                                                                                    • 5.3.6 二义性文法的应用
                                                                                                                                      • 5.3.7 LR分析中的出错处理
                                                                                                                                      • 5.4 语法分析程序的自动生成工具Yacc
                                                                                                                                        • 5.4.1 Yacc源程序的结构
                                                                                                                                          • 5.4.2 Yacc源程序的声明部分
                                                                                                                                            • 5.4.3 Yacc源程序的规则部分
                                                                                                                                              • 5.4.4 Yacc源程序的例程部分
                                                                                                                                                • 5.4.5 Yacc对二义性文法的处理
                                                                                                                                                  • 5.4.6 Yacc的出错处理
                                                                                                                                                  • 5.5 本章小结
                                                                                                                                                    • 习题
                                                                                                                                                    • 第6章 语法制导翻译与属性文法
                                                                                                                                                      • 6.1 语法制导翻译概述
                                                                                                                                                        • 6.2 语法制导定义
                                                                                                                                                          • 6.3 属性计算
                                                                                                                                                            • 6.3.1 依赖图
                                                                                                                                                              • 6.3.2 属性的计算顺序
                                                                                                                                                                • 6.3.3 S-属性定义
                                                                                                                                                                  • 6.3.4 L-属性定义
                                                                                                                                                                    • 6.3.5 属性计算示例
                                                                                                                                                                    • 6.4 翻译模式
                                                                                                                                                                      • 6.4.1 翻译模式与语义动作的执行时机
                                                                                                                                                                        • 6.4.2 S-属性定义的自底向上翻译
                                                                                                                                                                          • 6.4.3 L-属性定义的自顶向下翻译
                                                                                                                                                                            • 6.4.4 L-属性定义的自底向上翻译
                                                                                                                                                                            • 6.5 本章小结
                                                                                                                                                                              • 习题
                                                                                                                                                                              • 第7章 语义分析与中间代码生成
                                                                                                                                                                                • 7.1 中间代码的形式
                                                                                                                                                                                  • 7.1.1 逆波兰表示
                                                                                                                                                                                    • 7.1.2 三地址码
                                                                                                                                                                                      • 7.1.3 图表示
                                                                                                                                                                                      • 7.2 声明语句的翻译
                                                                                                                                                                                        • 7.2.1 类型表达式
                                                                                                                                                                                          • 7.2.2 类型等价
                                                                                                                                                                                            • 7.2.3 声明语句的文法
                                                                                                                                                                                              • 7.2.4 过程内声明语句的翻译
                                                                                                                                                                                                • 7.2.5 嵌套过程中声明语句的翻译
                                                                                                                                                                                                  • 7.2.6 记录的翻译
                                                                                                                                                                                                  • 7.3 赋值语句的翻译
                                                                                                                                                                                                    • 7.3.1 简单赋值语句的翻译
                                                                                                                                                                                                      • 7.3.2 数组元素的寻址
                                                                                                                                                                                                        • 7.3.3 带有数组引用的赋值语句的翻译
                                                                                                                                                                                                          • 7.3.4 记录域的访问
                                                                                                                                                                                                          • 7.4 类型检查
                                                                                                                                                                                                            • 7.4.1 类型检查的规则
                                                                                                                                                                                                              • 7.4.2 类型转换
                                                                                                                                                                                                              • 7.5 控制结构的翻译
                                                                                                                                                                                                                • 7.5.1 布尔表达式的翻译
                                                                                                                                                                                                                  • 7.5.2 常见控制结构的翻译
                                                                                                                                                                                                                    • 7.5.3 布尔表达式的控制流翻译
                                                                                                                                                                                                                      • 7.5.4 混合模式的布尔表达式翻译
                                                                                                                                                                                                                      • 7.6 回填
                                                                                                                                                                                                                        • 7.6.1 布尔表达式的回填式翻译
                                                                                                                                                                                                                          • 7.6.2 常用控制流语句的回填式翻译
                                                                                                                                                                                                                            • 7.6.3 for循环语句的回填式翻译
                                                                                                                                                                                                                              • 7.6.4 repeat语句的回填式翻译
                                                                                                                                                                                                                                • 7.6.5 break、continue及goto语句的翻译
                                                                                                                                                                                                                                • 7.7 switch语句的翻译
                                                                                                                                                                                                                                  • 7.7.1 switch语句翻译的基本思想
                                                                                                                                                                                                                                    • 7.7.2 switch语句的语法制导翻译
                                                                                                                                                                                                                                    • 7.8 过程调用和返回语句的翻译
                                                                                                                                                                                                                                      • 7.9 输入输出语句的翻译
                                                                                                                                                                                                                                        • 7.10 本章小结
                                                                                                                                                                                                                                          • 习题
                                                                                                                                                                                                                                          • 第8章 符号表管理
                                                                                                                                                                                                                                            • 8.1 符号表的作用
                                                                                                                                                                                                                                              • 8.2 符号表中存放的信息
                                                                                                                                                                                                                                                • 8.2.1 符号表中的名字
                                                                                                                                                                                                                                                  • 8.2.2 符号表中的属性
                                                                                                                                                                                                                                                    • 8.2.3 符号的地址属性
                                                                                                                                                                                                                                                    • 8.3 符号表的组织结构
                                                                                                                                                                                                                                                      • 8.3.1 符号表的线性表实现
                                                                                                                                                                                                                                                        • 8.3.2 符号表的散列表实现
                                                                                                                                                                                                                                                        • 8.4 符号表与作用域
                                                                                                                                                                                                                                                          • 8.4.1 程序块结构的符号表
                                                                                                                                                                                                                                                            • 8.4.2 程序块结构符号表的其他实现
                                                                                                                                                                                                                                                              • 8.4.3 C语言的符号表
                                                                                                                                                                                                                                                                • 8.4.4 嵌套过程的符号表
                                                                                                                                                                                                                                                                • 8.5 本章小结
                                                                                                                                                                                                                                                                  • 习题
                                                                                                                                                                                                                                                                  • 第9章 运行时的存储组织
                                                                                                                                                                                                                                                                    • 9.1 与存储组织有关的源语言概念与特征
                                                                                                                                                                                                                                                                      • 9.1.1 名字及其绑定
                                                                                                                                                                                                                                                                        • 9.1.2 声明的作用域
                                                                                                                                                                                                                                                                          • 9.1.3 过程及其活动
                                                                                                                                                                                                                                                                            • 9.1.4 参数传递方式
                                                                                                                                                                                                                                                                              • 9.1.5 对变长数据及用户自由申请空间的支持
                                                                                                                                                                                                                                                                              • 9.2 存储组织
                                                                                                                                                                                                                                                                                • 9.2.1 运行时内存的划分
                                                                                                                                                                                                                                                                                  • 9.2.2 活动记录
                                                                                                                                                                                                                                                                                    • 9.2.3 局部数据的组织
                                                                                                                                                                                                                                                                                      • 9.2.4 全局存储分配策略
                                                                                                                                                                                                                                                                                      • 9.3 静态存储分配
                                                                                                                                                                                                                                                                                        • 9.4 栈式存储分配
                                                                                                                                                                                                                                                                                          • 9.4.1 调用序列和返回序列
                                                                                                                                                                                                                                                                                            • 9.4.2 C语言的过程调用和过程返回
                                                                                                                                                                                                                                                                                              • 9.4.3 栈中的可变长数据
                                                                                                                                                                                                                                                                                              • 9.5 栈中非局部数据的访问
                                                                                                                                                                                                                                                                                                • 9.5.1 无嵌套过程的静态作用域的实现
                                                                                                                                                                                                                                                                                                  • 9.5.2 包含嵌套过程的静态作用域的实现
                                                                                                                                                                                                                                                                                                    • 9.5.3 动态作用域的实现
                                                                                                                                                                                                                                                                                                    • 9.6 堆管理
                                                                                                                                                                                                                                                                                                      • 9.6.1 内存管理器
                                                                                                                                                                                                                                                                                                        • 9.6.2 内存体系
                                                                                                                                                                                                                                                                                                          • 9.6.3 程序中的局部性
                                                                                                                                                                                                                                                                                                            • 9.6.4 降低碎片量的堆区空间管理策略
                                                                                                                                                                                                                                                                                                              • 9.6.5 人工回收请求
                                                                                                                                                                                                                                                                                                              • 9.7 本章小结
                                                                                                                                                                                                                                                                                                                • 习题
                                                                                                                                                                                                                                                                                                                • 第10章 代码优化
                                                                                                                                                                                                                                                                                                                  • 10.1 优化的种类
                                                                                                                                                                                                                                                                                                                    • 10.1.1 公共子表达式删除
                                                                                                                                                                                                                                                                                                                      • 10.1.2 复制传播
                                                                                                                                                                                                                                                                                                                        • 10.1.3 无用代码删除
                                                                                                                                                                                                                                                                                                                          • 10.1.4 代码外提
                                                                                                                                                                                                                                                                                                                            • 10.1.5 强度削弱和归纳变量删除
                                                                                                                                                                                                                                                                                                                            • 10.2 控制流分析
                                                                                                                                                                                                                                                                                                                              • 10.2.1 基本块
                                                                                                                                                                                                                                                                                                                                • 10.2.2 流图
                                                                                                                                                                                                                                                                                                                                  • 10.2.3 循环
                                                                                                                                                                                                                                                                                                                                  • 10.3 数据流分析
                                                                                                                                                                                                                                                                                                                                    • 10.3.1 数据流方程的一般形式
                                                                                                                                                                                                                                                                                                                                      • 10.3.2 到达-定义分析
                                                                                                                                                                                                                                                                                                                                        • 10.3.3 活跃变量分析
                                                                                                                                                                                                                                                                                                                                          • 10.3.4 可用表达式分析
                                                                                                                                                                                                                                                                                                                                          • 10.4 局部优化
                                                                                                                                                                                                                                                                                                                                            • 10.4.1 基本块的DAG表示
                                                                                                                                                                                                                                                                                                                                              • 10.4.2 局部公共子表达式删除
                                                                                                                                                                                                                                                                                                                                                • 10.4.3 无用代码删除
                                                                                                                                                                                                                                                                                                                                                  • 10.4.4 代数恒等式的使用
                                                                                                                                                                                                                                                                                                                                                    • 10.4.5 数组引用的DAG表示
                                                                                                                                                                                                                                                                                                                                                      • 10.4.6 指针赋值和过程调用的DAG表示
                                                                                                                                                                                                                                                                                                                                                        • 10.4.7 从DAG到基本块的重组
                                                                                                                                                                                                                                                                                                                                                        • 10.5 循环优化
                                                                                                                                                                                                                                                                                                                                                          • 10.5.1 循环不变计算的检测
                                                                                                                                                                                                                                                                                                                                                            • 10.5.2 代码外提
                                                                                                                                                                                                                                                                                                                                                              • 10.5.3 归纳变量删除和强度削弱
                                                                                                                                                                                                                                                                                                                                                                • 10.5.4 带有循环不变表达式的归纳变量
                                                                                                                                                                                                                                                                                                                                                                • 10.6 全局优化
                                                                                                                                                                                                                                                                                                                                                                  • 10.6.1 全局公共子表达式的删除
                                                                                                                                                                                                                                                                                                                                                                    • 10.6.2 复制传播
                                                                                                                                                                                                                                                                                                                                                                    • 10.7 本章小结
                                                                                                                                                                                                                                                                                                                                                                      • 习题
                                                                                                                                                                                                                                                                                                                                                                      • 第11章 代码生成
                                                                                                                                                                                                                                                                                                                                                                        • 11.1 代码生成器设计中的问题
                                                                                                                                                                                                                                                                                                                                                                          • 11.1.1 代码生成器的输入
                                                                                                                                                                                                                                                                                                                                                                            • 11.1.2 目标代码的形式
                                                                                                                                                                                                                                                                                                                                                                              • 11.1.3 指令选择
                                                                                                                                                                                                                                                                                                                                                                                • 11.1.4 寄存器分配
                                                                                                                                                                                                                                                                                                                                                                                  • 11.1.5 计算顺序选择
                                                                                                                                                                                                                                                                                                                                                                                  • 11.2 目标语言
                                                                                                                                                                                                                                                                                                                                                                                    • 11.2.1 目标机模型
                                                                                                                                                                                                                                                                                                                                                                                      • 11.2.2 程序和指令的开销
                                                                                                                                                                                                                                                                                                                                                                                        • 11.2.3 变量的运行时刻地址
                                                                                                                                                                                                                                                                                                                                                                                        • 11.3 一个简单的代码生成器
                                                                                                                                                                                                                                                                                                                                                                                          • 11.3.1 后续引用信息
                                                                                                                                                                                                                                                                                                                                                                                            • 11.3.2 寄存器描述符与地址描述符
                                                                                                                                                                                                                                                                                                                                                                                              • 11.3.3 代码生成算法
                                                                                                                                                                                                                                                                                                                                                                                                • 11.3.4 常用三地址码的代码生成
                                                                                                                                                                                                                                                                                                                                                                                                • 11.4 窥孔优化
                                                                                                                                                                                                                                                                                                                                                                                                  • 11.4.1 冗余指令消除
                                                                                                                                                                                                                                                                                                                                                                                                    • 11.4.2 不可达代码消除
                                                                                                                                                                                                                                                                                                                                                                                                      • 11.4.3 强度削弱
                                                                                                                                                                                                                                                                                                                                                                                                        • 11.4.4 特殊机器指令的使用
                                                                                                                                                                                                                                                                                                                                                                                                          • 11.4.5 其他处理
                                                                                                                                                                                                                                                                                                                                                                                                          • 11.5 寄存器分配与指派
                                                                                                                                                                                                                                                                                                                                                                                                            • 11.5.1 全局寄存器分配
                                                                                                                                                                                                                                                                                                                                                                                                              • 11.5.2 引用计数
                                                                                                                                                                                                                                                                                                                                                                                                                • 11.5.3 外层循环的寄存器指派
                                                                                                                                                                                                                                                                                                                                                                                                                • 11.6 本章小结
                                                                                                                                                                                                                                                                                                                                                                                                                  • 习题
                                                                                                                                                                                                                                                                                                                                                                                                                  • 附录 “编译原理”课程教学设计
                                                                                                                                                                                                                                                                                                                                                                                                                    • 缩写符号
                                                                                                                                                                                                                                                                                                                                                                                                                      • 词汇索引
                                                                                                                                                                                                                                                                                                                                                                                                                        • 参考文献

                                                                                                                                                                                                                                                                                                                                                                                                                        相关图书