• 增加VM的并发run
  • 编译函数
  • VM执行函数
  • 函数怎么调用的?
    • 编译阶段
    • 执行阶段
  • 函数怎么退出的?
  • 如何理解字节码?
  • 运行时会改变/增加/删除 global或constant数组吗?
  • CompiledFunction的Free对象指针数组是干什么的?
    • 运行阶段
    • 结论
  • 例子
• tengo指令集和go的操作码
• tengo运行过程
  • 初始状态
  • a := 1 后
  • b := 2 后
  • c := a+b 后
  • f := func(a, b) { return a + b } 后
  • FormatConstants函数
  • 那么什么是constant?
    • constants在何处使用, 在何处定义
    • 为什么constants要传递给NewCompiler?
• extension
  • 为什么extension.UserFunction不生效? -- 注意Copy()方法
    • 调查
    • 结论
  • bash
    • 能够在bash的命令里引用脚本的变量吗?
      • 解决方法
  • 添加新的builtin函数ex()
    • 能否添加到builtinFuncs表
    • 添加到global表
• tengo代码
  • examples/interoperability/main.go
    • 可被注册的对象: native go
    • 可被注册的对象: tengo脚本
    • native go对象穿越脚本的黑魔法
      • dlv调查
      • 对象穿越魔法揭秘
      • 使用注意
    • 总结
  • tengo锁
  • tengo并发
  • 代码组织:
    • 总结
    • error.go
    • require/require.go
    • parser/opcodes.go
    • parser/source_file.go
    • parser/parser.go
      • NewParser()函数
      • ParseFile()函数
    • formatter.go
      • Pool对象池技术
    • tengo.go
      • FromInterface()和ToInterface()函数是go和脚本交互的核心
      • 什么是callable对象
      • CountObjects这个递归函数写的真好
    • script.go
      • Script.Add用于从native go添加变量到tengo脚本
      • NewScript
      • Compile函数
      • preCompile()函数
      • RemoveDuplicates()去掉重复常量?
      • RunContext()函数
      • Run函数
    • variable.go
    • builtins.go
    • compiler.go
      • Compile()函数
      • emit()函数
      • Compile之module
      • compileModule()函数
      • module默认路径
      • Bytecode()函数返回编译好的字节码
    • modules.go
      • module类型: 支持import native go对象和tengo代码
    • symbol_table.go
      • NewSymbolTable()函数
      • Define()函数
      • builtin符号除了保存在store中, 还保存在单独的builtinSymbols中
      • Fork()函数
      • Resolve()函数
      • 总结
    • vm.go
      • VM New函数
      • VM Run函数
      • vm.run总结
    • stdlib/func_typedefs.go
• tengo的后继
• tengo
  • 入门
  • 语法
    • token
  • 一个go调脚本的例子
    • 所有都是值类型
    • tengo值类型和go类型
    • error升级为一等类型
    • 值不可变
    • 未定义也是一种类型
    • 广义的array和map
    • 函数也是值, 一等公民, 支持闭包
    • 变量scope
    • 内置类型转换
    • 支持三目操作
    • []和.能作用于复合类型:array map string和bytes
    • 再切片和go一样
    • if支持前置执行语句, 和go一样; for的结构也和go一样样的; for支持 for in
    • 其他和native go的不同点
  • 内置函数
  • 被嵌入执行
    • 直接代码执行
    • 代码实时"编译"后执行
    • 外部代码里import
  • 用户可以自定义类型
    • 自定义类型举例
    • 增加更多功能
    • 总结
  • 模块化和标准库
    • 标准库
  • runtime对象类型
  • 安全性
  • 并发
  • 这里说的VM感觉就是编译后的"表达树"?
    • 官方例子
  • 更多官方例子
    • gento代码转成lua
    • 有限状态机

1. 增加VM的并发run

思路是浅拷贝当前的VM, 来run一个compiledFunc

1.1. 编译函数

在compiler.go中

// Compile compiles the AST node.
func (c *Compiler) Compile(node parser.Node) error {
    case *parser.FuncLit: //函数编译
        c.enterScope()

        for _, p := range node.Type.Params.List {
            s := c.symbolTable.Define(p.Name)

            // function arguments is not assigned directly.
            s.LocalAssigned = true
        }

        if err := c.Compile(node.Body); err != nil {
            return err
        }

        // code optimization
        c.optimizeFunc(node)

        freeSymbols := c.symbolTable.FreeSymbols() //FreeSymbols函数返回"原始"symbol, 即被捕获的symbol, 所以才包含ScopeLocal和ScopeFree两个类型
        numLocals := c.symbolTable.MaxSymbols()
        instructions, sourceMap := c.leaveScope()

        for _, s := range freeSymbols { //这段没看明白, 这里已经是父函数scope, OpGetFreePtr到栈上? -- 是的. 在定义的时候就把子函数的free变量全部放到栈上备用. 对应VM的OpClosure会把这些free变量放到其
            switch s.Scope {
            case ScopeLocal:
                if !s.LocalAssigned {
                    c.emit(node, parser.OpNull)
                    c.emit(node, parser.OpDefineLocal, s.Index)
                    s.LocalAssigned = true
                }
                c.emit(node, parser.OpGetLocalPtr, s.Index) //捕获了父函数的local变量, s.Index是local变量在栈上相对basePointer的index
            case ScopeFree:
                c.emit(node, parser.OpGetFreePtr, s.Index) //捕获了父函数的free变量, index是父函数freeVar数组中的index
            }
        }

        compiledFunction := &CompiledFunction{
            Instructions:  instructions,
            NumLocals:     numLocals,
            NumParameters: len(node.Type.Params.List),
            VarArgs:       node.Type.Params.VarArgs,
            SourceMap:     sourceMap,
        }
        if len(freeSymbols) > 0 {
            c.emit(node, parser.OpClosure,
                c.addConstant(compiledFunction), len(freeSymbols))
        } else {
            c.emit(node, parser.OpConstant, c.addConstant(compiledFunction))
        }
    case *parser.CallExpr: //函数调用
        if err := c.Compile(node.Func); err != nil {
            return err
        }
        for _, arg := range node.Args {
            if err := c.Compile(arg); err != nil {
                return err
            }
        }
        ellipsis := 0
        if node.Ellipsis.IsValid() {
            ellipsis = 1
        }
        c.emit(node, parser.OpCall, len(node.Args), ellipsis) //OpCall操作码
}

1.2. VM执行函数

func (v *VM) run() {
        case parser.OpCall:
            numArgs := int(v.curInsts[v.ip+1])
            spread := int(v.curInsts[v.ip+2])
            v.ip += 2 //对应编译阶段的emit Opcall, 参数个数, 是否变长

            //比如两个参数的func, 栈是
            //sp-->|      |
            //sp-1 | arg1 |
            //sp-2 | arg0 |
            //sp-3 | func |
            value := v.stack[v.sp-1-numArgs] //sp-3的object就是func
            if !value.CanCall() {
                v.err = fmt.Errorf("not callable: %s", value.TypeName())
                return
            }

            if spread == 1 { //如果最后的参数是变长的, 则那个object必然是array; 把array的成员都展开到栈上, 栈向上增长. 更新numArgs的值
                v.sp--
                switch arr := v.stack[v.sp].(type) {
                case *Array:
                    for _, item := range arr.Value {
                        v.stack[v.sp] = item
                        v.sp++
                    }
                    numArgs += len(arr.Value) - 1
                case *ImmutableArray:
                    for _, item := range arr.Value {
                        v.stack[v.sp] = item
                        v.sp++
                    }
                    numArgs += len(arr.Value) - 1
                default:
                    v.err = fmt.Errorf("not an array: %s", arr.TypeName())
                    return
                }
            }

            if callee, ok := value.(*CompiledFunction); ok {
                if callee.VarArgs {
                    // if the closure is variadic,
                    // roll up all variadic parameters into an array
                    realArgs := callee.NumParameters - 1
                    varArgs := numArgs - realArgs
                    if varArgs >= 0 {
                        numArgs = realArgs + 1
                        args := make([]Object, varArgs)
                        spStart := v.sp - varArgs
                        for i := spStart; i < v.sp; i++ {
                            args[i-spStart] = v.stack[i]
                        }
                        v.stack[spStart] = &Array{Value: args} //这里的操做看起来和上面在栈上展开array正好相反, 把栈上展开后的变长参数们还原回array, 再放到栈上. -- 为啥这样搞? -- 因为要兼容调用native go代码的形式, native go里面, 参数都是变长传入的.
                        v.sp = spStart + 1
                    }
                }
                if numArgs != callee.NumParameters {
                    if callee.VarArgs {
                        v.err = fmt.Errorf(
                            "wrong number of arguments: want>=%d, got=%d",
                            callee.NumParameters-1, numArgs)
                    } else {
                        v.err = fmt.Errorf(
                            "wrong number of arguments: want=%d, got=%d",
                            callee.NumParameters, numArgs)
                    }
                    return
                }

                // test if it's tail-call
                if callee == v.curFrame.fn { // recursion
                    nextOp := v.curInsts[v.ip+1]
                    if nextOp == parser.OpReturn ||
                        (nextOp == parser.OpPop &&
                            parser.OpReturn == v.curInsts[v.ip+2]) {
                        for p := 0; p < numArgs; p++ {
                            v.stack[v.curFrame.basePointer+p] =
                                v.stack[v.sp-numArgs+p]
                        }
                        v.sp -= numArgs + 1
                        v.ip = -1 // reset IP to beginning of the frame
                        continue
                    }
                }
                if v.framesIndex >= MaxFrames {
                    v.err = ErrStackOverflow
                    return
                }

                // update call frame
                v.curFrame.ip = v.ip // store current ip before call
                v.curFrame = &(v.frames[v.framesIndex]) //framesIndex是提前++的, 所以这里就是下一个frame
                v.curFrame.fn = callee
                v.curFrame.freeVars = callee.Free
                v.curFrame.basePointer = v.sp - numArgs //帧指针的初值是sp的当前值减去参数个数
                v.curInsts = callee.Instructions
                v.ip = -1
                v.framesIndex++
                v.sp = v.sp - numArgs + callee.NumLocals //给局部变量留好空间, callee.NumLocals包括了arg的个数
            }
}

