-- Automatically generated by HaskellDirect (ihc.exe), snapshot 171208
-- Created: 23:37 Pacific Standard Time, Wednesday 17 December, 2008
-- Command line: -fno-qualified-names -fno-imports -fno-export-lists -fhs-to-c -fno-overload-variant -fout-pointers-are-not-refs -fsubtyped-interface-pointers -c System/Win32/Com/Automation/Base.idl -o System/Win32/Com/Automation/Base.hs

module System.Win32.Com.Automation.Base where



import System.Win32.Com (checkHR, marshallIUnknown, IUnknown, mkIID, IID, LCID)
import System.Win32.Com.HDirect.HDirect (Ptr, allocBytes, marshallBool, readref, readStablePtr,
                marshallPtr, readPtr, unmarshallref, trivialFree, doThenFree, free,
                sizeofInt32, readInt32, unmarshallString, freeString, sizeofInt16, 
                readInt16, sizeofDouble, readDouble, sizeofFloat, readFloat, Octet,
    readBool, sizeofChar, readChar, unmarshallBool,
    freeref, sizeofWord8, readWord8, sizeofWord32, readWord32,
    StablePtr, sizeofPtr, readPtr, writePtr, sizeofForeignPtr )
import System.Win32.Com.Automation.SafeArray ( SAFEARRAY, marshallSAFEARRAY, unmarshallSAFEARRAY, readSAFEARRAY, sizeofSAFEARRAY )
import System.Win32.Com.HDirect.Pointer ( allocMemory )
import System.IO.Unsafe (unsafePerformIO)
import Data.Int  (Int32, Int16)
import Data.Word (Word8, Word32)
import Foreign.ForeignPtr ( ForeignPtr, withForeignPtr )
import Foreign.Ptr ( castPtr ) 

data VARIANT_ = VARIANT_
type VARIANT = Ptr VARIANT_
sizeofBSTR = sizeofPtr

iidIDispatch :: IID (IDispatch ())
iidIDispatch  = mkIID "{00020400-0000-0000-C000-000000000046}"

sizeofVARIANT    :: Word32
sizeofVARIANT         = 16

marshallVARIANT   :: VARIANT -> IO VARIANT
marshallVARIANT m = return m

unmarshallVARIANT :: Ptr a -> IO VARIANT
unmarshallVARIANT v = return (castPtr v)

readVARIANT       :: Ptr VARIANT -> IO VARIANT
readVARIANT ptr = 
  readPtr ptr
--  unmarshallVARIANT ptr

writeVARIANT      :: Ptr VARIANT -> VARIANT -> IO ()
writeVARIANT ptr v = writePtr ptr v

copyVARIANT      :: VARIANT -> VARIANT -> IO ()
copyVARIANT ptr v = do
  primCopyVARIANT (castPtr ptr) (castPtr v)
  -- ToDo: if the passed in variant has a finaliser
  -- attached to it, this is the time to disable those.
  -- It doesn't at the moment, though.

allocVARIANT :: IO VARIANT
allocVARIANT = do
  x <- allocMemory (fromIntegral sizeofVARIANT)
  variantInit x
  return x

foreign import ccall "writeVarInt" writeVarStablePtr
     :: StablePtr a -> Ptr (StablePtr a) -> IO ()

foreign import ccall "readVarInt" prim_readVarStablePtr 
     :: Ptr (StablePtr a) -> Ptr b -> IO Int32

readVarStablePtr :: VARIANT -> IO (StablePtr a)
readVarStablePtr p = do
    i <- allocBytes (fromIntegral sizeofInt32)
    o_readVarInt <- prim_readVarStablePtr (castPtr p) i
    checkHR o_readVarInt
    doThenFree (freeref trivialFree) (unmarshallref readStablePtr) i


type DISPID = Int32
type PEXCEPINFO = Ptr ()
-- --------------------------------------------------
-- 
-- interface IDispatch
-- 
-- --------------------------------------------------
data IDispatch_ a = IDispatch__
                      
