{-# LINE 1 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}

{-# LINE 2 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
{-# LANGUAGE Safe #-}

{-# LINE 6 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
-----------------------------------------------------------------------------

-- |

-- Module      :  System.Win32.Mem

-- Copyright   :  (c) Alastair Reid, 1997-2003

-- License     :  BSD-style (see the file libraries/base/LICENSE)

--

-- Maintainer  :  Esa Ilari Vuokko <ei@vuokko.info>

-- Stability   :  provisional

-- Portability :  portable

--

-- A collection of FFI declarations for interfacing with Win32.

--

-----------------------------------------------------------------------------


module System.Win32.Mem
    ( MEMORY_BASIC_INFORMATION(..)
    , copyMemory
    , moveMemory
    , fillMemory
    , zeroMemory
    , memset
    , getProcessHeap

{-# LINE 29 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
    , getProcessHeaps

{-# LINE 31 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
    , HGLOBAL
      -- * Global allocation

    , GlobalAllocFlags
    , gMEM_INVALID_HANDLE
    , gMEM_FIXED
    , gMEM_MOVEABLE
    , gPTR
    , gHND
    , gMEM_DDESHARE
    , gMEM_SHARE
    , gMEM_LOWER
    , gMEM_NOCOMPACT
    , gMEM_NODISCARD
    , gMEM_NOT_BANKED
    , gMEM_NOTIFY
    , gMEM_ZEROINIT
    , globalAlloc
    , globalFlags
    , globalFree
    , globalHandle
    , globalLock
    , globalReAlloc
    , globalSize
    , globalUnlock

      -- * Heap allocation

    , HeapAllocFlags
    , hEAP_GENERATE_EXCEPTIONS
    , hEAP_NO_SERIALIZE
    , hEAP_ZERO_MEMORY
    , heapAlloc
    , heapCompact
    , heapCreate
    , heapDestroy
    , heapFree
    , heapLock
    , heapReAlloc
    , heapSize
    , heapUnlock
    , heapValidate

      -- * Virtual allocation

      -- ** Allocation

    , virtualAlloc
    , virtualAllocEx
    , VirtualAllocFlags
    , mEM_COMMIT
    , mEM_RESERVE
      -- ** Locking

    , virtualLock
    , virtualUnlock
      -- ** Protection

    , virtualProtect
    , virtualProtectEx
    , virtualQueryEx
    , ProtectFlags
    , pAGE_READONLY
    , pAGE_READWRITE
    , pAGE_EXECUTE
    , pAGE_EXECUTE_READ
    , pAGE_EXECUTE_READWRITE
    , pAGE_GUARD
    , pAGE_NOACCESS
    , pAGE_NOCACHE
      -- ** Freeing

    , virtualFree
    , virtualFreeEx
    , FreeFlags
    , mEM_DECOMMIT
    , mEM_RELEASE


    ) where

import System.Win32.Types

import Foreign
import Foreign.C.Types

#include "windows_cconv.h"




----------------------------------------------------------------

-- Data types

----------------------------------------------------------------


data MEMORY_BASIC_INFORMATION = MEMORY_BASIC_INFORMATION
    { mbiBaseAddress       :: Addr
    , mbiAllocationBase    :: Addr
    , mbiAllocationProtect :: DWORD
    , mbiRegionSize        :: SIZE_T
    , mbiState             :: DWORD
    , mbiProtect           :: DWORD
    , mbiType              :: DWORD
    } deriving (Show)

----------------------------------------------------------------

-- Instances

----------------------------------------------------------------


instance Storable MEMORY_BASIC_INFORMATION where
    sizeOf _ = (48)
{-# LINE 135 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
    alignment _ = 8
{-# LINE 136 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
    poke buf mbi = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0))       buf (mbiBaseAddress mbi)
{-# LINE 138 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 8))    buf (mbiAllocationBase mbi)
{-# LINE 139 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 16)) buf (mbiAllocationProtect mbi)
{-# LINE 140 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 24))        buf (mbiRegionSize mbi)
{-# LINE 141 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 32))             buf (mbiState mbi)
{-# LINE 142 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 36))           buf (mbiProtect mbi)
{-# LINE 143 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 40))              buf (mbiType mbi)
{-# LINE 144 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
    peek buf = do
        baseAddress       <- ((\hsc_ptr -> peekByteOff hsc_ptr 0))       buf
{-# LINE 146 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
        allocationBase    <- ((\hsc_ptr -> peekByteOff hsc_ptr 8))    buf
{-# LINE 147 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
        allocationProtect <- ((\hsc_ptr -> peekByteOff hsc_ptr 16)) buf
{-# LINE 148 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
        regionSize        <- ((\hsc_ptr -> peekByteOff hsc_ptr 24))        buf
{-# LINE 149 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
        state             <- ((\hsc_ptr -> peekByteOff hsc_ptr 32))             buf
{-# LINE 150 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
        protect           <- ((\hsc_ptr -> peekByteOff hsc_ptr 36))           buf
{-# LINE 151 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
        ty                <- ((\hsc_ptr -> peekByteOff hsc_ptr 40))              buf
{-# LINE 152 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
        return $ MEMORY_BASIC_INFORMATION baseAddress allocationBase allocationProtect regionSize state protect ty

----------------------------------------------------------------


copyMemory :: Ptr a -> Ptr a -> DWORD -> IO ()
copyMemory dest src nbytes = copyBytes dest src (fromIntegral nbytes)

moveMemory :: Ptr a -> Ptr a -> DWORD -> IO ()
moveMemory dest src nbytes = moveBytes dest src (fromIntegral nbytes)

fillMemory :: Ptr a -> DWORD -> BYTE -> IO ()
fillMemory dest nbytes val =
  memset dest (fromIntegral val) (fromIntegral nbytes)

zeroMemory :: Ptr a -> DWORD -> IO ()
zeroMemory dest nbytes = memset dest 0 (fromIntegral nbytes)

foreign import ccall unsafe "string.h" memset :: Ptr a -> CInt -> CSize -> IO ()

foreign import WINDOWS_CCONV unsafe "windows.h GetProcessHeap"
  getProcessHeap :: IO HANDLE


{-# LINE 175 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}
foreign import WINDOWS_CCONV unsafe "windows.h GetProcessHeaps"
  getProcessHeaps :: DWORD -> Addr -> IO DWORD

{-# LINE 178 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}

type   HGLOBAL   = Addr

type GlobalAllocFlags = UINT

gMEM_INVALID_HANDLE :: GlobalAllocFlags
gMEM_INVALID_HANDLE = 32768
{-# LINE 185 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}

gMEM_FIXED            :: GlobalAllocFlags
gMEM_FIXED            =  0
gMEM_MOVEABLE         :: GlobalAllocFlags
gMEM_MOVEABLE         =  2
gPTR                  :: GlobalAllocFlags
gPTR                  =  64
gHND                  :: GlobalAllocFlags
gHND                  =  66
gMEM_DDESHARE         :: GlobalAllocFlags
gMEM_DDESHARE         =  8192
gMEM_SHARE            :: GlobalAllocFlags
gMEM_SHARE            =  8192
gMEM_LOWER            :: GlobalAllocFlags
gMEM_LOWER            =  4096
gMEM_NOCOMPACT        :: GlobalAllocFlags
gMEM_NOCOMPACT        =  16
gMEM_NODISCARD        :: GlobalAllocFlags
gMEM_NODISCARD        =  32
gMEM_NOT_BANKED       :: GlobalAllocFlags
gMEM_NOT_BANKED       =  4096
gMEM_NOTIFY           :: GlobalAllocFlags
gMEM_NOTIFY           =  16384
gMEM_ZEROINIT         :: GlobalAllocFlags
gMEM_ZEROINIT         =  64

{-# LINE 200 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}

globalAlloc :: GlobalAllocFlags -> DWORD -> IO HGLOBAL
globalAlloc flags size =
  failIfNull "GlobalAlloc" $ c_GlobalAlloc flags size
foreign import WINDOWS_CCONV unsafe "windows.h GlobalAlloc"
  c_GlobalAlloc :: GlobalAllocFlags -> DWORD -> IO HGLOBAL

-- %fun GlobalDiscard :: HGLOBAL -> IO HGLOBAL

-- %fail {res1==NULL}{ErrorWin("GlobalDiscard")}


globalFlags :: HGLOBAL -> IO GlobalAllocFlags
globalFlags mem =
  failIf (== gMEM_INVALID_HANDLE) "GlobalFlags" $ c_GlobalFlags mem
foreign import WINDOWS_CCONV unsafe "windows.h GlobalFlags"
  c_GlobalFlags :: HGLOBAL -> IO GlobalAllocFlags

globalFree :: HGLOBAL -> IO HGLOBAL
globalFree mem =
  failIfNull "GlobalFree" $ c_GlobalFree mem
foreign import WINDOWS_CCONV unsafe "windows.h GlobalFree"
  c_GlobalFree :: HGLOBAL -> IO HGLOBAL

globalHandle :: Addr -> IO HGLOBAL
globalHandle addr =
  failIfNull "GlobalHandle" $ c_GlobalHandle addr
foreign import WINDOWS_CCONV unsafe "windows.h GlobalHandle"
  c_GlobalHandle :: Addr -> IO HGLOBAL

globalLock :: HGLOBAL -> IO Addr
globalLock mem =
  failIfNull "GlobalLock" $ c_GlobalLock mem
foreign import WINDOWS_CCONV unsafe "windows.h GlobalLock"
  c_GlobalLock :: HGLOBAL -> IO Addr

-- %fun GlobalMemoryStatus :: IO MEMORYSTATUS


globalReAlloc :: HGLOBAL -> DWORD -> GlobalAllocFlags -> IO HGLOBAL
globalReAlloc mem size flags =
  failIfNull "GlobalReAlloc" $ c_GlobalReAlloc mem size flags
foreign import WINDOWS_CCONV unsafe "windows.h GlobalReAlloc"
  c_GlobalReAlloc :: HGLOBAL -> DWORD -> GlobalAllocFlags -> IO HGLOBAL

globalSize :: HGLOBAL -> IO DWORD
globalSize mem =
  failIfZero "GlobalSize" $ c_GlobalSize mem
foreign import WINDOWS_CCONV unsafe "windows.h GlobalSize"
  c_GlobalSize :: HGLOBAL -> IO DWORD

globalUnlock :: HGLOBAL -> IO ()
globalUnlock mem =
  failIfFalse_ "GlobalUnlock" $ c_GlobalUnlock mem
foreign import WINDOWS_CCONV unsafe "windows.h GlobalUnlock"
  c_GlobalUnlock :: HGLOBAL -> IO Bool

type HeapAllocFlags = DWORD

hEAP_GENERATE_EXCEPTIONS      :: HeapAllocFlags
hEAP_GENERATE_EXCEPTIONS      =  4
hEAP_NO_SERIALIZE             :: HeapAllocFlags
hEAP_NO_SERIALIZE             =  1
hEAP_ZERO_MEMORY              :: HeapAllocFlags
hEAP_ZERO_MEMORY              =  8

{-# LINE 261 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}

heapAlloc :: HANDLE -> HeapAllocFlags -> DWORD -> IO Addr
heapAlloc heap flags size =
  failIfNull "HeapAlloc" $ c_HeapAlloc heap flags size
foreign import WINDOWS_CCONV unsafe "windows.h HeapAlloc"
  c_HeapAlloc :: HANDLE -> HeapAllocFlags -> DWORD -> IO Addr

heapCompact :: HANDLE -> HeapAllocFlags -> IO UINT
heapCompact heap flags =
  failIfZero "HeapCompact" $ c_HeapCompact heap flags
foreign import WINDOWS_CCONV unsafe "windows.h HeapCompact"
  c_HeapCompact :: HANDLE -> HeapAllocFlags -> IO UINT

heapCreate :: HeapAllocFlags -> DWORD -> DWORD -> IO HANDLE
heapCreate flags initSize maxSize =
  failIfNull "HeapCreate" $ c_HeapCreate flags initSize maxSize
foreign import WINDOWS_CCONV unsafe "windows.h HeapCreate"
  c_HeapCreate :: HeapAllocFlags -> DWORD -> DWORD -> IO HANDLE

heapDestroy :: HANDLE -> IO ()
heapDestroy heap =
  failIfFalse_ "HeapDestroy" $ c_HeapDestroy heap
foreign import WINDOWS_CCONV unsafe "windows.h HeapDestroy"
  c_HeapDestroy :: HANDLE -> IO Bool

heapFree :: HANDLE -> HeapAllocFlags -> Addr -> IO ()
heapFree heap flags addr =
  failIfFalse_ "HeapFree" $ c_HeapFree heap flags addr
foreign import WINDOWS_CCONV unsafe "windows.h HeapFree"
  c_HeapFree :: HANDLE -> HeapAllocFlags -> Addr -> IO Bool

heapLock :: HANDLE -> IO ()
heapLock heap =
  failIfFalse_ "HeapLock" $ c_HeapLock heap
foreign import WINDOWS_CCONV unsafe "windows.h HeapLock"
  c_HeapLock :: HANDLE -> IO Bool

heapReAlloc :: HANDLE -> HeapAllocFlags -> Addr -> DWORD -> IO Addr
heapReAlloc heap flags addr size =
  failIfNull "HeapReAlloc" $ c_HeapReAlloc heap flags addr size
foreign import WINDOWS_CCONV unsafe "windows.h HeapReAlloc"
  c_HeapReAlloc :: HANDLE -> HeapAllocFlags -> Addr -> DWORD -> IO Addr

heapSize :: HANDLE -> HeapAllocFlags -> Addr -> IO DWORD
heapSize heap flags addr =
  failIfZero "HeapSize" $ c_HeapSize heap flags addr
foreign import WINDOWS_CCONV unsafe "windows.h HeapSize"
  c_HeapSize :: HANDLE -> HeapAllocFlags -> Addr -> IO DWORD

heapUnlock :: HANDLE -> IO ()
heapUnlock heap =
  failIfFalse_ "HeapUnlock" $ c_HeapUnlock heap
foreign import WINDOWS_CCONV unsafe "windows.h HeapUnlock"
  c_HeapUnlock :: HANDLE -> IO Bool

foreign import WINDOWS_CCONV unsafe "windows.h HeapValidate"
  heapValidate :: HANDLE -> HeapAllocFlags -> Addr -> IO Bool

type VirtualAllocFlags = DWORD

mEM_COMMIT    :: VirtualAllocFlags
mEM_COMMIT    =  4096
mEM_RESERVE   :: VirtualAllocFlags
mEM_RESERVE   =  8192

{-# LINE 325 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}

-- % , MEM_TOP_DOWN (not in mingw-20001111 winnt.h)


type ProtectFlags = DWORD

pAGE_READONLY         :: ProtectFlags
pAGE_READONLY         =  2
pAGE_READWRITE        :: ProtectFlags
pAGE_READWRITE        =  4
pAGE_EXECUTE          :: ProtectFlags
pAGE_EXECUTE          =  16
pAGE_EXECUTE_READ     :: ProtectFlags
pAGE_EXECUTE_READ     =  32
pAGE_EXECUTE_READWRITE  :: ProtectFlags
pAGE_EXECUTE_READWRITE  =  64
pAGE_GUARD            :: ProtectFlags
pAGE_GUARD            =  256
pAGE_NOACCESS         :: ProtectFlags
pAGE_NOACCESS         =  1
pAGE_NOCACHE          :: ProtectFlags
pAGE_NOCACHE          =  512

{-# LINE 340 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}

type FreeFlags = DWORD

mEM_DECOMMIT  :: FreeFlags
mEM_DECOMMIT  =  16384
mEM_RELEASE   :: FreeFlags
mEM_RELEASE   =  32768

{-# LINE 347 "libraries\\Win32\\System\\Win32\\Mem.hsc" #-}

virtualAlloc :: Addr -> DWORD -> VirtualAllocFlags -> ProtectFlags -> IO Addr
virtualAlloc addt size ty flags =
  failIfNull "VirtualAlloc" $ c_VirtualAlloc addt size ty flags
foreign import WINDOWS_CCONV unsafe "windows.h VirtualAlloc"
  c_VirtualAlloc :: Addr -> DWORD -> DWORD -> DWORD -> IO Addr

virtualAllocEx :: HANDLE -> Addr -> DWORD -> VirtualAllocFlags -> ProtectFlags -> IO Addr
virtualAllocEx proc addt size ty flags =
  failIfNull "VirtualAllocEx" $ c_VirtualAllocEx proc addt size ty flags
foreign import WINDOWS_CCONV unsafe "windows.h VirtualAllocEx"
  c_VirtualAllocEx :: HANDLE -> Addr -> DWORD -> DWORD -> DWORD -> IO Addr

virtualFree :: Addr -> DWORD -> FreeFlags -> IO ()
virtualFree addr size flags =
  failIfFalse_ "VirtualFree" $ c_VirtualFree addr size flags
foreign import WINDOWS_CCONV unsafe "windows.h VirtualFree"
  c_VirtualFree :: Addr -> DWORD -> FreeFlags -> IO Bool

virtualFreeEx :: HANDLE -> Addr -> DWORD -> FreeFlags -> IO ()
virtualFreeEx proc addr size flags =
  failIfFalse_ "VirtualFreeEx" $ c_VirtualFreeEx proc addr size flags
foreign import WINDOWS_CCONV unsafe "windows.h VirtualFreeEx"
  c_VirtualFreeEx :: HANDLE -> Addr -> DWORD -> FreeFlags -> IO Bool

virtualLock :: Addr -> DWORD -> IO ()
virtualLock addr size =
  failIfFalse_ "VirtualLock" $ c_VirtualLock addr size
foreign import WINDOWS_CCONV unsafe "windows.h VirtualLock"
  c_VirtualLock :: Addr -> DWORD -> IO Bool

virtualProtect :: Addr -> DWORD -> ProtectFlags -> IO ProtectFlags
virtualProtect addr size new_prot =
  alloca $ \ p_old -> do
  failIfFalse_ "VirtualProtect" $ c_VirtualProtect addr size new_prot p_old
  peek p_old
foreign import WINDOWS_CCONV unsafe "windows.h VirtualProtect"
  c_VirtualProtect :: Addr -> DWORD -> DWORD -> Ptr DWORD -> IO Bool

virtualProtectEx :: HANDLE -> Addr -> DWORD -> ProtectFlags -> IO ProtectFlags
virtualProtectEx proc addr size new_prot =
  alloca $ \ p_old -> do
  failIfFalse_ "VirtualProtectEx" $
    c_VirtualProtectEx proc addr size new_prot p_old
  peek p_old
foreign import WINDOWS_CCONV unsafe "windows.h VirtualProtectEx"
  c_VirtualProtectEx :: HANDLE -> Addr -> DWORD -> DWORD -> Ptr DWORD -> IO Bool

virtualQueryEx :: HANDLE -> LPVOID -> Ptr MEMORY_BASIC_INFORMATION -> SIZE_T -> IO DWORD
virtualQueryEx hProcess lpAddress lpBuffer dwLength =
  failIfZero "VirtualQueryEx" $ c_VirtualQueryEx hProcess lpAddress lpBuffer dwLength
foreign import WINDOWS_CCONV unsafe "windows.h VirtualQueryEx"
  c_VirtualQueryEx :: HANDLE -> LPVOID -> Ptr MEMORY_BASIC_INFORMATION -> SIZE_T -> IO DWORD

virtualUnlock :: Addr -> DWORD -> IO ()
virtualUnlock addr size =
  failIfFalse_ "VirtualUnlock" $ c_VirtualUnlock addr size
foreign import WINDOWS_CCONV unsafe "windows.h VirtualUnlock"
  c_VirtualUnlock :: Addr -> DWORD -> IO Bool