COMP 520 - Compilers http://www.cs.unc.edu/~prins/Classes/520/ next offering: Spring 2020 date/time: TBD Instructor: Jan Prins FB 334 prins@cs.unc.edu Office Hours: TBD

Overview

• Understand the theory and practice of compilers, linkers, debuggers, hardware and abstract machine execution, and be able to work effectively with such programs.
• Be able to design and implement parsers and language translators for simple languages.
• Appreciate the effects of decisions in programming language and computer architecture design on the translation process and run-time systems.
• Have experience with the design and implementation of large and complex program using Java.
• Retain knowledge of compilation and interpretation techniques in preparation for advanced courses in compilers and/or comprehensive computer science studies.

Prerequisites

Text

Course Syllabus

• Index of Lecture Materials.

Scanner and Parser: download http://www.cs.unc.edu/~prins/Classes/520/Examples/simpleScannerParser.zip

Illustrates the package structure and classes for a scanner and parser (mostly following the text), and implements a scanner and parser that recognize (valid/invalid) simple arithmetic expressions using numbers, operators (+,-), and balanced parenthesization.

The top -level pacakage is miniArith contaning the Recognizer mainclass that parses input entered from the keyboard and judges whether it consitutes a valid arithmetic expression. The parse procedures corresponding to nonterminals in the grammar are traced to illustrate how the input was parsed.

The subpackage miniArith.SyntacticAnalyzer contains the Scanner, Parser, Token classes and the TokenKind enumeration.

You can use this example as a starting point for your miniJava compiler, if you wish.

AST construction and AST traversal: download http://www.cs.unc.edu/~prins/Classes/520/Examples/simpleAST.zip

Illustrates AST construction and traversal example using a stratified grammar to parse a simple arithmetic expression entered from the keyboard. It constructs an AST that reflects the associativity and precedence of addition and multiplication operations, and respects parenthesization.

The scanner and parser are in the SyntacticAnalysis subpackage and use AST classes provided in the AbstractSyntaxTrees subpackage to construct the AST during parsing.

Two traversals of the AST are implemented as visitors in the TraverseAST subpackage: DisplayAST constructs an explicitly parenthesized text representation of the AST and EvalAST evaluates an AST.

The top level package is miniArith with main class Evaluator. It uses the scanner and parser to parse an arithmetic expression entered as input from the keyboard and to construct an AST. The two visitors are used to display the AST in linear form and to compute its value.

Reference Section

MiniJava Project tester

Textbook

Watt & Brown, Programming Language Processors in Java

Textbook
The missing page 150

Java Reference

• An older Java specification to infer miniJava behavior: Java Language Specification, 3rd edn
• Java SE 8 to write your compiler: Java Platform Standard Edition Release 8 documentation

Additional references

• The MIPS instruction set is summarized in section A.10 from Appendix A of Hennessy and Patterson, Computer Organization and Design: The Hardware/Software Interface
• The Java Virtual Machine (JVM) SE 8 specification

Triangle compiler

• Instructions for installing and running the Triangle compiler tools on a Linux machine
  1. Make sure you have a working java runtime and compiler with the following commands:
     which java -- this should be /usr/bin/java
     java -version -- this should be 1.8 (on dept machines) is OK
     javac -version -- first two digits should match the version of java
     If you encounter problems check that /usr/bin is on your PATH.
  2. Install the TriangleTools directory:
     curl "http://www.cs.unc.edu/~prins/Classes/520/Examples/TriangleTools.tgz" | tar -xz
  3. Change into the TriangleTools directory and compile the Triangle language tools:
     cd TriangleTools
     javac Triangle/Compiler.java
     javac TAM/Interpreter.java
     javac TAM/Disassember.java
  4. Run the Triangle compiler on a sample input program p1.tri:
     java Triangle/Compiler p1.tri
  5. Run the interpreter on the object code generated in file obj.tam:
     java TAM/Interpreter obj.tam
  6. Run the disassembler on the object code generated in file obj.tam:
     java TAM/Disassembler obj.tam

• Instructions for installing and running the Triangle compiler using Eclipse
  1. In Eclipse, select the Java perspective and create a new Java project TriangleTools (File/New/Java Project, enter "TriangleTools" in the Project Name, important: choose "Use project folder as root for sources and class files" and select "Finish").
  2. Import the jar file TriangleTools.jar into the project (File/Import/General/Archive, browse to the jar file, verify the project it will be imported into is "TriangleTools", and select "Finish").
  3. Create run configurations in the project for the three Java Applications: Triangle.Compiler, TAM.Interpreter, and TAM.Disassembler (Run/Run Configurations ... then create three new instances of a run configuration for a Java Application, each with the appropriate main. Edit the run configuration for the Triangle compiler to include argument "p1.tri").
  4. Run the configurations in order: compiler, interpreter, and disassembler.