type IDispatch a = IUnknown (IDispatch_ a)
dispatchInvoke :: IDispatch a0
               -> DISPID
               -> LCID
               -> Bool
               -> Word32
               -> Word32
               -> Word32
               -> VARIANT
               -> VARIANT
               -> IO (PEXCEPINFO, Int32)
dispatchInvoke obj dispid lcid isfunction flags cargs cargsout args argsout =
  do
    info <- allocBytes (fromIntegral sizeofPtr)
    obj <- marshallIUnknown obj
    isfunction <- marshallBool isfunction
    o_dispatchInvoke <- withForeignPtr obj (\ obj -> prim_System_Win32_Com_Automation_Base_dispatchInvoke obj dispid lcid isfunction flags cargs cargsout args argsout info)
    info <- doThenFree free readPtr info
    return (info, o_dispatchInvoke)

foreign import ccall "dispatchInvoke" prim_System_Win32_Com_Automation_Base_dispatchInvoke :: Ptr (IDispatch a) -> Int32 -> Word32 -> Int32 -> Word32 -> Word32 -> Word32 -> VARIANT -> VARIANT -> Ptr (Ptr ()) -> IO Int32
dispatchGetMemberID :: IDispatch a0
                    -> Ptr String
                    -> LCID
                    -> IO (DISPID, Int32)
dispatchGetMemberID obj name lcid =
  do
    dispid <- allocBytes (fromIntegral sizeofInt32)
    obj <- marshallIUnknown obj
    o_dispatchGetMemberID <- withForeignPtr obj (\ obj -> prim_System_Win32_Com_Automation_Base_dispatchGetMemberID obj name lcid dispid)
    dispid <- doThenFree free readInt32 dispid
    return (dispid, o_dispatchGetMemberID)

foreign import ccall "dispatchGetMemberID" prim_System_Win32_Com_Automation_Base_dispatchGetMemberID :: Ptr (IDispatch a) -> Ptr String -> Word32 -> Ptr Int32 -> IO Int32
freeExcepInfo :: PEXCEPINFO
              -> IO ()
freeExcepInfo einfo =
  prim_System_Win32_Com_Automation_Base_freeExcepInfo einfo

foreign import ccall "freeExcepInfo" prim_System_Win32_Com_Automation_Base_freeExcepInfo :: Ptr () -> IO ()
getExcepInfoMessage :: PEXCEPINFO
                    -> IO (Ptr Char)
getExcepInfoMessage info =
  prim_System_Win32_Com_Automation_Base_getExcepInfoMessage info

foreign import ccall "getExcepInfoMessage" prim_System_Win32_Com_Automation_Base_getExcepInfoMessage :: Ptr () -> IO (Ptr Char)
freeVariants :: Word32
             -> VARIANT
             -> IO ()
freeVariants count p =
  prim_System_Win32_Com_Automation_Base_freeVariants count
                                                     p

foreign import ccall "freeVariants" prim_System_Win32_Com_Automation_Base_freeVariants :: Word32 -> VARIANT -> IO ()
readVariantTag :: VARIANT
               -> IO Int32
readVariantTag p =
  prim_System_Win32_Com_Automation_Base_readVariantTag p

foreign import ccall "readVariantTag" prim_System_Win32_Com_Automation_Base_readVariantTag :: VARIANT -> IO Int32
variantInit :: VARIANT
            -> IO ()
variantInit p =
  prim_System_Win32_Com_Automation_Base_variantInit p

foreign import stdcall "VariantInit" prim_System_Win32_Com_Automation_Base_variantInit :: VARIANT -> IO ()
writeVarShort :: Int16
              -> VARIANT
              -> IO ()
writeVarShort i p =
  prim_System_Win32_Com_Automation_Base_writeVarShort i
                                                      p

foreign import ccall "writeVarShort" prim_System_Win32_Com_Automation_Base_writeVarShort :: Int16 -> VARIANT -> IO ()
readVarShort :: VARIANT
             -> IO Int16
