AScript之编译递归函数

AScript是一个开源的C#动态脚本解析执行引擎，支持解释执行和编译执行两种模式，本篇介绍AScript中如何编译脚本中的递归函数。

一 解析函数

我们先来看个脚本：

int fib(int n) {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);
}
fib(10)

该脚本定义了一个fib递归函数，然后调用该递归函数，返回函数值。

解析脚本时，将函数定义生成语法树DefineFuncNode：

• 函数名：fib
• 返回类型：int
• 参数列表：int n
• 函数体

二 编译函数

对DefineFuncNode进行编译时，我们并不需要提前知道它的函数体是否存在递归调用。

2.1 编译上下文

首先，有个编译上下文BuildContext，保存编译期间的变量定义、函数定义。

编译函数时先定义一个临时上下文，用于保存函数内部的变量定义和函数定义：

var tempBuildContext = new BuildContext(buildContext)
{
    RewriteLocalVariables = false,
    ReturnType = funcReturnType,
    IsMain = true
};

2.2 函数参数

向临时上下文添加参数定义：

Type[] argTypes = null;
if (this.Args != null && this.Args.Length > 0)
{
    argTypes = new Type[this.Args.Length];
    for (int i = 0; i < this.Args.Length; i++)
    {
        var arg = this.Args[i];
        var type = arg.SystemType ?? scriptContext.EvalType(arg.Type);
        if (type == null)
        {
            throw new ScriptAnalyzingException($"unknown parameter type {arg.Type} in function {this.Name}");
        }
        argTypes[i] = type;
        string argName = arg.Name;
        // 匿名参数名：_1、_2、_3 ...
        if (IsAnonymous(argName)) argName = "_" + i;
        tempBuildContext.Parameters[argName] = Expression.Parameter(type, argName);
    }
}

2.3 函数头定义

这一步非常关键，先保存函数头定义，后续编译函数体时如果有函数调用，首先会搜索函数头定义列表是否有匹配的函数，实现递归调用。

// 匿名函数不生成函数头定义
var delegateDefine = IsAnonymous(this.Name) ? null : buildContext.AddDelegateDefine(this.Name, argTypes, funcReturnType);

注意，函数定义要添加到全局buildContext上下文，而不是函数临时上下文tempBuildContext中。

我们来看一下AddDelegateDefine方法：

public DelegateDefine AddDelegateDefine(string name, Type[] argTypes, Type returnType)
{
    List<DelegateDefine> list;
    if (_DelegateDefines == null)
    {
        _DelegateDefines = new Dictionary<string, List<DelegateDefine>>();
        _DelegateDefines[name] = list = new List<DelegateDefine>();
    }
    else if (!_DelegateDefines.TryGetValue(name, out list))
    {
        _DelegateDefines[name] = list = new List<DelegateDefine>();
    }
    var delegateDefine = new DelegateDefine(name, argTypes, returnType);
    list.Add(delegateDefine);
    return delegateDefine;
}

函数头DelegateDefine定义如下：

/// <summary>
/// int fib(int n)
/// </summary>
public class DelegateDefine
{
    public string Name { get; private set; }
    public Type[] ArgTypes { get; private set; }
    public Type ReturnType { get; private set; }
    public ParameterExpression Variable { get; set; }

    public DelegateDefine(string name, Type[] argTypes, Type returnType)
    {
        this.Name = name;
        this.ArgTypes = argTypes;
        this.ReturnType = returnType;
    }
}

其中Variable字段有什么用途呢？

它的类型是ParameterExpression，很明显是一个变量，用于引用编译的函数LambdaExpression，那什么时候创建这个变量呢？

2.4 编译函数体

前面函数参数定义、函数头定义都已就绪，接下来开始编译函数体：

var body = this.Body.Build(tempBuildContext, scriptContext, buildOptions);

我们具体看看函数体中调用函数是如何编译的，调用函数fib(n - 1)会解析生成CallFuncNode语法树：

public class CallFuncNode : TreeNode
{
    public string Name { get; set; }
    public ITreeNode[] Args { get; set; }
    
    public Expression Build(BuildContext buildContext, ScriptContext scriptContext, BuildOptions options);
}

编译时会搜索上下文中的函数定义：

Expression[] argExprs = null;
Type[] argTypes = null;

// 从编译上下文环境中构建
var tempBuildContext = buildContext;
while (tempBuildContext != null)
{
    var result = BuildFunc(buildContext, options, tempBuildContext.TempFunctions, name, args, ref argExprs, ref argTypes);
    if (result != null) return result;
    if (tempBuildContext.HasDelegateDefine(name))
    {
        if (args != null && args.Count > 0 && argExprs == null)
        {
            argExprs = new Expression[args.Count];
            argTypes = new Type[args.Count];
            for (int i = 0; i < args.Count; i++)
            {
                var arg = args[i].Build(buildContext, this, options);
                argExprs[i] = arg;
                argTypes[i] = arg.Type;
            }
        }
        var del = tempBuildContext.GetDelegateDefine(name, argTypes);
        if (del != null)
        {
            return Expression.Invoke(del, argExprs);
        }
    }
    tempBuildContext = tempBuildContext.Parent;
}

