LAB-7

Make a simple calculator. Consider the following grammar of simple expression, make a
working calculator.

Operators associativity
* /% multiply, divide, mod Left to right
+ - add, subtract Left to right

Step-1 You will write a top down recursive descent parser for simple expression. In a top down
recursive descent parser, you do two things:

1. Write a function for every non-terminal like for <expr>, <term>, <factor>
2. In each expression you follow the grammar rule for <expr> and you do two things:
a) For each non-terminal you call its corresponding function.
b) For each terminal you call the lexical analyzer and match the returned token with the Non
terminal in the grammar.
e.g. for the following grammar rule you would like to do the following;

<expr> → <expr> <opr1> <term> | <term>

Int expr()
{ expr(
);
opr1();
term();
}

But this will create an endless loop. So first rewrite the expression grammar. For top down
parser we can re-write the grammar in extended BNF as follows:
<expr> → <term> { <opr1> <term> }
<term> → <factor> {<opr2><factor>}
<factor> → INTEGER | (<expr>)
Now we can write: Thus, we can rewrite our expression rule as:
<expression> → <term> [<addop><term> ]
<term> → <factor> [mulop <factor>]
<factor> → NUM | (<expression>)
these rules can be used to write recursive functions.
Coding Considerations:
The code for corresponding function of an RD parser will be. This parser will only validate the
syntax of the given expression.
Int expr()
{
Int x; do { x = term(); // this will be called
at least once, token = get_next_token(); // and repeatedly if next
token is + or -
} while(token == Plus || token == Minus);
putbacktoken(); // if token is not + nor – then put back token

factor()
{ next_token(
);
switch(token)
case number :
break; case
id:
break;
case ‘(‘: {
expression();
next_token(); if( token != ‘)’ return( err); else return( success);
}
}

#include<iostream>
#include<conio.h>
#include <string>
#include <fstream>
using namespace std;
fstream AMINA;
enum tokentype {
A_PLUS_PLUS, A_EQUALSTO, A_plus, A_MINUS_MINUS, A_MINUS_EQUALS, A_MINUS,
A_MULTIPLY_EQUALS, A_MULTIPLY, A_DIVIDE_EQUALS, A_DIVIDE,
A_MOD_EQUALS, A_MOD, A_EQUALSTO_EQUALSTO, A_EQUAL, A_NOT_EQUALS,
A_NOT_EQUALS_TO, A_AND_AND, A_AND, A_OR_OR, A_OR, A_right_opening_bracket,
A_left_opening_bracket, A_right_round_bracket, A_left_round_bracket,
A_comma_op, A_semicolon, A_GREATER_OR_EQUALTO, A_input, A_GREATER_THAN,
A_LESS_OR_EQUALTO, A_output, A_LESS_THAN, A_num, A_if, A_elseif, A_int,
A_while, A_do, A_for, A_return, A_float, A_double, A_string, A_variable, A_NULL,
A_digit, A_Opr, A_CCB
};

struct AMINA_STRUCTURE
{
tokentype t;
string name = "";
int val = 0;
};
int maximum = 0;
string array1[10];
int insertsymboltable(string name)
{
int returnvalue;
int flag = 0;
for (int i = 0; i <= maximum; i++)
{
if (array1[i] == name)
{
flag = 0;
returnvalue = i;
return returnvalue;
}
else
{
flag = 1;
}
}
if (flag == 1)
{
array1[maximum] = name;
maximum++;
return maximum;
}
}

AMINA_STRUCTURE lexical()
{
AMINA_STRUCTURE A1;
char character = ' ';
//Check for operators
if (character == '+')
{
AMINA.get(character);
if (character == '+')
{
A1.t = A_PLUS_PLUS;
A1.name = "PLUS_PLUS";
A1.val;
return A1;
}
else if (character == '=')
{
A1.t = A_EQUALSTO;
A1.name = "A_EQUALSTO";
A1.val;
return A1;

}
 else
{
A1.t = A_plus;
A1.name = "A_plus";
A1.val;
return A1;

}
}
else if (character == '-')
{
AMINA.get(character);
if (character == '-')
{
A1.t = A_MINUS_MINUS;
A1.name = "A_MINUS_MINUS";
A1.val;
return A1;

}
else if (character == '=')
{
A1.t = A_MINUS_EQUALS;
A1.name = "A_MINUS_EQUALS";
A1.val;
return A1;

}
else
{
A1.t = A_MINUS;
A1.name = "A_MINUS";
A1.val;
return A1;

}
}
else if (character == '*')
{
AMINA.get(character);
if (character == '=')
{
A1.t = A_MULTIPLY_EQUALS;
A1.name = "A_MULTIPLY_EQUALS";
A1.val;
return A1;

}
else
{
A1.t = A_MULTIPLY;
A1.name = "A_MULTIPLY";
A1.val;
return A1;
 }
}
else if (character == '/')
{
AMINA.get(character);
if (character == '=')
{
A1.t = A_DIVIDE_EQUALS;
A1.name = "A_DIVIDE_EQUALS";
A1.val;
return A1;

}
else {
A1.t = A_DIVIDE;
A1.name = "A_DIVIDE";
A1.val;
return A1;

}
}
else if (character == '%')
{
AMINA.get(character);
if (character == '=')
{
A1.t = A_MOD_EQUALS;
A1.name = "A_MOD_EQUALS";
A1.val;
return A1;

}
else {
A1.t = A_MOD;
A1.name = "A_MOD";
A1.val;
return A1;

}
}
else if (character == '/')
{
AMINA.get(character);
if (character == '/')
{
while (character != '\n')
{
AMINA.get(character);
continue;
}

}
}
else if (character == '=')
{
AMINA.get(character);
 if (character == '=')
{
A1.t = A_EQUALSTO_EQUALSTO;
A1.name = "A_EQUALSTO_EQUALSTO";
A1.val;
return A1;

}
else {
A1.t = A_EQUAL;
A1.name = "A_EQUAL";
A1.val;
return A1;

}
}
else if (character == '!')
{
AMINA.get(character);
if (character == '=')
{
A1.t = A_NOT_EQUALS;
A1.name = "A_NOT_EQUALS";
A1.val;
return A1;

}
else {
A1.t = A_NOT_EQUALS_TO;
A1.name = " A_NOT_EQUALS_TO";
A1.val;
return A1;

}
}
else if (character == '&')
{
AMINA.get(character);
if (character == '&')
{
A1.t = A_AND_AND;
A1.name = "A_AND_AND";
A1.val;
return A1;

}
else {
A1.t = A_AND;
A1.name = "A_AND";
A1.val;
return A1;

}
}
else if (character == '|')
{
 AMINA.get(character);
if (character == '|')
{
A1.t = A_OR_OR;
A1.name = "A_OR_OR";
A1.val;
return A1;

}
else
{
A1.t = A_OR;
A1.name = "A_OR";
A1.val;
return A1;

}
}
else if (character == '{')
{

A1.t = A_right_opening_bracket;
A1.name = "A_right_opening_bracket";
A1.val;
return A1;

}
else if (character == '}')
{
A1.t = A_left_opening_bracket;
A1.name = "A_left_opening_bracket";
A1.val;
return A1;

}
else if (character == '(')
{
A1.t = A_right_round_bracket;
A1.name = "A_right_round_bracket";
A1.val;
return A1;

}
else if (character == ')')
{
A1.t = A_left_round_bracket;
A1.name = "A_left_round_bracket";
A1.val;
return A1;

}
else if (character == ',')
{
A1.t = A_comma_op;
 A1.name = "A_comma_op";
A1.val;
return A1;
}
else if (character == ';')
{
A1.t = A_semicolon;
A1.name = "A_semicolon";
A1.val;
return A1;

}
else if (character == '>')
{
AMINA.get(character);
if (character == '=')
{
A1.t = A_GREATER_OR_EQUALTO;
A1.name = "A_GREATER_OR_EQUALTO";
A1.val;
return A1;

}
else if (character == '>')
{
A1.t = A_input;
A1.name = "A_input";
A1.val;
return A1;

}
else
{
A1.t = A_GREATER_THAN;
A1.name = "A_GREATER_THAN ";
A1.val;
return A1;

}
}
else if (character == '<')
{
AMINA.get(character);
if (character == '=')
{
A1.t = A_LESS_OR_EQUALTO;
A1.name = "A_LESS_OR_EQUALTO";
A1.val;
return A1;

}
else if (character == '<')
{
A1.t = A_output;
A1.name = "A_output";
A1.val;
 return A1;

}
else
{
A1.t = A_LESS_THAN;
A1.name = "A_LESS_THAN";
A1.val;
return A1;

}
}
else if (isdigit(character))
{
string s;
do
{
s += character;
AMINA.get(character);
} while (isdigit(character));
AMINA.putback(character);
A1.t = A_num;
A1.name = "IS A NUMBER";
A1.val;
return A1;
}
else if (isalpha(character))
{
string s;
do
{
s += character;
AMINA.get(character);
} while (isalpha(character) || isdigit(character));
AMINA.putback(character);
if (s == "if")
{
A1.t = A_if;
A1.name = "..IF..";
A1.val;
return A1;

}
else if (s == "else if")
{
A1.t = A_elseif;
A1.name = "..ELSE_IF..";
A1.val;
return A1;

}
else if (s == "int")
{
A1.t = A_int;
A1.name = "..INT..";
A1.val;
 return A1;

}
else if (s == "while")
{
A1.t = A_while;
A1.name = "..WHILE..";
A1.val;
return A1;
}
else if (s == "do")
{
A1.t = A_do;
A1.name = "..DO..";
A1.val;
return A1;

}
else if (s == "return")
{
A1.t = A_return;
A1.name = "..RETURN..";
A1.val;
return A1;

}
else if (s == "for")
{
A1.t = A_for;
A1.name = "..FOR..";
A1.val;
return A1;

}
else if (s == "float")
{
A1.t = A_float;
A1.name = "..FLOAT..";
A1.val;
return A1;

}
else if (s == "double")
{
A1.t = A_double;
A1.name = "..DOUBLE..";
A1.val;
return A1;

}
else if (s == "string")
{
A1.t = A_string;
A1.name = "..STRING..";
A1.val;
return A1;
 }
else if (s == "variable")
{
A1.t = A_variable;
A1.name = "..variable..";
A1.val;
return A1;

}
else {
AMINA_STRUCTURE AM;
int val = insertsymboltable(s);
AM.t = A_variable;
AM.name = "A_variable,";
AM.val += val;
AM.val = NULL;
return AM;
}

}
}

bool AMINA_Z();
bool AMINA_K();
bool AMINA_U();

bool AMINA_Z()
{

AMINA_STRUCTURE b;

do
{
if (!AMINA_K())
{
return false;
}
AMINA_K();

b = lexical();

} while (b.t == A_plus || b.t == A_MINUS);

return true;

bool AMINA_K()
{
AMINA_STRUCTURE b;
 do
{
if (!AMINA_U())
{
return false;
}
AMINA_U();

b = lexical();

} while (b.t == A_MULTIPLY || b.t == A_DIVIDE);

return true;

bool AMINA_U()
{
AMINA_STRUCTURE c;
c = lexical();
if (c.t == A_variable)
{
return true;
}
else if (c.t == A_digit)
{
return true;
}
else if (c.t == A_Opr)
{
if (AMINA_Z())
{
c = lexical();
if (c.t == A_CCB)
{
return true;
}
}
}
}

int main()
{
AMINA.open("C:\\Users\\Student\\Desktop\\AMINA.txt");
if (!AMINA)
{
cout << "file does not exist";
}
else
{
char character;

while (!AMINA.eof())
{
AMINA.get(character);
if (AMINA.eof())
 {
break;
}
else if (character == ' ' || character == '\n' || character ==
'\t')
{
continue;
}
else
{
if (!AMINA.eof())
{
AMINA.putback(character);
}
AMINA_STRUCTURE A1;
A1 = lexical();
if (A1.t != A_NULL)
cout << A1.t << " " << A1.name << endl;
}
}
}
cout << "array is: " << endl;
for (int i = 0; i < maximum; i++)
{
cout << array1[i] << " " << i << endl;
}
system("pause");
return 0;
}