/* 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 woth 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 { def name: Name; } /** * D = ClassDef name [ name ] { M } */ abstract case class ClassDef( ) extends Def {}; //TODO /** * A common superclass for member definitions */ abstract class Member extends Def; /** * M = FieldDecl name T */ abstract case class FieldDecl( ) extends Member; //TODO /** * D = MethodDecl name { name T } T E */ abstract case class MethodDef( ) extends Member { val self: Name = Name("this"); } //TODO //############################################################################ // 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; // ... à compléter ... /** * E = Unop O E */ case class Unop(op: Operator, expr: Expr) extends Expr; // ... à compléter ... //############################################################################