// Code derived from Stroustrup's PPP2 book
// § 7.8.3 Predefined names
//  -and beginning on p 250

/*
    Simple calculator

    Revision history:

        Revised by Bjarne Stroustrup May 2007
        Revised by Bjarne Stroustrup August 2006
        Revised by Bjarne Stroustrup August 2004
        Originally written by Bjarne Stroustrup
            (bs@cs.tamu.edu) Spring 2004.

    This program implements a basic expression calculator.
    Input from cin; output to cout.

    The grammar for input is:

    Calculation:
        Statement
        Print
        Quit
        Calculation Statement

    Statement:
        Declaration
        Expression

    Declaration:
        "let" Name "=" Expression

    Print:
        ;

    Quit:
        q

    Expression:
        Term
        Expression + Term
        Expression - Term
    Term:
        Primary
        Term * Primary
        Term / Primary
        Term % Primary
    Primary:
        Number
        Name
        ( Expression )
        - Primary
        + Primary
    Number:
        floating-point-literal


        Input comes from cin through the Token_stream called ts.
*/

#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>

using namespace std;

void error(string const& s) { throw runtime_error(s); }
void error(string const& s1, string const& s2) { error(s1 + s2); }

// run-time checked narrowing cast (type conversion)
template <class R, class A>
R narrow_cast(A const& a)
{
  R r = R(a);
  if (A(r) != a)
    error("narrow_cast() info loss");

  return r;
}

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

const char   number  = '8';    // t.kind==number means that t is a number Token
const char   quit    = 'q';    // t.kind==quit means that t is a quit Token
const char   print   = ';';    // t.kind==print means that t is a print Token
const char   name    = 'a';    // name token
const char   let     = 'L';    // declaration token
const string declkey = "let";  // declaration keyword
const string prompt  = "> ";   // used to indicate we're waiting on user input
const string result  = "= ";   // used to indicate that what follows is a result

//------------------------------------------------------------------------------
class Token {
 public:
  Token(char ch) : kind{ch} {}

  Token(char ch, double val) : kind{ch}, value{val} {}

  Token(char ch, string n) : kind{ch}, name{n} {}

  char   kind  = '0';
  double value = 0.0;
  string name;  // for names: name itself
};

//------------------------------------------------------------------------------
class Token_stream {
 public:
  Token_stream();

  Token get();
  void  putback(Token t);
  void  ignore(char c);

 private:
  bool  full;
  Token buffer;
};

//------------------------------------------------------------------------------
Token_stream::Token_stream() : full{false}, buffer{0} {}

//------------------------------------------------------------------------------
// read a token from cin
Token Token_stream::get()
{
  if (full) {  // check if we already have a Token ready
    full = false;
    return buffer;
  }

  char ch;
  cin >> ch;

  // clang-format off
  switch (ch) {
    case print:
    case quit:
    case '(':
    case ')':
    case '+':
    case '-':
    case '*':
    case '/':
    case '%':
    case '=':
      return Token{ch};
      break;
    case '.':
    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9': {
      cin.putback(ch);  // put digit back into the input stream
      double val;
      cin >> val;
      return Token{number, val};
      break;
    }
    default:
      if (isalpha(ch)) {
        string s;
        s += ch;
        while (cin.get(ch) && (isalpha(ch) || isdigit(ch)))
          s += ch;

        cin.putback(ch);

        if (s == declkey)
          return Token{let};  // keyword "let"

        return Token{name, s};
      }
      error("Bad token");
      return Token{'K'};  // invalid, shouldn't reach here
  }
  // clang-format on
}

//------------------------------------------------------------------------------
// put token back into stream
void Token_stream::putback(Token t)
{
  if (full)
    error("putback() into a full buffer");

  buffer = t;
  full   = true;
}

//------------------------------------------------------------------------------
// c represents the kind of a Token
void Token_stream::ignore(char c)
{
  // first look in buffer:

  if (full && c == buffer.kind) {
    full = false;
    return;
  }

  // now search input:

  full = false;

  char ch = 0;

  while (cin >> ch)
    if (ch == c)
      return;
}

