看过《C＋＋程序设计语言》第6章写的那个“桌面计算器“的朋友请进。

ifree

在《C＋＋程序设计语言》的第6章有一个“桌面计算器“的程序，输入一个四则运算的表达式可以求出值来。我知道这可算是一个最简单的编译器（解释器）。我想以此为基础写一个MIX虚拟机的汇编语言的编译器。
可是三四天下来进展不大，请求大家给些思路启发一下。

ywchen2000

see code below, may be help for you.

1. #include<iostream>
   
2. #include<map>
   
3. #include<string>
   
4. #include<cctype>
   
5. #include<math.h>
   
6. using namespace std;
   
7. class expr;
   
8. enum Token_value{
   
9. SQRT,SIN,COS,
   
10. NAME,NUMBER,END,
    
11. PLUS='+',MINUS='-',MUL='*',DIV='/',
    
12. PRINT=';',ASSIGN='=',LP='(',RP=')',MIN='^'
    
13. };
    
14. typedef double (*dfdp)(double);
    
15. dfdp math[]={sqrt,sin,cos};
    
16. int i;
    
17. typedef Token_value (expr::*get_token_p_p)();
    
18. get_token_p_p get_token_p;
    
19. class expr{
    
20. public:
    
21. expr(const char* str);
    
22. expr(void);
    
23. void jisuan(void);
    
24. double eval();
    
25. void print(){}
    
26. 
    
27. private:
    
28. int line_no;
    
29. 
    
30. string string_expr;
    
31. double (*dfddp)(double,double);
    
32. double number_value;
    
33. string string_value;
    
34. map<string,double> table;
    
35. Token_value curr_tok;
    
36. double my_expr(bool get);
    
37. double term(bool get);
    
38. double prim(bool get);
    
39. double min(bool get);
    
40. Token_value get_token(void);
    
41. Token_value get_token_ios(void);
    
42. 
    
43. double error(char *str);
    
44. };
    
45. expr::expr(void)
    
46. {
    
47. line_no=0;
    
48. i=-1;
    
49. number_value=0;
    
50. table["pi"]=3.1415;
    
51. table["e"]=2.718281;
    
52. 
    
53. }
    
54. expr::expr(const char* str)
    
55. {
    
56. string_expr=str;
    
57. expr();
    
58. }
    
59. double expr::error(char *str)
    
60. {
    
61. cerr<<"line:"<<line_no<<" "<<str<<endl;
    
62. return 1;
    
63. }
    
64. double expr::my_expr(bool get)
    
65. {
    
66. double left=term(get);
    
67. for(;;)
    
68. switch(curr_tok){
    
69. case PLUS:
    
70. left+=term(true);
    
71. break;
    
72. case MINUS:
    
73. left-=term(true);
    
74. break;
    
75. default:
    
76. return left;
    
77. }
    
78. }
    
79. double expr::term(bool get)
    
80. {
    
81. double left=min(get);
    
82. for(;;)
    
83. switch(curr_tok){
    
84. case MUL:
    
85. left*=min(true);
    
86. break;
    
87. case DIV:
    
88. if(double d=min(true)){
    
89. left/=d;
    
90. break;
    
91. }
    
92. return error("divide by 0");
    
93. default:
    
94. return left;
    
95. }
    
96. }
    
97. double expr::min(bool get)
    
98. {
    
99. double left=prim(get);
    
100. dfddp=pow;
     
101. for(;;)
     
102. {
     
103. switch(curr_tok){
     
104. case MIN:
     
105. left=dfddp(left,prim(true));
     
106. break;
     
107. case SQRT:
     
108. left=math[SQRT](left);
     
109. (this->*get_token_p)();
     
110. return left;
     
111. case SIN:
     
112. left=math[SIN](left);
     
113. (this->*get_token_p)();
     
114. return left;
     
115. case COS:
     
116. left=math[COS](left);
     
117. (this->*get_token_p)();
     
118. return left;
     
119. default:
     
120. return left;
     
121. }
     
122. }
     
123. }
     
124. double expr::prim(bool get)
     