举例, 比如2个arg和4个局部变量的栈的初始情况

                    |             | <-- v.sp(frame n)
                    | local obj 3 |
                    | local obj 2 |
                    | local obj 1 |
v.sp(frame n-1) --> | local obj 0 |
                    | arg obj 1   |
                    | arg obj 0   | <-- v.curFrame.basePointer

1.3. 函数怎么调用的?

比如下面的代码

fn := func(i) { return i+1 }
...

res := fn(5) //res=6

是如何编译执行的?

1.3.1. 编译阶段

1. 编译器发现是case *parser.FuncLit:, 就编译func(i) { return i+1 }, 生成compiledFunction对象, 并把这个对象放到constant数组里, emit OpConstant操作码: c.emit(node, parser.OpConstant, c.addConstant(compiledFunction)); 如果是闭包函数, emit parser.OpClosure操做码.
2. tengo不支持声明函数, 而是用赋值模式. 那么上面一步把func(i) { return i+1 }编译完成后, 把compiledFunction对象保存到constant数组, 并马上放到栈上. 因为接下来就是赋值操做
3. 编译器发现接下来马上是case *parser.AssignStmt:对fn变量赋值: 在确定fn的符号位置后, 发送操作码到字节码:

   c.emit(node, parser.OpSetGlobal, symbol.Index)
   //或
   c.emit(node, parser.OpSetLocal, symbol.Index)
   //或
   c.emit(node, parser.OpSetFree, symbol.Index)
   

4. 现在假设代码运行到某处, 需要调用fn:res := fn(5). 编译器需要先解析fn这个符号. 这个例子中fn就是符号引用, 但更复杂的情况可以是res := someMap.fn(5), 下面c.Compile(node.Func)就是解析这个表达式, 最终get到这个compiledFunction对象fn:
   这里面包括两个过程:
   • 4.1. 先把fn放到栈上
   • 4.2. 依次编译args, 把结果args对象依次放到栈上

     case *parser.CallExpr:
        if err := c.Compile(node.Func); err != nil { //最终对应*parser.Ident来确定符号, 对应emit的操做码是OpGetGlobal或OpGetLocal或OpGetBuiltin或OpGetFree, 效果是把compiledFunction对象fn放到栈上
            return err
        }
        for _, arg := range node.Args { //比如这里的arg就是5, 它是个*parser.IntLit, 对应emit操作码OpConstant, 把5放到栈上
            if err := c.Compile(arg); err != nil {
                return err
            }
        }
        ellipsis := 0
        if node.Ellipsis.IsValid() {
            ellipsis = 1
        }
        c.emit(node, parser.OpCall, len(node.Args), ellipsis) //最后emit OpCall
     

     比如

            //比如两个参数的func, 栈是
            //sp-->|      |
            //sp-1 | arg1 |
            //sp-2 | arg0 |
            //sp-3 | func |
     

1.3.2. 执行阶段

VM负责执行

1. 对应编译阶段的前三步, VM执行fn := func(i) { return i+1 }, 效果是把fn这个compiledFunction对象先临时保存在v.stack[v.sp-1]中, 再根据变量scope, 保存在下面三种变量区的一个

   • 全局对象区, 即vm的globals数组中
   • 栈中: 因为上一步已经把fn放在了v.stack[v.sp-1], 这里做的就是把v.stack[v.sp-1]赋值给v.stack[v.curFrame.basePointer + localIndex]. 这个localIndex是操做码里指定的, 编译阶段就知道了
   • frame的free数组中: *v.curFrame.freeVars[freeIndex].Value = v.stack[v.sp-1]

2. VM执行到函数执行阶段res := fn(5)时: 对应case parser.OpCall:

            //比如两个参数的func, 栈是
            //sp-->|      |
            //sp-1 | arg1 |
            //sp-2 | arg0 |
            //sp-3 | func |
   

   进入下一个栈帧前, 做准备:

3. 保存当前ip到父栈帧
4. 准备空的栈帧, 栈帧切换到子函数
5. 子栈帧的fn为子函数callee
6. 子栈帧的freeVars为callee.Free, 此时callee.Free里面已经准备好了
7. 因为参数是父栈帧准备的, 这里子栈帧的basePointer = v.sp - numArgs
8. 子栈帧的字节码为callee.Instructions
9. 子栈帧的ip从-1开始, 正好下一次从0开始执行
10. 把local变量的位置留出来, 子栈帧的sp从local变量区顶部开始. 进入下一个栈帧, 从ip=0开始执行fn.Instructions

                    |             | <-- v.sp(frame n)
                    | local obj 3 |
                    | local obj 2 |
                    | local obj 1 |
v.sp(frame n-1) --> | local obj 0 |
                    | arg obj 1   |
                    | arg obj 0   | <-- v.curFrame.basePointer

1.4. 函数怎么退出的?

在编译阶段, 空的return会c.emit(node, parser.OpReturn, 0) return一个表达式的情况, 会先编译这个表达式, 最终的结果对象放到栈顶, 然后c.emit(node, parser.OpReturn, 1)

执行阶段, 如果发现OpReturn的第二个操作数是1, 就从栈上拿到返回值; 然后还原栈帧, 还原sp, 并把返回值放到栈顶(此时已经是父函数的栈了).

1.5. 如何理解字节码?

看这个文件compiler_test.go

1.6. 运行时会改变/增加/删除 global或constant数组吗?

首先, constant数组是在编译时确定的, 在运行时不改变. 其次, global数组是可以更改的, 但不需要增加/删除, 因为对global的操做的index是在编译时就确定的.

1.7. CompiledFunction的Free对象指针数组是干什么的?

在编译阶段, Resolve symbol的时候, 这个symbol可以是global的, 也可以是自己函数局部的, 还可以是父级函数路径上的局部函数. 最后这种情况就是free变量.

if symbol is defined in parent table and if it's not global/builtin then it's free variable.

free变量是一路父函数上的局部变量, resolve要化不少代价, 所以在编译生成函数对象CompiledFunction的时候就用Free []*ObjectPtr来保存对"捕获"的父函数局部变量的指针.

1.7.1. 运行阶段

只有闭包函数有free变量, 闭包在编译的时候, emit的是OpClosure, 在这之前free变量已经从父函数的local区和free区拷贝到栈上了.

        if len(freeSymbols) > 0 {
            c.emit(node, parser.OpClosure,
                c.addConstant(compiledFunction), len(freeSymbols))
        } else {
            c.emit(node, parser.OpConstant, c.addConstant(compiledFunction))
        }

那么运行时

case parser.OpClosure:
    v.ip += 3
    constIndex := int(v.curInsts[v.ip-1]) | int(v.curInsts[v.ip-2])<<8
    numFree := int(v.curInsts[v.ip])
    fn, ok := v.constants[constIndex].(*CompiledFunction)
    if !ok {
        v.err = fmt.Errorf("not function: %s", fn.TypeName())
        return
    }
    free := make([]*ObjectPtr, numFree) //分配free var的数组
    for i := 0; i < numFree; i++ {
        switch freeVar := (v.stack[v.sp-numFree+i]).(type) { //已经由前一个操作码(parser.FuncLit)提前把所有free变量连续的放到栈上了. 这里拷贝到free数组
        case *ObjectPtr:
            free[i] = freeVar
        default:
            free[i] = &ObjectPtr{
                Value: &v.stack[v.sp-numFree+i],
            }
        }
    }
    v.sp -= numFree
    cl := &CompiledFunction{
        Instructions:  fn.Instructions,
        NumLocals:     fn.NumLocals,
        NumParameters: fn.NumParameters,
        VarArgs:       fn.VarArgs,
        Free:          free, //到这里free数组已经ok
    }
    v.allocs--
    if v.allocs == 0 {
        v.err = ErrObjectAllocLimit
        return
    }
    v.stack[v.sp] = cl
    v.sp++

OpClosure操作码后面应该是接着赋值操做.

还有几个case:

• OpGetFreePtr:从freeVars数组取index对应的ptr到栈顶
• OpGetFree: 从freeVars数组取index的ptr的Value到栈顶
• OpSetFree: 栈顶obj赋值给freeVars数组index对应的ptr, 注意是赋值给*ptr
• OpGetLocalPtr: 把本frame的指定local变量v.stack[v.curFrame.basePointer + localIndex], 封装为*ObjectPtr, 放到栈顶.
• OpSetSelFree: 把selectors序列对应的对象依次写入v.curFrame.freeVars

1.7.2. 结论

• 子函数可以是普通的函数, 也可以是Closure, 他们都是compiledFunction. 区别在于函数声明后, 必定会赋值到一个变量. 到变量赋值这里后, closure的compiledFunction的Free域就有值了, 这些值是指针, 是对free变量的指针表.
• 闭包对free变量的访问不是去父函数路径上的栈里去找, 而是去自己的free变量的指针表里操做.

1.8. 例子

比如下面的代码

f1 := func(a, b) { return a + b}; func(fn, ...args){ return fn(args...) }(f1, 1, 2)

会被编译成

0000 CONST   0     //对应第一个函数从const 0取到栈顶
0003 SETG    0     //对应f1的赋值
0006 CONST   1     //对应第二个函数从const 1取到栈顶
0009 GETG    0     //对应f1入参
0012 CONST   2     //对应常量1入参
0015 CONST   3     //对应常量2入参
0018 CALL    3     0     //对应函数调用
0021 POP           //对应这块代码无返回值
0022 SUSPEND       //对应这块代码的结束

对应的const数组

