顶部
收藏

程序设计语言编译原理


作者:
刘春林 王挺 黄春 谭庆平 编著
定价:
45.00 元
版面字数:
540千字
开本:
16开
装帧形式:
平装
版次:
1
最新版次
印刷时间:
2024年
ISBN:
978-7-04-062282-9
物料号:
62282-00
出版时间:
2025-01-06
读者对象:
高等教育
一级分类:
计算机/教育技术类
二级分类:
计算机类专业核心课程
三级分类:
编译原理

编译理论和技术是计算机科学与技术的重要组成部分。编译原理课程是计算机专业的核心课程,对于学习计算机科学理论、培养计算机系统能力具有重要的意义。本书主要介绍程序设计语言编译程序构造的理论方法和实现技术,主要包括引论、程序设计语言及其语法描述、词法分析、语法分析、属性文法和语法制导翻译、语义分析和中间代码产生、运行时存储空间组织、优化、目标代码生成和高级编译优化等知识单元。

本书根据作者团队多年课程教学和编译系统研制实践经验总结而成,可作为高等学校计算机及相关专业的编译原理课程教材,也可作为相关科技人员了解编译理论和技术的参考读物。

  • 目录
    • 前辅文
      • 第一章 引论
        • 1.1 什么是编译程序
          • 1.2 编译过程概述
            • 1.3 编译程序的结构
              • 1.3.1 编译程序总框图
                • 1.3.2 表格与表格管理
                  • 1.3.3 出错处理
                    • 1.3.4 遍
                      • 1.3.5 编译前端与后端
                      • 1.4 编译程序与程序设计环境
                        • 1.5 编译程序的生成
                          • 1.6 如何学习编译原理
                            • 本章小结
                              • 习题
                              • 第二章 高级程序设计语言及其语法描述
                                • 2.1 程序设计语言的定义
                                  • 2.1.1 语法
                                    • 2.1.2 语义
                                    • 2.2 高级程序设计语言的一般特征
                                      • 2.2.1 高级程序设计语言的分类
                                        • 2.2.2 程序结构
                                          • 2.2.3 数据类型与操作
                                            • 2.2.4 语句与控制结构
                                            • 2.3 高级程序设计语言的语法描述
                                              • 2.3.1 基本概念
                                                • 2.3.2 上下文无关文法定义
                                                  • 2.3.3 推导、句型和句子
                                                    • 2.3.4 语法分析树与二义性
                                                      • 2.3.5 形式语言鸟瞰
                                                      • 本章小结
                                                        • 习题
                                                        • 第三章 词法分析
                                                          • 3.1 对于词法分析器的要求
                                                            • 3.1.1 词法分析器的功能和输出形式
                                                              • 3.1.2 词法分析与语法分析的衔接
                                                              • 3.2 词法分析器的设计
                                                                • 3.2.1 输入、预处理
                                                                  • 3.2.2 单词符号的识别:超前搜索
                                                                    • 3.2.3 状态转换图
                                                                      • 3.2.4 状态转换图的实现
                                                                      • 3.3 正规表达式与有限自动机
                                                                        • 3.3.1 正规式与正规集
                                                                          • 3.3.2 确定有限自动机(DFA)
                                                                            • 3.3.3 非确定有限自动机(NFA)
                                                                              • 3.3.4 正规文法与有限自动机的等价性
                                                                                • 3.3.5 正规式与有限自动机的等价性
                                                                                  • 3.3.6 确定有限自动机的化简
                                                                                  • 3.4 词法分析器的自动产生
                                                                                    • 3.4.1 语言LEX的一般描述
                                                                                      • 3.4.2 超前搜索
                                                                                        • 3.4.3 LEX的实现
                                                                                        • 本章小结
                                                                                          • 习题
                                                                                          • 第四章 语法分析
                                                                                            • 4.1 语法分析器的功能
                                                                                              • 4.2 自上而下语法分析
                                                                                                • 4.2.1 自上而下分析面临的问题
                                                                                                  • 4.2.2 LL(1)分析法
                                                                                                    • 4.2.3 递归下降分析程序构造
                                                                                                      • 4.2.4 预测分析程序
                                                                                                        • 4.2.5 LL(1)分析中的错误处理
                                                                                                        • 4.3 自下而上语法分析
                                                                                                          • 4.3.1 自下而上分析的基本问题
                                                                                                            • 4.3.2 LR分析法
                                                                                                              • 4.3.3 LR分析表构造
                                                                                                                • 4.3.4 二义文法的应用
                                                                                                                  • 4.3.5 LR分析中的出错处理
                                                                                                                  • 4.4 语法分析器的自动产生工具YACC
                                                                                                                    • 本章小结
                                                                                                                      • 习题
                                                                                                                      • 第五章 属性文法和语法制导翻译
                                                                                                                        • 5.1 属性文法
                                                                                                                          • 5.2 基于属性文法的处理方法
                                                                                                                            • 5.2.1 依赖图
                                                                                                                              • 5.2.2 树遍历的属性计算方法
                                                                                                                                • 5.2.3 一遍扫描的处理方法
                                                                                                                                  • 5.2.4 抽象语法树
                                                                                                                                  • 5.3 S-属性文法的自下而上计算
                                                                                                                                    • 5.4 L-属性文法和自顶向下翻译
                                                                                                                                      • 5.4.1 翻译模式
                                                                                                                                        • 5.4.2 自顶向下翻译
                                                                                                                                          • 5.4.3 递归下降翻译器的设计
                                                                                                                                          • 5.5 自下而上计算继承属性
                                                                                                                                            • 5.5.1 从翻译模式中去掉嵌入在产生式中间的动作
                                                                                                                                              • 5.5.2 分析栈中的继承属性
                                                                                                                                                • 5.5.3 模拟继承属性的计算
                                                                                                                                                  • 5.5.4 用综合属性代替继承属性
                                                                                                                                                  • 本章小结
                                                                                                                                                    • 习题
                                                                                                                                                    • 第六章 语义分析和中间代码产生
                                                                                                                                                      • 6.1 中间语言
                                                                                                                                                        • 6.1.1 后缀式
                                                                                                                                                          • 6.1.2 图表示法
                                                                                                                                                            • 6.1.3 三地址代码
                                                                                                                                                            • 6.2 说明语句的处理
                                                                                                                                                              • 6.2.1 过程中的说明语句
                                                                                                                                                                • 6.2.2 保留作用域信息
                                                                                                                                                                  • 6.2.3 记录和类中的域名
                                                                                                                                                                  • 6.3 赋值语句的翻译
                                                                                                                                                                    • 6.3.1 简单算术表达式及赋值语句
                                                                                                                                                                      • 6.3.2 数组元素的引用
                                                                                                                                                                        • 6.3.3 记录中域的引用
                                                                                                                                                                        • 6.4 布尔表达式的翻译
                                                                                                                                                                          • 6.4.1 数值表示法
                                                                                                                                                                            • 6.4.2 作为条件控制的布尔表达式翻译
                                                                                                                                                                            • 6.5 控制语句的翻译
                                                                                                                                                                              • 6.5.1 控制流语句
                                                                                                                                                                                • 6.5.2 标号与goto语句
                                                                                                                                                                                  • 6.5.3 分支语句的翻译
                                                                                                                                                                                  • 6.6 过程调用的处理
                                                                                                                                                                                    • 6.7 类型检查
                                                                                                                                                                                      • 6.7.1 类型系统
                                                                                                                                                                                        • 6.7.2 类型检查器的规格说明
                                                                                                                                                                                          • 6.7.3 函数和运算符的重载
                                                                                                                                                                                            • 6.7.4 多态函数
                                                                                                                                                                                            • 本章小结
                                                                                                                                                                                              • 习题
                                                                                                                                                                                              • 第七章 运行时存储空间组织
                                                                                                                                                                                                • 7.1 目标程序运行时的活动
                                                                                                                                                                                                  • 7.1.1 过程的活动
                                                                                                                                                                                                    • 7.1.2 参数传递
                                                                                                                                                                                                    • 7.2 运行时存储器的划分
                                                                                                                                                                                                      • 7.2.1 运行时存储器的划分
                                                                                                                                                                                                        • 7.2.2 活动记录
                                                                                                                                                                                                          • 7.2.3 存储分配策略
                                                                                                                                                                                                          • 7.3 静态分配
                                                                                                                                                                                                            • 7.3.1 数据区
                                                                                                                                                                                                              • 7.3.2 临时变量的地址分配
                                                                                                                                                                                                              • 7.4 栈式动态分配
                                                                                                                                                                                                                • 7.4.1 简单的栈式动态分配
                                                                                                                                                                                                                  • 7.4.2 嵌套过程语言的栈式实现
                                                                                                                                                                                                                  • 7.5 堆式动态分配
                                                                                                                                                                                                                    • 7.5.1 堆式动态分配的实现
                                                                                                                                                                                                                      • 7.5.2 垃圾回收
                                                                                                                                                                                                                      • 7.6 符号表
                                                                                                                                                                                                                        • 7.6.1 符号表的作用与组织
                                                                                                                                                                                                                          • 7.6.2 符号表的内容
                                                                                                                                                                                                                            • 7.6.3 利用符号表分析名字的作用域
                                                                                                                                                                                                                            • 本章小结
                                                                                                                                                                                                                              • 习题
                                                                                                                                                                                                                              • 第八章 优化
                                                                                                                                                                                                                                • 8.1 优化概述
                                                                                                                                                                                                                                  • 8.2 局部优化
                                                                                                                                                                                                                                    • 8.2.1 基本块及流图
                                                                                                                                                                                                                                      • 8.2.2 基本块的DAG表示及其应用
                                                                                                                                                                                                                                      • 8.3 循环优化
                                                                                                                                                                                                                                        • 8.3.1 代码外提
                                                                                                                                                                                                                                          • 8.3.2 强度削弱
                                                                                                                                                                                                                                            • 8.3.3 删除归纳变量
                                                                                                                                                                                                                                            • 8.4 数据流分析
                                                                                                                                                                                                                                              • 8.4.1 任意路径数据流分析
                                                                                                                                                                                                                                                • 8.4.2 全路径数据流分析
                                                                                                                                                                                                                                                  • 8.4.3 数据流问题的分类
                                                                                                                                                                                                                                                    • 8.4.4 其他主要的数据流问题
                                                                                                                                                                                                                                                      • 8.4.5 利用数据流信息进行全局优化
                                                                                                                                                                                                                                                      • 本章小结
                                                                                                                                                                                                                                                        • 习题
                                                                                                                                                                                                                                                        • 第九章 目标代码生成
                                                                                                                                                                                                                                                          • 9.1 基本问题
                                                                                                                                                                                                                                                            • 9.2 目标机模型
                                                                                                                                                                                                                                                              • 9.3 一个简单的代码生成器
                                                                                                                                                                                                                                                                • 9.3.1 待用信息
                                                                                                                                                                                                                                                                  • 9.3.2 寄存器描述数组和变量地址描述数组
                                                                                                                                                                                                                                                                    • 9.3.3 代码生成算法
                                                                                                                                                                                                                                                                    • 9.4 寄存器分配
                                                                                                                                                                                                                                                                      • 9.5 DAG的目标代码
                                                                                                                                                                                                                                                                        • 9.6 窥孔优化
                                                                                                                                                                                                                                                                          • 本章小结
                                                                                                                                                                                                                                                                            • 习题
                                                                                                                                                                                                                                                                            • 第十章 高级编译优化
                                                                                                                                                                                                                                                                              • 10.1 现代处理器体系结构对编译程序的挑战
                                                                                                                                                                                                                                                                                • 10.1.1 无处不在的并行
                                                                                                                                                                                                                                                                                  • 10.1.2 “存储墙”问题
                                                                                                                                                                                                                                                                                    • 10.1.3 优化编译程序
                                                                                                                                                                                                                                                                                    • 10.2 依赖关系分析
                                                                                                                                                                                                                                                                                      • 10.2.1 控制依赖
                                                                                                                                                                                                                                                                                        • 10.2.2 数据依赖和数据依赖图
                                                                                                                                                                                                                                                                                          • 10.2.3 循环中的依赖关系
                                                                                                                                                                                                                                                                                            • 10.2.4 依赖关系分析
                                                                                                                                                                                                                                                                                            • 10.3 高级循环优化
                                                                                                                                                                                                                                                                                              • 10.3.1 循环展开
                                                                                                                                                                                                                                                                                                • 10.3.2 循环交换和循环置换
                                                                                                                                                                                                                                                                                                  • 10.3.3 循环铺砌
                                                                                                                                                                                                                                                                                                  • 10.4 指令调度
                                                                                                                                                                                                                                                                                                    • 10.4.1 表调度
                                                                                                                                                                                                                                                                                                      • 10.4.2 全局调度
                                                                                                                                                                                                                                                                                                        • 10.4.3 循环软流水
                                                                                                                                                                                                                                                                                                        • 10.5 存储层次优化
                                                                                                                                                                                                                                                                                                          • 10.5.1 指令局部性优化
                                                                                                                                                                                                                                                                                                            • 10.5.2 寄存器重用
                                                                                                                                                                                                                                                                                                              • 10.5.3 数据预取
                                                                                                                                                                                                                                                                                                              • 本章小结
                                                                                                                                                                                                                                                                                                                • 习题
                                                                                                                                                                                                                                                                                                                • 参考文献

                                                                                                                                                                                                                                                                                                                相关图书