{-# LINE 1 "src/Clingo/Raw/Types.hsc" #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LINE 2 "src/Clingo/Raw/Types.hsc" #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module Clingo.Raw.Types
(
CBool,
Literal,
Atom,
Identifier,
Weight,
Logger,
mkCallbackLogger,
Location (..),
Signature,
Symbol,
SymbolicLiteral (..),
Model (..),
SolveHandle(..),
SolveControl (..),
SymbolicAtoms (..),
SymbolicAtomIterator,
TheoryAtoms (..),
PropagateInit (..),
Assignment (..),
PropagateControl (..),
CallbackPropagatorInit,
mkCallbackPropagatorInit,
CallbackPropagatorPropagate,
mkCallbackPropagatorPropagate,
CallbackPropagatorUndo,
mkCallbackPropagatorUndo,
CallbackPropagatorCheck,
mkCallbackPropagatorCheck,
Propagator (..),
WeightedLiteral (..),
Backend (..),
ProgramBuilder (..),
Configuration (..),
Statistics (..),
GroundProgramObserver (..),
mkGpoInitProgram,
mkGpoBeginStep,
mkGpoEndStep,
mkGpoRule,
mkGpoWeightRule,
mkGpoMinimize,
mkGpoProject,
mkGpoExternal,
mkGpoAssume,
mkGpoHeuristic,
mkGpoAcycEdge,
mkGpoTheoryTermNum,
mkGpoTheoryTermStr,
mkGpoTheoryTermCmp,
mkGpoTheoryElement,
mkGpoTheoryAtom,
mkGpoTheoryAtomGrd,
Control (..),
Part (..),
CallbackSymbol,
mkCallbackSymbol,
getCallbackSymbol,
CallbackGround,
mkCallbackGround,
CallbackEvent,
mkCallbackEvent,
CallbackFinish,
mkCallbackFinish
)
where
import Data.Int
import Data.Word
import Foreign
import Foreign.C
import Clingo.Raw.Enums
{-# LINE 97 "src/Clingo/Raw/Types.hsc" #-}
type CBool = Word8
{-# LINE 99 "src/Clingo/Raw/Types.hsc" #-}
type Literal = Int32
{-# LINE 101 "src/Clingo/Raw/Types.hsc" #-}
type Atom = Word32
{-# LINE 102 "src/Clingo/Raw/Types.hsc" #-}
type Identifier = Word32
{-# LINE 103 "src/Clingo/Raw/Types.hsc" #-}
type Weight = Int32
{-# LINE 104 "src/Clingo/Raw/Types.hsc" #-}
type Logger a = ClingoWarning -> Ptr CChar -> Ptr a -> IO ()
foreign import ccall "wrapper" mkCallbackLogger ::
Logger a -> IO (FunPtr (Logger a))
data Location = Location
{ locBeginFile :: CString
, locEndFile :: CString
, locBeginLine :: Word64
{-# LINE 114 "src/Clingo/Raw/Types.hsc" #-}
, locEndLine :: Word64
{-# LINE 115 "src/Clingo/Raw/Types.hsc" #-}
, locBeginCol :: Word64
{-# LINE 116 "src/Clingo/Raw/Types.hsc" #-}
, locEndCol :: Word64}
{-# LINE 117 "src/Clingo/Raw/Types.hsc" #-}
deriving (Eq, Show)
instance Storable Location where
sizeOf _ = (48)
{-# LINE 121 "src/Clingo/Raw/Types.hsc" #-}
alignment = sizeOf
peek p = Location
<$> ((\hsc_ptr -> peekByteOff hsc_ptr 0) p)
{-# LINE 125 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 8) p)
{-# LINE 126 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 16) p)
{-# LINE 127 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 24) p)
{-# LINE 128 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 32) p)
{-# LINE 129 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 40) p)
{-# LINE 130 "src/Clingo/Raw/Types.hsc" #-}
poke p l = do
((\hsc_ptr -> pokeByteOff hsc_ptr 0)) p (locBeginFile l)
{-# LINE 133 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 8)) p (locEndFile l)
{-# LINE 134 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 16)) p (locBeginLine l)
{-# LINE 135 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 24)) p (locEndLine l)
{-# LINE 136 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 32)) p (locBeginCol l)
{-# LINE 137 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 40)) p (locEndCol l)
{-# LINE 138 "src/Clingo/Raw/Types.hsc" #-}
type Signature = Word64
{-# LINE 140 "src/Clingo/Raw/Types.hsc" #-}
type Symbol = Word64
{-# LINE 141 "src/Clingo/Raw/Types.hsc" #-}
data SymbolicLiteral = SymbolicLiteral
{ slitSymbol :: Symbol
, slitPositive :: CBool }
instance Storable SymbolicLiteral where
sizeOf _ = (16)
{-# LINE 148 "src/Clingo/Raw/Types.hsc" #-}
alignment = sizeOf
peek p = SymbolicLiteral
<$> ((\hsc_ptr -> peekByteOff hsc_ptr 0) p)
{-# LINE 151 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 8) p)
{-# LINE 152 "src/Clingo/Raw/Types.hsc" #-}
poke p lit = do
((\hsc_ptr -> pokeByteOff hsc_ptr 0)) p (slitSymbol lit)
{-# LINE 155 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 8)) p (slitPositive lit)
{-# LINE 156 "src/Clingo/Raw/Types.hsc" #-}
newtype SolveHandle = SolveHandle (Ptr SolveHandle) deriving Storable
newtype SolveControl = SolveControl (Ptr SolveControl) deriving Storable
newtype Model = Model (Ptr Model) deriving Storable
newtype SymbolicAtoms = SymbolicAtoms (Ptr SymbolicAtoms) deriving Storable
type SymbolicAtomIterator = Word64
{-# LINE 163 "src/Clingo/Raw/Types.hsc" #-}
newtype TheoryAtoms = TheoryAtoms (Ptr TheoryAtoms) deriving Storable
newtype PropagateInit = PropagateInit (Ptr PropagateInit) deriving Storable
newtype Assignment = Assignment (Ptr Assignment) deriving Storable
newtype PropagateControl = PropagateControl (Ptr PropagateControl)
deriving Storable
type CallbackPropagatorInit a =
PropagateInit -> Ptr a -> IO (CBool)
foreign import ccall "wrapper" mkCallbackPropagatorInit ::
CallbackPropagatorInit a -> IO (FunPtr (CallbackPropagatorInit a))
type CallbackPropagatorPropagate a =
PropagateControl -> Ptr Literal -> CSize -> Ptr a -> IO CBool
foreign import ccall "wrapper" mkCallbackPropagatorPropagate ::
CallbackPropagatorPropagate a -> IO (FunPtr (CallbackPropagatorPropagate a))
type CallbackPropagatorUndo a =
PropagateControl -> Ptr Literal -> CSize -> Ptr a -> IO CBool
foreign import ccall "wrapper" mkCallbackPropagatorUndo ::
CallbackPropagatorUndo a -> IO (FunPtr (CallbackPropagatorUndo a))
type CallbackPropagatorCheck a =
PropagateControl -> Ptr a -> IO CBool
foreign import ccall "wrapper" mkCallbackPropagatorCheck ::
CallbackPropagatorCheck a -> IO (FunPtr (CallbackPropagatorCheck a))
data Propagator a = Propagator
{ propagatorInit :: FunPtr (CallbackPropagatorInit a)
, propagatorPropagate :: FunPtr (CallbackPropagatorPropagate a)
, propagatorUndo :: FunPtr (CallbackPropagatorUndo a)
, propagatorCheck :: FunPtr (CallbackPropagatorCheck a)
}
instance Storable (Propagator a) where
sizeOf _ = (32)
{-# LINE 203 "src/Clingo/Raw/Types.hsc" #-}
alignment = sizeOf
peek p = Propagator
<$> ((\hsc_ptr -> peekByteOff hsc_ptr 0) p)
{-# LINE 206 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 8) p)
{-# LINE 207 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 16) p)
{-# LINE 208 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 24) p)
{-# LINE 209 "src/Clingo/Raw/Types.hsc" #-}
poke p prop = do
((\hsc_ptr -> pokeByteOff hsc_ptr 0)) p (propagatorInit prop)
{-# LINE 212 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 8)) p (propagatorPropagate prop)
{-# LINE 213 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 16)) p (propagatorUndo prop)
{-# LINE 214 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 24)) p (propagatorCheck prop)
{-# LINE 215 "src/Clingo/Raw/Types.hsc" #-}
data WeightedLiteral = WeightedLiteral
{ wlLiteral :: Literal
, wlWeight :: Weight
}
instance Storable WeightedLiteral where
sizeOf _ = (8)
{-# LINE 223 "src/Clingo/Raw/Types.hsc" #-}
alignment = sizeOf
peek p = WeightedLiteral
<$> ((\hsc_ptr -> peekByteOff hsc_ptr 0) p)
{-# LINE 226 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 4) p)
{-# LINE 227 "src/Clingo/Raw/Types.hsc" #-}
poke p wl = do
((\hsc_ptr -> pokeByteOff hsc_ptr 0)) p (wlLiteral wl)
{-# LINE 230 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 4)) p (wlWeight wl)
{-# LINE 231 "src/Clingo/Raw/Types.hsc" #-}
newtype Backend = Backend (Ptr Backend) deriving Storable
newtype Configuration = Configuration (Ptr Configuration) deriving Storable
newtype Statistics = Statistics (Ptr Statistics) deriving Storable
newtype ProgramBuilder = ProgramBuilder (Ptr ProgramBuilder) deriving Storable
data GroundProgramObserver a = GroundProgramObserver
{ gpoInitProgram :: FunPtr (CBool -> Ptr a -> IO CBool)
, gpoBeginStep :: FunPtr (Ptr a -> IO CBool)
, gpoEndStep :: FunPtr (Ptr a -> IO CBool)
, gpoRule :: FunPtr (CBool -> Ptr Atom -> CSize
-> Ptr Literal -> CSize
-> Ptr a -> IO CBool)
, gpoWeightRule :: FunPtr (CBool -> Ptr Atom -> CSize -> Weight
-> Ptr WeightedLiteral -> CSize
-> Ptr a -> IO CBool)
, gpoMinimize :: FunPtr (Weight -> Ptr WeightedLiteral -> CSize
-> Ptr a -> IO CBool)
, gpoProject :: FunPtr (Ptr Atom -> CSize -> Ptr a -> IO CBool)
, gpoExternal :: FunPtr (Atom -> ExternalType -> Ptr a -> IO CBool)
, gpoAssume :: FunPtr (Ptr Literal -> CSize -> Ptr a -> IO CBool)
, gpoHeuristic :: FunPtr (Atom -> HeuristicType -> CInt
-> CUInt -> Ptr Literal -> CSize
-> Ptr a -> IO CBool)
, gpoAcycEdge :: FunPtr (CInt -> CInt -> Ptr Literal -> CSize
-> Ptr a -> IO CBool)
, gpoTheoryTermNum :: FunPtr (Identifier -> CInt -> Ptr a -> IO CBool)
, gpoTheoryTermStr :: FunPtr (Identifier -> Ptr CChar -> Ptr a -> IO CBool)
, gpoTheoryTermCmp :: FunPtr (Identifier -> CInt -> Ptr Identifier -> CSize
-> Ptr a -> IO CBool)
, gpoTheoryElement :: FunPtr (Identifier -> Ptr Identifier -> CSize
-> Ptr Literal -> CSize -> Ptr a
-> IO CBool)
, gpoTheoryAtom :: FunPtr (Identifier -> Identifier -> Ptr Identifier
-> CSize -> IO CBool)
, gpoTheoryAtomGrd :: FunPtr (Identifier -> Identifier -> Ptr Identifier
-> CSize -> Identifier
-> Identifier -> Ptr a
-> IO CBool)
}
foreign import ccall "wrapper" mkGpoInitProgram ::
(CBool -> Ptr a -> IO CBool) -> IO (FunPtr (CBool -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoBeginStep ::
(Ptr a -> IO CBool) -> IO (FunPtr (Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoEndStep ::
(Ptr a -> IO CBool) -> IO (FunPtr (Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoRule ::
(CBool -> Ptr Atom -> CSize -> Ptr Literal -> CSize -> Ptr a -> IO CBool) -> IO (FunPtr (CBool -> Ptr Atom -> CSize -> Ptr Literal -> CSize -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoWeightRule ::
(CBool -> Ptr Atom -> CSize -> Weight -> Ptr WeightedLiteral -> CSize -> Ptr a -> IO CBool) -> IO (FunPtr (CBool -> Ptr Atom -> CSize -> Weight -> Ptr WeightedLiteral -> CSize -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoMinimize ::
(Weight -> Ptr WeightedLiteral -> CSize -> Ptr a -> IO CBool) -> IO (FunPtr (Weight -> Ptr WeightedLiteral -> CSize -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoProject ::
(Ptr Atom -> CSize -> Ptr a -> IO CBool) -> IO (FunPtr (Ptr Atom -> CSize -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoExternal ::
(Atom -> ExternalType -> Ptr a -> IO CBool) -> IO (FunPtr (Atom -> ExternalType -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoAssume ::
(Ptr Literal -> CSize -> Ptr a -> IO CBool) -> IO (FunPtr (Ptr Literal -> CSize -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoHeuristic ::
(Atom -> HeuristicType -> CInt -> CUInt -> Ptr Literal -> CSize -> Ptr a -> IO CBool) -> IO (FunPtr (Atom -> HeuristicType -> CInt -> CUInt -> Ptr Literal -> CSize -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoAcycEdge ::
(CInt -> CInt -> Ptr Literal -> CSize -> Ptr a -> IO CBool) -> IO (FunPtr (CInt -> CInt -> Ptr Literal -> CSize -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoTheoryTermNum ::
(Identifier -> CInt -> Ptr a -> IO CBool) -> IO (FunPtr (Identifier -> CInt -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoTheoryTermStr ::
(Identifier -> Ptr CChar -> Ptr a -> IO CBool) -> IO (FunPtr (Identifier -> Ptr CChar -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoTheoryTermCmp ::
(Identifier -> CInt -> Ptr Identifier -> CSize -> Ptr a -> IO CBool) -> IO (FunPtr (Identifier -> CInt -> Ptr Identifier -> CSize -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoTheoryElement ::
(Identifier -> Ptr Identifier -> CSize -> Ptr Literal -> CSize -> Ptr a -> IO CBool) -> IO (FunPtr (Identifier -> Ptr Identifier -> CSize -> Ptr Literal -> CSize -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoTheoryAtom ::
(Identifier -> Identifier -> Ptr Identifier -> CSize -> IO CBool) -> IO (FunPtr (Identifier -> Identifier -> Ptr Identifier -> CSize -> IO CBool))
foreign import ccall "wrapper" mkGpoTheoryAtomGrd ::
(Identifier -> Identifier -> Ptr Identifier -> CSize -> Identifier -> Identifier -> Ptr a -> IO CBool) -> IO (FunPtr (Identifier -> Identifier -> Ptr Identifier -> CSize -> Identifier -> Identifier -> Ptr a -> IO CBool))
instance Storable (GroundProgramObserver a) where
sizeOf _ = (160)
{-# LINE 309 "src/Clingo/Raw/Types.hsc" #-}
alignment = sizeOf
peek p = GroundProgramObserver
<$> ((\hsc_ptr -> peekByteOff hsc_ptr 0) p)
{-# LINE 312 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 8) p)
{-# LINE 313 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 16) p)
{-# LINE 314 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 24) p)
{-# LINE 315 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 32) p)
{-# LINE 316 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 40) p)
{-# LINE 317 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 48) p)
{-# LINE 318 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 80) p)
{-# LINE 319 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 88) p)
{-# LINE 320 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 96) p)
{-# LINE 321 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 104) p)
{-# LINE 322 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 112) p)
{-# LINE 323 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 120) p)
{-# LINE 324 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 128) p)
{-# LINE 325 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 136) p)
{-# LINE 326 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 144) p)
{-# LINE 327 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 152) p)
{-# LINE 328 "src/Clingo/Raw/Types.hsc" #-}
poke p g = do
((\hsc_ptr -> pokeByteOff hsc_ptr 0)) p
{-# LINE 331 "src/Clingo/Raw/Types.hsc" #-}
(gpoInitProgram g)
((\hsc_ptr -> pokeByteOff hsc_ptr 8)) p (gpoBeginStep g)
{-# LINE 333 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 16)) p (gpoEndStep g)
{-# LINE 334 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 24)) p (gpoRule g)
{-# LINE 335 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 32)) p
{-# LINE 336 "src/Clingo/Raw/Types.hsc" #-}
(gpoWeightRule g)
((\hsc_ptr -> pokeByteOff hsc_ptr 40)) p (gpoMinimize g)
{-# LINE 338 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 48)) p (gpoProject g)
{-# LINE 339 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 80)) p (gpoExternal g)
{-# LINE 340 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 88)) p (gpoAssume g)
{-# LINE 341 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 96)) p (gpoHeuristic g)
{-# LINE 342 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 104)) p (gpoAcycEdge g)
{-# LINE 343 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 112)) p
{-# LINE 344 "src/Clingo/Raw/Types.hsc" #-}
(gpoTheoryTermNum g)
((\hsc_ptr -> pokeByteOff hsc_ptr 120)) p
{-# LINE 346 "src/Clingo/Raw/Types.hsc" #-}
(gpoTheoryTermStr g)
((\hsc_ptr -> pokeByteOff hsc_ptr 128)) p
{-# LINE 348 "src/Clingo/Raw/Types.hsc" #-}
(gpoTheoryTermCmp g)
((\hsc_ptr -> pokeByteOff hsc_ptr 136)) p
{-# LINE 350 "src/Clingo/Raw/Types.hsc" #-}
(gpoTheoryElement g)
((\hsc_ptr -> pokeByteOff hsc_ptr 144)) p
{-# LINE 352 "src/Clingo/Raw/Types.hsc" #-}
(gpoTheoryAtom g)
((\hsc_ptr -> pokeByteOff hsc_ptr 152)) p
{-# LINE 354 "src/Clingo/Raw/Types.hsc" #-}
(gpoTheoryAtomGrd g)
newtype Control = Control (Ptr Control) deriving Storable
data Part = Part
{ partName :: CString
, partParams :: Ptr Symbol
, partSize :: CSize
}
instance Storable Part where
sizeOf _ = (24)
{-# LINE 366 "src/Clingo/Raw/Types.hsc" #-}
alignment = sizeOf
peek p = Part
<$> ((\hsc_ptr -> peekByteOff hsc_ptr 0) p)
{-# LINE 369 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 8) p)
{-# LINE 370 "src/Clingo/Raw/Types.hsc" #-}
<*> ((\hsc_ptr -> peekByteOff hsc_ptr 16) p)
{-# LINE 371 "src/Clingo/Raw/Types.hsc" #-}
poke p part = do
((\hsc_ptr -> pokeByteOff hsc_ptr 0)) p (partName part)
{-# LINE 374 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 8)) p (partParams part)
{-# LINE 375 "src/Clingo/Raw/Types.hsc" #-}
((\hsc_ptr -> pokeByteOff hsc_ptr 16)) p (partSize part)
{-# LINE 376 "src/Clingo/Raw/Types.hsc" #-}
type CallbackSymbol a = Ptr Symbol -> CSize -> Ptr a -> IO CBool
type CallbackGround a =
Ptr Location -> Ptr CChar -> Ptr Symbol -> CSize -> Ptr a
-> FunPtr (CallbackSymbol a) -> Ptr a -> IO CBool
type CallbackEvent a = SolveEvent -> Ptr Model -> Ptr a -> Ptr CBool -> IO CBool
type CallbackFinish a = SolveResult -> Ptr a -> IO CBool
foreign import ccall "wrapper" mkCallbackGround ::
CallbackGround a -> IO (FunPtr (CallbackGround a))
foreign import ccall "wrapper" mkCallbackSymbol ::
CallbackSymbol a -> IO (FunPtr (CallbackSymbol a))
foreign import ccall "dynamic" getCallbackSymbol ::
FunPtr (CallbackSymbol a) -> CallbackSymbol a
foreign import ccall "wrapper" mkCallbackFinish ::
CallbackFinish a -> IO (FunPtr (CallbackFinish a))
foreign import ccall "wrapper" mkCallbackEvent ::
CallbackEvent a -> IO (FunPtr (CallbackEvent a))