diff --git a/ChangeLog.md b/ChangeLog.md --- a/ChangeLog.md +++ b/ChangeLog.md @@ -1,3 +1,7 @@ +### 4.0.17 + ++ Update to haskell-gi(-base) 0.22 + ### 4.0.16 + Update stack version to 12.10 diff --git a/GI/JavaScriptCore.hs b/GI/JavaScriptCore.hs new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore.hs @@ -0,0 +1,58 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.JavaScriptCore + ( module GI.JavaScriptCore.Callbacks , + module GI.JavaScriptCore.Constants , + module GI.JavaScriptCore.Enums , + module GI.JavaScriptCore.Flags , + module GI.JavaScriptCore.Functions , + module GI.JavaScriptCore.Objects , + module GI.JavaScriptCore.Structs , + + + + module Data.GI.Base , + + + ) where + +import GI.JavaScriptCore.Callbacks +import GI.JavaScriptCore.Constants +import GI.JavaScriptCore.Enums +import GI.JavaScriptCore.Flags +import GI.JavaScriptCore.Functions +import GI.JavaScriptCore.Objects +import GI.JavaScriptCore.Structs + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +import Data.GI.Base + diff --git a/GI/JavaScriptCore/Callbacks.hs b/GI/JavaScriptCore/Callbacks.hs new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Callbacks.hs @@ -0,0 +1,808 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.JavaScriptCore.Callbacks + ( + + -- * Signals +-- ** ClassDeletePropertyFunction #signal:ClassDeletePropertyFunction# + + C_ClassDeletePropertyFunction , + ClassDeletePropertyFunction , + dynamic_ClassDeletePropertyFunction , + genClosure_ClassDeletePropertyFunction , + mk_ClassDeletePropertyFunction , + noClassDeletePropertyFunction , + wrap_ClassDeletePropertyFunction , + + +-- ** ClassEnumeratePropertiesFunction #signal:ClassEnumeratePropertiesFunction# + + C_ClassEnumeratePropertiesFunction , + ClassEnumeratePropertiesFunction , + dynamic_ClassEnumeratePropertiesFunction, + genClosure_ClassEnumeratePropertiesFunction, + mk_ClassEnumeratePropertiesFunction , + noClassEnumeratePropertiesFunction , + wrap_ClassEnumeratePropertiesFunction , + + +-- ** ClassGetPropertyFunction #signal:ClassGetPropertyFunction# + + C_ClassGetPropertyFunction , + ClassGetPropertyFunction , + dynamic_ClassGetPropertyFunction , + genClosure_ClassGetPropertyFunction , + mk_ClassGetPropertyFunction , + noClassGetPropertyFunction , + wrap_ClassGetPropertyFunction , + + +-- ** ClassHasPropertyFunction #signal:ClassHasPropertyFunction# + + C_ClassHasPropertyFunction , + ClassHasPropertyFunction , + dynamic_ClassHasPropertyFunction , + genClosure_ClassHasPropertyFunction , + mk_ClassHasPropertyFunction , + noClassHasPropertyFunction , + wrap_ClassHasPropertyFunction , + + +-- ** ClassSetPropertyFunction #signal:ClassSetPropertyFunction# + + C_ClassSetPropertyFunction , + ClassSetPropertyFunction , + dynamic_ClassSetPropertyFunction , + genClosure_ClassSetPropertyFunction , + mk_ClassSetPropertyFunction , + noClassSetPropertyFunction , + wrap_ClassSetPropertyFunction , + + +-- ** ExceptionHandler #signal:ExceptionHandler# + + C_ExceptionHandler , + ExceptionHandler , + ExceptionHandler_WithClosures , + drop_closures_ExceptionHandler , + dynamic_ExceptionHandler , + genClosure_ExceptionHandler , + mk_ExceptionHandler , + noExceptionHandler , + noExceptionHandler_WithClosures , + wrap_ExceptionHandler , + + +-- ** OptionsFunc #signal:OptionsFunc# + + C_OptionsFunc , + OptionsFunc , + OptionsFunc_WithClosures , + drop_closures_OptionsFunc , + dynamic_OptionsFunc , + genClosure_OptionsFunc , + mk_OptionsFunc , + noOptionsFunc , + noOptionsFunc_WithClosures , + wrap_OptionsFunc , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.JavaScriptCore.Enums as JavaScriptCore.Enums +import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Class as JavaScriptCore.Class +import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Context as JavaScriptCore.Context +import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Exception as JavaScriptCore.Exception +import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Value as JavaScriptCore.Value + +-- callback OptionsFunc +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "%TRUE to stop the iteration, or %FALSE otherwise", sinceVersion = Nothing}, args = [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "JavaScriptCore", name = "OptionType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option #JSCOptionType", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the option description, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Function used to iterate options.\n\nNot that @description string is not localized.", sinceVersion = Just "2.24"}} +-- | Type for the callback on the (unwrapped) C side. +type C_OptionsFunc = + CString -> + CUInt -> + CString -> + Ptr () -> + IO CInt + +-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "JavaScriptCore", name = "OptionType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option #JSCOptionType", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the option description, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_OptionsFunc :: FunPtr C_OptionsFunc -> C_OptionsFunc + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_OptionsFunc :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_OptionsFunc + -> T.Text + {- ^ /@option@/: the option name -} + -> JavaScriptCore.Enums.OptionType + {- ^ /@type@/: the option 'GI.JavaScriptCore.Enums.OptionType' -} + -> Maybe (T.Text) + {- ^ /@description@/: the option description, or 'Nothing' -} + -> Ptr () + {- ^ /@userData@/: user data -} + -> m Bool + {- ^ __Returns:__ 'True' to stop the iteration, or 'False' otherwise -} +dynamic_OptionsFunc __funPtr option type_ description userData = liftIO $ do + option' <- textToCString option + let type_' = (fromIntegral . fromEnum) type_ + maybeDescription <- case description of + Nothing -> return nullPtr + Just jDescription -> do + jDescription' <- textToCString jDescription + return jDescription' + result <- (__dynamic_C_OptionsFunc __funPtr) option' type_' maybeDescription userData + let result' = (/= 0) result + freeMem option' + freeMem maybeDescription + return result' + +-- | Generate a function pointer callable from C code, from a `C_OptionsFunc`. +foreign import ccall "wrapper" + mk_OptionsFunc :: C_OptionsFunc -> IO (FunPtr C_OptionsFunc) + +{- | +Function used to iterate options. + +Not that /@description@/ string is not localized. + +/Since: 2.24/ +-} +type OptionsFunc = + T.Text + {- ^ /@option@/: the option name -} + -> JavaScriptCore.Enums.OptionType + {- ^ /@type@/: the option 'GI.JavaScriptCore.Enums.OptionType' -} + -> Maybe T.Text + {- ^ /@description@/: the option description, or 'Nothing' -} + -> IO Bool + {- ^ __Returns:__ 'True' to stop the iteration, or 'False' otherwise -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `OptionsFunc`@. +noOptionsFunc :: Maybe OptionsFunc +noOptionsFunc = Nothing + +{- | +Function used to iterate options. + +Not that /@description@/ string is not localized. + +/Since: 2.24/ +-} +type OptionsFunc_WithClosures = + T.Text + {- ^ /@option@/: the option name -} + -> JavaScriptCore.Enums.OptionType + {- ^ /@type@/: the option 'GI.JavaScriptCore.Enums.OptionType' -} + -> Maybe T.Text + {- ^ /@description@/: the option description, or 'Nothing' -} + -> Ptr () + {- ^ /@userData@/: user data -} + -> IO Bool + {- ^ __Returns:__ 'True' to stop the iteration, or 'False' otherwise -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `OptionsFunc_WithClosures`@. +noOptionsFunc_WithClosures :: Maybe OptionsFunc_WithClosures +noOptionsFunc_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_OptionsFunc :: OptionsFunc -> OptionsFunc_WithClosures +drop_closures_OptionsFunc _f option type_ description _ = _f option type_ description + +-- | Wrap the callback into a `GClosure`. +genClosure_OptionsFunc :: MonadIO m => OptionsFunc -> m (GClosure C_OptionsFunc) +genClosure_OptionsFunc cb = liftIO $ do + let cb' = drop_closures_OptionsFunc cb + let cb'' = wrap_OptionsFunc Nothing cb' + mk_OptionsFunc cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `OptionsFunc` into a `C_OptionsFunc`. +wrap_OptionsFunc :: + Maybe (Ptr (FunPtr C_OptionsFunc)) -> + OptionsFunc_WithClosures -> + C_OptionsFunc +wrap_OptionsFunc funptrptr _cb option type_ description userData = do + option' <- cstringToText option + let type_' = (toEnum . fromIntegral) type_ + maybeDescription <- + if description == nullPtr + then return Nothing + else do + description' <- cstringToText description + return $ Just description' + result <- _cb option' type_' maybeDescription userData + maybeReleaseFunPtr funptrptr + let result' = (fromIntegral . fromEnum) result + return result' + + +-- callback ExceptionHandler +-- -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Function used to handle JavaScript exceptions in a #JSCContext.", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_ExceptionHandler = + Ptr JavaScriptCore.Context.Context -> + Ptr JavaScriptCore.Exception.Exception -> + Ptr () -> + IO () + +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_ExceptionHandler :: FunPtr C_ExceptionHandler -> C_ExceptionHandler + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_ExceptionHandler :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a, JavaScriptCore.Exception.IsException b) => + FunPtr C_ExceptionHandler + -> a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> b + {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -} + -> Ptr () + {- ^ /@userData@/: user data -} + -> m () +dynamic_ExceptionHandler __funPtr context exception userData = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + exception' <- unsafeManagedPtrCastPtr exception + (__dynamic_C_ExceptionHandler __funPtr) context' exception' userData + touchManagedPtr context + touchManagedPtr exception + return () + +-- | Generate a function pointer callable from C code, from a `C_ExceptionHandler`. +foreign import ccall "wrapper" + mk_ExceptionHandler :: C_ExceptionHandler -> IO (FunPtr C_ExceptionHandler) + +{- | +Function used to handle JavaScript exceptions in a 'GI.JavaScriptCore.Objects.Context.Context'. +-} +type ExceptionHandler = + JavaScriptCore.Context.Context + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> JavaScriptCore.Exception.Exception + {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ExceptionHandler`@. +noExceptionHandler :: Maybe ExceptionHandler +noExceptionHandler = Nothing + +{- | +Function used to handle JavaScript exceptions in a 'GI.JavaScriptCore.Objects.Context.Context'. +-} +type ExceptionHandler_WithClosures = + JavaScriptCore.Context.Context + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> JavaScriptCore.Exception.Exception + {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -} + -> Ptr () + {- ^ /@userData@/: user data -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ExceptionHandler_WithClosures`@. +noExceptionHandler_WithClosures :: Maybe ExceptionHandler_WithClosures +noExceptionHandler_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_ExceptionHandler :: ExceptionHandler -> ExceptionHandler_WithClosures +drop_closures_ExceptionHandler _f context exception _ = _f context exception + +-- | Wrap the callback into a `GClosure`. +genClosure_ExceptionHandler :: MonadIO m => ExceptionHandler -> m (GClosure C_ExceptionHandler) +genClosure_ExceptionHandler cb = liftIO $ do + let cb' = drop_closures_ExceptionHandler cb + let cb'' = wrap_ExceptionHandler Nothing cb' + mk_ExceptionHandler cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `ExceptionHandler` into a `C_ExceptionHandler`. +wrap_ExceptionHandler :: + Maybe (Ptr (FunPtr C_ExceptionHandler)) -> + ExceptionHandler_WithClosures -> + C_ExceptionHandler +wrap_ExceptionHandler funptrptr _cb context exception userData = do + context' <- (newObject JavaScriptCore.Context.Context) context + exception' <- (newObject JavaScriptCore.Exception.Exception) exception + _cb context' exception' userData + maybeReleaseFunPtr funptrptr + + +-- callback ClassSetPropertyFunction +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "%TRUE if handled or %FALSE to forward the request to the parent class or prototype chain.", sinceVersion = Nothing}, args = [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #JSCValue to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of set_property in #JSCClassVTable. This is only required when you need to handle\nexternal properties not added to the prototype.", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_ClassSetPropertyFunction = + Ptr JavaScriptCore.Class.Class -> + Ptr JavaScriptCore.Context.Context -> + Ptr () -> + CString -> + Ptr JavaScriptCore.Value.Value -> + IO CInt + +-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #JSCValue to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_ClassSetPropertyFunction :: FunPtr C_ClassSetPropertyFunction -> C_ClassSetPropertyFunction + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_ClassSetPropertyFunction :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Class.IsClass a, JavaScriptCore.Context.IsContext b, JavaScriptCore.Value.IsValue c) => + FunPtr C_ClassSetPropertyFunction + -> a + {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -} + -> b + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> Ptr () + {- ^ /@instance@/: the /@jscClass@/ instance -} + -> T.Text + {- ^ /@name@/: the property name -} + -> c + {- ^ /@value@/: the 'GI.JavaScriptCore.Objects.Value.Value' to set -} + -> m Bool + {- ^ __Returns:__ 'True' if handled or 'False' to forward the request to the parent class or prototype chain. -} +dynamic_ClassSetPropertyFunction __funPtr jscClass context instance_ name value = liftIO $ do + jscClass' <- unsafeManagedPtrCastPtr jscClass + context' <- unsafeManagedPtrCastPtr context + name' <- textToCString name + value' <- unsafeManagedPtrCastPtr value + result <- (__dynamic_C_ClassSetPropertyFunction __funPtr) jscClass' context' instance_ name' value' + let result' = (/= 0) result + touchManagedPtr jscClass + touchManagedPtr context + touchManagedPtr value + freeMem name' + return result' + +-- | Generate a function pointer callable from C code, from a `C_ClassSetPropertyFunction`. +foreign import ccall "wrapper" + mk_ClassSetPropertyFunction :: C_ClassSetPropertyFunction -> IO (FunPtr C_ClassSetPropertyFunction) + +{- | +The type of set_property in 'GI.JavaScriptCore.Structs.ClassVTable.ClassVTable'. This is only required when you need to handle +external properties not added to the prototype. +-} +type ClassSetPropertyFunction = + JavaScriptCore.Class.Class + {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -} + -> JavaScriptCore.Context.Context + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> Ptr () + {- ^ /@instance@/: the /@jscClass@/ instance -} + -> T.Text + {- ^ /@name@/: the property name -} + -> JavaScriptCore.Value.Value + {- ^ /@value@/: the 'GI.JavaScriptCore.Objects.Value.Value' to set -} + -> IO Bool + {- ^ __Returns:__ 'True' if handled or 'False' to forward the request to the parent class or prototype chain. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ClassSetPropertyFunction`@. +noClassSetPropertyFunction :: Maybe ClassSetPropertyFunction +noClassSetPropertyFunction = Nothing + +-- | Wrap the callback into a `GClosure`. +genClosure_ClassSetPropertyFunction :: MonadIO m => ClassSetPropertyFunction -> m (GClosure C_ClassSetPropertyFunction) +genClosure_ClassSetPropertyFunction cb = liftIO $ do + let cb' = wrap_ClassSetPropertyFunction Nothing cb + mk_ClassSetPropertyFunction cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ClassSetPropertyFunction` into a `C_ClassSetPropertyFunction`. +wrap_ClassSetPropertyFunction :: + Maybe (Ptr (FunPtr C_ClassSetPropertyFunction)) -> + ClassSetPropertyFunction -> + C_ClassSetPropertyFunction +wrap_ClassSetPropertyFunction funptrptr _cb jscClass context instance_ name value = do + jscClass' <- (newObject JavaScriptCore.Class.Class) jscClass + context' <- (newObject JavaScriptCore.Context.Context) context + name' <- cstringToText name + value' <- (newObject JavaScriptCore.Value.Value) value + result <- _cb jscClass' context' instance_ name' value' + maybeReleaseFunPtr funptrptr + let result' = (fromIntegral . fromEnum) result + return result' + + +-- callback ClassHasPropertyFunction +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "%TRUE if @instance has a property with @name or %FALSE to forward the request\n to the parent class or prototype chain.", sinceVersion = Nothing}, args = [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of has_property in #JSCClassVTable. This is only required when you need to handle\nexternal properties not added to the prototype.", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_ClassHasPropertyFunction = + Ptr JavaScriptCore.Class.Class -> + Ptr JavaScriptCore.Context.Context -> + Ptr () -> + CString -> + IO CInt + +-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_ClassHasPropertyFunction :: FunPtr C_ClassHasPropertyFunction -> C_ClassHasPropertyFunction + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_ClassHasPropertyFunction :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Class.IsClass a, JavaScriptCore.Context.IsContext b) => + FunPtr C_ClassHasPropertyFunction + -> a + {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -} + -> b + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> Ptr () + {- ^ /@instance@/: the /@jscClass@/ instance -} + -> T.Text + {- ^ /@name@/: the property name -} + -> m Bool + {- ^ __Returns:__ 'True' if /@instance@/ has a property with /@name@/ or 'False' to forward the request + to the parent class or prototype chain. -} +dynamic_ClassHasPropertyFunction __funPtr jscClass context instance_ name = liftIO $ do + jscClass' <- unsafeManagedPtrCastPtr jscClass + context' <- unsafeManagedPtrCastPtr context + name' <- textToCString name + result <- (__dynamic_C_ClassHasPropertyFunction __funPtr) jscClass' context' instance_ name' + let result' = (/= 0) result + touchManagedPtr jscClass + touchManagedPtr context + freeMem name' + return result' + +-- | Generate a function pointer callable from C code, from a `C_ClassHasPropertyFunction`. +foreign import ccall "wrapper" + mk_ClassHasPropertyFunction :: C_ClassHasPropertyFunction -> IO (FunPtr C_ClassHasPropertyFunction) + +{- | +The type of has_property in 'GI.JavaScriptCore.Structs.ClassVTable.ClassVTable'. This is only required when you need to handle +external properties not added to the prototype. +-} +type ClassHasPropertyFunction = + JavaScriptCore.Class.Class + {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -} + -> JavaScriptCore.Context.Context + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> Ptr () + {- ^ /@instance@/: the /@jscClass@/ instance -} + -> T.Text + {- ^ /@name@/: the property name -} + -> IO Bool + {- ^ __Returns:__ 'True' if /@instance@/ has a property with /@name@/ or 'False' to forward the request + to the parent class or prototype chain. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ClassHasPropertyFunction`@. +noClassHasPropertyFunction :: Maybe ClassHasPropertyFunction +noClassHasPropertyFunction = Nothing + +-- | Wrap the callback into a `GClosure`. +genClosure_ClassHasPropertyFunction :: MonadIO m => ClassHasPropertyFunction -> m (GClosure C_ClassHasPropertyFunction) +genClosure_ClassHasPropertyFunction cb = liftIO $ do + let cb' = wrap_ClassHasPropertyFunction Nothing cb + mk_ClassHasPropertyFunction cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ClassHasPropertyFunction` into a `C_ClassHasPropertyFunction`. +wrap_ClassHasPropertyFunction :: + Maybe (Ptr (FunPtr C_ClassHasPropertyFunction)) -> + ClassHasPropertyFunction -> + C_ClassHasPropertyFunction +wrap_ClassHasPropertyFunction funptrptr _cb jscClass context instance_ name = do + jscClass' <- (newObject JavaScriptCore.Class.Class) jscClass + context' <- (newObject JavaScriptCore.Context.Context) context + name' <- cstringToText name + result <- _cb jscClass' context' instance_ name' + maybeReleaseFunPtr funptrptr + let result' = (fromIntegral . fromEnum) result + return result' + + +-- callback ClassGetPropertyFunction +-- -> Callable {returnType = Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})), returnMayBeNull = True, returnTransfer = TransferEverything, returnDocumentation = Documentation {rawDocText = Just "a #JSCValue or %NULL to forward the request to\n the parent class or prototype chain", sinceVersion = Nothing}, args = [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of get_property in #JSCClassVTable. This is only required when you need to handle\nexternal properties not added to the prototype.", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_ClassGetPropertyFunction = + Ptr JavaScriptCore.Class.Class -> + Ptr JavaScriptCore.Context.Context -> + Ptr () -> + CString -> + IO (Ptr JavaScriptCore.Value.Value) + +-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_ClassGetPropertyFunction :: FunPtr C_ClassGetPropertyFunction -> C_ClassGetPropertyFunction + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_ClassGetPropertyFunction :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Class.IsClass a, JavaScriptCore.Context.IsContext b) => + FunPtr C_ClassGetPropertyFunction + -> a + {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -} + -> b + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> Ptr () + {- ^ /@instance@/: the /@jscClass@/ instance -} + -> T.Text + {- ^ /@name@/: the property name -} + -> m (Maybe JavaScriptCore.Value.Value) + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' or 'Nothing' to forward the request to + the parent class or prototype chain -} +dynamic_ClassGetPropertyFunction __funPtr jscClass context instance_ name = liftIO $ do + jscClass' <- unsafeManagedPtrCastPtr jscClass + context' <- unsafeManagedPtrCastPtr context + name' <- textToCString name + result <- (__dynamic_C_ClassGetPropertyFunction __funPtr) jscClass' context' instance_ name' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject JavaScriptCore.Value.Value) result' + return result'' + touchManagedPtr jscClass + touchManagedPtr context + freeMem name' + return maybeResult + +-- | Generate a function pointer callable from C code, from a `C_ClassGetPropertyFunction`. +foreign import ccall "wrapper" + mk_ClassGetPropertyFunction :: C_ClassGetPropertyFunction -> IO (FunPtr C_ClassGetPropertyFunction) + +{- | +The type of get_property in 'GI.JavaScriptCore.Structs.ClassVTable.ClassVTable'. This is only required when you need to handle +external properties not added to the prototype. +-} +type ClassGetPropertyFunction = + JavaScriptCore.Class.Class + {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -} + -> JavaScriptCore.Context.Context + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> Ptr () + {- ^ /@instance@/: the /@jscClass@/ instance -} + -> T.Text + {- ^ /@name@/: the property name -} + -> IO (Maybe JavaScriptCore.Value.Value) + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' or 'Nothing' to forward the request to + the parent class or prototype chain -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ClassGetPropertyFunction`@. +noClassGetPropertyFunction :: Maybe ClassGetPropertyFunction +noClassGetPropertyFunction = Nothing + +-- | Wrap the callback into a `GClosure`. +genClosure_ClassGetPropertyFunction :: MonadIO m => ClassGetPropertyFunction -> m (GClosure C_ClassGetPropertyFunction) +genClosure_ClassGetPropertyFunction cb = liftIO $ do + let cb' = wrap_ClassGetPropertyFunction Nothing cb + mk_ClassGetPropertyFunction cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ClassGetPropertyFunction` into a `C_ClassGetPropertyFunction`. +wrap_ClassGetPropertyFunction :: + Maybe (Ptr (FunPtr C_ClassGetPropertyFunction)) -> + ClassGetPropertyFunction -> + C_ClassGetPropertyFunction +wrap_ClassGetPropertyFunction funptrptr _cb jscClass context instance_ name = do + jscClass' <- (newObject JavaScriptCore.Class.Class) jscClass + context' <- (newObject JavaScriptCore.Context.Context) context + name' <- cstringToText name + result <- _cb jscClass' context' instance_ name' + maybeReleaseFunPtr funptrptr + maybeM nullPtr result $ \result' -> do + result'' <- B.ManagedPtr.disownObject result' + return result'' + + +-- callback ClassEnumeratePropertiesFunction +-- -> Callable {returnType = Just (TCArray True (-1) (-1) (TBasicType TUTF8)), returnMayBeNull = True, returnTransfer = TransferEverything, returnDocumentation = Documentation {rawDocText = Just "a %NULL-terminated array of strings\n containing the property names, or %NULL if @instance doesn't have enumerable properties.", sinceVersion = Nothing}, args = [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of enumerate_properties in #JSCClassVTable. This is only required when you need to handle\nexternal properties not added to the prototype.", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_ClassEnumeratePropertiesFunction = + Ptr JavaScriptCore.Class.Class -> + Ptr JavaScriptCore.Context.Context -> + Ptr () -> + IO (Ptr CString) + +-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_ClassEnumeratePropertiesFunction :: FunPtr C_ClassEnumeratePropertiesFunction -> C_ClassEnumeratePropertiesFunction + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_ClassEnumeratePropertiesFunction :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Class.IsClass a, JavaScriptCore.Context.IsContext b) => + FunPtr C_ClassEnumeratePropertiesFunction + -> a + {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -} + -> b + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> Ptr () + {- ^ /@instance@/: the /@jscClass@/ instance -} + -> m (Maybe [T.Text]) + {- ^ __Returns:__ a 'Nothing'-terminated array of strings + containing the property names, or 'Nothing' if /@instance@/ doesn\'t have enumerable properties. -} +dynamic_ClassEnumeratePropertiesFunction __funPtr jscClass context instance_ = liftIO $ do + jscClass' <- unsafeManagedPtrCastPtr jscClass + context' <- unsafeManagedPtrCastPtr context + result <- (__dynamic_C_ClassEnumeratePropertiesFunction __funPtr) jscClass' context' instance_ + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackZeroTerminatedUTF8CArray result' + mapZeroTerminatedCArray freeMem result' + freeMem result' + return result'' + touchManagedPtr jscClass + touchManagedPtr context + return maybeResult + +-- | Generate a function pointer callable from C code, from a `C_ClassEnumeratePropertiesFunction`. +foreign import ccall "wrapper" + mk_ClassEnumeratePropertiesFunction :: C_ClassEnumeratePropertiesFunction -> IO (FunPtr C_ClassEnumeratePropertiesFunction) + +{- | +The type of enumerate_properties in 'GI.JavaScriptCore.Structs.ClassVTable.ClassVTable'. This is only required when you need to handle +external properties not added to the prototype. +-} +type ClassEnumeratePropertiesFunction = + JavaScriptCore.Class.Class + {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -} + -> JavaScriptCore.Context.Context + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> Ptr () + {- ^ /@instance@/: the /@jscClass@/ instance -} + -> IO (Maybe [T.Text]) + {- ^ __Returns:__ a 'Nothing'-terminated array of strings + containing the property names, or 'Nothing' if /@instance@/ doesn\'t have enumerable properties. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ClassEnumeratePropertiesFunction`@. +noClassEnumeratePropertiesFunction :: Maybe ClassEnumeratePropertiesFunction +noClassEnumeratePropertiesFunction = Nothing + +-- | Wrap the callback into a `GClosure`. +genClosure_ClassEnumeratePropertiesFunction :: MonadIO m => ClassEnumeratePropertiesFunction -> m (GClosure C_ClassEnumeratePropertiesFunction) +genClosure_ClassEnumeratePropertiesFunction cb = liftIO $ do + let cb' = wrap_ClassEnumeratePropertiesFunction Nothing cb + mk_ClassEnumeratePropertiesFunction cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ClassEnumeratePropertiesFunction` into a `C_ClassEnumeratePropertiesFunction`. +wrap_ClassEnumeratePropertiesFunction :: + Maybe (Ptr (FunPtr C_ClassEnumeratePropertiesFunction)) -> + ClassEnumeratePropertiesFunction -> + C_ClassEnumeratePropertiesFunction +wrap_ClassEnumeratePropertiesFunction funptrptr _cb jscClass context instance_ = do + jscClass' <- (newObject JavaScriptCore.Class.Class) jscClass + context' <- (newObject JavaScriptCore.Context.Context) context + result <- _cb jscClass' context' instance_ + maybeReleaseFunPtr funptrptr + maybeM nullPtr result $ \result' -> do + result'' <- packZeroTerminatedUTF8CArray result' + return result'' + + +-- callback ClassDeletePropertyFunction +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "%TRUE if handled or %FALSE to to forward the request to the parent class or prototype chain.", sinceVersion = Nothing}, args = [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of delete_property in #JSCClassVTable. This is only required when you need to handle\nexternal properties not added to the prototype.", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_ClassDeletePropertyFunction = + Ptr JavaScriptCore.Class.Class -> + Ptr JavaScriptCore.Context.Context -> + Ptr () -> + CString -> + IO CInt + +-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_ClassDeletePropertyFunction :: FunPtr C_ClassDeletePropertyFunction -> C_ClassDeletePropertyFunction + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_ClassDeletePropertyFunction :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Class.IsClass a, JavaScriptCore.Context.IsContext b) => + FunPtr C_ClassDeletePropertyFunction + -> a + {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -} + -> b + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> Ptr () + {- ^ /@instance@/: the /@jscClass@/ instance -} + -> T.Text + {- ^ /@name@/: the property name -} + -> m Bool + {- ^ __Returns:__ 'True' if handled or 'False' to to forward the request to the parent class or prototype chain. -} +dynamic_ClassDeletePropertyFunction __funPtr jscClass context instance_ name = liftIO $ do + jscClass' <- unsafeManagedPtrCastPtr jscClass + context' <- unsafeManagedPtrCastPtr context + name' <- textToCString name + result <- (__dynamic_C_ClassDeletePropertyFunction __funPtr) jscClass' context' instance_ name' + let result' = (/= 0) result + touchManagedPtr jscClass + touchManagedPtr context + freeMem name' + return result' + +-- | Generate a function pointer callable from C code, from a `C_ClassDeletePropertyFunction`. +foreign import ccall "wrapper" + mk_ClassDeletePropertyFunction :: C_ClassDeletePropertyFunction -> IO (FunPtr C_ClassDeletePropertyFunction) + +{- | +The type of delete_property in 'GI.JavaScriptCore.Structs.ClassVTable.ClassVTable'. This is only required when you need to handle +external properties not added to the prototype. +-} +type ClassDeletePropertyFunction = + JavaScriptCore.Class.Class + {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -} + -> JavaScriptCore.Context.Context + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> Ptr () + {- ^ /@instance@/: the /@jscClass@/ instance -} + -> T.Text + {- ^ /@name@/: the property name -} + -> IO Bool + {- ^ __Returns:__ 'True' if handled or 'False' to to forward the request to the parent class or prototype chain. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ClassDeletePropertyFunction`@. +noClassDeletePropertyFunction :: Maybe ClassDeletePropertyFunction +noClassDeletePropertyFunction = Nothing + +-- | Wrap the callback into a `GClosure`. +genClosure_ClassDeletePropertyFunction :: MonadIO m => ClassDeletePropertyFunction -> m (GClosure C_ClassDeletePropertyFunction) +genClosure_ClassDeletePropertyFunction cb = liftIO $ do + let cb' = wrap_ClassDeletePropertyFunction Nothing cb + mk_ClassDeletePropertyFunction cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ClassDeletePropertyFunction` into a `C_ClassDeletePropertyFunction`. +wrap_ClassDeletePropertyFunction :: + Maybe (Ptr (FunPtr C_ClassDeletePropertyFunction)) -> + ClassDeletePropertyFunction -> + C_ClassDeletePropertyFunction +wrap_ClassDeletePropertyFunction funptrptr _cb jscClass context instance_ name = do + jscClass' <- (newObject JavaScriptCore.Class.Class) jscClass + context' <- (newObject JavaScriptCore.Context.Context) context + name' <- cstringToText name + result <- _cb jscClass' context' instance_ name' + maybeReleaseFunPtr funptrptr + let result' = (fromIntegral . fromEnum) result + return result' + + + diff --git a/GI/JavaScriptCore/Constants.hs b/GI/JavaScriptCore/Constants.hs new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Constants.hs @@ -0,0 +1,103 @@ +{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-} + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.JavaScriptCore.Constants + ( + pattern OPTIONS_USE_LLINT , + pattern OPTIONS_USE_JIT , + pattern OPTIONS_USE_FTL , + pattern OPTIONS_USE_DFG , + pattern MINOR_VERSION , + pattern MICRO_VERSION , + pattern MAJOR_VERSION , + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +{- | +Allows the LLINT to be used if 'True'. +Option type: 'GI.JavaScriptCore.Enums.OptionTypeBoolean' +Default value: 'True'. + +/Since: 2.24/ +-} +pattern OPTIONS_USE_LLINT = "useLLInt" :: T.Text + +{- | +Allows the executable pages to be allocated for JIT and thunks if 'True'. +Option type: 'GI.JavaScriptCore.Enums.OptionTypeBoolean' +Default value: 'True'. + +/Since: 2.24/ +-} +pattern OPTIONS_USE_JIT = "useJIT" :: T.Text + +{- | +Allows the FTL JIT to be used if 'True'. +Option type: 'GI.JavaScriptCore.Enums.OptionTypeBoolean' +Default value: 'True'. + +/Since: 2.24/ +-} +pattern OPTIONS_USE_FTL = "useFTLJIT" :: T.Text + +{- | +Allows the DFG JIT to be used if 'True'. +Option type: 'GI.JavaScriptCore.Enums.OptionTypeBoolean' +Default value: 'True'. + +/Since: 2.24/ +-} +pattern OPTIONS_USE_DFG = "useDFGJIT" :: T.Text + +{- | +Like 'GI.JavaScriptCore.Functions.getMinorVersion', but from the headers used at +application compile time, rather than from the library linked +against at application run time. +-} +pattern MINOR_VERSION = 24 :: Int32 + +{- | +Like 'GI.JavaScriptCore.Functions.getMicroVersion', but from the headers used at +application compile time, rather than from the library linked +against at application run time. +-} +pattern MICRO_VERSION = 2 :: Int32 + +{- | +Like 'GI.JavaScriptCore.Functions.getMajorVersion', but from the headers used at +application compile time, rather than from the library linked +against at application run time. +-} +pattern MAJOR_VERSION = 2 :: Int32 + + diff --git a/GI/JavaScriptCore/Enums.hs b/GI/JavaScriptCore/Enums.hs new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Enums.hs @@ -0,0 +1,199 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.JavaScriptCore.Enums + ( + + -- * Enumerations +-- ** CheckSyntaxMode #enum:CheckSyntaxMode# + + CheckSyntaxMode(..) , + + +-- ** CheckSyntaxResult #enum:CheckSyntaxResult# + + CheckSyntaxResult(..) , + + +-- ** OptionType #enum:OptionType# + + OptionType(..) , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- Enum OptionType +{- | +Enum values for options types. + +/Since: 2.24/ +-} +data OptionType = + OptionTypeBoolean + {- ^ + A 'Bool' option type. + -} + | OptionTypeInt + {- ^ + A @/gint/@ option type. + -} + | OptionTypeUint + {- ^ + A @/guint/@ option type. + -} + | OptionTypeSize + {- ^ + A @/gsize/@ options type. + -} + | OptionTypeDouble + {- ^ + A @/gdouble/@ options type. + -} + | OptionTypeString + {- ^ + A string option type. + -} + | OptionTypeRangeString + {- ^ + A range string option type. + -} + | AnotherOptionType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum OptionType where + fromEnum OptionTypeBoolean = 0 + fromEnum OptionTypeInt = 1 + fromEnum OptionTypeUint = 2 + fromEnum OptionTypeSize = 3 + fromEnum OptionTypeDouble = 4 + fromEnum OptionTypeString = 5 + fromEnum OptionTypeRangeString = 6 + fromEnum (AnotherOptionType k) = k + + toEnum 0 = OptionTypeBoolean + toEnum 1 = OptionTypeInt + toEnum 2 = OptionTypeUint + toEnum 3 = OptionTypeSize + toEnum 4 = OptionTypeDouble + toEnum 5 = OptionTypeString + toEnum 6 = OptionTypeRangeString + toEnum k = AnotherOptionType k + +instance P.Ord OptionType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum CheckSyntaxResult +{- | +Enum values to specify the result of 'GI.JavaScriptCore.Objects.Context.contextCheckSyntax'. +-} +data CheckSyntaxResult = + CheckSyntaxResultSuccess + {- ^ + no errors + -} + | CheckSyntaxResultRecoverableError + {- ^ + recoverable syntax error + -} + | CheckSyntaxResultIrrecoverableError + {- ^ + irrecoverable syntax error + -} + | CheckSyntaxResultUnterminatedLiteralError + {- ^ + unterminated literal error + -} + | CheckSyntaxResultOutOfMemoryError + {- ^ + out of memory error + -} + | CheckSyntaxResultStackOverflowError + {- ^ + stack overflow error + -} + | AnotherCheckSyntaxResult Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum CheckSyntaxResult where + fromEnum CheckSyntaxResultSuccess = 0 + fromEnum CheckSyntaxResultRecoverableError = 1 + fromEnum CheckSyntaxResultIrrecoverableError = 2 + fromEnum CheckSyntaxResultUnterminatedLiteralError = 3 + fromEnum CheckSyntaxResultOutOfMemoryError = 4 + fromEnum CheckSyntaxResultStackOverflowError = 5 + fromEnum (AnotherCheckSyntaxResult k) = k + + toEnum 0 = CheckSyntaxResultSuccess + toEnum 1 = CheckSyntaxResultRecoverableError + toEnum 2 = CheckSyntaxResultIrrecoverableError + toEnum 3 = CheckSyntaxResultUnterminatedLiteralError + toEnum 4 = CheckSyntaxResultOutOfMemoryError + toEnum 5 = CheckSyntaxResultStackOverflowError + toEnum k = AnotherCheckSyntaxResult k + +instance P.Ord CheckSyntaxResult where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum CheckSyntaxMode +{- | +Enum values to specify a mode to check for syntax errors in 'GI.JavaScriptCore.Objects.Context.contextCheckSyntax'. +-} +data CheckSyntaxMode = + CheckSyntaxModeScript + {- ^ + mode to check syntax of a script + -} + | CheckSyntaxModeModule + {- ^ + mode to check syntax of a module + -} + | AnotherCheckSyntaxMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum CheckSyntaxMode where + fromEnum CheckSyntaxModeScript = 0 + fromEnum CheckSyntaxModeModule = 1 + fromEnum (AnotherCheckSyntaxMode k) = k + + toEnum 0 = CheckSyntaxModeScript + toEnum 1 = CheckSyntaxModeModule + toEnum k = AnotherCheckSyntaxMode k + +instance P.Ord CheckSyntaxMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + + diff --git a/GI/JavaScriptCore/Enums.hs-boot b/GI/JavaScriptCore/Enums.hs-boot new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Enums.hs-boot @@ -0,0 +1,30 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.JavaScriptCore.Enums where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +data OptionType +instance P.Enum OptionType where +data CheckSyntaxResult +instance P.Enum CheckSyntaxResult where +data CheckSyntaxMode +instance P.Enum CheckSyntaxMode where diff --git a/GI/JavaScriptCore/Flags.hs b/GI/JavaScriptCore/Flags.hs new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Flags.hs @@ -0,0 +1,87 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.JavaScriptCore.Flags + ( + + -- * Flags +-- ** ValuePropertyFlags #flag:ValuePropertyFlags# + + ValuePropertyFlags(..) , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- Flags ValuePropertyFlags +{- | +Flags used when defining properties with 'GI.JavaScriptCore.Objects.Value.valueObjectDefinePropertyData' and +'GI.JavaScriptCore.Objects.Value.valueObjectDefinePropertyAccessor'. +-} +data ValuePropertyFlags = + ValuePropertyFlagsConfigurable + {- ^ + the type of the property descriptor may be changed and the + property may be deleted from the corresponding object. + -} + | ValuePropertyFlagsEnumerable + {- ^ + the property shows up during enumeration of the properties on + the corresponding object. + -} + | ValuePropertyFlagsWritable + {- ^ + the value associated with the property may be changed with an + assignment operator. This doesn\'t have any effect when passed to 'GI.JavaScriptCore.Objects.Value.valueObjectDefinePropertyAccessor'. + -} + | AnotherValuePropertyFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum ValuePropertyFlags where + fromEnum ValuePropertyFlagsConfigurable = 1 + fromEnum ValuePropertyFlagsEnumerable = 2 + fromEnum ValuePropertyFlagsWritable = 4 + fromEnum (AnotherValuePropertyFlags k) = k + + toEnum 1 = ValuePropertyFlagsConfigurable + toEnum 2 = ValuePropertyFlagsEnumerable + toEnum 4 = ValuePropertyFlagsWritable + toEnum k = AnotherValuePropertyFlags k + +instance P.Ord ValuePropertyFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag ValuePropertyFlags + + diff --git a/GI/JavaScriptCore/Flags.hs-boot b/GI/JavaScriptCore/Flags.hs-boot new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Flags.hs-boot @@ -0,0 +1,27 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.JavaScriptCore.Flags where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +data ValuePropertyFlags +instance P.Enum ValuePropertyFlags where +instance IsGFlag ValuePropertyFlags diff --git a/GI/JavaScriptCore/Functions.hs b/GI/JavaScriptCore/Functions.hs new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Functions.hs @@ -0,0 +1,772 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.JavaScriptCore.Functions + ( + + -- * Methods +-- ** getMajorVersion #method:getMajorVersion# + + getMajorVersion , + + +-- ** getMicroVersion #method:getMicroVersion# + + getMicroVersion , + + +-- ** getMinorVersion #method:getMinorVersion# + + getMinorVersion , + + +-- ** optionsForeach #method:optionsForeach# + + optionsForeach , + + +-- ** optionsGetBoolean #method:optionsGetBoolean# + + optionsGetBoolean , + + +-- ** optionsGetDouble #method:optionsGetDouble# + + optionsGetDouble , + + +-- ** optionsGetInt #method:optionsGetInt# + + optionsGetInt , + + +-- ** optionsGetOptionGroup #method:optionsGetOptionGroup# + + optionsGetOptionGroup , + + +-- ** optionsGetRangeString #method:optionsGetRangeString# + + optionsGetRangeString , + + +-- ** optionsGetSize #method:optionsGetSize# + + optionsGetSize , + + +-- ** optionsGetString #method:optionsGetString# + + optionsGetString , + + +-- ** optionsGetUint #method:optionsGetUint# + + optionsGetUint , + + +-- ** optionsSetBoolean #method:optionsSetBoolean# + + optionsSetBoolean , + + +-- ** optionsSetDouble #method:optionsSetDouble# + + optionsSetDouble , + + +-- ** optionsSetInt #method:optionsSetInt# + + optionsSetInt , + + +-- ** optionsSetRangeString #method:optionsSetRangeString# + + optionsSetRangeString , + + +-- ** optionsSetSize #method:optionsSetSize# + + optionsSetSize , + + +-- ** optionsSetString #method:optionsSetString# + + optionsSetString , + + +-- ** optionsSetUint #method:optionsSetUint# + + optionsSetUint , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GLib.Structs.OptionGroup as GLib.OptionGroup +import qualified GI.JavaScriptCore.Callbacks as JavaScriptCore.Callbacks + +-- function jsc_options_set_uint +-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_options_set_uint" jsc_options_set_uint :: + CString -> -- option : TBasicType TUTF8 + Word32 -> -- value : TBasicType TUInt + IO CInt + +{- | +Set /@option@/ as a @/guint/@ value. + +/Since: 2.24/ +-} +optionsSetUint :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@option@/: the option identifier -} + -> Word32 + {- ^ /@value@/: the value to set -} + -> m Bool + {- ^ __Returns:__ 'True' if option was correctly set or 'False' otherwise. -} +optionsSetUint option value = liftIO $ do + option' <- textToCString option + result <- jsc_options_set_uint option' value + let result' = (/= 0) result + freeMem option' + return result' + + +-- function jsc_options_set_string +-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_options_set_string" jsc_options_set_string :: + CString -> -- option : TBasicType TUTF8 + CString -> -- value : TBasicType TUTF8 + IO CInt + +{- | +Set /@option@/ as a string. + +/Since: 2.24/ +-} +optionsSetString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@option@/: the option identifier -} + -> T.Text + {- ^ /@value@/: the value to set -} + -> m Bool + {- ^ __Returns:__ 'True' if option was correctly set or 'False' otherwise. -} +optionsSetString option value = liftIO $ do + option' <- textToCString option + value' <- textToCString value + result <- jsc_options_set_string option' value' + let result' = (/= 0) result + freeMem option' + freeMem value' + return result' + + +-- function jsc_options_set_size +-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_options_set_size" jsc_options_set_size :: + CString -> -- option : TBasicType TUTF8 + Word64 -> -- value : TBasicType TUInt64 + IO CInt + +{- | +Set /@option@/ as a @/gsize/@ value. + +/Since: 2.24/ +-} +optionsSetSize :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@option@/: the option identifier -} + -> Word64 + {- ^ /@value@/: the value to set -} + -> m Bool + {- ^ __Returns:__ 'True' if option was correctly set or 'False' otherwise. -} +optionsSetSize option value = liftIO $ do + option' <- textToCString option + result <- jsc_options_set_size option' value + let result' = (/= 0) result + freeMem option' + return result' + + +-- function jsc_options_set_range_string +-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_options_set_range_string" jsc_options_set_range_string :: + CString -> -- option : TBasicType TUTF8 + CString -> -- value : TBasicType TUTF8 + IO CInt + +{- | +Set /@option@/ as a range string. The string must be in the +format \[!]<low>[:<high>]\<\/emphasis> where low and high are @/guint/@ values. +Values between low and high (both included) will be considered in +the range, unless \!\<\/emphasis> is used to invert the range. + +/Since: 2.24/ +-} +optionsSetRangeString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@option@/: the option identifier -} + -> T.Text + {- ^ /@value@/: the value to set -} + -> m Bool + {- ^ __Returns:__ 'True' if option was correctly set or 'False' otherwise. -} +optionsSetRangeString option value = liftIO $ do + option' <- textToCString option + value' <- textToCString value + result <- jsc_options_set_range_string option' value' + let result' = (/= 0) result + freeMem option' + freeMem value' + return result' + + +-- function jsc_options_set_int +-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_options_set_int" jsc_options_set_int :: + CString -> -- option : TBasicType TUTF8 + Int32 -> -- value : TBasicType TInt + IO CInt + +{- | +Set /@option@/ as a @/gint/@ value. + +/Since: 2.24/ +-} +optionsSetInt :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@option@/: the option identifier -} + -> Int32 + {- ^ /@value@/: the value to set -} + -> m Bool + {- ^ __Returns:__ 'True' if option was correctly set or 'False' otherwise. -} +optionsSetInt option value = liftIO $ do + option' <- textToCString option + result <- jsc_options_set_int option' value + let result' = (/= 0) result + freeMem option' + return result' + + +-- function jsc_options_set_double +-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_options_set_double" jsc_options_set_double :: + CString -> -- option : TBasicType TUTF8 + CDouble -> -- value : TBasicType TDouble + IO CInt + +{- | +Set /@option@/ as a @/gdouble/@ value. + +/Since: 2.24/ +-} +optionsSetDouble :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@option@/: the option identifier -} + -> Double + {- ^ /@value@/: the value to set -} + -> m Bool + {- ^ __Returns:__ 'True' if option was correctly set or 'False' otherwise. -} +optionsSetDouble option value = liftIO $ do + option' <- textToCString option + let value' = realToFrac value + result <- jsc_options_set_double option' value' + let result' = (/= 0) result + freeMem option' + return result' + + +-- function jsc_options_set_boolean +-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_options_set_boolean" jsc_options_set_boolean :: + CString -> -- option : TBasicType TUTF8 + CInt -> -- value : TBasicType TBoolean + IO CInt + +{- | +Set /@option@/ as a 'Bool' value. + +/Since: 2.24/ +-} +optionsSetBoolean :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@option@/: the option identifier -} + -> Bool + {- ^ /@value@/: the value to set -} + -> m Bool + {- ^ __Returns:__ 'True' if option was correctly set or 'False' otherwise. -} +optionsSetBoolean option value = liftIO $ do + option' <- textToCString option + let value' = (fromIntegral . fromEnum) value + result <- jsc_options_set_boolean option' value' + let result' = (/= 0) result + freeMem option' + return result' + + +-- function jsc_options_get_uint +-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the option value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_options_get_uint" jsc_options_get_uint :: + CString -> -- option : TBasicType TUTF8 + Ptr Word32 -> -- value : TBasicType TUInt + IO CInt + +{- | +Get /@option@/ as a @/guint/@ value. + +/Since: 2.24/ +-} +optionsGetUint :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@option@/: the option identifier -} + -> m ((Bool, Word32)) + {- ^ __Returns:__ 'True' if /@value@/ has been set or 'False' if the option doesn\'t exist -} +optionsGetUint option = liftIO $ do + option' <- textToCString option + value <- allocMem :: IO (Ptr Word32) + result <- jsc_options_get_uint option' value + let result' = (/= 0) result + value' <- peek value + freeMem option' + freeMem value + return (result', value') + + +-- function jsc_options_get_string +-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the option value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_options_get_string" jsc_options_get_string :: + CString -> -- option : TBasicType TUTF8 + Ptr CString -> -- value : TBasicType TUTF8 + IO CInt + +{- | +Get /@option@/ as a string. + +/Since: 2.24/ +-} +optionsGetString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@option@/: the option identifier -} + -> m ((Bool, T.Text)) + {- ^ __Returns:__ 'True' if /@value@/ has been set or 'False' if the option doesn\'t exist -} +optionsGetString option = liftIO $ do + option' <- textToCString option + value <- allocMem :: IO (Ptr CString) + result <- jsc_options_get_string option' value + let result' = (/= 0) result + value' <- peek value + value'' <- cstringToText value' + freeMem value' + freeMem option' + freeMem value + return (result', value'') + + +-- function jsc_options_get_size +-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the option value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_options_get_size" jsc_options_get_size :: + CString -> -- option : TBasicType TUTF8 + Ptr Word64 -> -- value : TBasicType TUInt64 + IO CInt + +{- | +Get /@option@/ as a @/gsize/@ value. + +/Since: 2.24/ +-} +optionsGetSize :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@option@/: the option identifier -} + -> m ((Bool, Word64)) + {- ^ __Returns:__ 'True' if /@value@/ has been set or 'False' if the option doesn\'t exist -} +optionsGetSize option = liftIO $ do + option' <- textToCString option + value <- allocMem :: IO (Ptr Word64) + result <- jsc_options_get_size option' value + let result' = (/= 0) result + value' <- peek value + freeMem option' + freeMem value + return (result', value') + + +-- function jsc_options_get_range_string +-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the option value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_options_get_range_string" jsc_options_get_range_string :: + CString -> -- option : TBasicType TUTF8 + Ptr CString -> -- value : TBasicType TUTF8 + IO CInt + +{- | +Get /@option@/ as a range string. The string must be in the +format \[!]<low>[:<high>]\<\/emphasis> where low and high are @/guint/@ values. +Values between low and high (both included) will be considered in +the range, unless \!\<\/emphasis> is used to invert the range. + +/Since: 2.24/ +-} +optionsGetRangeString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@option@/: the option identifier -} + -> m ((Bool, T.Text)) + {- ^ __Returns:__ 'True' if /@value@/ has been set or 'False' if the option doesn\'t exist -} +optionsGetRangeString option = liftIO $ do + option' <- textToCString option + value <- allocMem :: IO (Ptr CString) + result <- jsc_options_get_range_string option' value + let result' = (/= 0) result + value' <- peek value + value'' <- cstringToText value' + freeMem value' + freeMem option' + freeMem value + return (result', value'') + + +-- function jsc_options_get_option_group +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GLib", name = "OptionGroup"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_options_get_option_group" jsc_options_get_option_group :: + IO (Ptr GLib.OptionGroup.OptionGroup) + +{- | +Create a 'GI.GLib.Structs.OptionGroup.OptionGroup' to handle JSCOptions as command line arguments. +The options will be exposed as command line arguments with the form +\--jsc-<option>=<value>\<\/emphasis>. +Each entry in the returned 'GI.GLib.Structs.OptionGroup.OptionGroup' is configured to apply the +corresponding option during command line parsing. Applications only need to +pass the returned group to 'GI.GLib.Structs.OptionContext.optionContextAddGroup', and the rest will +be taken care for automatically. + +/Since: 2.24/ +-} +optionsGetOptionGroup :: + (B.CallStack.HasCallStack, MonadIO m) => + m GLib.OptionGroup.OptionGroup + {- ^ __Returns:__ a 'GI.GLib.Structs.OptionGroup.OptionGroup' for the JSCOptions -} +optionsGetOptionGroup = liftIO $ do + result <- jsc_options_get_option_group + checkUnexpectedReturnNULL "optionsGetOptionGroup" result + result' <- (wrapBoxed GLib.OptionGroup.OptionGroup) result + return result' + + +-- function jsc_options_get_int +-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the option value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_options_get_int" jsc_options_get_int :: + CString -> -- option : TBasicType TUTF8 + Ptr Int32 -> -- value : TBasicType TInt + IO CInt + +{- | +Get /@option@/ as a @/gint/@ value. + +/Since: 2.24/ +-} +optionsGetInt :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@option@/: the option identifier -} + -> m ((Bool, Int32)) + {- ^ __Returns:__ 'True' if /@value@/ has been set or 'False' if the option doesn\'t exist -} +optionsGetInt option = liftIO $ do + option' <- textToCString option + value <- allocMem :: IO (Ptr Int32) + result <- jsc_options_get_int option' value + let result' = (/= 0) result + value' <- peek value + freeMem option' + freeMem value + return (result', value') + + +-- function jsc_options_get_double +-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the option value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_options_get_double" jsc_options_get_double :: + CString -> -- option : TBasicType TUTF8 + Ptr CDouble -> -- value : TBasicType TDouble + IO CInt + +{- | +Get /@option@/ as a @/gdouble/@ value. + +/Since: 2.24/ +-} +optionsGetDouble :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@option@/: the option identifier -} + -> m ((Bool, Double)) + {- ^ __Returns:__ 'True' if /@value@/ has been set or 'False' if the option doesn\'t exist -} +optionsGetDouble option = liftIO $ do + option' <- textToCString option + value <- allocMem :: IO (Ptr CDouble) + result <- jsc_options_get_double option' value + let result' = (/= 0) result + value' <- peek value + let value'' = realToFrac value' + freeMem option' + freeMem value + return (result', value'') + + +-- function jsc_options_get_boolean +-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the option value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_options_get_boolean" jsc_options_get_boolean :: + CString -> -- option : TBasicType TUTF8 + Ptr CInt -> -- value : TBasicType TBoolean + IO CInt + +{- | +Get /@option@/ as a 'Bool' value. + +/Since: 2.24/ +-} +optionsGetBoolean :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@option@/: the option identifier -} + -> m ((Bool, Bool)) + {- ^ __Returns:__ 'True' if /@value@/ has been set or 'False' if the option doesn\'t exist -} +optionsGetBoolean option = liftIO $ do + option' <- textToCString option + value <- allocMem :: IO (Ptr CInt) + result <- jsc_options_get_boolean option' value + let result' = (/= 0) result + value' <- peek value + let value'' = (/= 0) value' + freeMem option' + freeMem value + return (result', value'') + + +-- function jsc_options_foreach +-- Args : [Arg {argCName = "function", argType = TInterface (Name {namespace = "JavaScriptCore", name = "OptionsFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCOptionsFunc callback", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback user data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_options_foreach" jsc_options_foreach :: + FunPtr JavaScriptCore.Callbacks.C_OptionsFunc -> -- function : TInterface (Name {namespace = "JavaScriptCore", name = "OptionsFunc"}) + Ptr () -> -- user_data : TBasicType TPtr + IO () + +{- | +Iterates all available options calling /@function@/ for each one. Iteration can +stop early if /@function@/ returns 'False'. + +/Since: 2.24/ +-} +optionsForeach :: + (B.CallStack.HasCallStack, MonadIO m) => + JavaScriptCore.Callbacks.OptionsFunc + {- ^ /@function@/: a 'GI.JavaScriptCore.Callbacks.OptionsFunc' callback -} + -> m () +optionsForeach function = liftIO $ do + function' <- JavaScriptCore.Callbacks.mk_OptionsFunc (JavaScriptCore.Callbacks.wrap_OptionsFunc Nothing (JavaScriptCore.Callbacks.drop_closures_OptionsFunc function)) + let userData = nullPtr + jsc_options_foreach function' userData + safeFreeFunPtr $ castFunPtrToPtr function' + return () + + +-- function jsc_get_minor_version +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_get_minor_version" jsc_get_minor_version :: + IO Word32 + +{- | +Returns the minor version number of the JavaScriptCore library. +(e.g. in JavaScriptCore version 1.8.3 this is 8.) + +This function is in the library, so it represents the JavaScriptCore library +your code is running against. Contrast with the 'GI.JavaScriptCore.Constants.MINOR_VERSION' +macro, which represents the minor version of the JavaScriptCore headers you +have included when compiling your code. +-} +getMinorVersion :: + (B.CallStack.HasCallStack, MonadIO m) => + m Word32 + {- ^ __Returns:__ the minor version number of the JavaScriptCore library -} +getMinorVersion = liftIO $ do + result <- jsc_get_minor_version + return result + + +-- function jsc_get_micro_version +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_get_micro_version" jsc_get_micro_version :: + IO Word32 + +{- | +Returns the micro version number of the JavaScriptCore library. +(e.g. in JavaScriptCore version 1.8.3 this is 3.) + +This function is in the library, so it represents the JavaScriptCore library +your code is running against. Contrast with the 'GI.JavaScriptCore.Constants.MICRO_VERSION' +macro, which represents the micro version of the JavaScriptCore headers you +have included when compiling your code. +-} +getMicroVersion :: + (B.CallStack.HasCallStack, MonadIO m) => + m Word32 + {- ^ __Returns:__ the micro version number of the JavaScriptCore library -} +getMicroVersion = liftIO $ do + result <- jsc_get_micro_version + return result + + +-- function jsc_get_major_version +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_get_major_version" jsc_get_major_version :: + IO Word32 + +{- | +Returns the major version number of the JavaScriptCore library. +(e.g. in JavaScriptCore version 1.8.3 this is 1.) + +This function is in the library, so it represents the JavaScriptCore library +your code is running against. Contrast with the 'GI.JavaScriptCore.Constants.MAJOR_VERSION' +macro, which represents the major version of the JavaScriptCore headers you +have included when compiling your code. +-} +getMajorVersion :: + (B.CallStack.HasCallStack, MonadIO m) => + m Word32 + {- ^ __Returns:__ the major version number of the JavaScriptCore library -} +getMajorVersion = liftIO $ do + result <- jsc_get_major_version + return result + + + diff --git a/GI/JavaScriptCore/Objects.hs b/GI/JavaScriptCore/Objects.hs new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Objects.hs @@ -0,0 +1,51 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.JavaScriptCore.Objects + ( module GI.JavaScriptCore.Objects.Class , + module GI.JavaScriptCore.Objects.Context, + module GI.JavaScriptCore.Objects.Exception, + module GI.JavaScriptCore.Objects.Value , + module GI.JavaScriptCore.Objects.VirtualMachine, + module GI.JavaScriptCore.Objects.WeakValue, + + + ) where + +import GI.JavaScriptCore.Objects.Class +import GI.JavaScriptCore.Objects.Context +import GI.JavaScriptCore.Objects.Exception +import GI.JavaScriptCore.Objects.Value +import GI.JavaScriptCore.Objects.VirtualMachine +import GI.JavaScriptCore.Objects.WeakValue + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + + diff --git a/GI/JavaScriptCore/Objects/Class.hs b/GI/JavaScriptCore/Objects/Class.hs new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Objects/Class.hs @@ -0,0 +1,772 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.JavaScriptCore.Objects.Class + ( + +-- * Exported types + Class(..) , + IsClass , + toClass , + noClass , + + + -- * Methods +-- ** addConstructor #method:addConstructor# + +#if ENABLE_OVERLOADING + ClassAddConstructorMethodInfo , +#endif + classAddConstructor , + + +-- ** addConstructorVariadic #method:addConstructorVariadic# + +#if ENABLE_OVERLOADING + ClassAddConstructorVariadicMethodInfo , +#endif + classAddConstructorVariadic , + + +-- ** addMethod #method:addMethod# + +#if ENABLE_OVERLOADING + ClassAddMethodMethodInfo , +#endif + classAddMethod , + + +-- ** addMethodVariadic #method:addMethodVariadic# + +#if ENABLE_OVERLOADING + ClassAddMethodVariadicMethodInfo , +#endif + classAddMethodVariadic , + + +-- ** addProperty #method:addProperty# + +#if ENABLE_OVERLOADING + ClassAddPropertyMethodInfo , +#endif + classAddProperty , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + ClassGetNameMethodInfo , +#endif + classGetName , + + +-- ** getParent #method:getParent# + +#if ENABLE_OVERLOADING + ClassGetParentMethodInfo , +#endif + classGetParent , + + + + + -- * Properties +-- ** context #attr:context# +{- | The 'GI.JavaScriptCore.Objects.Context.Context' in which the class was registered. +-} +#if ENABLE_OVERLOADING + ClassContextPropertyInfo , +#endif +#if ENABLE_OVERLOADING + classContext , +#endif + constructClassContext , + getClassContext , + + +-- ** name #attr:name# +{- | The name of the class. +-} +#if ENABLE_OVERLOADING + ClassNamePropertyInfo , +#endif +#if ENABLE_OVERLOADING + className , +#endif + constructClassName , + getClassName , + + +-- ** parent #attr:parent# +{- | The parent class or 'Nothing' in case of final classes. +-} +#if ENABLE_OVERLOADING + ClassParentPropertyInfo , +#endif +#if ENABLE_OVERLOADING + classParent , +#endif + constructClassParent , + getClassParent , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GObject.Callbacks as GObject.Callbacks +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Context as JavaScriptCore.Context +import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Value as JavaScriptCore.Value + +-- | Memory-managed wrapper type. +newtype Class = Class (ManagedPtr Class) +foreign import ccall "jsc_class_get_type" + c_jsc_class_get_type :: IO GType + +instance GObject Class where + gobjectType = c_jsc_class_get_type + + +-- | Type class for types which can be safely cast to `Class`, for instance with `toClass`. +class (GObject o, O.IsDescendantOf Class o) => IsClass o +instance (GObject o, O.IsDescendantOf Class o) => IsClass o + +instance O.HasParentTypes Class +type instance O.ParentTypes Class = '[GObject.Object.Object] + +-- | Cast to `Class`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toClass :: (MonadIO m, IsClass o) => o -> m Class +toClass = liftIO . unsafeCastTo Class + +-- | A convenience alias for `Nothing` :: `Maybe` `Class`. +noClass :: Maybe Class +noClass = Nothing + +#if ENABLE_OVERLOADING +type family ResolveClassMethod (t :: Symbol) (o :: *) :: * where + ResolveClassMethod "addConstructor" o = ClassAddConstructorMethodInfo + ResolveClassMethod "addConstructorVariadic" o = ClassAddConstructorVariadicMethodInfo + ResolveClassMethod "addMethod" o = ClassAddMethodMethodInfo + ResolveClassMethod "addMethodVariadic" o = ClassAddMethodVariadicMethodInfo + ResolveClassMethod "addProperty" o = ClassAddPropertyMethodInfo + ResolveClassMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveClassMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveClassMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveClassMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveClassMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveClassMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveClassMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveClassMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveClassMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveClassMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveClassMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveClassMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveClassMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveClassMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveClassMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveClassMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveClassMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveClassMethod "getName" o = ClassGetNameMethodInfo + ResolveClassMethod "getParent" o = ClassGetParentMethodInfo + ResolveClassMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveClassMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveClassMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveClassMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveClassMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveClassMethod t Class, O.MethodInfo info Class p) => OL.IsLabel t (Class -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- VVV Prop "context" + -- Type: TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@context@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' class #context +@ +-} +getClassContext :: (MonadIO m, IsClass o) => o -> m (Maybe JavaScriptCore.Context.Context) +getClassContext obj = liftIO $ B.Properties.getObjectPropertyObject obj "context" JavaScriptCore.Context.Context + +{- | +Construct a `GValueConstruct` with valid value for the “@context@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructClassContext :: (IsClass o, JavaScriptCore.Context.IsContext a) => a -> IO (GValueConstruct o) +constructClassContext val = B.Properties.constructObjectPropertyObject "context" (Just val) + +#if ENABLE_OVERLOADING +data ClassContextPropertyInfo +instance AttrInfo ClassContextPropertyInfo where + type AttrAllowedOps ClassContextPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ClassContextPropertyInfo = JavaScriptCore.Context.IsContext + type AttrBaseTypeConstraint ClassContextPropertyInfo = IsClass + type AttrGetType ClassContextPropertyInfo = (Maybe JavaScriptCore.Context.Context) + type AttrLabel ClassContextPropertyInfo = "context" + type AttrOrigin ClassContextPropertyInfo = Class + attrGet _ = getClassContext + attrSet _ = undefined + attrConstruct _ = constructClassContext + attrClear _ = undefined +#endif + +-- VVV Prop "name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' class #name +@ +-} +getClassName :: (MonadIO m, IsClass o) => o -> m T.Text +getClassName obj = liftIO $ checkUnexpectedNothing "getClassName" $ B.Properties.getObjectPropertyString obj "name" + +{- | +Construct a `GValueConstruct` with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructClassName :: (IsClass o) => T.Text -> IO (GValueConstruct o) +constructClassName val = B.Properties.constructObjectPropertyString "name" (Just val) + +#if ENABLE_OVERLOADING +data ClassNamePropertyInfo +instance AttrInfo ClassNamePropertyInfo where + type AttrAllowedOps ClassNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ClassNamePropertyInfo = (~) T.Text + type AttrBaseTypeConstraint ClassNamePropertyInfo = IsClass + type AttrGetType ClassNamePropertyInfo = T.Text + type AttrLabel ClassNamePropertyInfo = "name" + type AttrOrigin ClassNamePropertyInfo = Class + attrGet _ = getClassName + attrSet _ = undefined + attrConstruct _ = constructClassName + attrClear _ = undefined +#endif + +-- VVV Prop "parent" + -- Type: TInterface (Name {namespace = "JavaScriptCore", name = "Class"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@parent@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' class #parent +@ +-} +getClassParent :: (MonadIO m, IsClass o) => o -> m Class +getClassParent obj = liftIO $ checkUnexpectedNothing "getClassParent" $ B.Properties.getObjectPropertyObject obj "parent" Class + +{- | +Construct a `GValueConstruct` with valid value for the “@parent@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructClassParent :: (IsClass o, IsClass a) => a -> IO (GValueConstruct o) +constructClassParent val = B.Properties.constructObjectPropertyObject "parent" (Just val) + +#if ENABLE_OVERLOADING +data ClassParentPropertyInfo +instance AttrInfo ClassParentPropertyInfo where + type AttrAllowedOps ClassParentPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ClassParentPropertyInfo = IsClass + type AttrBaseTypeConstraint ClassParentPropertyInfo = IsClass + type AttrGetType ClassParentPropertyInfo = Class + type AttrLabel ClassParentPropertyInfo = "parent" + type AttrOrigin ClassParentPropertyInfo = Class + attrGet _ = getClassParent + attrSet _ = undefined + attrConstruct _ = constructClassParent + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Class +type instance O.AttributeList Class = ClassAttributeList +type ClassAttributeList = ('[ '("context", ClassContextPropertyInfo), '("name", ClassNamePropertyInfo), '("parent", ClassParentPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +classContext :: AttrLabelProxy "context" +classContext = AttrLabelProxy + +className :: AttrLabelProxy "name" +className = AttrLabelProxy + +classParent :: AttrLabelProxy "parent" +classParent = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Class = ClassSignalList +type ClassSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Class::add_constructor_variadic +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the constructor name or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GCallback to be called to create an instance of @jsc_class", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of the constructor return value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_class_add_constructor_variadic" jsc_class_add_constructor_variadic :: + Ptr Class -> -- jsc_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"}) + CString -> -- name : TBasicType TUTF8 + FunPtr GObject.Callbacks.C_Callback -> -- callback : TInterface (Name {namespace = "GObject", name = "Callback"}) + Ptr () -> -- user_data : TBasicType TPtr + FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + CGType -> -- return_type : TBasicType TGType + IO (Ptr JavaScriptCore.Value.Value) + +{- | +Add a constructor to /@jscClass@/. If /@name@/ is 'Nothing', the class name will be used. When \new\<\/function> +is used with the constructor or @/jsc_value_constructor_call()/@ is called, /@callback@/ is invoked receiving +a 'GI.GLib.Structs.PtrArray.PtrArray' of 'GI.JavaScriptCore.Objects.Value.Value'\s as arguments and /@userData@/ as the last parameter. When the constructor object +is cleared in the 'GI.JavaScriptCore.Objects.Class.Class' context, /@destroyNotify@/ is called with /@userData@/ as parameter. + +This function creates the constructor, which needs to be added to an object as a property to be able to use it. Use +'GI.JavaScriptCore.Objects.Context.contextSetValue' to make the constructor available in the global object. + +Note that the value returned by /@callback@/ is adopted by /@jscClass@/, and the 'GI.GLib.Callbacks.DestroyNotify' passed to +'GI.JavaScriptCore.Objects.Context.contextRegisterClass' is responsible for disposing of it. +-} +classAddConstructorVariadic :: + (B.CallStack.HasCallStack, MonadIO m, IsClass a) => + a + {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -} + -> Maybe (T.Text) + {- ^ /@name@/: the constructor name or 'Nothing' -} + -> GObject.Callbacks.Callback + {- ^ /@callback@/: a 'GI.GObject.Callbacks.Callback' to be called to create an instance of /@jscClass@/ -} + -> GType + {- ^ /@returnType@/: the 'GType' of the constructor return value -} + -> m JavaScriptCore.Value.Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' representing the class constructor. -} +classAddConstructorVariadic jscClass name callback returnType = liftIO $ do + jscClass' <- unsafeManagedPtrCastPtr jscClass + maybeName <- case name of + Nothing -> return nullPtr + Just jName -> do + jName' <- textToCString jName + return jName' + callback' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback Nothing callback) + let returnType' = gtypeToCGType returnType + let userData = castFunPtrToPtr callback' + let destroyNotify = safeFreeFunPtrPtr + result <- jsc_class_add_constructor_variadic jscClass' maybeName callback' userData destroyNotify returnType' + checkUnexpectedReturnNULL "classAddConstructorVariadic" result + result' <- (wrapObject JavaScriptCore.Value.Value) result + touchManagedPtr jscClass + freeMem maybeName + return result' + +#if ENABLE_OVERLOADING +data ClassAddConstructorVariadicMethodInfo +instance (signature ~ (Maybe (T.Text) -> GObject.Callbacks.Callback -> GType -> m JavaScriptCore.Value.Value), MonadIO m, IsClass a) => O.MethodInfo ClassAddConstructorVariadicMethodInfo a signature where + overloadedMethod _ = classAddConstructorVariadic + +#endif + +-- method Class::add_constructor +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the constructor name or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GCallback to be called to create an instance of @jsc_class", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of the constructor return value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameter_types", argType = TCArray False (-1) 6 (TBasicType TGType), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a list of #GTypes, one for each parameter, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_class_add_constructorv" jsc_class_add_constructorv :: + Ptr Class -> -- jsc_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"}) + CString -> -- name : TBasicType TUTF8 + FunPtr GObject.Callbacks.C_Callback -> -- callback : TInterface (Name {namespace = "GObject", name = "Callback"}) + Ptr () -> -- user_data : TBasicType TPtr + FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + CGType -> -- return_type : TBasicType TGType + Word32 -> -- n_parameters : TBasicType TUInt + Ptr CGType -> -- parameter_types : TCArray False (-1) 6 (TBasicType TGType) + IO (Ptr JavaScriptCore.Value.Value) + +{- | +Add a constructor to /@jscClass@/. If /@name@/ is 'Nothing', the class name will be used. When \new\<\/function> +is used with the constructor or @/jsc_value_constructor_call()/@ is called, /@callback@/ is invoked receiving the +parameters and /@userData@/ as the last parameter. When the constructor object is cleared in the 'GI.JavaScriptCore.Objects.Class.Class' context, +/@destroyNotify@/ is called with /@userData@/ as parameter. + +This function creates the constructor, which needs to be added to an object as a property to be able to use it. Use +'GI.JavaScriptCore.Objects.Context.contextSetValue' to make the constructor available in the global object. + +Note that the value returned by /@callback@/ is adopted by /@jscClass@/, and the 'GI.GLib.Callbacks.DestroyNotify' passed to +'GI.JavaScriptCore.Objects.Context.contextRegisterClass' is responsible for disposing of it. +-} +classAddConstructor :: + (B.CallStack.HasCallStack, MonadIO m, IsClass a) => + a + {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -} + -> Maybe (T.Text) + {- ^ /@name@/: the constructor name or 'Nothing' -} + -> GObject.Callbacks.Callback + {- ^ /@callback@/: a 'GI.GObject.Callbacks.Callback' to be called to create an instance of /@jscClass@/ -} + -> GType + {- ^ /@returnType@/: the 'GType' of the constructor return value -} + -> Maybe ([GType]) + {- ^ /@parameterTypes@/: a list of 'GType'\s, one for each parameter, or 'Nothing' -} + -> m JavaScriptCore.Value.Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' representing the class constructor. -} +classAddConstructor jscClass name callback returnType parameterTypes = liftIO $ do + let nParameters = case parameterTypes of + Nothing -> 0 + Just jParameterTypes -> fromIntegral $ length jParameterTypes + jscClass' <- unsafeManagedPtrCastPtr jscClass + maybeName <- case name of + Nothing -> return nullPtr + Just jName -> do + jName' <- textToCString jName + return jName' + callback' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback Nothing callback) + let returnType' = gtypeToCGType returnType + maybeParameterTypes <- case parameterTypes of + Nothing -> return nullPtr + Just jParameterTypes -> do + jParameterTypes' <- (packMapStorableArray gtypeToCGType) jParameterTypes + return jParameterTypes' + let userData = castFunPtrToPtr callback' + let destroyNotify = safeFreeFunPtrPtr + result <- jsc_class_add_constructorv jscClass' maybeName callback' userData destroyNotify returnType' nParameters maybeParameterTypes + checkUnexpectedReturnNULL "classAddConstructor" result + result' <- (wrapObject JavaScriptCore.Value.Value) result + touchManagedPtr jscClass + freeMem maybeName + freeMem maybeParameterTypes + return result' + +#if ENABLE_OVERLOADING +data ClassAddConstructorMethodInfo +instance (signature ~ (Maybe (T.Text) -> GObject.Callbacks.Callback -> GType -> Maybe ([GType]) -> m JavaScriptCore.Value.Value), MonadIO m, IsClass a) => O.MethodInfo ClassAddConstructorMethodInfo a signature where + overloadedMethod _ = classAddConstructor + +#endif + +-- method Class::add_method_variadic +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the method name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GCallback to be called to invoke method @name of @jsc_class", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of the method return value, or %G_TYPE_NONE if the method is void.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_class_add_method_variadic" jsc_class_add_method_variadic :: + Ptr Class -> -- jsc_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"}) + CString -> -- name : TBasicType TUTF8 + FunPtr GObject.Callbacks.C_Callback -> -- callback : TInterface (Name {namespace = "GObject", name = "Callback"}) + Ptr () -> -- user_data : TBasicType TPtr + FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + CGType -> -- return_type : TBasicType TGType + IO () + +{- | +Add method with /@name@/ to /@jscClass@/. When the method is called by JavaScript or @/jsc_value_object_invoke_method()/@, +/@callback@/ is called receiving the class instance as first parameter, followed by a 'GI.GLib.Structs.PtrArray.PtrArray' of 'GI.JavaScriptCore.Objects.Value.Value'\s +with the method arguments and then /@userData@/ as last parameter. When the method is cleared in the 'GI.JavaScriptCore.Objects.Class.Class' context, +/@destroyNotify@/ is called with /@userData@/ as parameter. + +Note that the value returned by /@callback@/ must be transfer full. In case of non-refcounted boxed types, you should use +@/G_TYPE_POINTER/@ instead of the actual boxed 'GType' to ensure that the instance owned by 'GI.JavaScriptCore.Objects.Class.Class' is used. +If you really want to return a new copy of the boxed type, use @/JSC_TYPE_VALUE/@ and return a 'GI.JavaScriptCore.Objects.Value.Value' created +with 'GI.JavaScriptCore.Objects.Value.valueNewObject' that receives the copy as the instance parameter. +-} +classAddMethodVariadic :: + (B.CallStack.HasCallStack, MonadIO m, IsClass a) => + a + {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -} + -> T.Text + {- ^ /@name@/: the method name -} + -> GObject.Callbacks.Callback + {- ^ /@callback@/: a 'GI.GObject.Callbacks.Callback' to be called to invoke method /@name@/ of /@jscClass@/ -} + -> GType + {- ^ /@returnType@/: the 'GType' of the method return value, or @/G_TYPE_NONE/@ if the method is void. -} + -> m () +classAddMethodVariadic jscClass name callback returnType = liftIO $ do + jscClass' <- unsafeManagedPtrCastPtr jscClass + name' <- textToCString name + callback' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback Nothing callback) + let returnType' = gtypeToCGType returnType + let userData = castFunPtrToPtr callback' + let destroyNotify = safeFreeFunPtrPtr + jsc_class_add_method_variadic jscClass' name' callback' userData destroyNotify returnType' + touchManagedPtr jscClass + freeMem name' + return () + +#if ENABLE_OVERLOADING +data ClassAddMethodVariadicMethodInfo +instance (signature ~ (T.Text -> GObject.Callbacks.Callback -> GType -> m ()), MonadIO m, IsClass a) => O.MethodInfo ClassAddMethodVariadicMethodInfo a signature where + overloadedMethod _ = classAddMethodVariadic + +#endif + +-- method Class::add_method +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the method name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GCallback to be called to invoke method @name of @jsc_class", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of the method return value, or %G_TYPE_NONE if the method is void.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameter types to follow or 0 if the method doesn't receive parameters.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameter_types", argType = TCArray False (-1) 6 (TBasicType TGType), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a list of #GTypes, one for each parameter, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameter types to follow or 0 if the method doesn't receive parameters.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_class_add_methodv" jsc_class_add_methodv :: + Ptr Class -> -- jsc_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"}) + CString -> -- name : TBasicType TUTF8 + FunPtr GObject.Callbacks.C_Callback -> -- callback : TInterface (Name {namespace = "GObject", name = "Callback"}) + Ptr () -> -- user_data : TBasicType TPtr + FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + CGType -> -- return_type : TBasicType TGType + Word32 -> -- n_parameters : TBasicType TUInt + Ptr CGType -> -- parameter_types : TCArray False (-1) 6 (TBasicType TGType) + IO () + +{- | +Add method with /@name@/ to /@jscClass@/. When the method is called by JavaScript or @/jsc_value_object_invoke_method()/@, +/@callback@/ is called receiving the class instance as first parameter, followed by the method parameters and then +/@userData@/ as last parameter. When the method is cleared in the 'GI.JavaScriptCore.Objects.Class.Class' context, /@destroyNotify@/ is called with +/@userData@/ as parameter. + +Note that the value returned by /@callback@/ must be transfer full. In case of non-refcounted boxed types, you should use +@/G_TYPE_POINTER/@ instead of the actual boxed 'GType' to ensure that the instance owned by 'GI.JavaScriptCore.Objects.Class.Class' is used. +If you really want to return a new copy of the boxed type, use @/JSC_TYPE_VALUE/@ and return a 'GI.JavaScriptCore.Objects.Value.Value' created +with 'GI.JavaScriptCore.Objects.Value.valueNewObject' that receives the copy as the instance parameter. +-} +classAddMethod :: + (B.CallStack.HasCallStack, MonadIO m, IsClass a) => + a + {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -} + -> T.Text + {- ^ /@name@/: the method name -} + -> GObject.Callbacks.Callback + {- ^ /@callback@/: a 'GI.GObject.Callbacks.Callback' to be called to invoke method /@name@/ of /@jscClass@/ -} + -> GType + {- ^ /@returnType@/: the 'GType' of the method return value, or @/G_TYPE_NONE/@ if the method is void. -} + -> Maybe ([GType]) + {- ^ /@parameterTypes@/: a list of 'GType'\s, one for each parameter, or 'Nothing' -} + -> m () +classAddMethod jscClass name callback returnType parameterTypes = liftIO $ do + let nParameters = case parameterTypes of + Nothing -> 0 + Just jParameterTypes -> fromIntegral $ length jParameterTypes + jscClass' <- unsafeManagedPtrCastPtr jscClass + name' <- textToCString name + callback' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback Nothing callback) + let returnType' = gtypeToCGType returnType + maybeParameterTypes <- case parameterTypes of + Nothing -> return nullPtr + Just jParameterTypes -> do + jParameterTypes' <- (packMapStorableArray gtypeToCGType) jParameterTypes + return jParameterTypes' + let userData = castFunPtrToPtr callback' + let destroyNotify = safeFreeFunPtrPtr + jsc_class_add_methodv jscClass' name' callback' userData destroyNotify returnType' nParameters maybeParameterTypes + touchManagedPtr jscClass + freeMem name' + freeMem maybeParameterTypes + return () + +#if ENABLE_OVERLOADING +data ClassAddMethodMethodInfo +instance (signature ~ (T.Text -> GObject.Callbacks.Callback -> GType -> Maybe ([GType]) -> m ()), MonadIO m, IsClass a) => O.MethodInfo ClassAddMethodMethodInfo a signature where + overloadedMethod _ = classAddMethod + +#endif + +-- method Class::add_property +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of the property value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "getter", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCallback to be called to get the property value", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "setter", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCallback to be called to set the property value", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 5, argDestroy = 6, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @getter and @setter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_class_add_property" jsc_class_add_property :: + Ptr Class -> -- jsc_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"}) + CString -> -- name : TBasicType TUTF8 + CGType -> -- property_type : TBasicType TGType + FunPtr GObject.Callbacks.C_Callback -> -- getter : TInterface (Name {namespace = "GObject", name = "Callback"}) + FunPtr GObject.Callbacks.C_Callback -> -- setter : TInterface (Name {namespace = "GObject", name = "Callback"}) + Ptr () -> -- user_data : TBasicType TPtr + FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + IO () + +{- | +Add a property with /@name@/ to /@jscClass@/. When the property value needs to be getted, /@getter@/ is called +receiving the the class instance as first parameter and /@userData@/ as last parameter. When the property +value needs to be set, /@setter@/ is called receiving the the class instance as first parameter, followed +by the value to be set and then /@userData@/ as the last parameter. When the property is cleared in the +'GI.JavaScriptCore.Objects.Class.Class' context, /@destroyNotify@/ is called with /@userData@/ as parameter. + +Note that the value returned by /@getter@/ must be transfer full. In case of non-refcounted boxed types, you should use +@/G_TYPE_POINTER/@ instead of the actual boxed 'GType' to ensure that the instance owned by 'GI.JavaScriptCore.Objects.Class.Class' is used. +If you really want to return a new copy of the boxed type, use @/JSC_TYPE_VALUE/@ and return a 'GI.JavaScriptCore.Objects.Value.Value' created +with 'GI.JavaScriptCore.Objects.Value.valueNewObject' that receives the copy as the instance parameter. +-} +classAddProperty :: + (B.CallStack.HasCallStack, MonadIO m, IsClass a) => + a + {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -} + -> T.Text + {- ^ /@name@/: the property name -} + -> GType + {- ^ /@propertyType@/: the 'GType' of the property value -} + -> Maybe (GObject.Callbacks.Callback) + {- ^ /@getter@/: a 'GI.GObject.Callbacks.Callback' to be called to get the property value -} + -> Maybe (GObject.Callbacks.Callback) + {- ^ /@setter@/: a 'GI.GObject.Callbacks.Callback' to be called to set the property value -} + -> m () +classAddProperty jscClass name propertyType getter setter = liftIO $ do + jscClass' <- unsafeManagedPtrCastPtr jscClass + name' <- textToCString name + let propertyType' = gtypeToCGType propertyType + maybeGetter <- case getter of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jGetter -> do + ptrgetter <- callocMem :: IO (Ptr (FunPtr GObject.Callbacks.C_Callback)) + jGetter' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback (Just ptrgetter) jGetter) + poke ptrgetter jGetter' + return jGetter' + maybeSetter <- case setter of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jSetter -> do + jSetter' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback Nothing jSetter) + return jSetter' + let userData = castFunPtrToPtr maybeSetter + let destroyNotify = safeFreeFunPtrPtr + jsc_class_add_property jscClass' name' propertyType' maybeGetter maybeSetter userData destroyNotify + touchManagedPtr jscClass + freeMem name' + return () + +#if ENABLE_OVERLOADING +data ClassAddPropertyMethodInfo +instance (signature ~ (T.Text -> GType -> Maybe (GObject.Callbacks.Callback) -> Maybe (GObject.Callbacks.Callback) -> m ()), MonadIO m, IsClass a) => O.MethodInfo ClassAddPropertyMethodInfo a signature where + overloadedMethod _ = classAddProperty + +#endif + +-- method Class::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a @JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_class_get_name" jsc_class_get_name :: + Ptr Class -> -- jsc_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"}) + IO CString + +{- | +Get the class name of /@jscClass@/ +-} +classGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsClass a) => + a + {- ^ /@jscClass@/: a /@jSCClass@/ -} + -> m T.Text + {- ^ __Returns:__ the name of /@jscClass@/ -} +classGetName jscClass = liftIO $ do + jscClass' <- unsafeManagedPtrCastPtr jscClass + result <- jsc_class_get_name jscClass' + checkUnexpectedReturnNULL "classGetName" result + result' <- cstringToText result + touchManagedPtr jscClass + return result' + +#if ENABLE_OVERLOADING +data ClassGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsClass a) => O.MethodInfo ClassGetNameMethodInfo a signature where + overloadedMethod _ = classGetName + +#endif + +-- method Class::get_parent +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a @JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Class"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_class_get_parent" jsc_class_get_parent :: + Ptr Class -> -- jsc_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"}) + IO (Ptr Class) + +{- | +Get the parent class of /@jscClass@/ +-} +classGetParent :: + (B.CallStack.HasCallStack, MonadIO m, IsClass a) => + a + {- ^ /@jscClass@/: a /@jSCClass@/ -} + -> m Class + {- ^ __Returns:__ the parent class of /@jscClass@/ -} +classGetParent jscClass = liftIO $ do + jscClass' <- unsafeManagedPtrCastPtr jscClass + result <- jsc_class_get_parent jscClass' + checkUnexpectedReturnNULL "classGetParent" result + result' <- (newObject Class) result + touchManagedPtr jscClass + return result' + +#if ENABLE_OVERLOADING +data ClassGetParentMethodInfo +instance (signature ~ (m Class), MonadIO m, IsClass a) => O.MethodInfo ClassGetParentMethodInfo a signature where + overloadedMethod _ = classGetParent + +#endif + + diff --git a/GI/JavaScriptCore/Objects/Class.hs-boot b/GI/JavaScriptCore/Objects/Class.hs-boot new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Objects/Class.hs-boot @@ -0,0 +1,59 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.JavaScriptCore.Objects.Class where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype Class = Class (ManagedPtr Class) +instance GObject Class where +class (GObject o, O.IsDescendantOf Class o) => IsClass o +instance (GObject o, O.IsDescendantOf Class o) => IsClass o +instance O.HasParentTypes Class +#if ENABLE_OVERLOADING +data ClassContextPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ClassNamePropertyInfo +#endif +#if ENABLE_OVERLOADING +data ClassParentPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ClassAddConstructorVariadicMethodInfo +#endif +#if ENABLE_OVERLOADING +data ClassAddConstructorMethodInfo +#endif +#if ENABLE_OVERLOADING +data ClassAddMethodVariadicMethodInfo +#endif +#if ENABLE_OVERLOADING +data ClassAddMethodMethodInfo +#endif +#if ENABLE_OVERLOADING +data ClassAddPropertyMethodInfo +#endif +#if ENABLE_OVERLOADING +data ClassGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data ClassGetParentMethodInfo +#endif diff --git a/GI/JavaScriptCore/Objects/Context.hs b/GI/JavaScriptCore/Objects/Context.hs new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Objects/Context.hs @@ -0,0 +1,1175 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.JavaScriptCore.Objects.Context + ( + +-- * Exported types + Context(..) , + IsContext , + toContext , + noContext , + + + -- * Methods +-- ** checkSyntax #method:checkSyntax# + +#if ENABLE_OVERLOADING + ContextCheckSyntaxMethodInfo , +#endif + contextCheckSyntax , + + +-- ** clearException #method:clearException# + +#if ENABLE_OVERLOADING + ContextClearExceptionMethodInfo , +#endif + contextClearException , + + +-- ** evaluate #method:evaluate# + +#if ENABLE_OVERLOADING + ContextEvaluateMethodInfo , +#endif + contextEvaluate , + + +-- ** evaluateInObject #method:evaluateInObject# + +#if ENABLE_OVERLOADING + ContextEvaluateInObjectMethodInfo , +#endif + contextEvaluateInObject , + + +-- ** evaluateWithSourceUri #method:evaluateWithSourceUri# + +#if ENABLE_OVERLOADING + ContextEvaluateWithSourceUriMethodInfo , +#endif + contextEvaluateWithSourceUri , + + +-- ** getCurrent #method:getCurrent# + + contextGetCurrent , + + +-- ** getException #method:getException# + +#if ENABLE_OVERLOADING + ContextGetExceptionMethodInfo , +#endif + contextGetException , + + +-- ** getGlobalObject #method:getGlobalObject# + +#if ENABLE_OVERLOADING + ContextGetGlobalObjectMethodInfo , +#endif + contextGetGlobalObject , + + +-- ** getValue #method:getValue# + +#if ENABLE_OVERLOADING + ContextGetValueMethodInfo , +#endif + contextGetValue , + + +-- ** getVirtualMachine #method:getVirtualMachine# + +#if ENABLE_OVERLOADING + ContextGetVirtualMachineMethodInfo , +#endif + contextGetVirtualMachine , + + +-- ** new #method:new# + + contextNew , + + +-- ** newWithVirtualMachine #method:newWithVirtualMachine# + + contextNewWithVirtualMachine , + + +-- ** popExceptionHandler #method:popExceptionHandler# + +#if ENABLE_OVERLOADING + ContextPopExceptionHandlerMethodInfo , +#endif + contextPopExceptionHandler , + + +-- ** pushExceptionHandler #method:pushExceptionHandler# + +#if ENABLE_OVERLOADING + ContextPushExceptionHandlerMethodInfo , +#endif + contextPushExceptionHandler , + + +-- ** registerClass #method:registerClass# + +#if ENABLE_OVERLOADING + ContextRegisterClassMethodInfo , +#endif + contextRegisterClass , + + +-- ** setValue #method:setValue# + +#if ENABLE_OVERLOADING + ContextSetValueMethodInfo , +#endif + contextSetValue , + + +-- ** throw #method:throw# + +#if ENABLE_OVERLOADING + ContextThrowMethodInfo , +#endif + contextThrow , + + +-- ** throwException #method:throwException# + +#if ENABLE_OVERLOADING + ContextThrowExceptionMethodInfo , +#endif + contextThrowException , + + +-- ** throwWithName #method:throwWithName# + +#if ENABLE_OVERLOADING + ContextThrowWithNameMethodInfo , +#endif + contextThrowWithName , + + + + + -- * Properties +-- ** virtualMachine #attr:virtualMachine# +{- | The 'GI.JavaScriptCore.Objects.VirtualMachine.VirtualMachine' in which the context was created. +-} +#if ENABLE_OVERLOADING + ContextVirtualMachinePropertyInfo , +#endif + constructContextVirtualMachine , +#if ENABLE_OVERLOADING + contextVirtualMachine , +#endif + getContextVirtualMachine , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.JavaScriptCore.Callbacks as JavaScriptCore.Callbacks +import {-# SOURCE #-} qualified GI.JavaScriptCore.Enums as JavaScriptCore.Enums +import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Class as JavaScriptCore.Class +import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Exception as JavaScriptCore.Exception +import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Value as JavaScriptCore.Value +import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.VirtualMachine as JavaScriptCore.VirtualMachine +import {-# SOURCE #-} qualified GI.JavaScriptCore.Structs.ClassVTable as JavaScriptCore.ClassVTable + +-- | Memory-managed wrapper type. +newtype Context = Context (ManagedPtr Context) +foreign import ccall "jsc_context_get_type" + c_jsc_context_get_type :: IO GType + +instance GObject Context where + gobjectType = c_jsc_context_get_type + + +-- | Type class for types which can be safely cast to `Context`, for instance with `toContext`. +class (GObject o, O.IsDescendantOf Context o) => IsContext o +instance (GObject o, O.IsDescendantOf Context o) => IsContext o + +instance O.HasParentTypes Context +type instance O.ParentTypes Context = '[GObject.Object.Object] + +-- | Cast to `Context`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toContext :: (MonadIO m, IsContext o) => o -> m Context +toContext = liftIO . unsafeCastTo Context + +-- | A convenience alias for `Nothing` :: `Maybe` `Context`. +noContext :: Maybe Context +noContext = Nothing + +#if ENABLE_OVERLOADING +type family ResolveContextMethod (t :: Symbol) (o :: *) :: * where + ResolveContextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveContextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveContextMethod "checkSyntax" o = ContextCheckSyntaxMethodInfo + ResolveContextMethod "clearException" o = ContextClearExceptionMethodInfo + ResolveContextMethod "evaluate" o = ContextEvaluateMethodInfo + ResolveContextMethod "evaluateInObject" o = ContextEvaluateInObjectMethodInfo + ResolveContextMethod "evaluateWithSourceUri" o = ContextEvaluateWithSourceUriMethodInfo + ResolveContextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveContextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveContextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveContextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveContextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveContextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveContextMethod "popExceptionHandler" o = ContextPopExceptionHandlerMethodInfo + ResolveContextMethod "pushExceptionHandler" o = ContextPushExceptionHandlerMethodInfo + ResolveContextMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveContextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveContextMethod "registerClass" o = ContextRegisterClassMethodInfo + ResolveContextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveContextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveContextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveContextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveContextMethod "throw" o = ContextThrowMethodInfo + ResolveContextMethod "throwException" o = ContextThrowExceptionMethodInfo + ResolveContextMethod "throwWithName" o = ContextThrowWithNameMethodInfo + ResolveContextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveContextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveContextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveContextMethod "getException" o = ContextGetExceptionMethodInfo + ResolveContextMethod "getGlobalObject" o = ContextGetGlobalObjectMethodInfo + ResolveContextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveContextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveContextMethod "getValue" o = ContextGetValueMethodInfo + ResolveContextMethod "getVirtualMachine" o = ContextGetVirtualMachineMethodInfo + ResolveContextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveContextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveContextMethod "setValue" o = ContextSetValueMethodInfo + ResolveContextMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveContextMethod t Context, O.MethodInfo info Context p) => OL.IsLabel t (Context -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- VVV Prop "virtual-machine" + -- Type: TInterface (Name {namespace = "JavaScriptCore", name = "VirtualMachine"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@virtual-machine@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' context #virtualMachine +@ +-} +getContextVirtualMachine :: (MonadIO m, IsContext o) => o -> m JavaScriptCore.VirtualMachine.VirtualMachine +getContextVirtualMachine obj = liftIO $ checkUnexpectedNothing "getContextVirtualMachine" $ B.Properties.getObjectPropertyObject obj "virtual-machine" JavaScriptCore.VirtualMachine.VirtualMachine + +{- | +Construct a `GValueConstruct` with valid value for the “@virtual-machine@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructContextVirtualMachine :: (IsContext o, JavaScriptCore.VirtualMachine.IsVirtualMachine a) => a -> IO (GValueConstruct o) +constructContextVirtualMachine val = B.Properties.constructObjectPropertyObject "virtual-machine" (Just val) + +#if ENABLE_OVERLOADING +data ContextVirtualMachinePropertyInfo +instance AttrInfo ContextVirtualMachinePropertyInfo where + type AttrAllowedOps ContextVirtualMachinePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ContextVirtualMachinePropertyInfo = JavaScriptCore.VirtualMachine.IsVirtualMachine + type AttrBaseTypeConstraint ContextVirtualMachinePropertyInfo = IsContext + type AttrGetType ContextVirtualMachinePropertyInfo = JavaScriptCore.VirtualMachine.VirtualMachine + type AttrLabel ContextVirtualMachinePropertyInfo = "virtual-machine" + type AttrOrigin ContextVirtualMachinePropertyInfo = Context + attrGet _ = getContextVirtualMachine + attrSet _ = undefined + attrConstruct _ = constructContextVirtualMachine + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Context +type instance O.AttributeList Context = ContextAttributeList +type ContextAttributeList = ('[ '("virtualMachine", ContextVirtualMachinePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +contextVirtualMachine :: AttrLabelProxy "virtualMachine" +contextVirtualMachine = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Context = ContextSignalList +type ContextSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Context::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Context"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_new" jsc_context_new :: + IO (Ptr Context) + +{- | +Create a new 'GI.JavaScriptCore.Objects.Context.Context'. The context is created in a new 'GI.JavaScriptCore.Objects.VirtualMachine.VirtualMachine'. +Use 'GI.JavaScriptCore.Objects.Context.contextNewWithVirtualMachine' to create a new 'GI.JavaScriptCore.Objects.Context.Context' in an +existing 'GI.JavaScriptCore.Objects.VirtualMachine.VirtualMachine'. +-} +contextNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m Context + {- ^ __Returns:__ the newly created 'GI.JavaScriptCore.Objects.Context.Context'. -} +contextNew = liftIO $ do + result <- jsc_context_new + checkUnexpectedReturnNULL "contextNew" result + result' <- (wrapObject Context) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Context::new_with_virtual_machine +-- method type : Constructor +-- Args : [Arg {argCName = "vm", argType = TInterface (Name {namespace = "JavaScriptCore", name = "VirtualMachine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCVirtualMachine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Context"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_new_with_virtual_machine" jsc_context_new_with_virtual_machine :: + Ptr JavaScriptCore.VirtualMachine.VirtualMachine -> -- vm : TInterface (Name {namespace = "JavaScriptCore", name = "VirtualMachine"}) + IO (Ptr Context) + +{- | +Create a new 'GI.JavaScriptCore.Objects.Context.Context' in /@virtualMachine@/. +-} +contextNewWithVirtualMachine :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.VirtualMachine.IsVirtualMachine a) => + a + {- ^ /@vm@/: a 'GI.JavaScriptCore.Objects.VirtualMachine.VirtualMachine' -} + -> m Context + {- ^ __Returns:__ the newly created 'GI.JavaScriptCore.Objects.Context.Context'. -} +contextNewWithVirtualMachine vm = liftIO $ do + vm' <- unsafeManagedPtrCastPtr vm + result <- jsc_context_new_with_virtual_machine vm' + checkUnexpectedReturnNULL "contextNewWithVirtualMachine" result + result' <- (wrapObject Context) result + touchManagedPtr vm + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Context::check_syntax +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "code", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a JavaScript script to check", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @code, or -1 if @code is a nul-terminated string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "JavaScriptCore", name = "CheckSyntaxMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCCheckSyntaxMode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source URI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line_number", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the starting line number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for a #JSCException, or %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "CheckSyntaxResult"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_check_syntax" jsc_context_check_syntax :: + Ptr Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + CString -> -- code : TBasicType TUTF8 + Int64 -> -- length : TBasicType TInt64 + CUInt -> -- mode : TInterface (Name {namespace = "JavaScriptCore", name = "CheckSyntaxMode"}) + CString -> -- uri : TBasicType TUTF8 + Word32 -> -- line_number : TBasicType TUInt + Ptr (Ptr JavaScriptCore.Exception.Exception) -> -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}) + IO CUInt + +{- | +Check the given /@code@/ in /@context@/ for syntax errors. The /@lineNumber@/ is the starting line number in /@uri@/; +the value is one-based so the first line is 1. /@uri@/ and /@lineNumber@/ are only used to fill the /@exception@/. +In case of errors /@exception@/ will be set to a new 'GI.JavaScriptCore.Objects.Exception.Exception' with the details. You can pass 'Nothing' to +/@exception@/ to ignore the error details. +-} +contextCheckSyntax :: + (B.CallStack.HasCallStack, MonadIO m, IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> T.Text + {- ^ /@code@/: a JavaScript script to check -} + -> Int64 + {- ^ /@length@/: length of /@code@/, or -1 if /@code@/ is a nul-terminated string -} + -> JavaScriptCore.Enums.CheckSyntaxMode + {- ^ /@mode@/: a 'GI.JavaScriptCore.Enums.CheckSyntaxMode' -} + -> T.Text + {- ^ /@uri@/: the source URI -} + -> Word32 + {- ^ /@lineNumber@/: the starting line number -} + -> m ((JavaScriptCore.Enums.CheckSyntaxResult, JavaScriptCore.Exception.Exception)) + {- ^ __Returns:__ a 'GI.JavaScriptCore.Enums.CheckSyntaxResult' -} +contextCheckSyntax context code length_ mode uri lineNumber = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + code' <- textToCString code + let mode' = (fromIntegral . fromEnum) mode + uri' <- textToCString uri + exception <- allocMem :: IO (Ptr (Ptr JavaScriptCore.Exception.Exception)) + result <- jsc_context_check_syntax context' code' length_ mode' uri' lineNumber exception + let result' = (toEnum . fromIntegral) result + exception' <- peek exception + exception'' <- (wrapObject JavaScriptCore.Exception.Exception) exception' + touchManagedPtr context + freeMem code' + freeMem uri' + freeMem exception + return (result', exception'') + +#if ENABLE_OVERLOADING +data ContextCheckSyntaxMethodInfo +instance (signature ~ (T.Text -> Int64 -> JavaScriptCore.Enums.CheckSyntaxMode -> T.Text -> Word32 -> m ((JavaScriptCore.Enums.CheckSyntaxResult, JavaScriptCore.Exception.Exception))), MonadIO m, IsContext a) => O.MethodInfo ContextCheckSyntaxMethodInfo a signature where + overloadedMethod _ = contextCheckSyntax + +#endif + +-- method Context::clear_exception +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_clear_exception" jsc_context_clear_exception :: + Ptr Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + IO () + +{- | +Clear the uncaught exception in /@context@/ if any. +-} +contextClearException :: + (B.CallStack.HasCallStack, MonadIO m, IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> m () +contextClearException context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + jsc_context_clear_exception context' + touchManagedPtr context + return () + +#if ENABLE_OVERLOADING +data ContextClearExceptionMethodInfo +instance (signature ~ (m ()), MonadIO m, IsContext a) => O.MethodInfo ContextClearExceptionMethodInfo a signature where + overloadedMethod _ = contextClearException + +#endif + +-- method Context::evaluate +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "code", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a JavaScript script to evaluate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @code, or -1 if @code is a nul-terminated string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_evaluate" jsc_context_evaluate :: + Ptr Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + CString -> -- code : TBasicType TUTF8 + Int64 -> -- length : TBasicType TInt64 + IO (Ptr JavaScriptCore.Value.Value) + +{- | +Evaluate /@code@/ in /@context@/. +-} +contextEvaluate :: + (B.CallStack.HasCallStack, MonadIO m, IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> T.Text + {- ^ /@code@/: a JavaScript script to evaluate -} + -> Int64 + {- ^ /@length@/: length of /@code@/, or -1 if /@code@/ is a nul-terminated string -} + -> m JavaScriptCore.Value.Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' representing the last value generated by the script. -} +contextEvaluate context code length_ = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + code' <- textToCString code + result <- jsc_context_evaluate context' code' length_ + checkUnexpectedReturnNULL "contextEvaluate" result + result' <- (wrapObject JavaScriptCore.Value.Value) result + touchManagedPtr context + freeMem code' + return result' + +#if ENABLE_OVERLOADING +data ContextEvaluateMethodInfo +instance (signature ~ (T.Text -> Int64 -> m JavaScriptCore.Value.Value), MonadIO m, IsContext a) => O.MethodInfo ContextEvaluateMethodInfo a signature where + overloadedMethod _ = contextEvaluate + +#endif + +-- method Context::evaluate_in_object +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "code", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a JavaScript script to evaluate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @code, or -1 if @code is a nul-terminated string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object_instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "an object instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #JSCClass or %NULL to use the default", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source URI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line_number", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the starting line number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for a #JSCValue.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_evaluate_in_object" jsc_context_evaluate_in_object :: + Ptr Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + CString -> -- code : TBasicType TUTF8 + Int64 -> -- length : TBasicType TInt64 + Ptr () -> -- object_instance : TBasicType TPtr + Ptr JavaScriptCore.Class.Class -> -- object_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"}) + CString -> -- uri : TBasicType TUTF8 + Word32 -> -- line_number : TBasicType TUInt + Ptr (Ptr JavaScriptCore.Value.Value) -> -- object : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO (Ptr JavaScriptCore.Value.Value) + +{- | +Evaluate /@code@/ and create an new object where symbols defined in /@code@/ will be added as properties, +instead of being added to /@context@/ global object. The new object is returned as /@object@/ parameter. +Similar to how 'GI.JavaScriptCore.Objects.Value.valueNewObject' works, if /@objectInstance@/ is not 'Nothing' /@objectClass@/ must be provided too. +The /@lineNumber@/ is the starting line number in /@uri@/; the value is one-based so the first line is 1. +/@uri@/ and /@lineNumber@/ will be shown in exceptions and they don\'t affect the behavior of the script. +-} +contextEvaluateInObject :: + (B.CallStack.HasCallStack, MonadIO m, IsContext a, JavaScriptCore.Class.IsClass b) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> T.Text + {- ^ /@code@/: a JavaScript script to evaluate -} + -> Int64 + {- ^ /@length@/: length of /@code@/, or -1 if /@code@/ is a nul-terminated string -} + -> Ptr () + {- ^ /@objectInstance@/: an object instance -} + -> Maybe (b) + {- ^ /@objectClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' or 'Nothing' to use the default -} + -> T.Text + {- ^ /@uri@/: the source URI -} + -> Word32 + {- ^ /@lineNumber@/: the starting line number -} + -> m ((JavaScriptCore.Value.Value, JavaScriptCore.Value.Value)) + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' representing the last value generated by the script. -} +contextEvaluateInObject context code length_ objectInstance objectClass uri lineNumber = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + code' <- textToCString code + maybeObjectClass <- case objectClass of + Nothing -> return nullPtr + Just jObjectClass -> do + jObjectClass' <- unsafeManagedPtrCastPtr jObjectClass + return jObjectClass' + uri' <- textToCString uri + object <- allocMem :: IO (Ptr (Ptr JavaScriptCore.Value.Value)) + result <- jsc_context_evaluate_in_object context' code' length_ objectInstance maybeObjectClass uri' lineNumber object + checkUnexpectedReturnNULL "contextEvaluateInObject" result + result' <- (wrapObject JavaScriptCore.Value.Value) result + object' <- peek object + object'' <- (wrapObject JavaScriptCore.Value.Value) object' + touchManagedPtr context + whenJust objectClass touchManagedPtr + freeMem code' + freeMem uri' + freeMem object + return (result', object'') + +#if ENABLE_OVERLOADING +data ContextEvaluateInObjectMethodInfo +instance (signature ~ (T.Text -> Int64 -> Ptr () -> Maybe (b) -> T.Text -> Word32 -> m ((JavaScriptCore.Value.Value, JavaScriptCore.Value.Value))), MonadIO m, IsContext a, JavaScriptCore.Class.IsClass b) => O.MethodInfo ContextEvaluateInObjectMethodInfo a signature where + overloadedMethod _ = contextEvaluateInObject + +#endif + +-- method Context::evaluate_with_source_uri +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "code", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a JavaScript script to evaluate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @code, or -1 if @code is a nul-terminated string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source URI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line_number", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the starting line number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_evaluate_with_source_uri" jsc_context_evaluate_with_source_uri :: + Ptr Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + CString -> -- code : TBasicType TUTF8 + Int64 -> -- length : TBasicType TInt64 + CString -> -- uri : TBasicType TUTF8 + Word32 -> -- line_number : TBasicType TUInt + IO (Ptr JavaScriptCore.Value.Value) + +{- | +Evaluate /@code@/ in /@context@/ using /@uri@/ as the source URI. The /@lineNumber@/ is the starting line number +in /@uri@/; the value is one-based so the first line is 1. /@uri@/ and /@lineNumber@/ will be shown in exceptions and +they don\'t affect the behavior of the script. +-} +contextEvaluateWithSourceUri :: + (B.CallStack.HasCallStack, MonadIO m, IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> T.Text + {- ^ /@code@/: a JavaScript script to evaluate -} + -> Int64 + {- ^ /@length@/: length of /@code@/, or -1 if /@code@/ is a nul-terminated string -} + -> T.Text + {- ^ /@uri@/: the source URI -} + -> Word32 + {- ^ /@lineNumber@/: the starting line number -} + -> m JavaScriptCore.Value.Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' representing the last value generated by the script. -} +contextEvaluateWithSourceUri context code length_ uri lineNumber = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + code' <- textToCString code + uri' <- textToCString uri + result <- jsc_context_evaluate_with_source_uri context' code' length_ uri' lineNumber + checkUnexpectedReturnNULL "contextEvaluateWithSourceUri" result + result' <- (wrapObject JavaScriptCore.Value.Value) result + touchManagedPtr context + freeMem code' + freeMem uri' + return result' + +#if ENABLE_OVERLOADING +data ContextEvaluateWithSourceUriMethodInfo +instance (signature ~ (T.Text -> Int64 -> T.Text -> Word32 -> m JavaScriptCore.Value.Value), MonadIO m, IsContext a) => O.MethodInfo ContextEvaluateWithSourceUriMethodInfo a signature where + overloadedMethod _ = contextEvaluateWithSourceUri + +#endif + +-- method Context::get_exception +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Exception"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_get_exception" jsc_context_get_exception :: + Ptr Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + IO (Ptr JavaScriptCore.Exception.Exception) + +{- | +Get the last unhandled exception thrown in /@context@/ by API functions calls. +-} +contextGetException :: + (B.CallStack.HasCallStack, MonadIO m, IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> m (Maybe JavaScriptCore.Exception.Exception) + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Exception.Exception' or 'Nothing' if there isn\'t any + unhandled exception in the 'GI.JavaScriptCore.Objects.Context.Context'. -} +contextGetException context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- jsc_context_get_exception context' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject JavaScriptCore.Exception.Exception) result' + return result'' + touchManagedPtr context + return maybeResult + +#if ENABLE_OVERLOADING +data ContextGetExceptionMethodInfo +instance (signature ~ (m (Maybe JavaScriptCore.Exception.Exception)), MonadIO m, IsContext a) => O.MethodInfo ContextGetExceptionMethodInfo a signature where + overloadedMethod _ = contextGetException + +#endif + +-- method Context::get_global_object +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_get_global_object" jsc_context_get_global_object :: + Ptr Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + IO (Ptr JavaScriptCore.Value.Value) + +{- | +Get a 'GI.JavaScriptCore.Objects.Value.Value' referencing the /@context@/ global object +-} +contextGetGlobalObject :: + (B.CallStack.HasCallStack, MonadIO m, IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> m JavaScriptCore.Value.Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' -} +contextGetGlobalObject context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- jsc_context_get_global_object context' + checkUnexpectedReturnNULL "contextGetGlobalObject" result + result' <- (wrapObject JavaScriptCore.Value.Value) result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +data ContextGetGlobalObjectMethodInfo +instance (signature ~ (m JavaScriptCore.Value.Value), MonadIO m, IsContext a) => O.MethodInfo ContextGetGlobalObjectMethodInfo a signature where + overloadedMethod _ = contextGetGlobalObject + +#endif + +-- method Context::get_value +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_get_value" jsc_context_get_value :: + Ptr Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + CString -> -- name : TBasicType TUTF8 + IO (Ptr JavaScriptCore.Value.Value) + +{- | +Get a property of /@context@/ global object with /@name@/. +-} +contextGetValue :: + (B.CallStack.HasCallStack, MonadIO m, IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> T.Text + {- ^ /@name@/: the value name -} + -> m JavaScriptCore.Value.Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' -} +contextGetValue context name = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + name' <- textToCString name + result <- jsc_context_get_value context' name' + checkUnexpectedReturnNULL "contextGetValue" result + result' <- (wrapObject JavaScriptCore.Value.Value) result + touchManagedPtr context + freeMem name' + return result' + +#if ENABLE_OVERLOADING +data ContextGetValueMethodInfo +instance (signature ~ (T.Text -> m JavaScriptCore.Value.Value), MonadIO m, IsContext a) => O.MethodInfo ContextGetValueMethodInfo a signature where + overloadedMethod _ = contextGetValue + +#endif + +-- method Context::get_virtual_machine +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "VirtualMachine"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_get_virtual_machine" jsc_context_get_virtual_machine :: + Ptr Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + IO (Ptr JavaScriptCore.VirtualMachine.VirtualMachine) + +{- | +Get the 'GI.JavaScriptCore.Objects.VirtualMachine.VirtualMachine' where /@context@/ was created. +-} +contextGetVirtualMachine :: + (B.CallStack.HasCallStack, MonadIO m, IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> m JavaScriptCore.VirtualMachine.VirtualMachine + {- ^ __Returns:__ the 'GI.JavaScriptCore.Objects.VirtualMachine.VirtualMachine' where the 'GI.JavaScriptCore.Objects.Context.Context' was created. -} +contextGetVirtualMachine context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- jsc_context_get_virtual_machine context' + checkUnexpectedReturnNULL "contextGetVirtualMachine" result + result' <- (newObject JavaScriptCore.VirtualMachine.VirtualMachine) result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +data ContextGetVirtualMachineMethodInfo +instance (signature ~ (m JavaScriptCore.VirtualMachine.VirtualMachine), MonadIO m, IsContext a) => O.MethodInfo ContextGetVirtualMachineMethodInfo a signature where + overloadedMethod _ = contextGetVirtualMachine + +#endif + +-- method Context::pop_exception_handler +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_pop_exception_handler" jsc_context_pop_exception_handler :: + Ptr Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + IO () + +{- | +Remove the last 'GI.JavaScriptCore.Callbacks.ExceptionHandler' previously pushed to /@context@/ with +'GI.JavaScriptCore.Objects.Context.contextPushExceptionHandler'. +-} +contextPopExceptionHandler :: + (B.CallStack.HasCallStack, MonadIO m, IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> m () +contextPopExceptionHandler context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + jsc_context_pop_exception_handler context' + touchManagedPtr context + return () + +#if ENABLE_OVERLOADING +data ContextPopExceptionHandlerMethodInfo +instance (signature ~ (m ()), MonadIO m, IsContext a) => O.MethodInfo ContextPopExceptionHandlerMethodInfo a signature where + overloadedMethod _ = contextPopExceptionHandler + +#endif + +-- method Context::push_exception_handler +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "handler", argType = TInterface (Name {namespace = "JavaScriptCore", name = "ExceptionHandler"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCExceptionHandler", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @handler", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_push_exception_handler" jsc_context_push_exception_handler :: + Ptr Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + FunPtr JavaScriptCore.Callbacks.C_ExceptionHandler -> -- handler : TInterface (Name {namespace = "JavaScriptCore", name = "ExceptionHandler"}) + Ptr () -> -- user_data : TBasicType TPtr + FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + IO () + +{- | +Push an exception handler in /@context@/. Whenever a JavaScript exception happens in +the 'GI.JavaScriptCore.Objects.Context.Context', the given /@handler@/ will be called. The default 'GI.JavaScriptCore.Callbacks.ExceptionHandler' +simply calls 'GI.JavaScriptCore.Objects.Context.contextThrowException' to throw the exception to the 'GI.JavaScriptCore.Objects.Context.Context'. +If you don\'t want to catch the exception, but only get notified about it, call +'GI.JavaScriptCore.Objects.Context.contextThrowException' in /@handler@/ like the default one does. +The last exception handler pushed is the only one used by the 'GI.JavaScriptCore.Objects.Context.Context', use +'GI.JavaScriptCore.Objects.Context.contextPopExceptionHandler' to remove it and set the previous one. When /@handler@/ +is removed from the context, /@destroyNotify@/ i called with /@userData@/ as parameter. +-} +contextPushExceptionHandler :: + (B.CallStack.HasCallStack, MonadIO m, IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> JavaScriptCore.Callbacks.ExceptionHandler + {- ^ /@handler@/: a 'GI.JavaScriptCore.Callbacks.ExceptionHandler' -} + -> m () +contextPushExceptionHandler context handler = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + handler' <- JavaScriptCore.Callbacks.mk_ExceptionHandler (JavaScriptCore.Callbacks.wrap_ExceptionHandler Nothing (JavaScriptCore.Callbacks.drop_closures_ExceptionHandler handler)) + let userData = castFunPtrToPtr handler' + let destroyNotify = safeFreeFunPtrPtr + jsc_context_push_exception_handler context' handler' userData destroyNotify + touchManagedPtr context + return () + +#if ENABLE_OVERLOADING +data ContextPushExceptionHandlerMethodInfo +instance (signature ~ (JavaScriptCore.Callbacks.ExceptionHandler -> m ()), MonadIO m, IsContext a) => O.MethodInfo ContextPushExceptionHandlerMethodInfo a signature where + overloadedMethod _ = contextPushExceptionHandler + +#endif + +-- method Context::register_class +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the class name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #JSCClass or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "vtable", argType = TInterface (Name {namespace = "JavaScriptCore", name = "ClassVTable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "an optional #JSCClassVTable or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a destroy notifier for class instances", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Class"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_register_class" jsc_context_register_class :: + Ptr Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + CString -> -- name : TBasicType TUTF8 + Ptr JavaScriptCore.Class.Class -> -- parent_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"}) + Ptr JavaScriptCore.ClassVTable.ClassVTable -> -- vtable : TInterface (Name {namespace = "JavaScriptCore", name = "ClassVTable"}) + FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + IO (Ptr JavaScriptCore.Class.Class) + +{- | +Register a custom class in /@context@/ using the given /@name@/. If the new class inherits from +another 'GI.JavaScriptCore.Objects.Class.Class', the parent should be passed as /@parentClass@/, otherwise 'Nothing' should be +used. The optional /@vtable@/ parameter allows to provide a custom implementation for handling +the class, for example, to handle external properties not added to the prototype. +When an instance of the 'GI.JavaScriptCore.Objects.Class.Class' is cleared in the context, /@destroyNotify@/ is called with +the instance as parameter. +-} +contextRegisterClass :: + (B.CallStack.HasCallStack, MonadIO m, IsContext a, JavaScriptCore.Class.IsClass b) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> T.Text + {- ^ /@name@/: the class name -} + -> Maybe (b) + {- ^ /@parentClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' or 'Nothing' -} + -> Maybe (JavaScriptCore.ClassVTable.ClassVTable) + {- ^ /@vtable@/: an optional 'GI.JavaScriptCore.Structs.ClassVTable.ClassVTable' or 'Nothing' -} + -> Maybe (GLib.Callbacks.DestroyNotify) + {- ^ /@destroyNotify@/: a destroy notifier for class instances -} + -> m JavaScriptCore.Class.Class + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Class.Class' -} +contextRegisterClass context name parentClass vtable destroyNotify = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + name' <- textToCString name + maybeParentClass <- case parentClass of + Nothing -> return nullPtr + Just jParentClass -> do + jParentClass' <- unsafeManagedPtrCastPtr jParentClass + return jParentClass' + maybeVtable <- case vtable of + Nothing -> return nullPtr + Just jVtable -> do + jVtable' <- unsafeManagedPtrGetPtr jVtable + return jVtable' + maybeDestroyNotify <- case destroyNotify of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jDestroyNotify -> do + ptrdestroyNotify <- callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify)) + jDestroyNotify' <- GLib.Callbacks.mk_DestroyNotify (GLib.Callbacks.wrap_DestroyNotify (Just ptrdestroyNotify) jDestroyNotify) + poke ptrdestroyNotify jDestroyNotify' + return jDestroyNotify' + result <- jsc_context_register_class context' name' maybeParentClass maybeVtable maybeDestroyNotify + checkUnexpectedReturnNULL "contextRegisterClass" result + result' <- (newObject JavaScriptCore.Class.Class) result + touchManagedPtr context + whenJust parentClass touchManagedPtr + whenJust vtable touchManagedPtr + freeMem name' + return result' + +#if ENABLE_OVERLOADING +data ContextRegisterClassMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> Maybe (JavaScriptCore.ClassVTable.ClassVTable) -> Maybe (GLib.Callbacks.DestroyNotify) -> m JavaScriptCore.Class.Class), MonadIO m, IsContext a, JavaScriptCore.Class.IsClass b) => O.MethodInfo ContextRegisterClassMethodInfo a signature where + overloadedMethod _ = contextRegisterClass + +#endif + +-- method Context::set_value +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_set_value" jsc_context_set_value :: + Ptr Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + CString -> -- name : TBasicType TUTF8 + Ptr JavaScriptCore.Value.Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO () + +{- | +Set a property of /@context@/ global object with /@name@/ and /@value@/. +-} +contextSetValue :: + (B.CallStack.HasCallStack, MonadIO m, IsContext a, JavaScriptCore.Value.IsValue b) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> T.Text + {- ^ /@name@/: the value name -} + -> b + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> m () +contextSetValue context name value = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + name' <- textToCString name + value' <- unsafeManagedPtrCastPtr value + jsc_context_set_value context' name' value' + touchManagedPtr context + touchManagedPtr value + freeMem name' + return () + +#if ENABLE_OVERLOADING +data ContextSetValueMethodInfo +instance (signature ~ (T.Text -> b -> m ()), MonadIO m, IsContext a, JavaScriptCore.Value.IsValue b) => O.MethodInfo ContextSetValueMethodInfo a signature where + overloadedMethod _ = contextSetValue + +#endif + +-- method Context::throw +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error_message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an error message", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_throw" jsc_context_throw :: + Ptr Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + CString -> -- error_message : TBasicType TUTF8 + IO () + +{- | +Throw an exception to /@context@/ using the given error message. The created 'GI.JavaScriptCore.Objects.Exception.Exception' +can be retrieved with 'GI.JavaScriptCore.Objects.Context.contextGetException'. +-} +contextThrow :: + (B.CallStack.HasCallStack, MonadIO m, IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> T.Text + {- ^ /@errorMessage@/: an error message -} + -> m () +contextThrow context errorMessage = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + errorMessage' <- textToCString errorMessage + jsc_context_throw context' errorMessage' + touchManagedPtr context + freeMem errorMessage' + return () + +#if ENABLE_OVERLOADING +data ContextThrowMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsContext a) => O.MethodInfo ContextThrowMethodInfo a signature where + overloadedMethod _ = contextThrow + +#endif + +-- method Context::throw_exception +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_throw_exception" jsc_context_throw_exception :: + Ptr Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + Ptr JavaScriptCore.Exception.Exception -> -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}) + IO () + +{- | +Throw /@exception@/ to /@context@/. +-} +contextThrowException :: + (B.CallStack.HasCallStack, MonadIO m, IsContext a, JavaScriptCore.Exception.IsException b) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> b + {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -} + -> m () +contextThrowException context exception = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + exception' <- unsafeManagedPtrCastPtr exception + jsc_context_throw_exception context' exception' + touchManagedPtr context + touchManagedPtr exception + return () + +#if ENABLE_OVERLOADING +data ContextThrowExceptionMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsContext a, JavaScriptCore.Exception.IsException b) => O.MethodInfo ContextThrowExceptionMethodInfo a signature where + overloadedMethod _ = contextThrowException + +#endif + +-- method Context::throw_with_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the error name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error_message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an error message", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_throw_with_name" jsc_context_throw_with_name :: + Ptr Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + CString -> -- error_name : TBasicType TUTF8 + CString -> -- error_message : TBasicType TUTF8 + IO () + +{- | +Throw an exception to /@context@/ using the given error name and message. The created 'GI.JavaScriptCore.Objects.Exception.Exception' +can be retrieved with 'GI.JavaScriptCore.Objects.Context.contextGetException'. +-} +contextThrowWithName :: + (B.CallStack.HasCallStack, MonadIO m, IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> T.Text + {- ^ /@errorName@/: the error name -} + -> T.Text + {- ^ /@errorMessage@/: an error message -} + -> m () +contextThrowWithName context errorName errorMessage = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + errorName' <- textToCString errorName + errorMessage' <- textToCString errorMessage + jsc_context_throw_with_name context' errorName' errorMessage' + touchManagedPtr context + freeMem errorName' + freeMem errorMessage' + return () + +#if ENABLE_OVERLOADING +data ContextThrowWithNameMethodInfo +instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m, IsContext a) => O.MethodInfo ContextThrowWithNameMethodInfo a signature where + overloadedMethod _ = contextThrowWithName + +#endif + +-- method Context::get_current +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Context"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_context_get_current" jsc_context_get_current :: + IO (Ptr Context) + +{- | +Get the 'GI.JavaScriptCore.Objects.Context.Context' that is currently executing a function. This should only be +called within a function or method callback, otherwise 'Nothing' will be returned. +-} +contextGetCurrent :: + (B.CallStack.HasCallStack, MonadIO m) => + m (Maybe Context) + {- ^ __Returns:__ the 'GI.JavaScriptCore.Objects.Context.Context' that is currently executing. -} +contextGetCurrent = liftIO $ do + result <- jsc_context_get_current + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Context) result' + return result'' + return maybeResult + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/JavaScriptCore/Objects/Context.hs-boot b/GI/JavaScriptCore/Objects/Context.hs-boot new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Objects/Context.hs-boot @@ -0,0 +1,80 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.JavaScriptCore.Objects.Context where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype Context = Context (ManagedPtr Context) +instance GObject Context where +class (GObject o, O.IsDescendantOf Context o) => IsContext o +instance (GObject o, O.IsDescendantOf Context o) => IsContext o +instance O.HasParentTypes Context +#if ENABLE_OVERLOADING +data ContextVirtualMachinePropertyInfo +#endif +#if ENABLE_OVERLOADING +data ContextCheckSyntaxMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextClearExceptionMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextEvaluateMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextEvaluateInObjectMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextEvaluateWithSourceUriMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextGetExceptionMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextGetGlobalObjectMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextGetValueMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextGetVirtualMachineMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextPopExceptionHandlerMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextPushExceptionHandlerMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextRegisterClassMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextSetValueMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextThrowMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextThrowExceptionMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextThrowWithNameMethodInfo +#endif diff --git a/GI/JavaScriptCore/Objects/Exception.hs b/GI/JavaScriptCore/Objects/Exception.hs new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Objects/Exception.hs @@ -0,0 +1,575 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.JavaScriptCore.Objects.Exception + ( + +-- * Exported types + Exception(..) , + IsException , + toException , + noException , + + + -- * Methods +-- ** getBacktraceString #method:getBacktraceString# + +#if ENABLE_OVERLOADING + ExceptionGetBacktraceStringMethodInfo , +#endif + exceptionGetBacktraceString , + + +-- ** getColumnNumber #method:getColumnNumber# + +#if ENABLE_OVERLOADING + ExceptionGetColumnNumberMethodInfo , +#endif + exceptionGetColumnNumber , + + +-- ** getLineNumber #method:getLineNumber# + +#if ENABLE_OVERLOADING + ExceptionGetLineNumberMethodInfo , +#endif + exceptionGetLineNumber , + + +-- ** getMessage #method:getMessage# + +#if ENABLE_OVERLOADING + ExceptionGetMessageMethodInfo , +#endif + exceptionGetMessage , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + ExceptionGetNameMethodInfo , +#endif + exceptionGetName , + + +-- ** getSourceUri #method:getSourceUri# + +#if ENABLE_OVERLOADING + ExceptionGetSourceUriMethodInfo , +#endif + exceptionGetSourceUri , + + +-- ** new #method:new# + + exceptionNew , + + +-- ** newWithName #method:newWithName# + + exceptionNewWithName , + + +-- ** report #method:report# + +#if ENABLE_OVERLOADING + ExceptionReportMethodInfo , +#endif + exceptionReport , + + +-- ** toString #method:toString# + +#if ENABLE_OVERLOADING + ExceptionToStringMethodInfo , +#endif + exceptionToString , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Context as JavaScriptCore.Context + +-- | Memory-managed wrapper type. +newtype Exception = Exception (ManagedPtr Exception) +foreign import ccall "jsc_exception_get_type" + c_jsc_exception_get_type :: IO GType + +instance GObject Exception where + gobjectType = c_jsc_exception_get_type + + +-- | Type class for types which can be safely cast to `Exception`, for instance with `toException`. +class (GObject o, O.IsDescendantOf Exception o) => IsException o +instance (GObject o, O.IsDescendantOf Exception o) => IsException o + +instance O.HasParentTypes Exception +type instance O.ParentTypes Exception = '[GObject.Object.Object] + +-- | Cast to `Exception`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toException :: (MonadIO m, IsException o) => o -> m Exception +toException = liftIO . unsafeCastTo Exception + +-- | A convenience alias for `Nothing` :: `Maybe` `Exception`. +noException :: Maybe Exception +noException = Nothing + +#if ENABLE_OVERLOADING +type family ResolveExceptionMethod (t :: Symbol) (o :: *) :: * where + ResolveExceptionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveExceptionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveExceptionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveExceptionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveExceptionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveExceptionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveExceptionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveExceptionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveExceptionMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveExceptionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveExceptionMethod "report" o = ExceptionReportMethodInfo + ResolveExceptionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveExceptionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveExceptionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveExceptionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveExceptionMethod "toString" o = ExceptionToStringMethodInfo + ResolveExceptionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveExceptionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveExceptionMethod "getBacktraceString" o = ExceptionGetBacktraceStringMethodInfo + ResolveExceptionMethod "getColumnNumber" o = ExceptionGetColumnNumberMethodInfo + ResolveExceptionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveExceptionMethod "getLineNumber" o = ExceptionGetLineNumberMethodInfo + ResolveExceptionMethod "getMessage" o = ExceptionGetMessageMethodInfo + ResolveExceptionMethod "getName" o = ExceptionGetNameMethodInfo + ResolveExceptionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveExceptionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveExceptionMethod "getSourceUri" o = ExceptionGetSourceUriMethodInfo + ResolveExceptionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveExceptionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveExceptionMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveExceptionMethod t Exception, O.MethodInfo info Exception p) => OL.IsLabel t (Exception -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Exception +type instance O.AttributeList Exception = ExceptionAttributeList +type ExceptionAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Exception = ExceptionSignalList +type ExceptionSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Exception::new +-- method type : Constructor +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the error message", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Exception"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_exception_new" jsc_exception_new :: + Ptr JavaScriptCore.Context.Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + CString -> -- message : TBasicType TUTF8 + IO (Ptr Exception) + +{- | +Create a new 'GI.JavaScriptCore.Objects.Exception.Exception' in /@context@/ with /@message@/. +-} +exceptionNew :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> T.Text + {- ^ /@message@/: the error message -} + -> m Exception + {- ^ __Returns:__ a new 'GI.JavaScriptCore.Objects.Exception.Exception'. -} +exceptionNew context message = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + message' <- textToCString message + result <- jsc_exception_new context' message' + checkUnexpectedReturnNULL "exceptionNew" result + result' <- (wrapObject Exception) result + touchManagedPtr context + freeMem message' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Exception::new_with_name +-- method type : Constructor +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the error name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the error message", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Exception"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_exception_new_with_name" jsc_exception_new_with_name :: + Ptr JavaScriptCore.Context.Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + CString -> -- name : TBasicType TUTF8 + CString -> -- message : TBasicType TUTF8 + IO (Ptr Exception) + +{- | +Create a new 'GI.JavaScriptCore.Objects.Exception.Exception' in /@context@/ with /@name@/ and /@message@/. +-} +exceptionNewWithName :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> T.Text + {- ^ /@name@/: the error name -} + -> T.Text + {- ^ /@message@/: the error message -} + -> m Exception + {- ^ __Returns:__ a new 'GI.JavaScriptCore.Objects.Exception.Exception'. -} +exceptionNewWithName context name message = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + name' <- textToCString name + message' <- textToCString message + result <- jsc_exception_new_with_name context' name' message' + checkUnexpectedReturnNULL "exceptionNewWithName" result + result' <- (wrapObject Exception) result + touchManagedPtr context + freeMem name' + freeMem message' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Exception::get_backtrace_string +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_exception_get_backtrace_string" jsc_exception_get_backtrace_string :: + Ptr Exception -> -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}) + IO CString + +{- | +Get a string with the exception backtrace. +-} +exceptionGetBacktraceString :: + (B.CallStack.HasCallStack, MonadIO m, IsException a) => + a + {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the exception backtrace string or 'Nothing'. -} +exceptionGetBacktraceString exception = liftIO $ do + exception' <- unsafeManagedPtrCastPtr exception + result <- jsc_exception_get_backtrace_string exception' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr exception + return maybeResult + +#if ENABLE_OVERLOADING +data ExceptionGetBacktraceStringMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsException a) => O.MethodInfo ExceptionGetBacktraceStringMethodInfo a signature where + overloadedMethod _ = exceptionGetBacktraceString + +#endif + +-- method Exception::get_column_number +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_exception_get_column_number" jsc_exception_get_column_number :: + Ptr Exception -> -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}) + IO Word32 + +{- | +Get the column number at which /@exception@/ happened. +-} +exceptionGetColumnNumber :: + (B.CallStack.HasCallStack, MonadIO m, IsException a) => + a + {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -} + -> m Word32 + {- ^ __Returns:__ the column number of /@exception@/. -} +exceptionGetColumnNumber exception = liftIO $ do + exception' <- unsafeManagedPtrCastPtr exception + result <- jsc_exception_get_column_number exception' + touchManagedPtr exception + return result + +#if ENABLE_OVERLOADING +data ExceptionGetColumnNumberMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsException a) => O.MethodInfo ExceptionGetColumnNumberMethodInfo a signature where + overloadedMethod _ = exceptionGetColumnNumber + +#endif + +-- method Exception::get_line_number +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_exception_get_line_number" jsc_exception_get_line_number :: + Ptr Exception -> -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}) + IO Word32 + +{- | +Get the line number at which /@exception@/ happened. +-} +exceptionGetLineNumber :: + (B.CallStack.HasCallStack, MonadIO m, IsException a) => + a + {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -} + -> m Word32 + {- ^ __Returns:__ the line number of /@exception@/. -} +exceptionGetLineNumber exception = liftIO $ do + exception' <- unsafeManagedPtrCastPtr exception + result <- jsc_exception_get_line_number exception' + touchManagedPtr exception + return result + +#if ENABLE_OVERLOADING +data ExceptionGetLineNumberMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsException a) => O.MethodInfo ExceptionGetLineNumberMethodInfo a signature where + overloadedMethod _ = exceptionGetLineNumber + +#endif + +-- method Exception::get_message +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_exception_get_message" jsc_exception_get_message :: + Ptr Exception -> -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}) + IO CString + +{- | +Get the error message of /@exception@/. +-} +exceptionGetMessage :: + (B.CallStack.HasCallStack, MonadIO m, IsException a) => + a + {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -} + -> m T.Text + {- ^ __Returns:__ the /@exception@/ error message. -} +exceptionGetMessage exception = liftIO $ do + exception' <- unsafeManagedPtrCastPtr exception + result <- jsc_exception_get_message exception' + checkUnexpectedReturnNULL "exceptionGetMessage" result + result' <- cstringToText result + touchManagedPtr exception + return result' + +#if ENABLE_OVERLOADING +data ExceptionGetMessageMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsException a) => O.MethodInfo ExceptionGetMessageMethodInfo a signature where + overloadedMethod _ = exceptionGetMessage + +#endif + +-- method Exception::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_exception_get_name" jsc_exception_get_name :: + Ptr Exception -> -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}) + IO CString + +{- | +Get the error name of /@exception@/ +-} +exceptionGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsException a) => + a + {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -} + -> m T.Text + {- ^ __Returns:__ the /@exception@/ error name. -} +exceptionGetName exception = liftIO $ do + exception' <- unsafeManagedPtrCastPtr exception + result <- jsc_exception_get_name exception' + checkUnexpectedReturnNULL "exceptionGetName" result + result' <- cstringToText result + touchManagedPtr exception + return result' + +#if ENABLE_OVERLOADING +data ExceptionGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsException a) => O.MethodInfo ExceptionGetNameMethodInfo a signature where + overloadedMethod _ = exceptionGetName + +#endif + +-- method Exception::get_source_uri +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_exception_get_source_uri" jsc_exception_get_source_uri :: + Ptr Exception -> -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}) + IO CString + +{- | +Get the source URI of /@exception@/. +-} +exceptionGetSourceUri :: + (B.CallStack.HasCallStack, MonadIO m, IsException a) => + a + {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the the source URI of /@exception@/, or 'Nothing'. -} +exceptionGetSourceUri exception = liftIO $ do + exception' <- unsafeManagedPtrCastPtr exception + result <- jsc_exception_get_source_uri exception' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr exception + return maybeResult + +#if ENABLE_OVERLOADING +data ExceptionGetSourceUriMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsException a) => O.MethodInfo ExceptionGetSourceUriMethodInfo a signature where + overloadedMethod _ = exceptionGetSourceUri + +#endif + +-- method Exception::report +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_exception_report" jsc_exception_report :: + Ptr Exception -> -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}) + IO CString + +{- | +Return a report message of /@exception@/, containing all the possible details such us +source URI, line, column and backtrace, and formatted to be printed. +-} +exceptionReport :: + (B.CallStack.HasCallStack, MonadIO m, IsException a) => + a + {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -} + -> m T.Text + {- ^ __Returns:__ a new string with the exception report -} +exceptionReport exception = liftIO $ do + exception' <- unsafeManagedPtrCastPtr exception + result <- jsc_exception_report exception' + checkUnexpectedReturnNULL "exceptionReport" result + result' <- cstringToText result + freeMem result + touchManagedPtr exception + return result' + +#if ENABLE_OVERLOADING +data ExceptionReportMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsException a) => O.MethodInfo ExceptionReportMethodInfo a signature where + overloadedMethod _ = exceptionReport + +#endif + +-- method Exception::to_string +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_exception_to_string" jsc_exception_to_string :: + Ptr Exception -> -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}) + IO CString + +{- | +Get the string representation of /@exception@/ error. +-} +exceptionToString :: + (B.CallStack.HasCallStack, MonadIO m, IsException a) => + a + {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -} + -> m T.Text + {- ^ __Returns:__ the string representation of /@exception@/. -} +exceptionToString exception = liftIO $ do + exception' <- unsafeManagedPtrCastPtr exception + result <- jsc_exception_to_string exception' + checkUnexpectedReturnNULL "exceptionToString" result + result' <- cstringToText result + freeMem result + touchManagedPtr exception + return result' + +#if ENABLE_OVERLOADING +data ExceptionToStringMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsException a) => O.MethodInfo ExceptionToStringMethodInfo a signature where + overloadedMethod _ = exceptionToString + +#endif + + diff --git a/GI/JavaScriptCore/Objects/Exception.hs-boot b/GI/JavaScriptCore/Objects/Exception.hs-boot new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Objects/Exception.hs-boot @@ -0,0 +1,53 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.JavaScriptCore.Objects.Exception where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype Exception = Exception (ManagedPtr Exception) +instance GObject Exception where +class (GObject o, O.IsDescendantOf Exception o) => IsException o +instance (GObject o, O.IsDescendantOf Exception o) => IsException o +instance O.HasParentTypes Exception +#if ENABLE_OVERLOADING +data ExceptionGetBacktraceStringMethodInfo +#endif +#if ENABLE_OVERLOADING +data ExceptionGetColumnNumberMethodInfo +#endif +#if ENABLE_OVERLOADING +data ExceptionGetLineNumberMethodInfo +#endif +#if ENABLE_OVERLOADING +data ExceptionGetMessageMethodInfo +#endif +#if ENABLE_OVERLOADING +data ExceptionGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data ExceptionGetSourceUriMethodInfo +#endif +#if ENABLE_OVERLOADING +data ExceptionReportMethodInfo +#endif +#if ENABLE_OVERLOADING +data ExceptionToStringMethodInfo +#endif diff --git a/GI/JavaScriptCore/Objects/Value.hs b/GI/JavaScriptCore/Objects/Value.hs new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Objects/Value.hs @@ -0,0 +1,2132 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.JavaScriptCore.Objects.Value + ( + +-- * Exported types + Value(..) , + IsValue , + toValue , + noValue , + + + -- * Methods +-- ** constructorCall #method:constructorCall# + +#if ENABLE_OVERLOADING + ValueConstructorCallMethodInfo , +#endif + valueConstructorCall , + + +-- ** functionCall #method:functionCall# + +#if ENABLE_OVERLOADING + ValueFunctionCallMethodInfo , +#endif + valueFunctionCall , + + +-- ** getContext #method:getContext# + +#if ENABLE_OVERLOADING + ValueGetContextMethodInfo , +#endif + valueGetContext , + + +-- ** isArray #method:isArray# + +#if ENABLE_OVERLOADING + ValueIsArrayMethodInfo , +#endif + valueIsArray , + + +-- ** isBoolean #method:isBoolean# + +#if ENABLE_OVERLOADING + ValueIsBooleanMethodInfo , +#endif + valueIsBoolean , + + +-- ** isConstructor #method:isConstructor# + +#if ENABLE_OVERLOADING + ValueIsConstructorMethodInfo , +#endif + valueIsConstructor , + + +-- ** isFunction #method:isFunction# + +#if ENABLE_OVERLOADING + ValueIsFunctionMethodInfo , +#endif + valueIsFunction , + + +-- ** isNull #method:isNull# + +#if ENABLE_OVERLOADING + ValueIsNullMethodInfo , +#endif + valueIsNull , + + +-- ** isNumber #method:isNumber# + +#if ENABLE_OVERLOADING + ValueIsNumberMethodInfo , +#endif + valueIsNumber , + + +-- ** isObject #method:isObject# + +#if ENABLE_OVERLOADING + ValueIsObjectMethodInfo , +#endif + valueIsObject , + + +-- ** isString #method:isString# + +#if ENABLE_OVERLOADING + ValueIsStringMethodInfo , +#endif + valueIsString , + + +-- ** isUndefined #method:isUndefined# + +#if ENABLE_OVERLOADING + ValueIsUndefinedMethodInfo , +#endif + valueIsUndefined , + + +-- ** newArrayFromGarray #method:newArrayFromGarray# + + valueNewArrayFromGarray , + + +-- ** newArrayFromStrv #method:newArrayFromStrv# + + valueNewArrayFromStrv , + + +-- ** newBoolean #method:newBoolean# + + valueNewBoolean , + + +-- ** newFunction #method:newFunction# + + valueNewFunction , + + +-- ** newFunctionVariadic #method:newFunctionVariadic# + + valueNewFunctionVariadic , + + +-- ** newNull #method:newNull# + + valueNewNull , + + +-- ** newNumber #method:newNumber# + + valueNewNumber , + + +-- ** newObject #method:newObject# + + valueNewObject , + + +-- ** newString #method:newString# + + valueNewString , + + +-- ** newStringFromBytes #method:newStringFromBytes# + + valueNewStringFromBytes , + + +-- ** newUndefined #method:newUndefined# + + valueNewUndefined , + + +-- ** objectDefinePropertyAccessor #method:objectDefinePropertyAccessor# + +#if ENABLE_OVERLOADING + ValueObjectDefinePropertyAccessorMethodInfo, +#endif + valueObjectDefinePropertyAccessor , + + +-- ** objectDefinePropertyData #method:objectDefinePropertyData# + +#if ENABLE_OVERLOADING + ValueObjectDefinePropertyDataMethodInfo , +#endif + valueObjectDefinePropertyData , + + +-- ** objectDeleteProperty #method:objectDeleteProperty# + +#if ENABLE_OVERLOADING + ValueObjectDeletePropertyMethodInfo , +#endif + valueObjectDeleteProperty , + + +-- ** objectEnumerateProperties #method:objectEnumerateProperties# + +#if ENABLE_OVERLOADING + ValueObjectEnumeratePropertiesMethodInfo, +#endif + valueObjectEnumerateProperties , + + +-- ** objectGetProperty #method:objectGetProperty# + +#if ENABLE_OVERLOADING + ValueObjectGetPropertyMethodInfo , +#endif + valueObjectGetProperty , + + +-- ** objectGetPropertyAtIndex #method:objectGetPropertyAtIndex# + +#if ENABLE_OVERLOADING + ValueObjectGetPropertyAtIndexMethodInfo , +#endif + valueObjectGetPropertyAtIndex , + + +-- ** objectHasProperty #method:objectHasProperty# + +#if ENABLE_OVERLOADING + ValueObjectHasPropertyMethodInfo , +#endif + valueObjectHasProperty , + + +-- ** objectInvokeMethod #method:objectInvokeMethod# + +#if ENABLE_OVERLOADING + ValueObjectInvokeMethodMethodInfo , +#endif + valueObjectInvokeMethod , + + +-- ** objectIsInstanceOf #method:objectIsInstanceOf# + +#if ENABLE_OVERLOADING + ValueObjectIsInstanceOfMethodInfo , +#endif + valueObjectIsInstanceOf , + + +-- ** objectSetProperty #method:objectSetProperty# + +#if ENABLE_OVERLOADING + ValueObjectSetPropertyMethodInfo , +#endif + valueObjectSetProperty , + + +-- ** objectSetPropertyAtIndex #method:objectSetPropertyAtIndex# + +#if ENABLE_OVERLOADING + ValueObjectSetPropertyAtIndexMethodInfo , +#endif + valueObjectSetPropertyAtIndex , + + +-- ** toBoolean #method:toBoolean# + +#if ENABLE_OVERLOADING + ValueToBooleanMethodInfo , +#endif + valueToBoolean , + + +-- ** toDouble #method:toDouble# + +#if ENABLE_OVERLOADING + ValueToDoubleMethodInfo , +#endif + valueToDouble , + + +-- ** toInt32 #method:toInt32# + +#if ENABLE_OVERLOADING + ValueToInt32MethodInfo , +#endif + valueToInt32 , + + +-- ** toString #method:toString# + +#if ENABLE_OVERLOADING + ValueToStringMethodInfo , +#endif + valueToString , + + +-- ** toStringAsBytes #method:toStringAsBytes# + +#if ENABLE_OVERLOADING + ValueToStringAsBytesMethodInfo , +#endif + valueToStringAsBytes , + + + + + -- * Properties +-- ** context #attr:context# +{- | The 'GI.JavaScriptCore.Objects.Context.Context' in which the value was created. +-} +#if ENABLE_OVERLOADING + ValueContextPropertyInfo , +#endif + constructValueContext , + getValueContext , +#if ENABLE_OVERLOADING + valueContext , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.Bytes as GLib.Bytes +import qualified GI.GObject.Callbacks as GObject.Callbacks +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.JavaScriptCore.Flags as JavaScriptCore.Flags +import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Class as JavaScriptCore.Class +import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Context as JavaScriptCore.Context + +-- | Memory-managed wrapper type. +newtype Value = Value (ManagedPtr Value) +foreign import ccall "jsc_value_get_type" + c_jsc_value_get_type :: IO GType + +instance GObject Value where + gobjectType = c_jsc_value_get_type + + +-- | Type class for types which can be safely cast to `Value`, for instance with `toValue`. +class (GObject o, O.IsDescendantOf Value o) => IsValue o +instance (GObject o, O.IsDescendantOf Value o) => IsValue o + +instance O.HasParentTypes Value +type instance O.ParentTypes Value = '[GObject.Object.Object] + +-- | Cast to `Value`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toValue :: (MonadIO m, IsValue o) => o -> m Value +toValue = liftIO . unsafeCastTo Value + +-- | A convenience alias for `Nothing` :: `Maybe` `Value`. +noValue :: Maybe Value +noValue = Nothing + +#if ENABLE_OVERLOADING +type family ResolveValueMethod (t :: Symbol) (o :: *) :: * where + ResolveValueMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveValueMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveValueMethod "constructorCall" o = ValueConstructorCallMethodInfo + ResolveValueMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveValueMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveValueMethod "functionCall" o = ValueFunctionCallMethodInfo + ResolveValueMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveValueMethod "isArray" o = ValueIsArrayMethodInfo + ResolveValueMethod "isBoolean" o = ValueIsBooleanMethodInfo + ResolveValueMethod "isConstructor" o = ValueIsConstructorMethodInfo + ResolveValueMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveValueMethod "isFunction" o = ValueIsFunctionMethodInfo + ResolveValueMethod "isNull" o = ValueIsNullMethodInfo + ResolveValueMethod "isNumber" o = ValueIsNumberMethodInfo + ResolveValueMethod "isObject" o = ValueIsObjectMethodInfo + ResolveValueMethod "isString" o = ValueIsStringMethodInfo + ResolveValueMethod "isUndefined" o = ValueIsUndefinedMethodInfo + ResolveValueMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveValueMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveValueMethod "objectDefinePropertyAccessor" o = ValueObjectDefinePropertyAccessorMethodInfo + ResolveValueMethod "objectDefinePropertyData" o = ValueObjectDefinePropertyDataMethodInfo + ResolveValueMethod "objectDeleteProperty" o = ValueObjectDeletePropertyMethodInfo + ResolveValueMethod "objectEnumerateProperties" o = ValueObjectEnumeratePropertiesMethodInfo + ResolveValueMethod "objectGetProperty" o = ValueObjectGetPropertyMethodInfo + ResolveValueMethod "objectGetPropertyAtIndex" o = ValueObjectGetPropertyAtIndexMethodInfo + ResolveValueMethod "objectHasProperty" o = ValueObjectHasPropertyMethodInfo + ResolveValueMethod "objectInvokeMethod" o = ValueObjectInvokeMethodMethodInfo + ResolveValueMethod "objectIsInstanceOf" o = ValueObjectIsInstanceOfMethodInfo + ResolveValueMethod "objectSetProperty" o = ValueObjectSetPropertyMethodInfo + ResolveValueMethod "objectSetPropertyAtIndex" o = ValueObjectSetPropertyAtIndexMethodInfo + ResolveValueMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveValueMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveValueMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveValueMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveValueMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveValueMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveValueMethod "toBoolean" o = ValueToBooleanMethodInfo + ResolveValueMethod "toDouble" o = ValueToDoubleMethodInfo + ResolveValueMethod "toInt32" o = ValueToInt32MethodInfo + ResolveValueMethod "toString" o = ValueToStringMethodInfo + ResolveValueMethod "toStringAsBytes" o = ValueToStringAsBytesMethodInfo + ResolveValueMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveValueMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveValueMethod "getContext" o = ValueGetContextMethodInfo + ResolveValueMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveValueMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveValueMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveValueMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveValueMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveValueMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveValueMethod t Value, O.MethodInfo info Value p) => OL.IsLabel t (Value -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- VVV Prop "context" + -- Type: TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@context@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' value #context +@ +-} +getValueContext :: (MonadIO m, IsValue o) => o -> m JavaScriptCore.Context.Context +getValueContext obj = liftIO $ checkUnexpectedNothing "getValueContext" $ B.Properties.getObjectPropertyObject obj "context" JavaScriptCore.Context.Context + +{- | +Construct a `GValueConstruct` with valid value for the “@context@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructValueContext :: (IsValue o, JavaScriptCore.Context.IsContext a) => a -> IO (GValueConstruct o) +constructValueContext val = B.Properties.constructObjectPropertyObject "context" (Just val) + +#if ENABLE_OVERLOADING +data ValueContextPropertyInfo +instance AttrInfo ValueContextPropertyInfo where + type AttrAllowedOps ValueContextPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ValueContextPropertyInfo = JavaScriptCore.Context.IsContext + type AttrBaseTypeConstraint ValueContextPropertyInfo = IsValue + type AttrGetType ValueContextPropertyInfo = JavaScriptCore.Context.Context + type AttrLabel ValueContextPropertyInfo = "context" + type AttrOrigin ValueContextPropertyInfo = Value + attrGet _ = getValueContext + attrSet _ = undefined + attrConstruct _ = constructValueContext + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Value +type instance O.AttributeList Value = ValueAttributeList +type ValueAttributeList = ('[ '("context", ValueContextPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +valueContext :: AttrLabelProxy "context" +valueContext = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Value = ValueSignalList +type ValueSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Value::new_array_from_garray +-- method type : Constructor +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "array", argType = TPtrArray (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GPtrArray", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_new_array_from_garray" jsc_value_new_array_from_garray :: + Ptr JavaScriptCore.Context.Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + Ptr (GPtrArray (Ptr Value)) -> -- array : TPtrArray (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) + IO (Ptr Value) + +{- | +Create a new 'GI.JavaScriptCore.Objects.Value.Value' referencing an array with the items from /@array@/. If /@array@/ +is 'Nothing' or empty a new empty array will be created. Elements of /@array@/ should be +pointers to a 'GI.JavaScriptCore.Objects.Value.Value'. +-} +valueNewArrayFromGarray :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> Maybe ([Value]) + {- ^ /@array@/: a 'GI.GLib.Structs.PtrArray.PtrArray' -} + -> m Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -} +valueNewArrayFromGarray context array = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + maybeArray <- case array of + Nothing -> return nullPtr + Just jArray -> do + jArray' <- mapM unsafeManagedPtrCastPtr jArray + jArray'' <- packGPtrArray jArray' + return jArray'' + result <- jsc_value_new_array_from_garray context' maybeArray + checkUnexpectedReturnNULL "valueNewArrayFromGarray" result + result' <- (wrapObject Value) result + touchManagedPtr context + whenJust array (mapM_ touchManagedPtr) + unrefPtrArray maybeArray + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Value::new_array_from_strv +-- method type : Constructor +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "strv", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a %NULL-terminated array of strings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_new_array_from_strv" jsc_value_new_array_from_strv :: + Ptr JavaScriptCore.Context.Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + Ptr CString -> -- strv : TCArray True (-1) (-1) (TBasicType TUTF8) + IO (Ptr Value) + +{- | +Create a new 'GI.JavaScriptCore.Objects.Value.Value' referencing an array of strings with the items from /@strv@/. If /@array@/ +is 'Nothing' or empty a new empty array will be created. +-} +valueNewArrayFromStrv :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> [T.Text] + {- ^ /@strv@/: a 'Nothing'-terminated array of strings -} + -> m Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -} +valueNewArrayFromStrv context strv = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + strv' <- packZeroTerminatedUTF8CArray strv + result <- jsc_value_new_array_from_strv context' strv' + checkUnexpectedReturnNULL "valueNewArrayFromStrv" result + result' <- (wrapObject Value) result + touchManagedPtr context + mapZeroTerminatedCArray freeMem strv' + freeMem strv' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Value::new_boolean +-- method type : Constructor +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gboolean", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_new_boolean" jsc_value_new_boolean :: + Ptr JavaScriptCore.Context.Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + CInt -> -- value : TBasicType TBoolean + IO (Ptr Value) + +{- | +Create a new 'GI.JavaScriptCore.Objects.Value.Value' from /@value@/ +-} +valueNewBoolean :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> Bool + {- ^ /@value@/: a 'Bool' -} + -> m Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -} +valueNewBoolean context value = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + let value' = (fromIntegral . fromEnum) value + result <- jsc_value_new_boolean context' value' + checkUnexpectedReturnNULL "valueNewBoolean" result + result' <- (wrapObject Value) result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Value::new_function_variadic +-- method type : Constructor +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the function name or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GCallback.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @callback.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of the function return value, or %G_TYPE_NONE if the function is void.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_new_function_variadic" jsc_value_new_function_variadic :: + Ptr JavaScriptCore.Context.Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + CString -> -- name : TBasicType TUTF8 + FunPtr GObject.Callbacks.C_Callback -> -- callback : TInterface (Name {namespace = "GObject", name = "Callback"}) + Ptr () -> -- user_data : TBasicType TPtr + FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + CGType -> -- return_type : TBasicType TGType + IO (Ptr Value) + +{- | +Create a function in /@context@/. If /@name@/ is 'Nothing' an anonymous function will be created. +When the function is called by JavaScript or @/jsc_value_function_call()/@, /@callback@/ is called +receiving an 'GI.GLib.Structs.PtrArray.PtrArray' of 'GI.JavaScriptCore.Objects.Value.Value'\s with the arguments and then /@userData@/ as last parameter. +When the function is cleared in /@context@/, /@destroyNotify@/ is called with /@userData@/ as parameter. + +Note that the value returned by /@callback@/ must be fully transferred. In case of boxed types, you could use +@/G_TYPE_POINTER/@ instead of the actual boxed 'GType' to ensure that the instance owned by 'GI.JavaScriptCore.Objects.Class.Class' is used. +If you really want to return a new copy of the boxed type, use @/JSC_TYPE_VALUE/@ and return a 'GI.JavaScriptCore.Objects.Value.Value' created +with 'GI.JavaScriptCore.Objects.Value.valueNewObject' that receives the copy as instance parameter. +-} +valueNewFunctionVariadic :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> Maybe (T.Text) + {- ^ /@name@/: the function name or 'Nothing' -} + -> GObject.Callbacks.Callback + {- ^ /@callback@/: a 'GI.GObject.Callbacks.Callback'. -} + -> GType + {- ^ /@returnType@/: the 'GType' of the function return value, or @/G_TYPE_NONE/@ if the function is void. -} + -> m Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -} +valueNewFunctionVariadic context name callback returnType = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + maybeName <- case name of + Nothing -> return nullPtr + Just jName -> do + jName' <- textToCString jName + return jName' + callback' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback Nothing callback) + let returnType' = gtypeToCGType returnType + let userData = castFunPtrToPtr callback' + let destroyNotify = safeFreeFunPtrPtr + result <- jsc_value_new_function_variadic context' maybeName callback' userData destroyNotify returnType' + checkUnexpectedReturnNULL "valueNewFunctionVariadic" result + result' <- (wrapObject Value) result + touchManagedPtr context + freeMem maybeName + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Value::new_function +-- method type : Constructor +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the function name or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GCallback.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @callback.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of the function return value, or %G_TYPE_NONE if the function is void.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameter_types", argType = TCArray False (-1) 6 (TBasicType TGType), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a list of #GTypes, one for each parameter, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_new_functionv" jsc_value_new_functionv :: + Ptr JavaScriptCore.Context.Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + CString -> -- name : TBasicType TUTF8 + FunPtr GObject.Callbacks.C_Callback -> -- callback : TInterface (Name {namespace = "GObject", name = "Callback"}) + Ptr () -> -- user_data : TBasicType TPtr + FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + CGType -> -- return_type : TBasicType TGType + Word32 -> -- n_parameters : TBasicType TUInt + Ptr CGType -> -- parameter_types : TCArray False (-1) 6 (TBasicType TGType) + IO (Ptr Value) + +{- | +Create a function in /@context@/. If /@name@/ is 'Nothing' an anonymous function will be created. +When the function is called by JavaScript or @/jsc_value_function_call()/@, /@callback@/ is called +receiving the function parameters and then /@userData@/ as last parameter. When the function is +cleared in /@context@/, /@destroyNotify@/ is called with /@userData@/ as parameter. + +Note that the value returned by /@callback@/ must be fully transferred. In case of boxed types, you could use +@/G_TYPE_POINTER/@ instead of the actual boxed 'GType' to ensure that the instance owned by 'GI.JavaScriptCore.Objects.Class.Class' is used. +If you really want to return a new copy of the boxed type, use @/JSC_TYPE_VALUE/@ and return a 'GI.JavaScriptCore.Objects.Value.Value' created +with 'GI.JavaScriptCore.Objects.Value.valueNewObject' that receives the copy as instance parameter. +-} +valueNewFunction :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> Maybe (T.Text) + {- ^ /@name@/: the function name or 'Nothing' -} + -> GObject.Callbacks.Callback + {- ^ /@callback@/: a 'GI.GObject.Callbacks.Callback'. -} + -> GType + {- ^ /@returnType@/: the 'GType' of the function return value, or @/G_TYPE_NONE/@ if the function is void. -} + -> Maybe ([GType]) + {- ^ /@parameterTypes@/: a list of 'GType'\s, one for each parameter, or 'Nothing' -} + -> m Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -} +valueNewFunction context name callback returnType parameterTypes = liftIO $ do + let nParameters = case parameterTypes of + Nothing -> 0 + Just jParameterTypes -> fromIntegral $ length jParameterTypes + context' <- unsafeManagedPtrCastPtr context + maybeName <- case name of + Nothing -> return nullPtr + Just jName -> do + jName' <- textToCString jName + return jName' + callback' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback Nothing callback) + let returnType' = gtypeToCGType returnType + maybeParameterTypes <- case parameterTypes of + Nothing -> return nullPtr + Just jParameterTypes -> do + jParameterTypes' <- (packMapStorableArray gtypeToCGType) jParameterTypes + return jParameterTypes' + let userData = castFunPtrToPtr callback' + let destroyNotify = safeFreeFunPtrPtr + result <- jsc_value_new_functionv context' maybeName callback' userData destroyNotify returnType' nParameters maybeParameterTypes + checkUnexpectedReturnNULL "valueNewFunction" result + result' <- (wrapObject Value) result + touchManagedPtr context + freeMem maybeName + freeMem maybeParameterTypes + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Value::new_null +-- method type : Constructor +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_new_null" jsc_value_new_null :: + Ptr JavaScriptCore.Context.Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + IO (Ptr Value) + +{- | +Create a new 'GI.JavaScriptCore.Objects.Value.Value' referencing \null\<\/function> in /@context@/. +-} +valueNewNull :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> m Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -} +valueNewNull context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- jsc_value_new_null context' + checkUnexpectedReturnNULL "valueNewNull" result + result' <- (wrapObject Value) result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Value::new_number +-- method type : Constructor +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "number", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_new_number" jsc_value_new_number :: + Ptr JavaScriptCore.Context.Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + CDouble -> -- number : TBasicType TDouble + IO (Ptr Value) + +{- | +Create a new 'GI.JavaScriptCore.Objects.Value.Value' from /@number@/. +-} +valueNewNumber :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> Double + {- ^ /@number@/: a number -} + -> m Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -} +valueNewNumber context number = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + let number' = realToFrac number + result <- jsc_value_new_number context' number' + checkUnexpectedReturnNULL "valueNewNumber" result + result' <- (wrapObject Value) result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Value::new_object +-- method type : Constructor +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "an object instance or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #JSCClass of @instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_new_object" jsc_value_new_object :: + Ptr JavaScriptCore.Context.Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + Ptr () -> -- instance : TBasicType TPtr + Ptr JavaScriptCore.Class.Class -> -- jsc_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"}) + IO (Ptr Value) + +{- | +Create a new 'GI.JavaScriptCore.Objects.Value.Value' from /@instance@/. If /@instance@/ is 'Nothing' a new empty object is created. +When /@instance@/ is provided, /@jscClass@/ must be provided too. /@jscClass@/ takes ownership of +/@instance@/ that will be freed by the 'GI.GLib.Callbacks.DestroyNotify' passed to 'GI.JavaScriptCore.Objects.Context.contextRegisterClass'. +-} +valueNewObject :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a, JavaScriptCore.Class.IsClass b) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> Ptr () + {- ^ /@instance@/: an object instance or 'Nothing' -} + -> Maybe (b) + {- ^ /@jscClass@/: the 'GI.JavaScriptCore.Objects.Class.Class' of /@instance@/ -} + -> m Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -} +valueNewObject context instance_ jscClass = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + maybeJscClass <- case jscClass of + Nothing -> return nullPtr + Just jJscClass -> do + jJscClass' <- unsafeManagedPtrCastPtr jJscClass + return jJscClass' + result <- jsc_value_new_object context' instance_ maybeJscClass + checkUnexpectedReturnNULL "valueNewObject" result + result' <- (wrapObject Value) result + touchManagedPtr context + whenJust jscClass touchManagedPtr + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Value::new_string +-- method type : Constructor +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a null-terminated string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_new_string" jsc_value_new_string :: + Ptr JavaScriptCore.Context.Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + CString -> -- string : TBasicType TUTF8 + IO (Ptr Value) + +{- | +Create a new 'GI.JavaScriptCore.Objects.Value.Value' from /@string@/. If you need to create a 'GI.JavaScriptCore.Objects.Value.Value' from a +string containing null characters, use 'GI.JavaScriptCore.Objects.Value.valueNewStringFromBytes' instead. +-} +valueNewString :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> Maybe (T.Text) + {- ^ /@string@/: a null-terminated string -} + -> m Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -} +valueNewString context string = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + maybeString <- case string of + Nothing -> return nullPtr + Just jString -> do + jString' <- textToCString jString + return jString' + result <- jsc_value_new_string context' maybeString + checkUnexpectedReturnNULL "valueNewString" result + result' <- (wrapObject Value) result + touchManagedPtr context + freeMem maybeString + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Value::new_string_from_bytes +-- method type : Constructor +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GBytes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_new_string_from_bytes" jsc_value_new_string_from_bytes :: + Ptr JavaScriptCore.Context.Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + Ptr GLib.Bytes.Bytes -> -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"}) + IO (Ptr Value) + +{- | +Create a new 'GI.JavaScriptCore.Objects.Value.Value' from /@bytes@/. +-} +valueNewStringFromBytes :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> Maybe (GLib.Bytes.Bytes) + {- ^ /@bytes@/: a 'GI.GLib.Structs.Bytes.Bytes' -} + -> m Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -} +valueNewStringFromBytes context bytes = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + maybeBytes <- case bytes of + Nothing -> return nullPtr + Just jBytes -> do + jBytes' <- unsafeManagedPtrGetPtr jBytes + return jBytes' + result <- jsc_value_new_string_from_bytes context' maybeBytes + checkUnexpectedReturnNULL "valueNewStringFromBytes" result + result' <- (wrapObject Value) result + touchManagedPtr context + whenJust bytes touchManagedPtr + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Value::new_undefined +-- method type : Constructor +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_new_undefined" jsc_value_new_undefined :: + Ptr JavaScriptCore.Context.Context -> -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"}) + IO (Ptr Value) + +{- | +Create a new 'GI.JavaScriptCore.Objects.Value.Value' referencing \undefined\<\/function> in /@context@/. +-} +valueNewUndefined :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) => + a + {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -} + -> m Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -} +valueNewUndefined context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- jsc_value_new_undefined context' + checkUnexpectedReturnNULL "valueNewUndefined" result + result' <- (wrapObject Value) result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Value::constructor_call +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameters", argType = TCArray False (-1) 1 (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #JSCValues to pass as parameters to the constructor, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_constructor_callv" jsc_value_constructor_callv :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + Word32 -> -- n_parameters : TBasicType TUInt + Ptr (Ptr Value) -> -- parameters : TCArray False (-1) 1 (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) + IO (Ptr Value) + +{- | +Invoke \new\<\/function> with constructor referenced by /@value@/. If /@nParameters@/ +is 0 no parameters will be passed to the constructor. +-} +valueConstructorCall :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> Maybe ([Value]) + {- ^ /@parameters@/: the 'GI.JavaScriptCore.Objects.Value.Value'\s to pass as parameters to the constructor, or 'Nothing' -} + -> m Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' referencing the newly created object instance. -} +valueConstructorCall value parameters = liftIO $ do + let nParameters = case parameters of + Nothing -> 0 + Just jParameters -> fromIntegral $ length jParameters + value' <- unsafeManagedPtrCastPtr value + maybeParameters <- case parameters of + Nothing -> return nullPtr + Just jParameters -> do + jParameters' <- mapM unsafeManagedPtrCastPtr jParameters + jParameters'' <- packPtrArray jParameters' + return jParameters'' + result <- jsc_value_constructor_callv value' nParameters maybeParameters + checkUnexpectedReturnNULL "valueConstructorCall" result + result' <- (wrapObject Value) result + touchManagedPtr value + whenJust parameters (mapM_ touchManagedPtr) + freeMem maybeParameters + return result' + +#if ENABLE_OVERLOADING +data ValueConstructorCallMethodInfo +instance (signature ~ (Maybe ([Value]) -> m Value), MonadIO m, IsValue a) => O.MethodInfo ValueConstructorCallMethodInfo a signature where + overloadedMethod _ = valueConstructorCall + +#endif + +-- method Value::function_call +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameters", argType = TCArray False (-1) 1 (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #JSCValues to pass as parameters to the function, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_function_callv" jsc_value_function_callv :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + Word32 -> -- n_parameters : TBasicType TUInt + Ptr (Ptr Value) -> -- parameters : TCArray False (-1) 1 (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) + IO (Ptr Value) + +{- | +Call function referenced by /@value@/, passing the given /@parameters@/. If /@nParameters@/ +is 0 no parameters will be passed to the function. + +This function always returns a 'GI.JavaScriptCore.Objects.Value.Value', in case of void functions a 'GI.JavaScriptCore.Objects.Value.Value' referencing +\undefined\<\/function> is returned +-} +valueFunctionCall :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> Maybe ([Value]) + {- ^ /@parameters@/: the 'GI.JavaScriptCore.Objects.Value.Value'\s to pass as parameters to the function, or 'Nothing' -} + -> m Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' with the return value of the function. -} +valueFunctionCall value parameters = liftIO $ do + let nParameters = case parameters of + Nothing -> 0 + Just jParameters -> fromIntegral $ length jParameters + value' <- unsafeManagedPtrCastPtr value + maybeParameters <- case parameters of + Nothing -> return nullPtr + Just jParameters -> do + jParameters' <- mapM unsafeManagedPtrCastPtr jParameters + jParameters'' <- packPtrArray jParameters' + return jParameters'' + result <- jsc_value_function_callv value' nParameters maybeParameters + checkUnexpectedReturnNULL "valueFunctionCall" result + result' <- (wrapObject Value) result + touchManagedPtr value + whenJust parameters (mapM_ touchManagedPtr) + freeMem maybeParameters + return result' + +#if ENABLE_OVERLOADING +data ValueFunctionCallMethodInfo +instance (signature ~ (Maybe ([Value]) -> m Value), MonadIO m, IsValue a) => O.MethodInfo ValueFunctionCallMethodInfo a signature where + overloadedMethod _ = valueFunctionCall + +#endif + +-- method Value::get_context +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Context"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_get_context" jsc_value_get_context :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO (Ptr JavaScriptCore.Context.Context) + +{- | +Get the 'GI.JavaScriptCore.Objects.Context.Context' in which /@value@/ was created. +-} +valueGetContext :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> m JavaScriptCore.Context.Context + {- ^ __Returns:__ the 'GI.JavaScriptCore.Objects.Value.Value' context. -} +valueGetContext value = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + result <- jsc_value_get_context value' + checkUnexpectedReturnNULL "valueGetContext" result + result' <- (newObject JavaScriptCore.Context.Context) result + touchManagedPtr value + return result' + +#if ENABLE_OVERLOADING +data ValueGetContextMethodInfo +instance (signature ~ (m JavaScriptCore.Context.Context), MonadIO m, IsValue a) => O.MethodInfo ValueGetContextMethodInfo a signature where + overloadedMethod _ = valueGetContext + +#endif + +-- method Value::is_array +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_is_array" jsc_value_is_array :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO CInt + +{- | +Get whether the value referenced by /@value@/ is an array. +-} +valueIsArray :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> m Bool + {- ^ __Returns:__ whether the value is an array. -} +valueIsArray value = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + result <- jsc_value_is_array value' + let result' = (/= 0) result + touchManagedPtr value + return result' + +#if ENABLE_OVERLOADING +data ValueIsArrayMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueIsArrayMethodInfo a signature where + overloadedMethod _ = valueIsArray + +#endif + +-- method Value::is_boolean +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_is_boolean" jsc_value_is_boolean :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO CInt + +{- | +Get whether the value referenced by /@value@/ is a boolean. +-} +valueIsBoolean :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> m Bool + {- ^ __Returns:__ whether the value is a boolean. -} +valueIsBoolean value = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + result <- jsc_value_is_boolean value' + let result' = (/= 0) result + touchManagedPtr value + return result' + +#if ENABLE_OVERLOADING +data ValueIsBooleanMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueIsBooleanMethodInfo a signature where + overloadedMethod _ = valueIsBoolean + +#endif + +-- method Value::is_constructor +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_is_constructor" jsc_value_is_constructor :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO CInt + +{- | +Get whether the value referenced by /@value@/ is a constructor. +-} +valueIsConstructor :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> m Bool + {- ^ __Returns:__ whether the value is a constructor. -} +valueIsConstructor value = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + result <- jsc_value_is_constructor value' + let result' = (/= 0) result + touchManagedPtr value + return result' + +#if ENABLE_OVERLOADING +data ValueIsConstructorMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueIsConstructorMethodInfo a signature where + overloadedMethod _ = valueIsConstructor + +#endif + +-- method Value::is_function +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_is_function" jsc_value_is_function :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO CInt + +{- | +Get whether the value referenced by /@value@/ is a function +-} +valueIsFunction :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> m Bool + {- ^ __Returns:__ whether the value is a function. -} +valueIsFunction value = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + result <- jsc_value_is_function value' + let result' = (/= 0) result + touchManagedPtr value + return result' + +#if ENABLE_OVERLOADING +data ValueIsFunctionMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueIsFunctionMethodInfo a signature where + overloadedMethod _ = valueIsFunction + +#endif + +-- method Value::is_null +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_is_null" jsc_value_is_null :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO CInt + +{- | +Get whether the value referenced by /@value@/ is \null\<\/function>. +-} +valueIsNull :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> m Bool + {- ^ __Returns:__ whether the value is null. -} +valueIsNull value = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + result <- jsc_value_is_null value' + let result' = (/= 0) result + touchManagedPtr value + return result' + +#if ENABLE_OVERLOADING +data ValueIsNullMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueIsNullMethodInfo a signature where + overloadedMethod _ = valueIsNull + +#endif + +-- method Value::is_number +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_is_number" jsc_value_is_number :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO CInt + +{- | +Get whether the value referenced by /@value@/ is a number. +-} +valueIsNumber :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> m Bool + {- ^ __Returns:__ whether the value is a number. -} +valueIsNumber value = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + result <- jsc_value_is_number value' + let result' = (/= 0) result + touchManagedPtr value + return result' + +#if ENABLE_OVERLOADING +data ValueIsNumberMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueIsNumberMethodInfo a signature where + overloadedMethod _ = valueIsNumber + +#endif + +-- method Value::is_object +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_is_object" jsc_value_is_object :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO CInt + +{- | +Get whether the value referenced by /@value@/ is an object. +-} +valueIsObject :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> m Bool + {- ^ __Returns:__ whether the value is an object. -} +valueIsObject value = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + result <- jsc_value_is_object value' + let result' = (/= 0) result + touchManagedPtr value + return result' + +#if ENABLE_OVERLOADING +data ValueIsObjectMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueIsObjectMethodInfo a signature where + overloadedMethod _ = valueIsObject + +#endif + +-- method Value::is_string +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_is_string" jsc_value_is_string :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO CInt + +{- | +Get whether the value referenced by /@value@/ is a string +-} +valueIsString :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> m Bool + {- ^ __Returns:__ whether the value is a string -} +valueIsString value = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + result <- jsc_value_is_string value' + let result' = (/= 0) result + touchManagedPtr value + return result' + +#if ENABLE_OVERLOADING +data ValueIsStringMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueIsStringMethodInfo a signature where + overloadedMethod _ = valueIsString + +#endif + +-- method Value::is_undefined +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_is_undefined" jsc_value_is_undefined :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO CInt + +{- | +Get whether the value referenced by /@value@/ is \undefined\<\/function>. +-} +valueIsUndefined :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> m Bool + {- ^ __Returns:__ whether the value is undefined. -} +valueIsUndefined value = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + result <- jsc_value_is_undefined value' + let result' = (/= 0) result + touchManagedPtr value + return result' + +#if ENABLE_OVERLOADING +data ValueIsUndefinedMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueIsUndefinedMethodInfo a signature where + overloadedMethod _ = valueIsUndefined + +#endif + +-- method Value::object_define_property_accessor +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the property to define", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "JavaScriptCore", name = "ValuePropertyFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#JSCValuePropertyFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of the property", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "getter", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCallback to be called to get the property value", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "setter", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCallback to be called to set the property value", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 6, argDestroy = 7, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @getter and @setter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_object_define_property_accessor" jsc_value_object_define_property_accessor :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + CString -> -- property_name : TBasicType TUTF8 + CUInt -> -- flags : TInterface (Name {namespace = "JavaScriptCore", name = "ValuePropertyFlags"}) + CGType -> -- property_type : TBasicType TGType + FunPtr GObject.Callbacks.C_Callback -> -- getter : TInterface (Name {namespace = "GObject", name = "Callback"}) + FunPtr GObject.Callbacks.C_Callback -> -- setter : TInterface (Name {namespace = "GObject", name = "Callback"}) + Ptr () -> -- user_data : TBasicType TPtr + FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + IO () + +{- | +Define or modify a property with /@propertyName@/ in object referenced by /@value@/. When the +property value needs to be getted or set, /@getter@/ and /@setter@/ callbacks will be called. +When the property is cleared in the 'GI.JavaScriptCore.Objects.Class.Class' context, /@destroyNotify@/ is called with +/@userData@/ as parameter. This is equivalent to JavaScript \Object.@/defineProperty()/@\<\/function> +when used with an accessor descriptor. + +Note that the value returned by /@getter@/ must be fully transferred. In case of boxed types, you could use +@/G_TYPE_POINTER/@ instead of the actual boxed 'GType' to ensure that the instance owned by 'GI.JavaScriptCore.Objects.Class.Class' is used. +If you really want to return a new copy of the boxed type, use @/JSC_TYPE_VALUE/@ and return a 'GI.JavaScriptCore.Objects.Value.Value' created +with 'GI.JavaScriptCore.Objects.Value.valueNewObject' that receives the copy as instance parameter. +-} +valueObjectDefinePropertyAccessor :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> T.Text + {- ^ /@propertyName@/: the name of the property to define -} + -> [JavaScriptCore.Flags.ValuePropertyFlags] + {- ^ /@flags@/: 'GI.JavaScriptCore.Flags.ValuePropertyFlags' -} + -> GType + {- ^ /@propertyType@/: the 'GType' of the property -} + -> Maybe (GObject.Callbacks.Callback) + {- ^ /@getter@/: a 'GI.GObject.Callbacks.Callback' to be called to get the property value -} + -> Maybe (GObject.Callbacks.Callback) + {- ^ /@setter@/: a 'GI.GObject.Callbacks.Callback' to be called to set the property value -} + -> m () +valueObjectDefinePropertyAccessor value propertyName flags propertyType getter setter = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + propertyName' <- textToCString propertyName + let flags' = gflagsToWord flags + let propertyType' = gtypeToCGType propertyType + maybeGetter <- case getter of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jGetter -> do + ptrgetter <- callocMem :: IO (Ptr (FunPtr GObject.Callbacks.C_Callback)) + jGetter' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback (Just ptrgetter) jGetter) + poke ptrgetter jGetter' + return jGetter' + maybeSetter <- case setter of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jSetter -> do + jSetter' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback Nothing jSetter) + return jSetter' + let userData = castFunPtrToPtr maybeSetter + let destroyNotify = safeFreeFunPtrPtr + jsc_value_object_define_property_accessor value' propertyName' flags' propertyType' maybeGetter maybeSetter userData destroyNotify + touchManagedPtr value + freeMem propertyName' + return () + +#if ENABLE_OVERLOADING +data ValueObjectDefinePropertyAccessorMethodInfo +instance (signature ~ (T.Text -> [JavaScriptCore.Flags.ValuePropertyFlags] -> GType -> Maybe (GObject.Callbacks.Callback) -> Maybe (GObject.Callbacks.Callback) -> m ()), MonadIO m, IsValue a) => O.MethodInfo ValueObjectDefinePropertyAccessorMethodInfo a signature where + overloadedMethod _ = valueObjectDefinePropertyAccessor + +#endif + +-- method Value::object_define_property_data +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the property to define", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "JavaScriptCore", name = "ValuePropertyFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#JSCValuePropertyFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the default property value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_object_define_property_data" jsc_value_object_define_property_data :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + CString -> -- property_name : TBasicType TUTF8 + CUInt -> -- flags : TInterface (Name {namespace = "JavaScriptCore", name = "ValuePropertyFlags"}) + Ptr Value -> -- property_value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO () + +{- | +Define or modify a property with /@propertyName@/ in object referenced by /@value@/. This is equivalent to +JavaScript \Object.@/defineProperty()/@\<\/function> when used with a data descriptor. +-} +valueObjectDefinePropertyData :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a, IsValue b) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> T.Text + {- ^ /@propertyName@/: the name of the property to define -} + -> [JavaScriptCore.Flags.ValuePropertyFlags] + {- ^ /@flags@/: 'GI.JavaScriptCore.Flags.ValuePropertyFlags' -} + -> Maybe (b) + {- ^ /@propertyValue@/: the default property value -} + -> m () +valueObjectDefinePropertyData value propertyName flags propertyValue = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + propertyName' <- textToCString propertyName + let flags' = gflagsToWord flags + maybePropertyValue <- case propertyValue of + Nothing -> return nullPtr + Just jPropertyValue -> do + jPropertyValue' <- unsafeManagedPtrCastPtr jPropertyValue + return jPropertyValue' + jsc_value_object_define_property_data value' propertyName' flags' maybePropertyValue + touchManagedPtr value + whenJust propertyValue touchManagedPtr + freeMem propertyName' + return () + +#if ENABLE_OVERLOADING +data ValueObjectDefinePropertyDataMethodInfo +instance (signature ~ (T.Text -> [JavaScriptCore.Flags.ValuePropertyFlags] -> Maybe (b) -> m ()), MonadIO m, IsValue a, IsValue b) => O.MethodInfo ValueObjectDefinePropertyDataMethodInfo a signature where + overloadedMethod _ = valueObjectDefinePropertyData + +#endif + +-- method Value::object_delete_property +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_object_delete_property" jsc_value_object_delete_property :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + CString -> -- name : TBasicType TUTF8 + IO CInt + +{- | +Try to delete property with /@name@/ from /@value@/. This function will return 'False' if +the property was defined without 'GI.JavaScriptCore.Flags.ValuePropertyFlagsConfigurable' flag. +-} +valueObjectDeleteProperty :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> T.Text + {- ^ /@name@/: the property name -} + -> m Bool + {- ^ __Returns:__ 'True' if the property was deleted, or 'False' otherwise. -} +valueObjectDeleteProperty value name = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + name' <- textToCString name + result <- jsc_value_object_delete_property value' name' + let result' = (/= 0) result + touchManagedPtr value + freeMem name' + return result' + +#if ENABLE_OVERLOADING +data ValueObjectDeletePropertyMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueObjectDeletePropertyMethodInfo a signature where + overloadedMethod _ = valueObjectDeleteProperty + +#endif + +-- method Value::object_enumerate_properties +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_object_enumerate_properties" jsc_value_object_enumerate_properties :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO (Ptr CString) + +{- | +Get the list of property names of /@value@/. Only properties defined with 'GI.JavaScriptCore.Flags.ValuePropertyFlagsEnumerable' +flag will be collected. +-} +valueObjectEnumerateProperties :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> m (Maybe [T.Text]) + {- ^ __Returns:__ a 'Nothing'-terminated array of strings containing the + property names, or 'Nothing' if /@value@/ doesn\'t have enumerable properties. Use 'GI.GLib.Functions.strfreev' to free. -} +valueObjectEnumerateProperties value = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + result <- jsc_value_object_enumerate_properties value' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackZeroTerminatedUTF8CArray result' + mapZeroTerminatedCArray freeMem result' + freeMem result' + return result'' + touchManagedPtr value + return maybeResult + +#if ENABLE_OVERLOADING +data ValueObjectEnumeratePropertiesMethodInfo +instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsValue a) => O.MethodInfo ValueObjectEnumeratePropertiesMethodInfo a signature where + overloadedMethod _ = valueObjectEnumerateProperties + +#endif + +-- method Value::object_get_property +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_object_get_property" jsc_value_object_get_property :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + CString -> -- name : TBasicType TUTF8 + IO (Ptr Value) + +{- | +Get property with /@name@/ from /@value@/. +-} +valueObjectGetProperty :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> T.Text + {- ^ /@name@/: the property name -} + -> m Value + {- ^ __Returns:__ the property 'GI.JavaScriptCore.Objects.Value.Value'. -} +valueObjectGetProperty value name = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + name' <- textToCString name + result <- jsc_value_object_get_property value' name' + checkUnexpectedReturnNULL "valueObjectGetProperty" result + result' <- (wrapObject Value) result + touchManagedPtr value + freeMem name' + return result' + +#if ENABLE_OVERLOADING +data ValueObjectGetPropertyMethodInfo +instance (signature ~ (T.Text -> m Value), MonadIO m, IsValue a) => O.MethodInfo ValueObjectGetPropertyMethodInfo a signature where + overloadedMethod _ = valueObjectGetProperty + +#endif + +-- method Value::object_get_property_at_index +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property index", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_object_get_property_at_index" jsc_value_object_get_property_at_index :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + Word32 -> -- index : TBasicType TUInt + IO (Ptr Value) + +{- | +Get property at /@index@/ from /@value@/. +-} +valueObjectGetPropertyAtIndex :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> Word32 + {- ^ /@index@/: the property index -} + -> m Value + {- ^ __Returns:__ the property 'GI.JavaScriptCore.Objects.Value.Value'. -} +valueObjectGetPropertyAtIndex value index = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + result <- jsc_value_object_get_property_at_index value' index + checkUnexpectedReturnNULL "valueObjectGetPropertyAtIndex" result + result' <- (wrapObject Value) result + touchManagedPtr value + return result' + +#if ENABLE_OVERLOADING +data ValueObjectGetPropertyAtIndexMethodInfo +instance (signature ~ (Word32 -> m Value), MonadIO m, IsValue a) => O.MethodInfo ValueObjectGetPropertyAtIndexMethodInfo a signature where + overloadedMethod _ = valueObjectGetPropertyAtIndex + +#endif + +-- method Value::object_has_property +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_object_has_property" jsc_value_object_has_property :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + CString -> -- name : TBasicType TUTF8 + IO CInt + +{- | +Get whether /@value@/ has property with /@name@/. +-} +valueObjectHasProperty :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> T.Text + {- ^ /@name@/: the property name -} + -> m Bool + {- ^ __Returns:__ 'True' if /@value@/ has a property with /@name@/, or 'False' otherwise -} +valueObjectHasProperty value name = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + name' <- textToCString name + result <- jsc_value_object_has_property value' name' + let result' = (/= 0) result + touchManagedPtr value + freeMem name' + return result' + +#if ENABLE_OVERLOADING +data ValueObjectHasPropertyMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueObjectHasPropertyMethodInfo a signature where + overloadedMethod _ = valueObjectHasProperty + +#endif + +-- method Value::object_invoke_method +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the method name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameters", argType = TCArray False (-1) 2 (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #JSCValues to pass as parameters to the method, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_object_invoke_methodv" jsc_value_object_invoke_methodv :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + CString -> -- name : TBasicType TUTF8 + Word32 -> -- n_parameters : TBasicType TUInt + Ptr (Ptr Value) -> -- parameters : TCArray False (-1) 2 (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) + IO (Ptr Value) + +{- | +Invoke method with /@name@/ on object referenced by /@value@/, passing the given /@parameters@/. If +/@nParameters@/ is 0 no parameters will be passed to the method. +The object instance will be handled automatically even when the method is a custom one +registered with @/jsc_class_add_method()/@, so it should never be passed explicitly as parameter +of this function. + +This function always returns a 'GI.JavaScriptCore.Objects.Value.Value', in case of void methods a 'GI.JavaScriptCore.Objects.Value.Value' referencing +\undefined\<\/function> is returned. +-} +valueObjectInvokeMethod :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> T.Text + {- ^ /@name@/: the method name -} + -> Maybe ([Value]) + {- ^ /@parameters@/: the 'GI.JavaScriptCore.Objects.Value.Value'\s to pass as parameters to the method, or 'Nothing' -} + -> m Value + {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' with the return value of the method. -} +valueObjectInvokeMethod value name parameters = liftIO $ do + let nParameters = case parameters of + Nothing -> 0 + Just jParameters -> fromIntegral $ length jParameters + value' <- unsafeManagedPtrCastPtr value + name' <- textToCString name + maybeParameters <- case parameters of + Nothing -> return nullPtr + Just jParameters -> do + jParameters' <- mapM unsafeManagedPtrCastPtr jParameters + jParameters'' <- packPtrArray jParameters' + return jParameters'' + result <- jsc_value_object_invoke_methodv value' name' nParameters maybeParameters + checkUnexpectedReturnNULL "valueObjectInvokeMethod" result + result' <- (wrapObject Value) result + touchManagedPtr value + whenJust parameters (mapM_ touchManagedPtr) + freeMem name' + freeMem maybeParameters + return result' + +#if ENABLE_OVERLOADING +data ValueObjectInvokeMethodMethodInfo +instance (signature ~ (T.Text -> Maybe ([Value]) -> m Value), MonadIO m, IsValue a) => O.MethodInfo ValueObjectInvokeMethodMethodInfo a signature where + overloadedMethod _ = valueObjectInvokeMethod + +#endif + +-- method Value::object_is_instance_of +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a class name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_object_is_instance_of" jsc_value_object_is_instance_of :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + CString -> -- name : TBasicType TUTF8 + IO CInt + +{- | +Get whether the value referenced by /@value@/ is an instance of class /@name@/. +-} +valueObjectIsInstanceOf :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> T.Text + {- ^ /@name@/: a class name -} + -> m Bool + {- ^ __Returns:__ whether the value is an object instance of class /@name@/. -} +valueObjectIsInstanceOf value name = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + name' <- textToCString name + result <- jsc_value_object_is_instance_of value' name' + let result' = (/= 0) result + touchManagedPtr value + freeMem name' + return result' + +#if ENABLE_OVERLOADING +data ValueObjectIsInstanceOfMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueObjectIsInstanceOfMethodInfo a signature where + overloadedMethod _ = valueObjectIsInstanceOf + +#endif + +-- method Value::object_set_property +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #JSCValue to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_object_set_property" jsc_value_object_set_property :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + CString -> -- name : TBasicType TUTF8 + Ptr Value -> -- property : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO () + +{- | +Set /@property@/ with /@name@/ on /@value@/. +-} +valueObjectSetProperty :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a, IsValue b) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> T.Text + {- ^ /@name@/: the property name -} + -> b + {- ^ /@property@/: the 'GI.JavaScriptCore.Objects.Value.Value' to set -} + -> m () +valueObjectSetProperty value name property = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + name' <- textToCString name + property' <- unsafeManagedPtrCastPtr property + jsc_value_object_set_property value' name' property' + touchManagedPtr value + touchManagedPtr property + freeMem name' + return () + +#if ENABLE_OVERLOADING +data ValueObjectSetPropertyMethodInfo +instance (signature ~ (T.Text -> b -> m ()), MonadIO m, IsValue a, IsValue b) => O.MethodInfo ValueObjectSetPropertyMethodInfo a signature where + overloadedMethod _ = valueObjectSetProperty + +#endif + +-- method Value::object_set_property_at_index +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property index", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #JSCValue to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_object_set_property_at_index" jsc_value_object_set_property_at_index :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + Word32 -> -- index : TBasicType TUInt + Ptr Value -> -- property : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO () + +{- | +Set /@property@/ at /@index@/ on /@value@/. +-} +valueObjectSetPropertyAtIndex :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a, IsValue b) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> Word32 + {- ^ /@index@/: the property index -} + -> b + {- ^ /@property@/: the 'GI.JavaScriptCore.Objects.Value.Value' to set -} + -> m () +valueObjectSetPropertyAtIndex value index property = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + property' <- unsafeManagedPtrCastPtr property + jsc_value_object_set_property_at_index value' index property' + touchManagedPtr value + touchManagedPtr property + return () + +#if ENABLE_OVERLOADING +data ValueObjectSetPropertyAtIndexMethodInfo +instance (signature ~ (Word32 -> b -> m ()), MonadIO m, IsValue a, IsValue b) => O.MethodInfo ValueObjectSetPropertyAtIndexMethodInfo a signature where + overloadedMethod _ = valueObjectSetPropertyAtIndex + +#endif + +-- method Value::to_boolean +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_to_boolean" jsc_value_to_boolean :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO CInt + +{- | +Convert /@value@/ to a boolean. +-} +valueToBoolean :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> m Bool + {- ^ __Returns:__ a 'Bool' result of the conversion. -} +valueToBoolean value = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + result <- jsc_value_to_boolean value' + let result' = (/= 0) result + touchManagedPtr value + return result' + +#if ENABLE_OVERLOADING +data ValueToBooleanMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueToBooleanMethodInfo a signature where + overloadedMethod _ = valueToBoolean + +#endif + +-- method Value::to_double +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_to_double" jsc_value_to_double :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO CDouble + +{- | +Convert /@value@/ to a double. +-} +valueToDouble :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> m Double + {- ^ __Returns:__ a @/gdouble/@ result of the conversion. -} +valueToDouble value = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + result <- jsc_value_to_double value' + let result' = realToFrac result + touchManagedPtr value + return result' + +#if ENABLE_OVERLOADING +data ValueToDoubleMethodInfo +instance (signature ~ (m Double), MonadIO m, IsValue a) => O.MethodInfo ValueToDoubleMethodInfo a signature where + overloadedMethod _ = valueToDouble + +#endif + +-- method Value::to_int32 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_to_int32" jsc_value_to_int32 :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO Int32 + +{- | +Convert /@value@/ to a @/gint32/@. +-} +valueToInt32 :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> m Int32 + {- ^ __Returns:__ a @/gint32/@ result of the conversion. -} +valueToInt32 value = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + result <- jsc_value_to_int32 value' + touchManagedPtr value + return result + +#if ENABLE_OVERLOADING +data ValueToInt32MethodInfo +instance (signature ~ (m Int32), MonadIO m, IsValue a) => O.MethodInfo ValueToInt32MethodInfo a signature where + overloadedMethod _ = valueToInt32 + +#endif + +-- method Value::to_string +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_to_string" jsc_value_to_string :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO CString + +{- | +Convert /@value@/ to a string. Use 'GI.JavaScriptCore.Objects.Value.valueToStringAsBytes' instead, if you need to +handle strings containing null characters. +-} +valueToString :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> m T.Text + {- ^ __Returns:__ a null-terminated string result of the conversion. -} +valueToString value = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + result <- jsc_value_to_string value' + checkUnexpectedReturnNULL "valueToString" result + result' <- cstringToText result + freeMem result + touchManagedPtr value + return result' + +#if ENABLE_OVERLOADING +data ValueToStringMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsValue a) => O.MethodInfo ValueToStringMethodInfo a signature where + overloadedMethod _ = valueToString + +#endif + +-- method Value::to_string_as_bytes +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GLib", name = "Bytes"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_value_to_string_as_bytes" jsc_value_to_string_as_bytes :: + Ptr Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO (Ptr GLib.Bytes.Bytes) + +{- | +Convert /@value@/ to a string and return the results as 'GI.GLib.Structs.Bytes.Bytes'. This is needed +to handle strings with null characters. +-} +valueToStringAsBytes :: + (B.CallStack.HasCallStack, MonadIO m, IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> m GLib.Bytes.Bytes + {- ^ __Returns:__ a 'GI.GLib.Structs.Bytes.Bytes' with the result of the conversion. -} +valueToStringAsBytes value = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + result <- jsc_value_to_string_as_bytes value' + checkUnexpectedReturnNULL "valueToStringAsBytes" result + result' <- (wrapBoxed GLib.Bytes.Bytes) result + touchManagedPtr value + return result' + +#if ENABLE_OVERLOADING +data ValueToStringAsBytesMethodInfo +instance (signature ~ (m GLib.Bytes.Bytes), MonadIO m, IsValue a) => O.MethodInfo ValueToStringAsBytesMethodInfo a signature where + overloadedMethod _ = valueToStringAsBytes + +#endif + + diff --git a/GI/JavaScriptCore/Objects/Value.hs-boot b/GI/JavaScriptCore/Objects/Value.hs-boot new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Objects/Value.hs-boot @@ -0,0 +1,116 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.JavaScriptCore.Objects.Value where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype Value = Value (ManagedPtr Value) +instance GObject Value where +class (GObject o, O.IsDescendantOf Value o) => IsValue o +instance (GObject o, O.IsDescendantOf Value o) => IsValue o +instance O.HasParentTypes Value +#if ENABLE_OVERLOADING +data ValueContextPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ValueConstructorCallMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueFunctionCallMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueGetContextMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueIsArrayMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueIsBooleanMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueIsConstructorMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueIsFunctionMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueIsNullMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueIsNumberMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueIsObjectMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueIsStringMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueIsUndefinedMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueObjectDefinePropertyAccessorMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueObjectDefinePropertyDataMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueObjectDeletePropertyMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueObjectEnumeratePropertiesMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueObjectGetPropertyMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueObjectGetPropertyAtIndexMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueObjectHasPropertyMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueObjectInvokeMethodMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueObjectIsInstanceOfMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueObjectSetPropertyMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueObjectSetPropertyAtIndexMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueToBooleanMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueToDoubleMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueToInt32MethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueToStringMethodInfo +#endif +#if ENABLE_OVERLOADING +data ValueToStringAsBytesMethodInfo +#endif diff --git a/GI/JavaScriptCore/Objects/VirtualMachine.hs b/GI/JavaScriptCore/Objects/VirtualMachine.hs new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Objects/VirtualMachine.hs @@ -0,0 +1,156 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.JavaScriptCore.Objects.VirtualMachine + ( + +-- * Exported types + VirtualMachine(..) , + IsVirtualMachine , + toVirtualMachine , + noVirtualMachine , + + + -- * Methods +-- ** new #method:new# + + virtualMachineNew , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object + +-- | Memory-managed wrapper type. +newtype VirtualMachine = VirtualMachine (ManagedPtr VirtualMachine) +foreign import ccall "jsc_virtual_machine_get_type" + c_jsc_virtual_machine_get_type :: IO GType + +instance GObject VirtualMachine where + gobjectType = c_jsc_virtual_machine_get_type + + +-- | Type class for types which can be safely cast to `VirtualMachine`, for instance with `toVirtualMachine`. +class (GObject o, O.IsDescendantOf VirtualMachine o) => IsVirtualMachine o +instance (GObject o, O.IsDescendantOf VirtualMachine o) => IsVirtualMachine o + +instance O.HasParentTypes VirtualMachine +type instance O.ParentTypes VirtualMachine = '[GObject.Object.Object] + +-- | Cast to `VirtualMachine`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toVirtualMachine :: (MonadIO m, IsVirtualMachine o) => o -> m VirtualMachine +toVirtualMachine = liftIO . unsafeCastTo VirtualMachine + +-- | A convenience alias for `Nothing` :: `Maybe` `VirtualMachine`. +noVirtualMachine :: Maybe VirtualMachine +noVirtualMachine = Nothing + +#if ENABLE_OVERLOADING +type family ResolveVirtualMachineMethod (t :: Symbol) (o :: *) :: * where + ResolveVirtualMachineMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveVirtualMachineMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveVirtualMachineMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveVirtualMachineMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveVirtualMachineMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveVirtualMachineMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveVirtualMachineMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveVirtualMachineMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveVirtualMachineMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveVirtualMachineMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveVirtualMachineMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveVirtualMachineMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveVirtualMachineMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveVirtualMachineMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveVirtualMachineMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveVirtualMachineMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveVirtualMachineMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveVirtualMachineMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveVirtualMachineMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveVirtualMachineMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveVirtualMachineMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveVirtualMachineMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVirtualMachineMethod t VirtualMachine, O.MethodInfo info VirtualMachine p) => OL.IsLabel t (VirtualMachine -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VirtualMachine +type instance O.AttributeList VirtualMachine = VirtualMachineAttributeList +type VirtualMachineAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList VirtualMachine = VirtualMachineSignalList +type VirtualMachineSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method VirtualMachine::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "VirtualMachine"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_virtual_machine_new" jsc_virtual_machine_new :: + IO (Ptr VirtualMachine) + +{- | +Create a new 'GI.JavaScriptCore.Objects.VirtualMachine.VirtualMachine'. +-} +virtualMachineNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m VirtualMachine + {- ^ __Returns:__ the newly created 'GI.JavaScriptCore.Objects.VirtualMachine.VirtualMachine'. -} +virtualMachineNew = liftIO $ do + result <- jsc_virtual_machine_new + checkUnexpectedReturnNULL "virtualMachineNew" result + result' <- (wrapObject VirtualMachine) result + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/JavaScriptCore/Objects/VirtualMachine.hs-boot b/GI/JavaScriptCore/Objects/VirtualMachine.hs-boot new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Objects/VirtualMachine.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.JavaScriptCore.Objects.VirtualMachine where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VirtualMachine = VirtualMachine (ManagedPtr VirtualMachine) +instance GObject VirtualMachine where +class (GObject o, O.IsDescendantOf VirtualMachine o) => IsVirtualMachine o +instance (GObject o, O.IsDescendantOf VirtualMachine o) => IsVirtualMachine o +instance O.HasParentTypes VirtualMachine diff --git a/GI/JavaScriptCore/Objects/WeakValue.hs b/GI/JavaScriptCore/Objects/WeakValue.hs new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Objects/WeakValue.hs @@ -0,0 +1,342 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.JavaScriptCore.Objects.WeakValue + ( + +-- * Exported types + WeakValue(..) , + IsWeakValue , + toWeakValue , + noWeakValue , + + + -- * Methods +-- ** getValue #method:getValue# + +#if ENABLE_OVERLOADING + WeakValueGetValueMethodInfo , +#endif + weakValueGetValue , + + +-- ** new #method:new# + + weakValueNew , + + + + + -- * Properties +-- ** value #attr:value# +{- | The 'GI.JavaScriptCore.Objects.Value.Value' referencing the JavaScript value. +-} +#if ENABLE_OVERLOADING + WeakValueValuePropertyInfo , +#endif + constructWeakValueValue , +#if ENABLE_OVERLOADING + weakValueValue , +#endif + + + + + -- * Signals +-- ** cleared #signal:cleared# + + C_WeakValueClearedCallback , + WeakValueClearedCallback , +#if ENABLE_OVERLOADING + WeakValueClearedSignalInfo , +#endif + afterWeakValueCleared , + genClosure_WeakValueCleared , + mk_WeakValueClearedCallback , + noWeakValueClearedCallback , + onWeakValueCleared , + wrap_WeakValueClearedCallback , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Value as JavaScriptCore.Value + +-- | Memory-managed wrapper type. +newtype WeakValue = WeakValue (ManagedPtr WeakValue) +foreign import ccall "jsc_weak_value_get_type" + c_jsc_weak_value_get_type :: IO GType + +instance GObject WeakValue where + gobjectType = c_jsc_weak_value_get_type + + +-- | Type class for types which can be safely cast to `WeakValue`, for instance with `toWeakValue`. +class (GObject o, O.IsDescendantOf WeakValue o) => IsWeakValue o +instance (GObject o, O.IsDescendantOf WeakValue o) => IsWeakValue o + +instance O.HasParentTypes WeakValue +type instance O.ParentTypes WeakValue = '[GObject.Object.Object] + +-- | Cast to `WeakValue`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toWeakValue :: (MonadIO m, IsWeakValue o) => o -> m WeakValue +toWeakValue = liftIO . unsafeCastTo WeakValue + +-- | A convenience alias for `Nothing` :: `Maybe` `WeakValue`. +noWeakValue :: Maybe WeakValue +noWeakValue = Nothing + +#if ENABLE_OVERLOADING +type family ResolveWeakValueMethod (t :: Symbol) (o :: *) :: * where + ResolveWeakValueMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveWeakValueMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveWeakValueMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveWeakValueMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveWeakValueMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveWeakValueMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveWeakValueMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveWeakValueMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveWeakValueMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveWeakValueMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveWeakValueMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveWeakValueMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveWeakValueMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveWeakValueMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveWeakValueMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveWeakValueMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveWeakValueMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveWeakValueMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveWeakValueMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveWeakValueMethod "getValue" o = WeakValueGetValueMethodInfo + ResolveWeakValueMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveWeakValueMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveWeakValueMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveWeakValueMethod t WeakValue, O.MethodInfo info WeakValue p) => OL.IsLabel t (WeakValue -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- signal WeakValue::cleared +{- | +This signal is emitted when the JavaScript value is destroyed. +-} +type WeakValueClearedCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WeakValueClearedCallback`@. +noWeakValueClearedCallback :: Maybe WeakValueClearedCallback +noWeakValueClearedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WeakValueClearedCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_WeakValueClearedCallback`. +foreign import ccall "wrapper" + mk_WeakValueClearedCallback :: C_WeakValueClearedCallback -> IO (FunPtr C_WeakValueClearedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WeakValueCleared :: MonadIO m => WeakValueClearedCallback -> m (GClosure C_WeakValueClearedCallback) +genClosure_WeakValueCleared cb = liftIO $ do + let cb' = wrap_WeakValueClearedCallback cb + mk_WeakValueClearedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WeakValueClearedCallback` into a `C_WeakValueClearedCallback`. +wrap_WeakValueClearedCallback :: + WeakValueClearedCallback -> + C_WeakValueClearedCallback +wrap_WeakValueClearedCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@cleared@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' weakValue #cleared callback +@ +-} +onWeakValueCleared :: (IsWeakValue a, MonadIO m) => a -> WeakValueClearedCallback -> m SignalHandlerId +onWeakValueCleared obj cb = liftIO $ do + let cb' = wrap_WeakValueClearedCallback cb + cb'' <- mk_WeakValueClearedCallback cb' + connectSignalFunPtr obj "cleared" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@cleared@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' weakValue #cleared callback +@ +-} +afterWeakValueCleared :: (IsWeakValue a, MonadIO m) => a -> WeakValueClearedCallback -> m SignalHandlerId +afterWeakValueCleared obj cb = liftIO $ do + let cb' = wrap_WeakValueClearedCallback cb + cb'' <- mk_WeakValueClearedCallback cb' + connectSignalFunPtr obj "cleared" cb'' SignalConnectAfter + + +-- VVV Prop "value" + -- Type: TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + -- Flags: [PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Construct a `GValueConstruct` with valid value for the “@value@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWeakValueValue :: (IsWeakValue o, JavaScriptCore.Value.IsValue a) => a -> IO (GValueConstruct o) +constructWeakValueValue val = B.Properties.constructObjectPropertyObject "value" (Just val) + +#if ENABLE_OVERLOADING +data WeakValueValuePropertyInfo +instance AttrInfo WeakValueValuePropertyInfo where + type AttrAllowedOps WeakValueValuePropertyInfo = '[ 'AttrConstruct, 'AttrClear] + type AttrSetTypeConstraint WeakValueValuePropertyInfo = JavaScriptCore.Value.IsValue + type AttrBaseTypeConstraint WeakValueValuePropertyInfo = IsWeakValue + type AttrGetType WeakValueValuePropertyInfo = () + type AttrLabel WeakValueValuePropertyInfo = "value" + type AttrOrigin WeakValueValuePropertyInfo = WeakValue + attrGet _ = undefined + attrSet _ = undefined + attrConstruct _ = constructWeakValueValue + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList WeakValue +type instance O.AttributeList WeakValue = WeakValueAttributeList +type WeakValueAttributeList = ('[ '("value", WeakValueValuePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +weakValueValue :: AttrLabelProxy "value" +weakValueValue = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data WeakValueClearedSignalInfo +instance SignalInfo WeakValueClearedSignalInfo where + type HaskellCallbackType WeakValueClearedSignalInfo = WeakValueClearedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WeakValueClearedCallback cb + cb'' <- mk_WeakValueClearedCallback cb' + connectSignalFunPtr obj "cleared" cb'' connectMode + +type instance O.SignalList WeakValue = WeakValueSignalList +type WeakValueSignalList = ('[ '("cleared", WeakValueClearedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method WeakValue::new +-- method type : Constructor +-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "WeakValue"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_weak_value_new" jsc_weak_value_new :: + Ptr JavaScriptCore.Value.Value -> -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"}) + IO (Ptr WeakValue) + +{- | +Create a new 'GI.JavaScriptCore.Objects.WeakValue.WeakValue' for the JavaScript value referenced by /@value@/. +-} +weakValueNew :: + (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Value.IsValue a) => + a + {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -} + -> m WeakValue + {- ^ __Returns:__ a new 'GI.JavaScriptCore.Objects.WeakValue.WeakValue' -} +weakValueNew value = liftIO $ do + value' <- unsafeManagedPtrCastPtr value + result <- jsc_weak_value_new value' + checkUnexpectedReturnNULL "weakValueNew" result + result' <- (wrapObject WeakValue) result + touchManagedPtr value + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method WeakValue::get_value +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "weak_value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "WeakValue"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCWeakValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "jsc_weak_value_get_value" jsc_weak_value_get_value :: + Ptr WeakValue -> -- weak_value : TInterface (Name {namespace = "JavaScriptCore", name = "WeakValue"}) + IO (Ptr JavaScriptCore.Value.Value) + +{- | +Get a 'GI.JavaScriptCore.Objects.Value.Value' referencing the JavaScript value of /@weakValue@/. +-} +weakValueGetValue :: + (B.CallStack.HasCallStack, MonadIO m, IsWeakValue a) => + a + {- ^ /@weakValue@/: a 'GI.JavaScriptCore.Objects.WeakValue.WeakValue' -} + -> m JavaScriptCore.Value.Value + {- ^ __Returns:__ a new 'GI.JavaScriptCore.Objects.Value.Value' or 'Nothing' if /@weakValue@/ was cleared. -} +weakValueGetValue weakValue = liftIO $ do + weakValue' <- unsafeManagedPtrCastPtr weakValue + result <- jsc_weak_value_get_value weakValue' + checkUnexpectedReturnNULL "weakValueGetValue" result + result' <- (wrapObject JavaScriptCore.Value.Value) result + touchManagedPtr weakValue + return result' + +#if ENABLE_OVERLOADING +data WeakValueGetValueMethodInfo +instance (signature ~ (m JavaScriptCore.Value.Value), MonadIO m, IsWeakValue a) => O.MethodInfo WeakValueGetValueMethodInfo a signature where + overloadedMethod _ = weakValueGetValue + +#endif + + diff --git a/GI/JavaScriptCore/Objects/WeakValue.hs-boot b/GI/JavaScriptCore/Objects/WeakValue.hs-boot new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Objects/WeakValue.hs-boot @@ -0,0 +1,38 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.JavaScriptCore.Objects.WeakValue where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype WeakValue = WeakValue (ManagedPtr WeakValue) +instance GObject WeakValue where +class (GObject o, O.IsDescendantOf WeakValue o) => IsWeakValue o +instance (GObject o, O.IsDescendantOf WeakValue o) => IsWeakValue o +instance O.HasParentTypes WeakValue +#if ENABLE_OVERLOADING +data WeakValueValuePropertyInfo +#endif +#if ENABLE_OVERLOADING +data WeakValueClearedSignalInfo +#endif +#if ENABLE_OVERLOADING +data WeakValueGetValueMethodInfo +#endif diff --git a/GI/JavaScriptCore/Structs.hs b/GI/JavaScriptCore/Structs.hs new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Structs.hs @@ -0,0 +1,41 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.JavaScriptCore.Structs + ( module GI.JavaScriptCore.Structs.ClassVTable, + + + ) where + +import GI.JavaScriptCore.Structs.ClassVTable + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + + diff --git a/GI/JavaScriptCore/Structs/ClassVTable.hs b/GI/JavaScriptCore/Structs/ClassVTable.hs new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Structs/ClassVTable.hs @@ -0,0 +1,449 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Virtual table for a JSCClass. This can be optionally used when registering a 'GI.JavaScriptCore.Objects.Class.Class' in a 'GI.JavaScriptCore.Objects.Context.Context' +to provide a custom implementation for the class. All virtual functions are optional and can be set to +'Nothing' to fallback to the default implementation. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.JavaScriptCore.Structs.ClassVTable + ( + +-- * Exported types + ClassVTable(..) , + newZeroClassVTable , + noClassVTable , + + + -- * Properties +-- ** deleteProperty #attr:deleteProperty# +{- | a 'GI.JavaScriptCore.Callbacks.ClassDeletePropertyFunction' for deleting a property. +-} +#if ENABLE_OVERLOADING + classVTable_deleteProperty , +#endif + clearClassVTableDeleteProperty , + getClassVTableDeleteProperty , + setClassVTableDeleteProperty , + + +-- ** enumerateProperties #attr:enumerateProperties# +{- | a 'GI.JavaScriptCore.Callbacks.ClassEnumeratePropertiesFunction' for enumerating properties. +-} +#if ENABLE_OVERLOADING + classVTable_enumerateProperties , +#endif + clearClassVTableEnumerateProperties , + getClassVTableEnumerateProperties , + setClassVTableEnumerateProperties , + + +-- ** getProperty #attr:getProperty# +{- | a 'GI.JavaScriptCore.Callbacks.ClassGetPropertyFunction' for getting a property. +-} +#if ENABLE_OVERLOADING + classVTable_getProperty , +#endif + clearClassVTableGetProperty , + getClassVTableGetProperty , + setClassVTableGetProperty , + + +-- ** hasProperty #attr:hasProperty# +{- | a 'GI.JavaScriptCore.Callbacks.ClassHasPropertyFunction' for querying a property. +-} +#if ENABLE_OVERLOADING + classVTable_hasProperty , +#endif + clearClassVTableHasProperty , + getClassVTableHasProperty , + setClassVTableHasProperty , + + +-- ** setProperty #attr:setProperty# +{- | a 'GI.JavaScriptCore.Callbacks.ClassSetPropertyFunction' for setting a property. +-} +#if ENABLE_OVERLOADING + classVTable_setProperty , +#endif + clearClassVTableSetProperty , + getClassVTableSetProperty , + setClassVTableSetProperty , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.JavaScriptCore.Callbacks as JavaScriptCore.Callbacks + +-- | Memory-managed wrapper type. +newtype ClassVTable = ClassVTable (ManagedPtr ClassVTable) +instance WrappedPtr ClassVTable where + wrappedPtrCalloc = callocBytes 72 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 72 >=> wrapPtr ClassVTable) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `ClassVTable` struct initialized to zero. +newZeroClassVTable :: MonadIO m => m ClassVTable +newZeroClassVTable = liftIO $ wrappedPtrCalloc >>= wrapPtr ClassVTable + +instance tag ~ 'AttrSet => Constructible ClassVTable tag where + new _ attrs = do + o <- newZeroClassVTable + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `ClassVTable`. +noClassVTable :: Maybe ClassVTable +noClassVTable = Nothing + +{- | +Get the value of the “@get_property@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' classVTable #getProperty +@ +-} +getClassVTableGetProperty :: MonadIO m => ClassVTable -> m (Maybe JavaScriptCore.Callbacks.ClassGetPropertyFunction) +getClassVTableGetProperty s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO (FunPtr JavaScriptCore.Callbacks.C_ClassGetPropertyFunction) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = JavaScriptCore.Callbacks.dynamic_ClassGetPropertyFunction val' + return val'' + return result + +{- | +Set the value of the “@get_property@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' classVTable [ #getProperty 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setClassVTableGetProperty :: MonadIO m => ClassVTable -> FunPtr JavaScriptCore.Callbacks.C_ClassGetPropertyFunction -> m () +setClassVTableGetProperty s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: FunPtr JavaScriptCore.Callbacks.C_ClassGetPropertyFunction) + +{- | +Set the value of the “@get_property@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #getProperty +@ +-} +clearClassVTableGetProperty :: MonadIO m => ClassVTable -> m () +clearClassVTableGetProperty s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (FP.nullFunPtr :: FunPtr JavaScriptCore.Callbacks.C_ClassGetPropertyFunction) + +#if ENABLE_OVERLOADING +data ClassVTableGetPropertyFieldInfo +instance AttrInfo ClassVTableGetPropertyFieldInfo where + type AttrAllowedOps ClassVTableGetPropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ClassVTableGetPropertyFieldInfo = (~) (FunPtr JavaScriptCore.Callbacks.C_ClassGetPropertyFunction) + type AttrBaseTypeConstraint ClassVTableGetPropertyFieldInfo = (~) ClassVTable + type AttrGetType ClassVTableGetPropertyFieldInfo = Maybe JavaScriptCore.Callbacks.ClassGetPropertyFunction + type AttrLabel ClassVTableGetPropertyFieldInfo = "get_property" + type AttrOrigin ClassVTableGetPropertyFieldInfo = ClassVTable + attrGet _ = getClassVTableGetProperty + attrSet _ = setClassVTableGetProperty + attrConstruct = undefined + attrClear _ = clearClassVTableGetProperty + +classVTable_getProperty :: AttrLabelProxy "getProperty" +classVTable_getProperty = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@set_property@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' classVTable #setProperty +@ +-} +getClassVTableSetProperty :: MonadIO m => ClassVTable -> m (Maybe JavaScriptCore.Callbacks.ClassSetPropertyFunction) +getClassVTableSetProperty s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO (FunPtr JavaScriptCore.Callbacks.C_ClassSetPropertyFunction) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = JavaScriptCore.Callbacks.dynamic_ClassSetPropertyFunction val' + return val'' + return result + +{- | +Set the value of the “@set_property@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' classVTable [ #setProperty 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setClassVTableSetProperty :: MonadIO m => ClassVTable -> FunPtr JavaScriptCore.Callbacks.C_ClassSetPropertyFunction -> m () +setClassVTableSetProperty s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: FunPtr JavaScriptCore.Callbacks.C_ClassSetPropertyFunction) + +{- | +Set the value of the “@set_property@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #setProperty +@ +-} +clearClassVTableSetProperty :: MonadIO m => ClassVTable -> m () +clearClassVTableSetProperty s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullFunPtr :: FunPtr JavaScriptCore.Callbacks.C_ClassSetPropertyFunction) + +#if ENABLE_OVERLOADING +data ClassVTableSetPropertyFieldInfo +instance AttrInfo ClassVTableSetPropertyFieldInfo where + type AttrAllowedOps ClassVTableSetPropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ClassVTableSetPropertyFieldInfo = (~) (FunPtr JavaScriptCore.Callbacks.C_ClassSetPropertyFunction) + type AttrBaseTypeConstraint ClassVTableSetPropertyFieldInfo = (~) ClassVTable + type AttrGetType ClassVTableSetPropertyFieldInfo = Maybe JavaScriptCore.Callbacks.ClassSetPropertyFunction + type AttrLabel ClassVTableSetPropertyFieldInfo = "set_property" + type AttrOrigin ClassVTableSetPropertyFieldInfo = ClassVTable + attrGet _ = getClassVTableSetProperty + attrSet _ = setClassVTableSetProperty + attrConstruct = undefined + attrClear _ = clearClassVTableSetProperty + +classVTable_setProperty :: AttrLabelProxy "setProperty" +classVTable_setProperty = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@has_property@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' classVTable #hasProperty +@ +-} +getClassVTableHasProperty :: MonadIO m => ClassVTable -> m (Maybe JavaScriptCore.Callbacks.ClassHasPropertyFunction) +getClassVTableHasProperty s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO (FunPtr JavaScriptCore.Callbacks.C_ClassHasPropertyFunction) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = JavaScriptCore.Callbacks.dynamic_ClassHasPropertyFunction val' + return val'' + return result + +{- | +Set the value of the “@has_property@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' classVTable [ #hasProperty 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setClassVTableHasProperty :: MonadIO m => ClassVTable -> FunPtr JavaScriptCore.Callbacks.C_ClassHasPropertyFunction -> m () +setClassVTableHasProperty s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: FunPtr JavaScriptCore.Callbacks.C_ClassHasPropertyFunction) + +{- | +Set the value of the “@has_property@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #hasProperty +@ +-} +clearClassVTableHasProperty :: MonadIO m => ClassVTable -> m () +clearClassVTableHasProperty s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (FP.nullFunPtr :: FunPtr JavaScriptCore.Callbacks.C_ClassHasPropertyFunction) + +#if ENABLE_OVERLOADING +data ClassVTableHasPropertyFieldInfo +instance AttrInfo ClassVTableHasPropertyFieldInfo where + type AttrAllowedOps ClassVTableHasPropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ClassVTableHasPropertyFieldInfo = (~) (FunPtr JavaScriptCore.Callbacks.C_ClassHasPropertyFunction) + type AttrBaseTypeConstraint ClassVTableHasPropertyFieldInfo = (~) ClassVTable + type AttrGetType ClassVTableHasPropertyFieldInfo = Maybe JavaScriptCore.Callbacks.ClassHasPropertyFunction + type AttrLabel ClassVTableHasPropertyFieldInfo = "has_property" + type AttrOrigin ClassVTableHasPropertyFieldInfo = ClassVTable + attrGet _ = getClassVTableHasProperty + attrSet _ = setClassVTableHasProperty + attrConstruct = undefined + attrClear _ = clearClassVTableHasProperty + +classVTable_hasProperty :: AttrLabelProxy "hasProperty" +classVTable_hasProperty = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@delete_property@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' classVTable #deleteProperty +@ +-} +getClassVTableDeleteProperty :: MonadIO m => ClassVTable -> m (Maybe JavaScriptCore.Callbacks.ClassDeletePropertyFunction) +getClassVTableDeleteProperty s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO (FunPtr JavaScriptCore.Callbacks.C_ClassDeletePropertyFunction) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = JavaScriptCore.Callbacks.dynamic_ClassDeletePropertyFunction val' + return val'' + return result + +{- | +Set the value of the “@delete_property@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' classVTable [ #deleteProperty 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setClassVTableDeleteProperty :: MonadIO m => ClassVTable -> FunPtr JavaScriptCore.Callbacks.C_ClassDeletePropertyFunction -> m () +setClassVTableDeleteProperty s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (val :: FunPtr JavaScriptCore.Callbacks.C_ClassDeletePropertyFunction) + +{- | +Set the value of the “@delete_property@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #deleteProperty +@ +-} +clearClassVTableDeleteProperty :: MonadIO m => ClassVTable -> m () +clearClassVTableDeleteProperty s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (FP.nullFunPtr :: FunPtr JavaScriptCore.Callbacks.C_ClassDeletePropertyFunction) + +#if ENABLE_OVERLOADING +data ClassVTableDeletePropertyFieldInfo +instance AttrInfo ClassVTableDeletePropertyFieldInfo where + type AttrAllowedOps ClassVTableDeletePropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ClassVTableDeletePropertyFieldInfo = (~) (FunPtr JavaScriptCore.Callbacks.C_ClassDeletePropertyFunction) + type AttrBaseTypeConstraint ClassVTableDeletePropertyFieldInfo = (~) ClassVTable + type AttrGetType ClassVTableDeletePropertyFieldInfo = Maybe JavaScriptCore.Callbacks.ClassDeletePropertyFunction + type AttrLabel ClassVTableDeletePropertyFieldInfo = "delete_property" + type AttrOrigin ClassVTableDeletePropertyFieldInfo = ClassVTable + attrGet _ = getClassVTableDeleteProperty + attrSet _ = setClassVTableDeleteProperty + attrConstruct = undefined + attrClear _ = clearClassVTableDeleteProperty + +classVTable_deleteProperty :: AttrLabelProxy "deleteProperty" +classVTable_deleteProperty = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@enumerate_properties@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' classVTable #enumerateProperties +@ +-} +getClassVTableEnumerateProperties :: MonadIO m => ClassVTable -> m (Maybe JavaScriptCore.Callbacks.ClassEnumeratePropertiesFunction) +getClassVTableEnumerateProperties s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO (FunPtr JavaScriptCore.Callbacks.C_ClassEnumeratePropertiesFunction) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = JavaScriptCore.Callbacks.dynamic_ClassEnumeratePropertiesFunction val' + return val'' + return result + +{- | +Set the value of the “@enumerate_properties@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' classVTable [ #enumerateProperties 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setClassVTableEnumerateProperties :: MonadIO m => ClassVTable -> FunPtr JavaScriptCore.Callbacks.C_ClassEnumeratePropertiesFunction -> m () +setClassVTableEnumerateProperties s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: FunPtr JavaScriptCore.Callbacks.C_ClassEnumeratePropertiesFunction) + +{- | +Set the value of the “@enumerate_properties@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #enumerateProperties +@ +-} +clearClassVTableEnumerateProperties :: MonadIO m => ClassVTable -> m () +clearClassVTableEnumerateProperties s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (FP.nullFunPtr :: FunPtr JavaScriptCore.Callbacks.C_ClassEnumeratePropertiesFunction) + +#if ENABLE_OVERLOADING +data ClassVTableEnumeratePropertiesFieldInfo +instance AttrInfo ClassVTableEnumeratePropertiesFieldInfo where + type AttrAllowedOps ClassVTableEnumeratePropertiesFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ClassVTableEnumeratePropertiesFieldInfo = (~) (FunPtr JavaScriptCore.Callbacks.C_ClassEnumeratePropertiesFunction) + type AttrBaseTypeConstraint ClassVTableEnumeratePropertiesFieldInfo = (~) ClassVTable + type AttrGetType ClassVTableEnumeratePropertiesFieldInfo = Maybe JavaScriptCore.Callbacks.ClassEnumeratePropertiesFunction + type AttrLabel ClassVTableEnumeratePropertiesFieldInfo = "enumerate_properties" + type AttrOrigin ClassVTableEnumeratePropertiesFieldInfo = ClassVTable + attrGet _ = getClassVTableEnumerateProperties + attrSet _ = setClassVTableEnumerateProperties + attrConstruct = undefined + attrClear _ = clearClassVTableEnumerateProperties + +classVTable_enumerateProperties :: AttrLabelProxy "enumerateProperties" +classVTable_enumerateProperties = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ClassVTable +type instance O.AttributeList ClassVTable = ClassVTableAttributeList +type ClassVTableAttributeList = ('[ '("getProperty", ClassVTableGetPropertyFieldInfo), '("setProperty", ClassVTableSetPropertyFieldInfo), '("hasProperty", ClassVTableHasPropertyFieldInfo), '("deleteProperty", ClassVTableDeletePropertyFieldInfo), '("enumerateProperties", ClassVTableEnumeratePropertiesFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveClassVTableMethod (t :: Symbol) (o :: *) :: * where + ResolveClassVTableMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveClassVTableMethod t ClassVTable, O.MethodInfo info ClassVTable p) => OL.IsLabel t (ClassVTable -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/JavaScriptCore/Structs/ClassVTable.hs-boot b/GI/JavaScriptCore/Structs/ClassVTable.hs-boot new file mode 100644 --- /dev/null +++ b/GI/JavaScriptCore/Structs/ClassVTable.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.JavaScriptCore.Structs.ClassVTable where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype ClassVTable = ClassVTable (ManagedPtr ClassVTable) +instance WrappedPtr ClassVTable where diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,3 +1,17 @@ +The gi-javascriptcore library and included works are provided under the terms of the +GNU Library General Public License (LGPL) version 2.1 with the following +exception: + +Static linking of applications or any other source to the gi-javascriptcore library +does not constitute a modified or derivative work and does not require +the author(s) to provide source code for said work, to link against the +shared gi-javascriptcore libraries, or to link their applications against a +user-supplied version of gi-javascriptcore. If you link applications to a modified +version of gi-javascriptcore, then the changes to gi-javascriptcore must be provided under the +terms of the LGPL. + +---------------------------------------------------------------------------- + GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Documentation Autogenerated documentation for this package can be found at -[https://hackage.haskell.org/package/gi-javascriptcore-4.0.16/docs/GI-JavaScriptCore.html](https://hackage.haskell.org/package/gi-javascriptcore-4.0.16/docs/GI-JavaScriptCore.html) +[https://hackage.haskell.org/package/gi-javascriptcore-4.0.17/docs/GI-JavaScriptCore.html](https://hackage.haskell.org/package/gi-javascriptcore-4.0.17/docs/GI-JavaScriptCore.html) For general documentation on using [haskell-gi](https://github.com/haskell-gi/haskell-gi) based bindings, see [the project page](https://github.com/haskell-gi/haskell-gi) or [the Wiki](https://github.com/haskell-gi/haskell-gi/wiki). diff --git a/gi-javascriptcore.cabal b/gi-javascriptcore.cabal --- a/gi-javascriptcore.cabal +++ b/gi-javascriptcore.cabal @@ -1,12 +1,12 @@ name: gi-javascriptcore -version: 4.0.16 +version: 4.0.17 synopsis: JavaScriptCore bindings description: Bindings for JavaScriptCore, autogenerated by haskell-gi. homepage: https://github.com/haskell-gi/haskell-gi license: LGPL-2.1 license-file: LICENSE author: Will Thompson, Iñaki García Etxebarria and Jonas Platte -maintainer: Iñaki García Etxebarria (garetxe@gmail.com) +maintainer: Iñaki García Etxebarria (inaki@blueleaf.cc) category: Bindings build-type: Custom cabal-version: 1.24 @@ -14,20 +14,20 @@ extra-source-files: README.md ChangeLog.md stack.yaml custom-setup - setup-depends: base >= 4.7 && < 5, + setup-depends: base >= 4.9 && < 5, Cabal >= 1.24, - haskell-gi >= 0.21.1 && < 0.22 + haskell-gi >= 0.21.0 && < 0.23 library default-language: Haskell2010 - default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts + default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts, UndecidableSuperClasses other-extensions: PatternSynonyms, ViewPatterns ghc-options: -fno-warn-unused-imports -fno-warn-warnings-deprecations pkgconfig-depends: javascriptcoregtk-4.0 build-depends: base >= 4.7 && <5, - haskell-gi-base == 0.21.*, - haskell-gi >= 0.21.1 && < 0.22, + haskell-gi-base >= 0.21.0 && < 0.23, + haskell-gi >= 0.21.0 && < 0.23, haskell-gi-overloading < 1.1, gi-gobject == 2.0.*, gi-glib == 2.0.*, @@ -40,3 +40,19 @@ -- see https://ghc.haskell.org/trac/ghc/ticket/14382 if impl(ghc == 8.2.*) build-depends: haskell-gi-overloading == 0.0 + + exposed-modules: GI.JavaScriptCore, + GI.JavaScriptCore.Callbacks, + GI.JavaScriptCore.Constants, + GI.JavaScriptCore.Enums, + GI.JavaScriptCore.Flags, + GI.JavaScriptCore.Functions, + GI.JavaScriptCore.Objects, + GI.JavaScriptCore.Objects.Class, + GI.JavaScriptCore.Objects.Context, + GI.JavaScriptCore.Objects.Exception, + GI.JavaScriptCore.Objects.Value, + GI.JavaScriptCore.Objects.VirtualMachine, + GI.JavaScriptCore.Objects.WeakValue, + GI.JavaScriptCore.Structs, + GI.JavaScriptCore.Structs.ClassVTable diff --git a/stack.yaml b/stack.yaml --- a/stack.yaml +++ b/stack.yaml @@ -1,3 +1,3 @@ packages: - '.' -resolver: lts-12.10 +resolver: lts-13.7