自己动手写basic解释器(七)

 

自己动手写basic解释器

刺猬@http://blog.csdn.net/littlehedgehog

 





注: 文章basic解释源码摘自梁肇新先生的《编程高手箴言》(据他所说这个代码也是网上摘录的)，源码解读参考《java编程艺术》。《java编程艺术》里面自然是java版了(可能旭哥更加适合点儿)，我这里还是解读的C版basic解释器代码。





终于把这个basic解释器主干源码解述完了。其实说来这个解释器实际意义并不大，但是通过阅读源代码我们可以深一步领悟程序语言执行内部机理。我觉得特别值得提的三点：
1、通过prog指针模拟CPU中的eip寄存器，巧妙地借鉴了世界最顶尖级的硬件工程师在处理程序运行问题上的思路。
2、模拟函数调用栈，这个在go_sub函数中得到了淋漓尽致地体现。
3、p_buf就相当于计算机内存，或者说是程序运行空间的text段，26个变量就相当于data段，而我们的模拟栈恰好就是程序中的栈空间。


最后我把主程序的代码贴出来，方便兄弟伙们:

1. 
   
2. #include 
3. #include 
4. #include 
5. #include 
6. #include 
7. 
   
8. #define NUM_LAB 100
9. #define LAB_LEN 10
10. #define FOR_NEST 25
11. #define SUB_NEST 25
12. #define PROG_SIZE 10000
13. #define DELIMITER 1
14. #define VARIABLE 2
15. #define NUMBER 3
16. #define COMMAND 4
17. #define STRING 5
18. #define QUOTE 6
19. 
    
20. #define PRINT 1
21. #define INPUT 2
22. #define IF 3
23. #define THEN 4
24. #define FOR 5
25. #define NEXT 6
26. #define TO 7
27. #define GOTO 8
28. #define EOL 9
29. #define FINISHED 10
30. #define GOSUB 11
31. #define RETURN 12
32. #define END 13
33. 
    
34. char *prog;      /* holds expression to be analyzed  */
35. jmp_buf e_buf;   /* hold environment for longjmp() */
36. 
    
37. int variables[26]= {  /* 26 user variables,A-Z  */
38.     0,0,0,0,0,0,0,0,0,0,
39.     0,0,0,0,0,0,0,0,0,0,
40.     0,0,0,0,0,0
41. };
42. 
    
43. struct commands { /* keyword lookup table  */
44.     char command[20];
45.     char tok;
46. } table[] = {  /* command must be entered lowercase  */
47.     "print",PRINT,   /* in this table  */
48.     "input",INPUT,
49.     "if",IF,
50.     "then",THEN,
51.     "goto",GOTO,
52.     "for",FOR,
53.     "next",NEXT,
54.     "to",TO,
55.     "gosub",GOSUB,
56.     "return",RETURN,
57.     "end",END,
58.     NULL,END
59. };
60. 
    
61. char token[80];     //注意token是数组类型
62. char token_type,tok;
63. 
    
64. struct label {
65.     char name [LAB_LEN];
66.     char *p;    /* point to place to go in source */
67. };
68. 
    
69. struct label label_table[NUM_LAB];
70. char *find_label(),*gpop();
71. 
    
72. struct for_stack {
73.     int var;   /* counter variable  */
74.     int target;  /* target value  */
75.     char *loc;
76. } fstack[FOR_NEST];  /* stack for FOR/NEXT loop  */
77. struct for_stack fpop();
78. 
    
79. char *gstack[SUB_NEST];  /* stack for gosub  */
80. int ftos;  /* index to top of FOR stack  */
81. int gtos;  /* index to top of GOSUB  */
82. 
    
83. void print(),scan_labels(),find_eol(),exec_goto();
84. void gosub(),greturn(),gpush(),label_init(),fpush();
85. 
    
