/*
Simple calculator

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

The grammer for input is:

Statement:
    Expression
    Print
    Quit

Print:
    ';'

Quit:
    'q'

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

#include<iostream>
#include<stdexcept>

//Define the symbolic names:
const char number='8';
const char quit='q';
const char print=';';
const std::string prompt="> ";
const std::string result="= "; 

//---------------------------------------------------------
class Token
{
    public:
        char kind;
        double value;
        Token(char ch)
            :kind(ch), value(0){}
        Token(char ch, double val)
            :kind(ch), value(val){}
};

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){}

void Token_stream::putback(Token t)
{
    if(full) 
        throw std::runtime_error("putback() into a full buffer");
    buffer=t;
    full=true;
}

Token Token_stream::get()
{
    if (full)
    {
        full=false;
        return buffer;
    }

    char ch;
    std::cin>>ch;
    switch(ch)
    {
        case quit: 
        case print:
        case '(': 
        case ')': 
        case '+': 
        case '-': 
        case '*': 
        case '/': 
        case '%':
            return Token(ch);
        case'.':
        case'0': case'1': case'2': case'3': case'4':
        case'5': case'6': case'7': case'8': case'9':
        {
           std::cin.putback(ch);
           double val;
           std::cin>>val;
           return Token(number, val);
        }
        default: throw std::runtime_error("Bad Token");
    }
}

void Token_stream::ignore(char c)
{
    if(full && c==buffer.kind)
    {
        full=false;
        return;
    }
    full=false;
    
    //now search input:
    char ch=0;
    while(std::cin>>ch)
        if(ch==c) return;
}
//---------------------------------------------------------

Token_stream ts;
double primary();
double term();
double expression();
void calculate();
void clean_up_mess();

int main()
    try
    { 
        calculate();
        return 0;
    }
    catch (std::exception& e)
    {
        std::cerr<<e.what()<<std::endl;
        return 1;
    }
    catch(...)
    {
        std::cerr<<"exception \n"<<std::endl; 
        return 2;
    }

void calculate()
{
    double val=0;
    while(std::cin)
    try
    {
       std::cout<<prompt;
       Token t=ts.get();
       while(t.kind==print) t=ts.get();
       if (t.kind==quit) return;
       ts.putback(t);
       std::cout<<result<<expression()<<std::endl;
    }
    catch (std::exception& e)
    {
        std::cerr<<e.what()<<std::endl;
        clean_up_mess();
    }
}

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

double primary()
{
    Token t=ts.get();
    switch(t.kind)
    {
        case'(':
        {
            double d=expression();
            t=ts.get();
            if(t.kind!=')') throw std::runtime_error("')' expected");
            return d;
        }
        case number:
            return t.value;
        case '-':
            return -primary();
        case '+':
            return primary();
        default:
            throw std::runtime_error("primary expected!");
    }
}

double term()
{
    double left=primary();
    Token t=ts.get();
    while(true)
    {
        switch(t.kind)
        {
            case '*':
                left*=primary();
                t=ts.get(); 
                break;
            case '/':
            {
                double d=primary();
                if(d==0) throw std::runtime_error("Divide by zero!");
                left/=d;
                t=ts.get(); 
                break;           
            }
            case '%':
            {
                double d=primary();
                int i1=int(left);
                if(i1!=left) 
                    throw std::runtime_error("Left hand operator of % not int. ");
                int i2=int(d);
                if(i2!=d) 
                    throw std::runtime_error("Right hand operator of % not int. ");
                if(i2==0) 
                    throw std::runtime_error("%: Divide by zero.");
                left=i1%i2;
                t=ts.get();
                break;
            }
            default: 
                ts.putback(t);
                return left;
        }
    }
}

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