/*  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 {
  var 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;

//############################################################################