[  0] (Compiled Function|0xc0000946e8)
     0000 GETL    0    //对应得到入参a
     0002 GETL    1    //对应得到入参b
     0004 BINARYOP 11  //a+b
     0006 RET     1    //return 值
[  1] (Compiled Function|0xc0000946f0)
     0000 GETL    0    //对应得到fn
     0002 GETL    1    //对应应该传入的args
     0004 CALL    1     1    //call一个参数, 最后一个参数变长
     0007 RET     1    //return栈上的值
[  2] 1 (Int|0xc0000fd1e0)
[  3] 2 (Int|0xc0000fd200)

2. tengo指令集和go的操作码

GO的编译器也有自己一套的”操作码”.

是对所有CPU指令集的common抽象, 比如下面的CALL就相当于MIPS指令集的jal或者ARM的blr

Tengo的指令级比这个”高阶”, 比如数据访问永远都是以obj为单位. 但基本上思路是一样的.

3. tengo运行过程

在REPL中加打印, 主要考察符号表, 全局变量, 和constants

3.1. 初始状态

symbols: &tengo.SymbolTable{parent:(*tengo.SymbolTable)(nil), block:false, store:map[string]*tengo.Symbol{"ex":(*tengo.Symbol)(0xc0000df980), "show":(*tengo.Symbol)(0xc0000df9e0)}, numDe$
inition:2, maxDefinition:2, freeSymbols:[]*tengo.Symbol(nil), builtinSymbols:[]*tengo.Symbol(nil)}

没有父table, 是全局符号表. 里面有内建的两个函数: ex和show. 没毛病 constant为空 global只有两个, 对应ex和show. 没毛病