//------------------------------------------------------------------------------
class Variable {
 public:
  Variable(string n, double v) : name{n}, value{v} {}

  string name;
  double value;
};

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

vector<Variable> var_table;

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

// return the value of the Variable names s
double get_value(string s)
{
  for (unsigned i = 0; i < var_table.size(); ++i)
    if (var_table[i].name == s)
      return var_table[i].value;

  error("get: undefined variable ", s);

  return 0.0;  // shouldn't reach here
}

// set the Variable named s to d
void set_value(string s, double d)
{
  for (unsigned i = 0; i < var_table.size(); ++i) {
    if (var_table[i].name == s) {
      var_table[i].value = d;
      return;
    }
  }

  error("set: undefined variable ", s);
}

// is var already in var_table?
bool is_declared(string var)
{
  for (unsigned i = 0; i < var_table.size(); ++i)
    if (var_table[i].name == var)
      return true;

  return false;
}

// add (var,val) to var_table
double define_name(string var, double val)
{
  if (is_declared(var))
    error(var, " declared twice");

  var_table.push_back(Variable{var, val});
  return val;
}

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

Token_stream ts;

double expression();

//------------------------------------------------------------------------------
// deal with numbers, parentheses, unary -, unary +, and named vars
double primary()
{
  Token t = ts.get();

  switch (t.kind) {
    case '(': {
      double d = expression();

      t = ts.get();
      if (t.kind != ')')
        error("')' expected");

      return d;
      break;
    }
    case number: return t.value; break;
    case name:
      return get_value(t.name);  // return the variable's value
      break;
    case '-': return -primary(); break;
    case '+': return primary(); break;
    default:
      error("primary expected");
      // shouldn't reach here
      return 0.0;
  }
}

//------------------------------------------------------------------------------
// deal with *, /, and %
double term()
{
  double left = primary();

  Token t = ts.get();

  while (true) {
    switch (t.kind) {
      case '*': left *= primary(); break;
      case '/': {
        double d = primary();
        if (d == 0)
          error("divide by zero");

        left /= d;
        break;
      }
      case '%': {
        int i1 = narrow_cast<int>(left);
        int i2 = narrow_cast<int>(primary());
        if (i2 == 0)
          error("%: divide by zero");

        left = i1 % i2;
        break;
      }
      default: ts.putback(t); return left;
    }

    t = ts.get();
  }
}

//------------------------------------------------------------------------------
// deal with + and -
double expression()
{
  double left = term();

  Token t = ts.get();

  while (true) {
    switch (t.kind) {
      case '+': left += term(); break;
      case '-': left -= term(); break;
      default: ts.putback(t); return left;
    }

    t = ts.get();
  }
}

//------------------------------------------------------------------------------
// deal with name = expression
// declare a variable called "name" with the initial value "expression"
double declaration()
{
  Token t = ts.get();

  if (t.kind != name)
    error("name expected in declaration");

  string var_name = t.name;

  Token t2 = ts.get();

  if (t2.kind != '=')
    error("= missing in declaration of ", var_name);

  double d = expression();

  define_name(var_name, d);

  return d;
}

//------------------------------------------------------------------------------
double statement()
{
  Token t = ts.get();

  switch (t.kind) {
    case let: return declaration();
    default: ts.putback(t); return expression();
  }
}

//------------------------------------------------------------------------------
void clean_up_mess() { ts.ignore(print); }

//------------------------------------------------------------------------------
// expression evaluation loop
void calculate()
{
  while (cin)
    try {
      cout << prompt;

      Token t = ts.get();

      while (t.kind == print)
        t = ts.get();

      if (t.kind == quit) {
        cout << "\b\b";
        return;
      }

      ts.putback(t);

      cout << result << statement() << '\n';

    } catch (exception& e) {
      cerr << e.what() << '\n';

      clean_up_mess();
    }
}

//------------------------------------------------------------------------------
int main()
try {
  // predefine names:
  define_name("pi", 3.1415926535);
  define_name("e", 2.7182818284);

  calculate();

} catch (exception& e) {
  cerr << e.what() << '\n';
  return 1;

} catch (...) {
  cerr << "exception \n";
  return 2;
}