module SDL.Raw.Filesystem (
  -- * Filesystem Paths
  getBasePath,
  getPrefPath,

  -- * File I/O Abstraction
  allocRW,
  freeRW,
  rwFromConstMem,
  rwFromFP,
  rwFromFile,
  rwFromMem,
  rwClose,
  rwRead,
  rwSeek,
  rwTell,
  rwWrite,
  readBE16,
  readBE32,
  readBE64,
  readLE16,
  readLE32,
  readLE64,
  writeBE16,
  writeBE32,
  writeBE64,
  writeLE16,
  writeLE32,
  writeLE64
) where

import Control.Monad.IO.Class
import Data.Int
import Data.Word
import Foreign.C.String
import Foreign.C.Types
import Foreign.Ptr
import SDL.Raw.Types

foreign import ccall "SDL.h SDL_GetBasePath" getBasePathFFI :: IO CString
foreign import ccall "SDL.h SDL_GetPrefPath" getPrefPathFFI :: CString -> CString -> IO CString

foreign import ccall "SDL.h SDL_AllocRW" allocRWFFI :: IO (Ptr RWops)
foreign import ccall "SDL.h SDL_FreeRW" freeRWFFI :: Ptr RWops -> IO ()
foreign import ccall "SDL.h SDL_RWFromConstMem" rwFromConstMemFFI :: Ptr () -> CInt -> IO (Ptr RWops)
foreign import ccall "SDL.h SDL_RWFromFP" rwFromFPFFI :: Ptr () -> Bool -> IO (Ptr RWops)
foreign import ccall "SDL.h SDL_RWFromFile" rwFromFileFFI :: CString -> CString -> IO (Ptr RWops)
foreign import ccall "SDL.h SDL_RWFromMem" rwFromMemFFI :: Ptr () -> CInt -> IO (Ptr RWops)
foreign import ccall "sdlhelper.h SDLHelper_RWclose" rwCloseFFI :: Ptr RWops -> IO CInt
foreign import ccall "sdlhelper.h SDLHelper_RWread" rwReadFFI :: Ptr RWops -> Ptr () -> CSize -> CSize -> IO CSize
foreign import ccall "sdlhelper.h SDLHelper_RWseek" rwSeekFFI :: Ptr RWops -> Int64 -> CInt -> IO Int64
foreign import ccall "sdlhelper.h SDLHelper_RWtell" rwTellFFI :: Ptr RWops -> IO Int64
foreign import ccall "sdlhelper.h SDLHelper_RWwrite" rwWriteFFI :: Ptr RWops -> Ptr () -> CSize -> CSize -> IO CSize
foreign import ccall "SDL.h SDL_ReadBE16" readBE16FFI :: Ptr RWops -> IO Word16
foreign import ccall "SDL.h SDL_ReadBE32" readBE32FFI :: Ptr RWops -> IO Word32
foreign import ccall "SDL.h SDL_ReadBE64" readBE64FFI :: Ptr RWops -> IO Word64
foreign import ccall "SDL.h SDL_ReadLE16" readLE16FFI :: Ptr RWops -> IO Word16
foreign import ccall "SDL.h SDL_ReadLE32" readLE32FFI :: Ptr RWops -> IO Word32
foreign import ccall "SDL.h SDL_ReadLE64" readLE64FFI :: Ptr RWops -> IO Word64
foreign import ccall "SDL.h SDL_WriteBE16" writeBE16FFI :: Ptr RWops -> Word16 -> IO CSize
foreign import ccall "SDL.h SDL_WriteBE32" writeBE32FFI :: Ptr RWops -> Word32 -> IO CSize
foreign import ccall "SDL.h SDL_WriteBE64" writeBE64FFI :: Ptr RWops -> Word64 -> IO CSize
foreign import ccall "SDL.h SDL_WriteLE16" writeLE16FFI :: Ptr RWops -> Word16 -> IO CSize
foreign import ccall "SDL.h SDL_WriteLE32" writeLE32FFI :: Ptr RWops -> Word32 -> IO CSize
foreign import ccall "SDL.h SDL_WriteLE64" writeLE64FFI :: Ptr RWops -> Word64 -> IO CSize

