《编译器与编译器生成器（C++版）.pdf》资源-CSDN文库

4星 · 超过85%的资源需积分: 23 195 浏览量 2013-09-02 17:47:26 上传评论 4 收藏 1.06MB PDF 举报

资源推荐

资源详情

资源评论

Compilers and Compiler Generators

an introduction with C++

p.terry@ru.ac.za

This is a set of Postcript

files of the text of my book "Compilers and Compiler Generators - an

introduction with C++", published in 1997 by International Thomson Computer Press. The original

edition is now out of print, and the copyright has reverted to me.

The book is also available in other formats. The latest versions of the distribution and details of

how to download up-to-date compressed versions of the text and its supporting software and

courseware can be found at http://www.scifac.ru.ac.za/compilers/

for academic purposes, the material may not be redistributed without my knowledge or permission.

File List

The 18 chapters of the book are filed as chap01.ps through chap18.ps

The 4 appendices to the book are filed as appa.ps through appd.ps

The original appendix A of the book is filed as appa0.ps

The contents of the book is filed as contents.ps

The preface of the book is filed as preface.ps

An index for the book is filed as index.ps. Currently (January 2000) the page numbers refer to

an A4 version in PCL

format available at http://www.scifac.ru.ac.za/compilers/longpcl.zip.

However, software tools like GhostView may be used to search the files for specific text.

The bibliography for the book is filed as biblio.ps

Change List

18-October-1999 - Pre-release

12-November-1999 - First official on-line release

16-January-2000 - First release of Postscript version (incorporates minor corrections to

chapter 12)

Compilers and Compiler Generators © P.D. Terry, 2000

PREFACE

This book has been written to support a practically oriented course in programming language

translation for senior undergraduates in Computer Science. More specifically, it is aimed at students

who are probably quite competent in the art of imperative programming (for example, in C++,

Pascal, or Modula-2), but whose mathematics may be a little weak; students who require only a

solid introduction to the subject, so as to provide them with insight into areas of language design

and implementation, rather than a deluge of theory which they will probably never use again;

students who will enjoy fairly extensive case studies of translators for the sorts of languages with

which they are most familiar; students who need to be made aware of compiler writing tools, and to

come to appreciate and know how to use them. It will hopefully also appeal to a certain class of

hobbyist who wishes to know more about how translators work.

The reader is expected to have a good knowledge of programming in an imperative language and,

preferably, a knowledge of data structures. The book is practically oriented, and the reader who

cannot read and write code will have difficulty following quite a lot of the discussion. However, it

is difficult to imagine that students taking courses in compiler construction will not have that sort of

background!

There are several excellent books already extant in this field. What is intended to distinguish this

one from the others is that it attempts to mix theory and practice in a disciplined way, introducing

the use of attribute grammars and compiler writing tools, at the same time giving a highly practical

and pragmatic development of translators of only moderate size, yet large enough to provide

considerable challenge in the many exercises that are suggested.

Overview

The book starts with a fairly simple overview of the translation process, of the constituent parts of a

compiler, and of the concepts of porting and bootstrapping compilers. This is followed by a chapter

on machine architecture and machine emulation, as later case studies make extensive use of code

generation for emulated machines, a very common strategy in introductory courses. The next

chapter introduces the student to the notions of regular expressions, grammars, BNF and EBNF,

and the value of being able to specify languages concisely and accurately.

Two chapters follow that discuss simple features of assembler language, accompanied by the

development of an assembler/interpreter system which allows not only for very simple assembly,

but also for conditional assembly, macro-assembly, error detection, and so on. Complete code for

such an assembler is presented in a highly modularized form, but with deliberate scope left for

extensions, ranging from the trivial to the extensive.

Three chapters follow on formal syntax theory, parsing, and the manual construction of scanners

and parsers. The usual classifications of grammars and restrictions on practical grammars are

discussed in some detail. The material on parsing is kept to a fairly simple level, but with a

thorough discussion of the necessary conditions for LL(1) parsing. The parsing method treated in

most detail is the method of recursive descent, as is found in many Pascal compilers; LR parsing is

only briefly discussed.

The next chapter is on syntax directed translation, and stresses to the reader the importance and

usefulness of being able to start from a context-free grammar, adding attributes and actions that

allow for the manual or mechanical construction of a program that will handle the system that it

defines. Obvious applications come from the field of translators, but applications in other areas

such as simple database design are also used and suggested.

The next two chapters give a thorough introduction to the use of Coco/R, a compiler generator

based on L- attributed grammars. Besides a discussion of Cocol, the specification language for this

tool, several in-depth case studies are presented, and the reader is given some indication of how

parser generators are themselves constructed.

The next two chapters discuss the construction of a recursive descent compiler for a simple

