/*  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 ...

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