cs235_assign03.cpp

/***********************************************************************
 * Program:
 *    Assignment 03, Postfix to Assembly Code Generator
 *    Brother Ercanbrack, CS235
 * Author:
 *    Tyler Scott
 * Summary:
 *      This program is designed to utilize the provided stack class
 *      (stack.h). The task was to incorporate and write the member
 *      functions associated with it. Then using these methods convert
 *      infix expressons to postfix output. Then interpret the instructions
 *      and display them in machine code.
 *
 *    Estimated:  5.0 hrs
 *    Actual:     8.0 hrs
 *
 ************************************************************************/
#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <string>
#include <fstream>
using namespace std;

class Stack
{
private:
   int myTop;                  // index of top of stack
   int maxSize;                // maximum size of stack
   int *stackItems;            // pointer for dynamic array
public:
   Stack(int size = 100);      // default constructor (stack size 100)
   Stack(const Stack &aStack); // copy constructor
   int top(void);              // returns the value of top item in the stack
   void push(int item);        // store item on the stack
   void pop(void);             // remove/delete top item off stack
   bool empty(void);           // is stack empty
   bool full(void);            // is stack full
   ~Stack();                   // destructor
   Stack& operator = (const Stack &rtSide); // overloaded assignment operator
};

//Methods for member functions listed below
/********************************************
 *Default Constructor
 ********************************************/
Stack::Stack(int size) // default constructor (stack size 100)
{
   if (size > 0);
   {
      myTop = 0;
      maxSize = size;
      stackItems = new int[maxSize];
      // as long as the passed in size is greater than 0, set up the array
      // with the capacity that size.
      if (stackItems != 0)
         myTop =  -1;// when the array is at 0, the top is a position
      // previous, aka -1.
      else
      {
         cerr<< "[Error: Not enough memory to allocate.]\n";
      }
   }
}

/********************************************
 *Copy Constructor
 ********************************************/
Stack::Stack(const Stack &aStack)// copy constructor
{
   myTop = aStack.myTop;//duplicates all the assigned variables to the
   //new constructor for myTop, maxSize, and the
   //array of stuff.
   maxSize = aStack.maxSize;
   stackItems = new int[aStack.maxSize];
   if (stackItems != 0)
   {
      for (int i = 0; i <= aStack.myTop; i++)
      {
         stackItems[i] = aStack.stackItems[i];
         //duplicate the array values individually.
      }
   }
}

/********************************************
 * the top makes sure that the stack isnt empty
 * and returns the first value as the top of the
 * stack
 ********************************************/
int Stack::top(void) // returns the value of top item in the stack
{
   if (!empty())// if its not empty
      return(stackItems[myTop]);//return the top value
   else
   {
      cerr << "[Error: Stack is empty -- spewing garbage...]";
   }
}

/********************************************
 * Push adds items to the stack
 ********************************************/
void Stack::push(int item)  // store item on the stack
{
   if (myTop < maxSize -1)// if the top is receded on position
   {
      ++myTop; //increment the top.
      stackItems[myTop] = item; //sets the top equal to the new
      //passed in
   }
   else
   {
      cerr << "ERROR: Stack Overflow\n";
      //      cerr << "[Error: Stack is full -- can't add a new item...]\n"
      //         << " Must increase the maximum capacity of the stack.\n";
      return;
   }
}

/********************************************
 *Pop removes an item from the stack
 ********************************************/
void Stack::pop(void)       // remove/delete top item off stack
{
   if (!empty())//check empty
      myTop--;//decrement 1
   else
      cerr << "ERROR: Stack Underflow\n";
   //      cerr << "[Error: Stack is empty -- cant remove items]\n";
}

/********************************************
 *Empty checks whether there is anything on the stack
 ********************************************/
bool Stack::empty(void)    // is stack empty
{
   return (myTop==-1);//if the value for the postion of
                      // the stack is -1 its empty
}

/********************************************
 *Checks to make sure the stack isnt full
 ********************************************/
bool Stack::full(void)     // is stack full
{
   return (maxSize == myTop + 1);// if the max stack size
   //is equal to the top position and then some, its full 
}

/********************************************
 *Destructor
 ********************************************/
Stack::~Stack()                   // destructor
{
   delete[] stackItems;//clears the stack
   stackItems = NULL;
}

/********************************************
 *Assignment operator allows you to assign ADTs
 ********************************************/
Stack& Stack::operator = (const Stack &rtSide) // overloaded assignment operator
{
   if (this != &rtSide)//if the left does not equal 
   {
      if(maxSize != rtSide.maxSize)
      {
         delete[] stackItems;
         maxSize = rtSide.maxSize;
         stackItems =  new int[maxSize];
         if (stackItems == 0)
         {
            cerr << "[Error: Inadequate memory]\n";
         }
      }
      myTop = rtSide.myTop;
      for (int i = 0; i <= myTop; i++)
      {
         stackItems[i] = rtSide.stackItems[i];
      }
   }
   return *this;
}
//function prototypes.
string pfix(string exp);
void displayMachineCode(string exp);

/********************************************
 *Main controls where everything happens
 ********************************************/
int main(int argc, char** argv)
{
   string filename = "";
   if( argc == 2 )
   {
      filename = argv[1];
   }
   else
   {
      getline(cin, filename);
   }
//input the file from the command line
   ifstream fin;
   fin.open(filename.c_str());//open the file
   if(fin.fail())
   {
      cout << "Error reading File...";
      return 0;//if the file cant open display error
   }
   
   string infixExp;//declare new string for infix exp
   for (; !fin.eof(); )
   {
      getline(fin, infixExp);//read in the lines as a string
      if(!fin.fail())
      {
         cout << "\nInfix Expression: " << infixExp << endl;
         cout << "Postfix expression: " << pfix(infixExp) << endl;
         //convert ot postfix
      }
      displayMachineCode(pfix(infixExp));// call display function
   }
   fin.close();//close file
   return 0;
}

