Question

The second project involves completing and extending the C++ program that evaluates statements of an expression language contained in the module 3 case study. The statements of that expression language consist of an arithmetic expression followed by a list of assignments. Assignments are separated from the expression and each other by commas. A semicolon terminates the expression. The arithmetic expressions are fully parenthesized infix expressions containing integer literals and variables. The valid arithmetic operators are +, –, *, /. Tokens can be separated by any number of spaces. Variable names begin with an alphabetic character, followed by any number of alphanumeric characters. Variable names are case sensitive. This syntax is described by BNF and regular expressions in the case study. The program reads in the arithmetic expression and encodes the expression as a binary tree. After the expression has been read in, the variable assignments are read in and the variables and their values of the variables are placed into the symbol table. Finally the expression is evaluated recursively. Your first task is to complete the program provided by providing the three missing classes, Minus, Times and Divide. Next, you should extend the program so that it supports relational, logical and conditional expression operators as defined by the following extension to the grammar: -> '(' ')' | '(' ':' '?' ')' | '(' '!' ')' -> '+' | '-' | '*' | '/' | '>' | '<' | '=' | '&' | '|' Note that there are a few differences in the use of these operators compared to their customary use in the C family of languages. Their differences are:  In the conditional expression operator, the symbols are reversed and the third operand represents the condition. The first operand is the value when true and the second the value when false  The logical operators use single symbols not double, for example the and operator is & not &&  The negation operator ! is a postfix operator, not a prefix one  There are only three relational operators not the usual six and the operator for equality is = not == Like C and C++, any arithmetic expression can be interpreted as a logical value, taking 0 as false and anything else as true Your final task is to make the following two modifications to the program:  The program should accept input from a file, allowing for multiple expressions arranged one per line.

Answer 1

The required changes are program accepts input from a file and all results converts from double to int. I have made changes in module.cpp to read the input from the file and modifies double variables to int variables in all the file.

I have used stringstream to read the input from the file. If you have any doubts, please give comment.

module.cpp

#include <iostream>

#include <string>

#include <vector>

#include <fstream>

#include <sstream>

using namespace std;

#include "expression.h"

#include "subexpression.h"

#include "symboltable.h"

#include "parse.h"

//create an object of SymbolTable

SymbolTable symbolTable;

//prototype of the function

void parseAssignments(stringstream& in);

//define main function

int main()

{

       // declare the variables

       Expression* expression;

       char paren, comma;

       string line;

       // create an input file stream

       ifstream fin("input.txt");

       // check, if the file is not opened

       //then display a error message

       if (!fin.is_open())

              perror("error while opening file");

       //use a loop, to read the content from the file

       while (getline(fin, line))

       {

              symbolTable.init();

              if (!fin)

                     break;

              stringstream in(line, ios_base::in);

              in >> paren;

              cout << line << " ";

              expression = SubExpression::parse(in);

              in >> comma;

              //call the function

              parseAssignments(in);

              //Display the result

              int result = expression->evaluate();

              cout << "Value = " << result << endl;

       }

       system("pause");

       return 0;

}

//definition of the function parseAssignments()

void parseAssignments(stringstream& in)

{

    char assignop, delimiter;

    string variable;

    int value;

       symbolTable.init();

    do

    {

        variable = parseName(in);

        in >> ws >> assignop >> value >> delimiter;

        symbolTable.insert(variable, value);

    }

    while (delimiter == ',');

}

symboltable.h

//define the class SubExpression

class SymbolTable

{

public:

       //constructor

       SymbolTable() {}

       //declare the function

       void insert(string variable, int value);

       int lookUp(string variable) const;

       void init();

private:

       //define the structure Symbol

       struct Symbol

       {

              Symbol(string variable, int value)

              {

                     this->variable = variable;

                     this->value = value;

              }

              string variable;

              int value;

       };

       //create a vector of type Symbol

       vector <Symbol> elements;

};

symboltable.cpp

#include <string>

#include <vector>

using namespace std;

#include "symboltable.h"

//definition of the function insert()

void SymbolTable::insert(string variable, int value)

{

       //push the symbol in to the vector

       const Symbol& symbol = Symbol(variable, value);

       elements.push_back(symbol);

}

//definition of the function lookUp()

int SymbolTable::lookUp(string variable) const

{

       //search in the vector and return the value.

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

              if (elements[i].variable == variable)

                     return elements[i].value;

       return -1;

}

void SymbolTable::init()

{

       elements.clear();

}

subexpression.h

//define the class SubExpression subclass of the Expression

class SubExpression : public Expression

{

public:

       //constructor

       SubExpression(Expression* left, Expression* right);

       //declare a static function parse()

       static Expression* parse(stringstream& in);

protected:

       //declare the variables

       Expression* left;

       Expression* right;

};

subexpression.cpp

#include <iostream>

using namespace std;

#include "expression.h"

#include "subexpression.h"

