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

 

自己动手写basic解释器

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

 





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





4、for
接着看for，for循环这里借助了栈来实现，很不错的方法。

1. /* execute a FOR loop
2.  * for 循环  其主要格式 文章第一篇已经给出  
3.  * for i=1 to 10
4.  * next i
5.  * 下面就引用此例了
6.  */
7. void exec_for()
8. {
9.     struct for_stack i;     //申请一个栈元素  到时候加入
10.     int value;
11. 
    
12.     get_token();  /*  获取标号  这里获取到变量i */
13.     if (!isalpha(*token))  //变量必定是字符型
14.     {
15.         serror(4);
16.         return;
17.     }
18. 
    
19.     i.var = toupper(*token) - 'A';  /* 我们是把变量放在hash表中的  所以这里来计算变量在hash表中位置   */
20. 
    
21.     get_token();  /* 这里得到了等号 */
22.     if (*token!='=')  
23.     {
24.         serror(3);
25.         return;
26.     }
27.     get_exp(&value);  /* 初始值  比如这里是1 */
28. 
    
29.     variables[i.var]=value;     //这里把初始值放在变量数组中
30. 
    
31.     get_token();
32. 
    
33.     if (tok != TO) serror(9);  /* 读取to单词 */
34.     get_exp(&i.target);  /* 取得最终要达到的数值  比如这里是10 */
35. 
    
36.     /* if loop can execute at least once, push into on stack */
37.     if (value<=i.target)  {
38.         i.loc = prog;       //记录要执行的语句  这里是for循环的里面要执行的语句
39.         fpush(i);       //压栈
40.     }
41.     else  /* otherwise, skip loop code altogether */
42.         while (tok!=NEXT)  get_token();     //每到next之前  都输入for循环要执行的语句   所以一直执行
43. }

通过压栈可以记录for循环要执行的一系列语句。压栈代码如下,同样很简单:

1. void fpush(struct for_stack i)
2. {
3.     if (ftos>FOR_NEST)
4.     serror(10);
5.     fstack[ftos]=i;
6.     ftos++;
7. }

for循环依靠next关键字来进入下一轮循环，并且要把循环变量加一

1. /* execute a NEXT statement */
2. void next()
3. {
4.     struct for_stack i;
5. 
   
6.     i = fpop();  /* 这里我们读出当年压栈的记录 */
7. 
   
8.     variables[i.var]++;  /* 变量加一 */
9.     if (variables[i.var]>i.target)  return;  /* 这个自然是作完了 */
10.     fpush(i);   /* 没做完事情，记录当前变量  压栈 */
11.     prog = i.loc;  /* 记得么  loc记录了for循环的第一个要执行的语句 这样我们就顺利地转入下次循环开始执行 */
12. }
13. 
    

出栈代码也很简单，就是控制栈顶指针而已。

1. struct for_stack fpop()
2. {
3.     ftos--;
4.     if (ftos<0)  serror(11);
5.     return (fstack[ftos]);
6. }

通过栈不仅可以解决for循环的问题，而且gosub这个关键字也是通过栈来解决的。回想一下，我们在函数调用过程，cpu会先把当前的eip所指向的地址压栈，函数执行完后我们再出栈以跳回原执行地址。

1. /* execute a GOSUB command 
2.  * 这个类似c语言中的函数调用 */
3. void gosub()
4. {
5.     char *loc;
6. 
   
7.     get_token();
8.     /* find the label to call */
9.     loc = find_label(token);
10.     if (loc=='/0')
11.         serror(7);  /* label not defined */
12.     else  
13.     {
14.         gpush(prog);  /* 当前执行的地址压栈 */
15.         prog = loc;  /* 重新把要执行的地址赋值给prog */
16.     }
17. }

值得注意的是我们这里又重新定义了一个栈以及相关的操作，而不是采用的for循环的栈。如下

1. char *gstack[SUB_NEST];  /* stack for gosub  就是一个字符指针数组*/
2. int gtos;  /* index to top of GOSUB  栈顶指针 */

相关的函数也很简单:

1. /* GOSUB stack push function */
2. void gpush(char *s)
3. {
4.     gtos++;
5. 
   
6.     if (gtos==SUB_NEST)  
7.     {
8.         serror(12);
9.         return;
10.     }
11. 
    
12.     gstack[gtos] = s;
13. }
14. 
    
15. 
    
16. /* GOSUB stack pop function */
17. char *gpop()
18. {
19.     if (gtos==0)  {
20.         serror(13);
21.         return 0;
22.     }
23.     return gstack[gtos--];
24. }
25. 
    

go_sub的处理体现出了程序语言运行的精髓，通过压栈保留当前信息(当前地址)，必要时出栈又获取相应的信息 (想要返回的地址) 。cpu就是这样执行的，当然我们设计解释器也可以参照这个模型，来看看如何从一个"函数"(Basic中应该称作sub,子过程)中返回。

1. /* return from GOSUB */
2. void greturn()
3. {
4.     prog = gpop();   //出栈，并把栈顶元素(即原来的地址)付给prog
5. }