CString, Ptr a and CInt bindings (possibly others) are missing

[abbradar]

I've found no mention in documentation about this, so I assume that this is a bug. For example:

#include <string.h>

{#fun strcmp as ^ { `CString', `CString' } -> `CInt' #}

Produces the following error:

c2hs: Errors during expansion of binding hooks:

test.chs:3: (column 47) [ERROR]  >>> Missing "out" marshaller!
  There is no default marshaller for this combination of Haskell and C type:
  Haskell type: CInt
  C type      : CInt

And if I switch CInt to Int, then:

c2hs: Errors during expansion of binding hooks:

test.chs:3: (column 21) [ERROR]  >>> Missing "in" marshaller!
  There is no default marshaller for this combination of Haskell and C type:
  Haskell type: CString
  C type      : (Ptr CChar)

I can use 'id' as a marshaller, but in my opinion, this is a workaround and C-types should work out of the box.

[ian-ross]

@abbradar I'll look at this some time in the next week. Off the top of my head right now, I can't say for sure whether this is the intended behaviour or a bug I introduced recently when I was working on the default marshaller code.

[ian-ross]

@abbradar I've been thinking about this a bit, and I'm actually kind of confused about why you want to do this. C2HS marshalls Haskell types to and from C types, so that you can use strcmp as

{# fun strcmp as ^ { `String', `String' } -> `Int' #}

without ever needing to deal with C strings from within Haskell.

I'm a little worried that adding default marshallers for the Haskell representations of the C types (i..e the things defined in Foreign.C.Types and Foreign.C.String) will just lead to confusion. Do you have a use case where it makes sense to do this, and not to be using the plain Haskell types on the Haskell side of things?

[RyanGlScott]

For me at least, having default marshallers for C types are occasionally useful when you need to deal with lower-level FFI code. As an example, I occasionally make my own Sockets from the Network.Socket package, which has the constructor MkSocket CInt Family SocketType ProtocolNumber (MVar SocketStatus), where the CInt is the result of calling a C function such as socket() or accept(). However, with c2hs currently, the return type of socket() or accept() would have to be Int, which requires an additional call to fromIntegral to allow MkSocket to use it. Having a default marshaller from CInt to CInt would spare me a little bit of boilerplate.

Similarly, having a default marshaller from Ptr a to Ptr () would be nice for functions that accept void * arguments (e.g., sdp_data_alloc() from BlueZ) to avoid having to use castPtr a bunch.

[ian-ross]

@RyanGlScott @abbradar OK, those are good justifications. Let me think about this, and I'll try to do something for it for the next release but one.

[ian-ross]

I've added default in and out marshallers for the C... types (including CString). Seems to work...

[RyanGlScott]

Just to verify, was there any change made in the default marshallers for void *? This code won't compile for me with the latest version of c2hs:

// foo.h
#ifndef FOO_H
#define FOO_H

struct list_t {
    void *elem;
    struct list_t *next;
};

struct list_t *cons(void *elem, struct list_t *list);
#endif

// foo.c
#include <stdlib.h>
#include "foo.h"

struct list_t *prepend(void *elem, struct list_t *list) {
    struct list_t *head = malloc(sizeof(struct list_t));
    head->elem = elem;
    if (list) {
        head->next = list;
    } else {
        head->next = NULL;
    }
    return head;
}

-- Main.chs
{-# LANGUAGE EmptyDataDecls, ForeignFunctionInterface #-}
module Main (main) where

import Foreign
import Foreign.C.Types

#include "foo.h"

data List
{#pointer *list_t as ListPtr -> List #}

{#fun pure cons as cons { `Ptr a', `ListPtr' } -> `ListPtr' #}

main :: IO ()
main = putStrLn "Hello, World!"

Failing with the error:

./Main.chs:12: (column 27) [ERROR]  >>> Missing "in" marshaller!
  There is no default marshaller for this combination of Haskell and C type:
  Haskell type: Ptr a
  C type      : (Ptr ())

Writing {#fun pure cons as cons { Ptr ()', ListPtr' } -> ListPtr' #}` doesn't work either.

[ian-ross]

@RyanGlScott Derp. Forgot to do the void * stuff. I'll try to get to it this week.

[ian-ross]

@RyanGlScott OK, void * pointers ought to work now -- take a look at the test case for #83, which now does some very non-Haskell-ish mallocing and strcpying...