Go与C/Lua程序间通信及语言直接交互深度指南

package main

import (
    "fmt"
    "net"
    "os"
)

const (
    socketPath = "/tmp/go_lua.sock"
)

func main() {
    os.Remove(socketPath) // 确保套接字文件不存在

    listener, err := net.Listen("unix", socketPath)
    if err != nil {
        fmt.Println("Listen error:", err)
        return
    }
    defer listener.Close()

    fmt.Println("Go server listening on", socketPath)

    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("Accept error:", err)
            continue
        }
        go handleConnection(conn)
    }
}

func handleConnection(conn net.Conn) {
    defer conn.Close()
    buf := make([]byte, 1024)
    n, err := conn.Read(buf)
    if err != nil {
        fmt.Println("Read error:", err)
        return
    }
    fmt.Printf("Go received: %s\n", string(buf[:n]))

    response := "Hello from Go!"
    _, err = conn.Write([]byte(response))
    if err != nil {
        fmt.Println("Write error:", err)
        return
    }
}

-- Lua 客户端 (需要lualibs/luasocket)
local socket = require("socket")

local client = socket.unix()
local ok, err = client:connect("/tmp/go_lua.sock")

if not ok then
    print("Connect error:", err)
else
    print("Connected to Go server.")
    client:send("Request from Lua!")
    local response, err = client:receive("*l") -- Read until newline
    if response then
        print("Lua received:", response)
    else
        print("Receive error:", err)
    end
    client:close()
end

package main

/*
#include <stdio.h>

// 声明一个Go函数，供C代码调用
extern void goCallbackFromC(int);

// C函数，它会调用Go函数
void callGoFromC(int val) {
    printf("C says: Calling Go function with value %d\n", val);
    goCallbackFromC(val);
}

// 另一个C函数，供Go直接调用
int add_c(int a, int b) {
    return a + b;
}
*/
import "C" // 引入C语言环境
import "fmt"

//export goCallbackFromC
func goCallbackFromC(val C.int) {
    fmt.Printf("Go says: Received %d from C callback\n", val)
}

func main() {
    // Go 调用 C 函数
    result := C.add_c(C.int(10), C.int(20))
    fmt.Printf("Go says: Result from C's add_c: %d\n", result)

    // Go 调用 C 函数，该C函数会回调Go函数
    fmt.Println("Go says: Calling C function that will callback Go...")
    C.callGoFromC(C.int(42))
}

go run main.go

Go says: Result from C's add_c: 30
Go says: Calling C function that will callback Go...
C says: Calling Go function with value 42
Go says: Received 42 from C callback

package main

import (
    "fmt"
    "github.com/aarzilli/golua/lua"
)

// Go函数，将注册到Lua中供Lua调用
func goAdd(L *lua.State) int {
    // 从Lua栈中获取参数
    a := L.CheckNumber(1) // 第一个参数
    b := L.CheckNumber(2) // 第二个参数

    // 执行操作并将结果推入Lua栈
    L.PushNumber(a + b)
    return 1 // 返回值的数量
}

func main() {
    // 创建一个新的Lua状态
    L := lua.NewState()
    defer L.Close() // 确保Lua状态被关闭

    // 打开Lua标准库
    L.OpenLibs()

    // 注册Go函数到Lua环境中，名为 "go_add"
    L.Register("go_add", goAdd)
    fmt.Println("Go function 'go_add' registered in Lua.")

    // Go执行Lua代码，该Lua代码会调用Go函数
    luaCodeCallingGo := `
        print("Lua says: Calling Go function 'go_add'...")
        local result = go_add(10, 20)
        print("Lua says: Result from Go's go_add:", result)
    `
    if err := L.DoString(luaCodeCallingGo); err != nil {
        fmt.Println("Error executing Lua code calling Go:", err)
        return
    }

    // Go调用Lua函数
    luaCodeDefiningFunction := `
        function lua_multiply(a, b)
            print("Lua says: Multiplying", a, "and", b)
            return a * b
        end
    `
    if err := L.DoString(luaCodeDefiningFunction); err != nil {
        fmt.Println("Error defining Lua function:", err)
        return
    }

    fmt.Println("Go says: Calling Lua function 'lua_multiply'...")
    L.GetGlobal("lua_multiply") // 将lua_multiply函数推入栈
    L.PushNumber(5)             // 推入第一个参数
    L.PushNumber(6)             // 推入第二个参数
    L.Call(2, 1)                // 调用函数，2个参数，1个返回值

    // 从Lua栈中获取返回值
    res := L.ToNumber(-1) // 获取栈顶的返回值
    L.Pop(1)              // 弹出返回值
    fmt.Printf("Go says: Result from Lua's lua_multiply: %f\n", res)
}

go mod init myapp
go get github.com/aarzilli/golua
go run main.go

Go function 'go_add' registered in Lua.
Lua says: Calling Go function 'go_add'...
Lua says: Result from Go's go_add: 30
Go says: Calling Lua function 'lua_multiply'...
Lua says: Multiplying 5 and 6
Go says: Result from Lua's lua_multiply: 30.000000