11

Can anyone show me an example of using a C function with variadic arguments (e.g. printf) with Haskell's Foreign Function Interface? I tried searching the HaskellWiki, but found no such examples.

Thanks!

Pascal Cuoq
  • 79,187
  • 7
  • 161
  • 281

4 Answers4

7

I don't think that's possible. You can, however, make several foreign imports of the same C function and give it different Haskell names and Haskell types. I'm not sure that is 100% portable, though.

augustss
  • 22,884
  • 5
  • 56
  • 93
  • 1
    That's the approach I take, as well. – Don Stewart May 13 '11 at 17:33
  • 2
    it is not officially supported by the FFI spec, although we go to some trouble in GHC to make sure it works (the x86_64 ABI in particular makes binding to varargs functions a bit of a pain). – Simon Marlow May 13 '11 at 18:44
  • 1
    From the Haskell 2010 spec (8.5.1): "Note that for a C function defined to accept a variable number of arguments, all arguments beyond the explicitly typed arguments suffer argument promotion. However, because C permits the calling convention to be different for such functions, a Haskell system will, in general, not be able to make use of variable argument functions. Hence, their use is deprecated in portable code." – Simon Marlow May 13 '11 at 18:54
5

You can use the Haskell interface to libffi (http://hackage.haskell.org/package/libffi), as in this code copied verbatim out of a project I'm working on (you can see it in context at https://github.com/mokus0/bindings-hdf5/blob/master/src/Bindings/HDF5/Raw/H5E.hsc). This particular function also checks for the no-arguments case and calls the C function directly when possible to avoid the small overhead associated with libffi.

-- libffi to the rescue!  I have no idea how I'd wrap this without it, and there
-- doesn't appear to be a non-deprecated non-private non-varargs equivalent.
-- 
-- |Pushes a new error record onto error stack for the current
-- thread.  The error has major and minor IDs 'maj_id' and
-- 'min_id', the name of a function where the error was detected,
-- the name of the file where the error was detected, the
-- line within that file, and an error description string.  The
-- function name, file name, and error description strings must
-- be statically allocated.
-- 
-- Returns non-negative on success/Negative on failure.
-- 
-- > herr_t H5Epush2(hid_t err_stack, const char *file, const char *func, unsigned line,
-- >     hid_t cls_id, hid_t maj_id, hid_t min_id, const char *msg, ...);
--
-- (msg is a printf format string, the varargs are the format parameters)
h5e_push2 :: HId_t -> CString -> CString -> CUInt -> HId_t -> HId_t -> HId_t -> CString -> [Arg] -> IO HErr_t
h5e_push2 err_stack file func line cls_id maj_id min_id fmt [] =
    h5e_push2_no_varargs err_stack file func line cls_id maj_id min_id fmt
h5e_push2 (HId_t err_stack) file func line (HId_t cls_id) (HId_t maj_id) (HId_t min_id) fmt varargs =
    callFFI p_H5Epush2 retHErr_t args
    where 
        argHId_t = arg#type hid_t
        retHErr_t = fmap HErr_t (ret#type herr_t)

        args = argHId_t err_stack : argPtr file : argPtr func : argCUInt line
             : argHId_t cls_id : argHId_t maj_id : argHId_t min_id : argPtr fmt
             : varargs

foreign import ccall "H5Epush2"
    h5e_push2_no_varargs :: HId_t -> CString -> CString -> CUInt -> HId_t -> HId_t -> HId_t -> CString -> IO HErr_t
foreign import ccall "&H5Epush2"
    p_H5Epush2 :: FunPtr (HId_t -> CString -> CString -> CUInt -> HId_t -> HId_t -> HId_t -> CString -> IO HErr_t)
mokus
  • 3,490
  • 16
  • 22
  • 1
    Also, there is a Haskell binding to C/Invoke (http://hackage.haskell.org/package/cinvoke), but I've always had a better impression of libffi personally. – mokus May 13 '11 at 14:40
1

In recent versions of GHC you can use the CApiFFI extension to import variable-argument C functions.

GHC Users' Guide - The CAPI calling convention

glguy
  • 1,090
  • 7
  • 8
0

https://nek0.eu/posts/2016-04-19-Interfacing-variadic-functions-from-Haskell.html

I confess I am a Haskell aficionado. Whenever I program something for pleasure, I usually prefer this language because of its elegance.

Currently I am working on Haskell bindings to the GEGL library. The motivation behind this my desire to dabble in Game development and I have the need for a library to draw on SDL Surfaces. I am obviously not really a fan of the easy solutions and I try to learn new things. Like using the Haskell FFI.

While writing the bindings I encountered the problem, that GEGL exposes variadic functions in its header which I need to interface. This poses a serious Problem for Haskell because the number of function arguments has to be constant. There is simply no way defining a function without knowing how many arguments it has and of what type each argument is. This stays true even for my solution. The only reason my solution works is that I can limit the cases how to interface these variadic functions to a manageable amount.

To build my bindings I do not use the standard FFI of Haskell, but the Haskell library inline-c to call the C functions directly without using rigid bindings. This is achieved in inline-c by wrapping the function call into a QuasiQuoter. As I said earlier, this still requires you to write a QuasiQuoter for every case this function gets called, but you don’t have to clutter your code with foreign import ccall declarations.

For limiting your cases I recommend using a sum type as a function argument. A sum type is a type which has multiple constructors. You can have a constructor for each case you need to interface and distinguish between them using Haskell’s pattern matching. You can see an example on how to make all this in my bindings.

lihansey
  • 210
  • 2
  • 5