module Data.GI.GIR.Field
( Field(..)
, AnonymousMember(..)
, FieldInfoFlag
, parseFields
) where
import Control.Monad.Except (catchError, throwError)
import Data.Maybe (isJust, catMaybes)
#if !MIN_VERSION_base(4,11,0)
import Data.Monoid ((<>))
#endif
import Data.Text (Text, isSuffixOf)
import Data.GI.GIR.BasicTypes (Type(..), BasicType(..))
import Data.GI.GIR.Callback (Callback, parseCallback)
import Data.GI.GIR.Type (parseType, queryElementCType)
import Data.GI.GIR.Parser
data Field = Field {
Field -> ParseError
fieldName :: Text,
Field -> Bool
fieldVisible :: Bool,
Field -> Type
fieldType :: Type,
Field -> Maybe Bool
fieldIsPointer :: Maybe Bool,
Field -> Bool
fieldArrayOfPointers :: Bool,
Field -> Maybe Callback
fieldCallback :: Maybe Callback,
Field -> Int
fieldOffset :: Int,
Field -> Maybe Int
fieldBits :: Maybe Int,
Field -> Maybe Int
fieldBitShift :: Maybe Int,
Field -> Maybe AnonymousMember
fieldAnonymous :: Maybe AnonymousMember,
Field -> [FieldInfoFlag]
fieldFlags :: [FieldInfoFlag],
Field -> Documentation
fieldDocumentation :: Documentation,
Field -> Maybe DeprecationInfo
fieldDeprecated :: Maybe DeprecationInfo }
deriving Int -> Field -> ShowS
[Field] -> ShowS
Field -> [Char]
(Int -> Field -> ShowS)
-> (Field -> [Char]) -> ([Field] -> ShowS) -> Show Field
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Field -> ShowS
showsPrec :: Int -> Field -> ShowS
$cshow :: Field -> [Char]
show :: Field -> [Char]
$cshowList :: [Field] -> ShowS
showList :: [Field] -> ShowS
Show
data FieldInfoFlag = FieldIsReadable | FieldIsWritable
deriving Int -> FieldInfoFlag -> ShowS
[FieldInfoFlag] -> ShowS
FieldInfoFlag -> [Char]
(Int -> FieldInfoFlag -> ShowS)
-> (FieldInfoFlag -> [Char])
-> ([FieldInfoFlag] -> ShowS)
-> Show FieldInfoFlag
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FieldInfoFlag -> ShowS
showsPrec :: Int -> FieldInfoFlag -> ShowS
$cshow :: FieldInfoFlag -> [Char]
show :: FieldInfoFlag -> [Char]
$cshowList :: [FieldInfoFlag] -> ShowS
showList :: [FieldInfoFlag] -> ShowS
Show
data AnonymousMember = AnonymousUnion [Field]
| AnonymousStruct [Field]
deriving Int -> AnonymousMember -> ShowS
[AnonymousMember] -> ShowS
AnonymousMember -> [Char]
(Int -> AnonymousMember -> ShowS)
-> (AnonymousMember -> [Char])
-> ([AnonymousMember] -> ShowS)
-> Show AnonymousMember
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AnonymousMember -> ShowS
showsPrec :: Int -> AnonymousMember -> ShowS
$cshow :: AnonymousMember -> [Char]
show :: AnonymousMember -> [Char]
$cshowList :: [AnonymousMember] -> ShowS
showList :: [AnonymousMember] -> ShowS
Show
parseField :: Parser (Maybe Field)
parseField :: Parser (Maybe Field)
parseField = do
name <- Name -> Parser ParseError
getAttr Name
"name"
deprecated <- parseDeprecation
bits <- optionalAttr "bits" Nothing (fmap Just . parseIntegral)
readable <- optionalAttr "readable" True parseBool
writable <- optionalAttr "writable" False parseBool
let flags = if Bool
readable then [FieldInfoFlag
FieldIsReadable] else []
[FieldInfoFlag] -> [FieldInfoFlag] -> [FieldInfoFlag]
forall a. Semigroup a => a -> a -> a
<> if Bool
writable then [FieldInfoFlag
FieldIsWritable] else []
introspectable <- optionalAttr "introspectable" True parseBool
private <- optionalAttr "private" False parseBool
doc <- parseDocumentation
flip catchError (\ParseError
e -> if Bool -> Bool
not Bool
introspectable
then Maybe Field -> Parser (Maybe Field)
forall a. a -> ReaderT ParseContext (Except ParseError) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Field
forall a. Maybe a
Nothing
else ParseError -> Parser (Maybe Field)
forall a. ParseError -> ReaderT ParseContext (Except ParseError) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError ParseError
e) $ do
(t, isPtr, callback) <-
if introspectable
then do
callbacks <- parseChildrenWithLocalName "callback" parseCallback
(cbn, callback) <- case callbacks of
[] -> (Maybe Name, Maybe Callback)
-> ReaderT
ParseContext (Except ParseError) (Maybe Name, Maybe Callback)
forall a. a -> ReaderT ParseContext (Except ParseError) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Name
forall a. Maybe a
Nothing, Maybe Callback
forall a. Maybe a
Nothing)
[(Name
n, Callback
cb)] -> (Maybe Name, Maybe Callback)
-> ReaderT
ParseContext (Except ParseError) (Maybe Name, Maybe Callback)
forall a. a -> ReaderT ParseContext (Except ParseError) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Maybe Name
forall a. a -> Maybe a
Just Name
n, Callback -> Maybe Callback
forall a. a -> Maybe a
Just Callback
cb)
[(Name, Callback)]
_ -> ParseError
-> ReaderT
ParseContext (Except ParseError) (Maybe Name, Maybe Callback)
forall a. ParseError -> ReaderT ParseContext (Except ParseError) a
parseError ParseError
"Multiple callbacks in field"
(t, isPtr) <- case cbn of
Maybe Name
Nothing -> do
t <- Parser Type
parseType
ct <- queryElementCType
return (t, fmap ("*" `isSuffixOf`) ct)
Just Name
n -> (Type, Maybe Bool)
-> ReaderT ParseContext (Except ParseError) (Type, Maybe Bool)
forall a. a -> ReaderT ParseContext (Except ParseError) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Type
TInterface Name
n, Maybe Bool
forall a. Maybe a
Nothing)
return (t, isPtr, callback)
else do
callbacks <- parseAllChildrenWithLocalName "callback" parseName
case callbacks of
[] -> do
t <- Parser Type
parseType
ct <- queryElementCType
return (t, fmap ("*" `isSuffixOf`) ct, Nothing)
[Name
n] -> (Type, Maybe Bool, Maybe Callback)
-> ReaderT
ParseContext (Except ParseError) (Type, Maybe Bool, Maybe Callback)
forall a. a -> ReaderT ParseContext (Except ParseError) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Type
TInterface Name
n, Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True, Maybe Callback
forall a. Maybe a
Nothing)
[Name]
_ -> ParseError
-> ReaderT
ParseContext (Except ParseError) (Type, Maybe Bool, Maybe Callback)
forall a. ParseError -> ReaderT ParseContext (Except ParseError) a
parseError ParseError
"Multiple callbacks in field"
elementCTypes <- parseAllChildrenWithLocalName "array" queryElementCType
let arrayOfPointers = case [Maybe ParseError]
elementCTypes of
[Just ParseError
ct] -> ParseError
"*" ParseError -> ParseError -> Bool
`isSuffixOf` ParseError
ct
[Maybe ParseError]
_ -> Bool
False
return $ Just $ Field {
fieldName = name
, fieldVisible = introspectable && not private
, fieldType = t
, fieldIsPointer = if isJust callback
then Just True
else isPtr
, fieldArrayOfPointers = arrayOfPointers
, fieldCallback = callback
, fieldOffset = error ("unfixed field offset " ++ show name)
, fieldBits = if bits == Just 0 then Nothing else bits
, fieldBitShift = Nothing
, fieldAnonymous = Nothing
, fieldFlags = flags
, fieldDocumentation = doc
, fieldDeprecated = deprecated
}
parseAnonymousMember :: Bool -> Parser Field
parseAnonymousMember :: Bool -> Parser Field
parseAnonymousMember Bool
isUnion = do
name <- Name
-> ParseError
-> (ParseError -> Parser ParseError)
-> Parser ParseError
forall a. Name -> a -> (ParseError -> Parser a) -> Parser a
optionalAttr Name
"name" (if Bool
isUnion
then ParseError
"<anonymous union>"
else ParseError
"<anonymous struct>") ParseError -> Parser ParseError
forall a. a -> ReaderT ParseContext (Except ParseError) a
forall (m :: * -> *) a. Monad m => a -> m a
return
members <- map (\Field
f -> Field
f {fieldOffset = 0}) <$> parseFields
doc <- parseDocumentation
return $ Field {
fieldName = name
, fieldVisible = False
, fieldType = TBasicType TPtr
, fieldIsPointer = Just False
, fieldArrayOfPointers = False
, fieldCallback = Nothing
, fieldOffset = 0
, fieldBits = Nothing
, fieldBitShift = Nothing
, fieldAnonymous = Just (if isUnion
then AnonymousUnion members
else AnonymousStruct members)
, fieldFlags = []
, fieldDocumentation = doc
, fieldDeprecated = Nothing
}
parseFields :: Parser [Field]
parseFields :: ReaderT ParseContext (Except ParseError) [Field]
parseFields = [Maybe Field] -> [Field]
forall a. [Maybe a] -> [a]
catMaybes ([Maybe Field] -> [Field])
-> ReaderT ParseContext (Except ParseError) [Maybe Field]
-> ReaderT ParseContext (Except ParseError) [Field]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
[ParseError]
-> (ParseError -> Parser (Maybe Field))
-> ReaderT ParseContext (Except ParseError) [Maybe Field]
forall a. [ParseError] -> (ParseError -> Parser a) -> Parser [a]
parseAllChildrenWithLocalNames [ParseError
"field", ParseError
"union", ParseError
"record"] ParseError -> Parser (Maybe Field)
parseMember
where parseMember :: Text -> Parser (Maybe Field)
parseMember :: ParseError -> Parser (Maybe Field)
parseMember ParseError
"union" = Field -> Maybe Field
forall a. a -> Maybe a
Just (Field -> Maybe Field) -> Parser Field -> Parser (Maybe Field)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> Parser Field
parseAnonymousMember Bool
True
parseMember ParseError
"record" = Field -> Maybe Field
forall a. a -> Maybe a
Just (Field -> Maybe Field) -> Parser Field -> Parser (Maybe Field)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> Parser Field
parseAnonymousMember Bool
False
parseMember ParseError
_ = Parser (Maybe Field)
parseField