readVarShort p =
  do
    i <- allocBytes (fromIntegral sizeofInt16)
    o_readVarShort <- prim_System_Win32_Com_Automation_Base_readVarShort p i
    checkHR o_readVarShort
    doThenFree free readInt16 i

foreign import ccall "readVarShort" prim_System_Win32_Com_Automation_Base_readVarShort :: VARIANT -> Ptr Int16 -> IO Int32
writeVarInt :: Int32
            -> VARIANT
            -> IO ()
writeVarInt i p =
  prim_System_Win32_Com_Automation_Base_writeVarInt i
                                                    p

foreign import ccall "writeVarInt" prim_System_Win32_Com_Automation_Base_writeVarInt :: Int32 -> VARIANT -> IO ()
readVarInt :: VARIANT
           -> IO Int32
readVarInt p =
  do
    i <- allocBytes (fromIntegral sizeofInt32)
    o_readVarInt <- prim_System_Win32_Com_Automation_Base_readVarInt p i
    checkHR o_readVarInt
    doThenFree free readInt32 i

foreign import ccall "readVarInt" prim_System_Win32_Com_Automation_Base_readVarInt :: VARIANT -> Ptr Int32 -> IO Int32
writeVarWord :: Word32
             -> VARIANT
             -> IO ()
writeVarWord i p =
  prim_System_Win32_Com_Automation_Base_writeVarWord i
                                                     p

foreign import ccall "writeVarWord" prim_System_Win32_Com_Automation_Base_writeVarWord :: Word32 -> VARIANT -> IO ()
readVarWord :: VARIANT
            -> IO Word32
readVarWord p =
  do
    i <- allocBytes (fromIntegral sizeofWord32)
    o_readVarWord <- prim_System_Win32_Com_Automation_Base_readVarWord p i
    checkHR o_readVarWord
    doThenFree free readWord32 i

foreign import ccall "readVarWord" prim_System_Win32_Com_Automation_Base_readVarWord :: VARIANT -> Ptr Word32 -> IO Int32
writeVarFloat :: Float
              -> VARIANT
              -> IO ()
writeVarFloat i p =
  prim_System_Win32_Com_Automation_Base_writeVarFloat i
                                                      p

foreign import ccall "writeVarFloat" prim_System_Win32_Com_Automation_Base_writeVarFloat :: Float -> VARIANT -> IO ()
readVarFloat :: VARIANT
             -> IO Float
readVarFloat p =
  do
    i <- allocBytes (fromIntegral sizeofFloat)
    o_readVarFloat <- prim_System_Win32_Com_Automation_Base_readVarFloat p i
    checkHR o_readVarFloat
    doThenFree free readFloat i

foreign import ccall "readVarFloat" prim_System_Win32_Com_Automation_Base_readVarFloat :: VARIANT -> Ptr Float -> IO Int32
writeVarDouble :: Double
               -> VARIANT
               -> IO ()
writeVarDouble i p =
  prim_System_Win32_Com_Automation_Base_writeVarDouble i
                                                       p

foreign import ccall "writeVarDouble" prim_System_Win32_Com_Automation_Base_writeVarDouble :: Double -> VARIANT -> IO ()
readVarDouble :: VARIANT
              -> IO Double
readVarDouble p =
  do
    i <- allocBytes (fromIntegral sizeofDouble)
    o_readVarDouble <- prim_System_Win32_Com_Automation_Base_readVarDouble p i
    checkHR o_readVarDouble
    doThenFree free readDouble i

foreign import ccall "readVarDouble" prim_System_Win32_Com_Automation_Base_readVarDouble :: VARIANT -> Ptr Double -> IO Int32
writeVarString :: Ptr Char
               -> VARIANT
               -> IO ()
writeVarString str p =
  prim_System_Win32_Com_Automation_Base_writeVarString str
                                                       p

foreign import ccall "writeVarString" prim_System_Win32_Com_Automation_Base_writeVarString :: Ptr Char -> VARIANT -> IO ()
readVarString :: VARIANT
              -> IO (Ptr (Ptr Char), Ptr VARIANT)