Pascal-like source language, using both hand-crafted and machine-generated techniques. The

compiler produces pseudo-code for a hypothetical stack-based computer (for which an interpreter

was developed in an earlier chapter). "On the fly" code generation is discussed, as well as the use of

intermediate tree construction.

The last chapters extend the simple language (and its compiler) to allow for procedures and

functions, demonstrate the usual stack-frame approach to storage management, and go on to discuss

the implementation of simple concurrent programming. At all times the student can see how these

are handled by the compiler/interpreter system, which slowly grows in complexity and usefulness

until the final product enables the development of quite sophisticated programs.

The text abounds with suggestions for further exploration, and includes references to more

advanced texts where these can be followed up. Wherever it seems appropriate the opportunity is

taken to make the reader more aware of the strong and weak points in topical imperative languages.

Examples are drawn from several languages, such as Pascal, Modula-2, Oberon, C, C++, Edison

and Ada.

Support software

An earlier version of this text, published by Addison-Wesley in 1986, used Pascal throughout as a

development tool. By that stage Modula-2 had emerged as a language far better suited to serious

programming. A number of discerning teachers and programmers adopted it enthusiastically, and

the material in the present book was originally and successfully developed in Modula-2. More

recently, and especially in the USA, one has witnessed the spectacular rise in popularity of C++,

and so as to reflect this trend, this has been adopted as the main language used in the present text.

Although offering much of value to skilled practitioners, C++ is a complex language. As the aim of

the text is not to focus on intricate C++programming, but compiler construction, the supporting

software has been written to be as clear and as simple as possible. Besides the C++ code, complete

source for all the case studies has also been provided on an accompanying IBM-PC compatible

diskette in Turbo Pascal and Modula-2, so that readers who are proficient programmers in those

languages but only have a reading knowledge of C++ should be able to use the material very

successfully.

Appendix A gives instructions for unpacking the software provided on the diskette and installing it

on a reader’s computer. In the same appendix will be found the addresses of various sites on the

Internet where this software (and other freely available compiler construction software) can be

found in various formats. The software provided on the diskette includes

Emulators for the two virtual machines described in Chapter 4 (one of these is a simple

accumulator based machine, the other is a simple stack based machine).

The one- and two-pass assemblers for the accumulator based machine, discussed in Chapter 6.

A macro assembler for the accumulator-based machine, discussed in Chapter 7.

Three executable versions of the Coco/R compiler generator used in the text and described in

detail in Chapter 12, along with the frame files that it needs. (The three versions produce

Turbo Pascal, Modula-2 or C/C++ compilers)

Complete source code for hand-crafted versions of each of the versions of the Clang compiler

that is developed in a layered way in Chapters 14 through 18. This highly modularized code

comes with an "on the fly" code generator, and also with an alternative code generator that

builds and then walks a tree representation of the intermediate code.

Cocol grammars and support modules for the numerous case studies throughout the book that

use Coco/R. These include grammars for each of the versions of the Clang compiler.

A program for investigating the construction of minimal perfect hash functions (as discussed

in Chapter 14).

A simple demonstration of an LR parser (as discussed in Chapter 10).

Use as a course text

The book can be used for courses of various lengths. By choosing a selection of topics it could be

used on courses as short as 5-6 weeks (say 15-20 hours of lectures and 6 lab sessions). It could also

be used to support longer and more intensive courses. In our university, selected parts of the

material have been successfully used for several years in a course of about 35 - 40 hours of lectures

with strictly controlled and structured, related laboratory work, given to students in a pre-Honours

year. During that time the course has evolved significantly, from one in which theory and formal

specification played a very low key, to the present stage where students have come to appreciate the

use of specification and syntax-directed compiler-writing systems as very powerful and useful tools

in their armoury.

It is hoped that instructors can select material from the text so as to suit courses tailored to their

own interests, and to their students’ capabilities. The core of the theoretical material is to be found

in Chapters 1, 2, 5, 8, 9, 10 and 11, and it is suggested that this material should form part of any

course based on the book. Restricting the selection of material to those chapters would deny the

student the very important opportunity to see the material in practice, and at least a partial selection

of the material in the practically oriented chapters should be studied. However, that part of the

material in Chapter 4 on the accumulator-based machine, and Chapters 6 and 7 on writing

assemblers for this machine could be omitted without any loss of continuity. The development of

the small Clang compiler in Chapters 14 through 18 is handled in a way that allows for the later

sections of Chapter 15, and for Chapters 16 through 18 to be omitted if time is short. A very wide

variety of laboratory exercises can be selected from those suggested as exercises, providing the

students with both a challenge, and a feeling of satisfaction when they rise to meet that challenge.

Several of these exercises are based on the idea of developing a small compiler for a language

