Libgit2 update

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "hlibgit2/libgit2"]
 	path = hlibgit2/libgit2
-	url = https://github.com/jwiegley/libgit2.git
+	url = https://github.com/libgit2/libgit2.git

cabal.project

@@ -0,0 +1,6 @@
+packages: 
+  --*/*.cabal
+  gitlib
+  gitlib-libgit2
+  gitlib-test
+  hlibgit2

gitlib-libgit2/Git/Libgit2/Backend.hs

@@ -32,38 +32,38 @@ import Foreign.Storable
 import Git.Libgit2.Types
 
 type F'git_odb_backend_read_callback =
-    Ptr (Ptr ()) -> Ptr CSize -> Ptr C'git_otype -> Ptr C'git_odb_backend
+    Ptr (Ptr ()) -> Ptr CSize -> Ptr C'git_object_t -> Ptr C'git_odb_backend
         -> Ptr C'git_oid -> IO CInt
 type F'git_odb_backend_read_prefix_callback =
-    Ptr C'git_oid -> Ptr (Ptr ()) -> Ptr CSize -> Ptr C'git_otype
+    Ptr C'git_oid -> Ptr (Ptr ()) -> Ptr CSize -> Ptr C'git_object_t
         -> Ptr C'git_odb_backend -> Ptr C'git_oid -> CSize -> IO CInt
 type F'git_odb_backend_readstream_callback =
     Ptr (Ptr C'git_odb_stream) -> Ptr C'git_odb_backend -> Ptr C'git_oid
         -> IO CInt
 type F'git_odb_backend_read_header_callback =
-    Ptr CSize -> Ptr C'git_otype -> Ptr C'git_odb_backend -> Ptr C'git_oid
+    Ptr CSize -> Ptr C'git_object_t -> Ptr C'git_odb_backend -> Ptr C'git_oid
         -> IO CInt
 type F'git_odb_backend_write_callback =
-    Ptr C'git_oid -> Ptr C'git_odb_backend -> Ptr () -> CSize -> C'git_otype
+    Ptr C'git_oid -> Ptr C'git_odb_backend -> Ptr () -> CSize -> C'git_object_t
         -> IO CInt
 type F'git_odb_backend_writestream_callback =
     Ptr (Ptr C'git_odb_stream) -> Ptr C'git_odb_backend -> CSize
-        -> C'git_otype -> IO CInt
+        -> C'git_object_t -> IO CInt
 type F'git_odb_backend_exists_callback =
     Ptr C'git_odb_backend -> Ptr C'git_oid -> CInt -> IO CInt
 type F'git_odb_backend_refresh_callback = Ptr C'git_odb_backend -> IO CInt
 type F'git_odb_backend_foreach_callback =
     Ptr C'git_odb_backend -> C'git_odb_foreach_cb -> Ptr () -> IO CInt
 type F'git_odb_backend_writepack_callback =
     Ptr (Ptr C'git_odb_writepack) -> Ptr C'git_odb_backend
-        -> C'git_transfer_progress_callback -> Ptr () -> IO CInt
+        -> C'git_indexer_progress_cb -> Ptr () -> IO CInt
 type F'git_odb_backend_free_callback = Ptr C'git_odb_backend -> IO ()
 
 type F'git_odb_writepack_add_callback =
-    Ptr C'git_odb_writepack -> Ptr () -> CSize -> Ptr C'git_transfer_progress
+    Ptr C'git_odb_writepack -> Ptr () -> CSize -> Ptr C'git_indexer_progress_cb
         -> IO CInt
 type F'git_odb_writepack_commit_callback =
-    Ptr C'git_odb_writepack -> Ptr C'git_transfer_progress -> IO CInt
+    Ptr C'git_odb_writepack -> Ptr C'git_indexer_progress_cb -> IO CInt
 type F'git_odb_writepack_free_callback = Ptr C'git_odb_writepack -> IO ()
 
 

gitlib-libgit2/Git/Libgit2/Internal.hs

@@ -29,18 +29,18 @@ import           Git.Libgit2.Trace
 import           Git.Libgit2.Types
 import           System.FilePath.Posix
 
-addTracingBackend :: LgRepo -> IO ()
-addTracingBackend repo =
-    withCString (lgRepoPath repo </> "objects") $ \objectsDir ->
-        alloca $ \loosePtr -> do
-            r <- c'git_odb_backend_loose loosePtr objectsDir (-1) 0
-            when (r < 0) $
-                error "Failed to create loose objects backend"
-
-            loosePtr' <- peek loosePtr
-            backend   <- traceBackend loosePtr'
-            void $ odbBackendAdd repo backend 3
-            return ()
+--addTracingBackend :: LgRepo -> IO ()
+--addTracingBackend repo =
+--    withCString (lgRepoPath repo </> "objects") $ \objectsDir ->
+--        alloca $ \loosePtr -> do
+--            r <- c'git_odb_backend_loose loosePtr objectsDir (-1) 0
+--            when (r < 0) $
+--                error "Failed to create loose objects backend"
+--
+--            loosePtr' <- peek loosePtr
+--            backend   <- traceBackend loosePtr'
+--            void $ odbBackendAdd repo backend 3
+--            return ()
 
 coidPtrToOid :: Ptr C'git_oid -> IO (ForeignPtr C'git_oid)
 coidPtrToOid coidptr = do
@@ -68,7 +68,7 @@ lookupObject' oid len lookupFn lookupPrefixFn createFn = do
             then do
               oidStr <- withForeignPtr oid (flip oidToStr len)
               let args = ["Could not lookup ", T.pack oidStr]
-              err <- c'giterr_last
+              err <- c'git_error_last
               if err == nullPtr
                   then return $ Left $ T.concat args
                   else do

gitlib-libgit2/Git/Libgit2/Trace.hs

@@ -9,144 +9,150 @@ import Bindings.Libgit2
 import Control.Applicative
 import Control.Monad
 import Foreign.C.String
+import Foreign.ForeignPtr
 import Foreign.Marshal.Utils
 import Foreign.Ptr
 import Foreign.Storable
 import Git.Libgit2.Backend
 import Prelude hiding (mapM_)
 
-data TraceBackend = TraceBackend { traceParent :: C'git_odb_backend
-                                 , traceNext   :: Ptr C'git_odb_backend }
-
-instance Storable TraceBackend where
-  sizeOf _ = sizeOf (undefined :: C'git_odb_backend) +
-             sizeOf (undefined :: Ptr C'git_odb_backend)
-  alignment p = alignment (traceParent p)
-  peek p = do
-    v0 <- peekByteOff p 0
-    v1 <- peekByteOff p (sizeOf (undefined :: C'git_odb_backend))
-    return (TraceBackend v0 v1)
-  poke p (TraceBackend v0 v1) = do
-    pokeByteOff p 0 v0
-    pokeByteOff p (sizeOf (undefined :: C'git_odb_backend)) v1
-    return ()
+--data TraceBackend = TraceBackend { traceParent :: C'git_odb_backend
+--                                 , traceNext   :: Ptr C'git_odb_backend }
+--
+--instance Storable TraceBackend where
+--  sizeOf _ = sizeOf (undefined :: C'git_odb_backend) +
+--             sizeOf (undefined :: Ptr C'git_odb_backend)
+--  alignment p = alignment (traceParent p)
+--  peek p = do
+--    v0 <- peekByteOff p 0
+--    v1 <- peekByteOff p (sizeOf (undefined :: C'git_odb_backend))
+--    return (TraceBackend v0 v1)
+--  poke p (TraceBackend v0 v1) = do
+--    pokeByteOff p 0 v0
+--    pokeByteOff p (sizeOf (undefined :: C'git_odb_backend)) v1
+--    return ()
 
 oidToStr :: Ptr C'git_oid -> Int -> IO String
-oidToStr oid len = c'git_oid_allocfmt oid >>= fmap (take len) . peekCString
-
-traceBackendReadCallback :: F'git_odb_backend_read_callback
-traceBackendReadCallback data_p len_p type_p be oid = do
-  oidStr <- oidToStr oid 40
-  putStrLn $ "Read " ++ oidStr
-  tb <- peek (castPtr be :: Ptr TraceBackend)
-  tn <- peek (traceNext tb)
-  mK'git_odb_backend_read_callback
-      (c'git_odb_backend'read tn)
-      data_p
-      len_p
-      type_p
-      (traceNext tb)
-      oid
-
-traceBackendReadPrefixCallback :: F'git_odb_backend_read_prefix_callback
-traceBackendReadPrefixCallback out_oid oid_p len_p type_p be oid len = do
-  oidStr <- oidToStr oid 40
-  putStrLn $ "Read Prefix " ++ oidStr ++ " " ++ show len
-  tb <- peek (castPtr be :: Ptr TraceBackend)
-  tn <- peek (traceNext tb)
-  mK'git_odb_backend_read_prefix_callback
-      (c'git_odb_backend'read_prefix tn)
-      out_oid
-      oid_p
-      len_p
-      type_p
-      (traceNext tb)
-      oid
-      len
-
-traceBackendReadHeaderCallback :: F'git_odb_backend_read_header_callback
-traceBackendReadHeaderCallback len_p type_p be oid = do
-  oidStr <- oidToStr oid 40
-  putStrLn $ "Read Header " ++ oidStr
-  tb <- peek (castPtr be :: Ptr TraceBackend)
-  tn <- peek (traceNext tb)
-  mK'git_odb_backend_read_header_callback
-      (c'git_odb_backend'read_header tn)
-      len_p
-      type_p
-      (traceNext tb)
-      oid
-
-traceBackendWriteCallback :: F'git_odb_backend_write_callback
-traceBackendWriteCallback oid be obj_data len obj_type = do
-  r <- c'git_odb_hash oid obj_data len obj_type
-  case r of
-    0 -> do
-      oidStr <- oidToStr oid 40
-      putStrLn $ "Write " ++ oidStr ++ " len " ++ show len
-      tb <- peek (castPtr be :: Ptr TraceBackend)
-      tn <- peek (traceNext tb)
-      mK'git_odb_backend_write_callback
-          (c'git_odb_backend'write tn)
-          oid
-          (traceNext tb)
-          obj_data
-          len
-          obj_type
-    n -> return n
-
-traceBackendExistsCallback :: F'git_odb_backend_exists_callback
-traceBackendExistsCallback be oid confirmNotExists = do
-  oidStr <- oidToStr oid 40
-  putStrLn $ "Exists " ++ oidStr
-  tb <- peek (castPtr be :: Ptr TraceBackend)
-  tn <- peek (traceNext tb)
-  mK'git_odb_backend_exists_callback
-      (c'git_odb_backend'exists tn)
-      (traceNext tb)
-      oid
-      confirmNotExists
-
-traceBackendFreeCallback :: F'git_odb_backend_free_callback
-traceBackendFreeCallback be = do
-  backend <- peek be
-  freeHaskellFunPtr (c'git_odb_backend'read backend)
-  freeHaskellFunPtr (c'git_odb_backend'read_prefix backend)
-  freeHaskellFunPtr (c'git_odb_backend'read_header backend)
-  freeHaskellFunPtr (c'git_odb_backend'write backend)
-  freeHaskellFunPtr (c'git_odb_backend'exists backend)
-
-foreign export ccall "traceBackendFreeCallback"
-  traceBackendFreeCallback :: F'git_odb_backend_free_callback
-foreign import ccall "&traceBackendFreeCallback"
-  traceBackendFreeCallbackPtr :: FunPtr F'git_odb_backend_free_callback
-
-traceBackend :: Ptr C'git_odb_backend -> IO (Ptr C'git_odb_backend)
-traceBackend be = do
-  readFun <- mk'git_odb_backend_read_callback traceBackendReadCallback
-  readPrefixFun <-
-    mk'git_odb_backend_read_prefix_callback traceBackendReadPrefixCallback
-  readHeaderFun <-
-    mk'git_odb_backend_read_header_callback traceBackendReadHeaderCallback
-  writeFun <- mk'git_odb_backend_write_callback traceBackendWriteCallback
-  existsFun <- mk'git_odb_backend_exists_callback traceBackendExistsCallback
+oidToStr oid len = do 
+  ptr <- mallocForeignPtrArray0 len
+  withForeignPtr ptr $ \ptr' -> do
+    _ <- c'git_oid_fmt ptr' oid 
+    str <- peekCString ptr'
+    return $ take len str
 
-  castPtr <$> new TraceBackend {
-    traceParent = C'git_odb_backend {
-         c'git_odb_backend'version     = 1
-       , c'git_odb_backend'odb         = nullPtr
-       , c'git_odb_backend'read        = readFun
-       , c'git_odb_backend'read_prefix = readPrefixFun
-       , c'git_odb_backend'readstream  = nullFunPtr
-       , c'git_odb_backend'read_header = readHeaderFun
-       , c'git_odb_backend'write       = writeFun
-       , c'git_odb_backend'writestream = nullFunPtr
-       , c'git_odb_backend'exists      = existsFun
-       , c'git_odb_backend'refresh     = undefined
-       , c'git_odb_backend'foreach     = undefined
-       , c'git_odb_backend'writepack   = undefined
-       , c'git_odb_backend'free        = traceBackendFreeCallbackPtr
-       }
-    , traceNext = be }
+--traceBackendReadCallback :: F'git_odb_backend_read_callback
+--traceBackendReadCallback data_p len_p type_p be oid = do
+--  oidStr <- oidToStr oid 40
+--  putStrLn $ "Read " ++ oidStr
+--  tb <- peek (castPtr be :: Ptr TraceBackend)
+--  tn <- peek (traceNext tb)
+--  mK'git_odb_backend_read_callback
+--      (c'git_odb_backend'read tn)
+--      data_p
+--      len_p
+--      type_p
+--      (traceNext tb)
+--      oid
+--
+--traceBackendReadPrefixCallback :: F'git_odb_backend_read_prefix_callback
+--traceBackendReadPrefixCallback out_oid oid_p len_p type_p be oid len = do
+--  oidStr <- oidToStr oid 40
+--  putStrLn $ "Read Prefix " ++ oidStr ++ " " ++ show len
+--  tb <- peek (castPtr be :: Ptr TraceBackend)
+--  tn <- peek (traceNext tb)
+--  mK'git_odb_backend_read_prefix_callback
+--      (c'git_odb_backend'read_prefix tn)
+--      out_oid
+--      oid_p
+--      len_p
+--      type_p
+--      (traceNext tb)
+--      oid
+--      len
+--
+--traceBackendReadHeaderCallback :: F'git_odb_backend_read_header_callback
+--traceBackendReadHeaderCallback len_p type_p be oid = do
+--  oidStr <- oidToStr oid 40
+--  putStrLn $ "Read Header " ++ oidStr
+--  tb <- peek (castPtr be :: Ptr TraceBackend)
+--  tn <- peek (traceNext tb)
+--  mK'git_odb_backend_read_header_callback
+--      (c'git_odb_backend'read_header tn)
+--      len_p
+--      type_p
+--      (traceNext tb)
+--      oid
+--
+--traceBackendWriteCallback :: F'git_odb_backend_write_callback
+--traceBackendWriteCallback oid be obj_data len obj_type = do
+--  r <- c'git_odb_hash oid obj_data len obj_type
+--  case r of
+--    0 -> do
+--      oidStr <- oidToStr oid 40
+--      putStrLn $ "Write " ++ oidStr ++ " len " ++ show len
+--      tb <- peek (castPtr be :: Ptr TraceBackend)
+--      tn <- peek (traceNext tb)
+--      mK'git_odb_backend_write_callback
+--          (c'git_odb_backend'write tn)
+--          oid
+--          (traceNext tb)
+--          obj_data
+--          len
+--          obj_type
+--    n -> return n
+--
+--traceBackendExistsCallback :: F'git_odb_backend_exists_callback
+--traceBackendExistsCallback be oid confirmNotExists = do
+--  oidStr <- oidToStr oid 40
+--  putStrLn $ "Exists " ++ oidStr
+--  tb <- peek (castPtr be :: Ptr TraceBackend)
+--  tn <- peek (traceNext tb)
+--  mK'git_odb_backend_exists_callback
+--      (c'git_odb_backend'exists tn)
+--      (traceNext tb)
+--      oid
+--      confirmNotExists
+--
+--traceBackendFreeCallback :: F'git_odb_backend_free_callback
+--traceBackendFreeCallback be = do
+--  backend <- peek be
+--  freeHaskellFunPtr (c'git_odb_backend'read backend)
+--  freeHaskellFunPtr (c'git_odb_backend'read_prefix backend)
+--  freeHaskellFunPtr (c'git_odb_backend'read_header backend)
+--  freeHaskellFunPtr (c'git_odb_backend'write backend)
+--  freeHaskellFunPtr (c'git_odb_backend'exists backend)
+--
+--foreign export ccall "traceBackendFreeCallback"
+--  traceBackendFreeCallback :: F'git_odb_backend_free_callback
+--foreign import ccall "&traceBackendFreeCallback"
+--  traceBackendFreeCallbackPtr :: FunPtr F'git_odb_backend_free_callback
+--
+--traceBackend :: Ptr C'git_odb_backend -> IO (Ptr C'git_odb_backend)
+--traceBackend be = do
+--  readFun <- mk'git_odb_backend_read_callback traceBackendReadCallback
+--  readPrefixFun <-
+--    mk'git_odb_backend_read_prefix_callback traceBackendReadPrefixCallback
+--  readHeaderFun <-
+--    mk'git_odb_backend_read_header_callback traceBackendReadHeaderCallback
+--  writeFun <- mk'git_odb_backend_write_callback traceBackendWriteCallback
+--  existsFun <- mk'git_odb_backend_exists_callback traceBackendExistsCallback
+--
+--  castPtr <$> new TraceBackend {
+--    traceParent = C'git_odb_backend {
+--         c'git_odb_backend'version     = 1
+--       , c'git_odb_backend'odb         = nullPtr
+--       , c'git_odb_backend'read        = readFun
+--       , c'git_odb_backend'read_prefix = readPrefixFun
+--       , c'git_odb_backend'readstream  = nullFunPtr
+--       , c'git_odb_backend'read_header = readHeaderFun
+--       , c'git_odb_backend'write       = writeFun
+--       , c'git_odb_backend'writestream = nullFunPtr
+--       , c'git_odb_backend'exists      = existsFun
+--       , c'git_odb_backend'refresh     = undefined
+--       , c'git_odb_backend'foreach     = undefined
+--       , c'git_odb_backend'writepack   = undefined
+--       , c'git_odb_backend'free        = traceBackendFreeCallbackPtr
+--       }
+--    , traceNext = be }
 
 -- Trace.hs