Appelez Go fonctions de C

Vous pouvez appeler le Go du code de C. c'est une source de confusion proposition si.

Le processus est décrit dans le billet de blog que vous avez associé. Mais je peux voir comment cela n'est pas très utile. Voici un court extrait sans inutiles bits. Il devrait rendre les choses un peu plus claires.

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)) )
}

L'ordre dans lequel tout est appelée est comme suit:

foo.MyAdd(a, b) ->
  C.doAdd(a, b) ->
    C.goCallbackHandler(a, b) ->
      foo.goCallbackHandler(a, b)

La clé à retenir ici est qu'une fonction de rappel doit être marqué avec le //export commentaire sur l'Aller et que extern sur le C côté. Cela signifie que tout de rappel que vous souhaitez utiliser, doit être définie à l'intérieur de votre colis.

Afin de permettre à un utilisateur de votre colis, pour fournir une coutume fonction de rappel, nous utilisons exactement la même démarche que ci-dessus, mais nous fournissons à l'utilisateur du gestionnaire personnalisé (qui est juste un régulier de la fonction Go) comme un paramètre qui est passé sur le côté C comme void*. Il est ensuite reçu par le callbackhandler dans notre paquet et l'a appelé.

Nous allons utiliser un exemple plus complexe, je suis actuellement en train de travailler. Dans ce cas, nous avons une fonction C qui effectue une lourde tâche: Il lit une liste de fichiers à partir d'un périphérique USB. Cela peut prendre un certain temps, nous voulons que notre application pour être informé de ses progrès. Nous pouvons le faire en passant un pointeur de fonction que nous avons défini dans notre programme. Il affiche simplement quelques progrès info à l'utilisateur chaque fois qu'il est appelé. Depuis qu'il a bien connu la signature, on peut lui assigner son propre type:

type ProgressHandler func(current, total uint64, userdata interface{}) int

Ce gestionnaire prend des progrès info (nombre de dossiers reçus et le nombre total de fichiers) avec une interface{} valeur qui peut contenir tout ce que l'utilisateur en a besoin pour tenir.

Maintenant, nous avons besoin d'écrire du C et de plomberie pour nous permettre d'utiliser ce gestionnaire. Heureusement, la fonction C je souhaite appeler à partir de la bibliothèque nous permet de passer dans un userdata structure de type void*. Cela signifie qu'il peut contenir tout ce que nous voulons qu'il puisse tenir, sans poser de questions, et nous allons l'obtenir de nouveau dans la Aller le monde comme-est. Pour faire tout ce travail, nous n'avons pas appeler une fonction de la bibliothèque à partir d'y Aller directement, mais nous avons créer un wrapper C, ce qui nous permettra de nom goGetFiles(). C'est ce wrapper qui fait de fournitures de notre rendez-vous de rappel de la bibliothèque C, avec une userdata objet.

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"

Noter que le goGetFiles() fonction ne prend pas de pointeurs de fonction pour les rappels en tant que paramètres. Au lieu de cela, le rappel que notre utilisateur a fourni est emballé dans une coutume struct qui tient à la fois que le gestionnaire de l'utilisateur userdata de la valeur. Nous passons en goGetFiles() en tant que paramètre 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 ))
}

Que pour notre C liaisons. Le code de l'utilisateur est maintenant très simple: le

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
}

Tout cela semble beaucoup plus compliqué qu'il ne l'est. L'ordre d'appel n'a pas changé contrairement à notre exemple précédent, mais nous avons deux appels supplémentaires à la fin de la chaîne:

De la commande comme suit:

foo.GetFiles(....) ->
  C.goGetFiles(...) ->
    C.somelib_get_files(..) ->
      C.goProgressCB(...) ->
        foo.goProgressCB(...) ->
           main.myProgress(...)

La réponse a changé avec la sortie de parcourir 1,5

Ce DONC, la question que j'ai demandé il y a quelques temps les adresses de nouveau cette question à la lumière de la 1.5 ajouté des capacités de

Utilisation de code dans un projet C