// General Notes:
// - List<A> refers to your own implementation of lists
//           with subclasses NIL<A> and CONS<A> (see also SL-parse.tgz)
//           You are free to use LinkedList<A> instead.
//   http://java.sun.com/j2se/1.5.0/docs/api/java/util/LinkedList.html
// - Auxiliary data-types for Maybe<A>, Tuple<A> etc
//             are provided; depending on your grammar you 
//             may or may not need them
// - For implementing the visitor pattern, you can directly
//   use the accept methods as defined in the classes
// - There should be no need to modify this file at all. If you do,
//   you're probably implementing a visitor pattern or such the
//   wrong way.

abstract class Program {
    public abstract <A> A accept (ProgramVisitor<A> v);
}

class Prg extends Program {
    public Decl main;
    public List<Decl> ds;
    public Prg (Decl main, List<Decl> ds) {
        this.main = main;
        this.ds = ds;
    }
    public <A> A accept (ProgramVisitor<A> v) {
        return v.visit (this);
    }
}

interface ProgramVisitor<A> {
    public A visit (Prg p);
}

abstract class Maybe<a> {
    public abstract <A> A accept (MaybeVisitor<A,a> v);
}

class Nothing<a> extends Maybe<a> {
    public Nothing () {
    }
    public <A> A accept (MaybeVisitor<A,a> v) {
        return v.visit (this);
    }
}

class Just<a> extends Maybe<a> {
    public a just;
    public Just (a just) {
        this.just = just;
    }
    public <A> A accept (MaybeVisitor<A,a> v) {
        return v.visit (this);
    }
}

interface MaybeVisitor<A,a> {
    public A visit (Nothing<a> m);
    public A visit (Just<a> m);
}

abstract class Tuple2<a,b> {
    public abstract <A> A accept (Tuple2Visitor<A,a,b> v);
}

class T2<a,b> extends Tuple2<a,b> {
    public a fst2;
    public b snd2;
    public T2 (a fst2, b snd2) {
        this.fst2 = fst2;
        this.snd2 = snd2;
    }
    public <A> A accept (Tuple2Visitor<A,a,b> v) {
        return v.visit (this);
    }
}

interface Tuple2Visitor<A,a,b> {
    public A visit (T2<a,b> t);
}

abstract class Either2 {
    public abstract <A> A accept (Either2Visitor<A> v);
}

class Left2 extends Either2 {
    public Tuple2<Maybe<Expression>,Expression> left2;
    public Left2 (Tuple2<Maybe<Expression>,Expression> left2) {
        this.left2 = left2;
    }
    public <A> A accept (Either2Visitor<A> v) {
        return v.visit (this);
    }
}

class Right2 extends Either2 {
    public String right2;
    public Right2 (String right2) {
        this.right2 = right2;
    }
    public <A> A accept (Either2Visitor<A> v) {
        return v.visit (this);
    }
}

interface Either2Visitor<A> {
    public A visit (Left2 e);
    public A visit (Right2 e);
}

abstract class Meth3 {
    public abstract <A> A accept (Meth3Visitor<A> v);
}

class M3 extends Meth3 {
    public List<Decl> fst3;
    public List<Statement> snd3;
    public Expression thd3;
    public M3 (List<Decl> fst3, 
               List<Statement> snd3, 
               Expression thd3) {
        this.fst3 = fst3;
        this.snd3 = snd3;
        this.thd3 = thd3;
    }
    public <A> A accept (Meth3Visitor<A> v) {
        return v.visit (this);
    }
}

interface Meth3Visitor<A> {
    public A visit (M3 m);
}

abstract class Decl {
    public abstract <A> A accept (DeclVisitor<A> v);
}

class MethDecl extends Decl {
    public Type ty;
    public String id;
    public List<Params> ps;
    public List<Decl> ds;
    public List<Statement> ss;
    public Expression e;
    public MethDecl (Type ty, 
                     String id, 
                     List<Params> ps, 
                     List<Decl> ds, 
                     List<Statement> ss, 
                     Expression e) {
        this.ty = ty;
        this.id = id;
        this.ps = ps;
        this.ds = ds;
        this.ss = ss;
        this.e = e;
    }
    public <A> A accept (DeclVisitor<A> v) {
        return v.visit (this);
    }
}

