#get and #set don't accept newtyped pointers

[RyanGlScott]

Trying to use #pointer's newtype feature with #get and #set is inconvenient at the moment. For example,

{-# LANGUAGE ForeignFunctionInterface #-}
module NewtypeGetSet where

import Foreign.C.Types
import Foreign.Ptr
import Foreign.Storable

#c
typedef struct {
    int x;
    int y;
} foo_t;

void simple_func(foo_t *f);
#endc

{#pointer *foo_t as FooPtr newtype #}

get :: FooPtr -> IO CInt
get = {#get foo_t.x #}

set :: FooPtr -> CInt -> IO ()
set = {#set foo_t.x #}

call :: FooPtr -> IO ()
call = {#call simple_func #}

c2hs will translate this to:

-- GENERATED by C->Haskell Compiler, version 0.17.2 Crystal Seed, 24 Jan 2009 (Haskell)
-- Edit the ORIGNAL .chs file instead!


{-# LINE 1 "NewtypeGetSet.chs" #-}
{-# LANGUAGE ForeignFunctionInterface #-}
module NewtypeGetSet where

import Foreign.C.Types
import Foreign.Ptr
import Foreign.Storable

newtype FooPtr = FooPtr (Ptr (FooPtr))
{-# LINE 16 "NewtypeGetSet.chs" #-}


get :: FooPtr -> IO CInt
get = (\ptr -> do {peekByteOff ptr 0 ::IO CInt})
{-# LINE 19 "NewtypeGetSet.chs" #-}


set :: FooPtr -> CInt -> IO ()
set = (\ptr val -> do {pokeByteOff ptr 0 (val::CInt)})
{-# LINE 22 "NewtypeGetSet.chs" #-}


call :: FooPtr -> IO ()
call = simple_func
{-# LINE 25 "NewtypeGetSet.chs" #-}

foreign import ccall safe "NewtypeGetSet.chs.h simple_func"
  simple_func :: ((FooPtr) -> (IO ()))

This is a problem, since peekByteOff and pokeByteOff both expect an argument of type Ptr a, which FooPtr is not. In order to fix this, you'd have to manually pattern-match against FooPtr, e.g.,

get :: FooPtr -> IO CInt
get (FooPtr p) = {#get foo_t.x #} p

set :: FooPtr -> CInt -> IO ()
set (FooPtr p) = {#set foo_t.x #} p

which is a bit annoying, especially since #call and #fun automate the necessary plumbing for you.

[ian-ross]

Right. The pattern match should be generated inside the get and set functions for newtype pointers. Should be easy to fix.

[ian-ross]

@RyanGlScott I'm not 100% about this in absolutely all cases, but it does correctly handle the example you gave, and I think it is just about right.

[jmillikin]

Is there any way to either check the c2hs version (e.g. with a CPP macro), or disable the new behavior? This change is backwards-incompatible, so it's currently difficult to write code that will work with both 0.17 and 0.18.

[ian-ross]

@jmillikin I'm not sure, but I'll look into it. I've raised an issue for this (#107).

[RyanGlScott]

Wait, I had no idea this would introduce a breaking change. What about this change breaks code that was build with a version of c2hs prior to 0.18?

[jmillikin]

Example code:

{# pointer *cchar_t as CCharT newtype #}

toCCharT :: Char -> IO CCharT
toCCharT char = allocaBytes {# sizeof cchar_t #} $ \pBuf -> do
  void $ {# call memset #} (castPtr pBuf) 0 {# sizeof cchar_t #}
  {# set cchar_t->chars #} pBuf (wordPtrToPtr (fromIntegral (ord char)))
  return (CCharT pBuf)

In c2hs 0.18, the call to #set will fail because it expects a CCharT but receives Ptr CCharT.

[RyanGlScott]

Good point, I forgot that others were using the workaround already. So it is a breaking change (but hopefully a sensible one, since it makes the behavior of #get and #set consistent with #call and #fun).