COMP 520 - Compilers http://www.cs.unc.edu/~prins/Classes/520/ Spring 2019 (Thu Jan 10 - Thu Apr 25) TTh 12:30 - 1:45 PM FB 009 Instructor: Jan Prins FB 334 prins@cs.unc.edu Office Hours: Mon 2 - 3:30 pm TA: Qian Zhang qzane@cs.unc.edu Office Hours: Wed 2 - 3 pm in FB331

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

• We will be using Piazza for class discussions outside of class. I encourage you to post your questions on Piazza and to contribute to discussions.
  • Please join our discussion group using this link: http://piazza.com/unc/spring2019/comp520
  • Please access the discussion group using this link: http://piazza.com/unc/spring2019/comp520/home
• A portable Windows Java SE 8 and Eclipse IDE that includes example codes for this class is available at https://github.com/qzane/Compilers/. If you have a suitable Java and Eclipse already available, you can follow the instructions below to import examples.

Reading Assignments

• (for Tue Mar 19) PLPJ Chapter 6 - Run-Time Organization
  skim section 6.1 Data Representation (pp 173 - 192),
  read section 6.2 Expression evaluation (pp 192 - 195)
  
• (for Thu Mar 7) PLPJ Chapter 5 - Implementation of contextual analysis - section 5.3 (pp 153 - 163)
• (for Thu Feb 21) PLPJ Chapter 5 - Type checking - section 5.2 (pp 150 - 153) and contextual analysis - sections 5.2-5.3 (pp 150 - 163)
  
• (for Tue Feb 19) PLPJ Chapter 5: Contextual Analysis - section 5.1 (pp 136 - 150)
  
• (for Thu Feb 7) PLPJ Secn 4.6 Syntactic Analysis in Triangle (pp 124 - 128)
  PLPJ Secn 4.3.1 Bottom-up Parsing (pp 84 - 87)
• (for Thu Jan 31) PLPJ skim Abstract Syntax Trees, Secn 4.4 (pp 109 - 118)
• (for Thu Jan 24)PLPJ Scanner construction, Secn 4.5 (pp 118 - 124)
• (for Tue/Thu Jan 22/24) PLPJ Parsing, Secn 4.3 (pp 83 - 84)
  Top-down parsing, Secn 4.3.2, (pp 87 - 89)
  Recursive descent parsing, Secn 4.3.3 (pp 89 - 93)
  Systematic development of recursive-descent parsers, Secn 4.3.4 (pp 93 - 109)
• (for Thu Jan 17) PLPJ Skip Chapter 2 for now
  Skim PLPJ Chapter 3 (pp 55 -70)
  Study PLPJ Chapter 4 Secns 4.1, 4.2 (pp 73 - 83)
• (for Tue Jan 15) PLPJ Skim Chapter 1 - Introduction (pp 1 - 25).

Lecture Notes

• Index of Lecture Materials.

• Short written assignment WA3 assigned Tue Feb 12, due Tue Feb 19 (at start of class!)
  Sample solutions are available.
• Short written assignment WA2 assigned Tue Jan 22, due Tue Jan 29 (hand in at the start of class!)
  Sample solutions are available.
  Supplementary WA2 problem for extra credit posted Mon Feb 25, due Mon Mar 3.
  Sample solution for supplementary problem
• Short written assignment WA1 assigned Thu Jan 10, due Tue Jan 15 (hand in at the start of class!). This assignment is to get you thinking about some issues in Java and instruction-level computer programs. This assignment is available on paper at the back of the classroom, and should be turned in at the start of class next Tuesday.

Programming Assignments

• PA1 Syntactic Analysis assigned Tuesday Jan 15, and due Monday Feb 4.
  • PA1 submissions are graded. Scores are in your pa1 submission directory, and the tests can be run using the instructions in the reference section below.
    • PA1 tests (zipped)
    • The Checkpoint1.java tester. Make sure you have set up the correct projects and directories following the instructions and install the PA1 tests and the Checkpoint1 tester right locations.

• PA2 Abstract Syntax Trees handout (updated to show correct AST on last page) assigned Tuesday Feb 5, and due Monday Feb 25. In PA2, use the AbstractSyntaxTrees classes to build the AST while parsing miniJava programs.
  • The pa2 submission directories are open. Instructions for uploading your pa2 checkpoint are available here.
  • PA2 submissions are graded. Scores are in your pa2 submission directory, and the tests can be run using the instructions in the reference section below.
    • PA tests (zipped)
    • The Checkpoint2.java tester. Make sure you have set up the correct projects and directories following the instructions and install the pa2_tests and the Checkpoint2.java tester in the corect locations.

• PA3 Contextual Analysis assigned Tuesday Feb 26, due Monday Mar 25.

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

• Each checkpoint in the compiler project will be evaluated using a series of tests. You can rerun the tests that were used in scoring your checkpoint in Eclipse using a tester to check that you have fixed any errors. Note that earlier tests may not be valid at later checkpoints.
• Instructions to set up the tester in Eclipse
  1. Create a new package called tester within the project that includes your miniJava. So the tester package sits alongside your miniJava package, and not in your miniJava package.
  2. Create a new project (so not a Java project!) called tests in your Eclipse workspace (so tests and your miniJava project are completely separate projects).
• Instructions to use the tester in Eclipse
  1. Import or copy a checkpoint tester, e.g. Checkpoint1.java, into the tester package.
  2. Import the matching folder of tests, e.g. pa1_tests, into the the tests project.
  3. Run the tests, e.g. run Checkpoint1. It will apply all tests and show you a report of their outcome.

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.