1. #include <istream>
2. #include <cassert>
3. #include <cmath>
4. #include "complex.h"
5.  
6. // declarations
7. // ------------
8.  
9. // PRE: is = expression...
10. // POST: expression is extracted from is, and
11. //       its value is returned
12. Complex expression(std::istream& is);
13.  
14. // PRE: is = term...
15. // POST: term is extracted from is, and
16. //       its value is returned
17. Complex& term(std::istream& is);
18.  
19. // PRE: is = factor...
20. // POST: factor is extracted from is, and
21. //       its value is returned
22. Complex& factor(std::istream& is);
23.  
24. // definitions
25. // -----------
26.  
27. // POST: the first next character at the stream is returned (but not consumed)
28. char peek(std::istream& input) {
29.     if (input.eof()) {
30.         return 0;            // end of stream
31.     } else {
32.         return input.peek(); // next character in input
33.     }
34. }
35.  
36. // POST: leading whitespace characters are extracted
37. //       from is, and the first non-whitespace character
38. //       is returned (0 if there is no such character)
39. char lookahead(std::istream& is) {
40.     is >> std::ws;         // skip whitespaces
41.     if (is.eof()) {
42.         return 0;            // end of stream
43.     } else {
44.         return is.peek();    // next character in is
45.     }
46. }
47.  
48. // POST: if next character in is is ch, consume c and return
49. //       true, otherwise return false
50. bool consume(std::istream& is, char c) {
51.     if (lookahead(is) == c) {
52.         is >> c;
53.         return true;
54.     } else {
55.         return false;
56.     }
57. }
58.  
59. // POST: returns a complex number consumed from the stream
60. Complex number(std::istream& is) {
61.     Complex num;
62.     is >> num;
63.     return num;
64. }
65.  
66. // expression = term { "+" term | "-" term }
67. Complex expression(std::istream& is) {
68.     Complex value = term(is);        // term
69.     while (true) {
70.         if (consume(is, '+')) {
71.             value = value + term(is);          // "+" term
72.         } else if (consume(is, '-')) {
73.             value = value - term(is);          // "-" term
74.         } else {
75.             return value;
76.         }
77.     }
78. }
79.  
80. // term = factor { "*" factor | "/" factor }
81. Complex& term (std::istream& is) {
82.     Complex value = factor(is);        // factor
83.     while (true) {
84.         if (consume(is, '*')) {
85.             value = value * factor(is);          // "*" factor
86.         } else if (consume(is, '/')) {
87.             value = value / factor(is);          // "/" factor
88.         } else {
89.             return value;
90.         }
91.     }
92. }
93.  
94. // factor = unsigned_double | "(" expression ")" | -factor
95. Complex& factor (std::istream& is) {
96.     Complex value;
97.     if (consume(is, '(')) {  
98.         value = expression(is);      // "(" expression
99.         consume(is, ')');            // ")"
100.     } else if (consume(is, '-')) {
101.         value = -factor(is);         // - factor
102.     } else {
103.         value = number(is);          // unsigned_double
104.     }
105.     return value;
106. }
107.  
108. // POST: returns if from stream input a
109. //       valid evaluation could be consumed
110. // evaluation = expression "=".
111. Complex evaluation(std::istream& input) {
112.     Complex value = expression(input);
113.     assert(consume(input,'='));
114.     return value;
115. }
116.  
117. int main() {
118.     std::cout << "input expressions followed by '=' each\n";
119.     std::cout << evaluation(std::cin) << "\n";
120.     return 0;
121. }