getBasePath :: MonadIO m => m CString
getBasePath :: m CString
getBasePath = IO CString -> m CString
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO CString
getBasePathFFI
{-# INLINE getBasePath #-}

getPrefPath :: MonadIO m => CString -> CString -> m CString
getPrefPath :: CString -> CString -> m CString
getPrefPath v1 :: CString
v1 v2 :: CString
v2 = IO CString -> m CString
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CString -> m CString) -> IO CString -> m CString
forall a b. (a -> b) -> a -> b
$ CString -> CString -> IO CString
getPrefPathFFI CString
v1 CString
v2
{-# INLINE getPrefPath #-}

allocRW :: MonadIO m => m (Ptr RWops)
allocRW :: m (Ptr RWops)
allocRW = IO (Ptr RWops) -> m (Ptr RWops)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO (Ptr RWops)
allocRWFFI
{-# INLINE allocRW #-}

freeRW :: MonadIO m => Ptr RWops -> m ()
freeRW :: Ptr RWops -> m ()
freeRW v1 :: Ptr RWops
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> IO ()
freeRWFFI Ptr RWops
v1
{-# INLINE freeRW #-}

rwFromConstMem :: MonadIO m => Ptr () -> CInt -> m (Ptr RWops)
rwFromConstMem :: Ptr () -> CInt -> m (Ptr RWops)
rwFromConstMem v1 :: Ptr ()
v1 v2 :: CInt
v2 = IO (Ptr RWops) -> m (Ptr RWops)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr RWops) -> m (Ptr RWops))
-> IO (Ptr RWops) -> m (Ptr RWops)
forall a b. (a -> b) -> a -> b
$ Ptr () -> CInt -> IO (Ptr RWops)
rwFromConstMemFFI Ptr ()
v1 CInt
v2
{-# INLINE rwFromConstMem #-}

rwFromFP :: MonadIO m => Ptr () -> Bool -> m (Ptr RWops)
rwFromFP :: Ptr () -> Bool -> m (Ptr RWops)
rwFromFP v1 :: Ptr ()
v1 v2 :: Bool
v2 = IO (Ptr RWops) -> m (Ptr RWops)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr RWops) -> m (Ptr RWops))
-> IO (Ptr RWops) -> m (Ptr RWops)
forall a b. (a -> b) -> a -> b
$ Ptr () -> Bool -> IO (Ptr RWops)
rwFromFPFFI Ptr ()
v1 Bool
v2
{-# INLINE rwFromFP #-}

rwFromFile :: MonadIO m => CString -> CString -> m (Ptr RWops)
rwFromFile :: CString -> CString -> m (Ptr RWops)
rwFromFile v1 :: CString
v1 v2 :: CString
v2 = IO (Ptr RWops) -> m (Ptr RWops)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr RWops) -> m (Ptr RWops))
-> IO (Ptr RWops) -> m (Ptr RWops)
forall a b. (a -> b) -> a -> b
$ CString -> CString -> IO (Ptr RWops)
rwFromFileFFI CString
v1 CString
v2
{-# INLINE rwFromFile #-}

rwFromMem :: MonadIO m => Ptr () -> CInt -> m (Ptr RWops)
rwFromMem :: Ptr () -> CInt -> m (Ptr RWops)
rwFromMem v1 :: Ptr ()
v1 v2 :: CInt
v2 = IO (Ptr RWops) -> m (Ptr RWops)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr RWops) -> m (Ptr RWops))
-> IO (Ptr RWops) -> m (Ptr RWops)
forall a b. (a -> b) -> a -> b
$ Ptr () -> CInt -> IO (Ptr RWops)
rwFromMemFFI Ptr ()
v1 CInt
v2
{-# INLINE rwFromMem #-}

rwClose :: MonadIO m => Ptr RWops -> m CInt
rwClose :: Ptr RWops -> m CInt
rwClose v1 :: Ptr RWops
v1 = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> IO CInt
rwCloseFFI Ptr RWops
v1
{-# INLINE rwClose #-}

rwRead :: MonadIO m => Ptr RWops -> Ptr () -> CSize -> CSize -> m CSize
rwRead :: Ptr RWops -> Ptr () -> CSize -> CSize -> m CSize
rwRead v1 :: Ptr RWops
v1 v2 :: Ptr ()
v2 v3 :: CSize
v3 v4 :: CSize
v4 = IO CSize -> m CSize
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CSize -> m CSize) -> IO CSize -> m CSize
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> Ptr () -> CSize -> CSize -> IO CSize
rwReadFFI Ptr RWops
v1 Ptr ()
v2 CSize
v3 CSize
v4
{-# INLINE rwRead #-}

rwSeek :: MonadIO m => Ptr RWops -> Int64 -> CInt -> m Int64
rwSeek :: Ptr RWops -> Int64 -> CInt -> m Int64
rwSeek v1 :: Ptr RWops
v1 v2 :: Int64
v2 v3 :: CInt
v3 = IO Int64 -> m Int64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> Int64 -> CInt -> IO Int64
rwSeekFFI Ptr RWops
v1 Int64
v2 CInt
v3
{-# INLINE rwSeek #-}

rwTell :: MonadIO m => Ptr RWops -> m Int64
rwTell :: Ptr RWops -> m Int64
rwTell v1 :: Ptr RWops
v1 = IO Int64 -> m Int64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> IO Int64
rwTellFFI Ptr RWops
v1
{-# INLINE rwTell #-}

rwWrite :: MonadIO m => Ptr RWops -> Ptr () -> CSize -> CSize -> m CSize
rwWrite :: Ptr RWops -> Ptr () -> CSize -> CSize -> m CSize
rwWrite v1 :: Ptr RWops
v1 v2 :: Ptr ()
v2 v3 :: CSize
v3 v4 :: CSize
v4 = IO CSize -> m CSize
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CSize -> m CSize) -> IO CSize -> m CSize
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> Ptr () -> CSize -> CSize -> IO CSize
rwWriteFFI Ptr RWops
v1 Ptr ()
v2 CSize
v3 CSize
v4
{-# INLINE rwWrite #-}

readBE16 :: MonadIO m => Ptr RWops -> m Word16
readBE16 :: Ptr RWops -> m Word16
readBE16 v1 :: Ptr RWops
v1 = IO Word16 -> m Word16
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word16 -> m Word16) -> IO Word16 -> m Word16
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> IO Word16
readBE16FFI Ptr RWops
v1
{-# INLINE readBE16 #-}

readBE32 :: MonadIO m => Ptr RWops -> m Word32
readBE32 :: Ptr RWops -> m Word32
readBE32 v1 :: Ptr RWops
v1 = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> IO Word32
readBE32FFI Ptr RWops
v1
{-# INLINE readBE32 #-}

readBE64 :: MonadIO m => Ptr RWops -> m Word64
readBE64 :: Ptr RWops -> m Word64
readBE64 v1 :: Ptr RWops
v1 = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> IO Word64
readBE64FFI Ptr RWops
v1
{-# INLINE readBE64 #-}

readLE16 :: MonadIO m => Ptr RWops -> m Word16
readLE16 :: Ptr RWops -> m Word16
readLE16 v1 :: Ptr RWops
v1 = IO Word16 -> m Word16
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word16 -> m Word16) -> IO Word16 -> m Word16
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> IO Word16
readLE16FFI Ptr RWops
v1
{-# INLINE readLE16 #-}

readLE32 :: MonadIO m => Ptr RWops -> m Word32
readLE32 :: Ptr RWops -> m Word32
readLE32 v1 :: Ptr RWops
v1 = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> IO Word32
readLE32FFI Ptr RWops
v1
{-# INLINE readLE32 #-}

readLE64 :: MonadIO m => Ptr RWops -> m Word64
readLE64 :: Ptr RWops -> m Word64
readLE64 v1 :: Ptr RWops
v1 = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> IO Word64
readLE64FFI Ptr RWops
v1
{-# INLINE readLE64 #-}

writeBE16 :: MonadIO m => Ptr RWops -> Word16 -> m CSize
writeBE16 :: Ptr RWops -> Word16 -> m CSize
writeBE16 v1 :: Ptr RWops
v1 v2 :: Word16
v2 = IO CSize -> m CSize
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CSize -> m CSize) -> IO CSize -> m CSize
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> Word16 -> IO CSize
writeBE16FFI Ptr RWops
v1 Word16
v2
{-# INLINE writeBE16 #-}

writeBE32 :: MonadIO m => Ptr RWops -> Word32 -> m CSize
writeBE32 :: Ptr RWops -> Word32 -> m CSize
writeBE32 v1 :: Ptr RWops
v1 v2 :: Word32
v2 = IO CSize -> m CSize
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CSize -> m CSize) -> IO CSize -> m CSize
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> Word32 -> IO CSize
writeBE32FFI Ptr RWops
v1 Word32
v2
{-# INLINE writeBE32 #-}

writeBE64 :: MonadIO m => Ptr RWops -> Word64 -> m CSize
writeBE64 :: Ptr RWops -> Word64 -> m CSize
writeBE64 v1 :: Ptr RWops
v1 v2 :: Word64
v2 = IO CSize -> m CSize
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CSize -> m CSize) -> IO CSize -> m CSize
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> Word64 -> IO CSize
writeBE64FFI Ptr RWops
v1 Word64
v2
{-# INLINE writeBE64 #-}

writeLE16 :: MonadIO m => Ptr RWops -> Word16 -> m CSize
writeLE16 :: Ptr RWops -> Word16 -> m CSize
writeLE16 v1 :: Ptr RWops
v1 v2 :: Word16
v2 = IO CSize -> m CSize
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CSize -> m CSize) -> IO CSize -> m CSize
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> Word16 -> IO CSize
writeLE16FFI Ptr RWops
v1 Word16
v2
{-# INLINE writeLE16 #-}

writeLE32 :: MonadIO m => Ptr RWops -> Word32 -> m CSize
writeLE32 :: Ptr RWops -> Word32 -> m CSize
writeLE32 v1 :: Ptr RWops
v1 v2 :: Word32
v2 = IO CSize -> m CSize
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CSize -> m CSize) -> IO CSize -> m CSize
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> Word32 -> IO CSize
writeLE32FFI Ptr RWops
v1 Word32
v2
{-# INLINE writeLE32 #-}

writeLE64 :: MonadIO m => Ptr RWops -> Word64 -> m CSize
writeLE64 :: Ptr RWops -> Word64 -> m CSize
writeLE64 v1 :: Ptr RWops
v1 v2 :: Word64
v2 = IO CSize -> m CSize
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CSize -> m CSize) -> IO CSize -> m CSize
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> Word64 -> IO CSize
writeLE64FFI Ptr RWops
v1 Word64
v2
{-# INLINE writeLE64 #-}