#include "operand.h"

#include "plus.h"

#include "minus.h"

#include "times.h"

#include "divide.h"

#include <sstream>

//define the constructor

SubExpression::SubExpression(Expression* left, Expression* right)

{

       this->left = left;

       this->right = right;

}

//definition of the class parse()

Expression* SubExpression::parse(stringstream& in)

{

       Expression* left;

       Expression* right;

       char operation, paren;

       //read the Operand

       left = Operand::parse(in);

       //read the operation

       in >> operation;

       //read the Operand

       right = Operand::parse(in);

       //read the paren

       in >> paren;

       switch (operation)

       {

       case '+':

              return new Plus(left, right);

       case '-':

              return new Minus(left, right);

       case '*':

              return new Times(left, right);

       case '/':

              return new Divide(left, right);

       }

       system("pause");

       return 0;

}

parse.h

#include <iostream>

#include <string>

//declare a function parseName()

string parseName(stringstream &in);

parse.cpp

#include <cctype>

#include <iostream>

#include <string>

#include <sstream>

using namespace std;

#include "parse.h"

//definition of the function parseName()

string parseName(stringstream &in)

{

       char alnum;

       string name = "";

       in >> ws;

       while (isalnum(in.peek()))

       {

              in >> alnum;

              name += alnum;

       }

       return name;

}

operand.h

//define the class Operand subclass of the Expression

class Operand : public Expression

{

public:

       //declare a static function parse()

       static Expression* parse(stringstream& in);

};

operand.cpp

#include <cctype>

#include <iostream>

#include <list>

#include <string>

using namespace std;

#include "expression.h"

#include "subexpression.h"

#include "operand.h"

#include "variable.h"

#include "literal.h"

#include "parse.h"

#include <sstream>

//definition of the function parse()

Expression* Operand::parse(stringstream& in)

{

       char paren;

       double 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;

}

variable.h

#include <strstream>

#include <vector>

using namespace std;

//define the class Variable subclass of the Operand

class Variable : public Operand

{

public:

       //define the construtor

       Variable(string name)

       {

              this->name = name;

       }

       //define the function evaluate()

       int Variable::evaluate();

private:

       string name;

};

variable.cpp

#include <strstream>

#include <vector>

using namespace std;

#include "expression.h"

#include "operand.h"

#include "variable.h"

#include "symboltable.h"

//create an object of SymbolTable

extern SymbolTable symbolTable;

//definition of the function evaluate()

int Variable::evaluate()

{

       //return the name from the symbolTable

       return symbolTable.lookUp(name);

}

expression.h

//define the class Expression

class Expression

{

public:

       //declare a virtual function evaluate()

       virtual int evaluate() = 0;

};

plus.h

//define the class Plus subclass of the SubExpression

class Plus: public SubExpression

{

public:

       //define the default construtor

    Plus(Expression* left, Expression* right): SubExpression(left, right)

    {

    }

       //define the function evaluate()

    int evaluate()

    {

              //adds the value of left and value of the right

              //and return the value.

       return left->evaluate() + right->evaluate();

    }

};

minus.h

//define the class Minus subclass of the SubExpression

class Minus : public SubExpression

{

public:

       //define the default construtor

       Minus(Expression* left, Expression* right) : SubExpression(left, right)

       {

       }

       //define the function evaluate()

       int evaluate()

       {

              //subtract the value of right from the value of the left

              //and return the value.

              return left->evaluate() - right->evaluate();

       }

};

divide.h

//define the class Minus subclass of the SubExpression

class Divide : public SubExpression

{

public:

       //define the default construtor

       Divide(Expression* left, Expression* right) : SubExpression(left, right)

       {

       }

       //define the function evaluate()

       int evaluate()

       {

              //divide the value of left and value of the right

              //and return the value.

              return left->evaluate() / right->evaluate();

       }

};

literal.h

//define the class Literal subclass of the Operand

class Literal : public Operand

{

public:

       //define the construtor

       Literal(int value)

       {

              this->value = value;

       }

       //define the function evaluate()

       //returns the value

       int evaluate()

       {

              return value;

       }

private:

       int value;

};

times.h

//define the class Minus subclass of the SubExpression

class Times : public SubExpression

{

public:

       //define the default construtor

       Times(Expression* left, Expression* right) : SubExpression(left, right)

       {

       }

       //define the function evaluate()

       int evaluate()

       {

              //multiple the value of right and value of the left

              //and return the value.

              return left->evaluate() * right->evaluate();

       }

};

Sample input text file: input.txt

(x+y), x = 2, y= 6; /* Expect value = 8 */
(x-y), x=0, y=0; /* Expect value = 0 */
((x+y)/(x-y)), x=10, y=8; /* Expect value = 9 */
((x/y)/(x-y)), x=16, y=2; /* Expect value = 0 */
(x/y), x=25, y=5; /* Expect value = 5 */

Output screenshot: