22BCT0252

Vedh Bhattad

Code for Calculator:

st.l:
%{
#include <stdio.h>
#include <stdlib.h>
#include "st.tab.h"
extern int yylval;
%}
Num [0-9]+
AO [-+*/%]
PO [()]
%%
{AO} return *yytext;
{PO} return *yytext;
{Num} {yylval=atoi (yytext); return (Num);}
\n return *yytext;
%%

st.y:
%{
#include <stdio.h>
#include "st.tab.h"
int yylex();
void yyerror(char *s);
%}

%token Num

%%
S : E '\n' {printf("%d\n",$1);}
E : E '+' T {$$ = $1 + $3;}
| E '-' T {$$ = $1 - $3;}
| T {$$ = $1;}
T : T '*' F {$$ = $1 * $3;}
| T '/' F {$$ = $1 / $3;}
| T '%' F {$$ = $1 % $3;}
| F {$$ = $1;}
F : '(' E ')' {$$ = $2;}
| Num {$$ = $1;}
%%

int main(){
printf("Enter the expression: ");
yyparse();
 return 0;
}
int yywrap(){
return 1;
}
void yyerror(char *s){
fprintf(stderr,"%s\n",s);
}

Output:

Increment Decrement Code:

st.l:
%{
#include <stdio.h>
#include <stdlib.h>
#include "st.tab.h"
extern int yylval;
%}
Num [0-9]+
AO [-+*/%]
PO [()]
%%
{AO} return *yytext;
{PO} return *yytext;
{Num} {yylval=atoi (yytext); return (Num);}
\n return *yytext;
%%
st.y:
%{
#include <stdio.h>
#include "st.tab.h"
int yylex();
void yyerror(char *s);
%}

%token Num

%%
S : E '\n' {printf("%d\n",$1);}
E : T '+' '+' {$$ = $1 + 1;}
| '+' '+' T {$$ = $3+1;}
| '-' '-' T {$$ = $3-1;}
| T '-' '-' {$$ = $1 -1;}
T : F {$$ = $1;}
F : '(' E ')' {$$ = $2;}
| Num {$$ = $1;}
%%

int main(){
printf("Enter the expression: ");
yyparse();
return 0;
}
int yywrap(){
return 1;
}
void yyerror(char *s){
fprintf(stderr,"%s\n",s);
}
Output:

Predictive Parser Code:

#include <iostream>

#include <map>

#include <set>

#include <vector>

#include <string>

using namespace std;

map<char, set<char>> firstSet, followSet;

map<char, vector<string>> productions;

map<pair<char, char>, string> parsingTable;

