Question

Your program must evaluate algebraic expressions over real numbers in Reverse Polish Notation (RPN). + (addition), - (subtraction), * (multiplication) and / (division) should be treated as arithmetic operations. Depending on the selection, numerical values must be entered and displayed in decimal, hexadecimal or binary form.

 

Example: The expression ((3+4) *(7+1.6-12) -5) / (3-8.7)

Will be calculated on your RPN calculator as 3 4 + 7 1.6 + 12 - * 5 - 3 8.7 - /

 

Your RPN computer's user interface should respond to the following keystrokes:

·         Numeric input: decimal digits "0...9", hexadecimal numeric symbols "a...f" and decimal point ".", sign "-", exponent identifier "E" (exponent in base 10)

·         Operators: +, -, *, /

·         Stack management: u (push), o (pop)

·         Changed the representation of numbers in the stack: D (decimal), H (hexadecimal), B (binary)

·         Exit program: "x" (exit)

 

Your RPN calculator should work as follows:

 

·                    Output of a permanent operating and display screen for the RPN calculator.

·                    Receiving any keyboard input in the input line, including numeric input, operand input, command input. Each entry must be completed with the ENTER key. In the example above, the following entries are required one after the other:

3 INPUT 4 INPUT + INPUT 7 INPUT 1.6 INPUT + INPUT 12 INPUT – INPUT …

·                    Saving entered values and calculation results in a stack.

·                    Output the current stack contents to the console. The last value entered into the stack should be displayed on the bottom line of the stack, the other values above in the order in which they were entered. After changing the contents of the stack, display fragments of the previous stack's contents should no longer be visible. Depending on the selected numeric representation, the following output is required in the stack rows:

-decimal (D): real values in proper floating-point representation, left-justified

-hexadecimal (H): integer value parts, two's complement, left justified

-binary(B): integer value components, absolute value right justified, sign left justified

·                    After entering an arithmetic operator, the arithmetic operation is performed. In particular, the arithmetic operator "-" changes the sign of the value on the stack if only one value is stored on the stack (unary operation).

·                    After typing push, the top value in the stack is pushed back onto the stack. If no value was stored on the stack when push was entered, the value 0 is pushed on the stack.

·                    After typing pop, the top value of the stack is removed.

·                    Unauthorized entries should be ignored.

·                    The stack depth must be entered as a program parameter through the console. It must be at least 3 and at most 8.

Answer 1

/*
 Dateiname : POOL2_005.c
 Programm  : UPN-Rechner für Grundrechenarten (dezimal, hexadezimal, binaer)
 Beispielhafte Musterlösung für Aufgabe 005 aus POOL2
 Eingaben  : Parametereingabe bei Programmaufruf Ã¼ber Konsole. Aufruf mit:
             ./POOL2_005 <StackTiefe>
 StackTiefe = 3 ... 8
 Ausgaben  : Rückgabewerte des Programms:
             0 falls Eingabeparameter OK
             -1 falls fehlerhafte oder unvollständige Eingabeparameter
 Autor     : 
 Version   : 01   vom   2012-12-14
 */

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "console.h"

#define SCOL   40  //linke Spalte zur Stackdarstellung auf Konsole
#define SLINE  10  //obere Zeile zur Stackdarstellung auf Konsole
#define ILINE  12  //Eingabezeile auf Konsole
#define ICOL   41  //linke Eingabespalte in Stackdarstellung auf Konsole
#define SWIDTH 32  //max. Breite der Anzeige fuer Stack
#define STACKLINE "[                                ]"  // leere Stackzeile
#define SDEPTH 8   //max. Tiefe der Anzeige fuer Stack


/*
 Funktion  : void ClearLine(int Line)
 Aufgabe   : Loescht die Stackzeile Line auf dem Bildschirm
 Eingaben  : Line = Zeilenindex der zu loeschenden Zeile 
             (oberste Bildschirmzeile: Line=0)
 Ausgaben  : keine
 Autor     : Kreiser
 Version   : 01
 Datum der letzten Ã„nderung: 2012-12-14
 */
void ClearLine(int Line){
	CURPOS(Line, SCOL); CURCLR2EOL;
	CURPOS(Line, SCOL); printf("[                                ]");
	CURPOS(Line, ICOL);
}

/*
 Funktion  : void PrintStack(double* Stack, int StackTiefe, int StackIndex, 
                            char CalcMode)
 Aufgabe   : Gibt den gesamten Stack auf dem Bildschirm aus
 Eingaben  : Stack = Zeiger auf den Stack (Vektor mit double-Werten)
             StackTiefe = Groesse des Stacks (Anzahl der Speicherstellen)
             StackIndex = Index der letzten belegten Speicherstelle im Stack
             CalcMode = 'D' (dezimal), 'H' (hexadezimal), 'B' (binaer)
 Ausgaben  : keine
 Autor     : Kreiser
 Version   : 01
 Datum der letzten Ã„nderung: 2012-12-14
 */
void PrintStack(double* Stack, int StackTiefe, int StackIndex, char CalcMode){
    
}

/*
 Funktion  : void Bildschirmmaske(int StackTiefe)
 Aufgabe   : Zeigt den Bildschirm des UPN-Rechners an
 Eingaben  : StackTiefe = Groesse des Stacks (Anzahl der Speicherstellen)
 Ausgaben  : keine
 Autor     : Kreiser
 Version   : 01
 Datum der letzten Ã„nderung: 2012-12-14
 */
void Bildschirmmaske(int StackTiefe){
	int j;
	int i=3;  //Zeilenposition fuer Stackdarstellung auf Console
    CLS;
	CURPOS(1,   1); printf("UPN-Rechner - (c) 2012-12 F07");
	CURPOS(2,   1); printf("-------------------------------------------------------------------------");
	CURPOS(i++, 1); printf("Programm verlassen               (x)");
	CURPOS(i++, 1); printf("Operatoren                 (+ - * /)");
	CURPOS(i++, 1); printf("Ziffern          (01234567890abcdef)");
	CURPOS(i++, 1); printf("Dezimalpunkt | Vorzeichen    (. | -)");
	CURPOS(i++, 1); printf("Exponentkennung                  (E)");
	CURPOS(i++, 1); printf("Stackoperationen Push | Pop  (u | o)");
	CURPOS(i++, 1); printf("Eingabe abschliessen         (ENTER)");
	CURPOS(i++, 1); printf("Binaermodus                      (B)");
	CURPOS(i++, 1); printf("Dezimalmodus                     (D)");
	CURPOS(i++, 1); printf("Hexadezimalmodus                 (H)");
    i=ILINE;
    // Darstellungsfeld fuer Eingaben, Breite 30 Zeichen + Klammern
    CURPOS(i--, SCOL); printf(STACKLINE);
	CURPOS(i--, SCOL); printf("----------------------------------");
	//X                     0123456789          0123456789          0123456789          0123456789
	//X                               0123456789          0123456789          0123456789
	for(j=0;j<StackTiefe;j++){
		CURPOS(i--, SCOL); printf(STACKLINE);
	}
	CURPOS(ILINE+1, 1); printf("-------------------------------------------------------------------------\n");
}

int main(int argc, char *argv[]){
	int Ausgabe=0;    // Rueckgabewert von main()
    
    return(Ausgabe);
}