Modern compiler design [PDF]

Contents
1 Introduction & Explanation 3
1.1 What Is This Document? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 How To Use This Document . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 So Where Are Chapters 3 and 4? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 Where Can I Find Necessary Files for Creating a Compiler in C? . . . . . . . . . . . . . . . . 3
2 Lexical Analysis 4
2.1 Lex – A Lexical Analyzer Generator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.1.1 Structure of a Lex file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.2 Named Regular Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.3 Tokens With Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.4 Dealing with White Space . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.1.5 Keeping Track of Token Positions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.1.6 States in Lex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.1.7 Using Lex with Other C Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.8 Advanced Lex Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Creating a Lexical Analyzer for simpleJava in Lex . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2.1 Project Definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2.2 Project Difficulty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2.3 Project “Gotcha”s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2.4 Provided Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
5 Bottom-Up Parsing & Yacc 21
5.1 Yacc – Yet Another Compiler Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.1.1 Structure of a Yacc File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.1.2 Dealing With Parsing Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5.1.3 Tokens With Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.1.4 When Yacc Has Conflicts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.1.5 Operator Precedence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
5.2 Writing a Parser For simpleJava Using Yacc . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5.2.1 Project Definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5.2.2 Project Difficulty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5.2.3 Project “Gotcha”s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5.2.4 Provided Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5.3 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
6 Abstract Syntax Trees in C 33
6.1 Implementing Trees in C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
6.1.1 Representing trees – structs and unions . . . . . . . . . . . . . . . . . . . . . . . . . . 33
6.1.2 Using Constructors in C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
6.1.3 Traversing Trees in C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
6.2 Yacc Actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
6.2.1 Simple Yacc Actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
1