Evaluator.java

import java.util.*;

public class Evaluator { private Stack operandStack; private Stack operatorStack;

private StringTokenizer tokenizer; private static final String DELIMITERS = "+-*^/#! ";

public Evaluator() { operandStack = new Stack<>(); operatorStack = new Stack<>(); }

public int eval( String expression ) { String token;

// The 3rd argument is true to indicate that the delimiters should be used // as tokens, too. But, we'll need to remember to filter out spaces. this.tokenizer = new StringTokenizer( expression, DELIMITERS, true );

// initialize operator stack - necessary with operator priority schema // the priority of any operator in the operator stack other than // the usual mathematical operators - "+-*/" - should be less than the priority // of the usual operators

// TODO Operator is abstract - this will need to be fixed: // operatorStack.push( new Operator( "#" ));

// When is it a good time to add the "!" operator?

while ( this.tokenizer.hasMoreTokens() ) { // filter out spaces if ( !( token = this.tokenizer.nextToken() ).equals( " " )) { // check if token is an operand if ( Operand.check( token )) { operandStack.push( new Operand( token )); } else { if ( ! Operator.check( token )) { System.out.println( "*****invalid token******" ); System.exit( 1 ); }

// TODO Operator is abstract - these two lines will need to be fixed: // The Operator class should contain an instance of a HashMap, // and values will be instances of the Operators. See Operator class // skeleton for an example. Operator newOperator = new Operator( token );

while ( operatorStack.peek().priority() >= newOperator.priority() ) { // note that when we eval the expression 1 - 2 we will // push the 1 then the 2 and then do the subtraction operation // This means that the first number to be popped is the // second operand, not the first operand - see the following code Operator oldOpr = operatorStack.pop(); Operand op2 = operandStack.pop(); Operand op1 = operandStack.pop(); operandStack.push( oldOpr.execute( op1, op2 )); }

operatorStack.push( newOperator ); } } }

// Control gets here when we've picked up all of the tokens; you must add // code to complete the evaluation - consider how the code given here // will evaluate the expression 1+2*3 // When we have no more tokens to scan, the operand stack will contain 1 2 // and the operator stack will have + * with 2 and * on the top; // In order to complete the evaluation we must empty the stacks (except // the init operator on the operator stack); that is, we should keep // evaluating the operator stack until it only contains the init operator; // Suggestion: create a method that takes an operator as argument and // then executes the while loop; also, move the stacks out of the main // method return 0; } }

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

EvaluatorTester.java

public class EvaluatorTester { public static void main(String[] args) { Evaluator evaluator = new Evaluator();

for ( String arg : args ) { System.out.format( "%s = %d ", arg, evaluator.eval( arg ) ); // System.out.println( arg + " = " + evaluator.eval( arg ) ); } } }

--------------------------------------------------------------------------------------------------------------------------------------------------------------

EvaluatorUI.java

import javax.swing.*; import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener;

public class EvaluatorUI extends JFrame implements ActionListener { private TextField txField = new TextField(); private Panel buttonPanel = new Panel();

// total of 20 buttons on the calculator, // numbered from left to right, top to bottom // bText[] array contains the text for corresponding buttons private static final String[] bText = { "7", "8", "9", "+", "4", "5", "6", "- ", "1", "2", "3", "*", "0", "^", "=", "/", "(", ")", "C", "CE" }; private Button[] buttons = new Button[ bText.length ];

public static void main(String argv[]) { EvaluatorUI calc = new EvaluatorUI(); }

public EvaluatorUI() { setLayout( new BorderLayout() );

add( txField, BorderLayout.NORTH ); txField.setEditable( false );

add( buttonPanel, BorderLayout.CENTER ); buttonPanel.setLayout( new GridLayout( 5, 4 ));

//create 20 buttons with corresponding text in bText[] array for ( int i = 0; i < 20; i++ ) { buttons[ i ] = new Button( bText[ i ]); }

//add buttons to button panel for (int i=0; i<20; i++) { buttonPanel.add( buttons[ i ]); }

//set up buttons to listen for mouse input for ( int i = 0; i < 20; i++ ) { buttons[ i ].addActionListener( this ); }

setTitle( "Calculator" ); setSize( 400, 400 ); setLocationByPlatform( true ); setDefaultCloseOperation( WindowConstants.EXIT_ON_CLOSE ); setVisible( true ); }

public void actionPerformed( ActionEvent arg0 ) { // You need to fill in this fuction } }

------------------------------------------------------------------------------------

Operand.java

public class Operand {

public Operand( String token ) {

}

public Operand( int value ) {

}

public int getValue() { return 0; }

public static boolean check( String token ) { return false; } }

-------------------------------------------------------------------------------

Operator.java

public abstract class Operator { // The Operator class should contain an instance of a HashMap // This map will use keys as the tokens we're interested in, // and values will be instances of the Operators.

// Example: // Where does this declaration go? What should its access level be? // Class or instance variable? Is this the right declaration? // HashMap operators = new HashMap(); // operators.put( "+", new AdditionOperator() ); // operators.put( "-", new SubtractionOperator() );

public abstract int priority(); public abstract Operand execute( Operand op1, Operand op2 );

public static boolean check( String token ) { return false; } }

----------------------------------------------------------------------------------------------