前面调用AddDelegateDefine添加函数定义，这里GetDelegateDefine获取匹配的函数定义：

public ParameterExpression GetDelegateDefine(string name, IList<Type> inArgTypes)
{
    if (_DelegateDefines == null || _DelegateDefines.Count == 0) return null;
    if (!_DelegateDefines.TryGetValue(name, out var list)) return null;
    if (list.Count == 0) return null;
    var delegateDefine = list.FirstOrDefault(a => ScriptUtils.IsMatchArgTypes(inArgTypes, a.ArgTypes));
    if (delegateDefine == null) return null;
    if (delegateDefine.Variable == null)
    {
        delegateDefine.Variable = Expression.Variable(ScriptUtils.GetDelegateType(delegateDefine.ArgTypes, delegateDefine.ReturnType ?? typeof(object)), delegateDefine.Name);
    }
    return delegateDefine.Variable;
}

匹配到对应的函数定义时，创建DelegateDefine中的Variable变量，就表示有递归调用了。

2.5 生成Lambda

前面我们在编译函数体中的调用函数语句时，会检索当前函数定义，来实现递归调用。

最后，就是编译生成完整的函数：

// 如果函数未定义返回类型，但是有递归调用，此时无法自动根据函数体推导返回类型，强制定义为object类型
if (funcReturnType == null && delegateDefine?.Variable != null)
{
    tempBuildContext.ReturnType = typeof(object);
}
// 生成LambdaExpression
var lambda = tempBuildContext.Build(scriptContext, buildOptions, body);
// 将函数赋值给临时函数变量
var tmpVar = delegateDefine?.Variable ?? Expression.Variable(lambda.Type);
var assign = Expression.Assign(tmpVar, lambda);
int hashCode = tmpVar.GetHashCode();
string tmpVarName = hashCode > 0 ? $"<>$tmpVar_{hashCode}" : $"<>$tmpVar__{-hashCode}";
buildContext.Variables[tmpVarName] = tmpVar;
buildContext.LocalVariables.Add(tmpVarName);
buildContext.PrevExpressions.Add(assign);

2.6 回写函数

最后的最后，将函数添加到上下文，并回写到ScriptContext中，用于后续脚本调用：

if (!IsAnonymous(this.Name))
{
    // 添加到编译上下文
    buildContext.AddTempFunc(this.Name, tmpVar);
    // 回写到脚本上下文
    if (buildContext.RewriteLocalVariables && (options?.RewriteFunctions ?? true) && !(options?.Standalone ?? false))
    {
        var addTempFuncExpression = Expression.Call(
            buildContext.GetScriptContextParameter(),
            ScriptUtils.Method_ScriptContext_AddTempFunc,
            Expression.Constant(this.Name),
            tmpVar);
        return Expression.Block(addTempFuncExpression, tmpVar);
    }
}
// 返回函数引用
return tmpVar;

三 编译结果

我们来看看编译开头的脚本示例是什么样的。

var script = new Script();
// 仅生成LambdaExpression，断点调试可以查看DebugView
var lambda = script.Lambda(code);

查看lambda的DebugView信息：

.Lambda #Lambda1<System.Func`2[AScript.ScriptContext,System.Int32]>(AScript.ScriptContext $var1) {
    .Block(System.Func`2[System.Int32,System.Int32] $fib) {
        $fib = .Lambda #Lambda2<System.Func`2[System.Int32,System.Int32]>;
        .Call $var1.AddTempFunc(
            "fib",
            $fib);
        .Invoke $fib(10)
    }
}

.Lambda #Lambda2<System.Func`2[System.Int32,System.Int32]>(System.Int32 $n) {
    .Block(System.Int32 $var2) {
        .If ($n <= 1) {
            .Block() {
                $var2 = $n;
                .Return #Label1 { }
            }
        } .Else {
            .Default(System.Void)
        };
        $var2 = .Invoke $fib($n - 1) + .Invoke $fib($n - 2);
        .Return #Label1 { };
        .Label
        .LabelTarget #Label1:;
        $var2
    }
}

可以看到，首先定义了$fib变量引用fib函数，然后fib函数体调用$fib，实现递归调用。

四 结束语

通过预先定义函数头的方式，不仅能实现递归调用，也可以实现C语言中的函数头定义功能。如果函数在脚本末尾定义，前面如何发现和调用这个函数呢？我们可以把函数头定义放在最前面，函数实现就可以放后面了。

AScript开源地址：

• https://gitee.com/rockey627/AScript
• https://github.com/rockey627/AScript