if (...) {

} else if (...) {

} else if (...) {

} else {

}

class Token {
    int type; // type of Token; can be Token.TYPE_BOOLEAN, Token.TYPE_DOUBLE, Token.TYPE_STRING, Token.TYPE_LIST

    Token(boolean          value); // creates a new boolean type token with given value
    Token(double           value); // creates a new double  type token with given value
    Token(String           value); // creates a new string  type token with given value
    Token(ArrayList<Token> value); // creates a new list    type token with given value

    boolean          getBoolean(); // gets token's value as a  boolean          (crashes if not type boolean) 
    double           getDouble();  // gets token's value as a  double           (crashes if not type double) 
    String           getString();  // gets token's value as a  String           (crashes if not type string)
    ArrayList<Token> getList();    // gets token's value as an ArrayList<Token> (crashes if not type list) 

    static ArrayList<Token> tokenize(String postScriptProgram); // turns PostScript program into a list of tokens
}

class Interpreter {
    void interpretListOfTokens(ArrayList<Token> tokens); // interprets a list of tokens
    void interpretToken(Token token); // interprets a single token

    Token            stackPopToken();   // pops a Token off of the stack
    boolean          stackPopBoolean(); // pops a Token off of the stack and gets its value as a  boolean           (crashes if not type boolean)
    double           stackPopDouble();  // pops a Token off of the stack and gets its value as a  double            (crashes if not type double)
    String           stackPopString();  // pops a Token off of the stack and gets its value as a  String            (crashes if not type string)
    ArrayList<Token> stackPopList();    // pops a Token off of the stack and gets its value as an ArrayList<Token>  (crashes if not type list)
    void stackPush(Token            token); // pushes a token onto the stack
    void stackPush(boolean          value); // creates a new boolean type token with given value and pushes it onto the stack
    void stackPush(double           value); // creates a new double  type token with given value and pushes it onto the stack
    void stackPush(String           value); // creates a new string  type token with given value and pushes it onto the stack
    void stackPush(ArrayList<Token> value); // creates a new list    type token with given value and pushes it onto the stack
    
    void    mapPut(String key, Token value); // puts a key-value pair into the map
    Token   mapGet(String key); // for the given key, looks up the corresponding value in the map (crashes if key not in map)
    boolean mapContainsKey(String key); // returns whether the map contains a key-value pair with the given key
}

// // Two ways of pushing a new double type token with value 1.0 to the stack:

// Option A
stackPush(1.0);

// Option B (totally equivalent, but harder to read)
stackPush(new Token(1.0));

double num = stackPopDouble();

Token any = stackPopToken();
if (any.type == Token.TYPE_BOOLEAN) {
    boolean bool = any.getBoolean();
    ...
} else if (any.type == Token.TYPE_DOUBLE) {
    double num = any.getDouble();
    ...
} else if (any.type == Token.TYPE_STRING) {
    String string = any.getString();
    ...
} else if (any.type == Token.TYPE_LIST) {
    ArrayList<Token> list = any.getList();
} ...

// TODO: Make sure you read the Starter Code Documentation first!
// TODO: Before changing/adding anything, Compile and Run this Starter Code.

import java.util.*;

class HW06 {
    static class Token {
        int type;
        private boolean          _valueIfTypeBoolean;
        private double           _valueIfTypeDouble;
        private String           _valueIfTypeString;
        private ArrayList<Token> _valueIfTypeList;

        static final int TYPE_BOOLEAN = 0;
        static final int TYPE_DOUBLE  = 1;
        static final int TYPE_STRING  = 2;
        static final int TYPE_LIST    = 3;
        static final String[] _typeNames = { "boolean", "double", "String", "list" };
        static String stringFromType(int type) { return _typeNames[type]; }

        Token(boolean          value) { type = TYPE_BOOLEAN; _valueIfTypeBoolean = value; } 
        Token(double           value) { type = TYPE_DOUBLE;  _valueIfTypeDouble  = value; }
        Token(String           value) { type = TYPE_STRING;  _valueIfTypeString  = value; }
        Token(ArrayList<Token> value) { type = TYPE_LIST;    _valueIfTypeList    = value; }

        public String toString() {
            if (type == TYPE_BOOLEAN) { return "" + _valueIfTypeBoolean; }
            if (type == TYPE_DOUBLE ) { return "" + _valueIfTypeDouble;  }
            if (type == TYPE_STRING ) { return "" + _valueIfTypeString;  }
            if (type == TYPE_LIST   ) { return "" + _valueIfTypeList;  }
            assert false : "Token type not recognized; Token type = " + type;
            return "";
        }

        boolean          getBoolean() { assert type == TYPE_BOOLEAN : "Token type is " + stringFromType(type); return _valueIfTypeBoolean; }
        double           getDouble()  { assert type == TYPE_DOUBLE  : "Token type is " + stringFromType(type); return _valueIfTypeDouble;  }
        String           getString()  { assert type == TYPE_STRING  : "Token type is " + stringFromType(type); return _valueIfTypeString;  }
        ArrayList<Token> getList()    { assert type == TYPE_LIST    : "Token type is " + stringFromType(type); return _valueIfTypeList;    }

