// Name: Dominic Perry
// Date: November 10, 2006
// Purpose: File is the driver for a program that takes an equation in infix form
//          and converts it to postfix.  The driver uses the functions that are defined
//          in the postfix class.  The driver is based off of the Shunting Yard algorithm
//          The algorithm states:
//
//          While there are tokens to be read: 
//             *Read a token.
//                 *If the token is a number/letter, then add it to the output queue.
//                 *If the token is an operator, op1 then:
//                    1) while there is an operator, op2, at the top of the stack, and op2 has
//                       greater precedence then op1
//                          *pop op2 off the stack and push it onto the output queue; 
//                    2) If op2 has lesser precedence push op1 onto the operator stack. 
//                 *If the token is a left parenthesis, then push it onto the stack. 
//                 *If the token is a right parenthesis, then
//                    1) pop operators off the stack, onto the output queue, until the token 
//                       at the top of the stack is a left parenthesis
//                    2) Pop the left parenthese off the stack but do not add it to the output queue.
//          When there are no more tokens to read, pop all the operators, if any are left, off the stack
//          and add each to the output as it is popped off


#include <iostream>
#include <string>
#include "PostFix.h"

using namespace std;

int main()
{


     PostFix pClass;

     int tempI;
     string tempS;
              
     pClass.DisplayOpening();
     pClass.GetEquation();
               
     while(pClass.GetSize("input") != 0)
     {     
          tempS = pClass.LookValue("input");  //Look at the value on the queue

          //If it's not an operand or paranthese then move it to the final stack
          if(tempS != "+" && tempS != "-" && tempS != "*" && tempS != "/" && tempS != "$" && tempS != "(" && tempS != ")" )
          {

                pClass.MoveList("input", "final");

          }     
          else if (tempS != "(" && tempS != ")" ) //checks to see if the value is an operator or a parentheses
          {
               if(pClass.GetSize("operator") == 0) //if the op stack is empty then move it.
               {

                    pClass.MoveList("input", "operator");
                
               }
               else //if the op stack is not empty
               {
                              
                    // checks the precedence of what is on the op stack versus the new operator
                    // that will be put on top of that stack.
                    tempI = pClass.OpPrecedence(pClass.LookValue("operator"), tempS); 
                             
                    if(tempI == 2) //if the new operator has greater precedence put it on the op stack
                    {

                         pClass.MoveList("input", "operator");

                    }
                    else //if the new operator has lesser precedence move what is on the op stack to the 
                    {    //finished stack and then put the new operator on the op stack
                     
                         pClass.MoveList("operator","final");
                         

                         //Prime read for while loop
                         tempI = pClass.OpPrecedence(pClass.LookValue("operator"), tempS);

                         //Continue removing what is on the stack untill the new operator has lesser precedence
                         while(tempI == 1 && pClass.GetSize("operator") != 0 )
                         {
                              pClass.MoveList("operator", "final");
                              tempI = pClass.OpPrecedence(pClass.LookValue("operator"), tempS);
                         }     
                         pClass.MoveList("input", "operator");//puts the new value on the stack
                    }
               }     
          }
          else if(tempS == "(" ) //if the value is a ( then put it on the stack
          {

               pClass.MoveList("input", "operator");                             

          }
          else if(tempS == ")" )
          {
                         
               pClass.GetValue("input");  //If a ( is found, delete it and then search until a ) is found     
    
               //Prime read for the while loop
               tempS = pClass.LookValue("operator");
                     
               while (tempS != "(" )  //Continue until you read a (
               {
                    pClass.MoveList("operator", "final"); //Move what is inbetween the parentheses out of the stack
                    tempS = pClass.LookValue("operator"); //get the new value

               }
               pClass.GetValue("operator"); //removes the ( parentheses off the stack
          }     
                    
                                  
     } //End of While loop

     //Once the last letter is read, dump the op stack onto the final queue
     while(pClass.GetSize("operator") != 0)
     {
          pClass.MoveList("operator", "final");
     }

     cout<<endl<<"Your equation in Postfix form is: "<<endl;

     //Prints the final equation
     while(pClass.GetSize("final") != 0)
     {
          cout<<pClass.GetValue("final");
     }


return(0);

}

