CS 2433 RPN P8

Problem: Write a program, named p8.cpp, that behaves in the manner describe in programming assignment 7, but which incorporates the changes listed below. This will include the creation of some .h header files to contain the definitions of some classes to be used in place of some of the features thus far implemented. This is the first step into more serious C++ programming.

• Create a file, named rpn8.h containing a class declaration and definition for the functionality that is the "calculator". Your p8.cpp program will contain your main() function and the code needed to include the rpn8.h file, read the command line arguments and suitably instantiate the rpn8 class and initiate processing of input from stdin.
  • As noted above, the class to be created is to be named rpn8 . This class and objects that are members of it will require a constructor (more than one, eventually) along with various instance member functions. Initially, beyond the constructor and a function named process , include a function getstacksize() to return the number of items on the stack.
  • The general operation of the program will be to use the main() in p8.cpp to interpret the command line arguments, to instantiate an rpn8 object, call that instantiated object (which will then read from stdin ) and, when the process function returns print the value returned and print the number of values remaining on the stack. (Note, output of the results is to be performed as in prior assignments.)
  • You may add any other functionality in terms of member functions you require. Data members must of course be provided, but unless otherwise stated the implementation of the internals (such as use of the stack8 class below) of the class are up to you.
• Create a file named stack 8.h containing the declaration and definition of a class named stack8 8 , which will be used in place of the struct -based stack implementation
  • You will need to instantiate the stack as an object, and the class must provide a constructor , push , pop and, getsize functions. Provide whatever other member functions you require to ensure proper operation of the stack.
  • You may, if you wish, implement the stack inside that stack8 object using a vector or other C++ container class object.

Naming: Your submitted file is to be named p p8 8 .c pp . This will be the last pure C program of the semester.

Output: Output requirements are unchanged from programming assignment 7. Thus, the following output requirements are unchanged.

Your program's normal output must be to stdout and of one of the formats following, assuming argc and argv are the usual parameters for main() and where < program_name> is argv[0] .

If argv[1] is "--help ", display the following.

Usage: < program_name>
"< program_name> --help"
display thi i s usage material.

"< program_name> -rpn" "
The program accepts input from standard input as a sequence
of numbers and operators. The numbers (operands, as
integers or floating point numbers) read are push ed on a
stack until needed. When an operator is read, the required
operands are popped from the stack and used to perform the
calculation, with the result placed on the stack. Valid
operators are +, -, * and /, are interpret ed as addition,
subtraction, m ultiplication and division, respectively, as
described below. An additional operator is =, which
indicates that the value at the top of the stack is popped
from the stack and displayed along with the number of
values remaining on the stack, whereupon the program
terminates.

Stack underflows generate an error message and halt the
program, as do a stack overflows. Unrecognized input
tokens produce error messages and result in program
termination, as do unrecognized command line arguments.
The size of the stack is 10.

Stack operations are performed so as to produce results
identically as indicated here.

+ : push(pop() + pop());
- : temp = pop(); push(pop() – – temp;
* : push(pop() * pop());
/ : temp = pop(); push(pop() / temp;
' : push(1.0 / pop());
~ : push(-pop());
** : temp = pop(); push(pow(pop(),temp));
swap : t1 = pop(); t2 = pop(); push(t1); push(t2);
copy : temp = pop(); push(temp); push(temp);
= : pop stack top and display it as the result with the number of stack element s remaining.
dump : display the contents of the calculator stack.
peek : display the top-of-stack value.
peek("< text>") : display the top-of-stack value following the specified text.
=< variable> : pop the value from the top of the stack and Assign that value to the name specified.
< variable> : push the value of the variable onto the stack.

Variable names must be alphanumeric, both upper-and lower-case permitted, and must start with an alphabetic character.

The above describes the majority of the behavior of the program you are to write. To reiterate and expand important points:

• If the first command-line argument is "--help", subsequent command-line arguments are ignored, the usage message is displayed and the program terminates.
• If the first command-line argument is "-rpn", subsequent command line arguments are ignored and the program proceeds with reading from standard input.
• Invalid/unrecognized command-line arguments produce a suitable error message, display the usage information above, and terminate the program.
• If an unrecognized token is read from standard input, a suitable error message for the type of error is to be displayed with the usage text and the program terminated.
• A malformed peek() operand is an error, and should be reported as such, and in the same manner as other error messages.
• If all inputs are recognized and no errors arise, print the following to stdout.

Result = < result popped from top of stack>.
< number of operands on the stack> values remain on the stack.

For all error conditions, print the required output to stderr.

Remember that any item delimited by angle brackets ("< >") is to be replaced with the appropriate information, without the angle brackets.