Java lab infix to postfix and evaluate. need help with error checking for the program. need to check for invalid expressions: parenthesis 4 cases, adjacent operands, adjacent operators, missing parenthesis and extra parenthesis. my error correction thus far does not work but other than that the program will run for correct input. when incorrect output is read i recieve a stack underflow message

here's my code and input

8 + 4 * 2 - 6 7 * 2 - 4 * 3 + 2 * 5 2 * 3 * 4 - 8 + 9 / 3 / 3 5 + 7 * 4 - 6 4 * ( 3 + 2 * 4 ) - 7 ( 5 + 7 ) / ( 9 - 5 ) 3 * ( 5 * ( 5 - 2 ) ) - 9 ( ( 5 * ( 4 + 2 ) - ( 8 + 8 ) / 2 ) - 9 ) ^ 3 ( ( 5 + 5 * ( 6 - 2 ) + 4 ^ 2 ) * 8 ) ( ( ( 3 ^ 4 ) ) )

1 + * 2 1 2 * 3 ^ 4 ( 1 + 2 ( 1 + 2 ) * 3 )

import java.io.*; import java.util.Scanner;

/** * Driver - reads data from a file and parses through until EOF calling other classes to convert an * infix expression to a Postfix expression and evaluating the expression that is returned. * creates an ouput file that recieves both data from input file and output from conversion * and evaluation * * @author Josh Mumford * @version 09/14/2017 */ public class Driver { public static void main(String[] args) throws IOException { Scanner filescan = new Scanner(new File("infix.txt")); PrintWriter pw = new PrintWriter(new FileWriter("csis.txt")); EvalPostfix eval = new EvalPostfix(pw); InfixToPostfix infix = new InfixToPostfix(pw); try{ while (filescan.hasNextLine()) { String line = filescan.nextLine(); String postfix = infix.infixToPostfix(line); int value = eval.evalPostfix(postfix); System.out.println(line + " Postfix:" + postfix); //+ " Value:" + value); pw.println(line + " Postfix:" + postfix + " Value:" + value); } filescan.close(); pw.close(); } catch(ParenthesisMismatchException ex){ System.out.println(ex.getMessage()); } catch(InvalidExpressionException num){ System.out.println(num.getMessage()); } catch(MissingParenthesisException miss) { System.out.println(miss.getMessage()); } } }

import java.io.*; import java.util.Scanner;

/** * InfixToPostfix - takes a infix expression represented as a string & converts the * expression to postfix notation * * @author Josh Mumford * @version 09/21/17 */ public class InfixToPostfix { // instance variables private ObjectStack operator; private PrintWriter pw; /** * InfixToPostfix - initializes all instance variables * * @param pw passes PrintWriter object from driver class * */ public InfixToPostfix(PrintWriter pw) { // initialise instance variables this.pw = pw; operator = new ObjectStack(); }

/** * priority() - takes an operator represented as a char, returning a priority number * for each case * * @param op a character that represents operators * @return int returns an integer */ private int priority(char op) { switch(op) { case '^': return 3; case '*': case '/': return 2; case '+': case '-': return 1; default : return 0; } } /** * convertToPostfix() - contains all methods neccessary to convert a infix expression to postfix * * @param infix reference to the argument line in driver * @return String the method returns a string value */ public String infixToPostfix(String infix) throws ParenthesisMismatchException, InvalidExpressionException, MissingParenthesisException { StringBuilder post = new StringBuilder(); for(int i = 0; i < infix.length(); i++) { char ch = infix.charAt(i); if (ch >= '0' && ch <= '9'){ if(i < (infix.length() - 1) && (infix.charAt(i + 1) >= '0' && infix.charAt(i + 1) <= '9')) {throw new InvalidExpressionException("invalid infix expression: adjacent operands");} post.append(ch); } else if (ch == '('){ operator.push(ch); } else if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '^') { if (operator.isEmpty() || priority(ch) > priority((Character)operator.top())) operator.push(ch); else { while(!operator.isEmpty() && priority(ch) <= priority((Character)operator.top())) { post.append((Character)operator.pop()); } operator.push(ch); } } else if (ch == ')') { while ((Character)operator.top() != '(') { post.append((Character)operator.pop()); if (operator.isEmpty()) { throw new ParenthesisMismatchException("invalid expression: extra parenthesis"); } } operator.pop(); } } while (!operator.isEmpty()) { //try if top of stack is ( then its a invalid expression if((Character)operator.top() == '(') { throw new MissingParenthesisException("invalid expression: missing parentthesis"); } post.append((Character)operator.pop()); } return post.toString(); } }

import java.io.*;

/** * EvalPostFix - takes an arithmetic expression (string) and converts the expression from infix * notation to postfix notation, returning the expression * * @author Josh Mumford * @version 09/17/17 */ public class EvalPostfix { private PrintWriter pw; private ObjectStack operand; private int value;

/** * EvalPostfix - initializes all instance variables * * @param pw passes the pw object from driver class */ public EvalPostfix(PrintWriter pw) { this.pw = pw; operand = new ObjectStack(); }

/** * evalPostExp() - evaluates a (string) postfix expression, returns it as an integer and * prints that number to the output file * * @param exp passes a reference to the actual parameter * @return int returns a integer value */ public int evalPostfix(String exp) { for(int i = 0; i < exp.length(); i++) { char ch = exp.charAt(i); if (ch >= '0' && ch <= '9') operand.push(ch - 48); else if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '^') { int val2 = (Integer)operand.pop(); int val1 = (Integer)operand.pop(); if (ch == '+') operand.push(val1 + val2); else if (ch == '-') operand.push(val1 - val2); else if (ch == '*') operand.push(val1 * val2); else if (ch == '/') operand.push(val1 / val2); else if (ch == '^') operand.push((int) Math.pow(val1, val2)); } } return (Integer)operand.pop(); } }

/** * ObjectStack - creates a stack object that has methods to change it size, check if * the stack is empty or full, clear the stack, push or remove a value from the * stack and return the value at the top of the stack */ public class ObjectStack { private Object[] item; private int top; public ObjectStack() { item = new Object[1]; top = -1; }

public boolean isEmpty() { return top == -1; }

public boolean isFull() { return top == item.length-1; } public void clear() { item = new Object[1]; top = -1; } public void push(Object o) { if (isFull()) resize(2 * item.length); item[++top] = o; } private void resize(int size) { Object[] temp = new Object[size]; for (int i = 0; i <= top; i++) temp[i] = item[i]; item = temp; } public Object pop() { if (isEmpty()) { System.out.println("Stack Underflow."); System.exit(1); } Object temp = item[top]; item[top--] = null; if (top == item.length/4) resize(item.length/2); return temp; } public Object top() { if (isEmpty()) { System.out.println("Stack Underflow."); System.exit(1); } return item[top]; } }

/** * Write a description of class InvalidExpressionException here. * * @author (your name) * @version (a version number or a date) */ public class InvalidExpressionException extends Exception { public InvalidExpressionException(String message2) { super(message2); } }

/** * Write a description of class InvalidExpression here. * * @author (your name) * @version (a version number or a date) */ public class ParenthesisMismatchException extends Exception { public ParenthesisMismatchException(String message) { super(message); } }

/** * Write a description of class MissingParenthesisException here. * * @author (your name) * @version (a version number or a date) */ public class MissingParenthesisException extends Exception { /** * Constructor for objects of class MissingParenthesisException */ public MissingParenthesisException(String message) { super(message); }

}