Mirror of forum.nim-lang.org

7838 :: Capturing external variables in closure

• drkameleon (orginal) [2021-04-22T11:39:22+02:00] view original

  So, let me explain what I'm trying to do:

  I've created a Nim wrapper for a C/C++ library (basically, https://github.com/webview/webview).

  I need to pass a proc as a callback to a C function expecting a void*. Initially I declared it as pointer, then I decided to typedef it as:

  type
      WebView* = pointer
      Callback* = proc (s: cstring, r: cstring, a: pointer) {. cdecl .}
  Run

  The problem is... it generally works, but whenever I pass a Callback to the function in question I cannot capture any outer variable from inside the callback body and keep getting the following error:

  
  Error: illegal capture 'callback' because ':anonymous' has the calling convention: <cdecl>
  Run

  So... instead of randomly changing pragmas (because I honestly do not know 100% what is going on), I decided to ask you and see if there's any viable solution to this situation.

  I'm all ears :)

---

• haxscramper_ (orginal) [2021-04-22T12:51:29+02:00] view original

  {.cdecl.} is a calling convention for working with C callback functions and it cannot capture local variable. You can try declaring your variable globally (either by making it directly global or using {.global.} pragma).

---

• shirleyquirk (orginal) [2021-04-22T13:37:43+02:00] view original

  you can use that arg:pointer to send the environment, if you want to support closure callbacks. use rawProc and rawEnv, cast the rawProc to`Callback` and pass the rawEnv as the arg to webview_bind

---

• demotomohiro (orginal) [2021-04-22T19:02:20+02:00] view original

  Closure is actually a pair of a function pointer and a pointer to environment that holds captured variables. And only closure can capture local variables because other calling conventions don't have memory that can hold captured variables.

  proc closurething(x: int) =
    proc c =
      echo x
    proc d {.cdecl.} = discard
    proc e = discard
    
    echo pointer.sizeof # 8
    echo c.sizeof       # 16
    echo d.sizeof       # 8
    echo e.sizeof       # 8
  
  closurething(1)
  Run

  C functions that sets callback function usually takes a pointer to callback function and a pointer (typically void* type) that is passed to the callback function when it is called. That pointer is usually called user data and points to heap memory that contains variables used in the callback function. That user data pointer is held by a C object and that means the object that user data pointer points to is not managed by Nim's GC and you must free it manually. So I might forget to free it or read the pointer after freed.

  I uses id and table instead of pointer to avoid such a problem. Create an unique id and an object that I want to use in the callback function and add them to the global table. Then, pass the unique id instead of a pointer to C function that takes pointer to callback function. When the callback is called, cast user data pointer to a int and get the object from global table. I can check whether the object the callback function is about to use is exists.

  For example:

  # Example C function binding code
  type
    CObject = object
      callback: proc (arg: int; userData: pointer) {.cdecl.}
      userData: pointer
  
  proc cfuncSetCallback(cobj: ptr CObject; callback: proc (arg: int; userData: pointer) {.cdecl.}; userData: pointer) {.cdecl.} =
    cobj.callback = callback
    cobj.userData = userData
  
  proc cfuncDoSomething(cobj: ptr CObject) {.cdecl.} =
    echo "cfuncDoSomething"
    cobj.callback(123, cobj.userData)
  
  # Example user code
  import tables
  
  type
    Mydata = ref object
      mydata: string
  
  var
    idToMydata: Table[int, Mydata]
    idCounter: int
  
  proc main =
    var cobj: CObject
    proc mycallback(arg: int; userData: pointer) {.cdecl.} =
      let id = cast[int](userData)
      assert id in idToMydata
      var mydata = idToMydata[id]
      echo arg
      echo mydata.mydata
    
    inc idCounter
    let id = idCounter
    idToMydata[id] = Mydata(mydata: "My data")
    
    cfuncSetCallback(cobj.addr, mycallback, cast[pointer](id))
    cfuncDoSomething(cobj.addr)
    
    del idToMydata, id
    assert idToMydata.len == 0
  
  main()
  Run

---