Rewrite. Simplified code (WIP).

Fixed some issues but created others. See Issues section in source.

Author: fsaadatmand

chapter04/4-6.c

@@ -2,6 +2,15 @@
  * Exercise 4-6. Add commands for handling variables. (it's easy to provide
  * twenty-six variables with single-letter names). Add a variable for most
  * recently printed value.
+ * Issues: 
+ * 	1.	Variables are initialized to zero by default. Therefore, if a user
+ * 		calls an unset variable, it will return a value 0. For example, the
+ * 		result of "2 x$ *" is 0, if x is unset.  
+ * 	2.	If a variable is entered without the fetch operator "$", it will be
+ * 		ignored. For example, "2 x *" is be evaluated as "2 *".
+ * 	3.	If the call operator is used on an invalid variable, it will be ignored.
+ * 	4.	Ambiguity, 4 x = and x 4 = will assign 4 to x. This makes 4 x 5 y = will
+ *		ambiguous becasue it assigns 5 to x and y.
  * Faisal Saadatmand
  */
 
@@ -11,27 +20,28 @@
 #include <string.h>          /* for strcmp() */
 #include <math.h>            /* for math commands */
 
-#define MAXOP   100          /* max size of operand or operator */
-#define NUMBER  '0'          /* signal that a number was found */
-#define MATH    '1'          /* signal that an operation was found */
-#define MAXVAL  100          /* maximum depth of val stack */
-#define BUFSIZE 100
-#define MAXVAR  26
-#define TOP     val[sp - 1]  /* top element in stack */
+#define MAXOP    100          /* max size of operand or operator */
+#define NUMBER   '0'          /* signal that a number was found */
+#define COMMAND  '1'          /* signal that a string command was found */
+#define VARIABLE '2'          /* signal that variable was found */
+#define MAXVAL   100          /* maximum depth of val stack */
+#define BUFSIZE  100
+#define MAXVAR   26
+#define TOP      val[sp - 1]  /* top element in stack */
 
 /* functions */
 int    getop(char []);
 void   push(double);
 double pop(void);
 int    getch(void);
 void   ungetch(int);
-void   printTop(void);
+void   printTOP(void);
 void   duplicateTop(void);
 void   swapTopTwo(void);
 void   clearStack(void);
 int    mathfunction(char []);
-void   storeVariable(void);
-void   fetchVariable(void);
+void   storeValue(char);
+void   fetchValue(char);
 void   clearMemory(void);
 
 /* globals */
@@ -40,9 +50,9 @@ double val[MAXVAL];          /* value stack */
 double mem[MAXVAR];          /* variables values */
 char   buf[BUFSIZE];         /* buffer from ungetch */
 int    bufp;                 /* next free position in buf */
-int    stackcmd;             /* stack commands flag */
-char   variable;             /* current input variable */ 
-double lastPrint;            /* last printed value */
+int    peak;                 /* flag: peak at top of the stack */
+int    variable;             /* current input variable */ 
+double printed;              /* last printed value */
 
 /* push: push f onto value stack */
 void push(double f)
@@ -74,27 +84,27 @@ int getop(char s[])
 	s[1] = '\0';
 
 	i = 0;
-	if (c == '-')            /* check sign */
+	if (c == '-')                      /* check sign */
 		if (!isdigit(s[++i] = c = getch())) {
 			ungetch(c);                    
-			c = s[0];        /* not a sign */
+			c = s[0];                  /* not a sign */
 		}
 
-	if (isalpha(c)) {        /*  math functions */
+	if (isalpha(c)) {                  /* string command */
 		while (isalpha(s[++i] = c = getch()))
 			;
 		s[i] = '\0';
 		ungetch(c);
-		return MATH;
+		return (strlen(s) == 1) ? VARIABLE : COMMAND;
 	}
 
 	if (!isdigit(c) && c != '.')
-		return c;            /* not a number */
+		return c;                      /* not a number */
 
 	if (isdigit(c))
 		while (isdigit(s[++i] = c = getch()))
 			;
-	if( c == '.')            /* collect fraction part */
+	if( c == '.')                      /* collect fraction part */
 		while (isdigit(s[++i] = c = getch()))
 			;
 	s[i] = '\0';
@@ -119,98 +129,91 @@ void ungetch(int c)
 		buf[bufp++] = c;
 }
 
-/* printTop: prints the top element in the stack */
-void printTop(void)
+/* printTOP: print top of the stack without pop */
+void printTOP()
 {
-	if (sp > 0) {
-		printf("\t%.8g\n", TOP);
-		stackcmd = 1;
-	}
+	if (sp < 1)
+		printf("stack empty\n");
+	printf("\t%.8g\n", TOP);
 }
 
