/* zweic -- a compiler for zwei * * Stephane Micheloud & LAMP * * $Id$ */ package zweic; import Operators.Operator; //############################################################################ // The root of the tree node hierarchy /** * Class Tree defines the type of all abstract syntax tree nodes. */ abstract class Tree { /** * The source code position of this tree node. * Has to be set explicitly with the setPos method */ private var p: Int = Position.UNDEFINED; def pos: Int = p; def setPos(p: Int): this.type = { this.p = p; this } } //############################################################################ // Tree node representing a complete program /* P = Program { D } E */ case class Program(classes: List[ClassDef], main: Expr) extends Tree; //############################################################################ // Tree nodes for definitions /* A common superclass for all definitions */ abstract class Def extends Tree; /* D = ClassDef name [ name ] { M } */ case class ClassDef(name: Name, extend: Option[Name], members: List [Member]) extends Def; /* A common superclass for member definitions */ abstract class Member extends Def; /* M = FieldDecl formal */ case class FieldDecl(formal: Formal) extends Member; /* D = MethodDecl name { F } T E */ case class MethodDef(name: Name, args: List[Formal], returntype: TypeTree, expression: Expr) extends Member { val self: Name = Name("this"); } /* F = Formal name T */ case class Formal(name: Name, typ: TypeTree) extends Tree; //############################################################################ // Tree nodes for types /* A common superclass for tree nodes designating types */ abstract class TypeTree extends Tree; /* T = Int */ case class IntType extends TypeTree; /* T = Null */ case class NullType extends TypeTree; /* T = ClassType name */ case class ClassType(name: Name) extends TypeTree; //############################################################################ // Tree nodes for statements /* A common superclass for all statements */ abstract class Stat extends Tree; /* S = While E { S } */ case class While(cond: Expr, stats: List[Stat]) extends Stat; /* S = Var name T E */ case class Var(varname: Name, vartype: TypeTree, init: Expr) extends Stat; /* S = Set name E */ case class Set(name: Name, expr: Expr) extends Stat; /* S = Do E */ case class Do(expr: Expr) extends Stat; /* S = PrintInt E */ case class PrintInt(expr: Expr) extends Stat; /* S = PrintChar E */ case class PrintChar(expr: Expr) extends Stat; //############################################################################ // Tree nodes for expressions /* A common superclass for expressions */ abstract class Expr extends Tree { var brackets:Boolean = false; }; /* E = Ident name */ case class Ident(name: Name) extends Expr; /* E = New name { E } */ case class New(name: Name, args: List[Expr]) extends Expr; /* E = Select E name */ case class Select(obj: Expr, varname: Name) extends Expr; /* E = Call E name { E } */ case class Call(obj: Expr, funcname: Name, args: List[Expr]) extends Expr; /* E = NullLit */ case class NullLit extends Expr; /* E = IntLit int */ case class IntLit(value: int) extends Expr; /* E = Unop O E */ case class Unop(op: Operator, expr: Expr) extends Expr; /* E = Binop O E E */ case class Binop(op: Operator, left: Expr, right: Expr) extends Expr; /* E = ReadInt */ case class ReadInt extends Expr; /* E = ReadChar */ case class ReadChar extends Expr; /* E = If E E E */ case class If(cond: Expr, stata: Expr, statb: Expr) extends Expr; /* E = Block { S } E */ case class Block(stats: List[Stat], expression: Expr) extends Expr; //############################################################################