Mirror of forum.nim-lang.org

12787 :: FFI: too many arguments to a wrapped function

• dwhall256 (orginal) [2025-04-14T04:47:04+02:00] view original

  I'm trying to wrap this C function:

  
  PmReturn_t heap_init(uint8_t *base, uint32_t size);
  Run

  here is the wrap I made:

  
  proc heapInit*(
    base: openArray[char], size: cuint
  ): PmReturn {.importc: "heap_init", header: "heap.h".}
  Run

  where I created a nim enum, PmReturn, to mirror the c enum PmReturn_t.

  I am calling this code from a test:

  
  test "heap init SHOULD return OK after a successful init":
    var base4 = ['a', 'b', 'c', 'd']
    check heapInit(base4, 4) == PmRetOk
  Run

  When I compile, I get the error:

  
  CC: test_heap.nim
  C:\Users\dwhall\nimcache\test_heap_d\@mtest_heap.nim.c: In function 'NimMainModule':
  C:\Users\dwhall\nimcache\test_heap_d\@mtest_heap.nim.c:960:164: error: too many arguments to function 'heap_init'
    960 |                         nimlf_(688, "C:\\Users\\dwhall\\.choosenim\\toolchains\\nim-2.2.0\\lib\\pure\\unittest.nim");                   colonc1___test95heap_u99 = heap_init(base4__test95heap_u98, 4, ((unsigned int)4));
        |
                        ^~~~~~~~~
  In file included from C:\Users\dwhall\nimcache\test_heap_d\@mtest_heap.nim.c:10:
  src/vm/heap.h:52:12: note: declared here
     52 | PmReturn_t heap_init(uint8_t *base, uint32_t size);
        |            ^~~~~~~~~
  Error: execution of an external compiler program 'gcc.exe -c  -w -fmax-errors=3 -mno-ms-bitfields -DWIN32_LEAN_AND_MEAN -Isrc/vm -Isrc/platform/posix64 -Dplat=posix64   -IC:\Users\dwhall\.choosenim\tool64 -Dplat=posix64   -IC:\Users\dwhall\.choosenim\toolchains\nim-2.2.0\lib -IC:\Users\dwhall\GoogleDrive\code\p14p\tests\tdd -o C:\Users\dwhall\nimcacmcache\test_heap_d\@mtest_heap.nim.c' failed with exihe\test_heap_d\@mtest_heap.nim.c.o C:\Users\dwhall\nimcache\test_heap_d\@mtest_heap.nim.c' failed with exit code: 1
  Run

  Please ignore, for now, that I'm using an array of chars as a static memory pool. I'm trying to learn how to properly use FFI.

---

• dwhall256 (orginal) [2025-04-14T05:03:21+02:00] view original

  My estimate is that the nim ffi code generator is seeing the openArray and giving the size of the array as an extra argument. So I'm supposed to drop the size argument in the wrapper?

---

• doofenstein (orginal) [2025-04-14T06:32:44+02:00] view original

  You can use ptr UncheckedArray[uint8] as the type for the first parameter. Then add a utility function which takes an openArray and passes the address of the first parameter and the size cast to uint32 onward.

---

• Araq (orginal) [2025-04-14T06:43:44+02:00] view original

  If you make a mistake like this, you are not ready for wrapping C code. Let some tool like futhark, c2nim or an AI do the work.

---

• xigoi (orginal) [2025-04-14T08:41:41+02:00] view original

  How is a person supposed to learn something without trying it?

---

• Araq (orginal) [2025-04-14T08:42:47+02:00] view original

  By watching what the tools produce.

---

• PMunch (orginal) [2025-04-14T11:06:28+02:00] view original

  Doofenstein is 100% right, the openArray is turned into a pointer and a size. Same as happens under the hood in Nim. This means that you end up with an extra argument. Nim code will generate forward declarations when you wrap things, which gives a weak guarantee that you wrap things correctly and allows more flexible linking. However in this case it causes a type mismatch error which is actually fine. So you can do (slightly modified to make it self contained):

  
  {.emit:"""
  int heap_init(uint8_t *base, uint32_t size) {
    return size;
  }
  """.}
  
  proc heapInit*(
    base: openArray[char]): cint {.importc: "heap_init", nodecl.}
  
  var base4 = ['a', 'b', 'c', 'd']
  echo heapInit(base4)
  Run

  However the more idiomatic wrap would be to use ptr UncheckedArray and a convenience template (or if you wrap a lot of these then a macro which generates said templates through a small pattern language).

---

• dwhall256 (orginal) [2025-04-14T13:34:13+02:00] view original

  Thank you all. I made the helper function and I feel it's headed in the right direction

  
  proc heapInitWrap(
  #  base: ptr UncheckedArray[uint8], size: cuint
    base: ptr uint8, size: cuint
  ): PmReturn {.importc: "heap_init", header: "heap.h".}
  
  proc heapInit*(
    base: openArray[uint8], size: Positive
  ): PmReturn =
    heapInitWrap(
  #    cast[ptr UncheckedArray[uint8]](base.addr),
      cast[ptr uint8](base.addr),
      cast[cuint](size))
  Run

  with the caller:

  
  test "heap init SHOULD return OK after a successful init":
    var base4: array[4, uint8]
    check heapInit(base4, 4) == PmRetOk
  Run

  but a different kind of error pops up:

  
  Undefined symbols for architecture arm64:
    "_heap_init", referenced from:
        _heapInit__OOZOOZsrcZvmZheap_u5 in @m..@s..@ssrc@[email protected]
  ld: symbol(s) not found for architecture arm64
  clang: error: linker command failed with exit code 1 (use -v to see invocation)
  Run

  I will try the auto-wrapping tools eventually. But I wanted to learn enough about the process to get one example function wrapped.

---

• PMunch (orginal) [2025-04-14T22:29:14+02:00] view original

  That is a linker error. The wrapper just tells Nim how it can call this function, but you still need to link whatever code required to run the function into your binary. This is typically done with --passL:"-l<some library>".

  Second the openArray already has a length, so there's no need to pass it separately in your wrapper:

  
  proc heapInit*(
    base: openArray[uint8]): cint =
    heapInitWrap(
      cast[ptr uint8](base.addr),
      cast[cuint](base.len))
  Run

---