-/* deleteTop: deletes the top element in the stack */
+/* duplicateTop: duplicate the top element in the stack */
 void duplicateTop(void)
 {
-	if (sp > 0) {
-		push(TOP);
-		printTop();
-	}
+	double top;
+
+	if (sp < 1)
+		return;
+	push(top = pop());
+	push(top);
 }
 
 /* swapTopTwo: swaps top two elements */
  void swapTopTwo(void)
  {
 	 double top1, top2;
 
-	 if (sp > 1) {
-		 top1 = pop();
-		 top2 = pop();
-		 push(top1);
-		 push(top2);
-		 printTop();
+	 if (sp < 2) {
+		 if (sp == 1)
+			 printf("error: 1 element in stack\n");
+		 return;
 	 }
+	 top1 = pop();
+	 top2 = pop();
+	 push(top1);
+	 push(top2);
 }
 
 /* clear: clears the entire stack */
 void clearStack(void)
 {
-	while (sp > 0)
+	while (sp > 1)
 		pop();
-	printTop();
 }
 
-/* mathf: call the appropriate math function according to value of s */
+/* mathfunction: call the appropriate math function according to value of s,
+ * return 1 on success 0 on failure. */
 int mathfunction(char s[])
 {
 	double op2;
 
-	if (strcmp(s, "sin") == 0)
+	if (!strcmp(s, "sin"))
 		push(sin(pop()));
-	else if (strcmp(s, "cos") == 0)
+	else if (!strcmp(s, "cos"))
 		push(cos(pop()));
-	else if (strcmp(s, "exp") == 0)
+	else if (!strcmp(s, "exp"))
 		push(exp(pop()));
-	else if (strcmp(s, "sqrt") == 0)
+	else if (!strcmp(s, "sqrt"))
 		push(sqrt(pop()));
-	else if (strcmp(s, "pow") == 0) {
+	else if (!strcmp(s, "pow")) {
 		op2 = pop();
 		push(pow(pop(), op2));
 	} else
 		return 0;
 	return 1;
 }
 
-/* storeVariable: stores the value of a variable (a to z) to the corrosponding
- * memory location in mem */
-void storeVariable(void)
+/* storeValue: store value of a var (a to z) to the corresponding
+ * location in mem and push back to top of stack */
+void storeValue(char var)
 {
-	pop();                             /* pop stored value by fetchVariable */
-	variable = tolower(variable);
-	mem[variable - 'a'] = pop();       /* variable value - top of the stack */
-	stackcmd = 1;                      /* skip pop print */
+	push(mem[var - 'a'] = pop());
 }
 
-/* fetchVariable: fetches variable value from memory and pushes to the top of
- * the stack */
-void fetchVariable(void)
+/* fetchValue: fetch value var from mem and push on to value stack */
+void fetchValue(char var)
 {
-	if (variable == 'R')
-		push(lastPrint);
-	else {
-		variable = tolower(variable);
-		push(mem[variable - 'a']);
-	}
+	push(mem[var - 'a']);
 }
 
-/* clearMemory: initializes values of mem to 0 */
+/* clearMemory: set values of mem to 0 */
 void clearMemory(void)
 {
 	int i;
 
 	for (i = 0; i <= MAXVAR; ++i)
 		mem[i] = 0;
 	printf("memory cleared\n");
-	stackcmd = 1;                      /* skip pop print */
 }
 
 /* reverse Polish Calculator */
@@ -250,7 +253,7 @@ int main(void)
 				printf("error: zero divisor\n");
 			break;
 		case '!':
-			printTop();
+			peak = 1;
 			break;
 		case '#':
 			duplicateTop();
@@ -262,22 +265,43 @@ int main(void)
 			clearStack();
 			break;
 		case '=':
-			storeVariable();
+			if (isalpha(variable))     /* check if variable is valid */
+				storeValue(variable);
+			variable = 0;
+			break;
+		case '$':
+			if (isalpha(variable))     /* check if variable is valid */
+				fetchValue(variable);
+			variable = 0;
 			break;
 		case '\n':
-			if (!stackcmd)
-				printf("\t%.8g\n", lastPrint = pop());
-			stackcmd = 0;
+			if (peak) {
+				printTOP();
+				peak = 0;
+			} else
+				printf("\t%.8g\n", printed = pop());
+
+			if (variable) {
+				printf("usage: %c$\n", variable);
+				variable = 0;
+			}
 			break;
-		case MATH:
-			if (strlen(s) == 1) {
-				variable = s[0];
-				fetchVariable();
-			} else if (strcmp(s, "mc") == 0)
-				clearMemory();
-			else if (!mathfunction(s))
-				printf("error: unknown command %s\n", s);
+		case VARIABLE:
+			variable = tolower(s[0]);
 			break;
+		case COMMAND:
+			if (!strcmp(s, "lp")) {
+				push(printed);
+				break;
+			}
+			if (!strcmp(s, "mc")) {
+				clearMemory();
+				peak = 1;
+				break;
+			}
+			if (mathfunction(s))
+				break;
+			/* fall through */
 		default:
 			printf("error: unknown command %s\n", s);
 			break;