125. {
     
126. if(get) (this->*get_token_p)();
     
127. switch(curr_tok){
     
128. case NUMBER:
     
129. {
     
130. double v=number_value;
     
131. (this->*get_token_p)();
     
132. return v;
     
133. }
     
134. case NAME:
     
135. {
     
136. if(strcmp(string_value.c_str(),"sqrt")==0)
     
137. {
     
138. (this->*get_token_p)();
     
139. if(curr_tok!=LP) return error("(expected");
     
140. double e=my_expr(true);
     
141. if(curr_tok!=RP) return error(")expected");
     
142. //get_token(); // delete RP;
     
143. curr_tok=SQRT;
     
144. return e;
     
145. }
     
146. else if(strcmp(string_value.c_str(),"sin")==0)
     
147. {
     
148. (this->*get_token_p)();
     
149. if(curr_tok!=LP) return error("( expected");
     
150. double e=my_expr(true);
     
151. if(curr_tok!=RP) return error(")expected");
     
152. curr_tok=SIN;
     
153. return e;
     
154. }
     
155. else if(strcmp(string_value.c_str(),"cos")==0)
     
156. {
     
157. (this->*get_token_p)();
     
158. if(curr_tok!=LP) return error("( expected");
     
159. double e=my_expr(true);
     
160. if(curr_tok!=RP) return error(")expected");
     
161. curr_tok=COS;
     
162. return e;
     
163. }
     
164. else {
     
165. 
     
166. double& v=table[string_value];
     
167. if((this->*get_token_p)()==ASSIGN)
     
168. { line_no++; v=my_expr(true);}
     
169. return v;
     
170. }
     
171. }
     
172. case MINUS:
     
173. return -prim(true);
     
174. case LP:
     
175. {
     
176. double e=my_expr(true);
     
177. if(curr_tok!=RP) return error(")expected");
     
178. (this->*get_token_p)(); // delete RP;
     
179. return e;
     
180. }
     
181. return error("primay expected");
     
182. }
     
183. }
     
184. Token_value expr::get_token(void)
     
185. {
     
186. char ch=0;
     
187. double power=1;
     
188. number_value=0.0;
     
189. do{
     
190. if(!(ch=string_expr[++i])) return curr_tok=END;
     
191. }while(ch!='\n' && isspace(ch));
     
192. switch(ch){
     
193. case 0:
     
194. return curr_tok=END;
     
195. case ';':
     
196. case '*':
     
197. case '/':
     
198. case '+':
     
199. case '-':
     
200. case '(':
     
201. case ')':
     
202. case '=':
     
203. case '^':
     
204. return curr_tok=Token_value(ch);
     
205. case '0':
     
206. case '1':
     
207. case '2':
     
208. case '3':
     
209. case '4':
     
210. case '5':
     
211. case '6':
     
212. case '7':
     
213. case '8':
     
214. case '9':
     
215. case '.':
     
216. //string_expr.putback(ch);
     
217. while((isdigit((int)ch)))
     
218. {
     
219. number_value=number_value*10+(ch-'0');
     
220. ch=string_expr[++i];
     
221. }
     
222. if(ch=='.')
     
223. ch=string_expr[++i];
     
224. while((isdigit((int)ch)))
     
225. {
     
226. number_value=number_value*10+(ch-'0');
     
227. ch=string_expr[++i];
     
228. power*=10;
     
229. }
     
230. i--;
     
231. number_value=number_value/power;
     
232. // cout<<number_value<<endl;
     
233. return curr_tok=NUMBER;
     
234. default:
     
235. if(isalpha(ch)){
     
236. string_value=ch;
     
237. while((ch=string_expr[++i]) && isalnum(ch)) string_value.push_back(ch);
     
238. i--;
     
239. return curr_tok=NAME;
     
240. }
     
241. //error("bad token");
     
242. return curr_tok=PRINT;
     
243. }
     
244. }
     
245. Token_value expr::get_token_ios(void)
     
