Power operation in calculator... help!

[AldenB]

I'm writing this simple calculator program and I'm trying to add a pow() function for user input. The function dealing with power expressions is shown below. The entire source code can be found beneath it. My main issue is finding a concise way to write this.

Function used to handle powers:

double primary()
{
	Token t = ts.get();
	switch (t.kind) {
	case '(':
	{	double d = expression();
	t = ts.get();
	if (t.kind != ')') error("'(' expected");
	return d;
	}
	case '-':
		return -primary();
	case '+':
		return primary();
	case number:
		return t.value;
	case name:
		return get_value(t.name);
	case sqroot:
	{
		// square root... uses the syntax "sqrt(<expression()>)"
		t = ts.get();
		if (t.kind != '(') error("'(' expected");
		double d = expression();
		if (d < 0) error("error: sqrt of a negative number");
		t = ts.get();
		if (t.kind != ')') error("')' expected");
		return sqrt(d);
	}
	case powr:
	{
		//power... uses the syntax "pow(<base>,<exponent>)" where exponent must be an integer
	}
	default:
		error("primary expected");
	}
}

Entire source code:

/*
Simple calculator program

This program implements a grammar in order to parse mathematical expressions

The grammar is as follows:

Expression:
Term
Expression + Term
Expression - Term

Term:
Primary
Term * Primary
Term / Primary
Term % Primary

Primary:
Number
( Expression )
sqrt( Expression )
pow( Expression )
-Primary
+Primary

Number:
floating-point literal

Input is received from cin through Token_stream
*/

#include "std_lib_facilities.h"

struct Token {
	char kind; // stores the type of Token (character, number, name, etc...)
	double value; // stores the value of 'number' Tokens
	string name; // stores the name of 'name' Tokens
	Token(char ch) :kind(ch), value(0) { }
	Token(char ch, double val) :kind(ch), value(val) { }
	Token(char ch, string n) :kind(ch), name(n) { }
};

class Token_stream {
	bool full; // is there a Token in the buffer?
	Token buffer; // stores a Token in the Token_stream
public:
	Token_stream() :full(0), buffer(0) { }

	Token get();
	void unget(Token t) { buffer = t; full = true; }
	void ignore(char); // used for error handling; eats input until the 'char' is reached
};

const char let = 'L';
const char quit = 'Q';
const char print = ';';
const char number = '8';
const char name = 'a';
const char sqroot = 'S';
const char powr = 'P';

Token Token_stream::get()
{
	if (full) { full = false; return buffer; }
	char ch;
	cin >> ch;
	switch (ch) {
	case print:
	case quit:
	case '(':
	case ')':
	case '+':
	case '-':
	case '*':
	case '/':
	case '%':
	case '=':
		return Token(ch); // let each character represent itself as a Token
	case '.':
	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
	{	cin.unget(); // put digit back into input stream
	double val;
	cin >> val; // read entire number
	return Token(number, val); // a 'number' Token with a value 'val'
	}
	default:
		// checking for a 'name' token or declaration key ("let")
		if (isalpha(ch)) { // names must start with a letter
			string s;
			s += ch;
			while (cin.get(ch) && (isalpha(ch) || isdigit(ch))) s += ch; // the rest of the name can consist of digits or letters
			cin.unget(); //
			if (s == "let") return Token(let); // Token of kind 'let'
			if (s == "sqrt") return Token(sqroot); // square root
			if (s == "pow") return Token(powr); // power
			return Token(name, s); // Token of kind 'name' called 's'
		}
		error("Bad token");
	}
}

void Token_stream::ignore(char c)
{
	if (full && c == buffer.kind) { // first check the buffer for 'c'
		full = false;
		return;
	}
	full = false;

	char ch;
	while (cin >> ch) // eat characters until 'c' is found
		if (ch == c) return;
}

struct Variable {
	string name;
	double value;
	Variable(string n, double v) :name(n), value(v) { }
};

vector<Variable> names;

double get_value(string s)
{
	for (int i = 0; i<names.size(); ++i) // check names for 's' and return its value
		if (names[i].name == s) return names[i].value;
	error("get: undefined name ", s);
}

