Catch and handle the divide-by-zero situation that was assumed not to happen. For example, if the input expression is 9 7 7 - /, the result would be the exception message "illegal divide by zero".

Support a new operation indicated by "^" that returns the larger of its operands. for example, 3 9 ^ = 9

/** * Represents an integer evaluator of postfix expressions. Assumes * the operands are constants. * * * Revise and test the postfix expression evaluator program * 1. Catch and handle the divide-by-zero situation that was assumed not to happen. For example, if the input expression is 9 7 7 - /, * the result would be the exception message "illegal divide by zero". * 2. Support a new operation indicated by "^" that returns the larger of its operands. for example, 3 9 ^ = 9 **/

public class PostfixEvaluator { private final static char ADD = '+'; private final static char SUBTRACT = '-'; private final static char MULTIPLY = '*'; private final static char DIVIDE = '/'; private final static char LARGER = '^';

private Stack stack;

/** * Sets up this evalutor by creating a new stack. */ public PostfixEvaluator() { stack = new Stack(); }

/** * Evaluates the specified postfix expression. If an operand is * encountered, it is pushed onto the stack. If an operator is * encountered, two operands are popped, the operation is * evaluated, and the result is pushed onto the stack. * @param expr string representation of a postfix expression * @return value of the given expression */ public int evaluate(String expr) { int op1, op2, result = 0; String token; Scanner parser = new Scanner(expr);

while (parser.hasNext()) { token = parser.next();

if (isOperator(token)) { op2 = (stack.pop()).intValue(); op1 = (stack.pop()).intValue(); result = evaluateSingleOperator(token.charAt(0), op1, op2); stack.push(new Integer(result)); } else stack.push(new Integer(Integer.parseInt(token))); }

return result; }

/** * Determines if the specified token is an operator. * @param token the token to be evaluated * @return true if token is operator */ private boolean isOperator(String token) { boolean isOperator = token.equals("+") || token.equals("-") || token.equals("*") || token.equals("/");

// TODO Support a new operation indicated by "^" that returns the larger of its operands. for example, 3 9 ^ = 9 , insert a statement that resign the isOperator variable by considering the "^"

return isOperator; }

/** * Peforms integer evaluation on a single expression consisting of * the specified operator and operands. * @param operation operation to be performed * @param op1 the first operand * @param op2 the second operand * @return value of the expression */ private int evaluateSingleOperator(char operation, int op1, int op2) throws RuntimeException { int result = 0;

switch (operation) { case ADD: result = op1 + op2; break; case SUBTRACT: result = op1 - op2; break; case MULTIPLY: result = op1 * op2; break; case DIVIDE: // TODO Catch and handle the divide-by-zero situation once it happens. Insert a statement, where an instance of the IllegalDivisionException class will be thrown if a number is divided by zero

result = op1 / op2; break; case LARGER: // TODO Support a new operation indicated by "^" that returns the larger of its operands. for example, 3 9 ^ = 9. Insert a statement where the larger one of two number will be calculated }

return result; } }

public class IllegalDivistionException extends RuntimeException { /** * Sets up this exception with an appropriate message. * @param collection the name of the collection */ public IllegalDivistionException() { // TODO Catch and handle the divide-by-zero situation. For example, if the input expression is 9 7 7 - /, // the result would be the message "illegal divide by zero". // Insert a statement invoking the constructor of the super class and prompting the error message "illegal divide by zero"

} }