class VarDecl extends Decl {
    public Type ty;
    public String id;
    public VarDecl (Type ty, String id) {
        this.ty = ty;
        this.id = id;
    }
    public <A> A accept (DeclVisitor<A> v) {
        return v.visit (this);
    }
}

class ClassDecl extends Decl {
    public String id;
    public Maybe<String> id0;
    public List<Decl> vs;
    public List<Decl> ms;
    public ClassDecl (String id, 
                      Maybe<String> id0, 
                      List<Decl> vs, 
                      List<Decl> ms) {
        this.id = id;
        this.id0 = id0;
        this.vs = vs;
        this.ms = ms;
    }
    public <A> A accept (DeclVisitor<A> v) {
        return v.visit (this);
    }
}

class MainDecl extends Decl {
    public String id;
    public String id0;
    public Statement s;
    public MainDecl (String id, String id0, Statement s) {
        this.id = id;
        this.id0 = id0;
        this.s = s;
    }
    public <A> A accept (DeclVisitor<A> v) {
        return v.visit (this);
    }
}

interface DeclVisitor<A> {
    public A visit (MethDecl d);
    public A visit (VarDecl d);
    public A visit (ClassDecl d);
    public A visit (MainDecl d);
}

abstract class Type {
    public abstract <A> A accept (TypeVisitor<A> v);
}

class BoolTy extends Type {
    public BoolTy () {
    }
    public <A> A accept (TypeVisitor<A> v) {
        return v.visit (this);
    }
}

class IntTy extends Type {
    public IntTy () {
    }
    public <A> A accept (TypeVisitor<A> v) {
        return v.visit (this);
    }
}

class ObjTy extends Type {
    public String c;
    public ObjTy (String c) {
        this.c = c;
    }
    public <A> A accept (TypeVisitor<A> v) {
        return v.visit (this);
    }
}

class ArrTy extends Type {
    public Type ty;
    public ArrTy (Type ty) {
        this.ty = ty;
    }
    public <A> A accept (TypeVisitor<A> v) {
        return v.visit (this);
    }
}

interface TypeVisitor<A> {
    public A visit (BoolTy t);
    public A visit (IntTy t);
    public A visit (ObjTy t);
    public A visit (ArrTy t);
}

abstract class Params {
    public abstract <A> A accept (ParamsVisitor<A> v);
}

class Par extends Params {
    public String id;
    public Type ty;
    public Par (String id, Type ty) {
        this.id = id;
        this.ty = ty;
    }
    public <A> A accept (ParamsVisitor<A> v) {
        return v.visit (this);
    }
}

interface ParamsVisitor<A> {
    public A visit (Par p);
}

abstract class Statement {
    public abstract <A> A accept (StatementVisitor<A> v);
}

class SList extends Statement {
    public List<Statement> ss;
    public SList (List<Statement> ss) {
        this.ss = ss;
    }
    public <A> A accept (StatementVisitor<A> v) {
        return v.visit (this);
    }
}

class IfStm extends Statement {
    public Expression e;
    public Statement sT;
    public Statement sE;
    public IfStm (Expression e, Statement sT, Statement sE) {
        this.e = e;
        this.sT = sT;
        this.sE = sE;
    }
    public <A> A accept (StatementVisitor<A> v) {
        return v.visit (this);
    }
}

class WhileStm extends Statement {
    public Expression e;
    public Statement s;
    public WhileStm (Expression e, Statement s) {
        this.e = e;
        this.s = s;
    }
    public <A> A accept (StatementVisitor<A> v) {
        return v.visit (this);
    }
}

class PrintStm extends Statement {
    public Expression e;
    public PrintStm (Expression e) {
        this.e = e;
    }
    public <A> A accept (StatementVisitor<A> v) {
        return v.visit (this);
    }
}

