COMP 520 - Compilers http://www.cs.unc.edu/~prins/Classes/520/ Spring 2021 Tue, Thu 12:30 - 1:45 PM Jan 19 - May 4 (Remote-Only - Synchronous) Instructor: Jan Prins (prins@cs.unc.edu) TA: Chris Dean (cmdean@cs.unc.edu)

Announcements

• We will use Piazza for offline discussions. You should have received an invitation via email to join our Piazza site: https://piazza.com/unc/spring2021/comp520/home
• Written assignments should be submitted using gradescope.

Reading Assignments

• (for Thu Jan 21) PLPJ Skim Chapter 1 - Introduction (pp 1 - 25).
• (for Tue Jan 26) PLPJ Skim PLPJ Chapter 3 (pp 55 – 70). Study PLPJ Chapter 4 Secns 4.1, 4.2 (pp 73 – 83).
• (for Thu Jan 28, Tue Feb 2)
  • 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 Feb 4) PLPJ Scanner construction, Secn 4.5 (pp 118 - 124)
• (for Tue Feb 9) PLPJ Abstract Syntax Trees, Secn 4.4 (pp 109 - 118)
• (for Thu Feb 18) PLPJ AST construction in Triangle (pp 124 - 128)
• (for Thu Mar 4) PLPJ Contextual Analysis - Identification (pp 136 - 149)
• (for Tue Mar 9) PLPJ Contextual Analysis - secn 5.2 Type checking (pp 151-153)
• (for Tue Mar 16) midterm exam
• (for Thu Mar 18) PLPJ Contextual Analysis implementation using the visitor pattern (pp 154 - 163)
• (for Tue Mar 30) PLPJ Runtime organization (skim pp 173-229, read secn 7.6 pp 230 - 236 secn 6.7 on OO language runtime organization)
• (for Tue/Thu Apr 6,8) PLPJ Code Generation Chap 7 - skim through the chapter for aspects of Triangle/TAM that apply to miniJava/mJAM

Written Assignments

• (Due Thu Jan 21, 11PM, Gradescope) wa1 and sample solutions
• (Due Tue Feb 2, 11PM, Gradescope) wa2 and sample solutions
• (Due Mon Mar 1, 11PM, Gradescope) wa3 and sample solutions

Programming Assignments

• (Due: Tue Feb 9, 11:59 pm) PA1 - syntactic analysis
• (Due: Wed Mar 3, 11:59 PM) PA2 - Abstract Syntax Tree Construction
  and AbstractSyntaxTrees package for use in PA2.
• (Due: Wed Mar 31 11:59PM) PA3 - Contextual Analysis
• (Due Wed Apr 21 11:59 PM)
  • PA4 - Code Generation assignment
  • mJAM (miniJava Abstract Machine) zip file
  • PA4Test.java to incrementally build up the code generator.

Examples

Here are small examples implementing scanning, parsing, and AST construction for simple arithmetic expressions that correspond roughly to checkpoints PA1 and PA2 in our miniJava project. To install:
1. Download the zip file
2. in Eclipse: File / Import Existing Projects into Workspace / Next
3. choose "Select Archive File" radio button, browse to zip file and Open / Finish

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 package is miniArith. It contains 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.

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

Illustrates construction of an AST using the node definitions in the miniArith.AbstractSyntaxTrees subpackage. The first traversal displays the input arithmetic expression in fully parenthesized form, reflecting precedence and associativity rules. The second traversal evaluates the expression and displays the result. The two traversals are implemented using a single implementation of the Visitor design pattern.

PA4-example - Code Generation and Execution using mJAM : download http://www.cs.unc.edu/~prins/Classes/520/Examples/PA4-example.zip and import into Eclipse as a new project.

Generates a sequence of mJAM instructions that might be emitted by your code generation visitor applied to the example miniJava "Counter" class. First it generates a preamble in the code store starting at location 0 that calls public static main(String [] args) in class Counter with an empty array of String, and emits the body of the main class that creates counter, an instance of the Counter class, and applies the increase method of the Counter class, and finally prints the value of Counter.count
The generated code is then executed using mJAM in debug mode, so you can single step through the execution.

Lecture Materials

• Lecture Slides

  1. Introduction
  2. PLspec
  3. CFG-Parsing
  4. EBNF-RDparsing
  5. Scanner construction
  6. Compiler Structure (including PA1 submission instructions)
  7. Operator precedence and stratified grammars
  8. Abstract Syntax Trees
  9. AST wrapup and bottom up parsing
  10. 10-Identification
  11. 11-Types
  12. 12-ContextualAnalysis
  13. 12a-Identification
  14. 12c-ContextualAnalysis
  15. 13-RuntimeOrganization
  16. 14-CodeGeneration (parts 1 and 2)
  17. 15-miniJavaCodegenExample
  18. 16-OORuntime.pdf

• Lecture Recordings

  1. 01-19_COMP_520_Compilers_Introduction_startsat-2m0s.mp4
  2. 01-21_COMP_520_Compilers_PLspec_startsat-13m30s.mp4
  3. 01-26_COMP_520_Compilers_EBNF_Grammars_Top-down_Parsing_startsat_9m0s.mp4
  4. 01-28_COMP_520_Compilers_EBNF_RDparsing.mp4
  5. 02-02_COMP_520_Compilers_Lexical_Analysis_startsat_2m20s.mp4 and Whiteboard - parser construction example
  6. 02-04_COMP_520_Compiler_Scanner-review_startsat_6m45s.mp4
  7. 02_09_COMP_520_Compiler-Structure_startsat_15m20s.mp4
  8. 02_11_COMP_520_Precedence-Parsing_startsat_03m15s.mp4
  9. 02_23_COMP_520_Abstract_Syntax_trees_startsat_4m0s.mp4
  10. 02_25_COMP_520_ASTwrapup_BottomupParsing_startsat_03m0s.mp4
  11. 03_02_COMP_520_Identification_startsat_4m45s.mp4
  12. 03_04_COMP_520_Identification_and_Types_startsat_08m15s.mp4
  13. 03_09_COMP_520_PA3_Implementation_startsat_3m0s.mp4
  14. 03_18_COMP_520_Identification_Example_startsat_06m50s.mp4
  15. 03-23_COMP_520_Identification_using_Visitor_Pattern_12c_startsat_02m28s.mp4
  16. 03-30_COMP_520_Run-time_Organization_startat_04m15s.mp4
  17. 04-01_COMP_520_Code_Generation_Startsat_4m0s.mp4
  18. 04-06_CodeGeneration_Part2_Startsat_04m25s.mp4
  19. 04-08_COMP_520_miniJavaCodegenExample_startsat_17m0s.mp4
  20. 04-13_COMP_520_Compilers_Inheritance_Impl_startsAt_04m25s.mp4

Overview

• Understand the theory and practice of compilers, linkers, debuggers, and program execution by hardware or abstract machines.
• Appreciate the effect of trade-offs in programming language design and computer architecture on program compilation and the run-time support system.
• Have gained additional experience with the design and implementation of a large and complex program using Java.
• Be prepared for advanced study in programming languages and optimizing compilers.

Course Syllabus

Text

Watt & Brown, Programming Language Processors in Java

Textbook
The missing page 150