globals: []tengo.Object{(*tengo.UserFunction)(0xc0000df9b0), (*tengo.UserFunction)(0xc0000dfa10), ...后面都是nil

3.2. a := 1 后

symtable由于第一次执行后, 多了内置的很多函数, 也多了变量a

symbols: &tengo.SymbolTable{parent:(*tengo.SymbolTable)(nil), 
block:false, store:map[string]*tengo.Symbol{"a":(*tengo.Symbol)(0xc00018e690), "append":(*tengo.Symbol)(0xc00018e0f0), "bool":(*tengo.Symbol)(0xc00018e1e0), "bytes":(*tengo.Symbol)(0xc00018e270), "char":(*tengo.Symbol)(0xc00018e240), "copy":(*tengo.Symbol)(0xc00018e0c0), "delete":(*tengo.Symbol)(0xc00018e120), "ex":(*tengo.Symbol)(0xc0000df980), "float":(*tengo.Symbol)(0xc00018e210), "format":(*tengo.Symbol)(0xc00018e600), "int":(*tengo.Symbol)(0xc00018e1b0), "is_array":(*tengo.Symbol)(0xc00018e3f0), "is_bool":(*tengo.Symbol)(0xc00018e360), "is_bytes":(*tengo.Symbol)(0xc00018e3c0), "is_callable":(*tengo.Symbol)(0xc00018e5a0), "is_char":(*tengo.Symbol)(0xc00018e390), "is_error":(*tengo.Symbol)(0xc00018e510), "is_float":(*tengo.Symbol)(0xc00018e300), "is_function":(*tengo.Symbol)(0xc00018e570), "is_immutable_array":(*tengo.Symbol)(0xc00018e420), "is_immutable_map":(*tengo.Symbol)(0xc00018e480), "is_int":(*tengo.Symbol)(0xc00018e2d0), "is_iterable":(*tengo.Symbol)(0xc00018e4b0), "is_map":(*tengo.Symbol)(0xc00018e450), "is_string":(*tengo.Symbol)(0xc00018e330), "is_time":(*tengo.Symbol)(0xc00018e4e0), "is_undefined":(*tengo.Symbol)(0xc00018e540), "len":(*tengo.Symbol)(0xc00018e090), "show":(*tengo.Symbol)(0xc0000df9e0), "splice":(*tengo.Symbol)(0xc00018e150), "string":(*tengo.Symbol)(0xc00018e180), "time":(*tengo.Symbol)(0xc00018e2a0), "type_name":(*tengo.Symbol)(0xc00018e5d0)}, 
numDefinition:3, 
maxDefinition:3, 
freeSymbols:[]*tengo.Symbol(nil), 
builtinSymbols:[]*tengo.Symbol{(*tengo.Symbol)(0xc00018e090), (*tengo.Symbol)(0xc00018e0c0), (*tengo.Symbol)(0xc00018e0f0), (*tengo.Symbol)(0xc00018e120), (*tengo.Symbol)(0xc00018e150), (*tengo.Symbol)(0xc00018e180), (*tengo.Symbol)(0xc00018e1b0), (*tengo.Symbol)(0xc00018e1e0), (*tengo.Symbol)(0xc00018e210), (*tengo.Symbol)(0xc00018e240), (*tengo.Symbol)(0xc00018e270), (*tengo.Symbol)(0xc00018e2a0), (*tengo.Symbol)(0xc00018e2d0), (*tengo.Symbol)(0xc00018e300), (*tengo.Symbol)(0xc00018e330), (*tengo.Symbol)(0xc00018e360), (*tengo.Symbol)(0xc00018e390), (*tengo.Symbol)(0xc00018e3c0), (*tengo.Symbol)(0xc00018e3f0), (*tengo.Symbol)(0xc00018e420), (*tengo.Symbol)(0xc00018e450), (*tengo.Symbol)(0xc00018e480), (*tengo.Symbol)(0xc00018e4b0), (*tengo.Symbol)(0xc00018e4e0), (*tengo.Symbol)(0xc00018e510), (*tengo.Symbol)(0xc00018e540), (*tengo.Symbol)(0xc00018e570), (*tengo.Symbol)(0xc00018e5a0), (*tengo.Symbol)(0xc00018e5d0), (*tengo.Symbol)(0xc00018e600)}}

constant多了一个

constants: []tengo.Object{(*tengo.Int)(0xc000138028)}

globals多了一个, 多的这个和constant多出来的是一个地址.

globals: []tengo.Object{(*tengo.UserFunction)(0xc0000df9b0), (*tengo.UserFunction)(0xc0000dfa10), (*tengo.Int)(0xc000138028)

3.3. b := 2 后

symbol表多了b, 但似乎其他的符号地址都变了. -- 这里好像有bug

symbols: &tengo.SymbolTable{parent:(*tengo.SymbolTable)(nil), block:false, store:map[string]*tengo.Symbol{"a":(*tengo.Symbol)(0xc00018e690), "append":(*tengo.Symbol)(0xc00020a0f0), "b":(*tengo.Symbol)(0xc00020a690), "bool":(*tengo.Symbol)(0xc00020a1e0), "bytes":(*tengo.Symbol)(0xc00020a270), "char":(*tengo.Symbol)(0xc00020a240), "copy":(*tengo.Symbol)(0xc00020a0c0), "delete":(*tengo.Symbol)(0xc00020a120), "ex":(*tengo.Symbol)(0xc0000df980), "float":(*tengo.Symbol)(0xc00020a210), "format":(*tengo.Symbol)(0xc00020a600), "int":(*tengo.Symbol)(0xc00020a1b0), "is_array":(*tengo.Symbol)(0xc00020a3f0), "is_bool":(*tengo.Symbol)(0xc00020a360), "is_bytes":(*tengo.Symbol)(0xc00020a3c0), "is_callable":(*tengo.Symbol)(0xc00020a5a0), "is_char":(*tengo.Symbol)(0xc00020a390), "is_error":(*tengo.Symbol)(0xc00020a510), "is_float":(*tengo.Symbol)(0xc00020a300), "is_function":(*tengo.Symbol)(0xc00020a570), "is_immutable_array":(*tengo.Symbol)(0xc00020a420), "is_immutable_map":(*tengo.Symbol)(0xc00020a480), "is_int":(*tengo.Symbol)(0xc00020a2d0), "is_iterable":(*tengo.Symbol)(0xc00020a4b0), "is_map":(*tengo.Symbol)(0xc00020a450), "is_string":(*tengo.Symbol)(0xc00020a330), "is_time":(*tengo.Symbol)(0xc00020a4e0), "is_undefined":(*tengo.Symbol)(0xc00020a540), "len":(*tengo.Symbol)(0xc00020a090), "show":(*tengo.Symbol)(0xc0000df9e0), "splice":(*tengo.Symbol)(0xc00020a150), "string":(*tengo.Symbol)(0xc00020a180), "time":(*tengo.Symbol)(0xc00020a2a0), "type_name":(*tengo.Symbol)(0xc00020a5d0)}, numDefinition:4, maxDefinition:4, freeSymbols:[]*tengo.Symbol(nil), builtinSymbols:[]*tengo.Symbol{(*tengo.Symbol)(0xc00018e090), (*tengo.Symbol)(0xc00018e0c0), (*tengo.Symbol)(0xc00018e0f0), (*tengo.Symbol)(0xc00018e120), (*tengo.Symbol)(0xc00018e150), (*tengo.Symbol)(0xc00018e180), (*tengo.Symbol)(0xc00018e1b0), (*tengo.Symbol)(0xc00018e1e0), (*tengo.Symbol)(0xc00018e210), (*tengo.Symbol)(0xc00018e240), (*tengo.Symbol)(0xc00018e270), (*tengo.Symbol)(0xc00018e2a0), (*tengo.Symbol)(0xc00018e2d0), (*tengo.Symbol)(0xc00018e300), (*tengo.Symbol)(0xc00018e330), (*tengo.Symbol)(0xc00018e360), (*tengo.Symbol)(0xc00018e390), (*tengo.Symbol)(0xc00018e3c0), (*tengo.Symbol)(0xc00018e3f0), (*tengo.Symbol)(0xc00018e420), (*tengo.Symbol)(0xc00018e450), (*tengo.Symbol)(0xc00018e480), (*tengo.Symbol)(0xc00018e4b0), (*tengo.Symbol)(0xc00018e4e0), (*tengo.Symbol)(0xc00018e510), (*tengo.Symbol)(0xc00018e540), (*tengo.Symbol)(0xc00018e570), (*tengo.Symbol)(0xc00018e5a0), (*tengo.Symbol)(0xc00018e5d0), (*tengo.Symbol)(0xc00018e600), (*tengo.Symbol)(0xc00020a090), (*tengo.Symbol)(0xc00020a0c0), (*tengo.Symbol)(0xc00020a0f0), (*tengo.Symbol)(0xc00020a120), (*tengo.Symbol)(0xc00020a150), (*tengo.Symbol)(0xc00020a180), (*tengo.Symbol)(0xc00020a1b0), (*tengo.Symbol)(0xc00020a1e0), (*tengo.Symbol)(0xc00020a210), (*tengo.Symbol)(0xc00020a240), (*tengo.Symbol)(0xc00020a270), (*tengo.Symbol)(0xc00020a2a0), (*tengo.Symbol)(0xc00020a2d0), (*tengo.Symbol)(0xc00020a300), (*tengo.Symbol)(0xc00020a330), (*tengo.Symbol)(0xc00020a360), (*tengo.Symbol)(0xc00020a390), (*tengo.Symbol)(0xc00020a3c0), (*tengo.Symbol)(0xc00020a3f0), (*tengo.Symbol)(0xc00020a420), (*tengo.Symbol)(0xc00020a450), (*tengo.Symbol)(0xc00020a480), (*tengo.Symbol)(0xc00020a4b0), (*tengo.Symbol)(0xc00020a4e0), (*tengo.Symbol)(0xc00020a510), (*tengo.Symbol)(0xc00020a540), (*tengo.Symbol)(0xc00020a570), (*tengo.Symbol)(0xc00020a5a0), (*tengo.Symbol)(0xc00020a5d0), (*tengo.Symbol)(0xc00020a600)}}

constant多了一个, 就是b

constants: []tengo.Object{(*tengo.Int)(0xc000138028), (*tengo.Int)(0xc00012a178)}

globals也多了这一个

globals: []tengo.Object{(*tengo.UserFunction)(0xc0000df9b0), (*tengo.UserFunction)(0xc0000dfa10), (*tengo.Int)(0xc000138028), (*tengo.Int)(0xc00012a178)

3.4. c := a+b 后

symbol table多了c, 但还是之前的问题: builtin的符号都被重新注册了一次, 地址都变了.
但constants没有变化, 即c不是constant
globals多了c, 其他都一样.

globals: []tengo.Object{(*tengo.UserFunction)(0xc0000df9b0), (*tengo.UserFunction)(0xc0000dfa10), (*tengo.Int)(0xc000138028), (*tengo.Int)(0xc00012a178), (*tengo.Int)(0xc0001e4228)

3.5. f := func(a, b) { return a + b } 后

首先符号表多了f这个没有疑问. constants多了f, 类型是CompiledFunction

constants: []tengo.Object{(*tengo.Int)(0xc000138028), (*tengo.Int)(0xc00012a178), (*tengo.CompiledFunction)(0xc0000c86e0)}

这个f也出现在globals里面

globals: []tengo.Object{(*tengo.UserFunction)(0xc0000df9b0), (*tengo.UserFunction)(0xc0000dfa10), (*tengo.Int)(0xc000138028), (*tengo.Int)(0xc00012a178), (*tengo.Int)(0xc0001e4228), (*ten
go.CompiledFunction)(0xc0000c86e0)

3.6. FormatConstants函数

这个函数可以查看constant的值, 比如:

fmt.Println(bytecode.FormatConstants())

会打印:

[[  0] 1 (Int|0xc0000f4920) [  1] 2 (Int|0xc0000f4950) [  2] (Compiled Function|0xc0000c4730)      0000 GETL    0          0002 GETL    1          0004 BINARYOP 11         0006 RET     1    ]

这个Compiled Function和汇编的风格很像. 同时可以看到FormatConstants函数能够把编译后的字节码打印出来.

3.7. 那么什么是constant?

为什么constants数组在编译和运行时段都存在?
constants是个对象数组, 保存的是固定值的变量, 比如上文的

a := 1
b := 2
f := func(a, b){...}

3.7.1. constants在何处使用, 在何处定义

首先, VM在运行的时候, 在当前指令是parser.OpConstant的时候, 回去constants数组找需要的对象: v.stack[v.sp] = v.constants[cidx]

func (v *VM) run() {
    for atomic.LoadInt64(&v.aborting) == 0 {
        v.ip++

        switch v.curInsts[v.ip] {
        case parser.OpConstant:
            v.ip += 2
            cidx := int(v.curInsts[v.ip]) | int(v.curInsts[v.ip-1])<<8

            v.stack[v.sp] = v.constants[cidx]
            v.sp++

注意, constants对象数组是靠index来索引的.

这些constant对象, 是在编译的时候, 编译器发现a := 1变量是个常量, 就把它放到constants数组里, 并emit parser.OpConstant指令.

func (c *Compiler) addConstant(o Object) int {
    if c.parent != nil {
        // module compilers will use their parent's constants array
        return c.parent.addConstant(o)
    }
    c.constants = append(c.constants, o)
    if c.trace != nil {
        c.printTrace(fmt.Sprintf("CONST %04d %s", len(c.constants)-1, o))
    }
    return len(c.constants) - 1
}

// Compile compiles the AST node.
func (c *Compiler) Compile(node parser.Node) error {
    ...
    case *parser.IntLit:
        c.emit(node, parser.OpConstant,
            c.addConstant(&Int{Value: node.Value}))
    case *parser.FloatLit:
        c.emit(node, parser.OpConstant,
            c.addConstant(&Float{Value: node.Value}))

3.7.2. 为什么constants要传递给NewCompiler?

主要是用在REPL场景下, 把上一次的constants传递给这一次, 因为REPL是增量式编译执行模式, 需要前面的常量表和符号表, 而增量式的run也需要上一次的globals表.

            srcFile := fileSet.AddFile("repl", -1, len(line))
            p := parser.NewParser(srcFile, []byte(line), nil)
            file, err := p.ParseFile()
            if err != nil {
                fmt.Println(err)
                continue
            }

            c := tengo.NewCompiler(srcFile, sh.symbolTable, constants, sh.modules, nil)
            if err := c.Compile(file); err != nil {
                fmt.Println(err)
                continue
            }

            bytecode := c.Bytecode()
            bytecode.RemoveDuplicates()
            machine := tengo.NewVM(bytecode, sh.globals, -1)
            if err := machine.Run(); err != nil {
                fmt.Println(err)
                continue
            }
            constants = bytecode.Constants
            fmt.Println(bytecode.FormatConstants())

4. extension

4.1. 为什么extension.UserFunction不生效? -- 注意Copy()方法

我在eobjects.go里面, 继承了tengo.UserFunction

type UserFunction struct {
    tengo.UserFunction
    Signature string
    Help string
}

我是想重载String方法, 这样fmt.println会调用到这个String方法, 显示help信息.

func (o *UserFunction) TypeName() string {
    return "user-function(extended):" + o.Name
}

func (o *UserFunction) String() string {
    return o.Signature + "\n" + o.Help
}

在注册function的时候, 类型为&extension.UserFunction 编译通过, 似乎没问题.

var module = map[string]tengo.Object{
    "newx": &extension.UserFunction{
        UserFunction: tengo.UserFunction{
            Name:  "new",
            Value: newStat,
        },
        Signature: "new({option1:true, option2:false}) => statCollector",
        Help: "option can be ",
    }, // new({option1:true, option2:false}) => statCollector
}

但为什么还是调到了原tengo.UserFunction? 应该会打印帮助文本啊???

pidstat := import("pidstat")
fmt := import("fmt")
fmt.println(pidstat)
{newx: <user-function>, __module_name__: "pidstat"}

4.1.1. 调查

用vscode和dlv调查, 发现在注册的时候是对的, object类型是&extension.UserFunction

"newx": <github.com/d5/tengo/v2.Object(*bhgitlab.int.net.nokia.com/godev/gshell/extension.UserFunction)>)
    data: <*bhgitlab.int.net.nokia.com/godev/gshell/extension.UserFunction>(0xc0000f8050)

但调用到fmt.println的时候, 传入的object类型就变成了

<github.com/d5/tengo/v2.Object(*github.com/d5/tengo/v2.UserFunction)>)

是go的"继承"系统出了问题吗? 看起来像是对象从派生类变成基类了? -- 不是. go的继承没问题. 问题在注册module对象的时候, 返回了原module对象的Copy()方法, 目的是返回一个ImmutableMap

// BuiltinModule is an importable module that's written in Go.
type BuiltinModule struct {
    Attrs map[string]Object
}

// Import returns an immutable map for the module.
func (m *BuiltinModule) Import(moduleName string) (interface{}, error) {
    return m.AsImmutableMap(moduleName), nil
}

// AsImmutableMap converts builtin module into an immutable map.
func (m *BuiltinModule) AsImmutableMap(moduleName string) *ImmutableMap {
    attrs := make(map[string]Object, len(m.Attrs))
    for k, v := range m.Attrs {
        attrs[k] = v.Copy()
    }
    attrs["__module_name__"] = &String{Value: moduleName}
    return &ImmutableMap{Value: attrs}
}

注意AsImmutableMap()函数里面, 调用了attrs[k] = v.Copy() 问题就出在这里: 我继承了基类的Copy()方法:

// Copy returns a copy of the type.
func (o *UserFunction) Copy() Object {
    return &UserFunction{Value: o.Value}
}

它返回一个tengo.UserFunction对象. 所以后面fmt.println()的时候, 实际打印的是这个对象.

4.1.2. 结论

• tengo在注册module的时候, 为了不改变原对象, 对原对象进行了Copy(), 返回了immutable对象.
• immutable对象实际是调用原对象的Copy()方法来的, 要extend的话, 需要自己实现Copy()方法.

4.2. bash

4.2.1. 能够在bash的命令里引用脚本的变量吗?

file := "test"
fmt.println(bash.run(`touch $file`).output())

简单回答: 不能. 因为bash.run()实际是调用的native go的代码, 调用的时候已经是在tengo的VM中运行的字节码调用的. 在ast阶段是有符号概念的, 但ast编译成字节码之后, 符号已经变成了"地址"了.
所以, 调用到bash.run()时, 已经没有"file"这个变量了, 只有其对应的地址.

除非在ast中新增对$的解析, 在ast编译成字节码的阶段, 把touch $file对file的访问, emit成一个GetLocal的op. 比如c.emit(node, parser.OpGetLocal, symbol.Index)

解决方法

只有分两步走:

file := "testfile"
cmd := fmt.sprintf("touch %s", file)
fmt.println(bash.run(cmd).output())

注: 使用tengo内置的format函数更简单点

pid := 10086
fmt.println(format("hello %d", pid))

4.3. 添加新的builtin函数ex()

4.3.1. 能否添加到builtinFuncs表

先说结论: tengo的builtin函数表是固定的, 外面无法更改.

builtins.go中, 有个固化的表:

var builtinFuncs = []*BuiltinFunction{
    {
        Name:  "len",
        Value: builtinLen,
    },
    {
        Name:  "copy",
        Value: builtinCopy,
    },
}

调用这个表里的函数, 不是以字符串方式查找函数的, 而是index: vm.go执行字节码阶段的run()函数:

        case parser.OpGetBuiltin:
            v.ip++
            builtinIndex := int(v.curInsts[v.ip])
            v.stack[v.sp] = builtinFuncs[builtinIndex]
            v.sp++

从字节码里面取出builtinIndex, 查找builtinFuncs, 得到函数, 放到stack上.

而字节码的builtinIndex, 是在编译阶段compiler.go中Compile()函数:

    case *parser.Ident:
        symbol, _, ok := c.symbolTable.Resolve(node.Name, false)
        if !ok {
            return c.errorf(node, "unresolved reference '%s'", node.Name)
        }

        switch symbol.Scope {
        case ScopeGlobal:
            c.emit(node, parser.OpGetGlobal, symbol.Index)
        case ScopeLocal:
            c.emit(node, parser.OpGetLocal, symbol.Index)
        case ScopeBuiltin:
            c.emit(node, parser.OpGetBuiltin, symbol.Index)
        case ScopeFree:
            c.emit(node, parser.OpGetFree, symbol.Index)
        }

对符号的处理, 统一都是Resolve()当前的symbolTable, 得到symbol的Index信息, emit到字节码中. 字节码里面已经没有符号, 都是通过index来操作的. 这样最高效.

而最开始的符号, 是初始化的时候加的: gshell.go中runREPL()函数

    symbolTable := tengo.NewSymbolTable()
    for idx, fn := range tengo.GetAllBuiltinFunctions() {
        symbolTable.DefineBuiltin(idx, fn.Name)
    }

这里只是加了符号表信息, 把符号的名字和index对上. 实际运行阶段, 按前文所述, vm会去builtinFuncs表中找.

4.3.2. 添加到global表

函数也是对象, 那就可以当作"全局变量"添加到global表: 在symbolTable里定义一个ex的符号, 用返回的index和globals里面实际定义的函数对应起来.

    globals := make([]tengo.Object, tengo.GlobalsSize)
    symbolTable := tengo.NewSymbolTable()

    symbol := symbolTable.Define("ex")
    globals[symbol.Index] = &tengo.UserFunction{
        Name: "ex",
        Value: func(args ...tengo.Object) (ret tengo.Object, err error) {
            if len(args) != 1 {
                return nil, tengo.ErrWrongNumArguments
            }
            return extension.ExtendObj(args[0])
        },
    }

然后在NewCompiler()的时候传入symbolTable; 在NewVM()的时候传入globals 因为之前符号表和全局变量对的上, 那么运行时就能找到正确的函数.

5. tengo代码

从简单的例子开始:

import "github.com/d5/tengo/v2"

var code = `
reduce := func(seq, fn) {
    s := 0
    for x in seq { fn(x, s) }
    return s
}

print(reduce([1, 2, 3], func(x, s) { s += x }))
`

func main() {
    s := tengo.NewScript([]byte(code))
    if _, err := s.Run(); err != nil {
        panic(err)
    }
}

上面是直接运行的例子. 下面是编译成字节码后运行的例子.

s := tengo.NewScript([]byte(`a := b + 20`))
s.Add("b", 10)
c, err := s.Compile()
err := c.Run()
a := c.Get("a")
c.Set("b", 20)
c.Run()

5.1. examples/interoperability/main.go

func main() {
    src := `
     // goproxy and proxy must be imported.
     goproxy := import("goproxy")
     proxy := import("proxy")

     global := 0

     callbacks := {
         sum: func(a, b) {
             return a + b
         },
         multiply: func(a, b) {
             return a * b
         },
         increment: func() {
             global++
             return global
         }
     }

     // Register callbacks to call them in goproxy loop.
     goproxy.register(callbacks)

     // goproxy loop waits for new call requests and run them with the help of
     // "proxy" source module. Cancelling the context breaks the loop.
     for goproxy.next() {
         proxy(goproxy.args())
     }
`
    // 5 seconds context timeout is enough for an example.
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    script := tengo.NewScript([]byte(src))
    moduleMap := tengo.NewModuleMap()
    goproxy := NewGoProxy(ctx)
    // register modules
    moduleMap.AddBuiltinModule("goproxy", goproxy.ModuleMap())
    moduleMap.AddSourceModule("proxy", []byte(ProxySource))
    script.SetImports(moduleMap)

    compiled, err := script.Compile()
    if err != nil {
        panic(err)
    }

    // call "sum", "multiply", "increment" functions from tengo in a new goroutine
    go func() {
        callChan := goproxy.CallChan()
        result := make(chan tengo.Object, 1)
        // TODO: check tengo error from result channel.
    loop:
        for {
            select {
            case <-ctx.Done():
                break loop
            default:
            }
            fmt.Println("Calling tengo sum function")
            i1, i2 := rand.Int63n(100), rand.Int63n(100)
            callChan <- &CallArgs{Func: "sum",
                Params: []tengo.Object{&tengo.Int{Value: i1},
                    &tengo.Int{Value: i2}},
                Result: result,
            }
            v := <-result
            fmt.Printf("%d + %d = %v\n", i1, i2, v)

            fmt.Println("Calling tengo multiply function")
            i1, i2 = rand.Int63n(20), rand.Int63n(20)
            callChan <- &CallArgs{Func: "multiply",
                Params: []tengo.Object{&tengo.Int{Value: i1},
                    &tengo.Int{Value: i2}},
                Result: result,
            }
            v = <-result
            fmt.Printf("%d * %d = %v\n", i1, i2, v)

            fmt.Println("Calling tengo increment function")
            callChan <- &CallArgs{Func: "increment", Result: result}
            v = <-result
            fmt.Printf("increment = %v\n", v)
            time.Sleep(1 * time.Second)
        }
    }()

    if err := compiled.RunContext(ctx); err != nil {
        fmt.Println(err)
    }
}

5.1.1. 可被注册的对象: native go

// NewGoProxy creates GoProxy object.
func NewGoProxy(ctx context.Context) *GoProxy {
    mod := new(GoProxy)
    mod.ctx = ctx
    mod.callbacks = make(map[string]tengo.Object)
    mod.callChan = make(chan *CallArgs, 1)
    mod.moduleMap = map[string]tengo.Object{
        "next":     &tengo.UserFunction{Value: mod.next},
        "register": &tengo.UserFunction{Value: mod.register},
        "args":     &tengo.UserFunction{Value: mod.args},
    }
    mod.tasks = list.New()
    return mod
}

// GoProxy is a builtin tengo module to register tengo functions and run them.
type GoProxy struct {
    tengo.ObjectImpl //匿名包含tengo.ObjectImpl就是tengo的Object
    ctx       context.Context
    moduleMap map[string]tengo.Object
    callbacks map[string]tengo.Object
    callChan  chan *CallArgs
    tasks     *list.List
    mtx       sync.Mutex
}

上面的mod.next mod.args等符号, 是函数: 比如

func (mod *GoProxy) register(args ...tengo.Object) (tengo.Object, error) {
    if len(args) == 0 {
        return nil, tengo.ErrWrongNumArguments
    }
    mod.mtx.Lock()
    defer mod.mtx.Unlock()

    switch v := args[0].(type) {
    case *tengo.Map:
        mod.callbacks = v.Value
    case *tengo.ImmutableMap:
        mod.callbacks = v.Value
    default:
        return nil, tengo.ErrInvalidArgumentType{
            Name:     "first",
            Expected: "map",
            Found:    args[0].TypeName(),
        }
    }
    return tengo.UndefinedValue, nil
}

这些函数必须符合CallableFunc签名:

// CallableFunc is a function signature for the callable functions.
type CallableFunc = func(args ...Object) (ret Object, err error)

注意, 这里mod.register等函数, 在语法上是*GoProxy的方法, 为什么符合CallableFunc签名呢?
tengo脚本里面的
goproxy.register(callbacks) 又是怎么调用到func (mod *GoProxy) register(args ...tengo.Object) (tengo.Object, error)的呢? 这里的receiver是从哪里来的呢?
还有, New过的goproxy, 怎么在脚本和native go之前共享的呢?
goproxy := NewGoProxy(ctx)
见 native go对象穿越脚本的黑魔法

注:

• native go也可以调用tengo的函数
  脚本的goproxy.register(callbacks)其实会调用到native go的register函数, 而它的callbacks是tengo脚本里的函数

  global := 0
  
     callbacks := {
         sum: func(a, b) {
             return a + b
         },
         multiply: func(a, b) {
             return a * b
         },
         increment: func() {
             global++
             return global
         }
     }
  

  上面的脚本函数对应native go的*tengo.CompiledFunction对象. 在neitive go里断言得到compiledFunc对象.

  //mod.callbacks是在register的时候赋值的
  //mod.callbacks = v.Value
  f, ok := mod.callbacks[callArgs.Func]
  compiledFunc, ok := f.(*tengo.CompiledFunction)
  

  然后return一个不可改的tengo.Map

  return &tengo.ImmutableMap{
  
    Value: map[string]tengo.Object{
        ...
        "callable":   compiledFunc,
    }
  }
  

  通过这个对象, 脚本就又可以调用"callable"函数了, 即最终, 脚本调用"callable"是compiledFunc, 而后者就是从tengo脚本compile来的.

• 通常使用类型断言来解参数, 比如

    switch v := args[0].(type) {
    case *tengo.Map:
        mod.callbacks = v.Value
    case *tengo.ImmutableMap:
        mod.callbacks = v.Value
  

  这需要直到tengo中Object的具体类型的定义:

  type Map struct {
    ObjectImpl
    Value map[string]Object
  }
  

• native go里实现的函数, 可以做参数检查: 在这里是提示tengo脚本里的入参类型不对

    default:
        return nil, tengo.ErrInvalidArgumentType{
            Name:     "first",
            Expected: "map",
            Found:    args[0].TypeName(),
        }
  

从tengo脚本调用native go的过程就是解tengo.Object到go对象, 运算, 再返回tengo.Object的过程

函数方法返回的Object, 可以继续是一个BuiltinModule

func (mod *GoProxy) args(args ...tengo.Object) (tengo.Object, error) {
    mod.mtx.Lock()
    defer mod.mtx.Unlock()

    if mod.tasks.Len() == 0 {
        return tengo.UndefinedValue, nil
    }
    el := mod.tasks.Front()
    callArgs, ok := el.Value.(*CallArgs)
    if !ok || callArgs == nil {
        return nil, errors.New("invalid call arguments")
    }
    mod.tasks.Remove(el)
    f, ok := mod.callbacks[callArgs.Func]
    if !ok {
        return tengo.UndefinedValue, nil
    }
    compiledFunc, ok := f.(*tengo.CompiledFunction)
    if !ok {
        return tengo.UndefinedValue, nil
    }
    params := callArgs.Params
    if params == nil {
        params = make([]tengo.Object, 0)
    }
    // callable.VarArgs implementation is omitted.
    return &tengo.ImmutableMap{
        Value: map[string]tengo.Object{
            "result": &tengo.UserFunction{
                Value: func(args ...tengo.Object) (tengo.Object, error) {
                    if len(args) > 0 {
                        callArgs.Result <- args[0]
                        return tengo.UndefinedValue, nil
                    }
                    callArgs.Result <- &tengo.Error{
                        Value: &tengo.String{
                            Value: tengo.ErrWrongNumArguments.Error()},
                    }
                    return tengo.UndefinedValue, nil
                }},
            "num_params": &tengo.Int{Value: int64(compiledFunc.NumParameters)},
            "callable":   compiledFunc,
            "params":     &tengo.Array{Value: params},
        },
    }, nil
}

注:

• native go&tengo.ImmutableMap中的"params": &tengo.Array{Value: params},可以被tengo脚本使用: v = callable(args.params[0], args.params[1], args.params[2])

5.1.2. 可被注册的对象: tengo脚本

在main()中import了tengo的源码:

moduleMap.AddSourceModule("proxy", []byte(ProxySource))

脚本源码在此:

// ProxySource is a tengo script to handle bidirectional arguments flow between
// go and pure tengo functions. Note: you should add more if conditions for
// different number of parameters.
// TODO: handle variadic functions.
var ProxySource = `
 export func(args) {
     if is_undefined(args) {
         return
     }
     callable := args.callable
     if is_undefined(callable) {
         return
     }
     result := args.result
     num_params := args.num_params
     v := undefined
     // add more else if conditions for different number of parameters.
     if num_params == 0 {
         v = callable()
     } else if num_params == 1 {
         v = callable(args.params[0])
     } else if num_params == 2 {
         v = callable(args.params[0], args.params[1])
     } else if num_params == 3 {
         v = callable(args.params[0], args.params[1], args.params[2])
     }
     result(v)
 }
 `

注:

• 要在外部脚本引用的对象, 用export关键词导出

5.1.3. native go对象穿越脚本的黑魔法

在native go中, New了对象后, 只是把goproxy的moduleMap注册给script

goproxy := NewGoProxy(ctx)
moduleMap.AddBuiltinModule("goproxy", goproxy.ModuleMap())

其中, 这个map包括了这个模块支持的方法

    mod.moduleMap = map[string]tengo.Object{
        "next":     &tengo.UserFunction{Value: mod.next},
        "register": &tengo.UserFunction{Value: mod.register},
        "args":     &tengo.UserFunction{Value: mod.args},
    }

比如, register函数原型是

func (mod *GoProxy) register(args ...tengo.Object) (tengo.Object, error)

被包装成了&tengo.UserFunction{Value: mod.register}保存在goproxy.ModuleMap中

而在tengo脚本中, import只是得到这个map, 就直接调用native go的register方法了

goproxy := import("goproxy")
//调用native go的方法
goproxy.register(callbacks)

那么问题是, receiver哪去了? 没有receiver怎么调用

dlv调查

tengo脚本经过compile后, Run这个字节码:

compiled.RunContext(ctx)
    vm.run()的执行循环中
        for atomic.LoadInt64(&v.aborting) == 0 {
            v.ip++
            switch v.curInsts[v.ip] {
            case parser.OpCall:
                //支持CompiledFunction类型的执行, 这块对应tengo编译后的函数
                //但这里走的是UserFunction的分支
                    var args []Object
                    args = append(args, v.stack[v.sp-numArgs:v.sp]...)
                    //这里就是函数调用了
                    //value的静态类型是tengo.Object, 动态类型是tengo.UserFunction
                    //其值是main.(*GoProxy).register-fm, 见下图当时value的值
                    ret, e := value.Call(args...)
                    v.sp -= numArgs + 1
            ...

当时value的值

到这里有点有意思了: native go注册的函数是mod.register

    mod.moduleMap = map[string]tengo.Object{
        "register": &tengo.UserFunction{Value: mod.register},
    }

这里看到实际是main.(*GoProxy).register-fm 这个带fm字样的函数应该是编译器生成的, 或者说是编译器内部对"方法"到"函数"的转换表达: 它自带.this做为receiver

dlv对main.(*GoProxy).register-fm的处理也是隐形的: 它直接定位到func (mod *GoProxy) register(args ...tengo.Object) (tengo.Object, error)函数, 但调用栈能看到:register-fm是register的上级函数:

注意: register-fm的.this就是注册时候的"register": &tengo.UserFunction{Value: mod.register},中的mod, 是同一个对象.

待调用到register时, .this从register-fm变为receiver.

对象穿越魔法揭秘

编译的时候, 编译器发现这里把"方法"赋值给"函数", 比如:
func (mod *GoProxy) register(args ...tengo.Object) (tengo.Object, error)
赋值给CallableFunc, 其定义为func(args ...Object) (ret Object, err error)
即:
"register": &tengo.UserFunction{Value: mod.register}

那么此时编译器会给每个obj.function自动生成functionName-fm()函数, obj被保存到.this. 运行的时候functionName-fm()会调用obj.function(), 并把保存的.this做为receiver, 类似调用(.this).fucntion()
编译后的符号表有functionName-fm()出现:

go tool objdump -S interoperability看的非常清楚: 赋值的时候就是register-fm

这样赋值的结果是: mod对象会被带进UserFunction

所以, 这里的魔法是编译器在把"方法"转换为"函数"时, 生成的-fm包装代码. 详见: src/cmd/compile/internal/gc/closure.go的makepartialcall()函数

-- 真正的黑科技永远是芯片和编译器

使用注意

注意要用实际对象的方法来注册, 即下面的mod是个实例化过的对象.

// NewGoProxy creates GoProxy object.
func NewGoProxy(ctx context.Context) *GoProxy {
    mod := new(GoProxy)
    mod.ctx = ctx
    mod.callbacks = make(map[string]tengo.Object)
    mod.callChan = make(chan *CallArgs, 1)
    mod.moduleMap = map[string]tengo.Object{
        "next":     &tengo.UserFunction{Value: mod.next},
        "register": &tengo.UserFunction{Value: mod.register},
        "args":     &tengo.UserFunction{Value: mod.args},
    }
    mod.tasks = list.New()
    return mod
}

其实(*GoProxy).next也是语法合法的, 但它是type func(*GoProxy, args ...v2.Object) (v2.Object, error), 第一个参数是*GoProxy; 在这里不能赋值给func(args ...Object) (ret Object, err error)

5.1.4. 总结

tengo脚本和自定义native go的交互:

• native go的入参和返回值都是tengo.Object
• native go返回的tengo.Object的concrete类型可以是
  • &tengo.UserFunction: 脚本可以继续调函数
  • &tengo.Int: 脚本能直接用做Int
  • &tengo.Array: 脚本能按[index]来访问
  • 其他Object类型
  • 估计也可以自定义类型, 见用户可以自定义类型
• tengo脚本可以调用native go的代码
• native go也可以调用tengo的函数
• native go的对象方法能够转换为tengo脚本的函数.
• 要在tengo脚本里import("module_name"), 这个module必须先在native go代码里注册. 参考stdlib/stdlib.go中的GetModuleMap()函数

5.2. tengo锁

5.3. tengo并发

script_test.go中, 有个测并发的函数: 用了compiled.Clone()复制一个compiled对象, 每个go routine用复制的compiled对象来运行.

    for i := 0; i < concurrency; i++ {
        go func(compiled *tengo.Compiled) {
            time.Sleep(time.Duration(rand.Int63n(50)) * time.Millisecond)
            defer wg.Done()

            a := rand.Intn(10)
            b := rand.Intn(10)
            c := rand.Intn(10)

            d, e := executeFn(compiled, a, b, c)
            expectedD, expectedE := solve(a, b, c)

            require.Equal(t, expectedD, d, "input: %d, %d, %d", a, b, c)
            require.Equal(t, expectedE, e, "input: %d, %d, %d", a, b, c)
        }(compiled.Clone())
    }

Clone函数主要是clone了golbals全局变量集, 这样routine之前的全局变量不打架.
其他的几个filed, 都没有实际拷贝, 而是用了引用.

// Clone creates a new copy of Compiled. Cloned copies are safe for concurrent
// use by multiple goroutines.
func (c *Compiled) Clone() *Compiled {
    c.lock.Lock()
    defer c.lock.Unlock()

    clone := &Compiled{
        globalIndexes: c.globalIndexes,
        bytecode:      c.bytecode,
        globals:       make([]Object, len(c.globals)),
        maxAllocs:     c.maxAllocs,
    }
    // copy global objects
    for idx, g := range c.globals {
        if g != nil {
            clone.globals[idx] = g
        }
    }
    return clone
}

说明:

• 在vM执行过程中, bytecode是不会变的
• global的对照表也不变

5.4. 代码组织:

tengo很多代码都是直接属于tengo包的.

5.4.1. 总结

• SourceFile和symbolTable和constants和modules是Compiler(*tengo.Compiler)的属性.
• 而经过parser解析文本内容而来的代表ast的parser.File是Compiler的输入
• 编译后的bytecode和全局变量array是运行时VM的输入
• constants是运行时"不变"的Object的集合. 比如:a:=1和b:=2中的a和b是constant; 而c=a+b的c就不是constant. 不变的函数也是constant. 随着bytecode传递, 每次执行会改变
• tengo的Script经过compile后的compiled对象, 代表了VM之前的所有步骤.
  • compiled包括globals和bytecode
  • 在没有compiled.Run之前, globals是可以改的. compiled.Set()可以改
  • compiled.Get()可以得到结果.
  • compiled的Get()和Set()是go调用tengo脚本的时候, 和脚本交互变量用的.

5.4.2. error.go

内部预定义错误, 比如ErrStringLimit = errors.New("exceeding string size limit")

5.4.3. require/require.go

require.go依赖标准库testing, 提供了一些type断言的功能. 主要是tengo的内部test代码在用.

5.4.4. parser/opcodes.go

opcodes定义了支持的所有操作: 注意这里是"指令流"的操作, 没有for, 因为for已经被编译成类似Jump的指令了

// List of opcodes
const (
    OpConstant      Opcode = iota // Load constant
    OpBComplement                 // bitwise complement
    OpPop                         // Pop
    OpTrue                        // Push true
    OpFalse                       // Push false
    OpEqual                       // Equal ==
    OpNotEqual                    // Not equal !=
    OpMinus                       // Minus -
    OpLNot                        // Logical not !
    OpJumpFalsy                   // Jump if falsy
    OpAndJump                     // Logical AND jump
    OpOrJump                      // Logical OR jump
    OpJump                        // Jump
    OpNull                        // Push null
    OpArray                       // Array object
    OpMap                         // Map object
    OpError                       // Error object
    OpImmutable                   // Immutable object
    OpIndex                       // Index operation
    OpSliceIndex                  // Slice operation
    OpCall                        // Call function
    OpReturn                      // Return
    OpGetGlobal                   // Get global variable
    OpSetGlobal                   // Set global variable
    OpSetSelGlobal                // Set global variable using selectors
    OpGetLocal                    // Get local variable
    OpSetLocal                    // Set local variable
    OpDefineLocal                 // Define local variable
    OpSetSelLocal                 // Set local variable using selectors
    OpGetFreePtr                  // Get free variable pointer object
    OpGetFree                     // Get free variables
    OpSetFree                     // Set free variables
    OpGetLocalPtr                 // Get local variable as a pointer
    OpSetSelFree                  // Set free variables using selectors
    OpGetBuiltin                  // Get builtin function
    OpClosure                     // Push closure
    OpIteratorInit                // Iterator init
    OpIteratorNext                // Iterator next
    OpIteratorKey                 // Iterator key
    OpIteratorValue               // Iterator value
    OpBinaryOp                    // Binary operation
    OpSuspend                     // Suspend VM
)

5.4.5. parser/source_file.go

提供了脚本file的表达, 重点是file 集合

// SourceFileSet represents a set of source files.
type SourceFileSet struct {
    Base     int           // base offset for the next file
    Files    []*SourceFile // list of files in the order added to the set
    LastFile *SourceFile   // cache of last file looked up
}

其中SourceFile还可以包括Files

// SourceFile represents a source file.
type SourceFile struct {
    // SourceFile set for the file
    set *SourceFileSet
    // SourceFile name as provided to AddFile
    Name string
    // SourcePos value range for this file is [base...base+size]
    Base int
    // SourceFile size as provided to AddFile
    Size int
    // Lines contains the offset of the first character for each line
    // (the first entry is always 0)
    Lines []int
}

所以一个file集合是个树状的.

5.4.6. parser/parser.go

parser的底层是token, 对下调用token的方法, 对上提供词法分析 parser持有scanner实例, 提供next方法

// Parser parses the Tengo source files. It's based on Go's parser
// implementation.
type Parser struct {
    file      *SourceFile
    errors    ErrorList
    scanner   *Scanner
    pos       Pos
    token     token.Token
    tokenLit  string
    exprLevel int // < 0: in control clause, >= 0: in expression
    syncPos   Pos // last sync position
    syncCount int // number of advance calls without progress
    trace     bool
    indent    int
    traceOut  io.Writer
}

NewParser()函数

NewParser返回一个parser对象, 值得一提的是, 如果trace不是nil, 会输出debug信息到指定的io.Writer

// NewParser creates a Parser.
func NewParser(file *SourceFile, src []byte, trace io.Writer) *Parser {
    p := &Parser{
        file:     file,
        trace:    trace != nil,
        traceOut: trace,
    }
    p.scanner = NewScanner(p.file, src,
        func(pos SourceFilePos, msg string) {
            p.errors.Add(pos, msg)
        }, 0)
    p.next()
    return p
}

ParseFile()函数

ParseFile的核心是返回一个[]Stmt, 即表达式的集合

// ParseFile parses the source and returns an AST file unit.
func (p *Parser) ParseFile() (file *File, err error) {
    defer func() {
        if e := recover(); e != nil {
            if _, ok := e.(bailout); !ok {
                panic(e)
            }
        }

        p.errors.Sort() //这里用defer在最后来排序erros
        err = p.errors.Err()
    }()

    if p.trace {
        defer untracep(tracep(p, "File")) //使用了defer的trace技术
    }

    if p.errors.Len() > 0 {
        return nil, p.errors.Err()
    }

    stmts := p.parseStmtList()
    if p.errors.Len() > 0 {
        return nil, p.errors.Err()
    }

    file = &File{
        InputFile: p.file,
        Stmts:     stmts,
    }
    return
}

stmt是个抽象化的接口

type Stmt interface {
    Node
    stmtNode()
}

parseStmtList()不断调用p.parseStmt(), 并把结果放到[]Stmt中

func (p *Parser) parseStmtList() (list []Stmt) {
    if p.trace {
        defer untracep(tracep(p, "StatementList"))
    }

    for p.token != token.RBrace && p.token != token.EOF {
        list = append(list, p.parseStmt())
    }
    return
}

parseStmt()是核心函数, 根据每次根据token的类型做动作, 并且前进(advance)

func (p *Parser) parseStmt() (stmt Stmt) {
    if p.trace {
        defer untracep(tracep(p, "Statement"))
    }

    switch p.token {
    case // simple statements
        token.Func, token.Error, token.Immutable, token.Ident, token.Int,
        token.Float, token.Char, token.String, token.True, token.False,
        token.Undefined, token.Import, token.LParen, token.LBrace,
        token.LBrack, token.Add, token.Sub, token.Mul, token.And, token.Xor,
        token.Not:
        s := p.parseSimpleStmt(false)
        p.expectSemi()
        return s
    case token.Return:
        return p.parseReturnStmt()
    case token.Export:
        return p.parseExportStmt()
    case token.If:
        return p.parseIfStmt()
    case token.For:
        return p.parseForStmt()
    case token.Break, token.Continue:
        return p.parseBranchStmt(p.token)
    case token.Semicolon:
        s := &EmptyStmt{Semicolon: p.pos, Implicit: p.tokenLit == "\n"}
        p.next()
        return s
    case token.RBrace:
        // semicolon may be omitted before a closing "}"
        return &EmptyStmt{Semicolon: p.pos, Implicit: true}
    default:
        pos := p.pos
        p.errorExpected(pos, "statement")
        p.advance(stmtStart)
        return &BadStmt{From: pos, To: p.pos}
    }
}

比如其中的token.If

func (p *Parser) parseIfStmt() Stmt {
    if p.trace {
        defer untracep(tracep(p, "IfStmt"))
    }

    pos := p.expect(token.If)
    init, cond := p.parseIfHeader()
    body := p.parseBlockStmt()

    var elseStmt Stmt
    if p.token == token.Else {
        p.next()

        switch p.token {
        case token.If:
            elseStmt = p.parseIfStmt()
        case token.LBrace:
            elseStmt = p.parseBlockStmt()
            p.expectSemi()
        default:
            p.errorExpected(p.pos, "if or {")
            elseStmt = &BadStmt{From: p.pos, To: p.pos}
        }
    } else {
        p.expectSemi()
    }
    return &IfStmt{
        IfPos: pos,
        Init:  init,
        Cond:  cond,
        Body:  body,
        Else:  elseStmt,
    }
}

这个过程存在不少的递归. 比如if的body就是body := p.parseBlockStmt(), 而BlockStmt里面又可以包含任何的语句.

func (p *Parser) parseBlockStmt() *BlockStmt {
    if p.trace {
        defer untracep(tracep(p, "BlockStmt"))
    }

    lbrace := p.expect(token.LBrace)
    list := p.parseStmtList()
    rbrace := p.expect(token.RBrace)
    return &BlockStmt{
        LBrace: lbrace,
        RBrace: rbrace,
        Stmts:  list,
    }
}

5.4.7. formatter.go

提供了format tengo对象Object的函数, 这些函数是自己实现的, 不依赖标准库fmt.

// Format is like fmt.Sprintf but using Objects.
func Format(format string, a ...Object) (string, error)

Pool对象池技术

这里使用了sync.Pool技术来避免重复分配内存.

注: sync.Pool是标准库提供的对象池化技术, 主要用于cache对象, 减轻gc压力. 要点:

• 提供Put()和Get()接口, 用来存取pool中对象.
  • Put()和Get()没有相关性. 不保证Put过的对象就一定能Get()到
  • 实际上, 这里是对象池. 使用者不应该关心对象携带的"历史"信息. Get()一个就是一个新的对象.
  • 可以提供一个New func() interface{}函数, Get()不到的时候也返回一个新的.
• 并发安全
• 标准库fmt使用了Pool技术
• pool不能被拷贝
• 似乎比较heavy. 轻量的free list的需求场景建议自己实现对象free list

新建对象池, 这里提供了默认的New方法:

var ppFree = sync.Pool{
    New: func() interface{} { return new(pp) },
}

从对象池get:

// newPrinter allocates a new pp struct or grabs a cached one.
func newPrinter() *pp {
    p := ppFree.Get().(*pp)
    p.erroring = false
    p.fmt.init(&p.buf)
    return p
}

free对象, 放到对象池

// free saves used pp structs in ppFree; avoids an allocation per invocation.
func (p *pp) free() {
    // Proper usage of a sync.Pool requires each entry to have approximately
    // the same memory cost. To obtain this property when the stored type
    // contains a variably-sized fmtbuf, we add a hard limit on the maximum
    // fmtbuf to place back in the pool.
    //
    // See https://golang.org/issue/23199
    if cap(p.buf) > 64<<10 {
        return
    }

    p.buf = p.buf[:0] //注意这里, 看起来把slice置为0, 并不能导致gc回收其underlying的array. 否者就不会有上面的大于64K直接return. 还有个点可以证明: 如果这里能真正把underlying的array清0, 那么这个池化还有什么意义呢? 在我看来, 这里这个p.buf所代表的真正"buffer"是要被池化的最主要的目标.
    p.arg = nil
    ppFree.Put(p)
}

在这里, 被池化的对象是

// pp is used to store a printer's state and is reused with sync.Pool to avoid
// allocations.
type pp struct {
    buf fmtbuf

    // arg holds the current item.
    arg Object

    // fmt is used to format basic items such as integers or strings.
    fmt formatter

    // reordered records whether the format string used argument reordering.
    reordered bool

    // goodArgNum records whether the most recent reordering directive was
    // valid.
    goodArgNum bool

    // erroring is set when printing an error string to guard against calling
    // handleMethods.
    erroring bool
}

5.4.8. tengo.go

tengo.go里面的函数, 入参都是统一的Object, 利用类型断言来搞事情, 提供入参是Object, 对外统一的函数. 比如:

func ToInt(o Object) (v int, ok bool)
func CountObjects(o Object) (c int)
...

//最后这对方法很特别, 是native go和tengo类型互转的关键
func ToInterface(o Object) (res interface{})
func FromInterface(v interface{}) (Object, error)

对外提供统一的API, 即入参是Object的API, 有两个思路

• 本例中, 传入Object接口, 在函数实现里面搞类型断言, 比如:

  // ToTime will try to convert object o to time.Time value.
  func ToTime(o Object) (v time.Time, ok bool) {
    switch o := o.(type) {
    case *Time:
        v = o.Value
        ok = true
    case *Int:
        v = time.Unix(o.Value, 0)
        ok = true
    }
    return
  }
  

• 所有的对外API都定义成接口, 比如要求Object全部实现func ToTime(o Object) (v time.Time, ok bool)方法

比较而言, 第一种好点:

• 并不是所有Object都需要ToTime, 对一个array来搞ToTime有点怪.
• 而通过一个统一函数, ToTime(Object)的方式, 不怪, 如果传入Array类型的Object, 就返回0值就好了.

FromInterface()和ToInterface()函数是go和脚本交互的核心

FromInterface()从go的interface{}推断得到tengo的Object; 而ToInterface()正好相反

// FromInterface will attempt to convert an interface{} v to a Tengo Object
func FromInterface(v interface{}) (Object, error) {
    switch v := v.(type) {
    case nil:
        return UndefinedValue, nil //UndefinedValue Object = &Undefined{} 定义于objects.go
    case string:
        if len(v) > MaxStringLen {    //tengo的String不能大于MaxStringLen, 2G, 已经非常大了
            return nil, ErrStringLimit
        }
        return &String{Value: v}, nil
    case int64:
        return &Int{Value: v}, nil
    case int:
        return &Int{Value: int64(v)}, nil
    case bool:
        if v {
            return TrueValue, nil
        }
        return FalseValue, nil
    case rune:
        return &Char{Value: v}, nil
    case byte:
        return &Char{Value: rune(v)}, nil
    case float64:
        return &Float{Value: v}, nil
    case []byte:
        if len(v) > MaxBytesLen {
            return nil, ErrBytesLimit
        }
        return &Bytes{Value: v}, nil //Bytes就是[]byte的tengo表达
    case error:
        return &Error{Value: &String{Value: v.Error()}}, nil //Error默认是值为string
    case map[string]Object: //注意这个case, 比下个case更具体, 要放在前面; 从go代码调用下来, 有能力断言Object
        return &Map{Value: v}, nil
    case map[string]interface{}:    //层层嵌套的map
        kv := make(map[string]Object)
        for vk, vv := range v {
            vo, err := FromInterface(vv) //递归调用
            if err != nil {
                return nil, err
            }
            kv[vk] = vo
        }
        return &Map{Value: kv}, nil
    case []Object: //array类型
        return &Array{Value: v}, nil
    case []interface{}: //层层嵌套的arrary
        arr := make([]Object, len(v))
        for i, e := range v {
            vo, err := FromInterface(e) //递归调用
            if err != nil {
                return nil, err
            }
            arr[i] = vo
        }
        return &Array{Value: arr}, nil
    case time.Time:
        return &Time{Value: v}, nil //Time就是time.Time的包装
    case Object:
        return v, nil
    case CallableFunc:
        return &UserFunction{Value: v}, nil
    }
    return nil, fmt.Errorf("cannot convert to object: %T", v)
}

什么是callable对象

符合这个签名的都是:

// CallableFunc is a function signature for the callable functions.
type CallableFunc = func(args ...Object) (ret Object, err error)

经过测试

type test struct {
    a int
}

和下面带=号的版本, 都能编过, 效果差不多

type test = struct {
    a int
}

但还是有些差别:

• =版本的type, 只是别名, an alternate spelling; 别名拥有原名的一切属性
• 普通版本的type定义, 是一个全新的类型, 不具有原类型的方法

CountObjects这个递归函数写的真好

最里层返回预设值1, 其他情况递归的计算array/map的元素个数

// CountObjects returns the number of objects that a given object o contains.
// For scalar value types, it will always be 1. For compound value types,
// this will include its elements and all of their elements recursively.
func CountObjects(o Object) (c int) {
    c = 1
    switch o := o.(type) {
    case *Array:
        for _, v := range o.Value {
            c += CountObjects(v)
        }
    case *ImmutableArray:
        for _, v := range o.Value {
            c += CountObjects(v)
        }
    case *Map:
        for _, v := range o.Value {
            c += CountObjects(v)
        }
    case *ImmutableMap:
        for _, v := range o.Value {
            c += CountObjects(v)
        }
    case *Error:
        c += CountObjects(o.Value)
    }
    return
}

5.4.9. script.go

依赖parser, 用于嵌入代码和调用go代码的交互. 新建script实例, 从go代码add变量进script 还提供了一些API

func (s *Script) EnableFileImport(enable bool)

Script.Add用于从native go添加变量到tengo脚本

即把interface{}转换为{name, Object}, 加到script的variablesmap里

// Add adds a new variable or updates an existing variable to the script.
func (s *Script) Add(name string, value interface{}) error {
    obj, err := FromInterface(value) //见tengo.go里的函数实现
    if err != nil {
        return err
    }
    s.variables[name] = &Variable{
        name:  name,
        value: obj,
    }
    return nil
}

NewScript

在script.go中, NewScript简单到返回一个结构体:

// Variable is a user-defined variable for the script.
type Variable struct {
    name  string
    value Object //Object是tengo的数据类型的统一表述(接口)
}

// Script can simplify compilation and execution of embedded scripts.
type Script struct {
    variables        map[string]*Variable //script和外部go的变量交互通过这个map
    modules          *ModuleMap
    input            []byte
    maxAllocs        int64
    maxConstObjects  int
    enableFileImport bool
    importDir        string
}

// NewScript creates a Script instance with an input script.
func NewScript(input []byte) *Script {
    return &Script{
        variables:       make(map[string]*Variable),
        input:           input,
        maxAllocs:       -1,
        maxConstObjects: -1,
    }
}

Compile函数

Script对象的Compile方法把代码编译成Compiled对象 Compiled对象包括了字节码和全局变量, 和一个锁

// Compiled is a compiled instance of the user script. Use Script.Compile() to
// create Compiled object.
type Compiled struct {
    globalIndexes map[string]int // global symbol name to index
    globals       []Object //以上两个域一起, 实际就是map[string]Object; 这里作者这么搞怕不是有什么优化
    bytecode      *Bytecode
    maxAllocs     int64
    lock          sync.RWMutex
}