blob: 05d5c1b831904d5cb7b75e533846738476d430c2 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
/* The C Programming Language: 2nd Edition
*
* Exercise 4-3: Given the basic framework, it's straightforward to extend the
* calculator. Add the modulus (%) operator and provisions for negative
* numbers.
*
* Answer: Supporting modulus is indeed rather easy. The modulus operator
* divides the first operand by the second and returns the remainder, and C
* supports this out of the box, so there's no need to implement much math.
* Note that the modulus operator does integer division to get its remainder.
* Doing a "proper" modulus operator would require more work, and floats can
* be tricky. I might implement this sometime. For now, I typecasted.
*
* For negative numbers, you just need to make sure you allow the dash symbol
* in two key places.
*/
#define MAXOP 100
#define NUMBER '0'
#define MAXVAL 100
#define BUFSIZE 100
int getop(char []);
void push(double);
double pop(void);
int getch(void);
void ungetch(int);
int sp = 0; // Next free stack position
double val[MAXVAL]; // Value stack
char buf[BUFSIZE]; // buffer for ungetch
int bufp = 0; // next free position in buf
/* Reverse Polish calculator:
*
* Binary operations (+-*\%)
* operand operand operator
*
* Example: 6 minus 2 in Reverse Polish Notation is "6 2 -"
*/
int main() {
int type;
double op2;
char s[MAXOP];
while ((type = getop(s)) != EOF) {
switch (type) {
case NUMBER:
push(atof(s));
break;
case '+':
push(pop() + pop());
break;
case '*':
push(pop() * pop());
break;
case '-':
op2 = pop();
push(pop() - op2);
break;
case '/':
op2 = pop();
if (op2 != 0.0) {
push(pop() / op2);
} else {
printf("Error: Cannot divide by zero.\n");
}
break;
/* Yay for modulus! */
case '%':
op2 = pop();
if (op2 != 0.0) {
push((int)pop() % (int)op2);
} else {
printf("Error: Cannot modulo by zero.\n");
}
break;
case '\n':
printf("\t%.8g\n", pop());
break;
default:
printf("Error: Unknown command %s\n", s);
break;
}
}
return 0;
}
void push(double f) {
if (sp < MAXVAL) {
val[sp++] = f;
} else {
printf("Error: Stack full. Cannot push %g\n", f);
}
}
double pop(void) {
if (sp > 0) {
return val[--sp];
} else {
printf("Error: Stack empty.\n");
return 0.0;
}
}
int getop(char s[]) {
int i, c;
while ((s[0] = c = getch()) == ' ' || c == '\t') {
}
s[1] = '\0';
/* The final check is for negative numbers. */
if (!isdigit(c) && c != '.' && c != '-') {
return c;
}
i = 0;
/* The second half of this if-statement accounts for negatives */
if (isdigit(c) || (i == 0 && c == '-')) {
while (isdigit(s[++i] = c = getch())) {
}
}
if (c == '.') {
while (isdigit(s[++i] = c = getch())) {
}
}
s[i] = '\0';
if (c != EOF) {
ungetch(c);
}
return NUMBER;
}
int getch(void) {
return (bufp > 0) ? buf[--bufp] : getchar();
}
void ungetch(int c) {
if (bufp >= BUFSIZE) {
printf("ungetch: Too many characters.\n");
} else {
buf[bufp++] = c;
}
}
|
