I'm bored.
Code:
#include <iostream>
#include <string>
#include <sstream>
#include <list>
#include <stack>
#include <climits>
#ifdef __DJGPP__
#include <crt0.h>
extern "C" char **__crt0_glob_function (char*) {return 0;}
extern "C" void __crt0_load_environment_file (char *) { }
extern "C" void __crt0_setup_arguments (void) { }
#endif
enum opsym_t {OP_NEG, OP_ADD, OP_SUB, OP_MUL, OP_DIV, OP_GRP};
double eval(std::string&) throw (std::string&);
void stack_eval(std::stack<std::pair<opsym_t,int>, std::list<std::pair<opsym_t,int> > >&,
std::stack<double,std::list<double> >&);
void show_stacks(std::stack<std::pair<opsym_t,int>, std::list<std::pair<opsym_t,int> > >,
std::stack<double,std::list<double> >);
double opf_negate(double, double);
double opf_add(double, double);
double opf_sub(double, double);
double opf_mul(double, double);
double opf_div(double, double);
const int op_precs[] = {INT_MAX, 0, 0, 1, 1, INT_MIN};
double (*op_funcs[])(double, double) = {opf_negate, opf_add, opf_sub, opf_mul, opf_div, 0};
int main()
{
std::ios::sync_with_stdio(false);
double result = 0.0;
char* buf = new char [BUFSIZ];
std::cout << "Enter an arithmetic expression: ";
std::cin.get(buf, BUFSIZ);
std::string str(buf);
delete [] buf;
try
{
result = eval(str);
}
catch (std::string& err_msg)
{
std::cerr << err_msg << ".\n";
return 1;
}
std::cout << "= " << result << std::endl;
std::cin.get();
return 0;
}
void show_stacks(std::stack<std::pair<opsym_t,int>, std::list<std::pair<opsym_t,int> > > ops,
std::stack<double,std::list<double> > vals)
{
#ifndef NDEBUG
char opers[] = {'-', '+', '-', '*', '/', '('};
std::endl(std::cerr);
if (ops.empty())
std::cerr << "Empty";
else
while (!ops.empty())
{
std::cerr << opers[ops.top().first] << " : ";
ops.pop();
}
std::endl(std::cerr);
if (vals.empty())
std::cerr << "Empty";
else
while (!vals.empty())
{
std::cerr << vals.top() << " : ";
vals.pop();
}
std::endl(std::cerr);
#endif
}
void stack_eval(std::stack<std::pair<opsym_t,int>, std::list<std::pair<opsym_t,int> > >& ops,
std::stack<double,std::list<double> >& vals)
{
show_stacks(ops, vals);
double v1, v2 = 0, r;
opsym_t o;
o = ops.top().first;
ops.pop();
v1 = vals.top();
vals.pop();
if (o != OP_NEG)
{
v2 = vals.top();
vals.pop();
}
r = op_funcs[o](v1, v2);
vals.push(r);
#ifndef NDEBUG
char opers[] = {'-', '+', '-', '*', '/', '('};
std::cerr << "(" << v1 << ", " << v2 << ", " << opers[o] << ") -> " << r << std::endl;
#endif
}
double eval(std::string& s) throw (std::string&)
{
std::istringstream expr(s);
std::stack<std::pair<opsym_t,int>, std::list<std::pair<opsym_t,int> > > op_stack;
std::stack<double,std::list<double> > val_stack;
char c;
enum {VAL_OR_UNARY_OP, BINARY_OP} state = VAL_OR_UNARY_OP;
double temp;
while (expr >> std::ws >> c)
{
show_stacks(op_stack, val_stack);
if (state == VAL_OR_UNARY_OP)
{
if (c == '-')
op_stack.push(std::pair<opsym_t,int>(OP_NEG, op_precs[OP_NEG]));
else if (c == '(')
{
op_stack.push(std::pair<opsym_t,int>(OP_GRP, op_precs[OP_GRP]));
}
else
{
expr.seekg(-1, ios::cur);
expr >> temp;
if (!expr)
throw std::string("Invalid number or unary operator");
val_stack.push(temp);
state = BINARY_OP;
}
}
else
{
if (c == ')')
{
while (op_stack.top().first != OP_GRP)
{
if (op_stack.empty())
throw std::string("Imbalanced `)'");
stack_eval(op_stack, val_stack);
}
op_stack.pop();
continue;
}
std::pair<opsym_t,int> op;
switch (c)
{
case '+':
op.first = OP_ADD;
break;
case '-':
op.first = OP_SUB;
break;
case '*':
op.first = OP_MUL;
break;
case '/':
op.first = OP_DIV;
break;
default:
throw std::string("Invalid operator");
}
op.second = op_precs[op.first];
if (!op_stack.empty())
if (op_stack.top().second > op.second)
stack_eval(op_stack, val_stack);
op_stack.push(op);
state = VAL_OR_UNARY_OP;
}
}
if (state == VAL_OR_UNARY_OP)
throw (std::string("Dangling binary operator");
while (!op_stack.empty())
{
if (op_stack.top().first == OP_GRP)
op_stack.pop();
else
stack_eval(op_stack, val_stack);
}
temp = val_stack.top();
val_stack.pop();
return temp;
}
double opf_negate(double val, double)
{
return -val;
}
double opf_add(double val1, double val2)
{
return val2 + val1;
}
double opf_sub(double val1, double val2)
{
return val2 - val1;
}
double opf_mul(double val1, double val2)
{
return val2 * val1;
}
double opf_div(double val1, double val2)
{
return val2 / val1;
}
Last edited by Guest on 26 Dec 2005 03:09:17 pm; edited 1 time in total |
General Coding and Design => Calculator Programming
