////////////////////////////////////////////////////////////////////////////////

// Author: Julie Petrusa (991339)                                             //

// Program 3, Due date: March 6, 2001                                         //

// The class StackMachine gets a postfix expression from the user (containing //

//                        single letter operands and the operators +, -, *,   //

//                        and /) and prints a sequence of instructions to     //

//                        evaluate the expression                             //  

// Fields: input                                                              //

// Methods: -instructs, which inputs a postfix expression and outputs a       //

//                      sequence of instructions to evaluate the expression   //

// Known bugs: none                                                           //

////////////////////////////////////////////////////////////////////////////////

import java.io.*;  // needed in order to do io



class StackMachine

   {

   //---------------------------------------------------------------------------

   // fields

         String input;  // holds input string

   //---------------------------------------------------------------------------   

   // constructor

         public StackMachine(String in)

            {

            input = in;  // get the input string

            }

   //---------------------------------------------------------------------------

   /* 

      method instructs

      -inputs a postfix expression and outputs a sequence of instructions to 

       evaluate the expression   

      -precondition: -the postfix expression is valid

      -postcondition: -if postfix expression valid, a sequence of instructions 

                       to evaluate the expression is displayed

                      -if postfix expression not valid, throws an exception 

      -return: -void

   */

         public void instructs()

            {

            int stackSize = input.length();  // get maximum stack size

            TheStringStack newStack = new TheStringStack(stackSize);  // stack

            

            System.out.println("");

            int i = 1;  // counter for TEMPn

            

            for(int j=0; j<input.length(); j++)  // get chars in turn

               {

               char op = input.charAt(j);  // get char

               switch(op)

                  {

                  case '+':  // operators

                  case '-':                       

                  case '*':                       

                  case '/':                      

                     String op1 = newStack.pop();  // pop 2nd operand

                     String op2 = newStack.pop();  // pop 1st operand

                         

                     System.out.println("LD " + op2);  // 1st instruction

                        

                     if(op == '+')  // print instruction for '+'

                        System.out.println("AD " + op1);  // 2nd instruction

                          

                     if(op == '-')  // print instruction for '-' 

                        System.out.println("SB " + op1);  // 2nd instruction



                     if(op == '*')  // print instruction for '*'

                        System.out.println("ML " + op1);  // 2nd instruction



                     if(op == '/')  // print instruction for '/'

                        System.out.println("DV " + op1);  // 2nd instruction

                        

                     String TEMPn = ("TEMP" + i);  // make temporary variable 

                     newStack.push(TEMPn);  // push temporary variable

                        

                     System.out.println("ST " + TEMPn);  // 3rd instruction

                        

                     i++;  // increment counter for TEMPn

                     break;                                     

                  

                  default:  

                     newStack.push("" + op);  // push operand as string

                     break;

                           

                  }  // end switch

               }  // end for

            }       

   //---------------------------------------------------------------------------

   }  // end class StackMachine                       



                                                                                   

////////////////////////////////////////////////////////////////////////////////

// Author: Julie Petrusa (991339)                                             //

// Program 3, Due date: March 6, 2001                                         //

// The class Bonus accepts as input the stack machine and then outputs and    //

//                 executes it producing a result                             //

// Fields: input                                                              //

// Methods: -result, which inputs the stack machine and then outputs and      //                                                  

//                   executes it producing a result                           //

//          -getString, which reads in a string                               //

//          -getInt, which reads in an integer                                //                                                  

// Known bugs: none                                                           //

////////////////////////////////////////////////////////////////////////////////