similar to the one discussed in detail in the text. Development of such a compiler could rely entirely

on traditional hand-crafted techniques, or could rely entirely on a tool-based approach (both

approaches have been successfully used at our university). If a hand-crafted approach were used,

Chapters 12 and 13 could be omitted; Chapter 12 is largely a reference manual in any event, and

could be left to the students to study for themselves as the need arose. Similarly, Chapter 3 falls into

the category of background reading.

At our university we have also used an extended version of the Clang compiler as developed in the

text (one incorporating several of the extensions suggested as exercises) as a system for students to

study concurrent programming per se, and although it is a little limited, it is more than adequate for

the purpose. We have also used a slightly extended version of the assembler program very

successfully as our primary tool for introducing students to the craft of programming at the

assembler level.

Limitations

It is, perhaps, worth a slight digression to point out some things which the book does not claim to

be, and to justify some of the decisions made in the selection of material.

In the first place, while it is hoped that it will serve as a useful foundation for students who are

already considerably more advanced, a primary aim has been to make the material as accessible as

possible to students with a fairly limited background, to enhance the background, and to make them

somewhat more critical of it. In many cases this background is still Pascal based; increasingly it is

tending to become C++ based. Both of these languages have become rather large and complex, and

I have found that many students have a very superficial idea of how they really fit together. After a

course such as this one, many of the pieces of the language jigsaw fit together rather better.

When introducing the use of compiler writing tools, one might follow the many authors who

espouse the classic lex/yacc approach. However, there are now a number of excellent LL(1) based

tools, and these have the advantage that the code which is produced is close to that which might be

hand-crafted; at the same time, recursive descent parsing, besides being fairly intuitive, is powerful

enough to handle very usable languages.

That the languages used in case studies and their translators are relative toys cannot be denied. The

Clang language of later chapters, for example, supports only integer variables and simple

one-dimensional arrays of these, and has concurrent features allowing little beyond the simulation

of some simple textbook examples. The text is not intended to be a comprehensive treatise on

systems programming in general, just on certain selected topics in that area, and so very little is said

about native machine code generation and optimization, linkers and loaders, the interaction and

relationship with an operating system, and so on. These decisions were all taken deliberately, to

keep the material readily understandable and as machine-independent as possible. The systems may

be toys, but they are very usable toys! Of course the book is then open to the criticism that many of

the more difficult topics in translation (such as code generation and optimization) are effectively

not covered at all, and that the student may be deluded into thinking that these areas do not exist.

This is not entirely true; the careful reader will find most of these topics mentioned somewhere.

Good teachers will always want to put something of their own into a course, regardless of the

quality of the prescribed textbook. I have found that a useful (though at times highly dangerous)

technique is deliberately not to give the best solutions to a problem in a class discussion, with the

剩余426页未读，继续阅读

评论收藏

内容反馈

EliShaw

2014-08-04

目前还没看明白，先谢谢分享吧
noviciate

2013-09-26

对理解编译原理有帮助。
megamind001

2014-11-26

高深，理解吃力啊

arvin_xiaoting

粉丝: 367
资源: 54

《编译器与编译器生成器（C++版）.pdf》

编译器与编译器生成器（C++版）

C++制作的编译器 代码+例子

编译器设计生成

简单的编译器(c++实现)

自己开发的c++编译器

多态的编译器实现原理

C编译器剖析

一款C++开源代码编辑器Notepad源代码(Notepad.Plus.v4.4)

Crafting a Compiler by Charles N. Fisher Richard J. LeBlanc 带目录版

非常好用的PDF文件编辑器.rar

编译器和编译器生成器：C ++简介Compilers and Compiler Generators: an introduction with C++

在VisualC++集成开发环境下应用flex和bison开发编译器.pdf

轻量级PDF文档编辑器绿色版

万能文本编辑器V1.3

PDFEditor open source

C++编译器对字符串的编码转换.pdf

Notepad++配置C和C++编译器[归纳].pdf

C++编译器对字符串的编码转换[归类].pdf

C++(Qt)软件调试-编译器及编译参数学习（4）V1.0.0.pdf

C-C++显示各种C-C++编译器的预定义宏(C11标准、C++11标准、VC、BCB、Inte.pdf

在C++ 程序中调用被C 编译器编译后的函数,为什么要加extern “C”？.pdf

基于Mideva编译器的MATLAB与VC++混合编程技术.pdf

CPP-Templates.pdf.zip_编译器/解释器_Visual_C++_

VC++编译器选项设定方法[参考].pdf

英特尔® C++编译器Cilk语言扩展.pdf

C++(Qt)软件崩溃调试-编译器及编译参数学习（4）.pdf

Linux C++编程：编译器GCC简介.pdf

最新资源

C++制作的编译器代码+例子