86. /* Load a program */
87. load_program (char *p,char *fname)
88. {
89.     FILE *fp;
90.     int i=0;
91.    
92.     if (!(fp=fopen(fname,"rb")))  return 0;
93. 
    
94.     i=0;
95.     do  {
96.         *p = getc(fp);
97.         p++;i++;
98.     } while (!feof(fp)&&i
99.     *(p-2) = '/0';   /* null terminate the program  */
100.     fclose (fp);
101.     return 1;
102. }
103. 
     
104. 
     
105. /* 给变量赋值  比如 a＝3  
106.  * 注意这里为了简化起见，我们的变量就设置为26个字母
107.  */
108. assignment()
109. {
110.     int var,value;
111. 
     
112.     /* getthe variable name */
113.     get_token();
114.     if (!isalpha(*token))  //因为变量我们用字母代替 所以必定是字母类型
115.     {
116.         serror(4);
117.         return;
118.     }
119. 
     
120.     var = toupper(*token)-'A';  //转化为大写字母  然后减去'A' 这样让变量在hash表中有了座次 比如A减去A为0 这样A字符变量在变量hash表中第一个位置
121. 
     
122.     /* get the equals sign 
123.      * 这里我们取a=3 中间的等号*/
124.     get_token();
125.     if (*token!='=')    //既然赋值么 肯定有等号了
126.     {
127.         serror(3);
128.         return;
129.     }
130. 
     
131.     /* a=3  等号取走了 我们来取数值  */
132.     get_exp(&value);
133.    
134.     /* 把我们取到的变量 比如a 值为3 存放在hash表中 */
135.     variables[var] = value;
136. }
137. 
     
138. 
     
139. /* execute a simple version of the BASIC PRINT statement 
140.  * 执行打印  这里我们还是举例说明*/
141. void print()
142. {
143.     int answer;
144.     int len=0,spaces;
145.     char last_delim;
146.    
147.     do  {
148.         get_token();  /* get next list item */
149.         if (tok==EOL||tok==FINISHED)  break;  //如果取到的符号是一行结束或者文件结束  自然的打印结束
150. 
     
151.                  
152.         //BASIC 中print一般有两种用法  第二种就是print "hello world"  打印字符串  
153.         if (token_type==QUOTE)  
154.         {  
155.             printf ("%s",token);
156.             len+=strlen(token);
157.             get_token();    //注意我们打印了后又取了一次符号
158.         }
159.         else   //打印变量的
160.         { 
161.             putback();
162.             get_exp(&answer);
163.             get_token();    //注意我们打印了后又取了一次符号
164.             len += printf ("%d",answer);
165.         }
166.         last_delim = *token;    
167.         
168.         
169.         /* Basic 有两种打印间隔标识 
170.          * 比如 print a,b 表示按标准格式打印
171.          * 而print a;b 表示按照紧凑格式打印  
172.          * 所谓标准格式简单来讲就是间隔大点儿  紧凑自然间隔小点儿  
173.          */
174.         if (*token==',')  
175.         {
176.             /* compute number of move to next tab */
177.             spaces = 8-(len%8);
178.             len += spaces;  /* add in the tabbing position */
179.             while (spaces)  {
180.                 printf (" ");
181.                 spaces--;
182.             }
183.         }
184.         else if (*token==';')  
185.             printf ("  ");
186.         else if (tok != EOL && tok != FINISHED) serror (0);     //print a,b 打完一次后 要么是逗号、分号 要么就是行结束或者文件结束  如果四者不居其一  必然错了
187.     } while (*token==';'||*token==',');     //例如 print a,b,c 如果token是逗号、分号 那么表示后面还有打印  继续来
188. 
     
189.     /* 当处于行结束或者文件结束  那么前一次分界符不能是;或者,  
190.      * 示例 如果 "print a," 这个明显是语法错误 a后面不应该要逗号
191.      * 那么打印完a取出token是逗号  我们赋值给last_delim 继续循环
192.      *  下一个是行结束  跳出打印但是检验出last_delim是逗号  出错 */
193.     if (tok==EOL||tok==FINISHED)    
194.     {
195.         if (last_delim != ';' && last_delim != ',') printf ("/n");
196.     }
197.     else serror(0);  /* error is not, or ; */
198. }
199. 
     
200. 
     
201. /* 搜索所有标签 
202.  * 这个函数可以说是basic里面的预处理  
203.  * 我们搜索源代码 找出里面的标签  将其存入标签表
204.  * 所谓标签label 其实C语言也有 不过一般不常用 因为label多半和goto一起出现的  而在结构化程序设计中 goto出现被人认为是绝对不能的
205.  * 不过内核中goto却是常常出现
206.  * 下面这个函数最大的困惑判断标签的特征类型 我们设置为数字  要知道这里标签我们都是设置为数字的
207.  * 但是如何把标签与普通数值分开呢?
208.  */
209. void scan_labels()
210. {
211.     int addr;
212.     char *temp;
213. 
     
214.     label_init();  /* zero all labels */
215.     temp = prog;  /* save poiter to top of program */
216. 
     
217.     /* 如果源代码中第一个是个数字的话  存入标签表中  不过说实话   我没理解这个有什么意义*/
218.     get_token();
219.     if (token_type==NUMBER)  
220.     {
221.         strcpy (label_table[0].name,token);
222.         label_table[0].p=prog;
223.     }
224.    
225.     find_eol();     //提行
226.     do  {
227.         get_token();
228.         if (token_type==NUMBER)     //如果是数字   这里是一行开头  开头的数字不可能是一个数值  
229.         {
230.             addr = get_next_label(token);
231.             if (addr==-1||addr==-2)  
232.             {
233.                 (addr==-1) ? serror(5):serror(6);
234.             }
235.             strcpy (label_table[addr].name,token);
236.             label_table[addr].p = prog;  /* current point in program */
237.         }
238.         /* if not on a blank line , find next line */
239.         if (tok!=EOL) find_eol();
240.     } while (tok!=FINISHED);
241.     prog = temp;  /* restore to original */
242. }
243. 
     
244. 
     
245. /* find the start of next line */
246. void find_eol()
247. {
248.     while (*prog!='/n'&&*prog!='/0')  ++prog;
249.     if (*prog)  prog++;
250. }
251. 
     
252. 
     
253. /* return index of next free posion in the label array
254.       -1 is returned if the array is full.
255.       -2 is returned when duplicate label is found.
256. */
257. get_next_label(char *s)
258. {
259.     register int t;
260. 
     
261.     for (t=0;t
262.         if (label_table[t].name[0]==0)  return t;
263.         if (!strcmp(label_table[t].name,s)) return -2;  /* dup */
264.     }
265.     return -1;
266. }
267. 
     
268. /* find location of given label. A null is returned if
269.    label is not found; ohtherwise a pointer to the position
270.    of the label is returned.
271. */
272. char *find_label(char *s)
273. {
274.     register int t;
275. 
     
276.     for (t=0;t
277.         if (!strcmp(label_table[t].name,s))  return label_table[t].p;
278.     return '/0';  /* error condition */
279. }
280. 
     
281. 
     
282. /* execute a GOTO statement. 
283.  * goto一般形式即是 goto label 
284.  */
285. void exec_goto()
286. {
287.     char *loc;
288. 
     
289.     get_token();  /* 这里获取标号，即是标签内容 */
290.     
291.     loc = find_label (token);  //标签是为跳转所用，所以获取标签后我们马上要想办法得到标签所代表地址
292.     if (loc=='/0')
293.         serror(7);  /* 出错 */
294.     else prog=loc;  /* 重新 设置prog指针  指出了下一个我们运行的地址  我们得完全听他的*/
295. }
296. 
     
297. 
     
298. /* initialize the array that holds the labels.
299.    by convention , a null label name indicates that
300.    array posiiton is unused.
301. */
302. void label_init()
303. {
304.     register int t;
305. 
     
306.     for (t=0;t'/0';
307. }
308. 
     
309. 
     
310. /* execute an IF statement 
311.  * 执行if语句
312.  */
313. void exec_if()
314. {
315.     int x,y,cond;
316.     char op;
317.     /* 这里我们只是处理一个简单的if  就是if (x operator y) */
318.     get_exp(&x);  /* 获取操作符左边数值 */
319. 
     
320.     get_token();  /* 获取操作符  "比较符" */
321.     if (!strcmp("<>",*token))   //这里有点儿问题  一个字符串不可能跟一个字符比较吧
322.     {
323.         serror(0);  /* not a leagal oprator */
324.         return;
325.     }
326.     op = *token;
327.     get_exp(&y);  /* 操作符右边  */
328. 
     
329.     /* determine the outcome */
330.     cond = 0;
331.     switch(op)  {
332.         case '<':
333.             if (x
334.             break;
335.         case '>':
336.             if (x>y) cond=1;
337.             break;
338.         case '==':      //这里也是有点儿问题，op是字符类型 怎么会可能会是'=='，而且好笑的是basic没有这个符号
339.             if (x==y) cond=1;
340.             break;
341.     }
342.     if (cond)  {  /* is true so process target of IF */
343.         get_token();
344.         if (tok != THEN)  {     //if 后面会连上then 所以有if没then是错误的
345.             serror(8);
346.             return;
347.         }  /* else program execution starts on next line */
348.     }
349.     else find_eol();  /* find start of next line */
350. }
351. 
     
352. 
     
353. /* execute a FOR loop
354.  * for 循环  其主要格式 文章第一篇已经给出  
355.  * for i=1 to 10
356.  * next i
357.  * 下面就引用此例了
358.  */
359. void exec_for()
360. {
361.     struct for_stack i;     //申请一个栈元素  到时候加入
362.     int value;
363. 
     
364.     get_token();  /*  获取标号  这里获取到变量i */
365.     if (!isalpha(*token))  //变量必定是字符型
366.     {
367.         serror(4);
368.         return;
369.     }
370. 
     
371.     i.var = toupper(*token) - 'A';  /* 我们是把变量放在hash表中的  所以这里来计算变量在hash表中位置   */
372. 
     
373.     get_token();  /* 这里得到了等号 */
374.     if (*token!='=')  
375.     {
376.         serror(3);
377.         return;
378.     }
379.     get_exp(&value);  /* 初始值  比如这里是1 */
380. 
     
381.     variables[i.var]=value;     //这里把初始值放在变量数组中
382. 
     
383.     get_token();
384. 
     
385.     if (tok != TO) serror(9);  /* 读取to单词 */
386.     get_exp(&i.target);  /* 取得最终要达到的数值  比如这里是10 */
387. 
     
388.     /* if loop can execute at least once, push into on stack */
389.     if (value<=i.target)  {
390.         i.loc = prog;       //记录要执行的语句  这里是for循环的里面要执行的语句
391.         fpush(i);       //压栈
392.     }
393.     else  /* otherwise, skip loop code altogether */
394.         while (tok!=NEXT)  get_token();     //每到next之前  都输入for循环要执行的语句   所以一直执行
395. }
396. 
     
397. 
     
398. /* execute a NEXT statement */
399. void next()
400. {
401.     struct for_stack i;
402. 
     
403.     i = fpop();  /*read the loop info */
404. 
     
405.     variables[i.var]++;  /* increment control variable */
406.     if (variables[i.var]>i.target)  return;  /* all done */
407.     fpush(i);   /* otherwise,return the info */
408.     prog = i.loc;  /* loop */
409. }
410. 
     
411. 
     
412. /* push function for the FOR stack */
413. void fpush(struct for_stack i)
414. {
415.     if (ftos>FOR_NEST)
416.     serror(10);
417.     fstack[ftos]=i;
418.     ftos++;
419. }
420. 
     
421. 
     
422. struct for_stack fpop()
423. {
424.     ftos--;
425.     if (ftos<0)  serror(11);
426.     return (fstack[ftos]);
427. }
428. 
     
429. 
     
430. /* exec a simple form of BASIC INPUT command */
431. void input()
432. {
433.     char str[80],var;
434.     int i;
435. 
     
436.     get_token();  /* see if prompt string id=s present */
437.     if (token_type == QUOTE)  {
438.         printf (token);  /* if so , print it and check for command */
439.         get_token();
440.         if (*token != ',')  serror(1);
441.         get_token();
442.     }
443.     else printf ("? ");  /* otherwise, prompt with / */
444.     var = toupper(*token) - 'A';  /* get the input var */
445. 
     
446.     scanf ("%d",&i);  /* read input */
447.     variables[var] = i;  /* store it */
448. }
449. 
     
450. 
     
451. /* execute a GOSUB command 
452.  * 这个类似c语言中的函数调用 */
453. void gosub()
454. {
455.     char *loc;
456. 
     
457.     get_token();
458.     /* find the label to call */
459.     loc = find_label(token);
460.     if (loc=='/0')
461.         serror(7);  /* label not defined */
462.     else  
463.     {
464.         gpush(prog);  /* 当前执行的地址压栈 */
465.         prog = loc;  /* 重新把要执行的地址赋值给prog */
466.     }
467. }
468. 
     
469. 
     
470. /* return from GOSUB */
471. void greturn()
472. {
473.     prog = gpop();
474. }
475. 
     
476. 
     
477. /* GOSUB stack push function */
478. void gpush(char *s)
479. {
480.     gtos++;
481. 
     
482.     if (gtos==SUB_NEST)  
483.     {
484.         serror(12);
485.         return;
486.     }
487. 
     
488.     gstack[gtos] = s;
489. }
490. 
     
491. 
     
492. /* GOSUB stack pop function */
493. char *gpop()
494. {
495.     if (gtos==0)  {
496.         serror(13);
497.         return 0;
498.     }
499.     return gstack[gtos--];
500. }
501. 
     
502. main (int argc,char *argv[])
503. {
504.     char in[80];
505.     int answer;
506.     char *p_buf;
507.     char *t;
508. 
     
509.     if (argc!=2)  {
510.         printf ("usage: run /n");
511.         exit (1);
512.     }
513. 
     
514.     /* allocate memory for the program */
515.     if (!(p_buf=(char *)malloc(PROG_SIZE)))  {
516.         printf ("allocation failure");
517.         exit (1);
518.     }
519. 
     
520.     /* load the program to execute */
521.     if (!load_program(p_buf,argv[1]))  exit(1);
522. 
     
523.     if (setjmp(e_buf))  exit(1); /* initialize the long jump */
524. 
     
525.     prog = p_buf;
526.     scan_labels();  /*  搜索所有的标签  */
527.     ftos = 0;  /* 初始化栈  这个是为for循环作准备的  */
528.     gtos = 0;  /* 初始化栈  这个是为gosub作准备的 */
529.     do  {
530.         token_type = get_token();
531.         /* 如果当前是变量 */
532.         if (token_type==VARIABLE)  {
533.             putback();  /* 回退prog指针到变量前 */
534.             assignment();  /* 赋值  */
535.         }
536.         else  /* 除了变量那就是关键字了  可能有同学会问  呃  那个比如一个数字怎么没考虑  请想想一个数字怎么会单独出现 */
537.             switch (tok)  {
538.                 case PRINT:
539.                     print();
540.                     break;
541.                 case GOTO:
542.                     exec_goto();
543.                     break;
544.                 case IF:
545.                     exec_if();
546.                     break;
547.                 case FOR:
548.                     exec_for();
549.                     break;
550.                 case NEXT:
551.                     next();
552.                     break;
553.                 case INPUT:
554.                     input();
555.                     break;
556.                 case GOSUB:
557.                     gosub();
558.                     break;
559.                 case RETURN:
560.                     greturn();
561.                     break;
562.                 case END:
563.                     exit(0);
564.             }
565.     }while (tok != FINISHED);
566. }
567. 
     

刺猬@littlehedgehog