class Bonus

   {

   //---------------------------------------------------------------------------

   // fields

         private StackMachine inputSM;  // holds input StackMachine

   //---------------------------------------------------------------------------

   // constructor

         public Bonus(StackMachine inSM)

            {

            inputSM = inSM;  // get the input StackMachine

            }

   //---------------------------------------------------------------------------

   /*

      method result

      -inputs the stack machine and then outputs and executes it producing a

       result

      -precondition: -the stack machine is valid

      -postcondition: -if stack machine valid, it is outputted and executed and

                       the result is displayed

                      -if stack machine not valid, throws an exception

      -return: -void

   */

         public void result() throws IOException

            {

            int stackSize = inputSM.input.length();  // get maximum stack size

            TheIntStack newStack = new TheIntStack(stackSize);  // stack

            

            System.out.println("");                                   

            

            for(int j=0; j<inputSM.input.length(); j++)  // get chars in turn

               {

               char op = inputSM.input.charAt(j);  // get char

               switch(op)

                  {

                  case '+':  // operators

                  case '-':                       

                  case '*':                       

                  case '/':                      

                     int op1 = newStack.pop();  // pop 2nd operand

                     int op2 = newStack.pop();  // pop 1st operand

                        

                     if(op == '+')  // instruction for '+'

                        op2 = op2 + op1;  // add operands

                          

                     if(op == '-')  // instruction for '-' 

                        op2 = op2 - op1;  // subtract operands



                     if(op == '*')  // instruction for '*'

                        op2 = op2 * op1;  // multiply operands



                     if(op == '/')  // instruction for '/'

                        op2 = op2 / op1;  // divide operands

                        

                     newStack.push(op2);  // push result

                     break;                                     

                  

                  default:  // prompt the user for a numerical value

                     System.out.print("Enter a numerical value for ");

                     System.out.print(op + ": ");

                     System.out.flush();

                     

                     int number = getInt();  // get the user's value

                     newStack.push(number);  // push value

                     break;

                           

                  }  // end switch

               }  // end for

               

            int finalResult = newStack.pop();  // get the final result

            System.out.println("");  // display final result

            System.out.println("Final Result: " + finalResult);   

            }       

   //---------------------------------------------------------------------------

   /*

      method getString

      -reads in a string

      -precondition: -the user has typed in a valid string

      -postcondition: -if valid string, string is read in

                      -if not valid string, throws IOException

      -return: -static

   */

         public static String getString() throws IOException

            {

            InputStreamReader isr = new InputStreamReader(System.in);

            BufferedReader br = new BufferedReader(isr);

            String s = br.readLine();

            return s;

            }                   

   //---------------------------------------------------------------------------

   /*

      method getInt

      -reads in an integer

      -precondition: -the user has typed in a valid integer

      -postcondition: -if valid integer, integer is read in

                      -if not valid integer, throws IOException

      -return: -static

   */

         public static int getInt() throws IOException  

            {

            String s = getString();

            return Integer.parseInt(s);

            }

   //--------------------------------------------------------------------------- 

   }  // end class Bonus         





////////////////////////////////////////////////////////////////////////////////

// Author: Julie Petrusa (991339)                                             //

// Program 3, Due date: March 6, 2001                                         //

// The class TheStringStack implements the string stack                       //

// Fields: maxSize, stringStack, and top                                      //

// Methods: -push, which puts an item on the top of the stack                 //

//          -pop, which takes an item from the top of the stack               //

//          -peek, which peeks at the top of the stack                        //

//          -isEmpty, which returns true if stack is empty, false otherwise   // 

//          -isFull, which returns true if stack is full, false otherwise     //

// Known bugs: none                                                           //

////////////////////////////////////////////////////////////////////////////////