readVarString p =
  do
    pstr <- allocBytes (fromIntegral sizeofPtr)
    w <- allocBytes (fromIntegral sizeofVARIANT)
    o_readVarString <- prim_System_Win32_Com_Automation_Base_readVarString p pstr w
    checkHR o_readVarString
    return (pstr, w)

foreign import ccall "readVarString" prim_System_Win32_Com_Automation_Base_readVarString :: VARIANT -> Ptr (Ptr Char) -> Ptr VARIANT -> IO Int32
writeVarDispatch :: IDispatch a0
                 -> VARIANT
                 -> IO ()
writeVarDispatch ip p =
  do
    ip <- marshallIUnknown ip
    withForeignPtr ip (\ ip -> prim_System_Win32_Com_Automation_Base_writeVarDispatch ip p)

foreign import ccall "writeVarDispatch" prim_System_Win32_Com_Automation_Base_writeVarDispatch :: Ptr (IDispatch a) -> VARIANT -> IO ()
readVarDispatch :: VARIANT
                -> IO (Ptr (Ptr ()), Ptr VARIANT)
readVarDispatch p =
  do
    ip <- allocBytes (fromIntegral sizeofPtr)
    w <- allocBytes (fromIntegral sizeofVARIANT)
    o_readVarDispatch <- prim_System_Win32_Com_Automation_Base_readVarDispatch p ip w
    checkHR o_readVarDispatch
    return (ip, w)

foreign import ccall "readVarDispatch" prim_System_Win32_Com_Automation_Base_readVarDispatch :: VARIANT -> Ptr (Ptr ()) -> Ptr VARIANT -> IO Int32
writeVarOptional :: VARIANT
                 -> IO ()
writeVarOptional p =
  prim_System_Win32_Com_Automation_Base_writeVarOptional p

foreign import ccall "writeVarOptional" prim_System_Win32_Com_Automation_Base_writeVarOptional :: VARIANT -> IO ()
writeVarError :: Int32
              -> VARIANT
              -> IO ()
writeVarError err p =
  prim_System_Win32_Com_Automation_Base_writeVarError err
                                                      p

foreign import ccall "writeVarError" prim_System_Win32_Com_Automation_Base_writeVarError :: Int32 -> VARIANT -> IO ()
readVarError :: VARIANT
             -> IO Int32
readVarError p =
  do
    perr <- allocBytes (fromIntegral sizeofInt32)
    o_readVarError <- prim_System_Win32_Com_Automation_Base_readVarError p perr
    checkHR o_readVarError
    doThenFree free readInt32 perr

foreign import ccall "readVarError" prim_System_Win32_Com_Automation_Base_readVarError :: VARIANT -> Ptr Int32 -> IO Int32
writeVarBool :: Bool
             -> VARIANT
             -> IO ()
writeVarBool b p =
  do
    b <- marshallBool b
    prim_System_Win32_Com_Automation_Base_writeVarBool b p

foreign import ccall "writeVarBool" prim_System_Win32_Com_Automation_Base_writeVarBool :: Int32 -> VARIANT -> IO ()
readVarBool :: VARIANT
            -> IO Bool
readVarBool p =
  do
    pb <- allocBytes (fromIntegral sizeofInt32)
    o_readVarBool <- prim_System_Win32_Com_Automation_Base_readVarBool p pb
    checkHR o_readVarBool
    doThenFree free readBool pb

foreign import ccall "readVarBool" prim_System_Win32_Com_Automation_Base_readVarBool :: VARIANT -> Ptr Int32 -> IO Int32
writeVarUnknown :: IUnknown a0
                -> VARIANT
                -> IO ()
writeVarUnknown ip p =
  do
    ip <- marshallIUnknown ip
    withForeignPtr ip (\ ip -> prim_System_Win32_Com_Automation_Base_writeVarUnknown ip p)

foreign import ccall "writeVarUnknown" prim_System_Win32_Com_Automation_Base_writeVarUnknown :: Ptr (IUnknown a) -> VARIANT -> IO ()
readVarUnknown :: VARIANT
               -> IO (Ptr (Ptr ()), Ptr VARIANT)