/********************************************
 *Postfix conversion
 ********************************************/
string pfix(string exp)
{
   char token;
   char topToken;
   Stack opStack;
   string pfixExp;
   const string BLANK = "";
   for (int i = 0; i < exp.length(); i++)
   {
      token = exp[i];
      switch(token)
      {
         case ' ':
            break;

         case '(':
            opStack.push(token);
            break;


         case ')':
            for (;;)
            {
               if (!opStack.empty())
               {
                  topToken = opStack.top();
                  opStack.pop();
                  if (topToken == '(')
                     break;
                  pfixExp.append(BLANK + topToken);
               }
            }
            break;

         case '+' :
         case '-' :
         case '*' :
         case '/' :
         case '%':
            for (;;)
            {
               if (opStack.empty() || opStack.top() == '(' ||
                   (token == '*' || token == '/' || token == '%') &&
                   (opStack.top() == '+' || opStack.top() == '-'))
               {
                  opStack.push(token);
                  break;
               }
               else
               {
                  topToken = opStack.top();
                  opStack.pop();
                  pfixExp.append(BLANK + token);
               }
            }
         break;
         default :
            pfixExp.append(BLANK + token);
            for(;;)
            {
               if (!isalnum(exp[i+1]))break;
               i++;
               token = exp[i];
               pfixExp.append(1,token);
            }
      }
   }
   
   for (;;)
   {
      if (opStack.empty())
         break;
      topToken = opStack.top();
      opStack.pop();
      if (topToken != '(')
      {
         pfixExp.append(BLANK + topToken);
      }
      else
      {
         cout << "Error in infix notation...\n";
         break;
      }
   }
   return pfixExp;
}

/********************************************
 *Displaying the assembly code
 ********************************************/
void displayMachineCode(string exp)
{
   Stack here;
   string assembly;
//ran out of time to comment
   cout << "Assembly Code:\n";
   char r;
   char l;
   char temp = '1';
   for (int i = 0; i < exp.length(); i++)
   {
      switch (exp[i])// char push 1, opreand pop2
      {
         case 'A':
         case 'B':
         case 'C':
         case 'D':
         case 'E':
         case 'F':
         case 'G':
         case 'H':
            here.push(exp[i]);
         break;
         case ' ':
            break;

         case '+':
            assembly = "AD  ";
            r = here.top();
            here.pop();
            l = here.top();
            here.pop();
            cout << "LD  ";
            if (l == 'A' || l == 'B' || l == 'C' || l == 'D' ||
                l == 'E' || l == 'F' || l == 'G' || l == 'H')
               cout << l << endl;
            else
               cout << "TEMP" << l << endl;
            cout << assembly;
            if (r == 'A' || r == 'B' || r == 'C' || r == 'D' ||
                r == 'E' || r == 'F' || r == 'G' || r == 'H')
               cout << r << endl;
            else
               cout << "TEMP" << r << endl;
            cout  << "ST  " << "TEMP" << temp << endl;
            here.push(temp);
            temp++;
            break;

         case '-':
            assembly = "SB  ";
            r = here.top();
            here.pop();
            l = here.top();
            here.pop();
            cout << "LD  ";
            if (l == 'A' || l == 'B' || l == 'C' || l == 'D' ||
                l == 'E' || l == 'F' || l == 'G' || l == 'H')
               cout << l << endl;
            else
               cout << "TEMP" << l << endl;
            cout << assembly;
            if (r == 'A' || r == 'B' || r == 'C' || r == 'D' ||
                r == 'E' || r == 'F' || r == 'G' || r == 'H')
               cout << r << endl;
            else
               cout << "TEMP" << r << endl;
            cout  << "ST  " << "TEMP" << temp << endl;
            here.push(temp);
            temp++;
            break;

         case '*':
            assembly = "ML  ";
            r = here.top();
            here.pop();
            l = here.top();
            here.pop();
            cout << "LD  ";
            if (l == 'A' || l == 'B' || l == 'C' || l == 'D' ||
                l == 'E' || l == 'F' || l == 'G' || l == 'H')
               cout << l << endl;
            else
               cout << "TEMP" << l << endl;
            cout << assembly;
            if (r == 'A' || r == 'B' || r == 'C' || r == 'D' ||
                r == 'E' || r == 'F' || r == 'G' || r == 'H')
               cout << r << endl;
            else
               cout << "TEMP" << r << endl;
            cout  << "ST  " << "TEMP" << temp << endl;
            here.push(temp);
            temp++;
            break;
            
         case '/':
            assembly = "DV  ";
            r = here.top();
            here.pop();
            l = here.top();
            here.pop();
            cout << "LD  ";
            if (l == 'A' || l == 'B' || l == 'C' || l == 'D' ||
                l == 'E' || l == 'F' || l == 'G' || l == 'H')
               cout << l << endl;
            else
               cout << "TEMP" << l << endl;
            cout << assembly;
            if (r == 'A' || r == 'B' || r == 'C' || r == 'D' ||
                r == 'E' || r == 'F' || r == 'G' || r == 'H')
               cout << r << endl;
            else
               cout << "TEMP" << r << endl;
            cout << "ST  " << "TEMP" << temp << endl;
            here.push(temp);
            temp++;
            break;
            
         default:
            break;
      }
   }
}