class UnaryExpression : public Expression {
public:
UnaryExpression(Expression* operand);
double evaluate();
private:
Expression* operand;
};

class BinaryExpression : public Expression {
public:
BinaryExpression(Expression* left, char op, Expression* right);
double evaluate();
private:
Expression* left;
Expression* right;
char op;
};

class TernaryExpression : public Expression {
public:
TernaryExpression(Expression* condition, Expression* trueExpr, Expression* falseExpr);
double evaluate();
private:
Expression* condition;
Expression* trueExpr;
Expression* falseExpr;
};

class QuaternaryExpression : public Expression {
public:
QuaternaryExpression(Expression* condition, Expression* negExpr, Expression* zeroExpr, Expression* posExpr);
double evaluate();
private:
Expression* condition;
Expression* negExpr;
Expression* zeroExpr;
Expression* posExpr;
};

header.cpp

#include
#include
#include
using namespace std;

#include "parse.h"

string parseName(stringstream& in) {
char alnum;
string name = "";

in >> ws;
while (isalnum(in.peek())) {
in >> alnum;
name += alnum;
}
return name;
}

literal.h

class Literal: public Operand {
public:
Literal(double value) {
this->value = value;
}
double evaluate() {
return value;
}
private:
double value;
};

main.cpp

public class main
{
public main()
{
// Include the new exception header
#include "symboltableerror.h"

// ...
void parseAssignments(stringstream& in) {
symbolTable.clear();

char assignop, delimiter;
string variable;
double value;
do {
variable = parseName(in);
in >> ws >> assignop >> value >> delimiter;
// Check for assignment to floating-point values
symbolTable.insert(variable, value);
} while (delimiter == ',');

// Check for uninitialized and multiply initialized variables
for (const auto& symbol : symbolTable.elements) {
if (symbolTable.lookUp(symbol.variable) == -1) {
throw SymbolTableError("Error: Variable '" + symbol.variable + "' not initialized");
}
}
}
minus.h

class Minus: public SubExpression {
public:
Minus(Expression* left, Expression* right): SubExpression(left, right) {
}
double evaluate() {
return left->evaluate() - right->evaluate();
}
};

operand.cpp

#include
#include
#include
#include
#include
using namespace std;

#include "expression.h"
#include "subexpression.h"
#include "operand.h"
#include "variable.h"
#include "literal.h"
#include "parse.h"

Expression* Operand::parse(stringstream& in) {
char paren;
double value;
in >> ws;
if (isdigit(in.peek()) || in.peek() == '.') {
in >> value;
return new Literal(value);
}
if (in.peek() == '(') {
in >> paren;
return SubExpression::parse(in);
} else {
string name = parseName(in);
return new Variable(name);
}
return 0;
}

operand.h

class Operand: public Expression {
public:
static Expression* parse(stringstream& in);
};
parse.cpp

public class parse
{
public parse()
{
// Add the implementation for the new functions (parseUnaryExpression, parseBinaryExpression, parseTernaryExpression, parseQuaternaryExpression)
Expression* parseUnaryExpression(stringstream& in) {
Expression* operand = SubExpression::parse(in);
return new UnaryExpression(operand);
}

Expression* parseBinaryExpression(stringstream& in) {
Expression* left = SubExpression::parse(in);
char op;
in >> op;
Expression* right = SubExpression::parse(in);

return new BinaryExpression(left, op, right);
}

Expression* parseTernaryExpression(stringstream& in) {
Expression* condition = SubExpression::parse(in);
in.ignore(1); // Ignore the '?'
Expression* trueExpr = SubExpression::parse(in);
in.ignore(1); // Ignore the second expression
Expression* falseExpr = SubExpression::parse(in);

return new TernaryExpression(condition, trueExpr, falseExpr);
}

Expression* parseQuaternaryExpression(stringstream& in) {
Expression* condition = SubExpression::parse(in);
in.ignore(1); // Ignore the '#'
Expression* negExpr = SubExpression::parse(in);
in.ignore(1); // Ignore the second expression
Expression* zeroExpr = SubExpression::parse(in);
in.ignore(1); // Ignore the third expression
Expression* posExpr = SubExpression::parse(in);

return new QuaternaryExpression(condition, negExpr, zeroExpr, posExpr);
}
}
}
}

parse.h

string parseName(stringstream& in);

// Update the regular expressions for variable and literal tokens
variable: [a-zA-Z][a-zA-Z0-9_]*
literal: ([0-9]+(\.[0-9]*)?|\.[0-9]+)

Expression* parseUnaryExpression(stringstream& in);
Expression* parseBinaryExpression(stringstream& in);
Expression* parseTernaryExpression(stringstream& in);
Expression* parseQuaternaryExpression(stringstream& in);

plus.h

class Plus: public SubExpression {
public:
Plus(Expression* left, Expression* right): SubExpression(left, right) {
}
double evaluate() {
return left->evaluate() + right->evaluate();
}
};

project2.cpp

#include
#include
#include
#include
#include
using namespace std;

#include "expression.h"
#include "subexpression.h"
#include "symboltable.h"
#include "parse.h"

SymbolTable symbolTable;

void parseAssignments(stringstream& in);

int main() {
const int SIZE = 256;
Expression* expression;
char paren, comma, line[SIZE];

ifstream fin;
fin = ifstream("input.txt");
if (!(fin.is_open())) {
cout << "File did not open" << endl;
system("pause");
return 1;
}
while (true) {
fin.getline(line, SIZE);
if (!fin)
break;
stringstream in(line, ios_base::in);
in >> paren;
cout << line << " ";
try {
expression = SubExpression::parse(in);
in >> comma;
parseAssignments(in);
double result = expression->evaluate();
cout << "Value = " << result << endl;
}
catch (string message) {
cout << message << endl;
}
}
system("pause");
return 0;
}

void parseAssignments(stringstream& in) {
char assignop, delimiter;
string variable;
int value;
do {
variable = parseName(in);
in >> ws >> assignop >> value >> delimiter;
symbolTable.insert(variable, value);
}
while (delimiter == ',');
}

subexpression.cpp

#include
#include
using namespace std;

#include "expression.h"
#include "subexpression.h"
#include "operand.h"
#include "plus.h"
#include "minus.h"

SubExpression::SubExpression(Expression* left, Expression* right) {
this->left = left;
this->right = right;
}

Expression* SubExpression::parse(stringstream& in) {
Expression* left;
Expression* right;
char operation, paren;

left = Operand::parse(in);
in >> operation;
right = Operand::parse(in);
in >> paren;
switch (operation) {
case '+':
return new Plus(left, right);
case '-':
return new Minus(left, right);
}
return 0;
}
subexpression.h

class SubExpression: public Expression {
public:
SubExpression(Expression* left, Expression* right);
static Expression* parse(stringstream& in);
protected:
Expression* left;
Expression* right;
};

symboltable.cpp

#include
#include
using namespace std;

#include "symboltable.h"

void SymbolTable::insert(string variable, double value) {
const Symbol& symbol = Symbol(variable, value);
elements.push_back(symbol);
}

double SymbolTable::lookUp(string variable) const {
for (int i = 0; i < elements.size(); i++)
if (elements[i].variable == variable)
return elements[i].value;
return -1;
}

void SymbolTable::clear() {
elements.clear();
}

symboltable.h

class SymbolTable {
public:
SymbolTable() {}
void insert(string variable, double value);
double lookUp(string variable) const;
void clear(); // Add this function to clear the symbol table
};
private:
struct Symbol {
Symbol(string variable, double value) {
this->variable = variable;
this->value = value;
}
string variable;
double value;
};
vector elements;
};
symboltableerror.h

#ifndef SYMBOLTABLEERROR_H
#define SYMBOLTABLEERROR_H

#include
#include

class SymbolTableError : public std::exception {
public:
SymbolTableError(const std::string& message) : message(message) {}
virtual const char* what() const noexcept override { return message.c_str(); }
private:
std::string message;
};

#endif // SYMBOLTABLEERROR_H

variable.cpp

#include
#include
using namespace std;

#include "expression.h"
#include "operand.h"
#include "variable.h"
#include "symboltable.h"

extern SymbolTable symbolTable;

double Variable::evaluate() {
return symbolTable.lookUp(name);
}

variable.h

class Variable: public Operand {
public:
Variable(string name) {
this->name = name;
}
double evaluate();
private:
string name;
};