246. {
     
247. char ch=0;
     
248. do{
     
249. if(!cin.get(ch)) return curr_tok=END;
     
250. }while(ch!='\n' && isspace(ch));
     
251. switch(ch){
     
252. case 0:
     
253. return curr_tok=END;
     
254. case ';':
     
255. case '*':
     
256. case '/':
     
257. case '+':
     
258. case '-':
     
259. case '(':
     
260. case ')':
     
261. case '=':
     
262. case '^':
     
263. return curr_tok=Token_value(ch);
     
264. case '0':
     
265. case '1':
     
266. case '2':
     
267. case '3':
     
268. case '4':
     
269. case '5':
     
270. case '6':
     
271. case '7':
     
272. case '8':
     
273. case '9':
     
274. case '.':
     
275. cin.putback(ch);
     
276. cin>>number_value;
     
277. return curr_tok=NUMBER;
     
278. default:
     
279. if(isalpha(ch)){
     
280. string_value=ch;
     
281. while(cin.get(ch) && isalnum(ch)) string_value.push_back(ch);
     
282. cin.putback(ch);
     
283. return curr_tok=NAME;
     
284. }
     
285. //error("bad token");
     
286. return curr_tok=PRINT;
     
287. }
     
288. }
     
289. void expr::jisuan(void)
     
290. {
     
291. get_token_p=&expr::get_token_ios;
     
292. while(cin){
     
293. (this->*get_token_p)();
     
294. if(curr_tok==END)break;
     
295. if(curr_tok==PRINT)continue;
     
296. cout<<my_expr(false)<<'\n';
     
297. // cout<<number_value<<endl;
     
298. }
     
299. //return 0;
     
300. }
     
301. double expr::eval(void)
     
302. {
     
303. get_token_p=&expr::get_token;
     
304. //while(string_expr){
     
305. (this->*get_token_p)();
     
306. //if(curr_tok==END)break;
     
307. //if(curr_tok==PRINT)continue;
     
308. return my_expr(false);
     
309. // cout<<number_value<<endl;
     
310. // }
     
311. //return 0;
     
312. }
     
313. int main(void)
     
314. { /*
     
315. expr x("123/3+123*4-3");
     
316. cout<<"x="<<x.eval()<<"\n";
     
317. x.print();
     
318. */
     
319. expr a("1+3+9/3");
     
320. cout<<a.eval()<<endl;
     
321. a.jisuan();
     
322. }

复制代码

ywchen2000

上面的代码,是我做的练习,写这种程序需要时间的.可以看看<<虚拟机的设计和实现--c/c++>>

ifree

谢谢ywchen2000兄了，不过你的程序和书上的程序差不多。我现在遇到的困难是汇编的语法和这个计算器的语法差别很大，不知道该怎么该这个程序适应汇编的语法。另一方面这个程序是直接求值，汇编编译器却要生成代码。

我以前光是靠想，以为汇编其实就是一一对应的翻译，应该不难，没想到自己想做一个，却发现比原来想的要难得多。我不是科班出身，没有学过编译原理，只是大略的看了下《编译原理》的书，知道翻译有几个阶段。还有一个难点是我想只用一次扫描来实现，有的符号是在“未来”定义的，这个还不知道该如何处理。

ywchen2000

上面的代码就是展示了递归分析的技术.可以看看nasm的代码,也可以看看<<虚拟机的设计和实现--c/c++>>这本书,这本书上说的就是自己写个虚拟机,然后在上面实现个汇编编译器.多数的编译器是用二次扫描来实现,

ywchen2000

上面的代码和书上的有很大的不同.

ifree

谢谢ywchen2000
你的代码虽说和书上的有很大的不同，但是所解析的语法还是基本一致的。

我想解析的语法是这样的：

LABEL OPCODE ADDRESS,I(F)
其中LABEL可以没有，OPCODE有两种：机器代码和伪指令；ADDRESS是一个表达式或者没有，I是一个表达式或者没有，F也使一个表达式或者没有；
如果OPCODE是一个伪指令那么，应该是这样
LABEL OPCODE E(F),E(F)

我觉得困难在于如何一次扫描就可以把Address里的还没有定义的符号（但会在下文中定义）解析出值来。

不过慢慢的好像有一点门路了。

ywchen2000

呵呵,直接下个nasm的代码去看看,那是个好东东
http://blog.csdn.net/wenfengmtd/可能有帮助.