class TheStringStack

   {

   //---------------------------------------------------------------------------

   // fields

         private int maxSize;           // maximum size of stack array

         private String[] stringStack;  // stack array

         private int top;               // top of stack

   //---------------------------------------------------------------------------           

   // constructor

         public TheStringStack(int s)

            {

            maxSize = s;                        // set maximum size of array

            stringStack = new String[maxSize];  // create array

            top = -1;                           // no items yet

            }

   //---------------------------------------------------------------------------

   /* 

      method push

      -puts an item on the top of the stack

      -precondition: -stack is not full

      -postcondition: -if stack not full, item is pushed on top of stack

                      -if stack full, throws IllegalStateException

      -return: -void

   */   

         public void push(String j) throws IllegalStateException

            {

            if(isFull())                // if stack full, throw exception

               throw new IllegalStateException("Stack is full!");

            else                        // not full,   

               stringStack[++top] = j;  // increment top, insert item

            }

   //---------------------------------------------------------------------------

   /*      

      method pop

      -takes an item from the top of the stack

      -precondition: -stack is not empty

      -postcondition: -if stack not empty, item is popped off top of stack

                      -if stack empty, throws IllegalStateException

      -return: -the popped item

   */      

         public String pop() throws IllegalStateException

            {

            if(isEmpty())                  // if stack empty, throw exception

               throw new IllegalStateException("Stack is empty!");

            else                           // not empty,    

               return stringStack[top--];  // access item, decrement top

            }                          

   //---------------------------------------------------------------------------

   /*       

      method peek

      -peeks at the top of the stack

      -precondition: -none

      -postcondition: -the item at the top of the stack is returned

      -return: -the item at the top of the stack

   */       

         public String peek()

            {

            return stringStack[top];  // return the item at the top of the stack

            }    

   //---------------------------------------------------------------------------

   /*

      method isEmpty

      -returns true if stack is empty, false otherwise

      -precondition: -none

      -postcondition: -if stack empty, true is returned

                      -if stack not empty, false is returned

      -return: -true if stack is empty, false otherwise

   */

         public boolean isEmpty()

            {

            return (top == -1);  // return true if stack empty, false otherwise

            }              

   //---------------------------------------------------------------------------

   /*

      method isFull

      -returns true if stack is full, false otherwise

      -precondition: -none

      -postcondition: -if stack full, true is returned

                      -if stack not full, false is returned

      -return: -true if stack is full, false otherwise

   */

         public boolean isFull()

            {

            return (top == maxSize-1);  // return true if stack full, 

            }                           // false otherwise                  

   //---------------------------------------------------------------------------

   }  // end class TheStringStack 





////////////////////////////////////////////////////////////////////////////////

// Author: Julie Petrusa (991339)                                             //

// Program 3, Due date: March 6, 2001                                         //

// The class TheIntStack implements the int stack                             //

// Fields: maxSize, intStack, and top                                         //

// Methods: -push, which puts an item on the top of the stack                 //

//          -pop, which takes an item from the top of the stack               //

//          -peek, which peeks at the top of the stack                        //

//          -isEmpty, which returns true if stack is empty, false otherwise   // 

//          -isFull, which returns true if stack is full, false otherwise     //

// Known bugs: none                                                           //

////////////////////////////////////////////////////////////////////////////////

class TheIntStack

   {

   //---------------------------------------------------------------------------

   // fields

         private int maxSize;     // maximum size of stack array

         private int[] intStack;  // stack array

         private int top;         // top of stack

   //---------------------------------------------------------------------------           

   // constructor

         public TheIntStack(int s)

            {

            maxSize = s;                  // set maximum size of array

            intStack = new int[maxSize];  // create array

            top = -1;                     // no items yet

            }

   //---------------------------------------------------------------------------

   /* 

      method push

      -puts an item on the top of the stack

      -precondition: -stack is not full

      -postcondition: -if stack not full, item is pushed on top of stack

                      -if stack full, throws IllegalStateException

      -return: -void

   */   

         public void push(int j) throws IllegalStateException

            {

            if(isFull())             // if stack full, throw exception

               throw new IllegalStateException("Stack is full!");

            else                     // not full,   

               intStack[++top] = j;  // increment top, insert item

            }

   //---------------------------------------------------------------------------

   /*      

      method pop

      -takes an item from the top of the stack

      -precondition: -stack is not empty

      -postcondition: -if stack not empty, item is popped off top of stack

                      -if stack empty, throws IllegalStateException

      -return: -the popped item

   */      

         public int pop() throws IllegalStateException

            {

            if(isEmpty())               // if stack empty, throw exception

               throw new IllegalStateException("Stack is empty!");

            else                        // not empty,    

               return intStack[top--];  // access item, decrement top

            }                          

   //---------------------------------------------------------------------------

   /*       

      method peek

      -peeks at the top of the stack

      -precondition: -none

      -postcondition: -the item at the top of the stack is returned

      -return: -the item at the top of the stack

   */       

         public int peek()

            {

            return intStack[top];  // return the item at the top of the stack

            }    

   //---------------------------------------------------------------------------

   /*

      method isEmpty

      -returns true if stack is empty, false otherwise

      -precondition: -none

      -postcondition: -if stack empty, true is returned

                      -if stack not empty, false is returned

      -return: -true if stack is empty, false otherwise

   */

         public boolean isEmpty()

            {

            return (top == -1);  // return true if stack empty, false otherwise

            }              

   //---------------------------------------------------------------------------

   /*

      method isFull

      -returns true if stack is full, false otherwise

      -precondition: -none

      -postcondition: -if stack full, true is returned

                      -if stack not full, false is returned

      -return: -true if stack is full, false otherwise

   */

         public boolean isFull()

            {

            return (top == maxSize-1);  // return true if stack full, 

            }                           // false otherwise                  

   //---------------------------------------------------------------------------

   }  // end class TheIntStack

   

    

