Current C++ code- parse-h -- This file contains the function prototype (1).pdf

Current C++ code:
parse.h // This file contains the function prototype of the parseName function whose body is
defined in parse.cpp.
string parseName(stringstream& in);
parse.cpp // characters until the next whitespace and returns the name that those characters form.
#include #include #include using namespace std; #include "parse.h"
string parseName(stringstream& in) {
main.cpp
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
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 == ',');
}
char alnum;
string name = "";
in >> ws;
while (isalnum(in.peek()))
{ in >> alnum; name += alnum;
}
return name; }
operand.h

class Operand: public Expression {
public: static Expression* parse(stringstream& in);
};
operand.cpp
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; int value;
in >> ws;
if (isdigit(in.peek())) {
in >> value; Expression* literal = new Literal(value); return literal;
} if (in.peek() == '(') {
in >> paren; return SubExpression::parse(in);
} else
return new Variable(parseName(in)); return 0;
}
subexpression.h
class SubExpression: public Expression {
public: SubExpression(Expression* left, Expression* right);
static Expression* parse(stringstream& in);
protected: Expression* left; Expression* right;
};
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; }
plus.h
class Plus: public SubExpression {
public: Plus(Expression* left, Expression* right): SubExpression(left, right) { } double
evaluate() { return left->evaluate() + right->evaluate(); }
};
variable.h
class Variable: public Operand {
public: Variable(string name) { this->name = name; } double evaluate(); private: string name;
};
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);
}
minus.h

class Minus: public SubExpression {
public: Minus(Expression* left, Expression* right): SubExpression(left, right) { } double
evaluate() { return left->evaluate() - right->evaluate(); }
};
literal.h
class Literal: public Operand {
public: Literal(double value) { this->value = value; } double evaluate() { return value; } private:
double value; }; expression.h class Expression { public: virtual double evaluate() = 0;
};
symbolTable.h
class SymbolTable {
public: SymbolTable() {} void insert(string variable, double value); double lookUp(string
variable) const; private: struct Symbol { Symbol(string variable, double value) { this->variable =
variable; this->value = value; }
string variable; double value; };
vector elements;
};
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;
}

I need the following:
1. to modify the program so that it will parse additional types of expressions defined by the
expanded grammar shown below with the additions to the grammar in Bold :
statement expression ',' assignments ';'
expression '(' expressions ')'
expressions unary_expression | binary_expression | ternary_expression |
quaternary_expression
unary_expression expression '~'
binary_expression expression binary_operator expression
binary_operator '+' | '-' | '*' | '/' | '%' | '^' | '<' | '>' | '_'
ternary_expression expression '?' expression expression
quaternary_expression expression '#' expression expression expression
operand literal | variable | expression
assignments assignments ',' assignment | assignment
assignment variable '=' literal
Each new class must be in a separate .h and .cpp pair of files. If all the functions in a class are
one line functions, they can be implemented inline in .h file and the .cpp file can be omitted.
The semantics of the additional binary arithmetic operators are as follows: * Multiplication, /
Division, % Remainder, ^ Exponentiation.
Although two of the three additional binary operators are customarily relational operators in
most languages, that is not true in this language. The semantics of all three of those operators are
as follows: < Minimum (Evaluates to the minimum of the left and right operand) > Maximum
(Evaluates to the maximum of the left and right operand) & Average (Evaluates to the average of
the left and right operand) The single unary operator ~ is the negation operator. Unlike the unary
minus in most languages, it is a postfix operator rather than a prefix one. The single ternary
operator ? is the conditional expression operator. Unlike the conditional expression operator in
C++ and Java, no colon separates the second and third operands. This expression is evaluated as
follows. If the expression to the left of the operator ? is not 0, the value of the expression is the
value of the first expression after the operator ?. If it is 0, the value of the expression is the value
of the second expression after the operator ?. The single quaternary operator # is a variation of
the typical conditional expression operator. Like the ternary conditional expression operator, the

remaining three operands are delimited only by whitespace. This expression is evaluated as
follows. If the expression to the left of the operator # is less than 0, the value of the expression is
the value of the first expression after the operator #. If it is equal to 0, the value of the expression
is the value of the second expression after the operator #. If it is greater than 0, the value of the
expression is the value of the third expression after the operator #.

Current C++ code- parse-h -- This file contains the function prototype (1).pdf

Recommended

More Related Content

Similar to Current C++ code- parse-h -- This file contains the function prototype (1).pdf (20)

More from shyamsunder1211 (20)

Recently uploaded (20)

Current C++ code- parse-h -- This file contains the function prototype (1).pdf