// Soln6_5ANSI.cpp
// A program to implement a calculator accepting parentheses

#include <iostream>                   // For stream input/output
#include <cstdlib>                    // For the exit() function
#include <cctype>                     // For the isdigit() function
#include <cstring>                    // For the strcpy() function
#include <cmath>                      // For the pow() function
using std::cin;
using std::cout;
using std::endl;

void eatspaces(char* str);            // Function to eliminate blanks
double expr(char* str);               // Function evaluating an expression
double term(char* str, int& index);   // Function analyzing a term
double number(char* str, int& index); // Function to recognize a number
char* extract(char* str, int& index); // Function to extract a substring
void error(char* str, int index);     // Function to identify an error
double doOperation(char* op, double value);   // Execute math function

const int MAX = 80;                   // Maximum expression length,including '\0' 
const double degToRad = 57.295779;    // Conversion factor, degrees to radians
int main()
{
   char buffer[MAX] = {0};    // Input area for expression to be evaluated

   cout << endl
        << "Welcome to your friendly calculator."
        << endl
        << "Enter an expression, or an empty line to quit."
        << endl;

   for(;;)
   {
      cin.getline(buffer, sizeof buffer);   // Read an input line
      eatspaces(buffer);                    // Remove blanks from input

      if(!buffer[0])                        // Empty line ends calculator
         return 0;

      cout << "\t= " << expr(buffer)        // Output value of expression
           << endl << endl;
   }
}


// Function to eliminate spaces from a string
void eatspaces(char* str)
{
   int i = 0;                             // 'Copy to' index to string
   int j = 0;                             // 'Copy from' index to string

   while((*(str + i) = *(str + j++)) != '\0')  // Loop while character
                                               // copied is not \0
      if(*(str + i) != ' ')                    // Increment i as long as
         i++;                                  // character is not a space
   return;
}

// Function to evaluate an arithmetic expression
double expr(char* str)
{
  double value = 0.0;                  // Store result here
  int index = 0;                       // Keeps track of current character position

  value = term(str, index);            // Get first term

  for(;;)                              // Indefinite loop, all exits inside
  {
    switch(*(str + index++))           // Choose action based on current character
    {
      case '\0':                       // We're at the end of the string
         return value;                 // so return what we have got

      case '+':                        // + found so add in the
         value += term(str, index);    // next term
         break;

      case '-':                        // - found so subtract
         value -= term(str, index);    // the next term
         break;

      default:                         // If we reach here the string
         cout << endl                  // is junk
              << "Arrrgh!*#!! There's an error"
              << endl;
         error(str, index-1);
         exit(1);
    }
  }
}

// Function to get the value of a term
double term(char* str, int& index)
{
  double value = 0.0;                  // Somewhere to accumulate 
                                       // the result

  value = number(str, index);          // Get the first number in the term

  // Loop as long as we have a good operator
  while((*(str + index) == '*') || (*(str + index) == '/') || (*(str + index) == '^'))
  {

    if(*(str + index) == '*')          // If it's multiply,
      value *= number(str, ++index);   // multiply by next number

    if(*(str + index) == '/')          // If it's divide,
      value /= number(str, ++index);   // divide by next number
    if(*(str + index)=='^')
       value = pow(value, number(str, ++index));
  }
  return value;                        // We've finished, so return what 
                                       // we've got
}

// Function to recognize a number in a string
double number(char* str, int& index)
{
  double value = 0.0;                  // Store the resulting value

  // Look for a math function name
  char op[6];
  int ip = 0;
  while (isalpha(*(str+index)))      // Copy the function name
    op[ip++] = *(str+index++);
  op[ip] = '\0';                     // Append terminator


  if(*(str + index) == '(')           // Start of parentheses
  {
    char* psubstr = 0;               // Pointer for substring
    psubstr = extract(str, ++index); // Extract substring in brackets
    value = expr(psubstr);           // Get the value of the substring

    // If we have a math operation saved, go and do it
    if(op[0])
      value = doOperation(op, value);

    delete[]psubstr;                 // Clean up the free store
    return value;                    // Return substring value
  }

  while(isdigit(*(str + index)))       // Loop accumulating leading digits
    value = 10*value + (*(str + index++) - '0');

                                       // Not a digit when we get to here
  if(*(str + index) != '.')            // so check for decimal point
    return value;                      // and if not, return value

  double factor = 1.0;                 // Factor for decimal places
  while(isdigit(*(str + (++index))))   // Loop as long as we have digits
  {
    factor *= 0.1;                     // Decrease factor by factor of 10
    value = value + (*(str + index) - '0')*factor;   // Add decimal place
  }

  return value;                        // On loop exit we are done
}

// Function to extract a substring between parentheses 
// (requires cstring)
char* extract(char* str, int& index)
{
  char buffer[MAX];                   // Temporary space for substring
  char* pstr = 0;                     // Pointer to new string for return
  int numL = 0;                       // Count of left parentheses found
  int bufindex = index;               // Save starting value for index

  do
  {
    buffer[index - bufindex] = *(str + index);
    switch(buffer[index - bufindex])
    {
      case ')':
        if(numL == 0)
        {
          size_t size = index - bufindex;
          buffer[index - bufindex] = '\0';  // Replace ')' with '\0' 
          ++index;
          pstr = new char[index - bufindex];
          if(!pstr)
          {
            cout << "Memory allocation failed,"
                 << " program terminated.";
            exit(1);
          }
          strcpy_s(pstr, index-bufindex, buffer); // Copy substring to new memory
          return pstr;                 // Return substring in new memory
        }
        else
          numL--;                      // Reduce count of '(' to be matched
          break;

      case '(':
        numL++;                        // Increase count of '(' to be 
                                   // matched
        break;
      }
  } while(*(str + index++) != '\0'); // Loop - don't overrun end of string

  cout << "Ran off the end of the expression, must be bad input."
       << endl;
  exit(1);
  return pstr;
}

// Function to identify an error
void error(char* str, int index)
{
   cout << str << endl;
   for (int i=0; i<index; i++)
      cout << ' ';
   cout << '^' << endl;
}

// Execute math function
double doOperation(char* op, double value)
{
   if (!_stricmp(op, "sin"))
      return sin(value);
   else if (!_stricmp(op, "sind"))
      return sin(value/degToRad);
   else if (!_stricmp(op, "cos"))
      return cos(value);
   else if (!_stricmp(op, "cosd"))
      return cos(value/degToRad);
   else if (!_stricmp(op, "tan"))
      return tan(value);
   else if (!_stricmp(op, "tand"))
      return tan(value/degToRad);
   else if (!_stricmp(op, "sqrt"))
      return sqrt(value);
   else
   {
      cout << "Error: unknown operation '" << op << "'" << endl;
      exit(1);
   }
   return 0;
}