void computeFirst(char nonTerminal) {

if (!firstSet[nonTerminal].empty()) return; // Already computed

for (const string &prod : productions[nonTerminal]) {

for (char symbol : prod) {

if (!isupper(symbol)) { // Terminal

firstSet[nonTerminal].insert(symbol);

break;

} else { // Non-terminal

computeFirst(symbol);

set<char> tempFirst = firstSet[symbol];

bool epsilonFound = tempFirst.erase('#'); // Remove epsilon from first of symbol

firstSet[nonTerminal].insert(tempFirst.begin(), tempFirst.end());

if (!epsilonFound) break;

void computeFollow(char nonTerminal) {

if (!followSet[nonTerminal].empty()) return; // Already computed

for (auto &entry : productions) {

char lhs = entry.first;

for (string &prod : entry.second) {

for (int i = 0; i < prod.size(); i++) {

if (prod[i] == nonTerminal) {

// If A -> αBβ, add FIRST(β) to FOLLOW(B)

bool allNullable = true;

for (int j = i + 1; j < prod.size(); j++) {

if (isupper(prod[j])) {

computeFirst(prod[j]);
set<char> tempFirst = firstSet[prod[j]];

bool epsilonFound = tempFirst.erase('#');

followSet[nonTerminal].insert(tempFirst.begin(), tempFirst.end());

if (!epsilonFound) {

allNullable = false;

break;

} else {

followSet[nonTerminal].insert(prod[j]);

allNullable = false;

break;

if (allNullable || i + 1 == prod.size()) { // A -> αB

computeFollow(lhs);

followSet[nonTerminal].insert(followSet[lhs].begin(), followSet[lhs].end());

void generateParsingTable() {

for (auto &entry : productions) {

char nonTerminal = entry.first;

for (string &prod : entry.second) {

set<char> firstOfProd;

for (char symbol : prod) {

if (!isupper(symbol)) { // Terminal

firstOfProd.insert(symbol);

break;

} else {

firstOfProd = firstSet[symbol];

bool epsilonFound = firstOfProd.erase('#');

if (!epsilonFound) break;

for (char term : firstOfProd) {

parsingTable[{nonTerminal, term}] = prod;

if (firstOfProd.count('#')) {

for (char term : followSet[nonTerminal]) {

parsingTable[{nonTerminal, term}] = prod;

int main() {

int numProductions;

cout << "Enter number of productions: ";

cin >> numProductions;

for (int i = 0; i < numProductions; i++) {

char nonTerminal;

string production;

cout << "Enter production (e.g., A->BC or A->a): ";

cin >> nonTerminal >> production;

production = production.substr(2); // Skip the "->"

productions[nonTerminal].push_back(production);

char startSymbol;

cout << "Enter start symbol: ";

cin >> startSymbol;

// Compute First sets

for (auto &entry : productions) {

computeFirst(entry.first);

// Compute Follow sets

followSet[startSymbol].insert('$'); // Add '$' to the follow of the start symbol

for (auto &entry : productions) {

computeFollow(entry.first);

// Generate Parsing Table

generateParsingTable();

// Output First sets

cout << "\nFirst Sets:\n";

for (auto &entry : firstSet) {

cout << entry.first << ": { ";

for (char symbol : entry.second) {

cout << symbol << " ";

cout << "}\n";

// Output Follow sets

cout << "\nFollow Sets:\n";

for (auto &entry : followSet) {

cout << entry.first << ": { ";

for (char symbol : entry.second) {

cout << symbol << " ";

cout << "}\n";

// Output Parsing Table

cout << "\nParsing Table:\n";

for (auto &entry : parsingTable) {

cout << "M[" << entry.first.first << ", " << entry.first.second << "] = " << entry.second << "\n";

return 0;

Output:
Code for typecheck:

#include <iostream>
#include <string>
#include <unordered_map>
#include <sstream>
#include <vector>
#include <algorithm>
using namespace std;

string getType(const unordered_map<string, string> &varTypes, const string &var)

{
if (varTypes.find(var) != varTypes.end())
{
return varTypes.at(var);
}
else
{
return "NOT DECLARED";
}
}
void parseDeclaration(unordered_map<string, string> &varTypes, const string &line)
{
istringstream iss(line);
string type, var;
iss >> type;
while (iss >> var)
{
if (var.back() == ';')
var.pop_back();
if (var.back() == ',')
var.pop_back();
varTypes[var] = type;
}
}

void checkType(const unordered_map<string, string> &varTypes, const string &lhs, const

vector<string> &rhsVars)
{
string lhsType = getType(varTypes, lhs);

for (const string &rhsVar : rhsVars)

{
string rhsType = getType(varTypes, rhsVar);

if (lhsType == rhsType)
{
cout << "Type of " << lhs << " and " << rhsVar << " -> MATCHED" << endl;
}
else if (lhsType == "NOT DECLARED" || rhsType == "NOT DECLARED")
{
if (lhsType == "NOT DECLARED")
cout << "Type of " << lhs << " -> NOT DECLARED" << endl;
if (rhsType == "NOT DECLARED")
cout << "Type of " << rhsVar << " -> NOT DECLARED" << endl;
}
else
{
cout << "Type of " << lhs << " and " << rhsVar << " -> NOT MATCHED" << endl;
}
}
}

vector<string> extractVariables(const string &rhs)

{
vector<string> vars;
string token;
string cleanedToken;
for (char ch : rhs)
{
if (isspace(ch) || ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == ';')
{
if (!cleanedToken.empty())
 {
vars.push_back(cleanedToken);
cleanedToken.clear();
}
}
else
{
cleanedToken += ch;
}
}
if (!cleanedToken.empty())
{
vars.push_back(cleanedToken);
}
return vars;
}

int main()
{
unordered_map<string, string> varTypes;
int n;
cout << "Enter number of lines of code: ";
cin >> n;
cin.ignore();

// Read the lines of code

for (int i = 0; i < n; i++)
{
string line;
getline(cin, line);

if (line.find("int") != string::npos || line.find("float") != string::npos || line.find("char") !=

string::npos)
{
parseDeclaration(varTypes, line);
}
else if (line.find('=') != string::npos)
{

size_t equalPos = line.find('=');

string lhs = line.substr(0, equalPos);
string rhs = line.substr(equalPos + 1);

lhs.erase(remove(lhs.begin(), lhs.end(), ' '), lhs.end());

vector<string> rhsVars = extractVariables(rhs);

checkType(varTypes, lhs, rhsVars);

}
}

return 0;
}

Ouput: