// deal with numbers and parentheses
double primary()
{
Token t = ts.get();
switch (t.kind) {
case '{': // handle '{' expression '}'
{
double d = expression();
t = ts.get();
if (t.kind != '}') error("'}' expected");
return d;
}
case '(': // handle '(' expression ')'
{
double d = expression();
t = ts.get();
if (t.kind != ')') error("')' expected");
return d;
}
case '8': // we use '8' to represent a number
{
Token next_t = ts.get();
if (next_t.kind == '!')
return factorial(narrow_cast<int>(t.value));
else
ts.putback(next_t);
return t.value; // return the number's value
}
default:
error("primary expected");
}
}
double func()
{
Token t = ts.get();
if (ts.get().kind == '(') {
if(t.name == "sqrt"){
double d = expression();
t = ts.get();
if (t.kind != ')') error("')' expected");
if (d < 0) error("sqrt() parameter is negative number ");
return sqrt(d); // 平方根を返す
}
else if(t.name == "pow"){
double d1 = expression();
t = ts.get();
if (t.kind != ',') error("',' expected");
double d2 = expression();
int i2 = int(d2);
if (i2 < 0) error("second parameter is negative number ");
if (i2 != d2) error("second parameter is not integer");
t = ts.get();
if (t.kind != ')') error("')' expected");
return pow(d1, i2); // べき乗を返す
}
}
else
error("'(' expected");
}
// deal with numbers and parentheses
double primary()
{
Token t = ts.get();
switch (t.kind) {
case '(': // handle '(' expression ')'
{
double d = expression();
t = ts.get();
if (t.kind != ')') error("')' expected");
return d;
}
case number:
return t.value; // return the number's value
case name:
{
Token next = ts.get();
if (next.kind == '=') { // handle name = expression
double d = expression();
set_value(t.name,d);
return d;
}
else {
ts.putback(next); // not an assignment: return the value
return get_value(t.name); // return the variable's value
}
}
case '-':
return - primary();
case '+':
return primary();
default:
error("primary expected");
}
}
double primary(){
Token t = ts.get();
switch(t.kind){
case '(': // '(' Expression ')'を処理する
{
double d = expression();
t = ts.get();
if(t.kind != ')') error("')' expected");
return d;
}
case number: // 数字を表す
return t.value; // 数字の値を返す
case name:
{
Token t2 = ts.get();
if(t2.kind == '='){ // 変数に値を代入
double d = expression();
st.set_value(t.name, d);
return d;
}
else{
ts.putback(t2);
return st.get_value(t.name); // 変数の値を返す
}
}
case '-':
return -primary();
case '+':
return primary();
default:
error("primary expected");
}
}
double primary()
{
Token t = ts.get();
switch (t.kind) {
case '(':
{ double d = expression();
t = ts.get();
if (t.kind != ')') error("'(' expected");
return d;
}
case sqrtsymb:
return get_square();
case powsymb:
return get_pow();
case '-':
return - primary();
case name:
{
t2 = ts.get();
cin >>
if(t.kind == '=') return set_value();
return get_value(t.name);
}
case '+':
return primary();
case number:
return t.value;
default:
error("primary expected");
}
}
int main()
try
{
while (cin) {
cout << "> ";
Token t = ts.get();
while (t.kind == ';') t=ts.get(); // eat ';'
if (t.kind == 'q') {
keep_window_open();
return 0;
}
ts.putback(t);
cout << "= " << expression() << endl;
}
keep_window_open();
return 0;
}
catch (exception& e) {
cerr << e.what() << endl;
keep_window_open("~~");
return 1;
}
catch (...) {
cerr << "exception \n";
keep_window_open("~~");
return 2;
}
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) error("Division by zero.");
left /= d;
t = ts.get();
break;
}
case '%':
{
int i1 = narrow_cast<int>(left);
int i2 = narrow_cast<int>(term());
if (i2 == 0) error("%: divide by zero");
left = i1 % i2;
t = ts.get();
break;
}
default:
ts.putback(t);
return left;
}
}
}
double factorial()
{
double left = primary();
Token t = ts.get(); // get the next token from token stream
while(true) {
switch (t.kind) {
case '!':
{
int x = left;
int count = left;
for (int i = 1; i < count; i++) {
x*=i;
//cout << left << "\n" << i << "\n";
}
if (x == 0) left = 1;
else left = x;
t = ts.get();
break;
}
default:
ts.putback(t); // put t back into the token stream
return left;
}
}
}
// deal with numbers and parentheses
double primary()
{
Token t = ts.get();
switch (t.kind) {
case '(': // handle '(' expression ')'
{
double d = expression();
t = ts.get();
if (t.kind != ')') error("')' expected");
return d;
}
case '{': // handle '(' expression ')'
{
double d = expression();
t = ts.get();
if (t.kind != '}') error("'}' expected");
return d;
}
case '8': // we use '8' to represent a number
return t.value; // return the number's value
case 'x':
error("x");
default:
error("primary expected");
}
}
double primary()
{
Token t = ts.get();
if(t.kind == '(')
{
double val = expression();
t = ts.get();
if (t.kind != ')')
error ("Closing parenthesis expected, but not found");
return val;
}
else if(t.kind == '{')
{
double val = expression();
t = ts.get();
if(t.kind != '}')
error ("Closing brace expected, but not found");
return val;
}
else if (t.kind == '8')
return t.value;
error("Primary expected, but found something else");
// can never reach here
cerr << "Should never reach here" << endl;
return 0;
}
// deal with *, /, and %
double term()
{
double left = primary();
Token t = ts.get(); // get the next token from token stream
while (true) {
switch (t.kind) {
case '*':
left *= primary();
t = ts.get();
break; //added break and bracket
case '/':
{
double d = primary();
if (d == 0) error("divide by zero");
left /= d;
t = ts.get();
break;
}
default:
ts.putback(t); // put t back into the token stream
return left;
}
}
}
double primary(){
Token t = ts.get();
switch(t.kind){
case '(': // '(' Expression ')'を処理する
{
double d = expression();
t = ts.get();
if(t.kind != ')') error("')' expected");
return d;
}
case '{': // '{' Expression '}'を処理する
{
double d = expression();
t = ts.get();
if(t.kind != '}') error("'}' expected");
return d;
}
case '8': // '8'を使って数字を表す
return t.value; // 数字の値を返す
case 'q': // 追加
keep_window_open("~0");
exit(EXIT_SUCCESS);
default:
error("primary expected");
}
}
void calculate()
{
const string prompt = "> ";
const string result = "= ";
while (cin) {
try {
bool displayed_help = false;
cout << prompt;
Token t = ts.get();
while (t.kind == print) t = ts.get();
if (t.kind == quit) return;
if (t.kind == help_lower) {
display_help();
displayed_help = true;
}
if (displayed_help == false) {
ts.putback(t);
cout << result << statement() << endl;
}
}
catch (exception& e) {
cerr << e.what() << endl;
clean_up_mess();
}
}
}
int main()
try
{
cout << WELCOME << endl;
cout << INSTRUCT << endl;
double val = 0;
while (cin) {
Token t = ts.get();
if (t.kind == ';') // ';' for "print now"
cout << "=" << val << '\n';
else
ts.putback(t);
t = ts.get();
if (t.kind == 'x') break; // 'x' for quit
else
ts.putback(t);
val = expression();
}
keep_window_open();
}
catch (exception& e) {
cerr << "error: " << e.what() << '\n';
keep_window_open();
return 1;
}
catch (...) {
cerr << "Oops: unknown exception!\n";
keep_window_open();
return 2;
}
// deal with numbers and parentheses
double primary()
{
Token t = ts.get();
switch (t.kind) {
case '{':
{
double e=expression();
t=ts.get();
if(t.kind!='}') error("'}' expected");
return suffix(e);
}
case '(': // handle '(' expression ')'
{
double d = expression();
t = ts.get();
if (t.kind != ')') error("')' expected");
return suffix(d);
}
case '8': // we use '8' to represent a number
return suffix(t.value); // return the number's value
case END:
case QUIT:
ts.putback(t);
return 0;
default:
ts.putback(t);
error("primary expected");
return t.value;
}
}
// deal with '!' - factorial. do the conversion to int first.
double factorial()
{
double left = primary();
Token t = ts.get(); // get the next token from token stream
while(true) {
switch (t.kind) {
case '!':
{
int n = abs (left); // convert to int
long int fac = 1; // 0!=1
while (n>1) {
fac *= n--; // 1*n*(n-1)*.. *3*2
}
if (left < 0) {
left = -fac; // we want to handle the case -5!
} else {
left = fac;
}
t = ts.get();
break;
}
case 'x':
error("x");
break;
default:
ts.putback(t); // put t back into the token stream
return left;
}
}
}
double prim(bool get) {
if (get) ts.get();
switch (ts.current().kind) {
case Kind::number:
{
double v = ts.current().number_value;
ts.get();
return v;
}
case Kind::name:
{
double &v = table[ts.current().string_value];
if (ts.get().kind == Kind::assign) v = expr(true);
return v;
}
case Kind::minus:
{
return -prim(true);
}
case Kind::lp:
{
auto e = expr(true);
if (ts.current().kind != Kind::rp)
return error("'(' expected");
}
default:
return error("primary expected");
}
}
// deal with *, /, and %
double term()
{
//double left = primary();
double left = factorial();
Token t = ts.get(); // get the next token from token stream
while(true) {
switch (t.kind) {
case '*':
//left *= primary();
left *= factorial();
t = ts.get();
break;
case '/':
{
//double d = primary();
double d = factorial();
if (d == 0) error("divide by zero");
left /= d;
t = ts.get();
break;
}
case 'x':
error("x");
break;
default:
ts.putback(t); // put t back into the token stream
return left;
}
}
}
double primary()
{
Token t = ts.get();
switch (t.kind) {
case '(':
{
double d = expression();
t = ts.get();
if (t.kind != ')') error("expected ')'");
return d;
}
case '{':
{
double d = expression();
t = ts.get();
if (t.kind != '}') error("expected '}'");
return d;
}
case number:
return t.value;
case '-':
return - primary();
case '+':
return primary();
case name:
return get_value(t.name);
default:
error("primary expected");
}
}
double func(const char func_kind)
{
Token t {ts.get()};
if (t.kind != '(')
error("function expects a '(' as opening");
switch (func_kind) {
case sqrt_kind:
{
ts.unget(t);
double d {expression()};
if (d < 0)
error("negative value for sqrt()");
return sqrt(d);
}
case power_kind:
{
double d1 {expression()};
t = ts.get();
if (t.kind != ',')
error("',' expected");
double d2 {expression()};
return pow(d1, d2);
}
default:
return func(func_kind);
}
}
// deal with numbers and parentheses
double primary()
{
Token t = ts.get();
switch (t.kind) {
case '(': // handle '(' expression ')'
{
double d = expression();
t = ts.get();
if (t.kind != ')') error("')' expected");
Token next = ts.get();
if(next.kind != '!'){
ts.putback(next);
return d; // return the number's value
}
else
return get_factorical(int(d));
}
case '8': // we use '8' to represent a number
{
Token next = ts.get();
if(next.kind != '!'){
ts.putback(next);
return t.value; // return the number's value
}
else
return get_factorical(int(t.value));
}
default:
error("primary expected");
}
}
double factorial()
//find and calculate factorials
{
double left = primary();
Token t = ts.get();
while(true) {
switch(t.kind) {
case '!':
{
if (left == 0)
left = 1; //By def. of factorial
else {
int n = (int)left;
int ans = n;
for(int i = 1; i < n; i++)
ans = ans * (n - i);
left = ans;
t = ts.get();
}
break;
}
default:
ts.putback(t);
return left; //no more '!'
}//end switch
}//end while
}
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) error("divide by zero");
left /= d;
t = ts.get();
break;
}
case '%':
{
double d = primary();
int i1 = int(left);
if(i1 != left) error("left-hand operand of % not int");
int i2 = int(d);
if(i2 != d) error("right-hand operand of % not int");
if(i2 == 0) error("%: divide by zero");
left = i1 % i2;
t = ts.get();
break;
}
default:
ts.putback(t);
return left;
}
}
}
double declaration(bool is_const)
//Handle 'name = expression'
//Declare a variable called "name" with initial value "expresion"
{
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();
switch (is_const) {
case true:
symtable.declare(var_name, d, true);
break;
default:
if (symtable.is_declared(var_name))
symtable.set(var_name, d);
else
symtable.declare(var_name, d, false);
}
return d;
}
void calculate() // Performs calculations
{
while(true) try {
cout << prompt; // Output '>' symbol
Token t = ts.get(); // Get a new character
if (t.kind == help) { // If help was entered open help menu
cout << "Welcome to Awesome Calculator " << version << " ! Here is the list of the commands:\n"
"Available operators are '+','-','/','*'. The program is able to work with floating-point numbers\n"
"'Expression' + ';' - Prints the result (always use it at the end of the statement)\n"
"'let' + 'name of variable' + '='' + 'value' - defines a variable\n"
"'const' + 'name of constant' + '='' + 'value' - defines a constant\n"
"'name of variable' + '=' + 'new value' - assigns a new value to the variable\n"
"'pow(x,y)' - multiplies x by y times (y must be of type int)\n"
"'sqrt(x)' - returns square root of x\n"
"'h' or 'help' - opens this menu\n"
"'quit' - closes the program\n";
continue; // Move to next iteration
}
while (t.kind == print) t=ts.get(); // Read all ';'
if (t.kind == quit) return; // Close the program if exit was entered
ts.unget(t); // Return a character into the stream
cout << result << statement() << endl; // Output the result
}
catch(runtime_error& e) {
cerr << e.what() << endl; // Cout the error if the exception was thrown
clean_up_mess(); // Ignores all characters till the ';'
}
}
double term()
{
double left = factTerm();
Token t = ts.get();
while(true)
{
switch(t.kind)
{
case '*':
left *= factTerm();
t = ts.get();
break;
case '/':
{
double right = factTerm();
if(right == 0)
error("Division by 0 error");
left /= right;
t = ts.get();
}
break;
default:
ts.putback(t);
return left;
}
}
}
/* Term
Primary
Term '*' Primary
Term '/' Primary
Term '%' Primary
*/
double term()
{
double left = primary();
Token t = ts.get();
while (true) {
switch (t.kind) {
case '*':
left *= primary();
t = ts.get();
break;
case '/':
{ // to define a variable in case, need { }
double d = primary();
if (d == 0) error("divide by zero");
left /= d;
t = ts.get();
break;
}
// case '%':
// left %= primary();
// t = ts.get();
// break;
default:
ts.putback(t);
return left;
}
}
}
double calculateLoop()
{
double result = 0;
cout << "> ";
while (cin)
{
try
{
Token t = ts.get();
if(t.kind == QUIT)
break;
if(t.kind == PRINT) {
cout << "= " << result << endl << "> ";
while(t.kind == PRINT)
t = ts.get();
ts.putback(t);
continue;
}
ts.putback(t);
result = statement();
}
catch(exception &ex)
{
cerr << ex.what() << endl;
clean_up_mess();
cout << "> ";
}
}
return result;
}
// deal with *, /, and %
double term()
{
double left = primary();
Token t = ts.get(); // get the next token from token stream
while(true) {
switch (t.kind) {
case '*':
left *= primary();
t = ts.get();
break;
case '/':
{
double d = primary();
if (d == 0) error("divide by zero");
left /= d;
t = ts.get();
break;
}
case '%':
{
int i1 = narrow_cast<int>(left);
int i2 = narrow_cast<int>(term());
if (i2 == 0) error("%: divide by zero");
left = i1%i2;
t = ts.get();
break;
}
default:
ts.putback(t); // put t back into the token stream
return left;
}
}
}
static double expression(Token_stream& ts)
{
double left=term(ts);
Token t=ts.get();
double rez;
bool isdone=false;
do {
switch(t.kind){
case '+':
left+=term(ts);
t=ts.get();
break;
case '-':
left-=term(ts);
t=ts.get();
break;
default:
ts.putback(t);
isdone=true;
rez= left;
}
}while (!isdone);
return rez;
}