// checks the precedence of what is on the op stack versus the new operator
// that will be put on top of that stack.
tempI = pClass.OpPrecedence(pClass.LookValue("operator"), tempS); 

if( tempI == 2 ) //if the new operator has greater precedence put it on the op stack
{

        pClass.MoveList("input", "operator");

}

//Prime read for while loop
tempI = pClass.OpPrecedence(pClass.LookValue("operator"), tempS);

//Continue removing what is on the stack untill the new operator has lesser precedence
while( tempI == 1 && pClass.GetSize("operator") != 0 )
{
      pClass.MoveList("operator", "final");
      tempI = pClass.OpPrecedence(pClass.LookValue("operator"), tempS);
}     
pClass.MoveList("input", "operator");//puts the new value on the stack

do
{
    //Prime read for while loop
    tempI = pClass.OpPrecedence(pClass.LookValue("operator"), tempS);
    pClass.MoveList("operator", "final");

} while( tempI == 1 && pClass.GetSize("operator") != 0 );

    cout<<endl<<"Your equation in Postfix form is: "<<endl;

    //Prints the final equation
    while( pClass.GetSize("final") != 0 )
    {
        cout<<pClass.GetValue("final");
    }

// Name: Dominic
// Date: October 24, 2006
// Purpose: File holds the function declarations for the PostFix class
//          the holds functions to convert equations from infix to postfix
// Other Files Needed:
//    1)mstack.h
//    2)queue.h
//    2)PostFix.cpp
//


#ifndef POSTFIX_H
#define POSTFIX_H

#include <string>
#include "queue.h"
#include "mstack.h"


class PostFix
{

	public:

		// Input: none
		// Output: A greeting to the user
		// Return: none
		//
		// Function lets the user know what the program does
		void DisplayOpening();
		

		// Input: None
		// Output: a prompt for the equation
		// Return: None
		//
		// Function Prompts the user for an equation and then builds
		//    a linked list stack out of the equation. 
		void GetEquation();

		// Input: The list to move from and the list to move too
		// OutPut: None
		// Return: None
		//
		// Function moves the top of the list from the stack identified
		//    by fromList and puts it on the list  identified by toList
		void MoveList(string fromList, string toList);


		// Input: two operators
		// Output: None
		// Return: 1 if the first operator has precedence, 2 if the second
		//         operator has the precedence
		//
		// Function takes two operators in string form and determines the
		//    the precedence of the two.  It returns a 1 or a 2 depending on
		//    which operator has precedence.  A parentheses will always have lesser
                //    precedence for the purpose of this program.
		int OpPrecedence(string first, string second);


		// Input: None
		// Output: None
		// Return: The top value of the input list
		//
		// Function gets the top value of the input list and returns it.  The value is 
		//    removed from the stack.
		string GetValue(string listName);


		// Input: name of the list
		// Output: None
   		// Return: The size of the list
		// 
		// Function gets the size of the list specified and then returns it
		int GetSize(string listName);
		
		
		// Input: None
		// Output: None
		// Return: the top value of the inputlist stack
		//
		// Function looks at the value on top of the inputlist stack with out
		//    removing the value from that stack.
		string LookValue(string listName);

	private:

		// Declarations for the stack and queues
		queue inputList;
		Mstack operatorList;
		queue finalList;


};

#endif

int add( int a, int b )
{
    return a + b;
}

int add()
{
    int a, b;
    cout << "Enter an integer: ";
    cin >> a;
    cout << "Enter another integer: ";
    cin >> b;
    return a + b;
}

#include <iostream>
using namespace std;

int add( int a, int b )
{
    return a + b;
}

int add()
{
    int a, b;
    cout << "Enter an integer: ";
    cin >> a;
    cout << "Enter another integer: ";
    cin >> b;
    return a + b;
}

int main()
{
    int a = add();
    cout << "a = " << a << endl;
    return 0;
}

// Function lets the user know what the program does
void DisplayOpening();