java开发C语言解释器：函数递归调用时的环境保护

更详细的讲解和代码调试演示过程，请参看视频
用java开发C语言编译器

函数调用时，参数的传递是通过堆栈实现的，也就是每次出现函数调用，系统会先设置好一个堆栈，然后把要传递的参数压入堆栈，函数执行完毕后，再将参数从堆栈中弹出。

这样做的好处是，能够实现调用函数和被调函数间的环境隔离。特别是被调函数和调用函数是同一函数时，也就是函数递归调用时，相同变量不会相互影响。例如下面的代码：

void f(int i) {
   if (i <=0) {
       i= 0；
       a = 0;
       return;
   }

   int a ;
   a = i;
   printf("before call , local variable are: i : %d ,  a : %d", i, a);

    f(i-1);

    printf("after call , local variable are: i : %d ,  a : %d", i, a);
}

void main() {
    f(1);
}

代码中，函数f有两个变量，一个是参数i,另一个是局部变量a, 在f的实现中，有递归调用，在调用f(i-1)前，f把变量i和a的值打印出来，调用后再把两个变量打印一次，按道理，两次打印出的变量值必须是一样的。

但是，如果使用我们当前开发的解释器运行上面程序的话，打印情况是这样：
before call , local variable are: i :1, a : 1

after call , local variable are: i :0, a : 0

也就是说，递归调用时，也就是运行被调函数后，主调函数自己的变量居然被改变了，这是不符合逻辑的。出现这个问题的原因是，我们解释器在实现时，变量的传递并不是通过堆栈实现的，我们对每个变量都会在符号表中存储一份唯一的拷贝，这样一来，实现回调函数时，由于两个函数会对同名变量就行修改，而这些同名变量只对应于符号表中的统一拷贝，也就是说，f函数中的变量i 和 a 只在符号表中存储一次，那么当f(i-1)运行时，它对变量i和a的更改，那么主叫函数对应的a和i也就更改了，这个问题如果不处理，那么解释器运行递归调用代码时，逻辑就会乱套了。

我们的解决办法是，在调用子函数前，父函数先把自己的所以变量保存起来，调用完子函数后，再把调用前保存的变量值恢复到各个变量中，这个过程其实是模拟了用堆栈来传递参数的过程。

由于实现函数调用的是ExtDefExecutor，因此相应改动也会发生在该类里面，代码修改如下：

package backend;

import java.util.ArrayList;

import frontend.CGrammarInitializer;
import frontend.Symbol;
import frontend.TypeSystem;

public class ExtDefExecutor extends BaseExecutor {
    private ArrayList<Object> argsList = new ArrayList<Object>();
    ICodeNode root;
    String funcName;
    @Override
    public Object Execute(ICodeNode root) {
        this.root = root;
        int production = (Integer)root.getAttribute(ICodeKey.PRODUCTION);
        switch (production) {
        case CGrammarInitializer.OptSpecifiers_FunctDecl_CompoundStmt_TO_ExtDef:
            ICodeNode child = root.getChildren().get(0); 
            funcName = (String)child.getAttribute(ICodeKey.TEXT);
            root.setAttribute(ICodeKey.TEXT, funcName);
            saveArgs();
            executeChild(root, 0);

            executeChild(root, 1);
            Object returnVal = getReturnObj();
            clearReturnObj();

            if (returnVal != null) {
                root.setAttribute(ICodeKey.VALUE, returnVal);
            }

            isContinueExecution(true);

            restoreArgs();

            break;
        }
        return root;
    }

    private void saveArgs() {
        System.out.println("Save arguments....");
        TypeSystem typeSystem = TypeSystem.getTypeSystem();
        ArrayList<Symbol> args = typeSystem.getSymbolsByScope(funcName);
        int count = 0;
        while (count < args.size()) {
            Symbol arg = args.get(count);
            Object value = arg.getValue();
            argsList.add(value);
            count++;
            }
    }

    private void restoreArgs() {
        System.out.println("Restore arguments....");
        TypeSystem typeSystem = TypeSystem.getTypeSystem();
        ArrayList<Symbol> args = typeSystem.getSymbolsByScope(funcName);
        int count = 0;

        while (args != null && count < argsList.size()) {
            IValueSetter setter = (IValueSetter)args.get(count);
            try {
                Object value = argsList.get(count);
                setter.setValue(value);
            } catch (Exception e) {
                e.printStackTrace();
            }

            count++;
        }
    }

}

相比原来实现，我们增加了一下内容，首先是argsList，这个队列是用来存储函数所以相关变量的数值的。以前我们讲过，ExtDefExecutor的第0个孩子节点是FunctDeclExecutor，该对象的作用是获取输入参数，因此在执行第0个孩子节点前，需要把函数的参数及局部变量的值先存储起来，变量存储工作由saveArgs函数实现。

saveArgs 的实现逻辑是，从类型系统中，根据函数名，找到该函数的所以输入参数和局部变量，得到变量的Symbol对象后，把变量的值读出来，依次存入到argsList列表对象中。

接着运行函数体内的代码，在函数体内，可能会有递归调用，但由于我们已经把函数的相关变量值已经存储起来了，因此我们便不用担心函数在递归调用时，子函数的执行会把父函数的变量信息给破坏掉。

函数体运行结束后，通过restoreArgs 将前面存储的变量值重新写回到各个对应变量中。

我们还剩下一个问题是，如果从符号表中，得到与当前函数相关的所有变量对象。还记得我们以前设置了变量的作用范围吧，每个Symbol对象都包含一个域叫symbolScope，如果该变量是全局变量，那么该symbolScope的值是”global”，如果是函数参数，或是函数的局部变量，那么symbolScope的值就是对应的函数名。由此要找到与对应函数相关的变量对象就不难了，只要遍历symbol表中所以对象，找到symbolScope的值跟给定函数名一样的那些Symbol对象就可，由此在TypeSystem.java中做如下修改：

public class TypeSystem {
    public ArrayList<Symbol> getSymbolsByScope(String scope) {
        ArrayList<Symbol> list = new ArrayList<Symbol>();
        for (Map.Entry<String, ArrayList<Symbol>> entry : symbolTable.entrySet()) {
            ArrayList<Symbol> args = entry.getValue();
            for (int i = 0; i < args.size(); i++) {
                Symbol sym = args.get(i);
                if (sym.getScope().equals(scope)) {
                    list.add(sym);
                }
            }
        }

        return list;
    }
}

getSymbolsByScope函数的实现逻辑跟我们上面提到的做法是一致的。

有了上面改动后，原来的递归调用出现的问题便可以顺利解决，由于快速排序算法需要使用到函数递归调用，因此，我们这一节的改进，为我们解释器最终能正确运行C语言实现的快速排序算法，奠定了坚实的基础。

更详细的讲解和调试演示过程，请参看视频。

更多技术信息，包括操作系统，编译器，面试算法，机器学习，人工智能，请关照我的公众号：