X-Git-Url: https://git.xandkar.net/?a=blobdiff_plain;f=README.md;h=36ef94a6912549739027a3b8f395f73b72ecee1e;hb=c16dd441582b7c7c09cdb3e706f4767a5b266177;hp=632225a4993760aab5a0c0515b84058539f83858;hpb=96ad2fee9c1cde8e8ab49c2589b381ad5a4a750e;p=tiger.ml.git

diff --git a/README.md b/README.md
index 632225a..36ef94a 100644
--- a/README.md
+++ b/README.md
@@ -1,29 +1,96 @@
 Tiger.ml
 ========
 
+Implementation Notes
+--------------------
+
+### Parser
+
+#### shift/reduce conflicts
+##### grouping consecutive declarations
+##### lval
+
+### AST
+
+#### print as M-exp
+
 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-84    | --     | 2018-04-16 | xxxx-xx-xx |
+| ====== | ========== | ======================================== | ===== | ======== | ====== | ========== | ========== |
+| [x]    | 1          | - Fundamentals of Compilation            | 264   | 14       | --     | 2018-04-16 | ---------- |
+| [x]    | 1.01       | -- Introduction                          | 011   | 01       | 04     | 2018-04-16 | ---------- |
+| [x]    | 1.01.1     | --- Modules and interfaces               | 001   | --       | --     | 2018-04-16 | ---------- |
+| [x]    | 1.01.2     | --- Tools and Software                   | 002   | --       | --     | 2018-04-16 | ---------- |
+| [x]    | 1.01.3     | --- Data structures for tree languages   | 003   | --       | --     | 2018-04-16 | ---------- |
+| [x]    | 1.01.p     | --- Program                              | 002   | --       | --     | 2018-04-16 | 2018-04-17 |
+| [x]    | 1.01.p.1   | ---- interpreter: maxargs                | ---   | --       | --     | 2018-04-17 | 2018-04-17 |
+| [x]    | 1.01.p.2   | ---- interpreter: interp                 | ---   | --       | --     | 2018-04-17 | 2018-04-17 |
+| [x]    | 1.01.e     | --- Exercises                            | 002   | --       | --     | ---------- | ---------- |
+| [x]    | 1.01.e.1.a | ---- tree member                         | ---   | --       | --     | 2018-04-17 | 2018-04-17 |
+| [x]    | 1.01.e.1.b | ---- tree key/val                        | ---   | --       | --     | 2018-04-18 | 2018-04-18 |
+| [x]    | 1.01.e.1.c | ---- demo unbalanced behaviour           | ---   | --       | --     | 2018-04-18 | 2018-04-18 |
+| [x]    | 1.01.e.1.d | ---- find functional balanced tree       | ---   | --       | --     | 2018-04-19 | 2018-04-20 |
+| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- |
+| [x]    | 1.02       | -- Lexical Analysis                      | 024   | 01       | 01     | 2018-05-22 | 2018-05-22 |
+| [x]    | 1.02.1     | --- Lexical tokens                       | 001   | --       | --     | ---------- | ---------- |
+| [x]    | 1.02.2     | --- Regular expressions                  | 003   | --       | --     | ---------- | ---------- |
+| [x]    | 1.02.3     | --- Finite automata                      | 003   | --       | --     | ---------- | ---------- |
+| [x]    | 1.02.4     | --- Nondeterministic finite automata     | 006   | --       | --     | ---------- | ---------- |
+| [x]    | 1.02.5     | --- ML-Lex: a lexical analyzer generator | 003   | --       | --     | ---------- | ---------- |
+| [x]    | 1.02.p     | --- Program                              | 002   | --       | --     | ---------- | ---------- |
+| [x]    | 1.02.p.1   | ---- Tiger lexer                         | ---   | 01       | 01     | 2018-05-22 | 2018-05-22 |
+| [x]    | 1.02.e     | --- Exercises                            | 004   | --       | --     | ---------- | ---------- |
+| [x]    | 1.02.e.01  | ---- regexes                             | ---   | --       | --     | ---------- | ---------- |
+| [x]    | 1.02.e.02  | ---- why no regexes                      | ---   | --       | --     | ---------- | ---------- |
+| [x]    | 1.02.e.03  | ---- explain automata                    | ---   | --       | --     | ---------- | ---------- |
+| [x]    | 1.02.e.04  | ---- regex to nondeterministic automata  | ---   | --       | --     | ---------- | ---------- |
+| [x]    | 1.02.e.05  | ---- NFA to DFA                          | ---   | --       | --     | ---------- | ---------- |
+| [x]    | 1.02.e.06  | ---- merge equivalent automata states    | ---   | --       | --     | ---------- | ---------- |
+| [x]    | 1.02.e.07  | ---- DFA to regex                        | ---   | --       | --     | ---------- | ---------- |
+| [x]    | 1.02.e.08  | ---- analyze lexer based on given DFA    | ---   | --       | --     | ---------- | ---------- |
+| [x]    | 1.02.e.09  | ---- generate lexer tables from spec     | ---   | --       | --     | ---------- | ---------- |
+| [x]    | 1.02.e.10  | ---- design better lookahead than Aho    | ---   | --       | --     | ---------- | ---------- |
+| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- |
+| [x]    | 1.03       | -- Parsing                               | 049   | 02       | 05     | 2018-05-25 | 2018-05-31 |
+| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- |
+| [x]    | 1.04       | -- Abstract Syntax                       | 016   | 01       | 01     | 2018-05-30 | 2018-05-30 |
+| ------ | ---------- | ---------------------------------------- | ----- | -------- | ------ | ---------- | ---------- |
+| [ ]    | 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       | --     | ---------- | ---------- |