Ви можете зателефонувати на код Go від C. Це, однак, є заплутаною пропозицією.
Процес описаний у публікації блогу, до якого ви пов’язані. Але я бачу, як це не дуже корисно. Ось короткий фрагмент без зайвих шматочків. Це повинно зробити речі яснішими.
package foo
// extern int goCallbackHandler(int, int);
//
// static int doAdd(int a, int b) {
// return goCallbackHandler(a, b);
// }
import "C"
//export goCallbackHandler
func goCallbackHandler(a, b C.int) C.int {
return a + b
}
// This is the public function, callable from outside this package.
// It forwards the parameters to C.doAdd(), which in turn forwards
// them back to goCallbackHandler(). This one performs the addition
// and yields the result.
func MyAdd(a, b int) int {
return int( C.doAdd( C.int(a), C.int(b)) )
}
Порядок, у якому все називається, такий:
foo.MyAdd(a, b) ->
C.doAdd(a, b) ->
C.goCallbackHandler(a, b) ->
foo.goCallbackHandler(a, b)
Тут важливо пам’ятати, що функція зворотного дзвінка повинна бути позначена //exportкоментарем на стороні Go та як externна стороні C. Це означає, що будь-який зворотний дзвінок, який ви хочете використовувати, повинен бути визначений у вашому пакеті.
Для того, щоб дозволити користувачеві вашого пакета надавати власну функцію зворотного виклику, ми використовуємо точно такий же підхід, як і вище, але ми постачаємо користувальницький користувальницький обробник (що є лише звичайною функцією Go) як параметр, який передається на C сторона як void*. Потім він отримує зворотний дзвінок в нашому пакеті і дзвонить.
Давайте скористаємося більш просунутим прикладом, з яким я зараз працюю. У цьому випадку у нас є функція C, яка виконує досить важке завдання: вона читає список файлів з USB-пристрою. Це може зайняти деякий час, тому ми хочемо, щоб наш додаток був сповіщений про його хід. Ми можемо це зробити, передавши вказівник функції, який ми визначили в нашій програмі. Він просто відображає певну інформацію про прогрес користувачеві кожного разу, коли йому дзвонять. Оскільки він має добре відомий підпис, ми можемо призначити його власний тип:
type ProgressHandler func(current, total uint64, userdata interface{}) int
Цей обробник отримує деяку інформацію про прогрес (поточну кількість отриманих файлів та загальну кількість файлів), а також значення {} інтерфейсу, який може вмістити все, що потрібно для користування.
Тепер нам потрібно написати сантехніку C і Go, щоб ми могли використовувати цей обробник. На щастя, функція C, яку я хочу зателефонувати з бібліотеки, дозволяє нам передати структуру типів даних користувачів void*. Це означає, що він може вмістити все, що ми хочемо, і не задаватиметься жодних питань, і ми повернемо його назад у світ Go так, як є. Для того, щоб все це працювало, ми не викликаємо функцію бібліотеки від Go безпосередньо, а створюємо для неї обгортку C, яку ми назвамо goGetFiles(). Саме ця обгортка фактично постачає наш зворотний виклик Go у бібліотеку C разом із об’єктом даних користувача.
package foo
// #include <somelib.h>
// extern int goProgressCB(uint64_t current, uint64_t total, void* userdata);
//
// static int goGetFiles(some_t* handle, void* userdata) {
// return somelib_get_files(handle, goProgressCB, userdata);
// }
import "C"
import "unsafe"
Зауважте, що goGetFiles()функція не приймає жодних покажчиків функцій для зворотних викликів як параметрів. Натомість зворотний виклик, який надав наш користувач, упаковується у власну структуру, яка містить як цей обробник, так і власне значення даних користувача. Ми передаємо це goGetFiles()як параметр userdata.
// This defines the signature of our user's progress handler,
type ProgressHandler func(current, total uint64, userdata interface{}) int
// This is an internal type which will pack the users callback function and userdata.
// It is an instance of this type that we will actually be sending to the C code.
type progressRequest struct {
f ProgressHandler // The user's function pointer
d interface{} // The user's userdata.
}
//export goProgressCB
func goProgressCB(current, total C.uint64_t, userdata unsafe.Pointer) C.int {
// This is the function called from the C world by our expensive
// C.somelib_get_files() function. The userdata value contains an instance
// of *progressRequest, We unpack it and use it's values to call the
// actual function that our user supplied.
req := (*progressRequest)(userdata)
// Call req.f with our parameters and the user's own userdata value.
return C.int( req.f( uint64(current), uint64(total), req.d ) )
}
// This is our public function, which is called by the user and
// takes a handle to something our C lib needs, a function pointer
// and optionally some user defined data structure. Whatever it may be.
func GetFiles(h *Handle, pf ProgressFunc, userdata interface{}) int {
// Instead of calling the external C library directly, we call our C wrapper.
// We pass it the handle and an instance of progressRequest.
req := unsafe.Pointer(&progressequest{ pf, userdata })
return int(C.goGetFiles( (*C.some_t)(h), req ))
}
Це все для наших зв'язків на С. Код користувача зараз дуже прямий:
package main
import (
"foo"
"fmt"
)
func main() {
handle := SomeInitStuff()
// We call GetFiles. Pass it our progress handler and some
// arbitrary userdata (could just as well be nil).
ret := foo.GetFiles( handle, myProgress, "Callbacks rock!" )
....
}
// This is our progress handler. Do something useful like display.
// progress percentage.
func myProgress(current, total uint64, userdata interface{}) int {
fc := float64(current)
ft := float64(total) * 0.01
// print how far along we are.
// eg: 500 / 1000 (50.00%)
// For good measure, prefix it with our userdata value, which
// we supplied as "Callbacks rock!".
fmt.Printf("%s: %d / %d (%3.2f%%)\n", userdata.(string), current, total, fc / ft)
return 0
}
Це все виглядає набагато складніше, ніж це є. Порядок дзвінків не змінився на відміну від попереднього прикладу, але ми отримуємо два додаткових дзвінка в кінці ланцюга:
Порядок такий:
foo.GetFiles(....) ->
C.goGetFiles(...) ->
C.somelib_get_files(..) ->
C.goProgressCB(...) ->
foo.goProgressCB(...) ->
main.myProgress(...)