[FFI] How can I specify C types?

[iuridiniz]

Assuming I have a FFI function called complex_args

in C it is declared as:

int complex_args(
  MY_STRUCT *self,             /* generic pointer, maybe NULL */       /* 1st */
  const char *cont_arg,        /* const arg */                         /* 2nd */
  int (*callback)(void*),      /* Callback function */                 /* 3rd */
  void *cb_arg,                /* 1st argument to callback */          /* 4th */
  int16_t flags,               /* Some flags using a fixed integer */  /* 5th */
  void **output                /* some output */                       /* 6th */
);

The examples provided in https://docs.exaloop.io/codon/interoperability/cpp and https://docs.exaloop.io/codon/language/ffi are not sufficient. I was writing some code to interface a library and a lot of questions comes to my mind.

How can I call this from codon?
Is callback supported? If so, how can I unwind on errors? How to pass a callback?
Is output args supported?
How to correct way to pass NULL?

Some example that comes to my mind:

# export to be called back from C code (Is this correct?)
@export
def cb(arg1: cobj) -> Int[32]:  # How to define callback parameters / return type?
    pass

LIBRARY="/path/to/my/library.so"

# Is this declaration correct?
# There is any type for default C integer (compiler dependent, 64bits GCC it is 4 bytes) ? 
from C import LIBRARY.complex_args(cobj, cobj, cobj, cobj, Int[16], cobj) -> Int[32]

# Params
output = None
flags = Int[16]( FLAG_1 | FLAG_2 | FLAG_3 )
C_NULL = Ptr[int]()

my_data = Dict[int, str]()

# How to pass C_NULL (first arg)? Could it be 0x0 ?
# How to pass a constant arg (2nd arg)? 
# How to pass callback (3rd arg)? 
# How to pass the callback arg (4th arg)?
# How to pass a 16 bit integer (5th arg)? How to correct pass a integer/float/double/long long/unsigned/etc?
# How to pass am output param it (6th arg)? is safe to write on it?
complex_args(C_NULL, "arg2".c_str(), __ptr__(cb), 0x0, flags, __ptr__(my_data), flags, __ptr__(__ptr__(output)))

[arshajii]

Hi @iuridiniz -- your code is almost correct; here's what these arguments would be in Codon:

• MY_STRUCT *self: Can just be cobj, which represents a generic (void * / char *) pointer in C
• const char *cont_arg: Ptr[byte] in Codon or cobj if you don't care about the pointer's type
• int (*callback)(void*): This can also be cobj, and you can cast it to the correct type and call it as in Function[[cobj], i32](callback)(arg)
• void *cb_arg: Again cobj
• int16_t: i16 in Codon (or Int[16]; it's the same)
• void **output: Ptr[cobj], or just cobj if you don't care about the pointer's type

It looks like your from C import is missing the last cobj? i.e. there should be 6 arguments but your code has 5.

Now for your other questions:

• You can create a null pointer with the empty constructor: Ptr[T]() or cobj() are null pointers
• "arg2".c_str() works
• You can use __raw__() to get a function pointer: cb.__raw__()
• You can use the built-in types i8, i16, ..., u8, u16, ...; for example, i16(42) is an int16_t with value 42. There is also f32 for 32-bit float (default float is 64-bit, like C double)
• Yes, you can pass an output parameter. It should be output = cobj() and then pass __ptr__(output) as the last argument.

Please let me know if this makes sense and if you run into any issues.

[iuridiniz]

Thanks for this answer, it was so helpful. I tried to locate these types in source code without success. Amazing project by the way.

I have another questions about the callback function:

• The first arg is a generic pointer, How can I transform it back to Codon type? I think I cannot just use codon type in func declaration since it is a FFI function, right? Sample:

@export
def cb(arg1: cobj) -> i32
    arg: Dict[int, str]  = some_kind_of_cast_to_dict(arg1)

• In rust, when a function panics it (by default) does unwind, so if I pass a callback to be called by C code, we need to care about unwinding crossing FFI boundaries[1] .
  I think that codon does unwind on runtime errors (exceptions). Is there some mechanism to change behavior of runtime errors (rust has one)? If not and if I understood Codon well, surrounding my callback with a try/except Exception (a catch all) seems sufficient to avoid unwind to cross FFI boundaries, right? Sample:

@export
def cb(arg1: cobj) -> i32
    try:
        # my code that could rise runtime errors
        # ...
    except:
        # catching all exceptions in order to stop codon unwinding cross ABI boundaries.
        return -1 # No zero values means errors

---

PS: Yes, I missed the 6th arg, I will adjust the question.

[arshajii]

Of course, glad it was helpful :)

• So to get a specific type T out of a generic pointer (cobj) p, you can do Ptr[T](p)[0] -- the first part casts p to a pointer of type T and the [0] dereferences it (i.e. gets the 0th element it points to).
• Yes Codon will unwind on exceptions. There's no way currently to change this behavior, but your try-except workaround should work; no Codon exceptions will leave cb in that case.

[iuridiniz]

• void **output: Ptr[cobj], or just cobj if you don't care about the pointer's type

I found an inconsistence here and I filled a bug at #162