void set_value(string s, double d)
{
	for (int i = 0; i <= names.size(); ++i) // check names for 's' and change its value
		if (names[i].name == s) {
			names[i].value = d;
			return;
		}
	error("set: undefined name ", s);
}

bool is_declared(string s)
{
	for (int i = 0; i<names.size(); ++i) // check names to see is a Variable name has already been declared
		if (names[i].name == s) return true;
	return false;
}

void define_name(string var, double val) // add a new variable to 'names'
{
	if (is_declared(var)) error(var, " declared twice");
	names.push_back(Variable(var, val));
}

Token_stream ts;

double expression();

// handles '(' ')' and names
double primary()
{
	Token t = ts.get();
	switch (t.kind) {
	case '(':
	{	double d = expression();
	t = ts.get();
	if (t.kind != ')') error("'(' expected");
	return d;
	}
	case '-':
		return -primary();
	case '+':
		return primary();
	case number:
		return t.value;
	case name:
		return get_value(t.name);
	case sqroot:
	{
		// square root... uses the syntax "sqrt(<expression()>)"
		t = ts.get();
		if (t.kind != '(') error("'(' expected");
		double d = expression();
		if (d < 0) error("error: sqrt of a negative number");
		t = ts.get();
		if (t.kind != ')') error("')' expected");
		return sqrt(d);
	}
	case powr:
	{
		//power... uses the syntax "pow(<base>,<exponent>)" where exponent must be an integer
	}
	default:
		error("primary expected");
	}
}

// handles '*', '/' and '%'
double term()
{
	double left = primary();
	while (true) {
		Token t = ts.get();
		switch (t.kind) {
		case '*':
			left *= primary();
			break;

		case '/':
		{	double d = primary();
		if (d == 0) error("divide by zero");
		left /= d;
		break;
		}

		case '%':
		{	double d = primary();
		if (d == 0) error("divide by zero");
		left = fmod(left, d);
		break;
		}

		default:
			ts.unget(t);
			return left;
		}
	}
}

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

// creates new Variables using the format: "let" <name> "=" expression()
double declaration()
{
	Token t = ts.get();
	if (t.kind != name) error("name expected in declaration");
	string name = t.name;
	if (is_declared(name)) error(name, " declared twice");
	Token t2 = ts.get();
	if (t2.kind != '=') error("= missing in declaration of ", name);
	double d = expression();
	names.push_back(Variable(name, d));
	return d;
}

double statement()
{
	Token t = ts.get();
	switch (t.kind) {
	case let:
		return declaration();
	default:
		ts.unget(t);
		return expression();
	}
}

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

const string prompt = "> ";
const string result = "= ";

void calculate()
{
	while (true) try {
		cout << prompt;
		Token t = ts.get();
		while (t.kind == print) t = ts.get();
		if (t.kind == quit) return;
		ts.unget(t);
		cout << result << statement() << endl;
	}
	catch (runtime_error& e) {
		cerr << e.what() << endl;
		clean_up_mess();
	}
}

int main()
try
{
	define_name("k", 1000);

	calculate();
	return 0;
}
catch (exception& e)
{
	cerr << "exception: " << e.what() << endl;
	char c;
	while (cin >> c&& c != ';');
	return 1;
}
catch (...)
{
	cerr << "exception\n";
	char c;
	while (cin >> c && c != ';');
	return 2;
}

[JLBorges]

Something along these lines, perhaps:

// ...
case powr:
{
    //power... uses the syntax "pow(<base>,<exponent>)" where exponent must be an integer
    t = ts.get();
    if (t.kind != '(') error("'(' expected");

    double base = expression();

    t = ts.get(); // need to add a case for the character ','
    if (t.kind != ',') error("',' expected");

    double exponent = expression();
    // crude check for integer
    // you would want to refine this by providing a function that parses an integer
    if( exponent != int(exponent) ) error( "expected integer") ;

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

    return std::pow( base, exponent );
}
// ... 

[AldenB]

I think this will work just at a glance... I'll try it out, thank you for feedback!