From: Siraaj Khandkar Date: Fri, 13 Apr 2018 22:24:51 +0000 (-0400) Subject: Tabularize all and expand 1st 2 chapters X-Git-Url: https://git.xandkar.net/?p=tiger.ml.git;a=commitdiff_plain;h=c43a2e2eaad4f99f6e30208cb7d9193801a2bfc0 Tabularize all and expand 1st 2 chapters --- diff --git a/README.md b/README.md index 632225a..641ffa3 100644 --- a/README.md +++ b/README.md @@ -4,26 +4,80 @@ Tiger.ml Project Plan ------------ -I. Fundamentals of Compilation - 1. Introduction - 2. Lexical Analysis - 3. Parsing - 4. Abstract Syntax - 5. Semantic Analysis - 6. Activation Records - 7. Translation to Intermediate Code - 8. Basic Blocks and Traces - 9. Instruction Selection - 10. Liveness Analysis - 11. Register Allocation - 12. Putting It -II. Advanced Topics - 13. Garbage Collection - 14. Object-Oriented Languages - 15. Functional Programming Languages - 16. Polymorphic Types - 17. Dataflow Analysis - 18. Loop Optimizations - 19. Static Single-Assignment Form - 20. Pipelining and Scheduling - 21. The Memory Hierarchy +| status | id | title | pages | estimate | actual | start | finish | +|--------|------------|------------------------------------------|-------|----------|--------|------------|------------| +| [ ] | 0 | Modern Compiler Implementation in ML | 512 | 28 | -- | xxxx-xx-xx | xxxx-xx-xx | +| ====== | ========== | ======================================== | ===== | ======== | ====== | ========== | ========== | +| [ ] | 1 | - Fundamentals of Compilation | 264 | 14 | -- | ---------- | ---------- | +| [ ] | 1.01 | -- Introduction | 011 | 01 | -- | ---------- | ---------- | +| [ ] | 1.01.1 | --- Modules and interfaces | 001 | -- | -- | ---------- | ---------- | +| [ ] | 1.01.2 | --- Tools and Software | 002 | -- | -- | ---------- | ---------- | +| [ ] | 1.01.3 | --- Data structures for tree languages | 003 | -- | -- | ---------- | ---------- | +| [ ] | 1.01.p | --- Program | 002 | -- | -- | ---------- | ---------- | +| [ ] | 1.01.p.1 | ---- interpreter: maxargs | --- | -- | -- | ---------- | ---------- | +| [ ] | 1.01.p.2 | ---- interpreter: interp | --- | -- | -- | ---------- | ---------- | +| [ ] | 1.01.e | --- Exercises | 002 | -- | -- | ---------- | ---------- | +| [ ] | 1.01.e.1.a | ---- tree member | --- | -- | -- | ---------- | ---------- | +| [ ] | 1.01.e.1.b | ---- tree key/val | --- | -- | -- | ---------- | ---------- | +| [ ] | 1.01.e.1.c | ---- demo unbalanced behaviour | --- | -- | -- | ---------- | ---------- | +| [ ] | 1.01.e.1.d | ---- find functional balanced tree | --- | -- | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 1.02 | -- Lexical Analysis | 024 | 01 | -- | ---------- | ---------- | +| [ ] | 1.02.1 | --- Lexical tokens | 001 | -- | -- | ---------- | ---------- | +| [ ] | 1.02.2 | --- Regular expressions | 003 | -- | -- | ---------- | ---------- | +| [ ] | 1.02.3 | --- Finite automata | 003 | -- | -- | ---------- | ---------- | +| [ ] | 1.02.4 | --- Nondeterministic finite automata | 006 | -- | -- | ---------- | ---------- | +| [ ] | 1.02.5 | --- ML-Lex: a lexical analyzer generator | 003 | -- | -- | ---------- | ---------- | +| [ ] | 1.02.p | --- Program | 002 | -- | -- | ---------- | ---------- | +| [ ] | 1.02.p.1 | --- Tiger lexer | --- | -- | -- | ---------- | ---------- | +| [ ] | 1.02.e | --- Exercises | 004 | -- | -- | ---------- | ---------- | +| [ ] | 1.02.e.01 | ---- regexes | --- | -- | -- | ---------- | ---------- | +| [ ] | 1.02.e.02 | ---- why no regexes | --- | -- | -- | ---------- | ---------- | +| [ ] | 1.02.e.03 | ---- explain automata | --- | -- | -- | ---------- | ---------- | +| [ ] | 1.02.e.04 | ---- regex to nondeterministic automata | --- | -- | -- | ---------- | ---------- | +| [ ] | 1.02.e.05 | ---- NFA to DFA | --- | -- | -- | ---------- | ---------- | +| [ ] | 1.02.e.06 | ---- merge equivalent automata states | --- | -- | -- | ---------- | ---------- | +| [ ] | 1.02.e.07 | ---- DFA to regex | --- | -- | -- | ---------- | ---------- | +| [ ] | 1.02.e.08 | ---- analyze lexer based on given DFA | --- | -- | -- | ---------- | ---------- | +| [ ] | 1.02.e.09 | ---- generate lexer tables from spec | --- | -- | -- | ---------- | ---------- | +| [ ] | 1.02.e.10 | ---- design better lookahead than Aho | --- | -- | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 1.03 | -- Parsing | 049 | 02 | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 1.04 | -- Abstract Syntax | 016 | 01 | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 1.05 | -- Semantic Analysis | 021 | 01 | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 1.06 | -- Activation Records | 024 | 01 | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 1.07 | -- Translation to Intermediate Code | 025 | 01 | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 1.08 | -- Basic Blocks and Traces | 013 | 01 | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 1.09 | -- Instruction Selection | 025 | 01 | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 1.10 | -- Liveness Analysis | 017 | 01 | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 1.11 | -- Register Allocation | 030 | 02 | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 1.12 | -- Putting It | 009 | 01 | -- | ---------- | ---------- | +| ====== | ========== | ======================================== | ===== | ======== | ====== | ---------- | ---------- | +| [ ] | 2 | - Advanced Topics | 245 | 14 | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 2.13 | -- Garbage Collection | 026 | 02 | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 2.14 | -- Object-Oriented Languages | 016 | 01 | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 2.15 | -- Functional Programming Languages | 035 | 02 | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 2.16 | -- Polymorphic Types | 033 | 02 | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 2.17 | -- Dataflow Analysis | 027 | 02 | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 2.18 | -- Loop Optimizations | 023 | 01 | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 2.19 | -- Static Single-Assignment Form | 041 | 02 | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 2.20 | -- Pipelining and Scheduling | 024 | 01 | -- | ---------- | ---------- | +| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- | +| [ ] | 2.21 | -- The Memory Hierarchy | 020 | 01 | -- | ---------- | ---------- |