        static ArrayList<Token> tokenize(String postScriptProgram) {
            ArrayList<Token> result = new ArrayList<>();
            ArrayList<Token> list = null;
            ArrayList<Token> target = result;
            Scanner scanner = new Scanner(postScriptProgram);
            scanner.useLocale(Locale.US);
            while (scanner.hasNext()) {
                if (scanner.hasNextDouble()) {
                    target.add(new Token(scanner.nextDouble()));
                } else if (scanner.hasNextBoolean()) {
                    target.add(new Token(scanner.nextBoolean()));
                } else {
                    String string = scanner.next().trim();
                    if (string.equals("{")) {
                        list = new ArrayList<Token>();
                        target = list;
                    } else if (string.equals("}")) {
                        target = result;
                        target.add(new Token(list));
                    } else if (string.length() != 0) {
                        target.add(new Token(string));
                    }
                }
            }
            return result;
        }
    }

    static class Interpreter {
        Stack<Token> _stack;
        HashMap<String, Token> _map;
        
        Interpreter() {
            _stack = new Stack<>();
            _map = new HashMap<>();
        }

        Token            stackPopToken()   { assert _stack.size() > 0 : "can't pop; stack is empty"; return _stack.pop(); }
        boolean          stackPopBoolean() { Token token = stackPopToken(); return token.getBoolean(); }
        double           stackPopDouble()  { Token token = stackPopToken(); return token.getDouble();  }
        String           stackPopString()  { Token token = stackPopToken(); return token.getString();  }
        ArrayList<Token> stackPopList()    { Token token = stackPopToken(); return token.getList();  }

        void stackPush(Token            token) { _stack.push(token);            }
        void stackPush(boolean          value) { _stack.push(new Token(value)); }
        void stackPush(double           value) { _stack.push(new Token(value)); }
        void stackPush(String           value) { _stack.push(new Token(value)); }
        void stackPush(ArrayList<Token> value) { _stack.push(new Token(value)); }
        void stackPrint() {
            ArrayList<Token> tmp = new ArrayList<>();
            for (Token token : _stack) { tmp.add(token); }
            for (int i = tmp.size() - 1; i >= 0; --i) { System.out.println(tmp.get(i)); }
        }
        
        boolean mapContainsKey(String key) { return _map.containsKey(key); }
        void mapPut(String key, Token value) { _map.put(key, value); }
        Token mapGet(String key) { assert mapContainsKey(key); return _map.get(key); }
        void mapPrint() { System.out.println(_map); }

        void interpretListOfTokens(ArrayList<Token> listOfTokens) {
            boolean PRINT_TOKEN = true;
            boolean PRINT_STACK_AND_MAP = true; // NOTE: only prints map if nonempty
            boolean PRINT_BEGIN_AND_END_INTERPRETING = true;
            if (PRINT_BEGIN_AND_END_INTERPRETING) { System.out.println("\n- BEGIN INTERPRETING " + listOfTokens + " -\n\n"); }
            for (int tokenIndex = 0; tokenIndex < listOfTokens.size(); ++tokenIndex) {
                if (PRINT_TOKEN) { System.out.println("> " + listOfTokens.get(tokenIndex) + "\n"); }
                interpretToken(listOfTokens.get(tokenIndex));
                if (PRINT_STACK_AND_MAP) { stackPrint(); System.out.println("----- \nstack"); if (_map.size() > 0) { System.out.print(" + map "); mapPrint(); } System.out.println("\n"); }
            }
            if (PRINT_BEGIN_AND_END_INTERPRETING) { System.out.println("-- END INTERPRETING " + listOfTokens + " --\n\n"); }
        }

        void interpretToken(Token token) {
            // TODO: Implement this function (if-else if is your friend!)
            // NOTE: Resist the urge to write "helper functions." First make sure you actually need them!
            // NOTE: You can get an A with ~50 lines of code.
            //       (But feel free to use more. Just not like...way more.)
            // NOTE: Do NOT make a new instance of the Interpreter class.

        }
    }

    public static void main(String[] arguments) {
        // Definitely write your own teeny tiny PostScript programs to help you develop!
        // A good program to start with is just "5.0"
        // Implement one feature at a time!

        String program = "5.0 2.0 sub 3.0 eq";
        // String program = "/pi 3.14 def /tau pi pi add def";
        // String program = "/pythag { dup mul exch dup mul add sqrt } def 3.0 4.0 pythag";

        ArrayList<Token> listOfTokens = Token.tokenize(program);
        
        Interpreter interpreter = new Interpreter();
        interpreter.interpretListOfTokens(listOfTokens);
    }
}