/*
-- Time-stamp: <Tue Jan 10 2006 17:33:45 hwloidl>
-- $Id: MJIntmAbsSyn0.java,v 1.4 2006/01/10 16:37:58 hwloidl Exp $
--
-- A Compiler for MiniJava: 
--  Abstract Syntax for Intermediate language
-- Practical on compiler design, LMU 2005/6
-- Based on Appels book on "Modern Compiler Implementation"
-- ---------------------------------------------------------------------------

*/

abstract class Exp {
  public abstract <A> A accept (IntmVisitor<A> v);
  public abstract java.util.LinkedList<Exp> kids();
  public abstract Exp build(java.util.LinkedList<Exp> kids);
}

class CONST extends Exp {
    public Integer value;
    public CONST (Integer value) {
        this.value = value;
    }
    public java.util.LinkedList<Exp> kids() {
	java.util.LinkedList<Exp> kids = new java.util.LinkedList<Exp>();
	return kids;
    }
    public Exp build(java.util.LinkedList<Exp> kids) {
	return this;
    }

    public <A> A accept (IntmVisitor<A> v) {
        return v.visit (this);
    }
}

class NAME extends Exp {
    public Label label;
    public NAME (Label label) {
        this.label = label;
    }
    public NAME (String str) {

        this.label = new Label(str);
    }
    public java.util.LinkedList<Exp> kids() {
	java.util.LinkedList<Exp> kids = new java.util.LinkedList<Exp>();
	return kids;
    }
    public Exp build(java.util.LinkedList<Exp> kids) {
	return this;
    }
    public <A> A accept (IntmVisitor<A> v) {
        return v.visit (this);
    }
}

class TEMP extends Exp {
    public Temp temp;
    public TEMP (Temp temp) {
        this.temp = temp;
    }
    public java.util.LinkedList<Exp> kids() {
	java.util.LinkedList<Exp> kids = new java.util.LinkedList<Exp>();
	return kids;
    }
    public Exp build(java.util.LinkedList<Exp> kids) {
	return this;
    }
    public <A> A accept (IntmVisitor<A> v) {
        return v.visit (this);
    }
}

class BINOP extends Exp {
    public final static int PLUS=1, MINUS=2, MUL=3, DIV=4, 
      AND=5,OR=6,LSHIFT=7,RSHIFT=8,ARSHIFT=9,XOR=10;
    public int op;
    public Exp left;
    public Exp right;
    public BINOP (int op, Exp left, Exp right) {
        this.op = op;
        this.left = left;
        this.right = right;
    }
    public java.util.LinkedList<Exp> kids() {
	java.util.LinkedList<Exp> kids = new java.util.LinkedList<Exp>();
	kids.addFirst(left);
	kids.addLast(right);
	return kids;
    }
    public Exp build(java.util.LinkedList<Exp> kids) {
	return new BINOP(op, kids.getFirst(), kids.getLast());
    }
    public <A> A accept (IntmVisitor<A> v) {
        return v.visit (this);
    }
}

class MEM extends Exp {
    public Exp addr;
    public MEM (Exp addr) {
        this.addr = addr;
    }
    public java.util.LinkedList<Exp> kids() {
	java.util.LinkedList<Exp> kids = new java.util.LinkedList<Exp>();
	kids.addFirst(this.addr);
	return kids;
    }
    public Exp build(java.util.LinkedList<Exp> kids) {
      return new MEM(kids.getFirst());
    }
    public <A> A accept (IntmVisitor<A> v) {
        return v.visit (this);
    }
}

class CALL extends Exp {
    public Exp func;
    public List<Exp> args;
    public CALL (Exp func, List<Exp> args) {
        this.func = func;
        this.args = args;
    }
    public java.util.LinkedList<Exp> kids() {
	java.util.LinkedList<Exp> kids = new java.util.LinkedList<Exp>();
	kids.addAll(0,Utils.list2JList(args)); // NB: list2JList not needed for java.util.List!
	kids.addFirst(func);
	return kids;
    }
    public Exp build(java.util.LinkedList<Exp> kids) {
      return new CALL(kids.removeFirst(), Utils.jlist2List(kids)); // yuck!
    }
    public <A> A accept (IntmVisitor<A> v) {
        return v.visit (this);
    }
}

class ESEQ extends Exp {
    public Stm stm;
    public Exp exp;
    public ESEQ (Stm stm, Exp exp) {
        this.stm = stm;
        this.exp = exp;
    }
    public java.util.LinkedList<Exp> kids() {
	throw new Error("kids() not applicable to ESEQ");
    }
    public Exp build(java.util.LinkedList<Exp> kids) {
	throw new Error("build() not applicable to ESEQ");
    }
    public <A> A accept (IntmVisitor<A> v) {
        return v.visit (this);
    }
}

