build fix

4 files changed, 215 insertions, 126 deletions

diff --git a/haskell/Data/VCDIFF.hsc b/haskell/Data/VCDIFF.hs
index 804b119..a776052 100644
--- a/haskell/Data/VCDIFF.hsc
+++ b/haskell/Data/VCDIFF.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS_GHC -Wno-partial-type-signatures #-}
 {-# LANGUAGE BangPatterns               #-}
 {-# LANGUAGE DataKinds                  #-}
 {-# LANGUAGE DeriveFunctor              #-}
@@ -8,7 +7,6 @@
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE LambdaCase                 #-}
 {-# LANGUAGE NondecreasingIndentation   #-}
-{-# LANGUAGE PartialTypeSignatures      #-}
 {-# LANGUAGE PatternSynonyms            #-}
 {-# LANGUAGE RankNTypes                 #-}
 {-# LANGUAGE TypeFamilies               #-}
@@ -49,19 +47,8 @@ import GHC.TypeLits
 import Data.VCDIFF.Types
 import Data.VCDIFF.XDelta
 
-#ifndef SIZEOF_SIZE_T
-#define SIZEOF_SIZE_T __SIZEOF_SIZE_T__
-#define SIZEOF_UNSIGNED_INT __SIZEOF_INT__
-#define SIZEOF_UNSIGNED_LONG __SIZEOF_LONG__
-#define SIZEOF_UNSIGNED_LONG_LONG __SIZEOF_LONG_LONG__
-#define static_assert(...)
-#endif
-#include <xdelta3.h>
-
-#include "offset.h"
-
 data Stream m = Stream
-    { streamArray  :: MutableByteArray (PrimState m)
+    { streamArray  :: StreamArray m
     , streamPtr    :: ForeignPtr Xd3Stream -- ^ HACK: this is only used to attach a finalizer
                                            -- to 'streamArray'.  Don't use this pointer.
                                            -- This would be unnecessary if I could create a
@@ -69,73 +56,16 @@ data Stream m = Stream
     , streamSource :: MutVar (PrimState m) (Maybe (Source m))
     }
 
-foreign import ccall "xdelta3.h xd3_config_stream" xd3_config_stream :: Ptr Xd3Stream -> Ptr Config -> IO ErrorCode
-
-foreign import ccall "xdelta3.h xd3_free_stream" xd3_free_stream :: Ptr Xd3Stream -> IO ()
-
-foreign import ccall "xdelta3.h xd3_abort_stream" xd3_abort_stream :: Ptr Xd3Stream -> IO ()
-
-foreign import ccall "xdelta3.h xd3_close_stream" xd3_close_stream :: Ptr Xd3Stream -> IO ErrorCode
-
-
-
-writeCompressorConfig :: (PrimMonad m, _) => MutableByteArray (PrimState m) -> Offset j -> CompressorConfig -> m ()
-writeCompressorConfig c o sec = do
-    writeAtByte c (o +. #{off xd3_sec_cfg,ngroups}) (ngroups sec)
-    writeAtByte c (o +. #{off xd3_sec_cfg,sector_size}) (sector_size sec)
-    writeAtByte c (o +. #{off xd3_sec_cfg,inefficient}) (inefficient sec)
-
-writeMatcher :: (PrimMonad m, _) => MutableByteArray (PrimState m) -> Offset j -> StringMatcher -> m ()
-writeMatcher c o sm = do
-    -- handled elsewhere: const char *name; <- smName :: String
-    writeAtByte c (o +. #{off xd3_smatcher, string_match }) (smStringMatch sm)
-    writeAtByte c (o +. #{off xd3_smatcher, large_look   }) (smLargeLook sm)
-    writeAtByte c (o +. #{off xd3_smatcher, large_step   }) (smLargeStep sm)
-    writeAtByte c (o +. #{off xd3_smatcher, small_look   }) (smSmallLook sm)
-    writeAtByte c (o +. #{off xd3_smatcher, small_chain  }) (smSmallChain sm)
-    writeAtByte c (o +. #{off xd3_smatcher, small_lchain }) (smSmallLchain sm)
-    writeAtByte c (o +. #{off xd3_smatcher, max_lazy     }) (smMaxLazy sm)
-    writeAtByte c (o +. #{off xd3_smatcher, long_enough  }) (smLongEnough sm)
 
 -- The xd3_config structure is used to initialize a stream - all data
 -- is copied into stream so config may be a temporary variable.  See
 -- the [documentation] or comments on the xd3_config structure.
 config_stream :: PrimMonad m => Config -> m (Either ErrorCode (Stream m))
 config_stream cfg = do
-    let (len,n) = case smatch_cfg cfg of
-            Left  m -> let n = encodeUtf8 $ T.pack $ smName m
-                       in ( #{const sizeof(xd3_stream)} + B.length n + 1
-                          , n )
-            Right _ -> ( #{const sizeof(xd3_stream)}, B.empty )
-    s <- newPinnedByteArray len
-    let sptr = ptr (mutableByteArrayContents s) :: Ptr Xd3Stream
-    fillByteArray s 0 #{const sizeof(xd3_stream)} 0
-    nptr <- case smatch_cfg cfg of
-        Right _ -> writeStringAt s #{const sizeof(xd3_stream)} n
-        Left _ -> return nullPtr
-    c <- do
-        c <- newPinnedByteArray #const sizeof(xd3_config)
-        fillByteArray c 0 #{const sizeof(xd3_config)} 0
-        writeAtByte c #{off xd3_config, winsize} (winsize cfg)
-        writeAtByte c #{off xd3_config, sprevsz} (sprevsz cfg)
-        writeAtByte c #{off xd3_config, iopt_size} (iopt_size cfg)
-        writeAtByte c #{off xd3_config, flags} (coerce (flags cfg) :: Word32)
-        writeCompressorConfig c #{off xd3_config, sec_data} (sec_data cfg)
-        writeCompressorConfig c #{off xd3_config, sec_inst} (sec_inst cfg)
-        writeCompressorConfig c #{off xd3_config, sec_addr} (sec_addr cfg)
-        let msel :: #type xd3_smatch_cfg
-            msel = either (const #{const XD3_SMATCH_SOFT})
-                          (fromIntegral . fromEnum)
-                          (smatch_cfg cfg)
-        writeAtByte c (#{off xd3_config, smatch_cfg}) msel
-        case smatch_cfg cfg of
-            Right _      -> return ()
-            Left matcher -> do
-                let o = offset :: Offset #offset xd3_config,smatcher_soft
-                writeAtByte c (o +. (#{off xd3_smatcher, name})) nptr
-                writeMatcher c o matcher
-        unsafeFreezeByteArray c
+    (s,nptr) <- newStreamArray (either (Just . smName) (const Nothing) (smatch_cfg cfg))
+    c <- packConfig nptr cfg
     let cptr = ptr (byteArrayContents c) :: Ptr Config
+        sptr = streamArrayPtr s
     srcvar <- newMutVar Nothing
     stream <- unsafeIOToPrim $ do
         let finalize = do
@@ -154,8 +84,6 @@ config_stream cfg = do
         XD3_SUCCESS -> return $ c `seq` Right stream
         ecode       -> return $ Left ecode
 
-foreign import ccall "xdelta3.h xd3_set_source" xd3_set_source :: Ptr Xd3Stream -> Ptr Xd3Source -> IO ErrorCode
-
 
 set_source :: PrimMonad m =>
                     Stream m -> String  -- ^ name for debug/print purposes.
@@ -170,7 +98,7 @@ set_source stream nm blksz maxwinsz = do
                 #{offset xd3_stream, getblk}
                 nullPtr -- xdelta3.h documents this as an internal field.
     -}
-    let strm = ptr (mutableByteArrayContents $ streamArray stream)
+    let strm = streamArrayPtr $ streamArray stream
     unsafeIOToPrim (xd3_set_source strm $ sourcePtr src)
     writeMutVar (streamSource stream) (Just src)
 
@@ -186,43 +114,14 @@ data XDeltaMethods m u = XDeltaMethods
 -- -- | Checks for legal flag changes.
 -- foreign import ccall "xdelta3.h xd3_set_flags" xd3_set_flags :: Ptr Xd3Stream -> Flags -> IO ()
 
-setFlag :: PrimMonad m => Flags -> Stream m -> Bool -> m ()
-setFlag b stream wantFlush = do
-    f <- readAtByte (streamArray stream) (#{off xd3_stream, flags})
-    writeAtByte (streamArray stream) (#{off xd3_stream, flags})
-        . (coerce :: Flags -> Word32)
-        $ if wantFlush then Flags f .|. b
-                       else Flags f .&. complement b
-
-setFlush :: PrimMonad m => Stream m -> Bool -> m ()
-setFlush = setFlag XD3_FLUSH
-
-setSkipWindow :: PrimMonad m => Stream m -> Bool -> m ()
-setSkipWindow = setFlag XD3_SKIP_WINDOW
-
 -- -- declared static
 -- foreign import ccall "xdelta3.h xd3_avail_input" xd3_avail_input :: Ptr Xd3Stream -> Ptr a -> Usize_t -> IO ()
 
-avail_input :: PrimMonad m => Stream m -> Ptr a -> Usize_t -> m ()
-avail_input stream p sz = do
-    writeAtByte (streamArray stream) (#{off xd3_stream, next_in}) p
-    writeAtByte (streamArray stream) (#{off xd3_stream, avail_in}) sz
-
 -- | This acknowledges receipt of output data, must be called after any
 -- XD3_OUTPUT return.
 -- -- declared static
 -- foreign import ccall "xdelta3.h xd3_consume_output" xd3_consume_output :: Ptr Xd3Stream -> IO ()
 
-nextOut :: PrimMonad m => Stream m -> ((Ptr Word8, Usize_t) -> m a) -> m a
-nextOut stream action = do
-    buf <- (,)
-        <$> readAtByte (streamArray stream) (#{off xd3_stream, next_out})
-        <*> readAtByte (streamArray stream) (#{off xd3_stream, avail_out})
-    a <- action buf
-    -- unsafeIOToPrim $ xd3_consume_output (ptr $ mutableByteArrayContents $ streamArray stream)
-    writeAtByte (streamArray stream) (#{off xd3_stream, avail_out}) (0 :: Usize_t)
-    return a
-
 requestedBlockNumber :: PrimMonad m => Stream m -> m (Maybe Xoff_t)
 requestedBlockNumber stream = do
     msrc <- readMutVar $ streamSource stream
@@ -231,15 +130,6 @@ requestedBlockNumber stream = do
 -- -- declared static
 -- foreign import ccall "xdelta3.h xd3_errstring" xd3_errstring :: Ptr Xd3Stream -> IO CString
 
--- | Gives some extra information about the latest library error, if any
--- is known.
-errorString :: PrimMonad m => Stream m -> m String
-errorString stream = do
-    cstring <- readAtByte (streamArray stream) (#{off xd3_stream, msg})
-    if cstring /= nullPtr
-        then unsafeIOToPrim $ peekCString cstring -- TODO: avoid unsafeIOToPrim
-        else return ""
-
 pokeCurrentBlock :: PrimMonad m => Stream m -> CurrentBlock -> m ()
 pokeCurrentBlock stream blk = do
     msrc <- readMutVar $ streamSource stream
@@ -262,16 +152,16 @@ xdelta x xxcode_input ds = do
         go withBlk (d:ds) = do
             let (fp,off,len) = B.toForeignPtr d
                 eof = null ds
-            when eof $ setFlush stream True
+            when eof $ setFlush (streamArray stream) True
             withByteString d $ \indata len -> do
-                avail_input stream indata len
+                avail_input (streamArray stream) indata len
                 go2 withBlk eof ds
         go2 withBlk eof ds = do
             ret <- withBlk $ xxcode_input stream
             case ret of
                 XD3_INPUT -> if (not eof) then go withBlk ds else return mempty
                 XD3_OUTPUT -> do
-                    m' <- nextOut stream (\(p,len) -> xOutput x p (fromIntegral len))
+                    m' <- nextOut (streamArray stream) (\(p,len) -> xOutput x p (fromIntegral len))
                     ms <- xInterleave x $ go2 withBlk eof ds
                     return $ m' <> ms
                 XD3_GETSRCBLK -> do
@@ -292,21 +182,18 @@ xdelta x xxcode_input ds = do
                             -- xd3_encoder_srcbase :: Ptr Stream -> IO Xoff_t
                             -- xd3_encoder_srclen :: Ptr Stream -> IO Usize_t
                 e -> do
-                    s <- errorString stream
+                    s <- errorString (streamArray stream)
                     xOnError x e s
     xInterleave x $ go id ds
 
 
-foreign import ccall "xdelta3.h xd3_decode_input" xd3_decode_input  :: Ptr Xd3Stream -> IO ErrorCode
-foreign import ccall "xdelta3.h xd3_encode_input" xd3_encode_input  :: Ptr Xd3Stream -> IO ErrorCode
-
 decode_input :: PrimMonad m => Stream m -> m ErrorCode
 decode_input stream =
-    unsafeIOToPrim $ xd3_decode_input (ptr $ mutableByteArrayContents $ streamArray stream)
+    unsafeIOToPrim $ xd3_decode_input (streamArrayPtr $ streamArray stream)
 
 encode_input :: PrimMonad m => Stream m -> m ErrorCode
 encode_input stream =
-    unsafeIOToPrim $ xd3_encode_input (ptr $ mutableByteArrayContents $ streamArray stream)
+    unsafeIOToPrim $ xd3_encode_input (streamArrayPtr $ streamArray stream)
 
 -- RFC 3284
 newtype VCDIFF = VCDIFF L.ByteString
diff --git a/haskell/Data/VCDIFF/XDelta.hsc b/haskell/Data/VCDIFF/XDelta.hsc
new file mode 100644
index 0000000..6e32494
--- /dev/null
+++ b/haskell/Data/VCDIFF/XDelta.hsc
@@ -0,0 +1,202 @@
+{-# OPTIONS_GHC -Wno-partial-type-signatures #-}
+{-# LANGUAGE DataKinds             #-}
+{-# LANGUAGE PartialTypeSignatures #-}
+{-# LANGUAGE TypeFamilies          #-}
+module Data.VCDIFF.XDelta where
+
+import Control.Monad
+import Control.Monad.Primitive
+import Data.Bits
+import qualified Data.ByteString     as B
+import Data.Coerce
+import Data.Int
+import Data.Primitive.ByteArray
+import Data.Primitive.ByteArray.Util
+import qualified Data.Text           as T
+import Data.Text.Encoding
+import Data.VCDIFF.Types
+import Data.Word
+import Foreign.C.Types
+import Foreign.C.String
+import Foreign.Ptr
+
+#ifndef SIZEOF_SIZE_T
+#define SIZEOF_SIZE_T __SIZEOF_SIZE_T__
+#define SIZEOF_UNSIGNED_INT __SIZEOF_INT__
+#define SIZEOF_UNSIGNED_LONG __SIZEOF_LONG__
+#define SIZEOF_UNSIGNED_LONG_LONG __SIZEOF_LONG_LONG__
+#define static_assert(...)
+#endif
+#include <xdelta3.h>
+
+#include "offset.h"
+
+type instance SizeOf Usize_t              = #const sizeof(usize_t)
+type instance SizeOf (FunPtr a)           = #const sizeof(void(*)())
+type instance SizeOf (Ptr a)              = #const sizeof(void*)
+type instance SizeOf #{type int}          = #const sizeof(int)
+type instance SizeOf #{type unsigned int} = #const sizeof(unsigned int)
+
+
+data Xd3Source
+
+newtype Source m = Source (MutableByteArray (PrimState m))
+
+newSource :: PrimMonad m =>
+                    String  -- ^ name for debug/print purposes.
+                    -> Usize_t -- ^ block size
+                    -> Xoff_t  -- ^ maximum visible buffer (Suggested: set same as block size).
+                               -- Rounds up to approx 16k.
+                    -> m (Source m)
+newSource nm blksz maxwinsz = do
+    let bsname = encodeUtf8 $ T.pack nm
+    src <- newPinnedByteArray $ 1 + B.length bsname + #{const sizeof(xd3_source)}
+    nptr <- writeStringAt src #{const sizeof(xd3_source)} bsname
+    writeAtByte src (#{off xd3_source, blksize    }) blksz
+    writeAtByte src (#{off xd3_source, name       }) nptr
+    writeAtByte src (#{off xd3_source, max_winsize}) maxwinsz
+    writeAtByte src (#{off xd3_source, curblkno   }) (maxBound :: Xoff_t)
+    return $ Source src
+
+sourcePtr :: Source m -> Ptr Xd3Source
+sourcePtr (Source src) = ptr (mutableByteArrayContents src)
+
+sourceRequestedBlocknumber :: PrimMonad m => Source m -> m Xoff_t
+sourceRequestedBlocknumber (Source src) = readAtByte src (#{off xd3_source, getblkno})
+
+data CurrentBlock = CurrentBlock
+    { blkno   :: !Xoff_t      -- ^ current block number
+    , blkSize :: !Usize_t     -- ^ number of bytes on current block: must be >= 0 and <= 'srcBlockSize'
+    , blkPtr  :: !(Ptr Word8) -- ^ current block array
+    }
+
+sourceWriteCurrentBlock :: PrimMonad m => Source m -> CurrentBlock -> m ()
+sourceWriteCurrentBlock (Source src) (CurrentBlock no sz ptr) = do
+    writeAtByte src (#{off xd3_source, curblkno}) no
+    writeAtByte src (#{off xd3_source, onblk})    sz
+    writeAtByte src (#{off xd3_source, curblk})   ptr
+
+sourceWriteEOFKnown :: PrimMonad m => Source m -> Bool -> m ()
+sourceWriteEOFKnown (Source src) False = writeAtByte src (#{off xd3_source, eof_known}) (0 :: #{type int})
+sourceWriteEOFKnown (Source src) True  = writeAtByte src (#{off xd3_source, eof_known}) (1 :: #{type int})
+
+newtype StreamArray m = StreamArray (MutableByteArray (PrimState m))
+
+newStreamArray :: PrimMonad m =>
+                        Maybe String -> m (StreamArray m, CString)
+newStreamArray mmatcher = do
+    let (len,n) = case mmatcher of
+            Just m  -> let n = encodeUtf8 $ T.pack m
+                       in ( #{const sizeof(xd3_stream)} + B.length n + 1
+                          , n )
+            Nothing -> ( #{const sizeof(xd3_stream)}, B.empty )
+    s <- newPinnedByteArray len
+    fillByteArray s 0 #{const sizeof(xd3_stream)} 0
+    nptr <- case mmatcher of
+        Nothing -> writeStringAt s #{const sizeof(xd3_stream)} n
+        Just _  -> return nullPtr
+    return (StreamArray s,nptr)
+
+streamArrayPtr :: StreamArray m -> Ptr Xd3Stream
+streamArrayPtr (StreamArray s) = ptr (mutableByteArrayContents s)
+
+setFlag :: PrimMonad m => Flags -> StreamArray m -> Bool -> m ()
+setFlag b (StreamArray s) wantFlush = do
+    f <- readAtByte s (#{off xd3_stream, flags})
+    writeAtByte s (#{off xd3_stream, flags})
+        . (coerce :: Flags -> Word32)
+        $ if wantFlush then Flags f .|. b
+                       else Flags f .&. complement b
+
+setFlush :: PrimMonad m => StreamArray m -> Bool -> m ()
+setFlush = setFlag XD3_FLUSH
+
+setSkipWindow :: PrimMonad m => StreamArray m -> Bool -> m ()
+setSkipWindow = setFlag XD3_SKIP_WINDOW
+
+
+avail_input :: PrimMonad m => StreamArray m -> Ptr a -> Usize_t -> m ()
+avail_input (StreamArray s) p sz = do
+    writeAtByte s (#{off xd3_stream, next_in}) p
+    writeAtByte s (#{off xd3_stream, avail_in}) sz
+
+
+nextOut :: PrimMonad m => StreamArray m -> ((Ptr Word8, Usize_t) -> m a) -> m a
+nextOut (StreamArray s) action = do
+    buf <- (,)
+        <$> readAtByte s (#{off xd3_stream, next_out})
+        <*> readAtByte s (#{off xd3_stream, avail_out})
+    a <- action buf
+    -- unsafeIOToPrim $ xd3_consume_output (ptr $ mutableByteArrayContents $ streamArray stream)
+    writeAtByte s #{off xd3_stream, avail_out} (0 :: Usize_t)
+    return a
+
+
+-- | Gives some extra information about the latest library error, if any
+-- is known.
+errorString :: PrimMonad m => StreamArray m -> m String
+errorString (StreamArray s) = do
+    cstring <- readAtByte s (#{off xd3_stream, msg})
+    if cstring /= nullPtr
+        then unsafeIOToPrim $ peekCString cstring -- TODO: avoid unsafeIOToPrim
+        else return ""
+
+writeCompressorConfig :: (PrimMonad m, _) => MutableByteArray (PrimState m) -> Offset j -> CompressorConfig -> m ()
+writeCompressorConfig c o sec = do
+    writeAtByte c (o +. #{off xd3_sec_cfg,ngroups}) (ngroups sec)
+    writeAtByte c (o +. #{off xd3_sec_cfg,sector_size}) (sector_size sec)
+    writeAtByte c (o +. #{off xd3_sec_cfg,inefficient}) (inefficient sec)
+
+writeMatcher :: (PrimMonad m, _) => MutableByteArray (PrimState m) -> Offset j -> StringMatcher -> m ()
+writeMatcher c o sm = do
+    -- handled elsewhere: const char *name; <- smName :: String
+    writeAtByte c (o +. #{off xd3_smatcher, string_match }) (smStringMatch sm)
+    writeAtByte c (o +. #{off xd3_smatcher, large_look   }) (smLargeLook sm)
+    writeAtByte c (o +. #{off xd3_smatcher, large_step   }) (smLargeStep sm)
+    writeAtByte c (o +. #{off xd3_smatcher, small_look   }) (smSmallLook sm)
+    writeAtByte c (o +. #{off xd3_smatcher, small_chain  }) (smSmallChain sm)
+    writeAtByte c (o +. #{off xd3_smatcher, small_lchain }) (smSmallLchain sm)
+    writeAtByte c (o +. #{off xd3_smatcher, max_lazy     }) (smMaxLazy sm)
+    writeAtByte c (o +. #{off xd3_smatcher, long_enough  }) (smLongEnough sm)
+
+packConfig :: PrimMonad m => CString -- ^ Name of software matcher or nullPtr.
+                          -> Config
+                          -> m ByteArray
+packConfig nptr cfg = do
+    c <- newPinnedByteArray #const sizeof(xd3_config)
+    fillByteArray c 0 #{const sizeof(xd3_config)} 0
+    writeAtByte c #{off xd3_config, winsize} (winsize cfg)
+    writeAtByte c #{off xd3_config, sprevsz} (sprevsz cfg)
+    writeAtByte c #{off xd3_config, iopt_size} (iopt_size cfg)
+    writeAtByte c #{off xd3_config, flags} (coerce (flags cfg) :: Word32)
+    writeCompressorConfig c #{off xd3_config, sec_data} (sec_data cfg)
+    writeCompressorConfig c #{off xd3_config, sec_inst} (sec_inst cfg)
+    writeCompressorConfig c #{off xd3_config, sec_addr} (sec_addr cfg)
+    let msel :: #type xd3_smatch_cfg
+        msel = either (const #{const XD3_SMATCH_SOFT})
+                      (fromIntegral . fromEnum)
+                      (smatch_cfg cfg)
+    writeAtByte c (#{off xd3_config, smatch_cfg}) msel
+    let mmatcher = either Just (const Nothing) $ smatch_cfg cfg
+    forM_ mmatcher $ \matcher -> do
+            let o = #off xd3_config,smatcher_soft
+            writeAtByte c (o +. (#{off xd3_smatcher, name})) nptr
+            writeMatcher c o matcher
+    unsafeFreezeByteArray c
+
+foreign import ccall "xdelta3.h xd3_config_stream" xd3_config_stream :: Ptr Xd3Stream -> Ptr Config -> IO ErrorCode
+
+foreign import ccall "xdelta3.h xd3_free_stream" xd3_free_stream :: Ptr Xd3Stream -> IO ()
+
+foreign import ccall "xdelta3.h xd3_abort_stream" xd3_abort_stream :: Ptr Xd3Stream -> IO ()
+
+foreign import ccall "xdelta3.h xd3_close_stream" xd3_close_stream :: Ptr Xd3Stream -> IO ErrorCode
+
+
+foreign import ccall "xdelta3.h xd3_decode_input" xd3_decode_input  :: Ptr Xd3Stream -> IO ErrorCode
+foreign import ccall "xdelta3.h xd3_encode_input" xd3_encode_input  :: Ptr Xd3Stream -> IO ErrorCode
+
+
+foreign import ccall "xdelta3.h xd3_set_source" xd3_set_source :: Ptr Xd3Stream -> Ptr Xd3Source -> IO ErrorCode
+
+
diff --git a/haskell/Text/XXD.hs b/haskell/examples/Text/XXD.hs
index 77606bf..77606bf 100644
--- a/haskell/Text/XXD.hs
+++ b/haskell/examples/Text/XXD.hs
diff --git a/xdelta.cabal b/xdelta.cabal
index 6540559..4864d92 100644
--- a/xdelta.cabal
+++ b/xdelta.cabal
@@ -11,7 +11,7 @@ maintainer:          joe@jerkface.net
 category:            Data
 build-type:          Simple
 
-extra-source-files:  xdelta3/*.h xdelta3/*.c
+extra-source-files:  xdelta3/*.h xdelta3/*.c haskell/*.h
 
 library
   exposed-modules:  Data.VCDIFF.Types
@@ -33,5 +33,5 @@ library
 executable testdiff
   main-is: haskell/examples/testdiff.hs
   other-modules: Text.XXD
-  hs-source-dirs: haskell examples .
+  hs-source-dirs: haskell/examples .
   build-depends: base, bytestring, memory, xdelta