readVarUnknown p =
  do
    ip <- allocBytes (fromIntegral sizeofPtr)
    w <- allocBytes (fromIntegral sizeofVARIANT)
    o_readVarUnknown <- prim_System_Win32_Com_Automation_Base_readVarUnknown p ip w
    checkHR o_readVarUnknown
    return (ip, w)

foreign import ccall "readVarUnknown" prim_System_Win32_Com_Automation_Base_readVarUnknown :: VARIANT -> Ptr (Ptr ()) -> Ptr VARIANT -> IO Int32
writeVarByte :: Octet
             -> VARIANT
             -> IO ()
writeVarByte b p =
  prim_System_Win32_Com_Automation_Base_writeVarByte b
                                                     p

foreign import ccall "writeVarByte" prim_System_Win32_Com_Automation_Base_writeVarByte :: Word8 -> VARIANT -> IO ()
readVarByte :: VARIANT
            -> IO Octet
readVarByte p =
  do
    pb <- allocBytes (fromIntegral sizeofWord8)
    o_readVarByte <- prim_System_Win32_Com_Automation_Base_readVarByte p pb
    checkHR o_readVarByte
    doThenFree free readWord8 pb

foreign import ccall "readVarByte" prim_System_Win32_Com_Automation_Base_readVarByte :: VARIANT -> Ptr Word8 -> IO Int32
writeVarEmpty :: VARIANT
              -> IO ()
writeVarEmpty p =
  prim_System_Win32_Com_Automation_Base_writeVarEmpty p

foreign import ccall "writeVarEmpty" prim_System_Win32_Com_Automation_Base_writeVarEmpty :: VARIANT -> IO ()
writeVarNull :: VARIANT
             -> IO ()
writeVarNull p =
  prim_System_Win32_Com_Automation_Base_writeVarNull p

foreign import ccall "writeVarNull" prim_System_Win32_Com_Automation_Base_writeVarNull :: VARIANT -> IO ()
readVarNull :: VARIANT
            -> IO ()
readVarNull p =
  do
    o_readVarNull <- prim_System_Win32_Com_Automation_Base_readVarNull p
    checkHR o_readVarNull

foreign import ccall "readVarNull" prim_System_Win32_Com_Automation_Base_readVarNull :: VARIANT -> IO Int32
writeVarCurrency :: Int32
                 -> Word32
                 -> VARIANT
                 -> IO ()
writeVarCurrency hi lo p =
  prim_System_Win32_Com_Automation_Base_writeVarCurrency hi
                                                         lo
                                                         p

foreign import ccall "writeVarCurrency" prim_System_Win32_Com_Automation_Base_writeVarCurrency :: Int32 -> Word32 -> VARIANT -> IO ()
readVarCurrency :: VARIANT
                -> IO (Int32, Word32)
readVarCurrency p =
  do
    hi <- allocBytes (fromIntegral sizeofInt32)
    lo <- allocBytes (fromIntegral sizeofWord32)
    o_readVarCurrency <- prim_System_Win32_Com_Automation_Base_readVarCurrency p hi lo
    checkHR o_readVarCurrency
    hi <- doThenFree free readInt32 hi
    lo <- doThenFree free readWord32 lo
    return (hi, lo)

foreign import ccall "readVarCurrency" prim_System_Win32_Com_Automation_Base_readVarCurrency :: VARIANT -> Ptr Int32 -> Ptr Word32 -> IO Int32
writeVarWord64 :: Word32
               -> Word32
               -> VARIANT
               -> IO ()
writeVarWord64 hi lo p =
  prim_System_Win32_Com_Automation_Base_writeVarWord64 hi
                                                       lo
                                                       p

foreign import ccall "writeVarWord64" prim_System_Win32_Com_Automation_Base_writeVarWord64 :: Word32 -> Word32 -> VARIANT -> IO ()
readVarWord64 :: VARIANT
              -> IO (Word32, Word32)
