Preface

• Who this book is for
• What this book covers
• To get the most out of this book
• Get in touch

1. Section I: Programming Language Frontends

2. Why Build Another Programming Language? FREE CHAPTER

• Motivations for writing your own programming language
• Types of programming language implementations
• Organizing a bytecode language implementation
• Languages used in the examples
• The difference between programming languages and libraries
• Applicability to other software engineering tasks
• Establishing the requirements for your language
• Case study – requirements that inspired the Unicon language
• Summary
• Questions

3. Programming Language Design

• Determining the kinds of words and punctuation to provide in your language
• Specifying the control flow
• Deciding on what kinds of data to support
• Overall program structure
• Completing the Jzero language definition
• Case study – designing graphics facilities in Unicon
• Summary
• Questions

4. Scanning Source Code

• Technical requirements
• Lexemes, lexical categories, and tokens
• Regular expressions
• Using UFlex and JFlex
• Writing a scanner for Jzero
• Regular expressions are not always enough
• Summary
• Questions

5. Parsing

• Technical requirements
• Syntax analysis
• Context-free grammars
• Using iyacc and BYACC/J
• Writing a parser for Jzero
• Summary
• Questions

6. Syntax Trees

• Technical requirements
• Using GNU Make
• Learning about trees
• Creating leaves from terminal symbols
• Building internal nodes from production rules
• Forming syntax trees for the Jzero language
• Debugging and testing your syntax tree
• Summary
• Questions

7. Section II: Syntax Tree Traversals

8. Symbol Tables

• Technical requirements
• Establishing the groundwork for symbol tables
• Creating and populating symbol tables for each scope
• Checking for undeclared variables
• Finding redeclared variables
• Handling package and class scopes in Unicon
• Testing and debugging symbol tables
• Summary
• Questions

9. Checking Base Types

• Technical requirements
• Type representation in the compiler
• Assigning type information to declared variables
• Determining the type at each syntax tree node
• Runtime type checks and type inference in Unicon
• Summary
• Questions

10. Checking Types on Arrays, Method Calls, and Structure Accesses

• Technical requirements
• Checking operations on array types
• Checking method calls
• Checking structured type accesses
• Summary
• Questions

11. Intermediate Code Generation

• Technical requirements
• What is intermediate code?
• An intermediate code instruction set
• Annotating syntax trees with labels for control flow
• Generating code for expressions
• Generating code for control flow
• Summary
• Questions

12. Syntax Coloring in an IDE

• Writing your own IDE versus supporting an existing one
• Downloading the software used in this chapter
• Adding support for your language to Visual Studio Code
• Integrating a compiler into a programmer’s editor
• Avoiding reparsing the entire file on every change
• Using lexical information to colorize tokens
• Highlighting errors using parse results
• Summary
• Questions

13. Section III: Code Generation and Runtime Systems

14. Preprocessors and Transpilers

• Understanding preprocessors
• Code generation in the Unicon preprocessor
• The difference between preprocessors and transpilers
• Transpiling Jzero code to Unicon
• Summary
• Questions

15. Bytecode Interpreters

• Technical requirements
• Understanding what bytecode is
• Comparing bytecode with intermediate code
• Building a bytecode instruction set for Jzero
• Implementing a bytecode interpreter
• Writing a runtime system for Jzero
• Running a Jzero program
• Examining iconx, the Unicon bytecode interpreter
• Summary
• Questions

16. Generating Bytecode

• Technical requirements
• Converting intermediate code to Jzero bytecode
• Comparing bytecode assembler with binary formats
• Linking, loading, and including the runtime system
• Unicon example – bytecode generation in icont
• Summary
• Questions

17. Native Code Generation

• Technical requirements
• Deciding whether to generate native code
• Introducing the x64 instruction set
• Using registers
• Converting intermediate code to x64 code
• Generating x64 output
• Summary
• Questions
• Leave a review!

18. Implementing Operators and Built-In Functions

• Implementing operators
• Writing built-in functions
• Integrating built-ins with control structures
• Developing operators and functions for Unicon
• Summary
• Questions

19. Domain Control Structures

• Knowing when a new control structure is needed
• Scanning strings in Icon and Unicon
• Rendering regions in Unicon
• Summary
• Questions

20. Garbage Collection

• Grasping the importance of garbage collection
• Counting references to objects
• Marking live data and sweeping the rest
• Summary
• Questions

21. Final Thoughts

• Reflecting on what was learned from writing this book
• Deciding where to go from here
• Exploring references for further reading
• Summary

22. Section IV: Appendix

23. Answers

24. Other Books You May Enjoy

25. Index

Appendix: Unicon Essentials

• Syntactic shorthand
• Running Unicon
• Using Unicon’s declarations and data types
• Evaluating expressions
• Debugging and environmental issues
• Function mini-reference
• Selected keywords