abstract class Stm {
  public abstract <A> A accept (IntmVisitor<A> v);
  public abstract java.util.LinkedList<Exp> kids();
  public abstract Stm build(java.util.LinkedList<Exp> kids);
}

class MOVE extends Stm {
    public Exp dest;
    public Exp src;
    public MOVE (Exp dest, Exp src) {
        this.dest = dest;
        this.src = src;
    }
    public java.util.LinkedList<Exp> kids() {
	java.util.LinkedList<Exp> kids = new java.util.LinkedList<Exp>();
        if (dest instanceof MEM) {
	  kids.addFirst(((MEM)dest).addr);
	  kids.addLast(src);
	} else { 
	  kids.addFirst(src);
	}
	return kids;
    }
    public Stm build(java.util.LinkedList<Exp> kids) {
      if (dest instanceof MEM) {
	return new MOVE(new MEM(kids.getFirst()), kids.getLast());
      } else {
	return new MOVE(dest, kids.getFirst());
      }
    }
    public <A> A accept (IntmVisitor<A> v) {
        return v.visit (this);
    }
}

class EXP extends Stm {
    public Exp exp;
    public EXP (Exp exp) {
        this.exp = exp;
    }
    public java.util.LinkedList<Exp> kids() {
	java.util.LinkedList<Exp> kids = new java.util.LinkedList<Exp>();
	kids.addFirst(exp);
	return kids;
    }
    public Stm build(java.util.LinkedList<Exp> kids) {
        return new EXP(kids.getFirst());
    }
    public <A> A accept (IntmVisitor<A> v) {
        return v.visit (this);
    }
}

class JUMP extends Stm {
    public Exp dest;
    public List<Label> poss;
    public JUMP (Exp dest, List<Label> poss) {
        this.dest = dest;
        this.poss = poss;
    }
    public JUMP(Label target) {
       this.dest = ((Exp)new NAME(target));
       this.poss = ((List<Label>)new CONS<Label>(target, new NIL<Label>()));
    }
    public java.util.LinkedList<Exp> kids() {
	java.util.LinkedList<Exp> kids = new java.util.LinkedList<Exp>();
	kids.addFirst(dest);
	return kids;
    }
    public Stm build(java.util.LinkedList<Exp> kids) {
        return new JUMP(kids.getFirst(), poss);
    }
    public <A> A accept (IntmVisitor<A> v) {
        return v.visit (this);
    }
}

class CJUMP extends Stm {
    public final static int EQ=11, NE=12, LT=13, GT=14, LE=15, GE=16, ULT=17, ULE=18,
	UGT=19, UGE=20;
    public int rel;
    public Exp left;
    public Exp right;
    public Label trueLab;
    public Label falseLab;
    public CJUMP (int rel, 
                  Exp left, 
                  Exp right, 
                  Label trueLab, 
                  Label falseLab) {
        this.rel = rel;
        this.left = left;
        this.right = right;
        this.trueLab = trueLab;
        this.falseLab = falseLab;
    }
    public java.util.LinkedList<Exp> kids() {
	java.util.LinkedList<Exp> kids = new java.util.LinkedList<Exp>();
	kids.addFirst(left);
	kids.addLast(right);
	return kids;
    }
    public Stm build(java.util.LinkedList<Exp> kids) {
        return new CJUMP(this.rel,kids.getFirst(),kids.getLast(),this.trueLab,this.falseLab);
    }
    public static int notRel(int relop) {
	switch (relop) {
        case EQ:  return NE;
        case NE:  return EQ;
	case LT:  return GE;
	case GE:  return LT;
	case GT:  return LE;
	case LE:  return GT;
	case ULT: return UGE;
	case UGE: return ULT;
	case UGT: return ULE;
	case ULE: return UGT;
	default: throw new Error("bad relop in CJUMP.notRel");
	}
    }
    public <A> A accept (IntmVisitor<A> v) {
        return v.visit (this);
    }
}

class SEQ extends Stm {
    public Stm first;
    public Stm second;
    public SEQ (Stm first, Stm second) {
        this.first = first;
        this.second = second;
    }
    public java.util.LinkedList<Exp> kids() {
	java.util.LinkedList<Exp> kids = new java.util.LinkedList<Exp>();
	return kids;
    }
    public Stm build(java.util.LinkedList<Exp> kids) {
      return this;
    }
    public <A> A accept (IntmVisitor<A> v) {
        return v.visit (this);
    }
}

class LABEL extends Stm {
    public Label label;
    public LABEL (Label label) {
        this.label = label;
    }
    public java.util.LinkedList<Exp> kids() {
	java.util.LinkedList<Exp> kids = new java.util.LinkedList<Exp>();
	return kids;
    }
    public Stm build(java.util.LinkedList<Exp> kids) {
	return this;
    }
    public <A> A accept (IntmVisitor<A> v) {
        return v.visit (this);
    }
}