readVarWord64 p =
  do
    hi <- allocBytes (fromIntegral sizeofWord32)
    lo <- allocBytes (fromIntegral sizeofWord32)
    o_readVarWord64 <- prim_System_Win32_Com_Automation_Base_readVarWord64 p hi lo
    checkHR o_readVarWord64
    hi <- doThenFree free readWord32 hi
    lo <- doThenFree free readWord32 lo
    return (hi, lo)

foreign import ccall "readVarWord64" prim_System_Win32_Com_Automation_Base_readVarWord64 :: VARIANT -> Ptr Word32 -> Ptr Word32 -> IO Int32
writeVarVariant :: VARIANT
                -> VARIANT
                -> IO ()
writeVarVariant p1 p2 =
  prim_System_Win32_Com_Automation_Base_writeVarVariant p1
                                                        p2

foreign import ccall "writeVarVariant" prim_System_Win32_Com_Automation_Base_writeVarVariant :: VARIANT -> VARIANT -> IO ()
readVarVariant :: VARIANT
               -> IO (Ptr VARIANT)
readVarVariant p1 =
  do
    p2 <- allocBytes (fromIntegral sizeofVARIANT)
    o_readVarVariant <- prim_System_Win32_Com_Automation_Base_readVarVariant p1 p2
    checkHR o_readVarVariant
    return (p2)

foreign import ccall "readVarVariant" prim_System_Win32_Com_Automation_Base_readVarVariant :: VARIANT -> Ptr VARIANT -> IO Int32
writeVarSAFEARRAY :: VARIANT
                  -> SAFEARRAY
                  -> Int32
                  -> IO ()
writeVarSAFEARRAY p1 p2 vt =
  do
    p2 <- marshallSAFEARRAY p2
    withForeignPtr p2 (\ p2 -> prim_System_Win32_Com_Automation_Base_writeVarSAFEARRAY p1 p2 vt)

foreign import ccall "writeVarSAFEARRAY" prim_System_Win32_Com_Automation_Base_writeVarSAFEARRAY :: VARIANT -> Ptr SAFEARRAY -> Int32 -> IO ()
readVarSAFEARRAY :: VARIANT
                 -> Int32
                 -> IO (Ptr ())
readVarSAFEARRAY p1 vt =
  do
    p2 <- allocBytes (fromIntegral sizeofPtr)
    o_readVarSAFEARRAY <- prim_System_Win32_Com_Automation_Base_readVarSAFEARRAY p1 p2 vt
    checkHR o_readVarSAFEARRAY
    return (p2)

foreign import ccall "readVarSAFEARRAY" prim_System_Win32_Com_Automation_Base_readVarSAFEARRAY :: VARIANT -> Ptr () -> Int32 -> IO Int32
primCopyVARIANT :: VARIANT
                -> VARIANT
                -> IO ()
primCopyVARIANT p1 p2 =
  do
    o_primCopyVARIANT <- prim_System_Win32_Com_Automation_Base_primCopyVARIANT p1 p2
    checkHR o_primCopyVARIANT

foreign import ccall "primCopyVARIANT" prim_System_Win32_Com_Automation_Base_primCopyVARIANT :: VARIANT -> VARIANT -> IO Int32
primVARIANTClear :: VARIANT
                 -> IO ()
primVARIANTClear p1 =
  do
    o_primVARIANTClear <- prim_System_Win32_Com_Automation_Base_primVARIANTClear p1
    checkHR o_primVARIANTClear

foreign import ccall "primVARIANTClear" prim_System_Win32_Com_Automation_Base_primVARIANTClear :: VARIANT -> IO Int32
primClockToDate :: Int32
                -> IO Double
primClockToDate ct =
  do
    pT <- allocBytes (fromIntegral sizeofDouble)
    o_primClockToDate <- prim_System_Win32_Com_Automation_Base_primClockToDate ct pT
    checkHR o_primClockToDate
    doThenFree free readDouble pT

foreign import ccall "primClockToDate" prim_System_Win32_Com_Automation_Base_primClockToDate :: Int32 -> Ptr Double -> IO Int32