Videos
Interpreter:
- Interpreter executes each statement of a program at a time.
- It calls recursive functions for “statement”, “expression”, “factor”, “term” and “Identifier” to execute a statement.
- It allows arithmetic operations addition, subtraction, multiplication, division and exponentiation.
/***********************************************************
* This program extends the interpreter with exponentiation *
* process. *
***********************************************************/
Explanation of Solution
//interpreter.h
//Include header files
#ifndef INTERPRETER
#define INTERPRETER
#include <iostream>
#include <list>
#include <algorithm> // find
using namespace std;
//Definition of class IdNode
class IdNode
{
//Declare public methods
public:
//Declare Parameterized constructor
IdNode(char *s = "", double e = 0)
{
//Initialize variables
id = strdup(s);
value = e;
}
//Function to overload operator ==
bool operator== (const IdNode& node) const
{
/*Return true if both string are same, otherwise return false*/
return strcmp(id,node.id)==0;
}
//Declare private variables and overloading function
private:
//Declare variables
char *id;
double value;
//Declare class object
friend class Statement;
//Prototype for overloading function
friend ostream& operator<<(ostream&, const IdNode&);
};
//Definition of class Statement
class Statement
{
//Declare public functions
public :
//Constructor
Statement(){}
//Declare function getStatement()
void getStatement();
//Declare private variables
private:
//Declare variables
list<IdNode>idList;
char ch;
//Function prototypes
double factor();
double term();
double expression();
double exponent();
void readId(char*);
//Declare function to print error message
void issueError(char* s)
{
cerr << s << endl; exit(1);
}
//Function prototypes
double findValue(char*);
void processNode(char*, double);
friend ostream& operator<< (ostream&, const Statement&);
};
#endif
//interpreter.cpp
//Include header files
#include <cctype>
#include <stdio.h>
#include <string.h>
#include <string>
#include <list>
#include "interpreter.h"
//Function to find value of identifier
double Statement::findValue(char *id)
{
//Create object of class IdNode for id
IdNode tmp(id);
/*If identifier is present in IdNode list, return position */
list<IdNode>::iterator i = find(idList.begin(),idList.end(),tmp);
//If position is not end of list
if (i != idList.end())
//Return value of identifier
return i->value;
//Otherwise
else
//Print error message
issueError("Unknown variable");
// This statement will never be reached;
return 0;
}
//Function to process node
void Statement::processNode(char* id,double e)
{
/*Create object of class for IdNode for statement*/
IdNode tmp(id,e);
//If identifier is present in IdNode list find position of identifier
list<IdNode>::iterator i = find(idList.begin(),idList.end(),tmp);
//If position of identifier is not end of IdNode list
if (i != idList.end())
//Set value of identifier as value of expression
i->value = e;
//Otherwise
else
//Insert New value into list
idList.push_front(tmp);
}
/* readId() reads strings of letters and digits that start with a letter, and stores them in array passed to it as an actual parameter.*/
/* Examples of identifiers are: var1, x, pqr123xyz, aName, etc.*/
//Function to read identifier
void Statement::readId(char *id)
{
//Initialize variable i as 0
int i = 0;
//If ch is space
if (isspace(ch))
//Skip balks and read next character
cin >> ch;
//If character is alphabet
if (isalpha(ch))
{
//Read character till read a non-alphanumeric
while (isalnum(ch))
{
//Copy each character to identifier
id[i++] = ch;
//Read next character
cin.get(ch);
}
//Set last character as end of string
id[i] = '\0';
}
//Otherwise
else
//Print error message
issueError("Identifier expected");
}
//Function to find exponent
double Statement::exponent()
{
// <exponent> ::= <factor> ^ <exponent>,
double f = factor();
//If ch is operatotr ^
if (ch == '^')
//Compute power and Return it
return pow(f,exponent());
//Otherwise
else
//Return f
return f;
}
//Function factor()
double Statement::factor()
{
//Declare variables
double var, minus = 1.0;
static char id[200];
//Read character
cin >> ch;
//If ch is operator + or -
while (ch == '+' || ch == '-')
{
// take all '+'s and '-'s.
//If ch is -
if (ch == '-')
/*Set value as negative by multiplying with -1*/
minus *= -1.0;
//Read next character
cin >> ch;
}
//If ch is digit or operator dot
if (isdigit(ch) || ch == '.')
{ // Factor can be a number
//Read digits of number
cin.putback(ch);
cin >> var >> ch;
}
//If ch is paranthesis (
else if (ch == '(')
{
// or a parenthesized expression,
//Get next expression after (
var = expression();
//If character is )
if (ch == ')')
//Read next character
cin >> ch;
//Otherwise
else
//Print error message
issueError("Right paren left out");
}
//Otherwise
else
{
//Read identifier
readId(id);
//If chracter is space
if (isspace(ch))
//Read next character
cin >> ch;
//Get value of identifier
var = findValue(id);
}
//Return value
return minus * var;
}
//Function for term()
double Statement::term()
{
//Call function exponent()
double f = exponent();
//Do calculation for operators * and /
while (true)
{
//Switch statement
switch (ch)
{
//If ch is *, multiply recursively
case '*' : f *= exponent(); break;
//If ch is *, divide recursively
case '/' : f /= exponent(); break;
//Defaultly return f
default : return f;
}
}
}
//Function for expression()
double Statement::expression()
{
//Call function term()
double t = term();
//Do calculation for operators + and -
while (true)
{
//Switch statement
switch (ch)
{
//If ch is +, add recursively
case '+' : t += term(); break;
//If ch is -, subtract recursively
case '-' : t -= term(); break;
// Return f
default : return t;
}
}
}
//Function to read statement
void Statement::getStatement()
{
//Declare variables
char id[20], command[20];
double e;
//Prompt and read statement
cout << "Enter a statement: ";
cin >> ch;
//Read identifier
readId(id);
//Copy identifier to string command
strupr(strcpy(command,id));
//If command is STATUS
if (strcmp(command,"STATUS") == 0)
//Print current values of all variables
cout << *this;
//If command is PRINT
else if (strcmp(command,"PRINT") == 0)
{
//Read identifier from user
readId(id);
//Get value of identifier and print it
cout << id << " = " << findValue(id) << endl;
}
//If command is END
else if (strcmp(command,"END") == 0)
//Retun from program
exit(0);
//Otherwise
else
{
//If ch is space
if (isspace(ch))
//Read next character
cin >> ch;
//If ch is =
if (ch == '=')
{
//Read expression
e = expression();
//If ch is not ;
if (ch != ';')
//print error message
issueError("There are some extras in the statement");
//Otherwise process statement
else processNode(id,e);
}
//Otherwise print error message
else issueError("'=' is missing");
}
}
/*Function to overload operator << to print values all identifiers in list*/
ostream& operator<< (ostream& out, const Statement& s)
{
//Initialize iterator
list<IdNode>::const_iterator i = s.idList.begin();
//For each identifier
for ( ; i != s.idList.end(); i++)
//Print value of identifier
out << *i;
//Print new line
out << endl;
return out;
}
/*Function to overload operator << to print value od identifier*/
ostream& operator<< (ostream& out, const IdNode& r)
{
//Print value of identifier
out << r.id << " = " << r.value << endl;
return out;
}
//useInterpreter.cpp
//Include header files
#include "interpreter.h"
using namespace std;
//Program begins with main()
int main()
{
//Declare object of class Statement
Statement statement;
//Prompt message
cout << "The program processes statements of the following format:\n"<< "\t<id> = <expr>;\n\tprint <id>\n\tstatus\n\tend\n\n";
// This infinite loop is broken by exit(1)
while (true)
// in getStatement() or upon finding an
statement.getStatement();
//Return 0
return 0;
}
Explanation:
- Define function “exponent()” as member of class “Statement”.
- In function “exponent()”,
- It calls function “factor()”
- If next character is “^” compute exponentiation by calling function itself recursively.
- Return result.
- Function “term()” calls function “exponent()” instead of “factor()”.
Output:
The program processes statements of the following format:
<id> = <expr>;
print <id>
status
end
Enter a statement: var1=2+(2^3);
Enter a statement: var2=var1-2;
Enter a statement: var3=var2*2;
Enter a statement: status
var3 = 16
var2 = 8
var1 = 10
Enter a statement: var3=var3-4;
Enter a statement: print var3
var3 = 12
Enter a statement: end
Want to see more full solutions like this?
Chapter 5 Solutions
EBK DATA STRUCTURES AND ALGORITHMS IN C
- Lee has discovered what he thinks is a clever recursive strategy for printing the elements in a sequence (string, tuple, or list). He reasons that he can get at the first element in a sequence using the 0 index, and he can obtain a sequence of the rest of the elements by slicing from index 1. This strategy is realized in a function that expects just the sequence as an argument. If the sequence is not empty, the first element in the sequence is printed and then a recursive call is executed. On each recursive call, the sequence argument is sliced using the range 1:. Here is Lee’s function definition: Write a program that tests this function and add code to trace the argument on each call. Does this function work as expected? If so, are there any hidden costs in running it?arrow_forwardGiven L = {w = {a, b}*: |w| is even}, the correct statements are: (aa U ab Uba U bb)* is a regular expression that generates L. (ab Uba)* is a regular expression that generates L. aa U ab U ba U bb is a regular expression that generates L. ab U ba is a regular expression that generates L.arrow_forwardImplement the following two functions that allow breaking a string into non-empty tokens using a given delimiter in c language . For example, ● For a string “abc-EFG-hi”, and a delimiter ‘-’ : the list of tokens is [“abc”, “EFG”, “hi”] ● For a string “abc-EFG---hi-”, and a delimiter ‘-’ : the list of tokens is [“abc”, “EFG”, “hi”] ● For a string “abc”, and a delimiter ‘ ’ : the list of tokens is [“abc”] ● For a string “++abc++”, and a delimiter ‘+’ : the list of tokens is [“abc”] That is, we break the string using the given delimiter, and the tokens are only the non-empty substrings.arrow_forward
- Implement the following two functions that allow breaking a string into non-empty tokens using a given delimiter in c language . For example, ● For a string “abc-EFG-hi”, and a delimiter ‘-’ : the list of tokens is [“abc”, “EFG”, “hi”] ● For a string “abc-EFG---hi-”, and a delimiter ‘-’ : the list of tokens is [“abc”, “EFG”, “hi”] ● For a string “abc”, and a delimiter ‘ ’ : the list of tokens is [“abc”] ● For a string “++abc++”, and a delimiter ‘+’ : the list of tokens is [“abc”] That is, we break the string using the given delimiter, and the tokens are only the non-empty substrings. The function count_tokens gets a string str, and a char delim, and returns the number of tokens in the string separated by delim. int count_tokens(const char* str, char delim); For example● count_tokens("abc-EFG--",'-')needstoreturn2. ● count_tokens("++a+b+c",'+')needstoreturn3.● count_tokens("***",'*')needstoreturn0.The function get_tokens gets a string str, and a char delim, and returns the…arrow_forwardNOTE: WRITE IN C# Write a distributed probability random number generator using one of the probability sampling methods (like rejection sampling). Explain the codes and the sampling implementation in detail. Example: İnputs : (3, 0.4) (5, 0.5) Output: Generated random number is 3, it has %40 probability Generated random number is 5, it has %50 probability NOTE: WRITE IN C# NOTE: MAKE A GENERIC SOLUTION THAT APPLIES FOR ANY GIVEN NUMBER AND PROBABILITY. NOT JUST BASED ON THIS EXAMPLE !!!arrow_forwardCode this in C program A set of integers 0..MAX may be implemented using an array of boolean values. This particular implementation is called a bit-vector implementation of a Set. Since C doesn’t have the Boolean data type, then substitute TRUE with 1 and FALSE with 0, or define 1 and 0 as TRUE and FALSE, respectively.For example, if the integer 3 is an element of the set, then the array element indexed by 3 is TRUE. On the other hand, if 3 is not an element, then the array element indexed by 3 is FALSE. For example: if s = {3,4,6,8}, the array looks like this: 0 1 2 3 4 5 6 7 8 9 FALSE FALSE FALSE TRUE TRUE FALSE TRUE FALSE TRUE FALSE Implement a programmer-defined data type called BitSet to represent a set as follows:typedef int BitSet[MAX];Implement the following functions:void initialize(BitSet s); - set all array elements to FALSEvoid add(int elem,BitSet s);- set the item indexed by elem to TRUEvoid display(BitSet s);- display the set on the screen using set notation,…arrow_forward
- Recursive Palindrome! Recall that a palindrome is a string that reads the same forward and backward. Write a recursive function is_palindrome (s:str) -> bool to check whether a string s is a palindrome. Here's a hint: think about how you can use is_palindrome(t), where t is a substring of s, to help you decide whether s is a palindrome. Your Answer: 1 # Put your answer here 2 Submitarrow_forwardPython Lee has discovered what he thinks is a clever recursive strategy for printing the elements in a sequence (string, tuple, or list). He reasons that he can get at the first element in a sequence using the 0 index, and he can obtain a sequence of the rest of the elements by slicing from index 1. This strategy is realized in a function that expects just the sequence as an argument. If the sequence is not empty, the first element in the sequence is printed and then a recursive call is executed. On each recursive call, the sequence argument is sliced using the range 1:. Here is Lee’s function definition: def printAll(seq): if seq: print(seq[0]) printAll(seq[1:]) Write a program that tests this function and add code to trace the argument on each call. Does this function work as expected? If so, are there any hidden costs in running it? how ???arrow_forwardPython Lee has discovered what he thinks is a clever recursive strategy for printing the elements in a sequence (string, tuple, or list). He reasons that he can get at the first element in a sequence using the 0 index, and he can obtain a sequence of the rest of the elements by slicing from index 1. This strategy is realized in a function that expects just the sequence as an argument. If the sequence is not empty, the first element in the sequence is printed and then a recursive call is executed. On each recursive call, the sequence argument is sliced using the range 1:. Here is Lee’s function definition: def printAll(seq): if seq: print(seq[0]) printAll(seq[1:]) Write a program that tests this function and add code to trace the argument on each call. Does this function work as expected? If so, are there any hidden costs in running it? its supposed to print something like thisarrow_forward
- Write an iterative function that determines the number of even elements in an array a of integers of size n. The function should return the number of elements that are even in array a of size n. Propose an appropriate prototype for your function and then write its code. Write a recursive function to solve the above problem. Propose an appropriate prototype for your function and then write its code.arrow_forwardWrite a recursive function for int powerOfTwo (int k). The function determines the value of 2k. (Note: k is a positive integer). Example, when k=0 the function returns 1 and when k-3 the function returns 8. To show that your code is correct, give the recursive trace for powerOfTwo (2) that returns 4.arrow_forwardDO NOT COPY ANSWER FROM ANOTHER QUESTION LEAVE IF you cannot do it perfectly. Otherwise, I will not only DOWN the vote but also REPORT you to the official Chegg team.I won't stop calling Chegg until they really pay attention to this trash behavior. Write a structurally recursive function (prefix->postfix exp) that takes as input an expression in the same little language as Problem 4. prefix->postfix returns an expression of the same form as its input, except that all function applications have been reversed. Finish this Racket code below to answer the question above.(define prefix->postfix(lambda (exp)))arrow_forward
Database System ConceptsComputer ScienceISBN:9780078022159Author:Abraham Silberschatz Professor, Henry F. Korth, S. SudarshanPublisher:McGraw-Hill Education
Starting Out with Python (4th Edition)Computer ScienceISBN:9780134444321Author:Tony GaddisPublisher:PEARSON
Digital Fundamentals (11th Edition)Computer ScienceISBN:9780132737968Author:Thomas L. FloydPublisher:PEARSON
C How to Program (8th Edition)Computer ScienceISBN:9780133976892Author:Paul J. Deitel, Harvey DeitelPublisher:PEARSON
Database Systems: Design, Implementation, & Manag...Computer ScienceISBN:9781337627900Author:Carlos Coronel, Steven MorrisPublisher:Cengage Learning
Programmable Logic ControllersComputer ScienceISBN:9780073373843Author:Frank D. PetruzellaPublisher:McGraw-Hill Education