Compilers Project. Cyril Soldani. Mar 6th University of Liège

Transcription

1 Compilers Project Cyril Soldani University of Liège Mar 6th

2 Outline 1 General remarks 2 Syntax analysis 3 AST structure advice 2

3 Best group size is 2 Groups of 3 are allowed, but expected to do more. Groups of 1 are allowed, but not recommended: Completing a decent basic VSOP compiler alone is possible but might take more time than planed for the course! Students alone for the first assignment can still join a group. They will keep their grade for the first assignment. Contact me for group changes. 3

4 Outline 1 General remarks 2 Syntax analysis 3 AST structure advice 4

5 Syntax analysis [token] Parser AST Converts stream of tokens into an abstract syntax tree. Due before Tue the 20th of March. Automated tests worth 5% of your grade. Can use a parser generator (e.g. bison, CUP, PLY, ANTLR). Think in advance: top-down or bottom-up? You can now submit your own tests for (ungraded) validation: Just put.vsop files into a tests subfolder. You must now support two modes: -parse, but also -lex. 5

6 Output format Described in the wording. Example: [Class(List, Object, [], [Method(isNil, [], bool, true), Method(length, [], int32, 0)]), Class(Nil, List, [], []), Class(Cons, List, [Field(head, int32), Field(tail, List)], [Method(init, [hd : int32, tl : List], Cons, [Assign(head, hd), Assign(tail, tl), self]), Method(head, [], int32, head), Method(isNil, [], bool, false), Method(length, [], int32, BinOp(+, 1, Call(tail, length, [])))]), Class(Main, IO, [], [Method(main, [], int32, Let(xs, List, Call(New(Cons), init, [0, Call(New(Cons), init, [1, Call(New(Cons), init, [2, New(Nil)])])]), [Call(self, print, ["List has length "]), Call(self, printint32, [Call(xs, length, [])]), Call(self, print, ["\x0a"]), 0]))])] 6

7 A word about error management You are free to report syntax errors as you like, but... Error messages should go to stderr, and look like input_file.vsop:4:12: syntax error: description One (or more) error(s) should cause your compiler to fail, with non-zero exit code. Automated tests don t check the description, but we do! Lexical errors can still happen! Syntax error reporting is a challenging topic, see the lectures for hints. 7

8 Questions and (possibly) answers? 8

9 Outline 1 General remarks 2 Syntax analysis 3 AST structure advice 9

10 Generic Trees for AST class ASTNode { private List<ASTNode> children; private String value;... public double eval() { if (children.length() == 3) { if (children.get(1).value == "+") { return children.get(0).eval() + children.get(2).eval(); else if... else if... Hard to read. Error-prone. Generally a bad idea. 10

11 Object-Oriented (Simple) Approach abstract class Expr { public abstract double eval(); class Add extends Expr { Expr lhs; Expr rhs;... public double eval() { return lhs.eval() + rhs.eval(); Advantages: Good encapsulation. Adding an AST node means adding a single file. Drawbacks: Adding a pass means modifying all AST classes (many). Hard to read (many places to look at). Hard to factor code out. Hard to manage state. 11

12 Functional Approach type expr = Add of expr * expr... let rec eval expr = match expr with Add (lhs, rhs) -> eval lhs + eval rhs... Advantages: Adding a pass requires modifying a single file. More readable. Easier code reuse. Drawbacks: No information hiding. Adding an AST node means modifying all passes (few). Same in C with unions and switch. 12

13 Simulating Functional in OO: tagged union abstract class Expr { enum Type { ADD, SUB,... ; Type type; class Add extends Expr { Expr lhs; Expr rhs;... Add(Expr lhs, Expr rhs) { type = ADD; this.lhs = lhs; this.rhs = rhs; class Evaluator { static double eval(expr e) { switch (e.type) { case ADD: return eval(((add) e).lhs) + eval(((add) e).rhs);... Simple and efficient, but neither type-safe nor the most readable. 13

14 Simulating Functional in OO: the Visitor Pattern interface Visitor<R> { public R visitadd(add add); public R visitsub(sub sub);... abstract class Expr { public abstract <R> R accept(visitor<r> v); class Add extends Expr {... public <R> R accept(visitor<r> v) { return v.visitadd(this); class EvalVisitor implements Visitor<Double> { public Double visitadd(add add) { return add.lhs.accept(this) + add.rhs.accept(this);... Type-safe. Double dispatch. 14

15 Questions and (possibly) answers? 15