class AssignStm extends Statement {
    public String id;
    public Expression e;
    public AssignStm (String id, Expression e) {
        this.id = id;
        this.e = e;
    }
    public <A> A accept (StatementVisitor<A> v) {
        return v.visit (this);
    }
}

class ArrAssignStm extends Statement {
    public String id;
    public Expression e1;
    public Expression e2;
    public ArrAssignStm (String id, Expression e1, Expression e2) {
        this.id = id;
        this.e1 = e1;
        this.e2 = e2;
    }
    public <A> A accept (StatementVisitor<A> v) {
        return v.visit (this);
    }
}

interface StatementVisitor<A> {
    public A visit (SList s);
    public A visit (IfStm s);
    public A visit (WhileStm s);
    public A visit (PrintStm s);
    public A visit (AssignStm s);
    public A visit (ArrAssignStm s);
}

abstract class Expression {
    public abstract <A> A accept (ExpressionVisitor<A> v);
}

class CTrue extends Expression {
    public CTrue () {
    }
    public <A> A accept (ExpressionVisitor<A> v) {
        return v.visit (this);
    }
}

class CFalse extends Expression {
    public CFalse () {
    }
    public <A> A accept (ExpressionVisitor<A> v) {
        return v.visit (this);
    }
}

class This extends Expression {
    public This () {
    }
    public <A> A accept (ExpressionVisitor<A> v) {
        return v.visit (this);
    }
}

class NewInt extends Expression {
    public Expression e;
    public NewInt (Expression e) {
        this.e = e;
    }
    public <A> A accept (ExpressionVisitor<A> v) {
        return v.visit (this);
    }
}

class New extends Expression {
    public String id;
    public New (String id) {
        this.id = id;
    }
    public <A> A accept (ExpressionVisitor<A> v) {
        return v.visit (this);
    }
}

class Bonzo extends Expression {
    public Expression e;
    public Bonzo (Expression e) {
        this.e = e;
    }
    public <A> A accept (ExpressionVisitor<A> v) {
        return v.visit (this);
    }
}

class Infx extends Expression {
    public final static int PLUS=1, MINUS=2, TIMES=3, DIV=4, AND=5, LT=6; 
    public Expression e1;
    public int op;
    public Expression e2;
    public Infx (Expression e1, int op, Expression e2) {
        this.e1 = e1;
        this.op = op;
        this.e2 = e2;
    }
    public <A> A accept (ExpressionVisitor<A> v) {
        return v.visit (this);
    }
}

class Get extends Expression {
    public Expression e1;
    public Expression e2;
    public Get (Expression e1, Expression e2) {
        this.e1 = e1;
        this.e2 = e2;
    }
    public <A> A accept (ExpressionVisitor<A> v) {
        return v.visit (this);
    }
}

class Len extends Expression {
    public Expression e;
    public Len (Expression e) {
        this.e = e;
    }
    public <A> A accept (ExpressionVisitor<A> v) {
        return v.visit (this);
    }
}

class Invoke extends Expression {
    public Expression e;
    public String id;
    public List<Expression> es;
    public Invoke (Expression e, String id, List<Expression> es) {
        this.e = e;
        this.id = id;
        this.es = es;
    }
    public <A> A accept (ExpressionVisitor<A> v) {
        return v.visit (this);
    }
}

class IConst extends Expression {
    public int n;
    public IConst (int n) {
        this.n = n;
    }
    public <A> A accept (ExpressionVisitor<A> v) {
        return v.visit (this);
    }
}

class Id extends Expression {
    public String id;
    public Id (String id) {
        this.id = id;
    }
    public <A> A accept (ExpressionVisitor<A> v) {
        return v.visit (this);
    }
}

interface ExpressionVisitor<A> {
    public A visit (CTrue e);
    public A visit (CFalse e);
    public A visit (This e);
    public A visit (NewInt e);
    public A visit (New e);
    public A visit (Bonzo e);
    public A visit (Infx e);
    public A visit (Get e);
    public A visit (Len e);
    public A visit (Invoke e);
    public A visit (IConst e);
    public A visit (Id e);
}