{-# LINE 1 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 2 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 3 "Bindings/Libgit2/Diff.hsc" #-}
module Bindings.Libgit2.Diff where
import Foreign.Ptr (Ptr,FunPtr,plusPtr)
import Foreign.Ptr (wordPtrToPtr,castPtrToFunPtr)
import Foreign.Storable
import Foreign.C.Types
import Foreign.C.String (CString,CStringLen,CWString,CWStringLen)
import Foreign.Marshal.Alloc (alloca)
import Foreign.Marshal.Array (peekArray,pokeArray)
import Data.Int
import Data.Word

{-# LINE 5 "Bindings/Libgit2/Diff.hsc" #-}

import Bindings.Libgit2.Common
import Bindings.Libgit2.Types
import Bindings.Libgit2.Oid
import Bindings.Libgit2.Tree
import Bindings.Libgit2.Refs
{- enum {
    GIT_DIFF_NORMAL = 0,
    GIT_DIFF_REVERSE = 1 << 0,
    GIT_DIFF_FORCE_TEXT = 1 << 1,
    GIT_DIFF_IGNORE_WHITESPACE = 1 << 2,
    GIT_DIFF_IGNORE_WHITESPACE_CHANGE = 1 << 3,
    GIT_DIFF_IGNORE_WHITESPACE_EOL = 1 << 4,
    GIT_DIFF_IGNORE_SUBMODULES = 1 << 5,
    GIT_DIFF_PATIENCE = 1 << 6,
    GIT_DIFF_INCLUDE_IGNORED = 1 << 7,
    GIT_DIFF_INCLUDE_UNTRACKED = 1 << 8,
    GIT_DIFF_INCLUDE_UNMODIFIED = 1 << 9,
    GIT_DIFF_RECURSE_UNTRACKED_DIRS = 1 << 10
}; -}
c'GIT_DIFF_NORMAL = 0
c'GIT_DIFF_NORMAL :: (Num a) => a

{-# LINE 26 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_REVERSE = 1
c'GIT_DIFF_REVERSE :: (Num a) => a

{-# LINE 27 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FORCE_TEXT = 2
c'GIT_DIFF_FORCE_TEXT :: (Num a) => a

{-# LINE 28 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_IGNORE_WHITESPACE = 4
c'GIT_DIFF_IGNORE_WHITESPACE :: (Num a) => a

{-# LINE 29 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_IGNORE_WHITESPACE_CHANGE = 8
c'GIT_DIFF_IGNORE_WHITESPACE_CHANGE :: (Num a) => a

{-# LINE 30 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_IGNORE_WHITESPACE_EOL = 16
c'GIT_DIFF_IGNORE_WHITESPACE_EOL :: (Num a) => a

{-# LINE 31 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_IGNORE_SUBMODULES = 32
c'GIT_DIFF_IGNORE_SUBMODULES :: (Num a) => a

{-# LINE 32 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_PATIENCE = 64
c'GIT_DIFF_PATIENCE :: (Num a) => a

{-# LINE 33 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_INCLUDE_IGNORED = 128
c'GIT_DIFF_INCLUDE_IGNORED :: (Num a) => a

{-# LINE 34 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_INCLUDE_UNTRACKED = 256
c'GIT_DIFF_INCLUDE_UNTRACKED :: (Num a) => a

{-# LINE 35 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_INCLUDE_UNMODIFIED = 512
c'GIT_DIFF_INCLUDE_UNMODIFIED :: (Num a) => a

{-# LINE 36 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_RECURSE_UNTRACKED_DIRS = 1024
c'GIT_DIFF_RECURSE_UNTRACKED_DIRS :: (Num a) => a

{-# LINE 37 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef struct {
            uint32_t flags;
            uint16_t context_lines;
            uint16_t interhunk_lines;
            char * old_prefix;
            char * new_prefix;
            git_strarray pathspec;
        } git_diff_options; -}

{-# LINE 46 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 47 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 48 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 49 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 50 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 51 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 52 "Bindings/Libgit2/Diff.hsc" #-}
data C'git_diff_options = C'git_diff_options{
  c'git_diff_options'flags :: CUInt,
  c'git_diff_options'context_lines :: CUShort,
  c'git_diff_options'interhunk_lines :: CUShort,
  c'git_diff_options'old_prefix :: CString,
  c'git_diff_options'new_prefix :: CString,
  c'git_diff_options'pathspec :: C'git_strarray
} deriving (Eq,Show)
p'git_diff_options'flags p = plusPtr p 0
p'git_diff_options'flags :: Ptr (C'git_diff_options) -> Ptr (CUInt)
p'git_diff_options'context_lines p = plusPtr p 4
p'git_diff_options'context_lines :: Ptr (C'git_diff_options) -> Ptr (CUShort)
p'git_diff_options'interhunk_lines p = plusPtr p 6
p'git_diff_options'interhunk_lines :: Ptr (C'git_diff_options) -> Ptr (CUShort)
p'git_diff_options'old_prefix p = plusPtr p 8
p'git_diff_options'old_prefix :: Ptr (C'git_diff_options) -> Ptr (CString)
p'git_diff_options'new_prefix p = plusPtr p 12
p'git_diff_options'new_prefix :: Ptr (C'git_diff_options) -> Ptr (CString)
p'git_diff_options'pathspec p = plusPtr p 16
p'git_diff_options'pathspec :: Ptr (C'git_diff_options) -> Ptr (C'git_strarray)
instance Storable C'git_diff_options where
  sizeOf _ = 24
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 4
    v2 <- peekByteOff p 6
    v3 <- peekByteOff p 8
    v4 <- peekByteOff p 12
    v5 <- peekByteOff p 16
    return $ C'git_diff_options v0 v1 v2 v3 v4 v5
  poke p (C'git_diff_options v0 v1 v2 v3 v4 v5) = do
    pokeByteOff p 0 v0
    pokeByteOff p 4 v1
    pokeByteOff p 6 v2
    pokeByteOff p 8 v3
    pokeByteOff p 12 v4
    pokeByteOff p 16 v5
    return ()

{-# LINE 53 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef struct git_diff_list git_diff_list; -}
data C'git_diff_list = C'git_diff_list

{-# LINE 55 "Bindings/Libgit2/Diff.hsc" #-}
{- enum {
    GIT_DIFF_FILE_VALID_OID = 1 << 0,
    GIT_DIFF_FILE_FREE_PATH = 1 << 1,
    GIT_DIFF_FILE_BINARY = 1 << 2,
    GIT_DIFF_FILE_NOT_BINARY = 1 << 3,
    GIT_DIFF_FILE_FREE_DATA = 1 << 4,
    GIT_DIFF_FILE_UNMAP_DATA = 1 << 5
}; -}
c'GIT_DIFF_FILE_VALID_OID = 1
c'GIT_DIFF_FILE_VALID_OID :: (Num a) => a

{-# LINE 64 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FILE_FREE_PATH = 2
c'GIT_DIFF_FILE_FREE_PATH :: (Num a) => a

{-# LINE 65 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FILE_BINARY = 4
c'GIT_DIFF_FILE_BINARY :: (Num a) => a

{-# LINE 66 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FILE_NOT_BINARY = 8
c'GIT_DIFF_FILE_NOT_BINARY :: (Num a) => a

{-# LINE 67 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FILE_FREE_DATA = 16
c'GIT_DIFF_FILE_FREE_DATA :: (Num a) => a

{-# LINE 68 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FILE_UNMAP_DATA = 32
c'GIT_DIFF_FILE_UNMAP_DATA :: (Num a) => a

{-# LINE 69 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef enum {
            GIT_DELTA_UNMODIFIED = 0,
            GIT_DELTA_ADDED = 1,
            GIT_DELTA_DELETED = 2,
            GIT_DELTA_MODIFIED = 3,
            GIT_DELTA_RENAMED = 4,
            GIT_DELTA_COPIED = 5,
            GIT_DELTA_IGNORED = 6,
            GIT_DELTA_UNTRACKED = 7
        } git_delta_t; -}
type C'git_delta_t = CUInt

{-# LINE 80 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DELTA_UNMODIFIED = 0
c'GIT_DELTA_UNMODIFIED :: (Num a) => a

{-# LINE 81 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DELTA_ADDED = 1
c'GIT_DELTA_ADDED :: (Num a) => a

{-# LINE 82 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DELTA_DELETED = 2
c'GIT_DELTA_DELETED :: (Num a) => a

{-# LINE 83 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DELTA_MODIFIED = 3
c'GIT_DELTA_MODIFIED :: (Num a) => a

{-# LINE 84 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DELTA_RENAMED = 4
c'GIT_DELTA_RENAMED :: (Num a) => a

{-# LINE 85 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DELTA_COPIED = 5
c'GIT_DELTA_COPIED :: (Num a) => a

{-# LINE 86 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DELTA_IGNORED = 6
c'GIT_DELTA_IGNORED :: (Num a) => a

{-# LINE 87 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DELTA_UNTRACKED = 7
c'GIT_DELTA_UNTRACKED :: (Num a) => a

{-# LINE 88 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef struct {
            git_oid oid;
            char * path;
            uint16_t mode;
            git_off_t size;
            unsigned int flags;
        } git_diff_file; -}

{-# LINE 96 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 97 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 98 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 99 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 100 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 101 "Bindings/Libgit2/Diff.hsc" #-}
data C'git_diff_file = C'git_diff_file{
  c'git_diff_file'oid :: C'git_oid,
  c'git_diff_file'path :: CString,
  c'git_diff_file'mode :: CUShort,
  c'git_diff_file'size :: CLong,
  c'git_diff_file'flags :: CUInt
} deriving (Eq,Show)
p'git_diff_file'oid p = plusPtr p 0
p'git_diff_file'oid :: Ptr (C'git_diff_file) -> Ptr (C'git_oid)
p'git_diff_file'path p = plusPtr p 20
p'git_diff_file'path :: Ptr (C'git_diff_file) -> Ptr (CString)
p'git_diff_file'mode p = plusPtr p 24
p'git_diff_file'mode :: Ptr (C'git_diff_file) -> Ptr (CUShort)
p'git_diff_file'size p = plusPtr p 28
p'git_diff_file'size :: Ptr (C'git_diff_file) -> Ptr (CLong)
p'git_diff_file'flags p = plusPtr p 36
p'git_diff_file'flags :: Ptr (C'git_diff_file) -> Ptr (CUInt)
instance Storable C'git_diff_file where
  sizeOf _ = 40
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 20
    v2 <- peekByteOff p 24
    v3 <- peekByteOff p 28
    v4 <- peekByteOff p 36
    return $ C'git_diff_file v0 v1 v2 v3 v4
  poke p (C'git_diff_file v0 v1 v2 v3 v4) = do
    pokeByteOff p 0 v0
    pokeByteOff p 20 v1
    pokeByteOff p 24 v2
    pokeByteOff p 28 v3
    pokeByteOff p 36 v4
    return ()

{-# LINE 102 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef struct {
            git_diff_file old_file;
            git_diff_file new_file;
            git_delta_t status;
            unsigned int similarity;
            int binary;
        } git_diff_delta; -}

{-# LINE 110 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 111 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 112 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 113 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 114 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 115 "Bindings/Libgit2/Diff.hsc" #-}
data C'git_diff_delta = C'git_diff_delta{
  c'git_diff_delta'old_file :: C'git_diff_file,
  c'git_diff_delta'new_file :: C'git_diff_file,
  c'git_diff_delta'status :: C'git_delta_t,
  c'git_diff_delta'similarity :: CUInt,
  c'git_diff_delta'binary :: CInt
} deriving (Eq,Show)
p'git_diff_delta'old_file p = plusPtr p 0
p'git_diff_delta'old_file :: Ptr (C'git_diff_delta) -> Ptr (C'git_diff_file)
p'git_diff_delta'new_file p = plusPtr p 40
p'git_diff_delta'new_file :: Ptr (C'git_diff_delta) -> Ptr (C'git_diff_file)
p'git_diff_delta'status p = plusPtr p 80
p'git_diff_delta'status :: Ptr (C'git_diff_delta) -> Ptr (C'git_delta_t)
p'git_diff_delta'similarity p = plusPtr p 84
p'git_diff_delta'similarity :: Ptr (C'git_diff_delta) -> Ptr (CUInt)
p'git_diff_delta'binary p = plusPtr p 88
p'git_diff_delta'binary :: Ptr (C'git_diff_delta) -> Ptr (CInt)
instance Storable C'git_diff_delta where
  sizeOf _ = 92
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 40
    v2 <- peekByteOff p 80
    v3 <- peekByteOff p 84
    v4 <- peekByteOff p 88
    return $ C'git_diff_delta v0 v1 v2 v3 v4
  poke p (C'git_diff_delta v0 v1 v2 v3 v4) = do
    pokeByteOff p 0 v0
    pokeByteOff p 40 v1
    pokeByteOff p 80 v2
    pokeByteOff p 84 v3
    pokeByteOff p 88 v4
    return ()

{-# LINE 116 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef int (* git_diff_file_fn)(void * cb_data,
                                 git_diff_delta * delta,
                                 float progress); -}
type C'git_diff_file_fn = CInt

{-# LINE 120 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef struct {
            int old_start; int old_lines; int new_start; int new_lines;
        } git_diff_range; -}

{-# LINE 124 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 125 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 126 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 127 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 128 "Bindings/Libgit2/Diff.hsc" #-}
data C'git_diff_range = C'git_diff_range{
  c'git_diff_range'old_start :: CInt,
  c'git_diff_range'old_lines :: CInt,
  c'git_diff_range'new_start :: CInt,
  c'git_diff_range'new_lines :: CInt
} deriving (Eq,Show)
p'git_diff_range'old_start p = plusPtr p 0
p'git_diff_range'old_start :: Ptr (C'git_diff_range) -> Ptr (CInt)
p'git_diff_range'old_lines p = plusPtr p 4
p'git_diff_range'old_lines :: Ptr (C'git_diff_range) -> Ptr (CInt)
p'git_diff_range'new_start p = plusPtr p 8
p'git_diff_range'new_start :: Ptr (C'git_diff_range) -> Ptr (CInt)
p'git_diff_range'new_lines p = plusPtr p 12
p'git_diff_range'new_lines :: Ptr (C'git_diff_range) -> Ptr (CInt)
instance Storable C'git_diff_range where
  sizeOf _ = 16
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 4
    v2 <- peekByteOff p 8
    v3 <- peekByteOff p 12
    return $ C'git_diff_range v0 v1 v2 v3
  poke p (C'git_diff_range v0 v1 v2 v3) = do
    pokeByteOff p 0 v0
    pokeByteOff p 4 v1
    pokeByteOff p 8 v2
    pokeByteOff p 12 v3
    return ()

{-# LINE 129 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef int (* git_diff_hunk_fn)(void * cb_data,
                                 git_diff_delta * delta,
                                 git_diff_range * range,
                                 const char * header,
                                 size_t header_len); -}
type C'git_diff_hunk_fn = CInt

{-# LINE 135 "Bindings/Libgit2/Diff.hsc" #-}
{- enum {
    GIT_DIFF_LINE_CONTEXT = ' ',
    GIT_DIFF_LINE_ADDITION = '+',
    GIT_DIFF_LINE_DELETION = '-',
    GIT_DIFF_LINE_ADD_EOFNL = '\n',
    GIT_DIFF_LINE_DEL_EOFNL = '\0',
    GIT_DIFF_LINE_FILE_HDR = 'F',
    GIT_DIFF_LINE_HUNK_HDR = 'H',
    GIT_DIFF_LINE_BINARY = 'B'
}; -}
c'GIT_DIFF_LINE_CONTEXT = 32
c'GIT_DIFF_LINE_CONTEXT :: (Num a) => a

{-# LINE 146 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_LINE_ADDITION = 43
c'GIT_DIFF_LINE_ADDITION :: (Num a) => a

{-# LINE 147 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_LINE_DELETION = 45
c'GIT_DIFF_LINE_DELETION :: (Num a) => a

{-# LINE 148 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_LINE_ADD_EOFNL = 10
c'GIT_DIFF_LINE_ADD_EOFNL :: (Num a) => a

{-# LINE 149 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_LINE_DEL_EOFNL = 0
c'GIT_DIFF_LINE_DEL_EOFNL :: (Num a) => a

{-# LINE 150 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_LINE_FILE_HDR = 70
c'GIT_DIFF_LINE_FILE_HDR :: (Num a) => a

{-# LINE 151 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_LINE_HUNK_HDR = 72
c'GIT_DIFF_LINE_HUNK_HDR :: (Num a) => a

{-# LINE 152 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_LINE_BINARY = 66
c'GIT_DIFF_LINE_BINARY :: (Num a) => a

{-# LINE 153 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef int (* git_diff_data_fn)(void * cb_data,
                                 git_diff_delta * delta,
                                 git_diff_range * range,
                                 char line_origin,
                                 const char * content,
                                 size_t content_len); -}
type C'git_diff_data_fn = CInt

{-# LINE 160 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_list_free" c'git_diff_list_free
  :: Ptr C'git_diff_list -> IO ()
foreign import ccall "&git_diff_list_free" p'git_diff_list_free
  :: FunPtr (Ptr C'git_diff_list -> IO ())

{-# LINE 161 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_tree_to_tree" c'git_diff_tree_to_tree
  :: Ptr C'git_repository -> Ptr C'git_diff_options -> Ptr C'git_tree -> Ptr C'git_tree -> Ptr (Ptr C'git_diff_list) -> IO (CInt)
foreign import ccall "&git_diff_tree_to_tree" p'git_diff_tree_to_tree
  :: FunPtr (Ptr C'git_repository -> Ptr C'git_diff_options -> Ptr C'git_tree -> Ptr C'git_tree -> Ptr (Ptr C'git_diff_list) -> IO (CInt))

{-# LINE 162 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_index_to_tree" c'git_diff_index_to_tree
  :: Ptr C'git_repository -> Ptr C'git_diff_options -> Ptr C'git_tree -> Ptr (Ptr C'git_diff_list) -> IO (CInt)
foreign import ccall "&git_diff_index_to_tree" p'git_diff_index_to_tree
  :: FunPtr (Ptr C'git_repository -> Ptr C'git_diff_options -> Ptr C'git_tree -> Ptr (Ptr C'git_diff_list) -> IO (CInt))

{-# LINE 163 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_workdir_to_index" c'git_diff_workdir_to_index
  :: Ptr C'git_repository -> Ptr C'git_diff_options -> Ptr (Ptr C'git_diff_list) -> IO (CInt)
foreign import ccall "&git_diff_workdir_to_index" p'git_diff_workdir_to_index
  :: FunPtr (Ptr C'git_repository -> Ptr C'git_diff_options -> Ptr (Ptr C'git_diff_list) -> IO (CInt))

{-# LINE 164 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_workdir_to_tree" c'git_diff_workdir_to_tree
  :: Ptr C'git_repository -> Ptr C'git_diff_options -> Ptr C'git_tree -> Ptr (Ptr C'git_diff_list) -> IO (CInt)
foreign import ccall "&git_diff_workdir_to_tree" p'git_diff_workdir_to_tree
  :: FunPtr (Ptr C'git_repository -> Ptr C'git_diff_options -> Ptr C'git_tree -> Ptr (Ptr C'git_diff_list) -> IO (CInt))

{-# LINE 165 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_merge" c'git_diff_merge
  :: Ptr C'git_diff_list -> Ptr C'git_diff_list -> IO (CInt)
foreign import ccall "&git_diff_merge" p'git_diff_merge
  :: FunPtr (Ptr C'git_diff_list -> Ptr C'git_diff_list -> IO (CInt))

{-# LINE 166 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_foreach" c'git_diff_foreach
  :: Ptr C'git_diff_list -> Ptr () -> CInt -> CInt -> CInt -> IO (CInt)
foreign import ccall "&git_diff_foreach" p'git_diff_foreach
  :: FunPtr (Ptr C'git_diff_list -> Ptr () -> CInt -> CInt -> CInt -> IO (CInt))

{-# LINE 167 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_print_compact" c'git_diff_print_compact
  :: Ptr C'git_diff_list -> Ptr () -> CInt -> IO (CInt)
foreign import ccall "&git_diff_print_compact" p'git_diff_print_compact
  :: FunPtr (Ptr C'git_diff_list -> Ptr () -> CInt -> IO (CInt))

{-# LINE 168 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_print_patch" c'git_diff_print_patch
  :: Ptr C'git_diff_list -> Ptr () -> CInt -> IO (CInt)
foreign import ccall "&git_diff_print_patch" p'git_diff_print_patch
  :: FunPtr (Ptr C'git_diff_list -> Ptr () -> CInt -> IO (CInt))

{-# LINE 169 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_blobs" c'git_diff_blobs
  :: Ptr C'git_blob -> Ptr C'git_blob -> Ptr C'git_diff_options -> Ptr () -> CInt -> CInt -> CInt -> IO (CInt)
foreign import ccall "&git_diff_blobs" p'git_diff_blobs
  :: FunPtr (Ptr C'git_blob -> Ptr C'git_blob -> Ptr C'git_diff_options -> Ptr () -> CInt -> CInt -> CInt -> IO (CInt))

{-# LINE 170 "Bindings/Libgit2/Diff.hsc" #-}