Class 27: Symbol Tables, Continued

Held Wednesday, November 6, 2002

Summary

Today we continue our discussion of symbol tables by designing an interface for a symbol table object.

Notes

• One of my CS151 students reminded me of a favorite CS puzzle: Write a program that generates its own source code (without reading that source code from a file). How many of you have written that program?
• How go your more-time-consuming-than-expected parsers?
  • I've thought about the relative benefits of having you write less of the parser, and I expect that you'll feel less of a sense of ownership if you don't do it all yourself :-).
• Daren talks today! I can't go, but I hope you will.
• I've rearranged the course at a glance.

Overview

• Notes on translation
• Symbol tables, revisited

Status, or Stages of Compilation, Revisited

• We'll spend a few minutes going over our current "state" in the translation from source code to assembly code.
• We know how to build the parse tree (and, I think, can successfully build those parse trees).
• We know how to check the types and build the symbol table for the parse tree.
  • You wil soon work on that stage of the project.
• Note that because we've separated the symbol stuff from the translation, you can think of this as a multi-pass compiler.
  • In the good old days, many people worried that doing multiple passes over the source tree was a bad idea because it used lots of extra time. Now, many are willing to pay the cost in exchange for more elegant (and, ocassionally, more powerful) design.
• It is possible to do more than these two passes, but we'll stick with these two basics passes over the tree.
  • One to type check.
  • One to build abstract assembly code.
• We'll also do a few passes over the code.
  • One to deal with register allocation.
  • At least one to deal with improvement.
  • (Yes, they may be partially combined.)
• Another possibility would be to use some intermediate representations before going directly to assembly code. Such intermediate representations make it easier to compile for different architectures (since you worry less about precise details until those details are necessary).
  • We'll use an intermediate representation fairly close to our assembly, but perhaps with some details left to later.

Reflection: The Design of Symbol Tables

• We'll spend a few minutes working together as a class to come up with a good symbol table interface.