/*
 * Main.java
 *
 * Created on 05 October 2007, 14:45
 *
 */

package interpret;
import java.util.LinkedList;

/**
 *
 * @author Tormod
 */
public class Main {
    interface Semantics {
        int interpret();
    }
    
    // Definition of a static ActivationRecord
    class ActivationRecord {
        private int i,j,k;
        ActivationRecord(){i=j=k=0;}
        public int getI(){ return i; }
        public int getJ(){ return j; }
        public int getK(){ return k; }
        public void setI( int n){ i=n; }
        public void setJ( int n){ j=n; }
        public void setK( int n){ k=n; }
        public String toString() { 
            return "{ i="+getI()+", j="+getJ()+", k="+getK()+" }"; 
        }
    }
    
    // the actual ActivationRecord ( stack )
    protected ActivationRecord state;

    abstract class Stmt implements Semantics { }
    abstract class Exp  implements Semantics { }
    abstract class Var  implements Semantics {
        abstract public int get();
        abstract public void set(int n);
        public int interpret(){ return get(); }
    }
    
    // implementation of Var
    class I extends Var{ 
        public void set( int n ){ state.setI( n ); }
        public int get(){ return state.getI(); } 
    }
    class J extends Var{ 
        public void set( int n ){ state.setJ( n ); }
        public int get(){ return state.getJ(); } 
    }
    class K extends Var{ 
        public void set( int n ){ state.setK( n ); }
        public int get(){ return state.getK(); } 
    }

    // implementation of Exp
    class Number extends Exp{
        private int n;
        public Number(int inN){ n = inN;}
        public int interpret(){ return n;}
    }    
    class Plus extends Exp {
        protected Exp e1;
        protected Exp e2;
        public Plus(Exp inE1,Exp inE2) { e1= inE1; e2 = inE2; }
        public int interpret(){ return e1.interpret() + e2.interpret(); }
    }    
    class ExpVar extends Exp{
        private Var v;
        public ExpVar(Var inV) { v = inV; }
        public int interpret() { return v.interpret(); }
    }

    // implementation of Stms
    class Assign extends Stmt {
        private Var v;
        private Exp e;
        public Assign(Var inV,Exp inE) { v = inV; e = inE; }
        public int interpret() { v.set(e.interpret() ); return v.get(); }
    }
    class BoolExp extends Exp {
        protected Exp e1;
        protected Exp e2;
        public BoolExp(Exp inE1,Exp inE2) { e1= inE1; e2 = inE2; }
        public int interpret(){ if (e1.interpret() == e2.interpret()) { return 1; } else {return 0; } }
    }
    class IfThen extends Stmt {
        private BoolExp b;
        private Stmt s;
        public IfThen( BoolExp inB,Stmt inS ) { b=inB; s= inS; }
        public int interpret(){ if ( b.interpret() == 1 ) { return s.interpret(); } else { return 0; } }
    }
    class Print extends Stmt {
        private Var v;
        public Print( Var inV ) { v = inV;}
        public int interpret(){ System.out.println( v.get() ); return 0; }
    }
    
    // implementation of Prog    
    class Prog implements Semantics {
        private LinkedList<Stmt> stmtList;
        private boolean printDebuggingInfo;
        public Prog() { stmtList = new LinkedList<Stmt>(); printDebuggingInfo = false; }
        public void setDebugging( boolean inVerbose ) { printDebuggingInfo = inVerbose; }
        public void add(Stmt s) {  stmtList.add(s); }
        public int interpret() {
            for( Stmt s : stmtList ) {
                s.interpret();
                
                // just for debugging
                if ( printDebuggingInfo ) { System.out.println("State:"+ state); }
            }
            return 0;
        }
     }
    
    public Main() {  
        // making the sample program
        Prog sampleProgram = new Prog(); // making an empty program
        sampleProgram.add(new Assign( new I(), new Number( 1 ) ) );
        sampleProgram.add(new Assign( new J(), new Number( 2 ) ) );
        sampleProgram.add(new Assign( new K(), new Plus( new ExpVar( new I() ), new ExpVar(new J() ))));        
        sampleProgram.add(new IfThen( new BoolExp(new ExpVar( new K() ), new Number(3)), new Print(new K() ) ) );

        // if you want to monitor the state after each statement
        //sampleProgram.setDebugging(true);        
        
        // runnning the program
        state = new ActivationRecord(); // making the ctivation record       
        System.out.println("Starting state:" + state );       
        sampleProgram.interpret();
        System.out.println("Ending state:" + state );
    }
    
    public static void main(String[] args) {
        new Main();
    }
}