////////////////////////////////////////////////////////////////////////////////

// Author: Julie Petrusa (991339)                                             //

// Program 3, Due date: March 6, 2001                                         //

// The class PostfixExpressions tests the classes TheStack, StackMachine,     //

//                              and Bonus                                     //

// Fields: none                                                               //

// Methods: -main, which inputs a postfix expression from the user and        // 

//                 outputs the result                                         //

//          -getString, which reads in a string                               //

//          -getInt, which reads in an integer                                //

// Known bugs: none                                                           //

////////////////////////////////////////////////////////////////////////////////

class PostfixExpressions

   {

   //---------------------------------------------------------------------------

   /*

      main method

      -inputs a postfix expression from the user and outputs the result

      -precondition: -the classes TheStack, StackMachine, and Bonus work

      -postcondition: -if they work, the result is displayed

                      -if they do not work, exceptions are caught 

      -return: -void

   */   

         public static void main(String[] args) throws IOException

            {

            try

               {

               System.out.println("");  // display banner

               System.out.println("Author: Julie Petrusa (991339)"); 

               System.out.println("Program 3, Due date: March 6, 2001");

               System.out.print("This program inputs a postfix expression");

               System.out.println(" and outputs the result");

               

               boolean value = true;

               do 

                  {

                  System.out.println("");  // display options for the user

                  System.out.println("Choose one of the following options:");  

                  System.out.println("   1  -->  Enter a postfix expression");

                  System.out.println("   2  -->  Exit the program");

                  System.out.print("Answer: ");  // prompt user for answer

                  System.out.flush();

                  

                  int answer = getInt();  // read in the user's answer

                  switch (answer)  // do what the user wants

                     {

                     case 1:

                        System.out.println("");  // prompt user for expression

                        System.out.print("Enter a postfix expression: ");

                        System.out.flush();

                        

                        String in = getString();  // read in the expression                       

                        StackMachine newSM = new StackMachine(in);  // create SM

                        newSM.instructs();  // display instructions

                        

                        Bonus newBonus = new Bonus(newSM);  // create Bonus 

                        newBonus.result();  // calculate and display result     

                        break;

                           

                     case 2:

                        value = false;  // to end do-while loop

                        break;

                      

                     default:  // invalid answer, display error message

                        System.out.println("");

                        System.out.println("Invalid answer!");

                        break;

                        

                     }  // end switch

                  } while (value != false);

                  

               System.in.read();  // to view console

               }  // end try

                   

            catch (IOException e)

               {

               System.out.println("IOException");

               }  // end catch

                 

            }  // end main

   //---------------------------------------------------------------------------

   /*

      method getString

      -reads in a string

      -precondition: -the user has typed in a valid string

      -postcondition: -if valid string, string is read in

                      -if not valid string, throws IOException

      -return: -static

   */

         public static String getString() throws IOException

            {

            InputStreamReader isr = new InputStreamReader(System.in);

            BufferedReader br = new BufferedReader(isr);

            String s = br.readLine();

            return s;

            }                   

   //---------------------------------------------------------------------------

   /*

      method getInt

      -reads in an integer

      -precondition: -the user has typed in a valid integer

      -postcondition: -if valid integer, integer is read in

                      -if not valid integer, throws IOException

      -return: -static

   */

         public static int getInt() throws IOException  

            {

            String s = getString();

            return Integer.parseInt(s);

            }

   //---------------------------------------------------------------------------   

   }  // end class PostfixExpressions