{-# LANGUAGE DuplicateRecordFields #-}
-- | A type to represent operands to LLVM 'LLVM.AST.Instruction.Instruction's
module LLVM.AST.Operand
( module LLVM.AST.Operand
)
where

import LLVM.Prelude

import LLVM.AST.Name
import LLVM.AST.Constant
import LLVM.AST.InlineAssembly
import LLVM.AST.Type


-- | An 'Operand' is roughly that which is an argument to an 'LLVM.AST.Instruction.Instruction'
data Operand
  -- | %foo
  = LocalReference Type Name
  -- | 'Constant's include 'LLVM.AST.Constant.GlobalReference', for \@foo
  | ConstantOperand Constant
  | MetadataOperand Metadata
  deriving (Operand -> Operand -> Bool
(Operand -> Operand -> Bool)
-> (Operand -> Operand -> Bool) -> Eq Operand
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Operand -> Operand -> Bool
$c/= :: Operand -> Operand -> Bool
== :: Operand -> Operand -> Bool
$c== :: Operand -> Operand -> Bool
Eq, Eq Operand
Eq Operand =>
(Operand -> Operand -> Ordering)
-> (Operand -> Operand -> Bool)
-> (Operand -> Operand -> Bool)
-> (Operand -> Operand -> Bool)
-> (Operand -> Operand -> Bool)
-> (Operand -> Operand -> Operand)
-> (Operand -> Operand -> Operand)
-> Ord Operand
Operand -> Operand -> Bool
Operand -> Operand -> Ordering
Operand -> Operand -> Operand
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Operand -> Operand -> Operand
$cmin :: Operand -> Operand -> Operand
max :: Operand -> Operand -> Operand
$cmax :: Operand -> Operand -> Operand
>= :: Operand -> Operand -> Bool
$c>= :: Operand -> Operand -> Bool
> :: Operand -> Operand -> Bool
$c> :: Operand -> Operand -> Bool
<= :: Operand -> Operand -> Bool
$c<= :: Operand -> Operand -> Bool
< :: Operand -> Operand -> Bool
$c< :: Operand -> Operand -> Bool
compare :: Operand -> Operand -> Ordering
$ccompare :: Operand -> Operand -> Ordering
$cp1Ord :: Eq Operand
Ord, ReadPrec [Operand]
ReadPrec Operand
Int -> ReadS Operand
ReadS [Operand]
(Int -> ReadS Operand)
-> ReadS [Operand]
-> ReadPrec Operand
-> ReadPrec [Operand]
-> Read Operand
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Operand]
$creadListPrec :: ReadPrec [Operand]
readPrec :: ReadPrec Operand
$creadPrec :: ReadPrec Operand
readList :: ReadS [Operand]
$creadList :: ReadS [Operand]
readsPrec :: Int -> ReadS Operand
$creadsPrec :: Int -> ReadS Operand
Read, Int -> Operand -> ShowS
[Operand] -> ShowS
Operand -> String
(Int -> Operand -> ShowS)
-> (Operand -> String) -> ([Operand] -> ShowS) -> Show Operand
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Operand] -> ShowS
$cshowList :: [Operand] -> ShowS
show :: Operand -> String
$cshow :: Operand -> String
showsPrec :: Int -> Operand -> ShowS
$cshowsPrec :: Int -> Operand -> ShowS
Show, Typeable, Typeable Operand
DataType
Constr
Typeable Operand =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Operand -> c Operand)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Operand)
-> (Operand -> Constr)
-> (Operand -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Operand))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Operand))
-> ((forall b. Data b => b -> b) -> Operand -> Operand)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Operand -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Operand -> r)
-> (forall u. (forall d. Data d => d -> u) -> Operand -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Operand -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Operand -> m Operand)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Operand -> m Operand)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Operand -> m Operand)
-> Data Operand
Operand -> DataType
Operand -> Constr
(forall b. Data b => b -> b) -> Operand -> Operand
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Operand -> c Operand
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Operand
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Operand -> u
forall u. (forall d. Data d => d -> u) -> Operand -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Operand -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Operand -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Operand -> m Operand
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Operand -> m Operand
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Operand
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Operand -> c Operand
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Operand)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Operand)
$cMetadataOperand :: Constr
$cConstantOperand :: Constr
$cLocalReference :: Constr
$tOperand :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Operand -> m Operand
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Operand -> m Operand
gmapMp :: (forall d. Data d => d -> m d) -> Operand -> m Operand
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Operand -> m Operand
gmapM :: (forall d. Data d => d -> m d) -> Operand -> m Operand
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Operand -> m Operand
gmapQi :: Int -> (forall d. Data d => d -> u) -> Operand -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Operand -> u
gmapQ :: (forall d. Data d => d -> u) -> Operand -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Operand -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Operand -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Operand -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Operand -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Operand -> r
gmapT :: (forall b. Data b => b -> b) -> Operand -> Operand
$cgmapT :: (forall b. Data b => b -> b) -> Operand -> Operand
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Operand)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Operand)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Operand)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Operand)
dataTypeOf :: Operand -> DataType
$cdataTypeOf :: Operand -> DataType
toConstr :: Operand -> Constr
$ctoConstr :: Operand -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Operand
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Operand
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Operand -> c Operand
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Operand -> c Operand
$cp1Data :: Typeable Operand
Data, (forall x. Operand -> Rep Operand x)
-> (forall x. Rep Operand x -> Operand) -> Generic Operand
forall x. Rep Operand x -> Operand
forall x. Operand -> Rep Operand x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Operand x -> Operand
$cfrom :: forall x. Operand -> Rep Operand x
Generic)

-- | The 'LLVM.AST.Instruction.Call' instruction is special: the callee can be inline assembly
type CallableOperand  = Either InlineAssembly Operand

-- | <http://llvm.org/docs/LangRef.html#metadata>
data Metadata
  = MDString ShortByteString -- ^ <http://llvm.org/docs/doxygen/html/classllvm_1_1MDNode.html>
  | MDNode (MDRef MDNode) -- ^ <http://llvm.org/docs/doxygen/html/classllvm_1_1MDNode.html>
  | MDValue Operand -- ^ <http://llvm.org/docs/doxygen/html/classllvm_1_1ValueAsMetadata.html>
  deriving (Metadata -> Metadata -> Bool
(Metadata -> Metadata -> Bool)
-> (Metadata -> Metadata -> Bool) -> Eq Metadata
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Metadata -> Metadata -> Bool
$c/= :: Metadata -> Metadata -> Bool
== :: Metadata -> Metadata -> Bool
$c== :: Metadata -> Metadata -> Bool
Eq, Eq Metadata
Eq Metadata =>
(Metadata -> Metadata -> Ordering)
-> (Metadata -> Metadata -> Bool)
-> (Metadata -> Metadata -> Bool)
-> (Metadata -> Metadata -> Bool)
-> (Metadata -> Metadata -> Bool)
-> (Metadata -> Metadata -> Metadata)
-> (Metadata -> Metadata -> Metadata)
-> Ord Metadata
Metadata -> Metadata -> Bool
Metadata -> Metadata -> Ordering
Metadata -> Metadata -> Metadata
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Metadata -> Metadata -> Metadata
$cmin :: Metadata -> Metadata -> Metadata
max :: Metadata -> Metadata -> Metadata
$cmax :: Metadata -> Metadata -> Metadata
>= :: Metadata -> Metadata -> Bool
$c>= :: Metadata -> Metadata -> Bool
> :: Metadata -> Metadata -> Bool
$c> :: Metadata -> Metadata -> Bool
<= :: Metadata -> Metadata -> Bool
$c<= :: Metadata -> Metadata -> Bool
< :: Metadata -> Metadata -> Bool
$c< :: Metadata -> Metadata -> Bool
compare :: Metadata -> Metadata -> Ordering
$ccompare :: Metadata -> Metadata -> Ordering
$cp1Ord :: Eq Metadata
Ord, ReadPrec [Metadata]
ReadPrec Metadata
Int -> ReadS Metadata
ReadS [Metadata]
(Int -> ReadS Metadata)
-> ReadS [Metadata]
-> ReadPrec Metadata
-> ReadPrec [Metadata]
-> Read Metadata
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Metadata]
$creadListPrec :: ReadPrec [Metadata]
readPrec :: ReadPrec Metadata
$creadPrec :: ReadPrec Metadata
readList :: ReadS [Metadata]
$creadList :: ReadS [Metadata]
readsPrec :: Int -> ReadS Metadata
$creadsPrec :: Int -> ReadS Metadata
Read, Int -> Metadata -> ShowS
[Metadata] -> ShowS
Metadata -> String
(Int -> Metadata -> ShowS)
-> (Metadata -> String) -> ([Metadata] -> ShowS) -> Show Metadata
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Metadata] -> ShowS
$cshowList :: [Metadata] -> ShowS
show :: Metadata -> String
$cshow :: Metadata -> String
showsPrec :: Int -> Metadata -> ShowS
$cshowsPrec :: Int -> Metadata -> ShowS
Show, Typeable, Typeable Metadata
DataType
Constr
Typeable Metadata =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Metadata -> c Metadata)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Metadata)
-> (Metadata -> Constr)
-> (Metadata -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Metadata))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Metadata))
-> ((forall b. Data b => b -> b) -> Metadata -> Metadata)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Metadata -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Metadata -> r)
-> (forall u. (forall d. Data d => d -> u) -> Metadata -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Metadata -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Metadata -> m Metadata)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Metadata -> m Metadata)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Metadata -> m Metadata)
-> Data Metadata
Metadata -> DataType
Metadata -> Constr
(forall b. Data b => b -> b) -> Metadata -> Metadata
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Metadata -> c Metadata
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Metadata
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Metadata -> u
forall u. (forall d. Data d => d -> u) -> Metadata -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Metadata -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Metadata -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Metadata -> m Metadata
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Metadata -> m Metadata
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Metadata
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Metadata -> c Metadata
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Metadata)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Metadata)
$cMDValue :: Constr
$cMDNode :: Constr
$cMDString :: Constr
$tMetadata :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Metadata -> m Metadata
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Metadata -> m Metadata
gmapMp :: (forall d. Data d => d -> m d) -> Metadata -> m Metadata
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Metadata -> m Metadata
gmapM :: (forall d. Data d => d -> m d) -> Metadata -> m Metadata
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Metadata -> m Metadata
gmapQi :: Int -> (forall d. Data d => d -> u) -> Metadata -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Metadata -> u
gmapQ :: (forall d. Data d => d -> u) -> Metadata -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Metadata -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Metadata -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Metadata -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Metadata -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Metadata -> r
gmapT :: (forall b. Data b => b -> b) -> Metadata -> Metadata
$cgmapT :: (forall b. Data b => b -> b) -> Metadata -> Metadata
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Metadata)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Metadata)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Metadata)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Metadata)
dataTypeOf :: Metadata -> DataType
$cdataTypeOf :: Metadata -> DataType
toConstr :: Metadata -> Constr
$ctoConstr :: Metadata -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Metadata
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Metadata
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Metadata -> c Metadata
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Metadata -> c Metadata
$cp1Data :: Typeable Metadata
Data, (forall x. Metadata -> Rep Metadata x)
-> (forall x. Rep Metadata x -> Metadata) -> Generic Metadata
forall x. Rep Metadata x -> Metadata
forall x. Metadata -> Rep Metadata x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Metadata x -> Metadata
$cfrom :: forall x. Metadata -> Rep Metadata x
Generic)

-- | A 'MetadataNodeID' is a number for identifying a metadata node.
-- Note this is different from "named metadata", which are represented with
-- 'LLVM.AST.NamedMetadataDefinition'.
newtype MetadataNodeID = MetadataNodeID Word
  deriving (MetadataNodeID -> MetadataNodeID -> Bool
(MetadataNodeID -> MetadataNodeID -> Bool)
-> (MetadataNodeID -> MetadataNodeID -> Bool) -> Eq MetadataNodeID
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MetadataNodeID -> MetadataNodeID -> Bool
$c/= :: MetadataNodeID -> MetadataNodeID -> Bool
== :: MetadataNodeID -> MetadataNodeID -> Bool
$c== :: MetadataNodeID -> MetadataNodeID -> Bool
Eq, Eq MetadataNodeID
Eq MetadataNodeID =>
(MetadataNodeID -> MetadataNodeID -> Ordering)
-> (MetadataNodeID -> MetadataNodeID -> Bool)
-> (MetadataNodeID -> MetadataNodeID -> Bool)
-> (MetadataNodeID -> MetadataNodeID -> Bool)
-> (MetadataNodeID -> MetadataNodeID -> Bool)
-> (MetadataNodeID -> MetadataNodeID -> MetadataNodeID)
-> (MetadataNodeID -> MetadataNodeID -> MetadataNodeID)
-> Ord MetadataNodeID
MetadataNodeID -> MetadataNodeID -> Bool
MetadataNodeID -> MetadataNodeID -> Ordering
MetadataNodeID -> MetadataNodeID -> MetadataNodeID
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: MetadataNodeID -> MetadataNodeID -> MetadataNodeID
$cmin :: MetadataNodeID -> MetadataNodeID -> MetadataNodeID
max :: MetadataNodeID -> MetadataNodeID -> MetadataNodeID
$cmax :: MetadataNodeID -> MetadataNodeID -> MetadataNodeID
>= :: MetadataNodeID -> MetadataNodeID -> Bool
$c>= :: MetadataNodeID -> MetadataNodeID -> Bool
> :: MetadataNodeID -> MetadataNodeID -> Bool
$c> :: MetadataNodeID -> MetadataNodeID -> Bool
<= :: MetadataNodeID -> MetadataNodeID -> Bool
$c<= :: MetadataNodeID -> MetadataNodeID -> Bool
< :: MetadataNodeID -> MetadataNodeID -> Bool
$c< :: MetadataNodeID -> MetadataNodeID -> Bool
compare :: MetadataNodeID -> MetadataNodeID -> Ordering
$ccompare :: MetadataNodeID -> MetadataNodeID -> Ordering
$cp1Ord :: Eq MetadataNodeID
Ord, ReadPrec [MetadataNodeID]
ReadPrec MetadataNodeID
Int -> ReadS MetadataNodeID
ReadS [MetadataNodeID]
(Int -> ReadS MetadataNodeID)
-> ReadS [MetadataNodeID]
-> ReadPrec MetadataNodeID
-> ReadPrec [MetadataNodeID]
-> Read MetadataNodeID
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MetadataNodeID]
$creadListPrec :: ReadPrec [MetadataNodeID]
readPrec :: ReadPrec MetadataNodeID
$creadPrec :: ReadPrec MetadataNodeID
readList :: ReadS [MetadataNodeID]
$creadList :: ReadS [MetadataNodeID]
readsPrec :: Int -> ReadS MetadataNodeID
$creadsPrec :: Int -> ReadS MetadataNodeID
Read, Int -> MetadataNodeID -> ShowS
[MetadataNodeID] -> ShowS
MetadataNodeID -> String
(Int -> MetadataNodeID -> ShowS)
-> (MetadataNodeID -> String)
-> ([MetadataNodeID] -> ShowS)
-> Show MetadataNodeID
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MetadataNodeID] -> ShowS
$cshowList :: [MetadataNodeID] -> ShowS
show :: MetadataNodeID -> String
$cshow :: MetadataNodeID -> String
showsPrec :: Int -> MetadataNodeID -> ShowS
$cshowsPrec :: Int -> MetadataNodeID -> ShowS
Show, Typeable, Typeable MetadataNodeID
DataType
Constr
Typeable MetadataNodeID =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MetadataNodeID -> c MetadataNodeID)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MetadataNodeID)
-> (MetadataNodeID -> Constr)
-> (MetadataNodeID -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MetadataNodeID))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c MetadataNodeID))
-> ((forall b. Data b => b -> b)
    -> MetadataNodeID -> MetadataNodeID)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MetadataNodeID -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MetadataNodeID -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> MetadataNodeID -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MetadataNodeID -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> MetadataNodeID -> m MetadataNodeID)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MetadataNodeID -> m MetadataNodeID)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MetadataNodeID -> m MetadataNodeID)
-> Data MetadataNodeID
MetadataNodeID -> DataType
MetadataNodeID -> Constr
(forall b. Data b => b -> b) -> MetadataNodeID -> MetadataNodeID
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MetadataNodeID -> c MetadataNodeID
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MetadataNodeID
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> MetadataNodeID -> u
forall u. (forall d. Data d => d -> u) -> MetadataNodeID -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MetadataNodeID -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MetadataNodeID -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MetadataNodeID -> m MetadataNodeID
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MetadataNodeID -> m MetadataNodeID
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MetadataNodeID
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MetadataNodeID -> c MetadataNodeID
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MetadataNodeID)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MetadataNodeID)
$cMetadataNodeID :: Constr
$tMetadataNodeID :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> MetadataNodeID -> m MetadataNodeID
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MetadataNodeID -> m MetadataNodeID
gmapMp :: (forall d. Data d => d -> m d)
-> MetadataNodeID -> m MetadataNodeID
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MetadataNodeID -> m MetadataNodeID
gmapM :: (forall d. Data d => d -> m d)
-> MetadataNodeID -> m MetadataNodeID
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MetadataNodeID -> m MetadataNodeID
gmapQi :: Int -> (forall d. Data d => d -> u) -> MetadataNodeID -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MetadataNodeID -> u
gmapQ :: (forall d. Data d => d -> u) -> MetadataNodeID -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MetadataNodeID -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MetadataNodeID -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MetadataNodeID -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MetadataNodeID -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MetadataNodeID -> r
gmapT :: (forall b. Data b => b -> b) -> MetadataNodeID -> MetadataNodeID
$cgmapT :: (forall b. Data b => b -> b) -> MetadataNodeID -> MetadataNodeID
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MetadataNodeID)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MetadataNodeID)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c MetadataNodeID)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MetadataNodeID)
dataTypeOf :: MetadataNodeID -> DataType
$cdataTypeOf :: MetadataNodeID -> DataType
toConstr :: MetadataNodeID -> Constr
$ctoConstr :: MetadataNodeID -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MetadataNodeID
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MetadataNodeID
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MetadataNodeID -> c MetadataNodeID
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MetadataNodeID -> c MetadataNodeID
$cp1Data :: Typeable MetadataNodeID
Data, (forall x. MetadataNodeID -> Rep MetadataNodeID x)
-> (forall x. Rep MetadataNodeID x -> MetadataNodeID)
-> Generic MetadataNodeID
forall x. Rep MetadataNodeID x -> MetadataNodeID
forall x. MetadataNodeID -> Rep MetadataNodeID x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MetadataNodeID x -> MetadataNodeID
$cfrom :: forall x. MetadataNodeID -> Rep MetadataNodeID x
Generic)

-- | `MDRef` can either represent a reference to some piece of
-- metadata or the metadata itself.
--
-- This is mainly useful for encoding cyclic metadata. Note that LLVM
-- represents inline and non-inline nodes identically, so
-- roundtripping the Haskell AST does not preserve whether a node was
-- inline or not.
data MDRef a
  = MDRef MetadataNodeID
  | MDInline a
  deriving (MDRef a -> MDRef a -> Bool
(MDRef a -> MDRef a -> Bool)
-> (MDRef a -> MDRef a -> Bool) -> Eq (MDRef a)
forall a. Eq a => MDRef a -> MDRef a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MDRef a -> MDRef a -> Bool
$c/= :: forall a. Eq a => MDRef a -> MDRef a -> Bool
== :: MDRef a -> MDRef a -> Bool
$c== :: forall a. Eq a => MDRef a -> MDRef a -> Bool
Eq, Eq (MDRef a)
Eq (MDRef a) =>
(MDRef a -> MDRef a -> Ordering)
-> (MDRef a -> MDRef a -> Bool)
-> (MDRef a -> MDRef a -> Bool)
-> (MDRef a -> MDRef a -> Bool)
-> (MDRef a -> MDRef a -> Bool)
-> (MDRef a -> MDRef a -> MDRef a)
-> (MDRef a -> MDRef a -> MDRef a)
-> Ord (MDRef a)
MDRef a -> MDRef a -> Bool
MDRef a -> MDRef a -> Ordering
MDRef a -> MDRef a -> MDRef a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (MDRef a)
forall a. Ord a => MDRef a -> MDRef a -> Bool
forall a. Ord a => MDRef a -> MDRef a -> Ordering
forall a. Ord a => MDRef a -> MDRef a -> MDRef a
min :: MDRef a -> MDRef a -> MDRef a
$cmin :: forall a. Ord a => MDRef a -> MDRef a -> MDRef a
max :: MDRef a -> MDRef a -> MDRef a
$cmax :: forall a. Ord a => MDRef a -> MDRef a -> MDRef a
>= :: MDRef a -> MDRef a -> Bool
$c>= :: forall a. Ord a => MDRef a -> MDRef a -> Bool
> :: MDRef a -> MDRef a -> Bool
$c> :: forall a. Ord a => MDRef a -> MDRef a -> Bool
<= :: MDRef a -> MDRef a -> Bool
$c<= :: forall a. Ord a => MDRef a -> MDRef a -> Bool
< :: MDRef a -> MDRef a -> Bool
$c< :: forall a. Ord a => MDRef a -> MDRef a -> Bool
compare :: MDRef a -> MDRef a -> Ordering
$ccompare :: forall a. Ord a => MDRef a -> MDRef a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (MDRef a)
Ord, ReadPrec [MDRef a]
ReadPrec (MDRef a)
Int -> ReadS (MDRef a)
ReadS [MDRef a]
(Int -> ReadS (MDRef a))
-> ReadS [MDRef a]
-> ReadPrec (MDRef a)
-> ReadPrec [MDRef a]
-> Read (MDRef a)
forall a. Read a => ReadPrec [MDRef a]
forall a. Read a => ReadPrec (MDRef a)
forall a. Read a => Int -> ReadS (MDRef a)
forall a. Read a => ReadS [MDRef a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MDRef a]
$creadListPrec :: forall a. Read a => ReadPrec [MDRef a]
readPrec :: ReadPrec (MDRef a)
$creadPrec :: forall a. Read a => ReadPrec (MDRef a)
readList :: ReadS [MDRef a]
$creadList :: forall a. Read a => ReadS [MDRef a]
readsPrec :: Int -> ReadS (MDRef a)
$creadsPrec :: forall a. Read a => Int -> ReadS (MDRef a)
Read, Int -> MDRef a -> ShowS
[MDRef a] -> ShowS
MDRef a -> String
(Int -> MDRef a -> ShowS)
-> (MDRef a -> String) -> ([MDRef a] -> ShowS) -> Show (MDRef a)
forall a. Show a => Int -> MDRef a -> ShowS
forall a. Show a => [MDRef a] -> ShowS
forall a. Show a => MDRef a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MDRef a] -> ShowS
$cshowList :: forall a. Show a => [MDRef a] -> ShowS
show :: MDRef a -> String
$cshow :: forall a. Show a => MDRef a -> String
showsPrec :: Int -> MDRef a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> MDRef a -> ShowS
Show, Typeable, Typeable (MDRef a)
DataType
Constr
Typeable (MDRef a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MDRef a -> c (MDRef a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (MDRef a))
-> (MDRef a -> Constr)
-> (MDRef a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (MDRef a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MDRef a)))
-> ((forall b. Data b => b -> b) -> MDRef a -> MDRef a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MDRef a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MDRef a -> r)
-> (forall u. (forall d. Data d => d -> u) -> MDRef a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> MDRef a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a))
-> Data (MDRef a)
MDRef a -> DataType
MDRef a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (MDRef a))
(forall b. Data b => b -> b) -> MDRef a -> MDRef a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MDRef a -> c (MDRef a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MDRef a)
forall a. Data a => Typeable (MDRef a)
forall a. Data a => MDRef a -> DataType
forall a. Data a => MDRef a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> MDRef a -> MDRef a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> MDRef a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> MDRef a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MDRef a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MDRef a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MDRef a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MDRef a -> c (MDRef a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (MDRef a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MDRef a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> MDRef a -> u
forall u. (forall d. Data d => d -> u) -> MDRef a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MDRef a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MDRef a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MDRef a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MDRef a -> c (MDRef a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (MDRef a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MDRef a))
$cMDInline :: Constr
$cMDRef :: Constr
$tMDRef :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
gmapMp :: (forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
gmapM :: (forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> MDRef a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> MDRef a -> u
gmapQ :: (forall d. Data d => d -> u) -> MDRef a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> MDRef a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MDRef a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MDRef a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MDRef a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MDRef a -> r
gmapT :: (forall b. Data b => b -> b) -> MDRef a -> MDRef a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> MDRef a -> MDRef a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MDRef a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MDRef a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (MDRef a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (MDRef a))
dataTypeOf :: MDRef a -> DataType
$cdataTypeOf :: forall a. Data a => MDRef a -> DataType
toConstr :: MDRef a -> Constr
$ctoConstr :: forall a. Data a => MDRef a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MDRef a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MDRef a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MDRef a -> c (MDRef a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MDRef a -> c (MDRef a)
$cp1Data :: forall a. Data a => Typeable (MDRef a)
Data, (forall x. MDRef a -> Rep (MDRef a) x)
-> (forall x. Rep (MDRef a) x -> MDRef a) -> Generic (MDRef a)
forall x. Rep (MDRef a) x -> MDRef a
forall x. MDRef a -> Rep (MDRef a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (MDRef a) x -> MDRef a
forall a x. MDRef a -> Rep (MDRef a) x
$cto :: forall a x. Rep (MDRef a) x -> MDRef a
$cfrom :: forall a x. MDRef a -> Rep (MDRef a) x
Generic)

instance Functor MDRef where
  fmap :: (a -> b) -> MDRef a -> MDRef b
fmap _ (MDRef i :: MetadataNodeID
i) = MetadataNodeID -> MDRef b
forall a. MetadataNodeID -> MDRef a
MDRef MetadataNodeID
i
  fmap f :: a -> b
f (MDInline a :: a
a) = b -> MDRef b
forall a. a -> MDRef a
MDInline (a -> b
f a
a)

data DWOpFragment = DW_OP_LLVM_Fragment
  { DWOpFragment -> Word64
offset :: Word64
  , DWOpFragment -> Word64
size :: Word64
  } deriving (DWOpFragment -> DWOpFragment -> Bool
(DWOpFragment -> DWOpFragment -> Bool)
-> (DWOpFragment -> DWOpFragment -> Bool) -> Eq DWOpFragment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DWOpFragment -> DWOpFragment -> Bool
$c/= :: DWOpFragment -> DWOpFragment -> Bool
== :: DWOpFragment -> DWOpFragment -> Bool
$c== :: DWOpFragment -> DWOpFragment -> Bool
Eq, Eq DWOpFragment
Eq DWOpFragment =>
(DWOpFragment -> DWOpFragment -> Ordering)
-> (DWOpFragment -> DWOpFragment -> Bool)
-> (DWOpFragment -> DWOpFragment -> Bool)
-> (DWOpFragment -> DWOpFragment -> Bool)
-> (DWOpFragment -> DWOpFragment -> Bool)
-> (DWOpFragment -> DWOpFragment -> DWOpFragment)
-> (DWOpFragment -> DWOpFragment -> DWOpFragment)
-> Ord DWOpFragment
DWOpFragment -> DWOpFragment -> Bool
DWOpFragment -> DWOpFragment -> Ordering
DWOpFragment -> DWOpFragment -> DWOpFragment
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DWOpFragment -> DWOpFragment -> DWOpFragment
$cmin :: DWOpFragment -> DWOpFragment -> DWOpFragment
max :: DWOpFragment -> DWOpFragment -> DWOpFragment
$cmax :: DWOpFragment -> DWOpFragment -> DWOpFragment
>= :: DWOpFragment -> DWOpFragment -> Bool
$c>= :: DWOpFragment -> DWOpFragment -> Bool
> :: DWOpFragment -> DWOpFragment -> Bool
$c> :: DWOpFragment -> DWOpFragment -> Bool
<= :: DWOpFragment -> DWOpFragment -> Bool
$c<= :: DWOpFragment -> DWOpFragment -> Bool
< :: DWOpFragment -> DWOpFragment -> Bool
$c< :: DWOpFragment -> DWOpFragment -> Bool
compare :: DWOpFragment -> DWOpFragment -> Ordering
$ccompare :: DWOpFragment -> DWOpFragment -> Ordering
$cp1Ord :: Eq DWOpFragment
Ord, ReadPrec [DWOpFragment]
ReadPrec DWOpFragment
Int -> ReadS DWOpFragment
ReadS [DWOpFragment]
(Int -> ReadS DWOpFragment)
-> ReadS [DWOpFragment]
-> ReadPrec DWOpFragment
-> ReadPrec [DWOpFragment]
-> Read DWOpFragment
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DWOpFragment]
$creadListPrec :: ReadPrec [DWOpFragment]
readPrec :: ReadPrec DWOpFragment
$creadPrec :: ReadPrec DWOpFragment
readList :: ReadS [DWOpFragment]
$creadList :: ReadS [DWOpFragment]
readsPrec :: Int -> ReadS DWOpFragment
$creadsPrec :: Int -> ReadS DWOpFragment
Read, Int -> DWOpFragment -> ShowS
[DWOpFragment] -> ShowS
DWOpFragment -> String
(Int -> DWOpFragment -> ShowS)
-> (DWOpFragment -> String)
-> ([DWOpFragment] -> ShowS)
-> Show DWOpFragment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DWOpFragment] -> ShowS
$cshowList :: [DWOpFragment] -> ShowS
show :: DWOpFragment -> String
$cshow :: DWOpFragment -> String
showsPrec :: Int -> DWOpFragment -> ShowS
$cshowsPrec :: Int -> DWOpFragment -> ShowS
Show, Typeable, Typeable DWOpFragment
DataType
Constr
Typeable DWOpFragment =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DWOpFragment -> c DWOpFragment)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DWOpFragment)
-> (DWOpFragment -> Constr)
-> (DWOpFragment -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DWOpFragment))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DWOpFragment))
-> ((forall b. Data b => b -> b) -> DWOpFragment -> DWOpFragment)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DWOpFragment -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DWOpFragment -> r)
-> (forall u. (forall d. Data d => d -> u) -> DWOpFragment -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DWOpFragment -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment)
-> Data DWOpFragment
DWOpFragment -> DataType
DWOpFragment -> Constr
(forall b. Data b => b -> b) -> DWOpFragment -> DWOpFragment
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DWOpFragment -> c DWOpFragment
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DWOpFragment
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DWOpFragment -> u
forall u. (forall d. Data d => d -> u) -> DWOpFragment -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DWOpFragment -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DWOpFragment -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DWOpFragment
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DWOpFragment -> c DWOpFragment
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DWOpFragment)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DWOpFragment)
$cDW_OP_LLVM_Fragment :: Constr
$tDWOpFragment :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment
gmapMp :: (forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment
gmapM :: (forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment
gmapQi :: Int -> (forall d. Data d => d -> u) -> DWOpFragment -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DWOpFragment -> u
gmapQ :: (forall d. Data d => d -> u) -> DWOpFragment -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DWOpFragment -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DWOpFragment -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DWOpFragment -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DWOpFragment -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DWOpFragment -> r
gmapT :: (forall b. Data b => b -> b) -> DWOpFragment -> DWOpFragment
$cgmapT :: (forall b. Data b => b -> b) -> DWOpFragment -> DWOpFragment
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DWOpFragment)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DWOpFragment)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DWOpFragment)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DWOpFragment)
dataTypeOf :: DWOpFragment -> DataType
$cdataTypeOf :: DWOpFragment -> DataType
toConstr :: DWOpFragment -> Constr
$ctoConstr :: DWOpFragment -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DWOpFragment
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DWOpFragment
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DWOpFragment -> c DWOpFragment
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DWOpFragment -> c DWOpFragment
$cp1Data :: Typeable DWOpFragment
Data, (forall x. DWOpFragment -> Rep DWOpFragment x)
-> (forall x. Rep DWOpFragment x -> DWOpFragment)
-> Generic DWOpFragment
forall x. Rep DWOpFragment x -> DWOpFragment
forall x. DWOpFragment -> Rep DWOpFragment x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DWOpFragment x -> DWOpFragment
$cfrom :: forall x. DWOpFragment -> Rep DWOpFragment x
Generic)

-- | <https://llvm.org/docs/LangRef.html#diexpression>
data DWOp
  = DwOpFragment DWOpFragment -- ^ Must appear at the end
  | DW_OP_StackValue -- ^ Must be the last one or followed by a DW_OP_LLVM_Fragment
  | DW_OP_Swap
  | DW_OP_ConstU Word64
  | DW_OP_Lit0
  | DW_OP_PlusUConst Word64
  | DW_OP_Plus
  | DW_OP_Minus
  | DW_OP_Mul
  | DW_OP_Div
  | DW_OP_Mod
  | DW_OP_Not
  | DW_OP_Or
  | DW_OP_Xor
  | DW_OP_And
  | DW_OP_Shr
  | DW_OP_Shra
  | DW_OP_Shl
  | DW_OP_Dup
  | DW_OP_Deref
  | DW_OP_XDeref
  deriving (DWOp -> DWOp -> Bool
(DWOp -> DWOp -> Bool) -> (DWOp -> DWOp -> Bool) -> Eq DWOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DWOp -> DWOp -> Bool
$c/= :: DWOp -> DWOp -> Bool
== :: DWOp -> DWOp -> Bool
$c== :: DWOp -> DWOp -> Bool
Eq, Eq DWOp
Eq DWOp =>
(DWOp -> DWOp -> Ordering)
-> (DWOp -> DWOp -> Bool)
-> (DWOp -> DWOp -> Bool)
-> (DWOp -> DWOp -> Bool)
-> (DWOp -> DWOp -> Bool)
-> (DWOp -> DWOp -> DWOp)
-> (DWOp -> DWOp -> DWOp)
-> Ord DWOp
DWOp -> DWOp -> Bool
DWOp -> DWOp -> Ordering
DWOp -> DWOp -> DWOp
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DWOp -> DWOp -> DWOp
$cmin :: DWOp -> DWOp -> DWOp
max :: DWOp -> DWOp -> DWOp
$cmax :: DWOp -> DWOp -> DWOp
>= :: DWOp -> DWOp -> Bool
$c>= :: DWOp -> DWOp -> Bool
> :: DWOp -> DWOp -> Bool
$c> :: DWOp -> DWOp -> Bool
<= :: DWOp -> DWOp -> Bool
$c<= :: DWOp -> DWOp -> Bool
< :: DWOp -> DWOp -> Bool
$c< :: DWOp -> DWOp -> Bool
compare :: DWOp -> DWOp -> Ordering
$ccompare :: DWOp -> DWOp -> Ordering
$cp1Ord :: Eq DWOp
Ord, ReadPrec [DWOp]
ReadPrec DWOp
Int -> ReadS DWOp
ReadS [DWOp]
(Int -> ReadS DWOp)
-> ReadS [DWOp] -> ReadPrec DWOp -> ReadPrec [DWOp] -> Read DWOp
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DWOp]
$creadListPrec :: ReadPrec [DWOp]
readPrec :: ReadPrec DWOp
$creadPrec :: ReadPrec DWOp
readList :: ReadS [DWOp]
$creadList :: ReadS [DWOp]
readsPrec :: Int -> ReadS DWOp
$creadsPrec :: Int -> ReadS DWOp
Read, Int -> DWOp -> ShowS
[DWOp] -> ShowS
DWOp -> String
(Int -> DWOp -> ShowS)
-> (DWOp -> String) -> ([DWOp] -> ShowS) -> Show DWOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DWOp] -> ShowS
$cshowList :: [DWOp] -> ShowS
show :: DWOp -> String
$cshow :: DWOp -> String
showsPrec :: Int -> DWOp -> ShowS
$cshowsPrec :: Int -> DWOp -> ShowS
Show, Typeable, Typeable DWOp
DataType
Constr
Typeable DWOp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DWOp -> c DWOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DWOp)
-> (DWOp -> Constr)
-> (DWOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DWOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DWOp))
-> ((forall b. Data b => b -> b) -> DWOp -> DWOp)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DWOp -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DWOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> DWOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DWOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DWOp -> m DWOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DWOp -> m DWOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DWOp -> m DWOp)
-> Data DWOp
DWOp -> DataType
DWOp -> Constr
(forall b. Data b => b -> b) -> DWOp -> DWOp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DWOp -> c DWOp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DWOp
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DWOp -> u
forall u. (forall d. Data d => d -> u) -> DWOp -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DWOp -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DWOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DWOp -> m DWOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DWOp -> m DWOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DWOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DWOp -> c DWOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DWOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DWOp)
$cDW_OP_XDeref :: Constr
$cDW_OP_Deref :: Constr
$cDW_OP_Dup :: Constr
$cDW_OP_Shl :: Constr
$cDW_OP_Shra :: Constr
$cDW_OP_Shr :: Constr
$cDW_OP_And :: Constr
$cDW_OP_Xor :: Constr
$cDW_OP_Or :: Constr
$cDW_OP_Not :: Constr
$cDW_OP_Mod :: Constr
$cDW_OP_Div :: Constr
$cDW_OP_Mul :: Constr
$cDW_OP_Minus :: Constr
$cDW_OP_Plus :: Constr
$cDW_OP_PlusUConst :: Constr
$cDW_OP_Lit0 :: Constr
$cDW_OP_ConstU :: Constr
$cDW_OP_Swap :: Constr
$cDW_OP_StackValue :: Constr
$cDwOpFragment :: Constr
$tDWOp :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DWOp -> m DWOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DWOp -> m DWOp
gmapMp :: (forall d. Data d => d -> m d) -> DWOp -> m DWOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DWOp -> m DWOp
gmapM :: (forall d. Data d => d -> m d) -> DWOp -> m DWOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DWOp -> m DWOp
gmapQi :: Int -> (forall d. Data d => d -> u) -> DWOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DWOp -> u
gmapQ :: (forall d. Data d => d -> u) -> DWOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DWOp -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DWOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DWOp -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DWOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DWOp -> r
gmapT :: (forall b. Data b => b -> b) -> DWOp -> DWOp
$cgmapT :: (forall b. Data b => b -> b) -> DWOp -> DWOp
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DWOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DWOp)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DWOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DWOp)
dataTypeOf :: DWOp -> DataType
$cdataTypeOf :: DWOp -> DataType
toConstr :: DWOp -> Constr
$ctoConstr :: DWOp -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DWOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DWOp
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DWOp -> c DWOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DWOp -> c DWOp
$cp1Data :: Typeable DWOp
Data, (forall x. DWOp -> Rep DWOp x)
-> (forall x. Rep DWOp x -> DWOp) -> Generic DWOp
forall x. Rep DWOp x -> DWOp
forall x. DWOp -> Rep DWOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DWOp x -> DWOp
$cfrom :: forall x. DWOp -> Rep DWOp x
Generic)

-- | <http://llvm.org/docs/LangRef.html#metadata>
data MDNode
  = MDTuple [Maybe Metadata] -- ^ Nothing represents 'null'
  | DIExpression DIExpression
  | DIGlobalVariableExpression DIGlobalVariableExpression
  | DILocation DILocation
  | DIMacroNode DIMacroNode
  | DINode DINode
  deriving (MDNode -> MDNode -> Bool
(MDNode -> MDNode -> Bool)
-> (MDNode -> MDNode -> Bool) -> Eq MDNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MDNode -> MDNode -> Bool
$c/= :: MDNode -> MDNode -> Bool
== :: MDNode -> MDNode -> Bool
$c== :: MDNode -> MDNode -> Bool
Eq, Eq MDNode
Eq MDNode =>
(MDNode -> MDNode -> Ordering)
-> (MDNode -> MDNode -> Bool)
-> (MDNode -> MDNode -> Bool)
-> (MDNode -> MDNode -> Bool)
-> (MDNode -> MDNode -> Bool)
-> (MDNode -> MDNode -> MDNode)
-> (MDNode -> MDNode -> MDNode)
-> Ord MDNode
MDNode -> MDNode -> Bool
MDNode -> MDNode -> Ordering
MDNode -> MDNode -> MDNode
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: MDNode -> MDNode -> MDNode
$cmin :: MDNode -> MDNode -> MDNode
max :: MDNode -> MDNode -> MDNode
$cmax :: MDNode -> MDNode -> MDNode
>= :: MDNode -> MDNode -> Bool
$c>= :: MDNode -> MDNode -> Bool
> :: MDNode -> MDNode -> Bool
$c> :: MDNode -> MDNode -> Bool
<= :: MDNode -> MDNode -> Bool
$c<= :: MDNode -> MDNode -> Bool
< :: MDNode -> MDNode -> Bool
$c< :: MDNode -> MDNode -> Bool
compare :: MDNode -> MDNode -> Ordering
$ccompare :: MDNode -> MDNode -> Ordering
$cp1Ord :: Eq MDNode
Ord, ReadPrec [MDNode]
ReadPrec MDNode
Int -> ReadS MDNode
ReadS [MDNode]
(Int -> ReadS MDNode)
-> ReadS [MDNode]
-> ReadPrec MDNode
-> ReadPrec [MDNode]
-> Read MDNode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MDNode]
$creadListPrec :: ReadPrec [MDNode]
readPrec :: ReadPrec MDNode
$creadPrec :: ReadPrec MDNode
readList :: ReadS [MDNode]
$creadList :: ReadS [MDNode]
readsPrec :: Int -> ReadS MDNode
$creadsPrec :: Int -> ReadS MDNode
Read, Int -> MDNode -> ShowS
[MDNode] -> ShowS
MDNode -> String
(Int -> MDNode -> ShowS)
-> (MDNode -> String) -> ([MDNode] -> ShowS) -> Show MDNode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MDNode] -> ShowS
$cshowList :: [MDNode] -> ShowS
show :: MDNode -> String
$cshow :: MDNode -> String
showsPrec :: Int -> MDNode -> ShowS
$cshowsPrec :: Int -> MDNode -> ShowS
Show, Typeable, Typeable MDNode
DataType
Constr
Typeable MDNode =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MDNode -> c MDNode)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MDNode)
-> (MDNode -> Constr)
-> (MDNode -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MDNode))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MDNode))
-> ((forall b. Data b => b -> b) -> MDNode -> MDNode)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MDNode -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MDNode -> r)
-> (forall u. (forall d. Data d => d -> u) -> MDNode -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> MDNode -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MDNode -> m MDNode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MDNode -> m MDNode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MDNode -> m MDNode)
-> Data MDNode
MDNode -> DataType
MDNode -> Constr
(forall b. Data b => b -> b) -> MDNode -> MDNode
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MDNode -> c MDNode
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MDNode
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> MDNode -> u
forall u. (forall d. Data d => d -> u) -> MDNode -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MDNode -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MDNode -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MDNode -> m MDNode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MDNode -> m MDNode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MDNode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MDNode -> c MDNode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MDNode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MDNode)
$cDINode :: Constr
$cDIMacroNode :: Constr
$cDILocation :: Constr
$cDIGlobalVariableExpression :: Constr
$cDIExpression :: Constr
$cMDTuple :: Constr
$tMDNode :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> MDNode -> m MDNode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MDNode -> m MDNode
gmapMp :: (forall d. Data d => d -> m d) -> MDNode -> m MDNode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MDNode -> m MDNode
gmapM :: (forall d. Data d => d -> m d) -> MDNode -> m MDNode
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MDNode -> m MDNode
gmapQi :: Int -> (forall d. Data d => d -> u) -> MDNode -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MDNode -> u
gmapQ :: (forall d. Data d => d -> u) -> MDNode -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MDNode -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MDNode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MDNode -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MDNode -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MDNode -> r
gmapT :: (forall b. Data b => b -> b) -> MDNode -> MDNode
$cgmapT :: (forall b. Data b => b -> b) -> MDNode -> MDNode
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MDNode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MDNode)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c MDNode)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MDNode)
dataTypeOf :: MDNode -> DataType
$cdataTypeOf :: MDNode -> DataType
toConstr :: MDNode -> Constr
$ctoConstr :: MDNode -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MDNode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MDNode
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MDNode -> c MDNode
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MDNode -> c MDNode
$cp1Data :: Typeable MDNode
Data, (forall x. MDNode -> Rep MDNode x)
-> (forall x. Rep MDNode x -> MDNode) -> Generic MDNode
forall x. Rep MDNode x -> MDNode
forall x. MDNode -> Rep MDNode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MDNode x -> MDNode
$cfrom :: forall x. MDNode -> Rep MDNode x
Generic)

data DILocation = Location
  { DILocation -> Word32
line :: Word32
  , DILocation -> Word16
column :: Word16
  , DILocation -> MDRef DILocalScope
scope :: MDRef DILocalScope
  } deriving (DILocation -> DILocation -> Bool
(DILocation -> DILocation -> Bool)
-> (DILocation -> DILocation -> Bool) -> Eq DILocation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DILocation -> DILocation -> Bool
$c/= :: DILocation -> DILocation -> Bool
== :: DILocation -> DILocation -> Bool
$c== :: DILocation -> DILocation -> Bool
Eq, Eq DILocation
Eq DILocation =>
(DILocation -> DILocation -> Ordering)
-> (DILocation -> DILocation -> Bool)
-> (DILocation -> DILocation -> Bool)
-> (DILocation -> DILocation -> Bool)
-> (DILocation -> DILocation -> Bool)
-> (DILocation -> DILocation -> DILocation)
-> (DILocation -> DILocation -> DILocation)
-> Ord DILocation
DILocation -> DILocation -> Bool
DILocation -> DILocation -> Ordering
DILocation -> DILocation -> DILocation
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DILocation -> DILocation -> DILocation
$cmin :: DILocation -> DILocation -> DILocation
max :: DILocation -> DILocation -> DILocation
$cmax :: DILocation -> DILocation -> DILocation
>= :: DILocation -> DILocation -> Bool
$c>= :: DILocation -> DILocation -> Bool
> :: DILocation -> DILocation -> Bool
$c> :: DILocation -> DILocation -> Bool
<= :: DILocation -> DILocation -> Bool
$c<= :: DILocation -> DILocation -> Bool
< :: DILocation -> DILocation -> Bool
$c< :: DILocation -> DILocation -> Bool
compare :: DILocation -> DILocation -> Ordering
$ccompare :: DILocation -> DILocation -> Ordering
$cp1Ord :: Eq DILocation
Ord, ReadPrec [DILocation]
ReadPrec DILocation
Int -> ReadS DILocation
ReadS [DILocation]
(Int -> ReadS DILocation)
-> ReadS [DILocation]
-> ReadPrec DILocation
-> ReadPrec [DILocation]
-> Read DILocation
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DILocation]
$creadListPrec :: ReadPrec [DILocation]
readPrec :: ReadPrec DILocation
$creadPrec :: ReadPrec DILocation
readList :: ReadS [DILocation]
$creadList :: ReadS [DILocation]
readsPrec :: Int -> ReadS DILocation
$creadsPrec :: Int -> ReadS DILocation
Read, Int -> DILocation -> ShowS
[DILocation] -> ShowS
DILocation -> String
(Int -> DILocation -> ShowS)
-> (DILocation -> String)
-> ([DILocation] -> ShowS)
-> Show DILocation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DILocation] -> ShowS
$cshowList :: [DILocation] -> ShowS
show :: DILocation -> String
$cshow :: DILocation -> String
showsPrec :: Int -> DILocation -> ShowS
$cshowsPrec :: Int -> DILocation -> ShowS
Show, Typeable, Typeable DILocation
DataType
Constr
Typeable DILocation =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DILocation -> c DILocation)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DILocation)
-> (DILocation -> Constr)
-> (DILocation -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DILocation))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DILocation))
-> ((forall b. Data b => b -> b) -> DILocation -> DILocation)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DILocation -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DILocation -> r)
-> (forall u. (forall d. Data d => d -> u) -> DILocation -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DILocation -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DILocation -> m DILocation)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DILocation -> m DILocation)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DILocation -> m DILocation)
-> Data DILocation
DILocation -> DataType
DILocation -> Constr
(forall b. Data b => b -> b) -> DILocation -> DILocation
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocation -> c DILocation
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocation
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DILocation -> u
forall u. (forall d. Data d => d -> u) -> DILocation -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocation -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocation -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DILocation -> m DILocation
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILocation -> m DILocation
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocation
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocation -> c DILocation
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILocation)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DILocation)
$cLocation :: Constr
$tDILocation :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DILocation -> m DILocation
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILocation -> m DILocation
gmapMp :: (forall d. Data d => d -> m d) -> DILocation -> m DILocation
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILocation -> m DILocation
gmapM :: (forall d. Data d => d -> m d) -> DILocation -> m DILocation
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DILocation -> m DILocation
gmapQi :: Int -> (forall d. Data d => d -> u) -> DILocation -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DILocation -> u
gmapQ :: (forall d. Data d => d -> u) -> DILocation -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DILocation -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocation -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocation -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocation -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocation -> r
gmapT :: (forall b. Data b => b -> b) -> DILocation -> DILocation
$cgmapT :: (forall b. Data b => b -> b) -> DILocation -> DILocation
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DILocation)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DILocation)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DILocation)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILocation)
dataTypeOf :: DILocation -> DataType
$cdataTypeOf :: DILocation -> DataType
toConstr :: DILocation -> Constr
$ctoConstr :: DILocation -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocation
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocation
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocation -> c DILocation
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocation -> c DILocation
$cp1Data :: Typeable DILocation
Data, (forall x. DILocation -> Rep DILocation x)
-> (forall x. Rep DILocation x -> DILocation) -> Generic DILocation
forall x. Rep DILocation x -> DILocation
forall x. DILocation -> Rep DILocation x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DILocation x -> DILocation
$cfrom :: forall x. DILocation -> Rep DILocation x
Generic)

-- | <https://llvm.org/docs/LangRef.html#diexpression>
data DIExpression = Expression
  { DIExpression -> [DWOp]
operands :: [DWOp]
  } deriving (DIExpression -> DIExpression -> Bool
(DIExpression -> DIExpression -> Bool)
-> (DIExpression -> DIExpression -> Bool) -> Eq DIExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIExpression -> DIExpression -> Bool
$c/= :: DIExpression -> DIExpression -> Bool
== :: DIExpression -> DIExpression -> Bool
$c== :: DIExpression -> DIExpression -> Bool
Eq, Eq DIExpression
Eq DIExpression =>
(DIExpression -> DIExpression -> Ordering)
-> (DIExpression -> DIExpression -> Bool)
-> (DIExpression -> DIExpression -> Bool)
-> (DIExpression -> DIExpression -> Bool)
-> (DIExpression -> DIExpression -> Bool)
-> (DIExpression -> DIExpression -> DIExpression)
-> (DIExpression -> DIExpression -> DIExpression)
-> Ord DIExpression
DIExpression -> DIExpression -> Bool
DIExpression -> DIExpression -> Ordering
DIExpression -> DIExpression -> DIExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DIExpression -> DIExpression -> DIExpression
$cmin :: DIExpression -> DIExpression -> DIExpression
max :: DIExpression -> DIExpression -> DIExpression
$cmax :: DIExpression -> DIExpression -> DIExpression
>= :: DIExpression -> DIExpression -> Bool
$c>= :: DIExpression -> DIExpression -> Bool
> :: DIExpression -> DIExpression -> Bool
$c> :: DIExpression -> DIExpression -> Bool
<= :: DIExpression -> DIExpression -> Bool
$c<= :: DIExpression -> DIExpression -> Bool
< :: DIExpression -> DIExpression -> Bool
$c< :: DIExpression -> DIExpression -> Bool
compare :: DIExpression -> DIExpression -> Ordering
$ccompare :: DIExpression -> DIExpression -> Ordering
$cp1Ord :: Eq DIExpression
Ord, ReadPrec [DIExpression]
ReadPrec DIExpression
Int -> ReadS DIExpression
ReadS [DIExpression]
(Int -> ReadS DIExpression)
-> ReadS [DIExpression]
-> ReadPrec DIExpression
-> ReadPrec [DIExpression]
-> Read DIExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DIExpression]
$creadListPrec :: ReadPrec [DIExpression]
readPrec :: ReadPrec DIExpression
$creadPrec :: ReadPrec DIExpression
readList :: ReadS [DIExpression]
$creadList :: ReadS [DIExpression]
readsPrec :: Int -> ReadS DIExpression
$creadsPrec :: Int -> ReadS DIExpression
Read, Int -> DIExpression -> ShowS
[DIExpression] -> ShowS
DIExpression -> String
(Int -> DIExpression -> ShowS)
-> (DIExpression -> String)
-> ([DIExpression] -> ShowS)
-> Show DIExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DIExpression] -> ShowS
$cshowList :: [DIExpression] -> ShowS
show :: DIExpression -> String
$cshow :: DIExpression -> String
showsPrec :: Int -> DIExpression -> ShowS
$cshowsPrec :: Int -> DIExpression -> ShowS
Show, Typeable, Typeable DIExpression
DataType
Constr
Typeable DIExpression =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIExpression -> c DIExpression)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIExpression)
-> (DIExpression -> Constr)
-> (DIExpression -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIExpression))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIExpression))
-> ((forall b. Data b => b -> b) -> DIExpression -> DIExpression)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIExpression -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIExpression -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIExpression -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIExpression -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIExpression -> m DIExpression)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIExpression -> m DIExpression)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIExpression -> m DIExpression)
-> Data DIExpression
DIExpression -> DataType
DIExpression -> Constr
(forall b. Data b => b -> b) -> DIExpression -> DIExpression
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIExpression -> c DIExpression
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIExpression
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DIExpression -> u
forall u. (forall d. Data d => d -> u) -> DIExpression -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIExpression -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIExpression -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIExpression
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIExpression -> c DIExpression
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIExpression)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIExpression)
$cExpression :: Constr
$tDIExpression :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
gmapMp :: (forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
gmapM :: (forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
gmapQi :: Int -> (forall d. Data d => d -> u) -> DIExpression -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIExpression -> u
gmapQ :: (forall d. Data d => d -> u) -> DIExpression -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIExpression -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIExpression -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIExpression -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIExpression -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIExpression -> r
gmapT :: (forall b. Data b => b -> b) -> DIExpression -> DIExpression
$cgmapT :: (forall b. Data b => b -> b) -> DIExpression -> DIExpression
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIExpression)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIExpression)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DIExpression)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIExpression)
dataTypeOf :: DIExpression -> DataType
$cdataTypeOf :: DIExpression -> DataType
toConstr :: DIExpression -> Constr
$ctoConstr :: DIExpression -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIExpression
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIExpression
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIExpression -> c DIExpression
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIExpression -> c DIExpression
$cp1Data :: Typeable DIExpression
Data, (forall x. DIExpression -> Rep DIExpression x)
-> (forall x. Rep DIExpression x -> DIExpression)
-> Generic DIExpression
forall x. Rep DIExpression x -> DIExpression
forall x. DIExpression -> Rep DIExpression x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DIExpression x -> DIExpression
$cfrom :: forall x. DIExpression -> Rep DIExpression x
Generic)

-- | A pair of a `DIGlobalVariable` and a `DIExpression`.
--
-- This is used in the `cuGlobals` fields of `DICompileUnit`.
data DIGlobalVariableExpression = GlobalVariableExpression
  { DIGlobalVariableExpression -> MDRef DIGlobalVariable
var :: MDRef DIGlobalVariable
  , DIGlobalVariableExpression -> MDRef DIExpression
expr :: MDRef DIExpression
  } deriving (DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
(DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool)
-> (DIGlobalVariableExpression
    -> DIGlobalVariableExpression -> Bool)
-> Eq DIGlobalVariableExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
$c/= :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
== :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
$c== :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
Eq, Eq DIGlobalVariableExpression
Eq DIGlobalVariableExpression =>
(DIGlobalVariableExpression
 -> DIGlobalVariableExpression -> Ordering)
-> (DIGlobalVariableExpression
    -> DIGlobalVariableExpression -> Bool)
-> (DIGlobalVariableExpression
    -> DIGlobalVariableExpression -> Bool)
-> (DIGlobalVariableExpression
    -> DIGlobalVariableExpression -> Bool)
-> (DIGlobalVariableExpression
    -> DIGlobalVariableExpression -> Bool)
-> (DIGlobalVariableExpression
    -> DIGlobalVariableExpression -> DIGlobalVariableExpression)
-> (DIGlobalVariableExpression
    -> DIGlobalVariableExpression -> DIGlobalVariableExpression)
-> Ord DIGlobalVariableExpression
DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
DIGlobalVariableExpression
-> DIGlobalVariableExpression -> Ordering
DIGlobalVariableExpression
-> DIGlobalVariableExpression -> DIGlobalVariableExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DIGlobalVariableExpression
-> DIGlobalVariableExpression -> DIGlobalVariableExpression
$cmin :: DIGlobalVariableExpression
-> DIGlobalVariableExpression -> DIGlobalVariableExpression
max :: DIGlobalVariableExpression
-> DIGlobalVariableExpression -> DIGlobalVariableExpression
$cmax :: DIGlobalVariableExpression
-> DIGlobalVariableExpression -> DIGlobalVariableExpression
>= :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
$c>= :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
> :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
$c> :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
<= :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
$c<= :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
< :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
$c< :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
compare :: DIGlobalVariableExpression
-> DIGlobalVariableExpression -> Ordering
$ccompare :: DIGlobalVariableExpression
-> DIGlobalVariableExpression -> Ordering
$cp1Ord :: Eq DIGlobalVariableExpression
Ord, ReadPrec [DIGlobalVariableExpression]
ReadPrec DIGlobalVariableExpression
Int -> ReadS DIGlobalVariableExpression
ReadS [DIGlobalVariableExpression]
(Int -> ReadS DIGlobalVariableExpression)
-> ReadS [DIGlobalVariableExpression]
-> ReadPrec DIGlobalVariableExpression
-> ReadPrec [DIGlobalVariableExpression]
-> Read DIGlobalVariableExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DIGlobalVariableExpression]
$creadListPrec :: ReadPrec [DIGlobalVariableExpression]
readPrec :: ReadPrec DIGlobalVariableExpression
$creadPrec :: ReadPrec DIGlobalVariableExpression
readList :: ReadS [DIGlobalVariableExpression]
$creadList :: ReadS [DIGlobalVariableExpression]
readsPrec :: Int -> ReadS DIGlobalVariableExpression
$creadsPrec :: Int -> ReadS DIGlobalVariableExpression
Read, Int -> DIGlobalVariableExpression -> ShowS
[DIGlobalVariableExpression] -> ShowS
DIGlobalVariableExpression -> String
(Int -> DIGlobalVariableExpression -> ShowS)
-> (DIGlobalVariableExpression -> String)
-> ([DIGlobalVariableExpression] -> ShowS)
-> Show DIGlobalVariableExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DIGlobalVariableExpression] -> ShowS
$cshowList :: [DIGlobalVariableExpression] -> ShowS
show :: DIGlobalVariableExpression -> String
$cshow :: DIGlobalVariableExpression -> String
showsPrec :: Int -> DIGlobalVariableExpression -> ShowS
$cshowsPrec :: Int -> DIGlobalVariableExpression -> ShowS
Show, Typeable, Typeable DIGlobalVariableExpression
DataType
Constr
Typeable DIGlobalVariableExpression =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DIGlobalVariableExpression
 -> c DIGlobalVariableExpression)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIGlobalVariableExpression)
-> (DIGlobalVariableExpression -> Constr)
-> (DIGlobalVariableExpression -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c DIGlobalVariableExpression))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIGlobalVariableExpression))
-> ((forall b. Data b => b -> b)
    -> DIGlobalVariableExpression -> DIGlobalVariableExpression)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DIGlobalVariableExpression
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DIGlobalVariableExpression
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DIGlobalVariableExpression -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u) -> DIGlobalVariableExpression -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DIGlobalVariableExpression -> m DIGlobalVariableExpression)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIGlobalVariableExpression -> m DIGlobalVariableExpression)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIGlobalVariableExpression -> m DIGlobalVariableExpression)
-> Data DIGlobalVariableExpression
DIGlobalVariableExpression -> DataType
DIGlobalVariableExpression -> Constr
(forall b. Data b => b -> b)
-> DIGlobalVariableExpression -> DIGlobalVariableExpression
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIGlobalVariableExpression
-> c DIGlobalVariableExpression
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIGlobalVariableExpression
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int
-> (forall d. Data d => d -> u) -> DIGlobalVariableExpression -> u
forall u.
(forall d. Data d => d -> u) -> DIGlobalVariableExpression -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression -> m DIGlobalVariableExpression
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression -> m DIGlobalVariableExpression
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIGlobalVariableExpression
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIGlobalVariableExpression
-> c DIGlobalVariableExpression
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c DIGlobalVariableExpression)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIGlobalVariableExpression)
$cGlobalVariableExpression :: Constr
$tDIGlobalVariableExpression :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> DIGlobalVariableExpression -> m DIGlobalVariableExpression
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression -> m DIGlobalVariableExpression
gmapMp :: (forall d. Data d => d -> m d)
-> DIGlobalVariableExpression -> m DIGlobalVariableExpression
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression -> m DIGlobalVariableExpression
gmapM :: (forall d. Data d => d -> m d)
-> DIGlobalVariableExpression -> m DIGlobalVariableExpression
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression -> m DIGlobalVariableExpression
gmapQi :: Int
-> (forall d. Data d => d -> u) -> DIGlobalVariableExpression -> u
$cgmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> DIGlobalVariableExpression -> u
gmapQ :: (forall d. Data d => d -> u) -> DIGlobalVariableExpression -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> DIGlobalVariableExpression -> [u]
gmapQr :: (r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression
-> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression
-> r
gmapQl :: (r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression
-> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression
-> r
gmapT :: (forall b. Data b => b -> b)
-> DIGlobalVariableExpression -> DIGlobalVariableExpression
$cgmapT :: (forall b. Data b => b -> b)
-> DIGlobalVariableExpression -> DIGlobalVariableExpression
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIGlobalVariableExpression)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIGlobalVariableExpression)
dataCast1 :: (forall d. Data d => c (t d))
-> Maybe (c DIGlobalVariableExpression)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c DIGlobalVariableExpression)
dataTypeOf :: DIGlobalVariableExpression -> DataType
$cdataTypeOf :: DIGlobalVariableExpression -> DataType
toConstr :: DIGlobalVariableExpression -> Constr
$ctoConstr :: DIGlobalVariableExpression -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIGlobalVariableExpression
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIGlobalVariableExpression
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIGlobalVariableExpression
-> c DIGlobalVariableExpression
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIGlobalVariableExpression
-> c DIGlobalVariableExpression
$cp1Data :: Typeable DIGlobalVariableExpression
Data, (forall x.
 DIGlobalVariableExpression -> Rep DIGlobalVariableExpression x)
-> (forall x.
    Rep DIGlobalVariableExpression x -> DIGlobalVariableExpression)
-> Generic DIGlobalVariableExpression
forall x.
Rep DIGlobalVariableExpression x -> DIGlobalVariableExpression
forall x.
DIGlobalVariableExpression -> Rep DIGlobalVariableExpression x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DIGlobalVariableExpression x -> DIGlobalVariableExpression
$cfrom :: forall x.
DIGlobalVariableExpression -> Rep DIGlobalVariableExpression x
Generic)

-- | Accessiblity flag
data DIAccessibility
  = Private
  | Protected
  | Public
  deriving (DIAccessibility -> DIAccessibility -> Bool
(DIAccessibility -> DIAccessibility -> Bool)
-> (DIAccessibility -> DIAccessibility -> Bool)
-> Eq DIAccessibility
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIAccessibility -> DIAccessibility -> Bool
$c/= :: DIAccessibility -> DIAccessibility -> Bool
== :: DIAccessibility -> DIAccessibility -> Bool
$c== :: DIAccessibility -> DIAccessibility -> Bool
Eq, Eq DIAccessibility
Eq DIAccessibility =>
(DIAccessibility -> DIAccessibility -> Ordering)
-> (DIAccessibility -> DIAccessibility -> Bool)
-> (DIAccessibility -> DIAccessibility -> Bool)
-> (DIAccessibility -> DIAccessibility -> Bool)
-> (DIAccessibility -> DIAccessibility -> Bool)
-> (DIAccessibility -> DIAccessibility -> DIAccessibility)
-> (DIAccessibility -> DIAccessibility -> DIAccessibility)
-> Ord DIAccessibility
DIAccessibility -> DIAccessibility -> Bool
DIAccessibility -> DIAccessibility -> Ordering
DIAccessibility -> DIAccessibility -> DIAccessibility
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DIAccessibility -> DIAccessibility -> DIAccessibility
$cmin :: DIAccessibility -> DIAccessibility -> DIAccessibility
max :: DIAccessibility -> DIAccessibility -> DIAccessibility
$cmax :: DIAccessibility -> DIAccessibility -> DIAccessibility
>= :: DIAccessibility -> DIAccessibility -> Bool
$c>= :: DIAccessibility -> DIAccessibility -> Bool
> :: DIAccessibility -> DIAccessibility -> Bool
$c> :: DIAccessibility -> DIAccessibility -> Bool
<= :: DIAccessibility -> DIAccessibility -> Bool
$c<= :: DIAccessibility -> DIAccessibility -> Bool
< :: DIAccessibility -> DIAccessibility -> Bool
$c< :: DIAccessibility -> DIAccessibility -> Bool
compare :: DIAccessibility -> DIAccessibility -> Ordering
$ccompare :: DIAccessibility -> DIAccessibility -> Ordering
$cp1Ord :: Eq DIAccessibility
Ord, ReadPrec [DIAccessibility]
ReadPrec DIAccessibility
Int -> ReadS DIAccessibility
ReadS [DIAccessibility]
(Int -> ReadS DIAccessibility)
-> ReadS [DIAccessibility]
-> ReadPrec DIAccessibility
-> ReadPrec [DIAccessibility]
-> Read DIAccessibility
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DIAccessibility]
$creadListPrec :: ReadPrec [DIAccessibility]
readPrec :: ReadPrec DIAccessibility
$creadPrec :: ReadPrec DIAccessibility
readList :: ReadS [DIAccessibility]
$creadList :: ReadS [DIAccessibility]
readsPrec :: Int -> ReadS DIAccessibility
$creadsPrec :: Int -> ReadS DIAccessibility
Read, Int -> DIAccessibility -> ShowS
[DIAccessibility] -> ShowS
DIAccessibility -> String
(Int -> DIAccessibility -> ShowS)
-> (DIAccessibility -> String)
-> ([DIAccessibility] -> ShowS)
-> Show DIAccessibility
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DIAccessibility] -> ShowS
$cshowList :: [DIAccessibility] -> ShowS
show :: DIAccessibility -> String
$cshow :: DIAccessibility -> String
showsPrec :: Int -> DIAccessibility -> ShowS
$cshowsPrec :: Int -> DIAccessibility -> ShowS
Show, Typeable, Typeable DIAccessibility
DataType
Constr
Typeable DIAccessibility =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIAccessibility -> c DIAccessibility)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIAccessibility)
-> (DIAccessibility -> Constr)
-> (DIAccessibility -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIAccessibility))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIAccessibility))
-> ((forall b. Data b => b -> b)
    -> DIAccessibility -> DIAccessibility)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIAccessibility -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIAccessibility -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DIAccessibility -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIAccessibility -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DIAccessibility -> m DIAccessibility)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIAccessibility -> m DIAccessibility)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIAccessibility -> m DIAccessibility)
-> Data DIAccessibility
DIAccessibility -> DataType
DIAccessibility -> Constr
(forall b. Data b => b -> b) -> DIAccessibility -> DIAccessibility
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIAccessibility -> c DIAccessibility
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIAccessibility
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DIAccessibility -> u
forall u. (forall d. Data d => d -> u) -> DIAccessibility -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIAccessibility -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIAccessibility -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIAccessibility -> m DIAccessibility
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIAccessibility -> m DIAccessibility
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIAccessibility
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIAccessibility -> c DIAccessibility
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIAccessibility)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIAccessibility)
$cPublic :: Constr
$cProtected :: Constr
$cPrivate :: Constr
$tDIAccessibility :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> DIAccessibility -> m DIAccessibility
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIAccessibility -> m DIAccessibility
gmapMp :: (forall d. Data d => d -> m d)
-> DIAccessibility -> m DIAccessibility
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIAccessibility -> m DIAccessibility
gmapM :: (forall d. Data d => d -> m d)
-> DIAccessibility -> m DIAccessibility
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIAccessibility -> m DIAccessibility
gmapQi :: Int -> (forall d. Data d => d -> u) -> DIAccessibility -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DIAccessibility -> u
gmapQ :: (forall d. Data d => d -> u) -> DIAccessibility -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIAccessibility -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIAccessibility -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIAccessibility -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIAccessibility -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIAccessibility -> r
gmapT :: (forall b. Data b => b -> b) -> DIAccessibility -> DIAccessibility
$cgmapT :: (forall b. Data b => b -> b) -> DIAccessibility -> DIAccessibility
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIAccessibility)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIAccessibility)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DIAccessibility)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIAccessibility)
dataTypeOf :: DIAccessibility -> DataType
$cdataTypeOf :: DIAccessibility -> DataType
toConstr :: DIAccessibility -> Constr
$ctoConstr :: DIAccessibility -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIAccessibility
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIAccessibility
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIAccessibility -> c DIAccessibility
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIAccessibility -> c DIAccessibility
$cp1Data :: Typeable DIAccessibility
Data, (forall x. DIAccessibility -> Rep DIAccessibility x)
-> (forall x. Rep DIAccessibility x -> DIAccessibility)
-> Generic DIAccessibility
forall x. Rep DIAccessibility x -> DIAccessibility
forall x. DIAccessibility -> Rep DIAccessibility x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DIAccessibility x -> DIAccessibility
$cfrom :: forall x. DIAccessibility -> Rep DIAccessibility x
Generic)

-- | Inheritance flag
data DIInheritance
  = SingleInheritance
  | MultipleInheritance
  | VirtualInheritance
  deriving (DIInheritance -> DIInheritance -> Bool
(DIInheritance -> DIInheritance -> Bool)
-> (DIInheritance -> DIInheritance -> Bool) -> Eq DIInheritance
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIInheritance -> DIInheritance -> Bool
$c/= :: DIInheritance -> DIInheritance -> Bool
== :: DIInheritance -> DIInheritance -> Bool
$c== :: DIInheritance -> DIInheritance -> Bool
Eq, Eq DIInheritance
Eq DIInheritance =>
(DIInheritance -> DIInheritance -> Ordering)
-> (DIInheritance -> DIInheritance -> Bool)
-> (DIInheritance -> DIInheritance -> Bool)
-> (DIInheritance -> DIInheritance -> Bool)
-> (DIInheritance -> DIInheritance -> Bool)
-> (DIInheritance -> DIInheritance -> DIInheritance)
-> (DIInheritance -> DIInheritance -> DIInheritance)
-> Ord DIInheritance
DIInheritance -> DIInheritance -> Bool
DIInheritance -> DIInheritance -> Ordering
DIInheritance -> DIInheritance -> DIInheritance
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DIInheritance -> DIInheritance -> DIInheritance
$cmin :: DIInheritance -> DIInheritance -> DIInheritance
max :: DIInheritance -> DIInheritance -> DIInheritance
$cmax :: DIInheritance -> DIInheritance -> DIInheritance
>= :: DIInheritance -> DIInheritance -> Bool
$c>= :: DIInheritance -> DIInheritance -> Bool
> :: DIInheritance -> DIInheritance -> Bool
$c> :: DIInheritance -> DIInheritance -> Bool
<= :: DIInheritance -> DIInheritance -> Bool
$c<= :: DIInheritance -> DIInheritance -> Bool
< :: DIInheritance -> DIInheritance -> Bool
$c< :: DIInheritance -> DIInheritance -> Bool
compare :: DIInheritance -> DIInheritance -> Ordering
$ccompare :: DIInheritance -> DIInheritance -> Ordering
$cp1Ord :: Eq DIInheritance
Ord, ReadPrec [DIInheritance]
ReadPrec DIInheritance
Int -> ReadS DIInheritance
ReadS [DIInheritance]
(Int -> ReadS DIInheritance)
-> ReadS [DIInheritance]
-> ReadPrec DIInheritance
-> ReadPrec [DIInheritance]
-> Read DIInheritance
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DIInheritance]
$creadListPrec :: ReadPrec [DIInheritance]
readPrec :: ReadPrec DIInheritance
$creadPrec :: ReadPrec DIInheritance
readList :: ReadS [DIInheritance]
$creadList :: ReadS [DIInheritance]
readsPrec :: Int -> ReadS DIInheritance
$creadsPrec :: Int -> ReadS DIInheritance
Read, Int -> DIInheritance -> ShowS
[DIInheritance] -> ShowS
DIInheritance -> String
(Int -> DIInheritance -> ShowS)
-> (DIInheritance -> String)
-> ([DIInheritance] -> ShowS)
-> Show DIInheritance
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DIInheritance] -> ShowS
$cshowList :: [DIInheritance] -> ShowS
show :: DIInheritance -> String
$cshow :: DIInheritance -> String
showsPrec :: Int -> DIInheritance -> ShowS
$cshowsPrec :: Int -> DIInheritance -> ShowS
Show, Typeable, Typeable DIInheritance
DataType
Constr
Typeable DIInheritance =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIInheritance -> c DIInheritance)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIInheritance)
-> (DIInheritance -> Constr)
-> (DIInheritance -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIInheritance))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIInheritance))
-> ((forall b. Data b => b -> b) -> DIInheritance -> DIInheritance)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIInheritance -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIInheritance -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIInheritance -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIInheritance -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance)
-> Data DIInheritance
DIInheritance -> DataType
DIInheritance -> Constr
(forall b. Data b => b -> b) -> DIInheritance -> DIInheritance
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIInheritance -> c DIInheritance
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIInheritance
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DIInheritance -> u
forall u. (forall d. Data d => d -> u) -> DIInheritance -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIInheritance -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIInheritance -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIInheritance
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIInheritance -> c DIInheritance
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIInheritance)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIInheritance)
$cVirtualInheritance :: Constr
$cMultipleInheritance :: Constr
$cSingleInheritance :: Constr
$tDIInheritance :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance
gmapMp :: (forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance
gmapM :: (forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance
gmapQi :: Int -> (forall d. Data d => d -> u) -> DIInheritance -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIInheritance -> u
gmapQ :: (forall d. Data d => d -> u) -> DIInheritance -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIInheritance -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIInheritance -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIInheritance -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIInheritance -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIInheritance -> r
gmapT :: (forall b. Data b => b -> b) -> DIInheritance -> DIInheritance
$cgmapT :: (forall b. Data b => b -> b) -> DIInheritance -> DIInheritance
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIInheritance)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIInheritance)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DIInheritance)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIInheritance)
dataTypeOf :: DIInheritance -> DataType
$cdataTypeOf :: DIInheritance -> DataType
toConstr :: DIInheritance -> Constr
$ctoConstr :: DIInheritance -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIInheritance
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIInheritance
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIInheritance -> c DIInheritance
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIInheritance -> c DIInheritance
$cp1Data :: Typeable DIInheritance
Data, (forall x. DIInheritance -> Rep DIInheritance x)
-> (forall x. Rep DIInheritance x -> DIInheritance)
-> Generic DIInheritance
forall x. Rep DIInheritance x -> DIInheritance
forall x. DIInheritance -> Rep DIInheritance x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DIInheritance x -> DIInheritance
$cfrom :: forall x. DIInheritance -> Rep DIInheritance x
Generic)

data DIFlag
  = Accessibility DIAccessibility
  | FwdDecl
  | AppleBlock
  | BlockByrefStruct
  | VirtualFlag
  | Artificial
  | Explicit
  | Prototyped
  | ObjcClassComplete
  | ObjectPointer
  | Vector
  | StaticMember
  | LValueReference
  | RValueReference
  | InheritanceFlag DIInheritance
  | IntroducedVirtual
  | BitField
  | NoReturn
  | ArgumentNotModified
  | TypePassByValue
  | TypePassByReference
  | EnumClass
  | Thunk
  | NonTrivial
  | BigEndian
  | LittleEndian
  | AllCallsDescribed
  deriving (DIFlag -> DIFlag -> Bool
(DIFlag -> DIFlag -> Bool)
-> (DIFlag -> DIFlag -> Bool) -> Eq DIFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIFlag -> DIFlag -> Bool
$c/= :: DIFlag -> DIFlag -> Bool
== :: DIFlag -> DIFlag -> Bool
$c== :: DIFlag -> DIFlag -> Bool
Eq, Eq DIFlag
Eq DIFlag =>
(DIFlag -> DIFlag -> Ordering)
-> (DIFlag -> DIFlag -> Bool)
-> (DIFlag -> DIFlag -> Bool)
-> (DIFlag -> DIFlag -> Bool)
-> (DIFlag -> DIFlag -> Bool)
-> (DIFlag -> DIFlag -> DIFlag)
-> (DIFlag -> DIFlag -> DIFlag)
-> Ord DIFlag
DIFlag -> DIFlag -> Bool
DIFlag -> DIFlag -> Ordering
DIFlag -> DIFlag -> DIFlag
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DIFlag -> DIFlag -> DIFlag
$cmin :: DIFlag -> DIFlag -> DIFlag
max :: DIFlag -> DIFlag -> DIFlag
$cmax :: DIFlag -> DIFlag -> DIFlag
>= :: DIFlag -> DIFlag -> Bool
$c>= :: DIFlag -> DIFlag -> Bool
> :: DIFlag -> DIFlag -> Bool
$c> :: DIFlag -> DIFlag -> Bool
<= :: DIFlag -> DIFlag -> Bool
$c<= :: DIFlag -> DIFlag -> Bool
< :: DIFlag -> DIFlag -> Bool
$c< :: DIFlag -> DIFlag -> Bool
compare :: DIFlag -> DIFlag -> Ordering
$ccompare :: DIFlag -> DIFlag -> Ordering
$cp1Ord :: Eq DIFlag
Ord, ReadPrec [DIFlag]
ReadPrec DIFlag
Int -> ReadS DIFlag
ReadS [DIFlag]
(Int -> ReadS DIFlag)
-> ReadS [DIFlag]
-> ReadPrec DIFlag
-> ReadPrec [DIFlag]
-> Read DIFlag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DIFlag]
$creadListPrec :: ReadPrec [DIFlag]
readPrec :: ReadPrec DIFlag
$creadPrec :: ReadPrec DIFlag
readList :: ReadS [DIFlag]
$creadList :: ReadS [DIFlag]
readsPrec :: Int -> ReadS DIFlag
$creadsPrec :: Int -> ReadS DIFlag
Read, Int -> DIFlag -> ShowS
[DIFlag] -> ShowS
DIFlag -> String
(Int -> DIFlag -> ShowS)
-> (DIFlag -> String) -> ([DIFlag] -> ShowS) -> Show DIFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DIFlag] -> ShowS
$cshowList :: [DIFlag] -> ShowS
show :: DIFlag -> String
$cshow :: DIFlag -> String
showsPrec :: Int -> DIFlag -> ShowS
$cshowsPrec :: Int -> DIFlag -> ShowS
Show, Typeable, Typeable DIFlag
DataType
Constr
Typeable DIFlag =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIFlag -> c DIFlag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIFlag)
-> (DIFlag -> Constr)
-> (DIFlag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIFlag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFlag))
-> ((forall b. Data b => b -> b) -> DIFlag -> DIFlag)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIFlag -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIFlag -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIFlag -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DIFlag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIFlag -> m DIFlag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIFlag -> m DIFlag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIFlag -> m DIFlag)
-> Data DIFlag
DIFlag -> DataType
DIFlag -> Constr
(forall b. Data b => b -> b) -> DIFlag -> DIFlag
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIFlag -> c DIFlag
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIFlag
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DIFlag -> u
forall u. (forall d. Data d => d -> u) -> DIFlag -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIFlag -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIFlag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIFlag -> m DIFlag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFlag -> m DIFlag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIFlag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIFlag -> c DIFlag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIFlag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFlag)
$cAllCallsDescribed :: Constr
$cLittleEndian :: Constr
$cBigEndian :: Constr
$cNonTrivial :: Constr
$cThunk :: Constr
$cEnumClass :: Constr
$cTypePassByReference :: Constr
$cTypePassByValue :: Constr
$cArgumentNotModified :: Constr
$cNoReturn :: Constr
$cBitField :: Constr
$cIntroducedVirtual :: Constr
$cInheritanceFlag :: Constr
$cRValueReference :: Constr
$cLValueReference :: Constr
$cStaticMember :: Constr
$cVector :: Constr
$cObjectPointer :: Constr
$cObjcClassComplete :: Constr
$cPrototyped :: Constr
$cExplicit :: Constr
$cArtificial :: Constr
$cVirtualFlag :: Constr
$cBlockByrefStruct :: Constr
$cAppleBlock :: Constr
$cFwdDecl :: Constr
$cAccessibility :: Constr
$tDIFlag :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DIFlag -> m DIFlag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFlag -> m DIFlag
gmapMp :: (forall d. Data d => d -> m d) -> DIFlag -> m DIFlag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFlag -> m DIFlag
gmapM :: (forall d. Data d => d -> m d) -> DIFlag -> m DIFlag
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIFlag -> m DIFlag
gmapQi :: Int -> (forall d. Data d => d -> u) -> DIFlag -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIFlag -> u
gmapQ :: (forall d. Data d => d -> u) -> DIFlag -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIFlag -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIFlag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIFlag -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIFlag -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIFlag -> r
gmapT :: (forall b. Data b => b -> b) -> DIFlag -> DIFlag
$cgmapT :: (forall b. Data b => b -> b) -> DIFlag -> DIFlag
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFlag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFlag)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DIFlag)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIFlag)
dataTypeOf :: DIFlag -> DataType
$cdataTypeOf :: DIFlag -> DataType
toConstr :: DIFlag -> Constr
$ctoConstr :: DIFlag -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIFlag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIFlag
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIFlag -> c DIFlag
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIFlag -> c DIFlag
$cp1Data :: Typeable DIFlag
Data, (forall x. DIFlag -> Rep DIFlag x)
-> (forall x. Rep DIFlag x -> DIFlag) -> Generic DIFlag
forall x. Rep DIFlag x -> DIFlag
forall x. DIFlag -> Rep DIFlag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DIFlag x -> DIFlag
$cfrom :: forall x. DIFlag -> Rep DIFlag x
Generic)

data DIMacroInfo = Define | Undef
  deriving (DIMacroInfo -> DIMacroInfo -> Bool
(DIMacroInfo -> DIMacroInfo -> Bool)
-> (DIMacroInfo -> DIMacroInfo -> Bool) -> Eq DIMacroInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIMacroInfo -> DIMacroInfo -> Bool
$c/= :: DIMacroInfo -> DIMacroInfo -> Bool
== :: DIMacroInfo -> DIMacroInfo -> Bool
$c== :: DIMacroInfo -> DIMacroInfo -> Bool
Eq, Eq DIMacroInfo
Eq DIMacroInfo =>
(DIMacroInfo -> DIMacroInfo -> Ordering)
-> (DIMacroInfo -> DIMacroInfo -> Bool)
-> (DIMacroInfo -> DIMacroInfo -> Bool)
-> (DIMacroInfo -> DIMacroInfo -> Bool)
-> (DIMacroInfo -> DIMacroInfo -> Bool)
-> (DIMacroInfo -> DIMacroInfo -> DIMacroInfo)
-> (DIMacroInfo -> DIMacroInfo -> DIMacroInfo)
-> Ord DIMacroInfo
DIMacroInfo -> DIMacroInfo -> Bool
DIMacroInfo -> DIMacroInfo -> Ordering
DIMacroInfo -> DIMacroInfo -> DIMacroInfo
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DIMacroInfo -> DIMacroInfo -> DIMacroInfo
$cmin :: DIMacroInfo -> DIMacroInfo -> DIMacroInfo
max :: DIMacroInfo -> DIMacroInfo -> DIMacroInfo
$cmax :: DIMacroInfo -> DIMacroInfo -> DIMacroInfo
>= :: DIMacroInfo -> DIMacroInfo -> Bool
$c>= :: DIMacroInfo -> DIMacroInfo -> Bool
> :: DIMacroInfo -> DIMacroInfo -> Bool
$c> :: DIMacroInfo -> DIMacroInfo -> Bool
<= :: DIMacroInfo -> DIMacroInfo -> Bool
$c<= :: DIMacroInfo -> DIMacroInfo -> Bool
< :: DIMacroInfo -> DIMacroInfo -> Bool
$c< :: DIMacroInfo -> DIMacroInfo -> Bool
compare :: DIMacroInfo -> DIMacroInfo -> Ordering
$ccompare :: DIMacroInfo -> DIMacroInfo -> Ordering
$cp1Ord :: Eq DIMacroInfo
Ord, ReadPrec [DIMacroInfo]
ReadPrec DIMacroInfo
Int -> ReadS DIMacroInfo
ReadS [DIMacroInfo]
(Int -> ReadS DIMacroInfo)
-> ReadS [DIMacroInfo]
-> ReadPrec DIMacroInfo
-> ReadPrec [DIMacroInfo]
-> Read DIMacroInfo
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DIMacroInfo]
$creadListPrec :: ReadPrec [DIMacroInfo]
readPrec :: ReadPrec DIMacroInfo
$creadPrec :: ReadPrec DIMacroInfo
readList :: ReadS [DIMacroInfo]
$creadList :: ReadS [DIMacroInfo]
readsPrec :: Int -> ReadS DIMacroInfo
$creadsPrec :: Int -> ReadS DIMacroInfo
Read, Int -> DIMacroInfo -> ShowS
[DIMacroInfo] -> ShowS
DIMacroInfo -> String
(Int -> DIMacroInfo -> ShowS)
-> (DIMacroInfo -> String)
-> ([DIMacroInfo] -> ShowS)
-> Show DIMacroInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DIMacroInfo] -> ShowS
$cshowList :: [DIMacroInfo] -> ShowS
show :: DIMacroInfo -> String
$cshow :: DIMacroInfo -> String
showsPrec :: Int -> DIMacroInfo -> ShowS
$cshowsPrec :: Int -> DIMacroInfo -> ShowS
Show, Typeable, Typeable DIMacroInfo
DataType
Constr
Typeable DIMacroInfo =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIMacroInfo -> c DIMacroInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIMacroInfo)
-> (DIMacroInfo -> Constr)
-> (DIMacroInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIMacroInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIMacroInfo))
-> ((forall b. Data b => b -> b) -> DIMacroInfo -> DIMacroInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIMacroInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIMacroInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIMacroInfo -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIMacroInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo)
-> Data DIMacroInfo
DIMacroInfo -> DataType
DIMacroInfo -> Constr
(forall b. Data b => b -> b) -> DIMacroInfo -> DIMacroInfo
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIMacroInfo -> c DIMacroInfo
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIMacroInfo
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DIMacroInfo -> u
forall u. (forall d. Data d => d -> u) -> DIMacroInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIMacroInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIMacroInfo -> c DIMacroInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIMacroInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIMacroInfo)
$cUndef :: Constr
$cDefine :: Constr
$tDIMacroInfo :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo
gmapMp :: (forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo
gmapM :: (forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo
gmapQi :: Int -> (forall d. Data d => d -> u) -> DIMacroInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIMacroInfo -> u
gmapQ :: (forall d. Data d => d -> u) -> DIMacroInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIMacroInfo -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroInfo -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroInfo -> r
gmapT :: (forall b. Data b => b -> b) -> DIMacroInfo -> DIMacroInfo
$cgmapT :: (forall b. Data b => b -> b) -> DIMacroInfo -> DIMacroInfo
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIMacroInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIMacroInfo)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DIMacroInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIMacroInfo)
dataTypeOf :: DIMacroInfo -> DataType
$cdataTypeOf :: DIMacroInfo -> DataType
toConstr :: DIMacroInfo -> Constr
$ctoConstr :: DIMacroInfo -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIMacroInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIMacroInfo
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIMacroInfo -> c DIMacroInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIMacroInfo -> c DIMacroInfo
$cp1Data :: Typeable DIMacroInfo
Data, (forall x. DIMacroInfo -> Rep DIMacroInfo x)
-> (forall x. Rep DIMacroInfo x -> DIMacroInfo)
-> Generic DIMacroInfo
forall x. Rep DIMacroInfo x -> DIMacroInfo
forall x. DIMacroInfo -> Rep DIMacroInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DIMacroInfo x -> DIMacroInfo
$cfrom :: forall x. DIMacroInfo -> Rep DIMacroInfo x
Generic)

-- | <https://llvm.org/doxygen/classllvm_1_1DIMacroNode.html>
data DIMacroNode
  -- | <https://llvm.org/docs/LangRef.html#dimacro>
  = DIMacro
    { DIMacroNode -> DIMacroInfo
info :: DIMacroInfo
    , DIMacroNode -> Word32
line :: Word32
    , DIMacroNode -> ShortByteString
name :: ShortByteString
    , DIMacroNode -> ShortByteString
value :: ShortByteString
    }
  -- | <https://llvm.org/docs/LangRef.html#dimacrofile>
  | DIMacroFile
    { line :: Word32
    , DIMacroNode -> MDRef DIFile
file :: MDRef DIFile
    , DIMacroNode -> [MDRef DIMacroNode]
elements :: [MDRef DIMacroNode]
    }
  deriving (DIMacroNode -> DIMacroNode -> Bool
(DIMacroNode -> DIMacroNode -> Bool)
-> (DIMacroNode -> DIMacroNode -> Bool) -> Eq DIMacroNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIMacroNode -> DIMacroNode -> Bool
$c/= :: DIMacroNode -> DIMacroNode -> Bool
== :: DIMacroNode -> DIMacroNode -> Bool
$c== :: DIMacroNode -> DIMacroNode -> Bool
Eq, Eq DIMacroNode
Eq DIMacroNode =>
(DIMacroNode -> DIMacroNode -> Ordering)
-> (DIMacroNode -> DIMacroNode -> Bool)
-> (DIMacroNode -> DIMacroNode -> Bool)
-> (DIMacroNode -> DIMacroNode -> Bool)
-> (DIMacroNode -> DIMacroNode -> Bool)
-> (DIMacroNode -> DIMacroNode -> DIMacroNode)
-> (DIMacroNode -> DIMacroNode -> DIMacroNode)
-> Ord DIMacroNode
DIMacroNode -> DIMacroNode -> Bool
DIMacroNode -> DIMacroNode -> Ordering
DIMacroNode -> DIMacroNode -> DIMacroNode
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DIMacroNode -> DIMacroNode -> DIMacroNode
$cmin :: DIMacroNode -> DIMacroNode -> DIMacroNode
max :: DIMacroNode -> DIMacroNode -> DIMacroNode
$cmax :: DIMacroNode -> DIMacroNode -> DIMacroNode
>= :: DIMacroNode -> DIMacroNode -> Bool
$c>= :: DIMacroNode -> DIMacroNode -> Bool
> :: DIMacroNode -> DIMacroNode -> Bool
$c> :: DIMacroNode -> DIMacroNode -> Bool
<= :: DIMacroNode -> DIMacroNode -> Bool
$c<= :: DIMacroNode -> DIMacroNode -> Bool
< :: DIMacroNode -> DIMacroNode -> Bool
$c< :: DIMacroNode -> DIMacroNode -> Bool
compare :: DIMacroNode -> DIMacroNode -> Ordering
$ccompare :: DIMacroNode -> DIMacroNode -> Ordering
$cp1Ord :: Eq DIMacroNode
Ord, ReadPrec [DIMacroNode]
ReadPrec DIMacroNode
Int -> ReadS DIMacroNode
ReadS [DIMacroNode]
(Int -> ReadS DIMacroNode)
-> ReadS [DIMacroNode]
-> ReadPrec DIMacroNode
-> ReadPrec [DIMacroNode]
-> Read DIMacroNode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DIMacroNode]
$creadListPrec :: ReadPrec [DIMacroNode]
readPrec :: ReadPrec DIMacroNode
$creadPrec :: ReadPrec DIMacroNode
readList :: ReadS [DIMacroNode]
$creadList :: ReadS [DIMacroNode]
readsPrec :: Int -> ReadS DIMacroNode
$creadsPrec :: Int -> ReadS DIMacroNode
Read, Int -> DIMacroNode -> ShowS
[DIMacroNode] -> ShowS
DIMacroNode -> String
(Int -> DIMacroNode -> ShowS)
-> (DIMacroNode -> String)
-> ([DIMacroNode] -> ShowS)
-> Show DIMacroNode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DIMacroNode] -> ShowS
$cshowList :: [DIMacroNode] -> ShowS
show :: DIMacroNode -> String
$cshow :: DIMacroNode -> String
showsPrec :: Int -> DIMacroNode -> ShowS
$cshowsPrec :: Int -> DIMacroNode -> ShowS
Show, Typeable, Typeable DIMacroNode
DataType
Constr
Typeable DIMacroNode =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIMacroNode -> c DIMacroNode)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIMacroNode)
-> (DIMacroNode -> Constr)
-> (DIMacroNode -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIMacroNode))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIMacroNode))
-> ((forall b. Data b => b -> b) -> DIMacroNode -> DIMacroNode)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIMacroNode -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIMacroNode -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIMacroNode -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIMacroNode -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode)
-> Data DIMacroNode
DIMacroNode -> DataType
DIMacroNode -> Constr
(forall b. Data b => b -> b) -> DIMacroNode -> DIMacroNode
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIMacroNode -> c DIMacroNode
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIMacroNode
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DIMacroNode -> u
forall u. (forall d. Data d => d -> u) -> DIMacroNode -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroNode -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroNode -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIMacroNode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIMacroNode -> c DIMacroNode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIMacroNode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIMacroNode)
$cDIMacroFile :: Constr
$cDIMacro :: Constr
$tDIMacroNode :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode
gmapMp :: (forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode
gmapM :: (forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode
gmapQi :: Int -> (forall d. Data d => d -> u) -> DIMacroNode -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIMacroNode -> u
gmapQ :: (forall d. Data d => d -> u) -> DIMacroNode -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIMacroNode -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroNode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroNode -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroNode -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroNode -> r
gmapT :: (forall b. Data b => b -> b) -> DIMacroNode -> DIMacroNode
$cgmapT :: (forall b. Data b => b -> b) -> DIMacroNode -> DIMacroNode
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIMacroNode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIMacroNode)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DIMacroNode)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIMacroNode)
dataTypeOf :: DIMacroNode -> DataType
$cdataTypeOf :: DIMacroNode -> DataType
toConstr :: DIMacroNode -> Constr
$ctoConstr :: DIMacroNode -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIMacroNode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIMacroNode
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIMacroNode -> c DIMacroNode
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIMacroNode -> c DIMacroNode
$cp1Data :: Typeable DIMacroNode
Data, (forall x. DIMacroNode -> Rep DIMacroNode x)
-> (forall x. Rep DIMacroNode x -> DIMacroNode)
-> Generic DIMacroNode
forall x. Rep DIMacroNode x -> DIMacroNode
forall x. DIMacroNode -> Rep DIMacroNode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DIMacroNode x -> DIMacroNode
$cfrom :: forall x. DIMacroNode -> Rep DIMacroNode x
Generic)

-- | <https://llvm.org/doxygen/classllvm_1_1DINode.html>
data DINode
  = DIEnumerator DIEnumerator
  | DIImportedEntity DIImportedEntity
  | DIObjCProperty DIObjCProperty
  | DIScope DIScope
  | DISubrange DISubrange
  | DITemplateParameter DITemplateParameter
  | DIVariable DIVariable
  deriving (DINode -> DINode -> Bool
(DINode -> DINode -> Bool)
-> (DINode -> DINode -> Bool) -> Eq DINode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DINode -> DINode -> Bool
$c/= :: DINode -> DINode -> Bool
== :: DINode -> DINode -> Bool
$c== :: DINode -> DINode -> Bool
Eq, Eq DINode
Eq DINode =>
(DINode -> DINode -> Ordering)
-> (DINode -> DINode -> Bool)
-> (DINode -> DINode -> Bool)
-> (DINode -> DINode -> Bool)
-> (DINode -> DINode -> Bool)
-> (DINode -> DINode -> DINode)
-> (DINode -> DINode -> DINode)
-> Ord DINode
DINode -> DINode -> Bool
DINode -> DINode -> Ordering
DINode -> DINode -> DINode
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DINode -> DINode -> DINode
$cmin :: DINode -> DINode -> DINode
max :: DINode -> DINode -> DINode
$cmax :: DINode -> DINode -> DINode
>= :: DINode -> DINode -> Bool
$c>= :: DINode -> DINode -> Bool
> :: DINode -> DINode -> Bool
$c> :: DINode -> DINode -> Bool
<= :: DINode -> DINode -> Bool
$c<= :: DINode -> DINode -> Bool
< :: DINode -> DINode -> Bool
$c< :: DINode -> DINode -> Bool
compare :: DINode -> DINode -> Ordering
$ccompare :: DINode -> DINode -> Ordering
$cp1Ord :: Eq DINode
Ord, ReadPrec [DINode]
ReadPrec DINode
Int -> ReadS DINode
ReadS [DINode]
(Int -> ReadS DINode)
-> ReadS [DINode]
-> ReadPrec DINode
-> ReadPrec [DINode]
-> Read DINode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DINode]
$creadListPrec :: ReadPrec [DINode]
readPrec :: ReadPrec DINode
$creadPrec :: ReadPrec DINode
readList :: ReadS [DINode]
$creadList :: ReadS [DINode]
readsPrec :: Int -> ReadS DINode
$creadsPrec :: Int -> ReadS DINode
Read, Int -> DINode -> ShowS
[DINode] -> ShowS
DINode -> String
(Int -> DINode -> ShowS)
-> (DINode -> String) -> ([DINode] -> ShowS) -> Show DINode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DINode] -> ShowS
$cshowList :: [DINode] -> ShowS
show :: DINode -> String
$cshow :: DINode -> String
showsPrec :: Int -> DINode -> ShowS
$cshowsPrec :: Int -> DINode -> ShowS
Show, Typeable, Typeable DINode
DataType
Constr
Typeable DINode =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DINode -> c DINode)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DINode)
-> (DINode -> Constr)
-> (DINode -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DINode))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DINode))
-> ((forall b. Data b => b -> b) -> DINode -> DINode)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DINode -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DINode -> r)
-> (forall u. (forall d. Data d => d -> u) -> DINode -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DINode -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DINode -> m DINode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DINode -> m DINode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DINode -> m DINode)
-> Data DINode
DINode -> DataType
DINode -> Constr
(forall b. Data b => b -> b) -> DINode -> DINode
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DINode -> c DINode
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DINode
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DINode -> u
forall u. (forall d. Data d => d -> u) -> DINode -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DINode -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DINode -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DINode -> m DINode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DINode -> m DINode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DINode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DINode -> c DINode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DINode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DINode)
$cDIVariable :: Constr
$cDITemplateParameter :: Constr
$cDISubrange :: Constr
$cDIScope :: Constr
$cDIObjCProperty :: Constr
$cDIImportedEntity :: Constr
$cDIEnumerator :: Constr
$tDINode :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DINode -> m DINode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DINode -> m DINode
gmapMp :: (forall d. Data d => d -> m d) -> DINode -> m DINode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DINode -> m DINode
gmapM :: (forall d. Data d => d -> m d) -> DINode -> m DINode
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DINode -> m DINode
gmapQi :: Int -> (forall d. Data d => d -> u) -> DINode -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DINode -> u
gmapQ :: (forall d. Data d => d -> u) -> DINode -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DINode -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DINode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DINode -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DINode -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DINode -> r
gmapT :: (forall b. Data b => b -> b) -> DINode -> DINode
$cgmapT :: (forall b. Data b => b -> b) -> DINode -> DINode
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DINode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DINode)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DINode)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DINode)
dataTypeOf :: DINode -> DataType
$cdataTypeOf :: DINode -> DataType
toConstr :: DINode -> Constr
$ctoConstr :: DINode -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DINode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DINode
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DINode -> c DINode
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DINode -> c DINode
$cp1Data :: Typeable DINode
Data, (forall x. DINode -> Rep DINode x)
-> (forall x. Rep DINode x -> DINode) -> Generic DINode
forall x. Rep DINode x -> DINode
forall x. DINode -> Rep DINode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DINode x -> DINode
$cfrom :: forall x. DINode -> Rep DINode x
Generic)

-- | <https://llvm.org/doxygen/classllvm_1_1DIObjCProperty.html>
data DIObjCProperty = ObjCProperty
  { DIObjCProperty -> ShortByteString
name :: ShortByteString
  , DIObjCProperty -> Maybe (MDRef DIFile)
file :: Maybe (MDRef DIFile)
  , DIObjCProperty -> Word32
line :: Word32
  , DIObjCProperty -> ShortByteString
getterName :: ShortByteString
  , DIObjCProperty -> ShortByteString
setterName :: ShortByteString
  , DIObjCProperty -> Word32
attributes :: Word32
  , DIObjCProperty -> Maybe (MDRef DIType)
type' :: Maybe (MDRef DIType)
  } deriving (DIObjCProperty -> DIObjCProperty -> Bool
(DIObjCProperty -> DIObjCProperty -> Bool)
-> (DIObjCProperty -> DIObjCProperty -> Bool) -> Eq DIObjCProperty
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIObjCProperty -> DIObjCProperty -> Bool
$c/= :: DIObjCProperty -> DIObjCProperty -> Bool
== :: DIObjCProperty -> DIObjCProperty -> Bool
$c== :: DIObjCProperty -> DIObjCProperty -> Bool
Eq, Eq DIObjCProperty
Eq DIObjCProperty =>
(DIObjCProperty -> DIObjCProperty -> Ordering)
-> (DIObjCProperty -> DIObjCProperty -> Bool)
-> (DIObjCProperty -> DIObjCProperty -> Bool)
-> (DIObjCProperty -> DIObjCProperty -> Bool)
-> (DIObjCProperty -> DIObjCProperty -> Bool)
-> (DIObjCProperty -> DIObjCProperty -> DIObjCProperty)
-> (DIObjCProperty -> DIObjCProperty -> DIObjCProperty)
-> Ord DIObjCProperty
DIObjCProperty -> DIObjCProperty -> Bool
DIObjCProperty -> DIObjCProperty -> Ordering
DIObjCProperty -> DIObjCProperty -> DIObjCProperty
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DIObjCProperty -> DIObjCProperty -> DIObjCProperty
$cmin :: DIObjCProperty -> DIObjCProperty -> DIObjCProperty
max :: DIObjCProperty -> DIObjCProperty -> DIObjCProperty
$cmax :: DIObjCProperty -> DIObjCProperty -> DIObjCProperty
>= :: DIObjCProperty -> DIObjCProperty -> Bool
$c>= :: DIObjCProperty -> DIObjCProperty -> Bool
> :: DIObjCProperty -> DIObjCProperty -> Bool
$c> :: DIObjCProperty -> DIObjCProperty -> Bool
<= :: DIObjCProperty -> DIObjCProperty -> Bool
$c<= :: DIObjCProperty -> DIObjCProperty -> Bool
< :: DIObjCProperty -> DIObjCProperty -> Bool
$c< :: DIObjCProperty -> DIObjCProperty -> Bool
compare :: DIObjCProperty -> DIObjCProperty -> Ordering
$ccompare :: DIObjCProperty -> DIObjCProperty -> Ordering
$cp1Ord :: Eq DIObjCProperty
Ord, ReadPrec [DIObjCProperty]
ReadPrec DIObjCProperty
Int -> ReadS DIObjCProperty
ReadS [DIObjCProperty]
(Int -> ReadS DIObjCProperty)
-> ReadS [DIObjCProperty]
-> ReadPrec DIObjCProperty
-> ReadPrec [DIObjCProperty]
-> Read DIObjCProperty
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DIObjCProperty]
$creadListPrec :: ReadPrec [DIObjCProperty]
readPrec :: ReadPrec DIObjCProperty
$creadPrec :: ReadPrec DIObjCProperty
readList :: ReadS [DIObjCProperty]
$creadList :: ReadS [DIObjCProperty]
readsPrec :: Int -> ReadS DIObjCProperty
$creadsPrec :: Int -> ReadS DIObjCProperty
Read, Int -> DIObjCProperty -> ShowS
[DIObjCProperty] -> ShowS
DIObjCProperty -> String
(Int -> DIObjCProperty -> ShowS)
-> (DIObjCProperty -> String)
-> ([DIObjCProperty] -> ShowS)
-> Show DIObjCProperty
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DIObjCProperty] -> ShowS
$cshowList :: [DIObjCProperty] -> ShowS
show :: DIObjCProperty -> String
$cshow :: DIObjCProperty -> String
showsPrec :: Int -> DIObjCProperty -> ShowS
$cshowsPrec :: Int -> DIObjCProperty -> ShowS
Show, Typeable, Typeable DIObjCProperty
DataType
Constr
Typeable DIObjCProperty =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIObjCProperty -> c DIObjCProperty)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIObjCProperty)
-> (DIObjCProperty -> Constr)
-> (DIObjCProperty -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIObjCProperty))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIObjCProperty))
-> ((forall b. Data b => b -> b)
    -> DIObjCProperty -> DIObjCProperty)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIObjCProperty -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIObjCProperty -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DIObjCProperty -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIObjCProperty -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DIObjCProperty -> m DIObjCProperty)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIObjCProperty -> m DIObjCProperty)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIObjCProperty -> m DIObjCProperty)
-> Data DIObjCProperty
DIObjCProperty -> DataType
DIObjCProperty -> Constr
(forall b. Data b => b -> b) -> DIObjCProperty -> DIObjCProperty
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIObjCProperty -> c DIObjCProperty
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIObjCProperty
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DIObjCProperty -> u
forall u. (forall d. Data d => d -> u) -> DIObjCProperty -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIObjCProperty -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIObjCProperty -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIObjCProperty -> m DIObjCProperty
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIObjCProperty -> m DIObjCProperty
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIObjCProperty
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIObjCProperty -> c DIObjCProperty
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIObjCProperty)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIObjCProperty)
$cObjCProperty :: Constr
$tDIObjCProperty :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> DIObjCProperty -> m DIObjCProperty
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIObjCProperty -> m DIObjCProperty
gmapMp :: (forall d. Data d => d -> m d)
-> DIObjCProperty -> m DIObjCProperty
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIObjCProperty -> m DIObjCProperty
gmapM :: (forall d. Data d => d -> m d)
-> DIObjCProperty -> m DIObjCProperty
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIObjCProperty -> m DIObjCProperty
gmapQi :: Int -> (forall d. Data d => d -> u) -> DIObjCProperty -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DIObjCProperty -> u
gmapQ :: (forall d. Data d => d -> u) -> DIObjCProperty -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIObjCProperty -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIObjCProperty -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIObjCProperty -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIObjCProperty -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIObjCProperty -> r
gmapT :: (forall b. Data b => b -> b) -> DIObjCProperty -> DIObjCProperty
$cgmapT :: (forall b. Data b => b -> b) -> DIObjCProperty -> DIObjCProperty
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIObjCProperty)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIObjCProperty)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DIObjCProperty)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIObjCProperty)
dataTypeOf :: DIObjCProperty -> DataType
$cdataTypeOf :: DIObjCProperty -> DataType
toConstr :: DIObjCProperty -> Constr
$ctoConstr :: DIObjCProperty -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIObjCProperty
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIObjCProperty
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIObjCProperty -> c DIObjCProperty
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIObjCProperty -> c DIObjCProperty
$cp1Data :: Typeable DIObjCProperty
Data, (forall x. DIObjCProperty -> Rep DIObjCProperty x)
-> (forall x. Rep DIObjCProperty x -> DIObjCProperty)
-> Generic DIObjCProperty
forall x. Rep DIObjCProperty x -> DIObjCProperty
forall x. DIObjCProperty -> Rep DIObjCProperty x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DIObjCProperty x -> DIObjCProperty
$cfrom :: forall x. DIObjCProperty -> Rep DIObjCProperty x
Generic)

data ImportedEntityTag = ImportedModule | ImportedDeclaration
  deriving (ImportedEntityTag -> ImportedEntityTag -> Bool
(ImportedEntityTag -> ImportedEntityTag -> Bool)
-> (ImportedEntityTag -> ImportedEntityTag -> Bool)
-> Eq ImportedEntityTag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ImportedEntityTag -> ImportedEntityTag -> Bool
$c/= :: ImportedEntityTag -> ImportedEntityTag -> Bool
== :: ImportedEntityTag -> ImportedEntityTag -> Bool
$c== :: ImportedEntityTag -> ImportedEntityTag -> Bool
Eq, Eq ImportedEntityTag
Eq ImportedEntityTag =>
(ImportedEntityTag -> ImportedEntityTag -> Ordering)
-> (ImportedEntityTag -> ImportedEntityTag -> Bool)
-> (ImportedEntityTag -> ImportedEntityTag -> Bool)
-> (ImportedEntityTag -> ImportedEntityTag -> Bool)
-> (ImportedEntityTag -> ImportedEntityTag -> Bool)
-> (ImportedEntityTag -> ImportedEntityTag -> ImportedEntityTag)
-> (ImportedEntityTag -> ImportedEntityTag -> ImportedEntityTag)
-> Ord ImportedEntityTag
ImportedEntityTag -> ImportedEntityTag -> Bool
ImportedEntityTag -> ImportedEntityTag -> Ordering
ImportedEntityTag -> ImportedEntityTag -> ImportedEntityTag
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ImportedEntityTag -> ImportedEntityTag -> ImportedEntityTag
$cmin :: ImportedEntityTag -> ImportedEntityTag -> ImportedEntityTag
max :: ImportedEntityTag -> ImportedEntityTag -> ImportedEntityTag
$cmax :: ImportedEntityTag -> ImportedEntityTag -> ImportedEntityTag
>= :: ImportedEntityTag -> ImportedEntityTag -> Bool
$c>= :: ImportedEntityTag -> ImportedEntityTag -> Bool
> :: ImportedEntityTag -> ImportedEntityTag -> Bool
$c> :: ImportedEntityTag -> ImportedEntityTag -> Bool
<= :: ImportedEntityTag -> ImportedEntityTag -> Bool
$c<= :: ImportedEntityTag -> ImportedEntityTag -> Bool
< :: ImportedEntityTag -> ImportedEntityTag -> Bool
$c< :: ImportedEntityTag -> ImportedEntityTag -> Bool
compare :: ImportedEntityTag -> ImportedEntityTag -> Ordering
$ccompare :: ImportedEntityTag -> ImportedEntityTag -> Ordering
$cp1Ord :: Eq ImportedEntityTag
Ord, ReadPrec [ImportedEntityTag]
ReadPrec ImportedEntityTag
Int -> ReadS ImportedEntityTag
ReadS [ImportedEntityTag]
(Int -> ReadS ImportedEntityTag)
-> ReadS [ImportedEntityTag]
-> ReadPrec ImportedEntityTag
-> ReadPrec [ImportedEntityTag]
-> Read ImportedEntityTag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ImportedEntityTag]
$creadListPrec :: ReadPrec [ImportedEntityTag]
readPrec :: ReadPrec ImportedEntityTag
$creadPrec :: ReadPrec ImportedEntityTag
readList :: ReadS [ImportedEntityTag]
$creadList :: ReadS [ImportedEntityTag]
readsPrec :: Int -> ReadS ImportedEntityTag
$creadsPrec :: Int -> ReadS ImportedEntityTag
Read, Int -> ImportedEntityTag -> ShowS
[ImportedEntityTag] -> ShowS
ImportedEntityTag -> String
(Int -> ImportedEntityTag -> ShowS)
-> (ImportedEntityTag -> String)
-> ([ImportedEntityTag] -> ShowS)
-> Show ImportedEntityTag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ImportedEntityTag] -> ShowS
$cshowList :: [ImportedEntityTag] -> ShowS
show :: ImportedEntityTag -> String
$cshow :: ImportedEntityTag -> String
showsPrec :: Int -> ImportedEntityTag -> ShowS
$cshowsPrec :: Int -> ImportedEntityTag -> ShowS
Show, Typeable, Typeable ImportedEntityTag
DataType
Constr
Typeable ImportedEntityTag =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> ImportedEntityTag
 -> c ImportedEntityTag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ImportedEntityTag)
-> (ImportedEntityTag -> Constr)
-> (ImportedEntityTag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ImportedEntityTag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ImportedEntityTag))
-> ((forall b. Data b => b -> b)
    -> ImportedEntityTag -> ImportedEntityTag)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportedEntityTag -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportedEntityTag -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ImportedEntityTag -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ImportedEntityTag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ImportedEntityTag -> m ImportedEntityTag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ImportedEntityTag -> m ImportedEntityTag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ImportedEntityTag -> m ImportedEntityTag)
-> Data ImportedEntityTag
ImportedEntityTag -> DataType
ImportedEntityTag -> Constr
(forall b. Data b => b -> b)
-> ImportedEntityTag -> ImportedEntityTag
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportedEntityTag -> c ImportedEntityTag
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImportedEntityTag
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> ImportedEntityTag -> u
forall u. (forall d. Data d => d -> u) -> ImportedEntityTag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportedEntityTag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportedEntityTag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ImportedEntityTag -> m ImportedEntityTag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ImportedEntityTag -> m ImportedEntityTag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImportedEntityTag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportedEntityTag -> c ImportedEntityTag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImportedEntityTag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImportedEntityTag)
$cImportedDeclaration :: Constr
$cImportedModule :: Constr
$tImportedEntityTag :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> ImportedEntityTag -> m ImportedEntityTag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ImportedEntityTag -> m ImportedEntityTag
gmapMp :: (forall d. Data d => d -> m d)
-> ImportedEntityTag -> m ImportedEntityTag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ImportedEntityTag -> m ImportedEntityTag
gmapM :: (forall d. Data d => d -> m d)
-> ImportedEntityTag -> m ImportedEntityTag
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ImportedEntityTag -> m ImportedEntityTag
gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportedEntityTag -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ImportedEntityTag -> u
gmapQ :: (forall d. Data d => d -> u) -> ImportedEntityTag -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ImportedEntityTag -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportedEntityTag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportedEntityTag -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportedEntityTag -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportedEntityTag -> r
gmapT :: (forall b. Data b => b -> b)
-> ImportedEntityTag -> ImportedEntityTag
$cgmapT :: (forall b. Data b => b -> b)
-> ImportedEntityTag -> ImportedEntityTag
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImportedEntityTag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImportedEntityTag)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ImportedEntityTag)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImportedEntityTag)
dataTypeOf :: ImportedEntityTag -> DataType
$cdataTypeOf :: ImportedEntityTag -> DataType
toConstr :: ImportedEntityTag -> Constr
$ctoConstr :: ImportedEntityTag -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImportedEntityTag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImportedEntityTag
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportedEntityTag -> c ImportedEntityTag
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportedEntityTag -> c ImportedEntityTag
$cp1Data :: Typeable ImportedEntityTag
Data, (forall x. ImportedEntityTag -> Rep ImportedEntityTag x)
-> (forall x. Rep ImportedEntityTag x -> ImportedEntityTag)
-> Generic ImportedEntityTag
forall x. Rep ImportedEntityTag x -> ImportedEntityTag
forall x. ImportedEntityTag -> Rep ImportedEntityTag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ImportedEntityTag x -> ImportedEntityTag
$cfrom :: forall x. ImportedEntityTag -> Rep ImportedEntityTag x
Generic)

-- | <https://llvm.org/doxygen/classllvm_1_1DIImportedEntity.html>
data DIImportedEntity = ImportedEntity
  { DIImportedEntity -> ImportedEntityTag
tag :: ImportedEntityTag
  , DIImportedEntity -> ShortByteString
name :: ShortByteString
  , DIImportedEntity -> MDRef DIScope
scope :: MDRef DIScope
  , DIImportedEntity -> Maybe (MDRef DINode)
entity :: Maybe (MDRef DINode)
  , DIImportedEntity -> Maybe (MDRef DIFile)
file :: Maybe (MDRef DIFile)
  , DIImportedEntity -> Word32
line :: Word32
  } deriving (DIImportedEntity -> DIImportedEntity -> Bool
(DIImportedEntity -> DIImportedEntity -> Bool)
-> (DIImportedEntity -> DIImportedEntity -> Bool)
-> Eq DIImportedEntity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIImportedEntity -> DIImportedEntity -> Bool
$c/= :: DIImportedEntity -> DIImportedEntity -> Bool
== :: DIImportedEntity -> DIImportedEntity -> Bool
$c== :: DIImportedEntity -> DIImportedEntity -> Bool
Eq, Eq DIImportedEntity
Eq DIImportedEntity =>
(DIImportedEntity -> DIImportedEntity -> Ordering)
-> (DIImportedEntity -> DIImportedEntity -> Bool)
-> (DIImportedEntity -> DIImportedEntity -> Bool)
-> (DIImportedEntity -> DIImportedEntity -> Bool)
-> (DIImportedEntity -> DIImportedEntity -> Bool)
-> (DIImportedEntity -> DIImportedEntity -> DIImportedEntity)
-> (DIImportedEntity -> DIImportedEntity -> DIImportedEntity)
-> Ord DIImportedEntity
DIImportedEntity -> DIImportedEntity -> Bool
DIImportedEntity -> DIImportedEntity -> Ordering
DIImportedEntity -> DIImportedEntity -> DIImportedEntity
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DIImportedEntity -> DIImportedEntity -> DIImportedEntity
$cmin :: DIImportedEntity -> DIImportedEntity -> DIImportedEntity
max :: DIImportedEntity -> DIImportedEntity -> DIImportedEntity
$cmax :: DIImportedEntity -> DIImportedEntity -> DIImportedEntity
>= :: DIImportedEntity -> DIImportedEntity -> Bool
$c>= :: DIImportedEntity -> DIImportedEntity -> Bool
> :: DIImportedEntity -> DIImportedEntity -> Bool
$c> :: DIImportedEntity -> DIImportedEntity -> Bool
<= :: DIImportedEntity -> DIImportedEntity -> Bool
$c<= :: DIImportedEntity -> DIImportedEntity -> Bool
< :: DIImportedEntity -> DIImportedEntity -> Bool
$c< :: DIImportedEntity -> DIImportedEntity -> Bool
compare :: DIImportedEntity -> DIImportedEntity -> Ordering
$ccompare :: DIImportedEntity -> DIImportedEntity -> Ordering
$cp1Ord :: Eq DIImportedEntity
Ord, ReadPrec [DIImportedEntity]
ReadPrec DIImportedEntity
Int -> ReadS DIImportedEntity
ReadS [DIImportedEntity]
(Int -> ReadS DIImportedEntity)
-> ReadS [DIImportedEntity]
-> ReadPrec DIImportedEntity
-> ReadPrec [DIImportedEntity]
-> Read DIImportedEntity
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DIImportedEntity]
$creadListPrec :: ReadPrec [DIImportedEntity]
readPrec :: ReadPrec DIImportedEntity
$creadPrec :: ReadPrec DIImportedEntity
readList :: ReadS [DIImportedEntity]
$creadList :: ReadS [DIImportedEntity]
readsPrec :: Int -> ReadS DIImportedEntity
$creadsPrec :: Int -> ReadS DIImportedEntity
Read, Int -> DIImportedEntity -> ShowS
[DIImportedEntity] -> ShowS
DIImportedEntity -> String
(Int -> DIImportedEntity -> ShowS)
-> (DIImportedEntity -> String)
-> ([DIImportedEntity] -> ShowS)
-> Show DIImportedEntity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DIImportedEntity] -> ShowS
$cshowList :: [DIImportedEntity] -> ShowS
show :: DIImportedEntity -> String
$cshow :: DIImportedEntity -> String
showsPrec :: Int -> DIImportedEntity -> ShowS
$cshowsPrec :: Int -> DIImportedEntity -> ShowS
Show, Typeable, Typeable DIImportedEntity
DataType
Constr
Typeable DIImportedEntity =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIImportedEntity -> c DIImportedEntity)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIImportedEntity)
-> (DIImportedEntity -> Constr)
-> (DIImportedEntity -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIImportedEntity))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIImportedEntity))
-> ((forall b. Data b => b -> b)
    -> DIImportedEntity -> DIImportedEntity)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIImportedEntity -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIImportedEntity -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DIImportedEntity -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIImportedEntity -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DIImportedEntity -> m DIImportedEntity)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIImportedEntity -> m DIImportedEntity)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIImportedEntity -> m DIImportedEntity)
-> Data DIImportedEntity
DIImportedEntity -> DataType
DIImportedEntity -> Constr
(forall b. Data b => b -> b)
-> DIImportedEntity -> DIImportedEntity
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIImportedEntity -> c DIImportedEntity
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIImportedEntity
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DIImportedEntity -> u
forall u. (forall d. Data d => d -> u) -> DIImportedEntity -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIImportedEntity -> m DIImportedEntity
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIImportedEntity -> m DIImportedEntity
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIImportedEntity
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIImportedEntity -> c DIImportedEntity
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIImportedEntity)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIImportedEntity)
$cImportedEntity :: Constr
$tDIImportedEntity :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> DIImportedEntity -> m DIImportedEntity
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIImportedEntity -> m DIImportedEntity
gmapMp :: (forall d. Data d => d -> m d)
-> DIImportedEntity -> m DIImportedEntity
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIImportedEntity -> m DIImportedEntity
gmapM :: (forall d. Data d => d -> m d)
-> DIImportedEntity -> m DIImportedEntity
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIImportedEntity -> m DIImportedEntity
gmapQi :: Int -> (forall d. Data d => d -> u) -> DIImportedEntity -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DIImportedEntity -> u
gmapQ :: (forall d. Data d => d -> u) -> DIImportedEntity -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIImportedEntity -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity -> r
gmapT :: (forall b. Data b => b -> b)
-> DIImportedEntity -> DIImportedEntity
$cgmapT :: (forall b. Data b => b -> b)
-> DIImportedEntity -> DIImportedEntity
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIImportedEntity)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIImportedEntity)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DIImportedEntity)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIImportedEntity)
dataTypeOf :: DIImportedEntity -> DataType
$cdataTypeOf :: DIImportedEntity -> DataType
toConstr :: DIImportedEntity -> Constr
$ctoConstr :: DIImportedEntity -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIImportedEntity
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIImportedEntity
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIImportedEntity -> c DIImportedEntity
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIImportedEntity -> c DIImportedEntity
$cp1Data :: Typeable DIImportedEntity
Data, (forall x. DIImportedEntity -> Rep DIImportedEntity x)
-> (forall x. Rep DIImportedEntity x -> DIImportedEntity)
-> Generic DIImportedEntity
forall x. Rep DIImportedEntity x -> DIImportedEntity
forall x. DIImportedEntity -> Rep DIImportedEntity x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DIImportedEntity x -> DIImportedEntity
$cfrom :: forall x. DIImportedEntity -> Rep DIImportedEntity x
Generic)

-- | <https://llvm.org/docs/LangRef.html#dienumerator>
data DIEnumerator =
  Enumerator { DIEnumerator -> Int64
value :: Int64, DIEnumerator -> Bool
isUnsigned :: Bool, DIEnumerator -> ShortByteString
name :: ShortByteString }
  deriving (DIEnumerator -> DIEnumerator -> Bool
(DIEnumerator -> DIEnumerator -> Bool)
-> (DIEnumerator -> DIEnumerator -> Bool) -> Eq DIEnumerator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIEnumerator -> DIEnumerator -> Bool
$c/= :: DIEnumerator -> DIEnumerator -> Bool
== :: DIEnumerator -> DIEnumerator -> Bool
$c== :: DIEnumerator -> DIEnumerator -> Bool
Eq, Eq DIEnumerator
Eq DIEnumerator =>
(DIEnumerator -> DIEnumerator -> Ordering)
-> (DIEnumerator -> DIEnumerator -> Bool)
-> (DIEnumerator -> DIEnumerator -> Bool)
-> (DIEnumerator -> DIEnumerator -> Bool)
-> (DIEnumerator -> DIEnumerator -> Bool)
-> (DIEnumerator -> DIEnumerator -> DIEnumerator)
-> (DIEnumerator -> DIEnumerator -> DIEnumerator)
-> Ord DIEnumerator
DIEnumerator -> DIEnumerator -> Bool
DIEnumerator -> DIEnumerator -> Ordering
DIEnumerator -> DIEnumerator -> DIEnumerator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DIEnumerator -> DIEnumerator -> DIEnumerator
$cmin :: DIEnumerator -> DIEnumerator -> DIEnumerator
max :: DIEnumerator -> DIEnumerator -> DIEnumerator
$cmax :: DIEnumerator -> DIEnumerator -> DIEnumerator
>= :: DIEnumerator -> DIEnumerator -> Bool
$c>= :: DIEnumerator -> DIEnumerator -> Bool
> :: DIEnumerator -> DIEnumerator -> Bool
$c> :: DIEnumerator -> DIEnumerator -> Bool
<= :: DIEnumerator -> DIEnumerator -> Bool
$c<= :: DIEnumerator -> DIEnumerator -> Bool
< :: DIEnumerator -> DIEnumerator -> Bool
$c< :: DIEnumerator -> DIEnumerator -> Bool
compare :: DIEnumerator -> DIEnumerator -> Ordering
$ccompare :: DIEnumerator -> DIEnumerator -> Ordering
$cp1Ord :: Eq DIEnumerator
Ord, ReadPrec [DIEnumerator]
ReadPrec DIEnumerator
Int -> ReadS DIEnumerator
ReadS [DIEnumerator]
(Int -> ReadS DIEnumerator)
-> ReadS [DIEnumerator]
-> ReadPrec DIEnumerator
-> ReadPrec [DIEnumerator]
-> Read DIEnumerator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DIEnumerator]
$creadListPrec :: ReadPrec [DIEnumerator]
readPrec :: ReadPrec DIEnumerator
$creadPrec :: ReadPrec DIEnumerator
readList :: ReadS [DIEnumerator]
$creadList :: ReadS [DIEnumerator]
readsPrec :: Int -> ReadS DIEnumerator
$creadsPrec :: Int -> ReadS DIEnumerator
Read, Int -> DIEnumerator -> ShowS
[DIEnumerator] -> ShowS
DIEnumerator -> String
(Int -> DIEnumerator -> ShowS)
-> (DIEnumerator -> String)
-> ([DIEnumerator] -> ShowS)
-> Show DIEnumerator
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DIEnumerator] -> ShowS
$cshowList :: [DIEnumerator] -> ShowS
show :: DIEnumerator -> String
$cshow :: DIEnumerator -> String
showsPrec :: Int -> DIEnumerator -> ShowS
$cshowsPrec :: Int -> DIEnumerator -> ShowS
Show, Typeable, Typeable DIEnumerator
DataType
Constr
Typeable DIEnumerator =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIEnumerator -> c DIEnumerator)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIEnumerator)
-> (DIEnumerator -> Constr)
-> (DIEnumerator -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIEnumerator))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIEnumerator))
-> ((forall b. Data b => b -> b) -> DIEnumerator -> DIEnumerator)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIEnumerator -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIEnumerator -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIEnumerator -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIEnumerator -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator)
-> Data DIEnumerator
DIEnumerator -> DataType
DIEnumerator -> Constr
(forall b. Data b => b -> b) -> DIEnumerator -> DIEnumerator
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIEnumerator -> c DIEnumerator
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIEnumerator
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DIEnumerator -> u
forall u. (forall d. Data d => d -> u) -> DIEnumerator -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIEnumerator -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIEnumerator -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIEnumerator
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIEnumerator -> c DIEnumerator
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIEnumerator)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIEnumerator)
$cEnumerator :: Constr
$tDIEnumerator :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator
gmapMp :: (forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator
gmapM :: (forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator
gmapQi :: Int -> (forall d. Data d => d -> u) -> DIEnumerator -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIEnumerator -> u
gmapQ :: (forall d. Data d => d -> u) -> DIEnumerator -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIEnumerator -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIEnumerator -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIEnumerator -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIEnumerator -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIEnumerator -> r
gmapT :: (forall b. Data b => b -> b) -> DIEnumerator -> DIEnumerator
$cgmapT :: (forall b. Data b => b -> b) -> DIEnumerator -> DIEnumerator
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIEnumerator)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIEnumerator)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DIEnumerator)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIEnumerator)
dataTypeOf :: DIEnumerator -> DataType
$cdataTypeOf :: DIEnumerator -> DataType
toConstr :: DIEnumerator -> Constr
$ctoConstr :: DIEnumerator -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIEnumerator
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIEnumerator
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIEnumerator -> c DIEnumerator
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIEnumerator -> c DIEnumerator
$cp1Data :: Typeable DIEnumerator
Data, (forall x. DIEnumerator -> Rep DIEnumerator x)
-> (forall x. Rep DIEnumerator x -> DIEnumerator)
-> Generic DIEnumerator
forall x. Rep DIEnumerator x -> DIEnumerator
forall x. DIEnumerator -> Rep DIEnumerator x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DIEnumerator x -> DIEnumerator
$cfrom :: forall x. DIEnumerator -> Rep DIEnumerator x
Generic)

-- | <https://llvm.org/docs/LangRef.html#disubrange>
data DISubrange =
  Subrange { DISubrange -> DICount
count :: DICount, DISubrange -> Int64
lowerBound :: Int64 }
  deriving (DISubrange -> DISubrange -> Bool
(DISubrange -> DISubrange -> Bool)
-> (DISubrange -> DISubrange -> Bool) -> Eq DISubrange
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DISubrange -> DISubrange -> Bool
$c/= :: DISubrange -> DISubrange -> Bool
== :: DISubrange -> DISubrange -> Bool
$c== :: DISubrange -> DISubrange -> Bool
Eq, Eq DISubrange
Eq DISubrange =>
(DISubrange -> DISubrange -> Ordering)
-> (DISubrange -> DISubrange -> Bool)
-> (DISubrange -> DISubrange -> Bool)
-> (DISubrange -> DISubrange -> Bool)
-> (DISubrange -> DISubrange -> Bool)
-> (DISubrange -> DISubrange -> DISubrange)
-> (DISubrange -> DISubrange -> DISubrange)
-> Ord DISubrange
DISubrange -> DISubrange -> Bool
DISubrange -> DISubrange -> Ordering
DISubrange -> DISubrange -> DISubrange
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DISubrange -> DISubrange -> DISubrange
$cmin :: DISubrange -> DISubrange -> DISubrange
max :: DISubrange -> DISubrange -> DISubrange
$cmax :: DISubrange -> DISubrange -> DISubrange
>= :: DISubrange -> DISubrange -> Bool
$c>= :: DISubrange -> DISubrange -> Bool
> :: DISubrange -> DISubrange -> Bool
$c> :: DISubrange -> DISubrange -> Bool
<= :: DISubrange -> DISubrange -> Bool
$c<= :: DISubrange -> DISubrange -> Bool
< :: DISubrange -> DISubrange -> Bool
$c< :: DISubrange -> DISubrange -> Bool
compare :: DISubrange -> DISubrange -> Ordering
$ccompare :: DISubrange -> DISubrange -> Ordering
$cp1Ord :: Eq DISubrange
Ord, ReadPrec [DISubrange]
ReadPrec DISubrange
Int -> ReadS DISubrange
ReadS [DISubrange]
(Int -> ReadS DISubrange)
-> ReadS [DISubrange]
-> ReadPrec DISubrange
-> ReadPrec [DISubrange]
-> Read DISubrange
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DISubrange]
$creadListPrec :: ReadPrec [DISubrange]
readPrec :: ReadPrec DISubrange
$creadPrec :: ReadPrec DISubrange
readList :: ReadS [DISubrange]
$creadList :: ReadS [DISubrange]
readsPrec :: Int -> ReadS DISubrange
$creadsPrec :: Int -> ReadS DISubrange
Read, Int -> DISubrange -> ShowS
[DISubrange] -> ShowS
DISubrange -> String
(Int -> DISubrange -> ShowS)
-> (DISubrange -> String)
-> ([DISubrange] -> ShowS)
-> Show DISubrange
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DISubrange] -> ShowS
$cshowList :: [DISubrange] -> ShowS
show :: DISubrange -> String
$cshow :: DISubrange -> String
showsPrec :: Int -> DISubrange -> ShowS
$cshowsPrec :: Int -> DISubrange -> ShowS
Show, Typeable, Typeable DISubrange
DataType
Constr
Typeable DISubrange =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DISubrange -> c DISubrange)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DISubrange)
-> (DISubrange -> Constr)
-> (DISubrange -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DISubrange))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DISubrange))
-> ((forall b. Data b => b -> b) -> DISubrange -> DISubrange)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DISubrange -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DISubrange -> r)
-> (forall u. (forall d. Data d => d -> u) -> DISubrange -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DISubrange -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DISubrange -> m DISubrange)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DISubrange -> m DISubrange)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DISubrange -> m DISubrange)
-> Data DISubrange
DISubrange -> DataType
DISubrange -> Constr
(forall b. Data b => b -> b) -> DISubrange -> DISubrange
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubrange -> c DISubrange
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubrange
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DISubrange -> u
forall u. (forall d. Data d => d -> u) -> DISubrange -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DISubrange -> m DISubrange
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DISubrange -> m DISubrange
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubrange
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubrange -> c DISubrange
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DISubrange)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DISubrange)
$cSubrange :: Constr
$tDISubrange :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DISubrange -> m DISubrange
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DISubrange -> m DISubrange
gmapMp :: (forall d. Data d => d -> m d) -> DISubrange -> m DISubrange
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DISubrange -> m DISubrange
gmapM :: (forall d. Data d => d -> m d) -> DISubrange -> m DISubrange
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DISubrange -> m DISubrange
gmapQi :: Int -> (forall d. Data d => d -> u) -> DISubrange -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DISubrange -> u
gmapQ :: (forall d. Data d => d -> u) -> DISubrange -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DISubrange -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange -> r
gmapT :: (forall b. Data b => b -> b) -> DISubrange -> DISubrange
$cgmapT :: (forall b. Data b => b -> b) -> DISubrange -> DISubrange
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DISubrange)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DISubrange)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DISubrange)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DISubrange)
dataTypeOf :: DISubrange -> DataType
$cdataTypeOf :: DISubrange -> DataType
toConstr :: DISubrange -> Constr
$ctoConstr :: DISubrange -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubrange
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubrange
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubrange -> c DISubrange
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubrange -> c DISubrange
$cp1Data :: Typeable DISubrange
Data, (forall x. DISubrange -> Rep DISubrange x)
-> (forall x. Rep DISubrange x -> DISubrange) -> Generic DISubrange
forall x. Rep DISubrange x -> DISubrange
forall x. DISubrange -> Rep DISubrange x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DISubrange x -> DISubrange
$cfrom :: forall x. DISubrange -> Rep DISubrange x
Generic)

data DICount
  = DICountConstant Int64
  | DICountVariable (MDRef DIVariable)
  deriving (DICount -> DICount -> Bool
(DICount -> DICount -> Bool)
-> (DICount -> DICount -> Bool) -> Eq DICount
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DICount -> DICount -> Bool
$c/= :: DICount -> DICount -> Bool
== :: DICount -> DICount -> Bool
$c== :: DICount -> DICount -> Bool
Eq, Eq DICount
Eq DICount =>
(DICount -> DICount -> Ordering)
-> (DICount -> DICount -> Bool)
-> (DICount -> DICount -> Bool)
-> (DICount -> DICount -> Bool)
-> (DICount -> DICount -> Bool)
-> (DICount -> DICount -> DICount)
-> (DICount -> DICount -> DICount)
-> Ord DICount
DICount -> DICount -> Bool
DICount -> DICount -> Ordering
DICount -> DICount -> DICount
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DICount -> DICount -> DICount
$cmin :: DICount -> DICount -> DICount
max :: DICount -> DICount -> DICount
$cmax :: DICount -> DICount -> DICount
>= :: DICount -> DICount -> Bool
$c>= :: DICount -> DICount -> Bool
> :: DICount -> DICount -> Bool
$c> :: DICount -> DICount -> Bool
<= :: DICount -> DICount -> Bool
$c<= :: DICount -> DICount -> Bool
< :: DICount -> DICount -> Bool
$c< :: DICount -> DICount -> Bool
compare :: DICount -> DICount -> Ordering
$ccompare :: DICount -> DICount -> Ordering
$cp1Ord :: Eq DICount
Ord, ReadPrec [DICount]
ReadPrec DICount
Int -> ReadS DICount
ReadS [DICount]
(Int -> ReadS DICount)
-> ReadS [DICount]
-> ReadPrec DICount
-> ReadPrec [DICount]
-> Read DICount
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DICount]
$creadListPrec :: ReadPrec [DICount]
readPrec :: ReadPrec DICount
$creadPrec :: ReadPrec DICount
readList :: ReadS [DICount]
$creadList :: ReadS [DICount]
readsPrec :: Int -> ReadS DICount
$creadsPrec :: Int -> ReadS DICount
Read, Int -> DICount -> ShowS
[DICount] -> ShowS
DICount -> String
(Int -> DICount -> ShowS)
-> (DICount -> String) -> ([DICount] -> ShowS) -> Show DICount
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DICount] -> ShowS
$cshowList :: [DICount] -> ShowS
show :: DICount -> String
$cshow :: DICount -> String
showsPrec :: Int -> DICount -> ShowS
$cshowsPrec :: Int -> DICount -> ShowS
Show, Typeable, Typeable DICount
DataType
Constr
Typeable DICount =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DICount -> c DICount)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DICount)
-> (DICount -> Constr)
-> (DICount -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DICount))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DICount))
-> ((forall b. Data b => b -> b) -> DICount -> DICount)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DICount -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DICount -> r)
-> (forall u. (forall d. Data d => d -> u) -> DICount -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DICount -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DICount -> m DICount)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DICount -> m DICount)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DICount -> m DICount)
-> Data DICount
DICount -> DataType
DICount -> Constr
(forall b. Data b => b -> b) -> DICount -> DICount
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICount -> c DICount
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICount
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DICount -> u
forall u. (forall d. Data d => d -> u) -> DICount -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICount -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICount -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DICount -> m DICount
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DICount -> m DICount
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICount
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICount -> c DICount
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DICount)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DICount)
$cDICountVariable :: Constr
$cDICountConstant :: Constr
$tDICount :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DICount -> m DICount
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DICount -> m DICount
gmapMp :: (forall d. Data d => d -> m d) -> DICount -> m DICount
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DICount -> m DICount
gmapM :: (forall d. Data d => d -> m d) -> DICount -> m DICount
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DICount -> m DICount
gmapQi :: Int -> (forall d. Data d => d -> u) -> DICount -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DICount -> u
gmapQ :: (forall d. Data d => d -> u) -> DICount -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DICount -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICount -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICount -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICount -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICount -> r
gmapT :: (forall b. Data b => b -> b) -> DICount -> DICount
$cgmapT :: (forall b. Data b => b -> b) -> DICount -> DICount
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DICount)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DICount)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DICount)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DICount)
dataTypeOf :: DICount -> DataType
$cdataTypeOf :: DICount -> DataType
toConstr :: DICount -> Constr
$ctoConstr :: DICount -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICount
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICount
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICount -> c DICount
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICount -> c DICount
$cp1Data :: Typeable DICount
Data, (forall x. DICount -> Rep DICount x)
-> (forall x. Rep DICount x -> DICount) -> Generic DICount
forall x. Rep DICount x -> DICount
forall x. DICount -> Rep DICount x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DICount x -> DICount
$cfrom :: forall x. DICount -> Rep DICount x
Generic)

-- | <https://llvm.org/doxygen/classllvm_1_1DIScope.html>
data DIScope
  = DICompileUnit DICompileUnit
  | DIFile DIFile
  | DILocalScope DILocalScope
  | DIModule DIModule
  | DINamespace DINamespace
  | DIType DIType
  deriving (DIScope -> DIScope -> Bool
(DIScope -> DIScope -> Bool)
-> (DIScope -> DIScope -> Bool) -> Eq DIScope
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIScope -> DIScope -> Bool
$c/= :: DIScope -> DIScope -> Bool
== :: DIScope -> DIScope -> Bool
$c== :: DIScope -> DIScope -> Bool
Eq, Eq DIScope
Eq DIScope =>
(DIScope -> DIScope -> Ordering)
-> (DIScope -> DIScope -> Bool)
-> (DIScope -> DIScope -> Bool)
-> (DIScope -> DIScope -> Bool)
-> (DIScope -> DIScope -> Bool)
-> (DIScope -> DIScope -> DIScope)
-> (DIScope -> DIScope -> DIScope)
-> Ord DIScope
DIScope -> DIScope -> Bool
DIScope -> DIScope -> Ordering
DIScope -> DIScope -> DIScope
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DIScope -> DIScope -> DIScope
$cmin :: DIScope -> DIScope -> DIScope
max :: DIScope -> DIScope -> DIScope
$cmax :: DIScope -> DIScope -> DIScope
>= :: DIScope -> DIScope -> Bool
$c>= :: DIScope -> DIScope -> Bool
> :: DIScope -> DIScope -> Bool
$c> :: DIScope -> DIScope -> Bool
<= :: DIScope -> DIScope -> Bool
$c<= :: DIScope -> DIScope -> Bool
< :: DIScope -> DIScope -> Bool
$c< :: DIScope -> DIScope -> Bool
compare :: DIScope -> DIScope -> Ordering
$ccompare :: DIScope -> DIScope -> Ordering
$cp1Ord :: Eq DIScope
Ord, ReadPrec [DIScope]
ReadPrec DIScope
Int -> ReadS DIScope
ReadS [DIScope]
(Int -> ReadS DIScope)
-> ReadS [DIScope]
-> ReadPrec DIScope
-> ReadPrec [DIScope]
-> Read DIScope
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DIScope]
$creadListPrec :: ReadPrec [DIScope]
readPrec :: ReadPrec DIScope
$creadPrec :: ReadPrec DIScope
readList :: ReadS [DIScope]
$creadList :: ReadS [DIScope]
readsPrec :: Int -> ReadS DIScope
$creadsPrec :: Int -> ReadS DIScope
Read, Int -> DIScope -> ShowS
[DIScope] -> ShowS
DIScope -> String
(Int -> DIScope -> ShowS)
-> (DIScope -> String) -> ([DIScope] -> ShowS) -> Show DIScope
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DIScope] -> ShowS
$cshowList :: [DIScope] -> ShowS
show :: DIScope -> String
$cshow :: DIScope -> String
showsPrec :: Int -> DIScope -> ShowS
$cshowsPrec :: Int -> DIScope -> ShowS
Show, Typeable, Typeable DIScope
DataType
Constr
Typeable DIScope =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIScope -> c DIScope)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIScope)
-> (DIScope -> Constr)
-> (DIScope -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIScope))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIScope))
-> ((forall b. Data b => b -> b) -> DIScope -> DIScope)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIScope -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIScope -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIScope -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DIScope -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIScope -> m DIScope)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIScope -> m DIScope)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIScope -> m DIScope)
-> Data DIScope
DIScope -> DataType
DIScope -> Constr
(forall b. Data b => b -> b) -> DIScope -> DIScope
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIScope -> c DIScope
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIScope
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DIScope -> u
forall u. (forall d. Data d => d -> u) -> DIScope -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIScope -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIScope -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIScope -> m DIScope
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIScope -> m DIScope
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIScope
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIScope -> c DIScope
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIScope)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIScope)
$cDIType :: Constr
$cDINamespace :: Constr
$cDIModule :: Constr
$cDILocalScope :: Constr
$cDIFile :: Constr
$cDICompileUnit :: Constr
$tDIScope :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DIScope -> m DIScope
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIScope -> m DIScope
gmapMp :: (forall d. Data d => d -> m d) -> DIScope -> m DIScope
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIScope -> m DIScope
gmapM :: (forall d. Data d => d -> m d) -> DIScope -> m DIScope
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIScope -> m DIScope
gmapQi :: Int -> (forall d. Data d => d -> u) -> DIScope -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIScope -> u
gmapQ :: (forall d. Data d => d -> u) -> DIScope -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIScope -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIScope -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIScope -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIScope -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIScope -> r
gmapT :: (forall b. Data b => b -> b) -> DIScope -> DIScope
$cgmapT :: (forall b. Data b => b -> b) -> DIScope -> DIScope
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIScope)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIScope)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DIScope)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIScope)
dataTypeOf :: DIScope -> DataType
$cdataTypeOf :: DIScope -> DataType
toConstr :: DIScope -> Constr
$ctoConstr :: DIScope -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIScope
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIScope
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIScope -> c DIScope
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIScope -> c DIScope
$cp1Data :: Typeable DIScope
Data, (forall x. DIScope -> Rep DIScope x)
-> (forall x. Rep DIScope x -> DIScope) -> Generic DIScope
forall x. Rep DIScope x -> DIScope
forall x. DIScope -> Rep DIScope x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DIScope x -> DIScope
$cfrom :: forall x. DIScope -> Rep DIScope x
Generic)

data DIModule = Module
  { DIModule -> Maybe (MDRef DIScope)
scope :: Maybe (MDRef DIScope)
  , DIModule -> ShortByteString
name :: ShortByteString
  , DIModule -> ShortByteString
configurationMacros :: ShortByteString
  , DIModule -> ShortByteString
includePath :: ShortByteString
  , DIModule -> ShortByteString
isysRoot :: ShortByteString
  } deriving (DIModule -> DIModule -> Bool
(DIModule -> DIModule -> Bool)
-> (DIModule -> DIModule -> Bool) -> Eq DIModule
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIModule -> DIModule -> Bool
$c/= :: DIModule -> DIModule -> Bool
== :: DIModule -> DIModule -> Bool
$c== :: DIModule -> DIModule -> Bool
Eq, Eq DIModule
Eq DIModule =>
(DIModule -> DIModule -> Ordering)
-> (DIModule -> DIModule -> Bool)
-> (DIModule -> DIModule -> Bool)
-> (DIModule -> DIModule -> Bool)
-> (DIModule -> DIModule -> Bool)
-> (DIModule -> DIModule -> DIModule)
-> (DIModule -> DIModule -> DIModule)
-> Ord DIModule
DIModule -> DIModule -> Bool
DIModule -> DIModule -> Ordering
DIModule -> DIModule -> DIModule
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DIModule -> DIModule -> DIModule
$cmin :: DIModule -> DIModule -> DIModule
max :: DIModule -> DIModule -> DIModule
$cmax :: DIModule -> DIModule -> DIModule
>= :: DIModule -> DIModule -> Bool
$c>= :: DIModule -> DIModule -> Bool
> :: DIModule -> DIModule -> Bool
$c> :: DIModule -> DIModule -> Bool
<= :: DIModule -> DIModule -> Bool
$c<= :: DIModule -> DIModule -> Bool
< :: DIModule -> DIModule -> Bool
$c< :: DIModule -> DIModule -> Bool
compare :: DIModule -> DIModule -> Ordering
$ccompare :: DIModule -> DIModule -> Ordering
$cp1Ord :: Eq DIModule
Ord, ReadPrec [DIModule]
ReadPrec DIModule
Int -> ReadS DIModule
ReadS [DIModule]
(Int -> ReadS DIModule)
-> ReadS [DIModule]
-> ReadPrec DIModule
-> ReadPrec [DIModule]
-> Read DIModule
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DIModule]
$creadListPrec :: ReadPrec [DIModule]
readPrec :: ReadPrec DIModule
$creadPrec :: ReadPrec DIModule
readList :: ReadS [DIModule]
$creadList :: ReadS [DIModule]
readsPrec :: Int -> ReadS DIModule
$creadsPrec :: Int -> ReadS DIModule
Read, Int -> DIModule -> ShowS
[DIModule] -> ShowS
DIModule -> String
(Int -> DIModule -> ShowS)
-> (DIModule -> String) -> ([DIModule] -> ShowS) -> Show DIModule
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DIModule] -> ShowS
$cshowList :: [DIModule] -> ShowS
show :: DIModule -> String
$cshow :: DIModule -> String
showsPrec :: Int -> DIModule -> ShowS
$cshowsPrec :: Int -> DIModule -> ShowS
Show, Typeable, Typeable DIModule
DataType
Constr
Typeable DIModule =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIModule -> c DIModule)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIModule)
-> (DIModule -> Constr)
-> (DIModule -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIModule))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIModule))
-> ((forall b. Data b => b -> b) -> DIModule -> DIModule)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIModule -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIModule -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIModule -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DIModule -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIModule -> m DIModule)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIModule -> m DIModule)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIModule -> m DIModule)
-> Data DIModule
DIModule -> DataType
DIModule -> Constr
(forall b. Data b => b -> b) -> DIModule -> DIModule
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIModule -> c DIModule
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIModule
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DIModule -> u
forall u. (forall d. Data d => d -> u) -> DIModule -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIModule -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIModule -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIModule -> m DIModule
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIModule -> m DIModule
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIModule
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIModule -> c DIModule
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIModule)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIModule)
$cModule :: Constr
$tDIModule :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DIModule -> m DIModule
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIModule -> m DIModule
gmapMp :: (forall d. Data d => d -> m d) -> DIModule -> m DIModule
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIModule -> m DIModule
gmapM :: (forall d. Data d => d -> m d) -> DIModule -> m DIModule
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIModule -> m DIModule
gmapQi :: Int -> (forall d. Data d => d -> u) -> DIModule -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIModule -> u
gmapQ :: (forall d. Data d => d -> u) -> DIModule -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIModule -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIModule -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIModule -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIModule -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIModule -> r
gmapT :: (forall b. Data b => b -> b) -> DIModule -> DIModule
$cgmapT :: (forall b. Data b => b -> b) -> DIModule -> DIModule
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIModule)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIModule)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DIModule)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIModule)
dataTypeOf :: DIModule -> DataType
$cdataTypeOf :: DIModule -> DataType
toConstr :: DIModule -> Constr
$ctoConstr :: DIModule -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIModule
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIModule
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIModule -> c DIModule
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIModule -> c DIModule
$cp1Data :: Typeable DIModule
Data, (forall x. DIModule -> Rep DIModule x)
-> (forall x. Rep DIModule x -> DIModule) -> Generic DIModule
forall x. Rep DIModule x -> DIModule
forall x. DIModule -> Rep DIModule x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DIModule x -> DIModule
$cfrom :: forall x. DIModule -> Rep DIModule x
Generic)

data DINamespace = Namespace
  { DINamespace -> ShortByteString
name :: ShortByteString
  , DINamespace -> Maybe (MDRef DIScope)
scope :: Maybe (MDRef DIScope)
  , DINamespace -> Bool
exportSymbols :: Bool
  } deriving (DINamespace -> DINamespace -> Bool
(DINamespace -> DINamespace -> Bool)
-> (DINamespace -> DINamespace -> Bool) -> Eq DINamespace
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DINamespace -> DINamespace -> Bool
$c/= :: DINamespace -> DINamespace -> Bool
== :: DINamespace -> DINamespace -> Bool
$c== :: DINamespace -> DINamespace -> Bool
Eq, Eq DINamespace
Eq DINamespace =>
(DINamespace -> DINamespace -> Ordering)
-> (DINamespace -> DINamespace -> Bool)
-> (DINamespace -> DINamespace -> Bool)
-> (DINamespace -> DINamespace -> Bool)
-> (DINamespace -> DINamespace -> Bool)
-> (DINamespace -> DINamespace -> DINamespace)
-> (DINamespace -> DINamespace -> DINamespace)
-> Ord DINamespace
DINamespace -> DINamespace -> Bool
DINamespace -> DINamespace -> Ordering
DINamespace -> DINamespace -> DINamespace
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DINamespace -> DINamespace -> DINamespace
$cmin :: DINamespace -> DINamespace -> DINamespace
max :: DINamespace -> DINamespace -> DINamespace
$cmax :: DINamespace -> DINamespace -> DINamespace
>= :: DINamespace -> DINamespace -> Bool
$c>= :: DINamespace -> DINamespace -> Bool
> :: DINamespace -> DINamespace -> Bool
$c> :: DINamespace -> DINamespace -> Bool
<= :: DINamespace -> DINamespace -> Bool
$c<= :: DINamespace -> DINamespace -> Bool
< :: DINamespace -> DINamespace -> Bool
$c< :: DINamespace -> DINamespace -> Bool
compare :: DINamespace -> DINamespace -> Ordering
$ccompare :: DINamespace -> DINamespace -> Ordering
$cp1Ord :: Eq DINamespace
Ord, ReadPrec [DINamespace]
ReadPrec DINamespace
Int -> ReadS DINamespace
ReadS [DINamespace]
(Int -> ReadS DINamespace)
-> ReadS [DINamespace]
-> ReadPrec DINamespace
-> ReadPrec [DINamespace]
-> Read DINamespace
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DINamespace]
$creadListPrec :: ReadPrec [DINamespace]
readPrec :: ReadPrec DINamespace
$creadPrec :: ReadPrec DINamespace
readList :: ReadS [DINamespace]
$creadList :: ReadS [DINamespace]
readsPrec :: Int -> ReadS DINamespace
$creadsPrec :: Int -> ReadS DINamespace
Read, Int -> DINamespace -> ShowS
[DINamespace] -> ShowS
DINamespace -> String
(Int -> DINamespace -> ShowS)
-> (DINamespace -> String)
-> ([DINamespace] -> ShowS)
-> Show DINamespace
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DINamespace] -> ShowS
$cshowList :: [DINamespace] -> ShowS
show :: DINamespace -> String
$cshow :: DINamespace -> String
showsPrec :: Int -> DINamespace -> ShowS
$cshowsPrec :: Int -> DINamespace -> ShowS
Show, Typeable, Typeable DINamespace
DataType
Constr
Typeable DINamespace =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DINamespace -> c DINamespace)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DINamespace)
-> (DINamespace -> Constr)
-> (DINamespace -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DINamespace))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DINamespace))
-> ((forall b. Data b => b -> b) -> DINamespace -> DINamespace)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DINamespace -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DINamespace -> r)
-> (forall u. (forall d. Data d => d -> u) -> DINamespace -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DINamespace -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DINamespace -> m DINamespace)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DINamespace -> m DINamespace)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DINamespace -> m DINamespace)
-> Data DINamespace
DINamespace -> DataType
DINamespace -> Constr
(forall b. Data b => b -> b) -> DINamespace -> DINamespace
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DINamespace -> c DINamespace
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DINamespace
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DINamespace -> u
forall u. (forall d. Data d => d -> u) -> DINamespace -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DINamespace -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DINamespace -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DINamespace -> m DINamespace
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DINamespace -> m DINamespace
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DINamespace
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DINamespace -> c DINamespace
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DINamespace)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DINamespace)
$cNamespace :: Constr
$tDINamespace :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DINamespace -> m DINamespace
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DINamespace -> m DINamespace
gmapMp :: (forall d. Data d => d -> m d) -> DINamespace -> m DINamespace
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DINamespace -> m DINamespace
gmapM :: (forall d. Data d => d -> m d) -> DINamespace -> m DINamespace
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DINamespace -> m DINamespace
gmapQi :: Int -> (forall d. Data d => d -> u) -> DINamespace -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DINamespace -> u
gmapQ :: (forall d. Data d => d -> u) -> DINamespace -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DINamespace -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DINamespace -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DINamespace -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DINamespace -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DINamespace -> r
gmapT :: (forall b. Data b => b -> b) -> DINamespace -> DINamespace
$cgmapT :: (forall b. Data b => b -> b) -> DINamespace -> DINamespace
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DINamespace)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DINamespace)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DINamespace)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DINamespace)
dataTypeOf :: DINamespace -> DataType
$cdataTypeOf :: DINamespace -> DataType
toConstr :: DINamespace -> Constr
$ctoConstr :: DINamespace -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DINamespace
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DINamespace
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DINamespace -> c DINamespace
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DINamespace -> c DINamespace
$cp1Data :: Typeable DINamespace
Data, (forall x. DINamespace -> Rep DINamespace x)
-> (forall x. Rep DINamespace x -> DINamespace)
-> Generic DINamespace
forall x. Rep DINamespace x -> DINamespace
forall x. DINamespace -> Rep DINamespace x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DINamespace x -> DINamespace
$cfrom :: forall x. DINamespace -> Rep DINamespace x
Generic)

data DebugEmissionKind = NoDebug | FullDebug | LineTablesOnly
  deriving (DebugEmissionKind -> DebugEmissionKind -> Bool
(DebugEmissionKind -> DebugEmissionKind -> Bool)
-> (DebugEmissionKind -> DebugEmissionKind -> Bool)
-> Eq DebugEmissionKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DebugEmissionKind -> DebugEmissionKind -> Bool
$c/= :: DebugEmissionKind -> DebugEmissionKind -> Bool
== :: DebugEmissionKind -> DebugEmissionKind -> Bool
$c== :: DebugEmissionKind -> DebugEmissionKind -> Bool
Eq, Eq DebugEmissionKind
Eq DebugEmissionKind =>
(DebugEmissionKind -> DebugEmissionKind -> Ordering)
-> (DebugEmissionKind -> DebugEmissionKind -> Bool)
-> (DebugEmissionKind -> DebugEmissionKind -> Bool)
-> (DebugEmissionKind -> DebugEmissionKind -> Bool)
-> (DebugEmissionKind -> DebugEmissionKind -> Bool)
-> (DebugEmissionKind -> DebugEmissionKind -> DebugEmissionKind)
-> (DebugEmissionKind -> DebugEmissionKind -> DebugEmissionKind)
-> Ord DebugEmissionKind
DebugEmissionKind -> DebugEmissionKind -> Bool
DebugEmissionKind -> DebugEmissionKind -> Ordering
DebugEmissionKind -> DebugEmissionKind -> DebugEmissionKind
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DebugEmissionKind -> DebugEmissionKind -> DebugEmissionKind
$cmin :: DebugEmissionKind -> DebugEmissionKind -> DebugEmissionKind
max :: DebugEmissionKind -> DebugEmissionKind -> DebugEmissionKind
$cmax :: DebugEmissionKind -> DebugEmissionKind -> DebugEmissionKind
>= :: DebugEmissionKind -> DebugEmissionKind -> Bool
$c>= :: DebugEmissionKind -> DebugEmissionKind -> Bool
> :: DebugEmissionKind -> DebugEmissionKind -> Bool
$c> :: DebugEmissionKind -> DebugEmissionKind -> Bool
<= :: DebugEmissionKind -> DebugEmissionKind -> Bool
$c<= :: DebugEmissionKind -> DebugEmissionKind -> Bool
< :: DebugEmissionKind -> DebugEmissionKind -> Bool
$c< :: DebugEmissionKind -> DebugEmissionKind -> Bool
compare :: DebugEmissionKind -> DebugEmissionKind -> Ordering
$ccompare :: DebugEmissionKind -> DebugEmissionKind -> Ordering
$cp1Ord :: Eq DebugEmissionKind
Ord, ReadPrec [DebugEmissionKind]
ReadPrec DebugEmissionKind
Int -> ReadS DebugEmissionKind
ReadS [DebugEmissionKind]
(Int -> ReadS DebugEmissionKind)
-> ReadS [DebugEmissionKind]
-> ReadPrec DebugEmissionKind
-> ReadPrec [DebugEmissionKind]
-> Read DebugEmissionKind
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DebugEmissionKind]
$creadListPrec :: ReadPrec [DebugEmissionKind]
readPrec :: ReadPrec DebugEmissionKind
$creadPrec :: ReadPrec DebugEmissionKind
readList :: ReadS [DebugEmissionKind]
$creadList :: ReadS [DebugEmissionKind]
readsPrec :: Int -> ReadS DebugEmissionKind
$creadsPrec :: Int -> ReadS DebugEmissionKind
Read, Int -> DebugEmissionKind -> ShowS
[DebugEmissionKind] -> ShowS
DebugEmissionKind -> String
(Int -> DebugEmissionKind -> ShowS)
-> (DebugEmissionKind -> String)
-> ([DebugEmissionKind] -> ShowS)
-> Show DebugEmissionKind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DebugEmissionKind] -> ShowS
$cshowList :: [DebugEmissionKind] -> ShowS
show :: DebugEmissionKind -> String
$cshow :: DebugEmissionKind -> String
showsPrec :: Int -> DebugEmissionKind -> ShowS
$cshowsPrec :: Int -> DebugEmissionKind -> ShowS
Show, Typeable, Typeable DebugEmissionKind
DataType
Constr
Typeable DebugEmissionKind =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DebugEmissionKind
 -> c DebugEmissionKind)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DebugEmissionKind)
-> (DebugEmissionKind -> Constr)
-> (DebugEmissionKind -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DebugEmissionKind))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DebugEmissionKind))
-> ((forall b. Data b => b -> b)
    -> DebugEmissionKind -> DebugEmissionKind)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DebugEmissionKind -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DebugEmissionKind -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DebugEmissionKind -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DebugEmissionKind -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DebugEmissionKind -> m DebugEmissionKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DebugEmissionKind -> m DebugEmissionKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DebugEmissionKind -> m DebugEmissionKind)
-> Data DebugEmissionKind
DebugEmissionKind -> DataType
DebugEmissionKind -> Constr
(forall b. Data b => b -> b)
-> DebugEmissionKind -> DebugEmissionKind
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebugEmissionKind -> c DebugEmissionKind
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DebugEmissionKind
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DebugEmissionKind -> u
forall u. (forall d. Data d => d -> u) -> DebugEmissionKind -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugEmissionKind -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugEmissionKind -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DebugEmissionKind -> m DebugEmissionKind
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugEmissionKind -> m DebugEmissionKind
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DebugEmissionKind
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebugEmissionKind -> c DebugEmissionKind
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DebugEmissionKind)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DebugEmissionKind)
$cLineTablesOnly :: Constr
$cFullDebug :: Constr
$cNoDebug :: Constr
$tDebugEmissionKind :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> DebugEmissionKind -> m DebugEmissionKind
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugEmissionKind -> m DebugEmissionKind
gmapMp :: (forall d. Data d => d -> m d)
-> DebugEmissionKind -> m DebugEmissionKind
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugEmissionKind -> m DebugEmissionKind
gmapM :: (forall d. Data d => d -> m d)
-> DebugEmissionKind -> m DebugEmissionKind
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DebugEmissionKind -> m DebugEmissionKind
gmapQi :: Int -> (forall d. Data d => d -> u) -> DebugEmissionKind -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DebugEmissionKind -> u
gmapQ :: (forall d. Data d => d -> u) -> DebugEmissionKind -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DebugEmissionKind -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugEmissionKind -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugEmissionKind -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugEmissionKind -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugEmissionKind -> r
gmapT :: (forall b. Data b => b -> b)
-> DebugEmissionKind -> DebugEmissionKind
$cgmapT :: (forall b. Data b => b -> b)
-> DebugEmissionKind -> DebugEmissionKind
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DebugEmissionKind)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DebugEmissionKind)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DebugEmissionKind)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DebugEmissionKind)
dataTypeOf :: DebugEmissionKind -> DataType
$cdataTypeOf :: DebugEmissionKind -> DataType
toConstr :: DebugEmissionKind -> Constr
$ctoConstr :: DebugEmissionKind -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DebugEmissionKind
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DebugEmissionKind
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebugEmissionKind -> c DebugEmissionKind
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebugEmissionKind -> c DebugEmissionKind
$cp1Data :: Typeable DebugEmissionKind
Data, (forall x. DebugEmissionKind -> Rep DebugEmissionKind x)
-> (forall x. Rep DebugEmissionKind x -> DebugEmissionKind)
-> Generic DebugEmissionKind
forall x. Rep DebugEmissionKind x -> DebugEmissionKind
forall x. DebugEmissionKind -> Rep DebugEmissionKind x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DebugEmissionKind x -> DebugEmissionKind
$cfrom :: forall x. DebugEmissionKind -> Rep DebugEmissionKind x
Generic)

data DebugNameTableKind = NameTableKindDefault | NameTableKindGNU | NameTableKindNone
  deriving (DebugNameTableKind -> DebugNameTableKind -> Bool
(DebugNameTableKind -> DebugNameTableKind -> Bool)
-> (DebugNameTableKind -> DebugNameTableKind -> Bool)
-> Eq DebugNameTableKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DebugNameTableKind -> DebugNameTableKind -> Bool
$c/= :: DebugNameTableKind -> DebugNameTableKind -> Bool
== :: DebugNameTableKind -> DebugNameTableKind -> Bool
$c== :: DebugNameTableKind -> DebugNameTableKind -> Bool
Eq, Eq DebugNameTableKind
Eq DebugNameTableKind =>
(DebugNameTableKind -> DebugNameTableKind -> Ordering)
-> (DebugNameTableKind -> DebugNameTableKind -> Bool)
-> (DebugNameTableKind -> DebugNameTableKind -> Bool)
-> (DebugNameTableKind -> DebugNameTableKind -> Bool)
-> (DebugNameTableKind -> DebugNameTableKind -> Bool)
-> (DebugNameTableKind -> DebugNameTableKind -> DebugNameTableKind)
-> (DebugNameTableKind -> DebugNameTableKind -> DebugNameTableKind)
-> Ord DebugNameTableKind
DebugNameTableKind -> DebugNameTableKind -> Bool
DebugNameTableKind -> DebugNameTableKind -> Ordering
DebugNameTableKind -> DebugNameTableKind -> DebugNameTableKind
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DebugNameTableKind -> DebugNameTableKind -> DebugNameTableKind
$cmin :: DebugNameTableKind -> DebugNameTableKind -> DebugNameTableKind
max :: DebugNameTableKind -> DebugNameTableKind -> DebugNameTableKind
$cmax :: DebugNameTableKind -> DebugNameTableKind -> DebugNameTableKind
>= :: DebugNameTableKind -> DebugNameTableKind -> Bool
$c>= :: DebugNameTableKind -> DebugNameTableKind -> Bool
> :: DebugNameTableKind -> DebugNameTableKind -> Bool
$c> :: DebugNameTableKind -> DebugNameTableKind -> Bool
<= :: DebugNameTableKind -> DebugNameTableKind -> Bool
$c<= :: DebugNameTableKind -> DebugNameTableKind -> Bool
< :: DebugNameTableKind -> DebugNameTableKind -> Bool
$c< :: DebugNameTableKind -> DebugNameTableKind -> Bool
compare :: DebugNameTableKind -> DebugNameTableKind -> Ordering
$ccompare :: DebugNameTableKind -> DebugNameTableKind -> Ordering
$cp1Ord :: Eq DebugNameTableKind
Ord, ReadPrec [DebugNameTableKind]
ReadPrec DebugNameTableKind
Int -> ReadS DebugNameTableKind
ReadS [DebugNameTableKind]
(Int -> ReadS DebugNameTableKind)
-> ReadS [DebugNameTableKind]
-> ReadPrec DebugNameTableKind
-> ReadPrec [DebugNameTableKind]
-> Read DebugNameTableKind
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DebugNameTableKind]
$creadListPrec :: ReadPrec [DebugNameTableKind]
readPrec :: ReadPrec DebugNameTableKind
$creadPrec :: ReadPrec DebugNameTableKind
readList :: ReadS [DebugNameTableKind]
$creadList :: ReadS [DebugNameTableKind]
readsPrec :: Int -> ReadS DebugNameTableKind
$creadsPrec :: Int -> ReadS DebugNameTableKind
Read, Int -> DebugNameTableKind -> ShowS
[DebugNameTableKind] -> ShowS
DebugNameTableKind -> String
(Int -> DebugNameTableKind -> ShowS)
-> (DebugNameTableKind -> String)
-> ([DebugNameTableKind] -> ShowS)
-> Show DebugNameTableKind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DebugNameTableKind] -> ShowS
$cshowList :: [DebugNameTableKind] -> ShowS
show :: DebugNameTableKind -> String
$cshow :: DebugNameTableKind -> String
showsPrec :: Int -> DebugNameTableKind -> ShowS
$cshowsPrec :: Int -> DebugNameTableKind -> ShowS
Show, Typeable, Typeable DebugNameTableKind
DataType
Constr
Typeable DebugNameTableKind =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DebugNameTableKind
 -> c DebugNameTableKind)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DebugNameTableKind)
-> (DebugNameTableKind -> Constr)
-> (DebugNameTableKind -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DebugNameTableKind))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DebugNameTableKind))
-> ((forall b. Data b => b -> b)
    -> DebugNameTableKind -> DebugNameTableKind)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DebugNameTableKind -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DebugNameTableKind -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DebugNameTableKind -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DebugNameTableKind -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DebugNameTableKind -> m DebugNameTableKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DebugNameTableKind -> m DebugNameTableKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DebugNameTableKind -> m DebugNameTableKind)
-> Data DebugNameTableKind
DebugNameTableKind -> DataType
DebugNameTableKind -> Constr
(forall b. Data b => b -> b)
-> DebugNameTableKind -> DebugNameTableKind
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DebugNameTableKind
-> c DebugNameTableKind
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DebugNameTableKind
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DebugNameTableKind -> u
forall u. (forall d. Data d => d -> u) -> DebugNameTableKind -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugNameTableKind -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugNameTableKind -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DebugNameTableKind -> m DebugNameTableKind
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugNameTableKind -> m DebugNameTableKind
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DebugNameTableKind
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DebugNameTableKind
-> c DebugNameTableKind
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DebugNameTableKind)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DebugNameTableKind)
$cNameTableKindNone :: Constr
$cNameTableKindGNU :: Constr
$cNameTableKindDefault :: Constr
$tDebugNameTableKind :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> DebugNameTableKind -> m DebugNameTableKind
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugNameTableKind -> m DebugNameTableKind
gmapMp :: (forall d. Data d => d -> m d)
-> DebugNameTableKind -> m DebugNameTableKind
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugNameTableKind -> m DebugNameTableKind
gmapM :: (forall d. Data d => d -> m d)
-> DebugNameTableKind -> m DebugNameTableKind
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DebugNameTableKind -> m DebugNameTableKind
gmapQi :: Int -> (forall d. Data d => d -> u) -> DebugNameTableKind -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DebugNameTableKind -> u
gmapQ :: (forall d. Data d => d -> u) -> DebugNameTableKind -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DebugNameTableKind -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugNameTableKind -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugNameTableKind -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugNameTableKind -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugNameTableKind -> r
gmapT :: (forall b. Data b => b -> b)
-> DebugNameTableKind -> DebugNameTableKind
$cgmapT :: (forall b. Data b => b -> b)
-> DebugNameTableKind -> DebugNameTableKind
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DebugNameTableKind)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DebugNameTableKind)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DebugNameTableKind)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DebugNameTableKind)
dataTypeOf :: DebugNameTableKind -> DataType
$cdataTypeOf :: DebugNameTableKind -> DataType
toConstr :: DebugNameTableKind -> Constr
$ctoConstr :: DebugNameTableKind -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DebugNameTableKind
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DebugNameTableKind
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DebugNameTableKind
-> c DebugNameTableKind
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DebugNameTableKind
-> c DebugNameTableKind
$cp1Data :: Typeable DebugNameTableKind
Data, (forall x. DebugNameTableKind -> Rep DebugNameTableKind x)
-> (forall x. Rep DebugNameTableKind x -> DebugNameTableKind)
-> Generic DebugNameTableKind
forall x. Rep DebugNameTableKind x -> DebugNameTableKind
forall x. DebugNameTableKind -> Rep DebugNameTableKind x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DebugNameTableKind x -> DebugNameTableKind
$cfrom :: forall x. DebugNameTableKind -> Rep DebugNameTableKind x
Generic)

-- | <https://llvm.org/docs/LangRef.html#dicompileunit>
data DICompileUnit = CompileUnit
  { DICompileUnit -> Word32
language :: Word32
  , DICompileUnit -> MDRef DIFile
file :: MDRef DIFile
  , DICompileUnit -> ShortByteString
producer :: ShortByteString
  , DICompileUnit -> Bool
optimized :: Bool
  , DICompileUnit -> ShortByteString
flags :: ShortByteString
  , DICompileUnit -> Word32
runtimeVersion :: Word32
  , DICompileUnit -> ShortByteString
splitDebugFileName :: ShortByteString
  , DICompileUnit -> DebugEmissionKind
emissionKind :: DebugEmissionKind
  , DICompileUnit -> [MDRef DICompositeType]
enums :: [MDRef DICompositeType] -- ^ Only enum types are allowed here
  , DICompileUnit -> [MDRef (Either DIType DISubprogram)]
retainedTypes :: [MDRef (Either DIType DISubprogram)]
  , DICompileUnit -> [MDRef DIGlobalVariableExpression]
globals :: [MDRef DIGlobalVariableExpression]
  , DICompileUnit -> [MDRef DIImportedEntity]
imports :: [MDRef DIImportedEntity]
  , DICompileUnit -> [MDRef DIMacroNode]
macros :: [MDRef DIMacroNode]
  , DICompileUnit -> Word64
dWOId :: Word64
  , DICompileUnit -> Bool
splitDebugInlining :: Bool
  , DICompileUnit -> Bool
debugInfoForProfiling :: Bool
  , DICompileUnit -> DebugNameTableKind
nameTableKind :: DebugNameTableKind
  , DICompileUnit -> Bool
debugBaseAddress :: Bool
  } deriving (DICompileUnit -> DICompileUnit -> Bool
(DICompileUnit -> DICompileUnit -> Bool)
-> (DICompileUnit -> DICompileUnit -> Bool) -> Eq DICompileUnit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DICompileUnit -> DICompileUnit -> Bool
$c/= :: DICompileUnit -> DICompileUnit -> Bool
== :: DICompileUnit -> DICompileUnit -> Bool
$c== :: DICompileUnit -> DICompileUnit -> Bool
Eq, Eq DICompileUnit
Eq DICompileUnit =>
(DICompileUnit -> DICompileUnit -> Ordering)
-> (DICompileUnit -> DICompileUnit -> Bool)
-> (DICompileUnit -> DICompileUnit -> Bool)
-> (DICompileUnit -> DICompileUnit -> Bool)
-> (DICompileUnit -> DICompileUnit -> Bool)
-> (DICompileUnit -> DICompileUnit -> DICompileUnit)
-> (DICompileUnit -> DICompileUnit -> DICompileUnit)
-> Ord DICompileUnit
DICompileUnit -> DICompileUnit -> Bool
DICompileUnit -> DICompileUnit -> Ordering
DICompileUnit -> DICompileUnit -> DICompileUnit
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DICompileUnit -> DICompileUnit -> DICompileUnit
$cmin :: DICompileUnit -> DICompileUnit -> DICompileUnit
max :: DICompileUnit -> DICompileUnit -> DICompileUnit
$cmax :: DICompileUnit -> DICompileUnit -> DICompileUnit
>= :: DICompileUnit -> DICompileUnit -> Bool
$c>= :: DICompileUnit -> DICompileUnit -> Bool
> :: DICompileUnit -> DICompileUnit -> Bool
$c> :: DICompileUnit -> DICompileUnit -> Bool
<= :: DICompileUnit -> DICompileUnit -> Bool
$c<= :: DICompileUnit -> DICompileUnit -> Bool
< :: DICompileUnit -> DICompileUnit -> Bool
$c< :: DICompileUnit -> DICompileUnit -> Bool
compare :: DICompileUnit -> DICompileUnit -> Ordering
$ccompare :: DICompileUnit -> DICompileUnit -> Ordering
$cp1Ord :: Eq DICompileUnit
Ord, ReadPrec [DICompileUnit]
ReadPrec DICompileUnit
Int -> ReadS DICompileUnit
ReadS [DICompileUnit]
(Int -> ReadS DICompileUnit)
-> ReadS [DICompileUnit]
-> ReadPrec DICompileUnit
-> ReadPrec [DICompileUnit]
-> Read DICompileUnit
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DICompileUnit]
$creadListPrec :: ReadPrec [DICompileUnit]
readPrec :: ReadPrec DICompileUnit
$creadPrec :: ReadPrec DICompileUnit
readList :: ReadS [DICompileUnit]
$creadList :: ReadS [DICompileUnit]
readsPrec :: Int -> ReadS DICompileUnit
$creadsPrec :: Int -> ReadS DICompileUnit
Read, Int -> DICompileUnit -> ShowS
[DICompileUnit] -> ShowS
DICompileUnit -> String
(Int -> DICompileUnit -> ShowS)
-> (DICompileUnit -> String)
-> ([DICompileUnit] -> ShowS)
-> Show DICompileUnit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DICompileUnit] -> ShowS
$cshowList :: [DICompileUnit] -> ShowS
show :: DICompileUnit -> String
$cshow :: DICompileUnit -> String
showsPrec :: Int -> DICompileUnit -> ShowS
$cshowsPrec :: Int -> DICompileUnit -> ShowS
Show, Typeable, Typeable DICompileUnit
DataType
Constr
Typeable DICompileUnit =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DICompileUnit -> c DICompileUnit)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DICompileUnit)
-> (DICompileUnit -> Constr)
-> (DICompileUnit -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DICompileUnit))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DICompileUnit))
-> ((forall b. Data b => b -> b) -> DICompileUnit -> DICompileUnit)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DICompileUnit -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DICompileUnit -> r)
-> (forall u. (forall d. Data d => d -> u) -> DICompileUnit -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DICompileUnit -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit)
-> Data DICompileUnit
DICompileUnit -> DataType
DICompileUnit -> Constr
(forall b. Data b => b -> b) -> DICompileUnit -> DICompileUnit
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICompileUnit -> c DICompileUnit
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICompileUnit
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DICompileUnit -> u
forall u. (forall d. Data d => d -> u) -> DICompileUnit -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICompileUnit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICompileUnit -> c DICompileUnit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DICompileUnit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DICompileUnit)
$cCompileUnit :: Constr
$tDICompileUnit :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit
gmapMp :: (forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit
gmapM :: (forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit
gmapQi :: Int -> (forall d. Data d => d -> u) -> DICompileUnit -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DICompileUnit -> u
gmapQ :: (forall d. Data d => d -> u) -> DICompileUnit -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DICompileUnit -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit -> r
gmapT :: (forall b. Data b => b -> b) -> DICompileUnit -> DICompileUnit
$cgmapT :: (forall b. Data b => b -> b) -> DICompileUnit -> DICompileUnit
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DICompileUnit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DICompileUnit)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DICompileUnit)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DICompileUnit)
dataTypeOf :: DICompileUnit -> DataType
$cdataTypeOf :: DICompileUnit -> DataType
toConstr :: DICompileUnit -> Constr
$ctoConstr :: DICompileUnit -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICompileUnit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICompileUnit
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICompileUnit -> c DICompileUnit
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICompileUnit -> c DICompileUnit
$cp1Data :: Typeable DICompileUnit
Data, (forall x. DICompileUnit -> Rep DICompileUnit x)
-> (forall x. Rep DICompileUnit x -> DICompileUnit)
-> Generic DICompileUnit
forall x. Rep DICompileUnit x -> DICompileUnit
forall x. DICompileUnit -> Rep DICompileUnit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DICompileUnit x -> DICompileUnit
$cfrom :: forall x. DICompileUnit -> Rep DICompileUnit x
Generic)

-- | <https://llvm.org/docs/LangRef.html#difile>
data DIFile = File
  { DIFile -> ShortByteString
filename :: ShortByteString
  , DIFile -> ShortByteString
directory :: ShortByteString
  , DIFile -> Maybe ChecksumInfo
checksum :: Maybe ChecksumInfo
  } deriving (DIFile -> DIFile -> Bool
(DIFile -> DIFile -> Bool)
-> (DIFile -> DIFile -> Bool) -> Eq DIFile
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIFile -> DIFile -> Bool
$c/= :: DIFile -> DIFile -> Bool
== :: DIFile -> DIFile -> Bool
$c== :: DIFile -> DIFile -> Bool
Eq, Eq DIFile
Eq DIFile =>
(DIFile -> DIFile -> Ordering)
-> (DIFile -> DIFile -> Bool)
-> (DIFile -> DIFile -> Bool)
-> (DIFile -> DIFile -> Bool)
-> (DIFile -> DIFile -> Bool)
-> (DIFile -> DIFile -> DIFile)
-> (DIFile -> DIFile -> DIFile)
-> Ord DIFile
DIFile -> DIFile -> Bool
DIFile -> DIFile -> Ordering
DIFile -> DIFile -> DIFile
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DIFile -> DIFile -> DIFile
$cmin :: DIFile -> DIFile -> DIFile
max :: DIFile -> DIFile -> DIFile
$cmax :: DIFile -> DIFile -> DIFile
>= :: DIFile -> DIFile -> Bool
$c>= :: DIFile -> DIFile -> Bool
> :: DIFile -> DIFile -> Bool
$c> :: DIFile -> DIFile -> Bool
<= :: DIFile -> DIFile -> Bool
$c<= :: DIFile -> DIFile -> Bool
< :: DIFile -> DIFile -> Bool
$c< :: DIFile -> DIFile -> Bool
compare :: DIFile -> DIFile -> Ordering
$ccompare :: DIFile -> DIFile -> Ordering
$cp1Ord :: Eq DIFile
Ord, ReadPrec [DIFile]
ReadPrec DIFile
Int -> ReadS DIFile
ReadS [DIFile]
(Int -> ReadS DIFile)
-> ReadS [DIFile]
-> ReadPrec DIFile
-> ReadPrec [DIFile]
-> Read DIFile
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DIFile]
$creadListPrec :: ReadPrec [DIFile]
readPrec :: ReadPrec DIFile
$creadPrec :: ReadPrec DIFile
readList :: ReadS [DIFile]
$creadList :: ReadS [DIFile]
readsPrec :: Int -> ReadS DIFile
$creadsPrec :: Int -> ReadS DIFile
Read, Int -> DIFile -> ShowS
[DIFile] -> ShowS
DIFile -> String
(Int -> DIFile -> ShowS)
-> (DIFile -> String) -> ([DIFile] -> ShowS) -> Show DIFile
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DIFile] -> ShowS
$cshowList :: [DIFile] -> ShowS
show :: DIFile -> String
$cshow :: DIFile -> String
showsPrec :: Int -> DIFile -> ShowS
$cshowsPrec :: Int -> DIFile -> ShowS
Show, Typeable, Typeable DIFile
DataType
Constr
Typeable DIFile =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIFile -> c DIFile)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIFile)
-> (DIFile -> Constr)
-> (DIFile -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIFile))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFile))
-> ((forall b. Data b => b -> b) -> DIFile -> DIFile)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIFile -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIFile -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIFile -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DIFile -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIFile -> m DIFile)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIFile -> m DIFile)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIFile -> m DIFile)
-> Data DIFile
DIFile -> DataType
DIFile -> Constr
(forall b. Data b => b -> b) -> DIFile -> DIFile
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIFile -> c DIFile
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIFile
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DIFile -> u
forall u. (forall d. Data d => d -> u) -> DIFile -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIFile -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIFile -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIFile
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIFile -> c DIFile
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIFile)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFile)
$cFile :: Constr
$tDIFile :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DIFile -> m DIFile
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
gmapMp :: (forall d. Data d => d -> m d) -> DIFile -> m DIFile
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
gmapM :: (forall d. Data d => d -> m d) -> DIFile -> m DIFile
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
gmapQi :: Int -> (forall d. Data d => d -> u) -> DIFile -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIFile -> u
gmapQ :: (forall d. Data d => d -> u) -> DIFile -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIFile -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIFile -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIFile -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIFile -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIFile -> r
gmapT :: (forall b. Data b => b -> b) -> DIFile -> DIFile
$cgmapT :: (forall b. Data b => b -> b) -> DIFile -> DIFile
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFile)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFile)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DIFile)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIFile)
dataTypeOf :: DIFile -> DataType
$cdataTypeOf :: DIFile -> DataType
toConstr :: DIFile -> Constr
$ctoConstr :: DIFile -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIFile
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIFile
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIFile -> c DIFile
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIFile -> c DIFile
$cp1Data :: Typeable DIFile
Data, (forall x. DIFile -> Rep DIFile x)
-> (forall x. Rep DIFile x -> DIFile) -> Generic DIFile
forall x. Rep DIFile x -> DIFile
forall x. DIFile -> Rep DIFile x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DIFile x -> DIFile
$cfrom :: forall x. DIFile -> Rep DIFile x
Generic)

data ChecksumInfo = ChecksumInfo
  { ChecksumInfo -> ChecksumKind
checksumKind :: ChecksumKind
  , ChecksumInfo -> ShortByteString
checksumValue :: ShortByteString
  } deriving (ChecksumInfo -> ChecksumInfo -> Bool
(ChecksumInfo -> ChecksumInfo -> Bool)
-> (ChecksumInfo -> ChecksumInfo -> Bool) -> Eq ChecksumInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ChecksumInfo -> ChecksumInfo -> Bool
$c/= :: ChecksumInfo -> ChecksumInfo -> Bool
== :: ChecksumInfo -> ChecksumInfo -> Bool
$c== :: ChecksumInfo -> ChecksumInfo -> Bool
Eq, Eq ChecksumInfo
Eq ChecksumInfo =>
(ChecksumInfo -> ChecksumInfo -> Ordering)
-> (ChecksumInfo -> ChecksumInfo -> Bool)
-> (ChecksumInfo -> ChecksumInfo -> Bool)
-> (ChecksumInfo -> ChecksumInfo -> Bool)
-> (ChecksumInfo -> ChecksumInfo -> Bool)
-> (ChecksumInfo -> ChecksumInfo -> ChecksumInfo)
-> (ChecksumInfo -> ChecksumInfo -> ChecksumInfo)
-> Ord ChecksumInfo
ChecksumInfo -> ChecksumInfo -> Bool
ChecksumInfo -> ChecksumInfo -> Ordering
ChecksumInfo -> ChecksumInfo -> ChecksumInfo
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ChecksumInfo -> ChecksumInfo -> ChecksumInfo
$cmin :: ChecksumInfo -> ChecksumInfo -> ChecksumInfo
max :: ChecksumInfo -> ChecksumInfo -> ChecksumInfo
$cmax :: ChecksumInfo -> ChecksumInfo -> ChecksumInfo
>= :: ChecksumInfo -> ChecksumInfo -> Bool
$c>= :: ChecksumInfo -> ChecksumInfo -> Bool
> :: ChecksumInfo -> ChecksumInfo -> Bool
$c> :: ChecksumInfo -> ChecksumInfo -> Bool
<= :: ChecksumInfo -> ChecksumInfo -> Bool
$c<= :: ChecksumInfo -> ChecksumInfo -> Bool
< :: ChecksumInfo -> ChecksumInfo -> Bool
$c< :: ChecksumInfo -> ChecksumInfo -> Bool
compare :: ChecksumInfo -> ChecksumInfo -> Ordering
$ccompare :: ChecksumInfo -> ChecksumInfo -> Ordering
$cp1Ord :: Eq ChecksumInfo
Ord, ReadPrec [ChecksumInfo]
ReadPrec ChecksumInfo
Int -> ReadS ChecksumInfo
ReadS [ChecksumInfo]
(Int -> ReadS ChecksumInfo)
-> ReadS [ChecksumInfo]
-> ReadPrec ChecksumInfo
-> ReadPrec [ChecksumInfo]
-> Read ChecksumInfo
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ChecksumInfo]
$creadListPrec :: ReadPrec [ChecksumInfo]
readPrec :: ReadPrec ChecksumInfo
$creadPrec :: ReadPrec ChecksumInfo
readList :: ReadS [ChecksumInfo]
$creadList :: ReadS [ChecksumInfo]
readsPrec :: Int -> ReadS ChecksumInfo
$creadsPrec :: Int -> ReadS ChecksumInfo
Read, Int -> ChecksumInfo -> ShowS
[ChecksumInfo] -> ShowS
ChecksumInfo -> String
(Int -> ChecksumInfo -> ShowS)
-> (ChecksumInfo -> String)
-> ([ChecksumInfo] -> ShowS)
-> Show ChecksumInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ChecksumInfo] -> ShowS
$cshowList :: [ChecksumInfo] -> ShowS
show :: ChecksumInfo -> String
$cshow :: ChecksumInfo -> String
showsPrec :: Int -> ChecksumInfo -> ShowS
$cshowsPrec :: Int -> ChecksumInfo -> ShowS
Show, Typeable, Typeable ChecksumInfo
DataType
Constr
Typeable ChecksumInfo =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ChecksumInfo -> c ChecksumInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ChecksumInfo)
-> (ChecksumInfo -> Constr)
-> (ChecksumInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ChecksumInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ChecksumInfo))
-> ((forall b. Data b => b -> b) -> ChecksumInfo -> ChecksumInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ChecksumInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ChecksumInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> ChecksumInfo -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ChecksumInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo)
-> Data ChecksumInfo
ChecksumInfo -> DataType
ChecksumInfo -> Constr
(forall b. Data b => b -> b) -> ChecksumInfo -> ChecksumInfo
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChecksumInfo -> c ChecksumInfo
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChecksumInfo
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ChecksumInfo -> u
forall u. (forall d. Data d => d -> u) -> ChecksumInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChecksumInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChecksumInfo -> c ChecksumInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChecksumInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ChecksumInfo)
$cChecksumInfo :: Constr
$tChecksumInfo :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo
gmapMp :: (forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo
gmapM :: (forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo
gmapQi :: Int -> (forall d. Data d => d -> u) -> ChecksumInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ChecksumInfo -> u
gmapQ :: (forall d. Data d => d -> u) -> ChecksumInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ChecksumInfo -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumInfo -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumInfo -> r
gmapT :: (forall b. Data b => b -> b) -> ChecksumInfo -> ChecksumInfo
$cgmapT :: (forall b. Data b => b -> b) -> ChecksumInfo -> ChecksumInfo
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ChecksumInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ChecksumInfo)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ChecksumInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChecksumInfo)
dataTypeOf :: ChecksumInfo -> DataType
$cdataTypeOf :: ChecksumInfo -> DataType
toConstr :: ChecksumInfo -> Constr
$ctoConstr :: ChecksumInfo -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChecksumInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChecksumInfo
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChecksumInfo -> c ChecksumInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChecksumInfo -> c ChecksumInfo
$cp1Data :: Typeable ChecksumInfo
Data, (forall x. ChecksumInfo -> Rep ChecksumInfo x)
-> (forall x. Rep ChecksumInfo x -> ChecksumInfo)
-> Generic ChecksumInfo
forall x. Rep ChecksumInfo x -> ChecksumInfo
forall x. ChecksumInfo -> Rep ChecksumInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ChecksumInfo x -> ChecksumInfo
$cfrom :: forall x. ChecksumInfo -> Rep ChecksumInfo x
Generic)

data ChecksumKind = MD5 | SHA1
  deriving (ChecksumKind -> ChecksumKind -> Bool
(ChecksumKind -> ChecksumKind -> Bool)
-> (ChecksumKind -> ChecksumKind -> Bool) -> Eq ChecksumKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ChecksumKind -> ChecksumKind -> Bool
$c/= :: ChecksumKind -> ChecksumKind -> Bool
== :: ChecksumKind -> ChecksumKind -> Bool
$c== :: ChecksumKind -> ChecksumKind -> Bool
Eq, Eq ChecksumKind
Eq ChecksumKind =>
(ChecksumKind -> ChecksumKind -> Ordering)
-> (ChecksumKind -> ChecksumKind -> Bool)
-> (ChecksumKind -> ChecksumKind -> Bool)
-> (ChecksumKind -> ChecksumKind -> Bool)
-> (ChecksumKind -> ChecksumKind -> Bool)
-> (ChecksumKind -> ChecksumKind -> ChecksumKind)
-> (ChecksumKind -> ChecksumKind -> ChecksumKind)
-> Ord ChecksumKind
ChecksumKind -> ChecksumKind -> Bool
ChecksumKind -> ChecksumKind -> Ordering
ChecksumKind -> ChecksumKind -> ChecksumKind
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ChecksumKind -> ChecksumKind -> ChecksumKind
$cmin :: ChecksumKind -> ChecksumKind -> ChecksumKind
max :: ChecksumKind -> ChecksumKind -> ChecksumKind
$cmax :: ChecksumKind -> ChecksumKind -> ChecksumKind
>= :: ChecksumKind -> ChecksumKind -> Bool
$c>= :: ChecksumKind -> ChecksumKind -> Bool
> :: ChecksumKind -> ChecksumKind -> Bool
$c> :: ChecksumKind -> ChecksumKind -> Bool
<= :: ChecksumKind -> ChecksumKind -> Bool
$c<= :: ChecksumKind -> ChecksumKind -> Bool
< :: ChecksumKind -> ChecksumKind -> Bool
$c< :: ChecksumKind -> ChecksumKind -> Bool
compare :: ChecksumKind -> ChecksumKind -> Ordering
$ccompare :: ChecksumKind -> ChecksumKind -> Ordering
$cp1Ord :: Eq ChecksumKind
Ord, ReadPrec [ChecksumKind]
ReadPrec ChecksumKind
Int -> ReadS ChecksumKind
ReadS [ChecksumKind]
(Int -> ReadS ChecksumKind)
-> ReadS [ChecksumKind]
-> ReadPrec ChecksumKind
-> ReadPrec [ChecksumKind]
-> Read ChecksumKind
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ChecksumKind]
$creadListPrec :: ReadPrec [ChecksumKind]
readPrec :: ReadPrec ChecksumKind
$creadPrec :: ReadPrec ChecksumKind
readList :: ReadS [ChecksumKind]
$creadList :: ReadS [ChecksumKind]
readsPrec :: Int -> ReadS ChecksumKind
$creadsPrec :: Int -> ReadS ChecksumKind
Read, Int -> ChecksumKind -> ShowS
[ChecksumKind] -> ShowS
ChecksumKind -> String
(Int -> ChecksumKind -> ShowS)
-> (ChecksumKind -> String)
-> ([ChecksumKind] -> ShowS)
-> Show ChecksumKind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ChecksumKind] -> ShowS
$cshowList :: [ChecksumKind] -> ShowS
show :: ChecksumKind -> String
$cshow :: ChecksumKind -> String
showsPrec :: Int -> ChecksumKind -> ShowS
$cshowsPrec :: Int -> ChecksumKind -> ShowS
Show, Typeable, Typeable ChecksumKind
DataType
Constr
Typeable ChecksumKind =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ChecksumKind -> c ChecksumKind)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ChecksumKind)
-> (ChecksumKind -> Constr)
-> (ChecksumKind -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ChecksumKind))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ChecksumKind))
-> ((forall b. Data b => b -> b) -> ChecksumKind -> ChecksumKind)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ChecksumKind -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ChecksumKind -> r)
-> (forall u. (forall d. Data d => d -> u) -> ChecksumKind -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ChecksumKind -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind)
-> Data ChecksumKind
ChecksumKind -> DataType
ChecksumKind -> Constr
(forall b. Data b => b -> b) -> ChecksumKind -> ChecksumKind
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChecksumKind -> c ChecksumKind
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChecksumKind
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ChecksumKind -> u
forall u. (forall d. Data d => d -> u) -> ChecksumKind -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumKind -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumKind -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChecksumKind
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChecksumKind -> c ChecksumKind
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChecksumKind)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ChecksumKind)
$cSHA1 :: Constr
$cMD5 :: Constr
$tChecksumKind :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind
gmapMp :: (forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind
gmapM :: (forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind
gmapQi :: Int -> (forall d. Data d => d -> u) -> ChecksumKind -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ChecksumKind -> u
gmapQ :: (forall d. Data d => d -> u) -> ChecksumKind -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ChecksumKind -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumKind -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumKind -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumKind -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumKind -> r
gmapT :: (forall b. Data b => b -> b) -> ChecksumKind -> ChecksumKind
$cgmapT :: (forall b. Data b => b -> b) -> ChecksumKind -> ChecksumKind
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ChecksumKind)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ChecksumKind)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ChecksumKind)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChecksumKind)
dataTypeOf :: ChecksumKind -> DataType
$cdataTypeOf :: ChecksumKind -> DataType
toConstr :: ChecksumKind -> Constr
$ctoConstr :: ChecksumKind -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChecksumKind
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChecksumKind
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChecksumKind -> c ChecksumKind
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChecksumKind -> c ChecksumKind
$cp1Data :: Typeable ChecksumKind
Data, (forall x. ChecksumKind -> Rep ChecksumKind x)
-> (forall x. Rep ChecksumKind x -> ChecksumKind)
-> Generic ChecksumKind
forall x. Rep ChecksumKind x -> ChecksumKind
forall x. ChecksumKind -> Rep ChecksumKind x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ChecksumKind x -> ChecksumKind
$cfrom :: forall x. ChecksumKind -> Rep ChecksumKind x
Generic)

-- | <https://llvm.org/doxygen/classllvm_1_1DILocalScope.html>
data DILocalScope
  = DILexicalBlockBase DILexicalBlockBase
  | DISubprogram DISubprogram
  deriving (DILocalScope -> DILocalScope -> Bool
(DILocalScope -> DILocalScope -> Bool)
-> (DILocalScope -> DILocalScope -> Bool) -> Eq DILocalScope
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DILocalScope -> DILocalScope -> Bool
$c/= :: DILocalScope -> DILocalScope -> Bool
== :: DILocalScope -> DILocalScope -> Bool
$c== :: DILocalScope -> DILocalScope -> Bool
Eq, Eq DILocalScope
Eq DILocalScope =>
(DILocalScope -> DILocalScope -> Ordering)
-> (DILocalScope -> DILocalScope -> Bool)
-> (DILocalScope -> DILocalScope -> Bool)
-> (DILocalScope -> DILocalScope -> Bool)
-> (DILocalScope -> DILocalScope -> Bool)
-> (DILocalScope -> DILocalScope -> DILocalScope)
-> (DILocalScope -> DILocalScope -> DILocalScope)
-> Ord DILocalScope
DILocalScope -> DILocalScope -> Bool
DILocalScope -> DILocalScope -> Ordering
DILocalScope -> DILocalScope -> DILocalScope
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DILocalScope -> DILocalScope -> DILocalScope
$cmin :: DILocalScope -> DILocalScope -> DILocalScope
max :: DILocalScope -> DILocalScope -> DILocalScope
$cmax :: DILocalScope -> DILocalScope -> DILocalScope
>= :: DILocalScope -> DILocalScope -> Bool
$c>= :: DILocalScope -> DILocalScope -> Bool
> :: DILocalScope -> DILocalScope -> Bool
$c> :: DILocalScope -> DILocalScope -> Bool
<= :: DILocalScope -> DILocalScope -> Bool
$c<= :: DILocalScope -> DILocalScope -> Bool
< :: DILocalScope -> DILocalScope -> Bool
$c< :: DILocalScope -> DILocalScope -> Bool
compare :: DILocalScope -> DILocalScope -> Ordering
$ccompare :: DILocalScope -> DILocalScope -> Ordering
$cp1Ord :: Eq DILocalScope
Ord, ReadPrec [DILocalScope]
ReadPrec DILocalScope
Int -> ReadS DILocalScope
ReadS [DILocalScope]
(Int -> ReadS DILocalScope)
-> ReadS [DILocalScope]
-> ReadPrec DILocalScope
-> ReadPrec [DILocalScope]
-> Read DILocalScope
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DILocalScope]
$creadListPrec :: ReadPrec [DILocalScope]
readPrec :: ReadPrec DILocalScope
$creadPrec :: ReadPrec DILocalScope
readList :: ReadS [DILocalScope]
$creadList :: ReadS [DILocalScope]
readsPrec :: Int -> ReadS DILocalScope
$creadsPrec :: Int -> ReadS DILocalScope
Read, Int -> DILocalScope -> ShowS
[DILocalScope] -> ShowS
DILocalScope -> String
(Int -> DILocalScope -> ShowS)
-> (DILocalScope -> String)
-> ([DILocalScope] -> ShowS)
-> Show DILocalScope
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DILocalScope] -> ShowS
$cshowList :: [DILocalScope] -> ShowS
show :: DILocalScope -> String
$cshow :: DILocalScope -> String
showsPrec :: Int -> DILocalScope -> ShowS
$cshowsPrec :: Int -> DILocalScope -> ShowS
Show, Typeable, Typeable DILocalScope
DataType
Constr
Typeable DILocalScope =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DILocalScope -> c DILocalScope)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DILocalScope)
-> (DILocalScope -> Constr)
-> (DILocalScope -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DILocalScope))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DILocalScope))
-> ((forall b. Data b => b -> b) -> DILocalScope -> DILocalScope)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DILocalScope -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DILocalScope -> r)
-> (forall u. (forall d. Data d => d -> u) -> DILocalScope -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DILocalScope -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope)
-> Data DILocalScope
DILocalScope -> DataType
DILocalScope -> Constr
(forall b. Data b => b -> b) -> DILocalScope -> DILocalScope
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocalScope -> c DILocalScope
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocalScope
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DILocalScope -> u
forall u. (forall d. Data d => d -> u) -> DILocalScope -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalScope -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalScope -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocalScope
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocalScope -> c DILocalScope
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILocalScope)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DILocalScope)
$cDISubprogram :: Constr
$cDILexicalBlockBase :: Constr
$tDILocalScope :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope
gmapMp :: (forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope
gmapM :: (forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope
gmapQi :: Int -> (forall d. Data d => d -> u) -> DILocalScope -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DILocalScope -> u
gmapQ :: (forall d. Data d => d -> u) -> DILocalScope -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DILocalScope -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalScope -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalScope -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalScope -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalScope -> r
gmapT :: (forall b. Data b => b -> b) -> DILocalScope -> DILocalScope
$cgmapT :: (forall b. Data b => b -> b) -> DILocalScope -> DILocalScope
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DILocalScope)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DILocalScope)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DILocalScope)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILocalScope)
dataTypeOf :: DILocalScope -> DataType
$cdataTypeOf :: DILocalScope -> DataType
toConstr :: DILocalScope -> Constr
$ctoConstr :: DILocalScope -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocalScope
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocalScope
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocalScope -> c DILocalScope
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocalScope -> c DILocalScope
$cp1Data :: Typeable DILocalScope
Data, (forall x. DILocalScope -> Rep DILocalScope x)
-> (forall x. Rep DILocalScope x -> DILocalScope)
-> Generic DILocalScope
forall x. Rep DILocalScope x -> DILocalScope
forall x. DILocalScope -> Rep DILocalScope x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DILocalScope x -> DILocalScope
$cfrom :: forall x. DILocalScope -> Rep DILocalScope x
Generic)

-- | <https://llvm.org/docs/LangRef.html#disubprogram>
data DISubprogram = Subprogram
  { DISubprogram -> Maybe (MDRef DIScope)
scope :: Maybe (MDRef DIScope)
  , DISubprogram -> ShortByteString
name :: ShortByteString
  , DISubprogram -> ShortByteString
linkageName :: ShortByteString
  , DISubprogram -> Maybe (MDRef DIFile)
file :: Maybe (MDRef DIFile)
  , DISubprogram -> Word32
line :: Word32
  , DISubprogram -> Maybe (MDRef DISubroutineType)
type' :: Maybe (MDRef DISubroutineType)
  , DISubprogram -> Bool
localToUnit :: Bool
  , DISubprogram -> Bool
definition :: Bool
  , DISubprogram -> Word32
scopeLine :: Word32
  , DISubprogram -> Maybe (MDRef DIType)
containingType :: Maybe (MDRef DIType)
  , DISubprogram -> Virtuality
virtuality :: Virtuality
  , DISubprogram -> Word32
virtualityIndex :: Word32
  , DISubprogram -> Int32
thisAdjustment :: Int32
  , DISubprogram -> [DIFlag]
flags :: [DIFlag]
  , DISubprogram -> Bool
optimized :: Bool
  , DISubprogram -> Maybe (MDRef DICompileUnit)
unit :: Maybe (MDRef DICompileUnit)
  , DISubprogram -> [MDRef DITemplateParameter]
templateParams :: [MDRef DITemplateParameter]
  , DISubprogram -> Maybe (MDRef DISubprogram)
declaration :: Maybe (MDRef DISubprogram)
  , DISubprogram -> [MDRef DILocalVariable]
retainedNodes :: [MDRef DILocalVariable]
  , DISubprogram -> [MDRef DIType]
thrownTypes :: [MDRef DIType]
  } deriving (DISubprogram -> DISubprogram -> Bool
(DISubprogram -> DISubprogram -> Bool)
-> (DISubprogram -> DISubprogram -> Bool) -> Eq DISubprogram
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DISubprogram -> DISubprogram -> Bool
$c/= :: DISubprogram -> DISubprogram -> Bool
== :: DISubprogram -> DISubprogram -> Bool
$c== :: DISubprogram -> DISubprogram -> Bool
Eq, Eq DISubprogram
Eq DISubprogram =>
(DISubprogram -> DISubprogram -> Ordering)
-> (DISubprogram -> DISubprogram -> Bool)
-> (DISubprogram -> DISubprogram -> Bool)
-> (DISubprogram -> DISubprogram -> Bool)
-> (DISubprogram -> DISubprogram -> Bool)
-> (DISubprogram -> DISubprogram -> DISubprogram)
-> (DISubprogram -> DISubprogram -> DISubprogram)
-> Ord DISubprogram
DISubprogram -> DISubprogram -> Bool
DISubprogram -> DISubprogram -> Ordering
DISubprogram -> DISubprogram -> DISubprogram
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DISubprogram -> DISubprogram -> DISubprogram
$cmin :: DISubprogram -> DISubprogram -> DISubprogram
max :: DISubprogram -> DISubprogram -> DISubprogram
$cmax :: DISubprogram -> DISubprogram -> DISubprogram
>= :: DISubprogram -> DISubprogram -> Bool
$c>= :: DISubprogram -> DISubprogram -> Bool
> :: DISubprogram -> DISubprogram -> Bool
$c> :: DISubprogram -> DISubprogram -> Bool
<= :: DISubprogram -> DISubprogram -> Bool
$c<= :: DISubprogram -> DISubprogram -> Bool
< :: DISubprogram -> DISubprogram -> Bool
$c< :: DISubprogram -> DISubprogram -> Bool
compare :: DISubprogram -> DISubprogram -> Ordering
$ccompare :: DISubprogram -> DISubprogram -> Ordering
$cp1Ord :: Eq DISubprogram
Ord, ReadPrec [DISubprogram]
ReadPrec DISubprogram
Int -> ReadS DISubprogram
ReadS [DISubprogram]
(Int -> ReadS DISubprogram)
-> ReadS [DISubprogram]
-> ReadPrec DISubprogram
-> ReadPrec [DISubprogram]
-> Read DISubprogram
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DISubprogram]
$creadListPrec :: ReadPrec [DISubprogram]
readPrec :: ReadPrec DISubprogram
$creadPrec :: ReadPrec DISubprogram
readList :: ReadS [DISubprogram]
$creadList :: ReadS [DISubprogram]
readsPrec :: Int -> ReadS DISubprogram
$creadsPrec :: Int -> ReadS DISubprogram
Read, Int -> DISubprogram -> ShowS
[DISubprogram] -> ShowS
DISubprogram -> String
(Int -> DISubprogram -> ShowS)
-> (DISubprogram -> String)
-> ([DISubprogram] -> ShowS)
-> Show DISubprogram
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DISubprogram] -> ShowS
$cshowList :: [DISubprogram] -> ShowS
show :: DISubprogram -> String
$cshow :: DISubprogram -> String
showsPrec :: Int -> DISubprogram -> ShowS
$cshowsPrec :: Int -> DISubprogram -> ShowS
Show, Typeable, Typeable DISubprogram
DataType
Constr
Typeable DISubprogram =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DISubprogram -> c DISubprogram)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DISubprogram)
-> (DISubprogram -> Constr)
-> (DISubprogram -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DISubprogram))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DISubprogram))
-> ((forall b. Data b => b -> b) -> DISubprogram -> DISubprogram)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DISubprogram -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DISubprogram -> r)
-> (forall u. (forall d. Data d => d -> u) -> DISubprogram -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DISubprogram -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram)
-> Data DISubprogram
DISubprogram -> DataType
DISubprogram -> Constr
(forall b. Data b => b -> b) -> DISubprogram -> DISubprogram
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubprogram -> c DISubprogram
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubprogram
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DISubprogram -> u
forall u. (forall d. Data d => d -> u) -> DISubprogram -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubprogram
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubprogram -> c DISubprogram
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DISubprogram)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DISubprogram)
$cSubprogram :: Constr
$tDISubprogram :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram
gmapMp :: (forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram
gmapM :: (forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram
gmapQi :: Int -> (forall d. Data d => d -> u) -> DISubprogram -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DISubprogram -> u
gmapQ :: (forall d. Data d => d -> u) -> DISubprogram -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DISubprogram -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram -> r
gmapT :: (forall b. Data b => b -> b) -> DISubprogram -> DISubprogram
$cgmapT :: (forall b. Data b => b -> b) -> DISubprogram -> DISubprogram
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DISubprogram)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DISubprogram)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DISubprogram)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DISubprogram)
dataTypeOf :: DISubprogram -> DataType
$cdataTypeOf :: DISubprogram -> DataType
toConstr :: DISubprogram -> Constr
$ctoConstr :: DISubprogram -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubprogram
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubprogram
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubprogram -> c DISubprogram
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubprogram -> c DISubprogram
$cp1Data :: Typeable DISubprogram
Data, (forall x. DISubprogram -> Rep DISubprogram x)
-> (forall x. Rep DISubprogram x -> DISubprogram)
-> Generic DISubprogram
forall x. Rep DISubprogram x -> DISubprogram
forall x. DISubprogram -> Rep DISubprogram x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DISubprogram x -> DISubprogram
$cfrom :: forall x. DISubprogram -> Rep DISubprogram x
Generic)

data Virtuality = NoVirtuality | Virtual | PureVirtual
  deriving (Virtuality -> Virtuality -> Bool
(Virtuality -> Virtuality -> Bool)
-> (Virtuality -> Virtuality -> Bool) -> Eq Virtuality
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Virtuality -> Virtuality -> Bool
$c/= :: Virtuality -> Virtuality -> Bool
== :: Virtuality -> Virtuality -> Bool
$c== :: Virtuality -> Virtuality -> Bool
Eq, Eq Virtuality
Eq Virtuality =>
(Virtuality -> Virtuality -> Ordering)
-> (Virtuality -> Virtuality -> Bool)
-> (Virtuality -> Virtuality -> Bool)
-> (Virtuality -> Virtuality -> Bool)
-> (Virtuality -> Virtuality -> Bool)
-> (Virtuality -> Virtuality -> Virtuality)
-> (Virtuality -> Virtuality -> Virtuality)
-> Ord Virtuality
Virtuality -> Virtuality -> Bool
Virtuality -> Virtuality -> Ordering
Virtuality -> Virtuality -> Virtuality
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Virtuality -> Virtuality -> Virtuality
$cmin :: Virtuality -> Virtuality -> Virtuality
max :: Virtuality -> Virtuality -> Virtuality
$cmax :: Virtuality -> Virtuality -> Virtuality
>= :: Virtuality -> Virtuality -> Bool
$c>= :: Virtuality -> Virtuality -> Bool
> :: Virtuality -> Virtuality -> Bool
$c> :: Virtuality -> Virtuality -> Bool
<= :: Virtuality -> Virtuality -> Bool
$c<= :: Virtuality -> Virtuality -> Bool
< :: Virtuality -> Virtuality -> Bool
$c< :: Virtuality -> Virtuality -> Bool
compare :: Virtuality -> Virtuality -> Ordering
$ccompare :: Virtuality -> Virtuality -> Ordering
$cp1Ord :: Eq Virtuality
Ord, ReadPrec [Virtuality]
ReadPrec Virtuality
Int -> ReadS Virtuality
ReadS [Virtuality]
(Int -> ReadS Virtuality)
-> ReadS [Virtuality]
-> ReadPrec Virtuality
-> ReadPrec [Virtuality]
-> Read Virtuality
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Virtuality]
$creadListPrec :: ReadPrec [Virtuality]
readPrec :: ReadPrec Virtuality
$creadPrec :: ReadPrec Virtuality
readList :: ReadS [Virtuality]
$creadList :: ReadS [Virtuality]
readsPrec :: Int -> ReadS Virtuality
$creadsPrec :: Int -> ReadS Virtuality
Read, Int -> Virtuality -> ShowS
[Virtuality] -> ShowS
Virtuality -> String
(Int -> Virtuality -> ShowS)
-> (Virtuality -> String)
-> ([Virtuality] -> ShowS)
-> Show Virtuality
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Virtuality] -> ShowS
$cshowList :: [Virtuality] -> ShowS
show :: Virtuality -> String
$cshow :: Virtuality -> String
showsPrec :: Int -> Virtuality -> ShowS
$cshowsPrec :: Int -> Virtuality -> ShowS
Show, Typeable, Typeable Virtuality
DataType
Constr
Typeable Virtuality =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Virtuality -> c Virtuality)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Virtuality)
-> (Virtuality -> Constr)
-> (Virtuality -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Virtuality))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Virtuality))
-> ((forall b. Data b => b -> b) -> Virtuality -> Virtuality)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Virtuality -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Virtuality -> r)
-> (forall u. (forall d. Data d => d -> u) -> Virtuality -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Virtuality -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Virtuality -> m Virtuality)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Virtuality -> m Virtuality)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Virtuality -> m Virtuality)
-> Data Virtuality
Virtuality -> DataType
Virtuality -> Constr
(forall b. Data b => b -> b) -> Virtuality -> Virtuality
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Virtuality -> c Virtuality
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Virtuality
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Virtuality -> u
forall u. (forall d. Data d => d -> u) -> Virtuality -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Virtuality -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Virtuality -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Virtuality -> m Virtuality
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Virtuality -> m Virtuality
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Virtuality
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Virtuality -> c Virtuality
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Virtuality)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Virtuality)
$cPureVirtual :: Constr
$cVirtual :: Constr
$cNoVirtuality :: Constr
$tVirtuality :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Virtuality -> m Virtuality
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Virtuality -> m Virtuality
gmapMp :: (forall d. Data d => d -> m d) -> Virtuality -> m Virtuality
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Virtuality -> m Virtuality
gmapM :: (forall d. Data d => d -> m d) -> Virtuality -> m Virtuality
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Virtuality -> m Virtuality
gmapQi :: Int -> (forall d. Data d => d -> u) -> Virtuality -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Virtuality -> u
gmapQ :: (forall d. Data d => d -> u) -> Virtuality -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Virtuality -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Virtuality -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Virtuality -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Virtuality -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Virtuality -> r
gmapT :: (forall b. Data b => b -> b) -> Virtuality -> Virtuality
$cgmapT :: (forall b. Data b => b -> b) -> Virtuality -> Virtuality
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Virtuality)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Virtuality)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Virtuality)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Virtuality)
dataTypeOf :: Virtuality -> DataType
$cdataTypeOf :: Virtuality -> DataType
toConstr :: Virtuality -> Constr
$ctoConstr :: Virtuality -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Virtuality
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Virtuality
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Virtuality -> c Virtuality
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Virtuality -> c Virtuality
$cp1Data :: Typeable Virtuality
Data, (forall x. Virtuality -> Rep Virtuality x)
-> (forall x. Rep Virtuality x -> Virtuality) -> Generic Virtuality
forall x. Rep Virtuality x -> Virtuality
forall x. Virtuality -> Rep Virtuality x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Virtuality x -> Virtuality
$cfrom :: forall x. Virtuality -> Rep Virtuality x
Generic)

data BasicTypeTag = BaseType | UnspecifiedType
  deriving (BasicTypeTag -> BasicTypeTag -> Bool
(BasicTypeTag -> BasicTypeTag -> Bool)
-> (BasicTypeTag -> BasicTypeTag -> Bool) -> Eq BasicTypeTag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BasicTypeTag -> BasicTypeTag -> Bool
$c/= :: BasicTypeTag -> BasicTypeTag -> Bool
== :: BasicTypeTag -> BasicTypeTag -> Bool
$c== :: BasicTypeTag -> BasicTypeTag -> Bool
Eq, Eq BasicTypeTag
Eq BasicTypeTag =>
(BasicTypeTag -> BasicTypeTag -> Ordering)
-> (BasicTypeTag -> BasicTypeTag -> Bool)
-> (BasicTypeTag -> BasicTypeTag -> Bool)
-> (BasicTypeTag -> BasicTypeTag -> Bool)
-> (BasicTypeTag -> BasicTypeTag -> Bool)
-> (BasicTypeTag -> BasicTypeTag -> BasicTypeTag)
-> (BasicTypeTag -> BasicTypeTag -> BasicTypeTag)
-> Ord BasicTypeTag
BasicTypeTag -> BasicTypeTag -> Bool
BasicTypeTag -> BasicTypeTag -> Ordering
BasicTypeTag -> BasicTypeTag -> BasicTypeTag
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BasicTypeTag -> BasicTypeTag -> BasicTypeTag
$cmin :: BasicTypeTag -> BasicTypeTag -> BasicTypeTag
max :: BasicTypeTag -> BasicTypeTag -> BasicTypeTag
$cmax :: BasicTypeTag -> BasicTypeTag -> BasicTypeTag
>= :: BasicTypeTag -> BasicTypeTag -> Bool
$c>= :: BasicTypeTag -> BasicTypeTag -> Bool
> :: BasicTypeTag -> BasicTypeTag -> Bool
$c> :: BasicTypeTag -> BasicTypeTag -> Bool
<= :: BasicTypeTag -> BasicTypeTag -> Bool
$c<= :: BasicTypeTag -> BasicTypeTag -> Bool
< :: BasicTypeTag -> BasicTypeTag -> Bool
$c< :: BasicTypeTag -> BasicTypeTag -> Bool
compare :: BasicTypeTag -> BasicTypeTag -> Ordering
$ccompare :: BasicTypeTag -> BasicTypeTag -> Ordering
$cp1Ord :: Eq BasicTypeTag
Ord, ReadPrec [BasicTypeTag]
ReadPrec BasicTypeTag
Int -> ReadS BasicTypeTag
ReadS [BasicTypeTag]
(Int -> ReadS BasicTypeTag)
-> ReadS [BasicTypeTag]
-> ReadPrec BasicTypeTag
-> ReadPrec [BasicTypeTag]
-> Read BasicTypeTag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BasicTypeTag]
$creadListPrec :: ReadPrec [BasicTypeTag]
readPrec :: ReadPrec BasicTypeTag
$creadPrec :: ReadPrec BasicTypeTag
readList :: ReadS [BasicTypeTag]
$creadList :: ReadS [BasicTypeTag]
readsPrec :: Int -> ReadS BasicTypeTag
$creadsPrec :: Int -> ReadS BasicTypeTag
Read, Int -> BasicTypeTag -> ShowS
[BasicTypeTag] -> ShowS
BasicTypeTag -> String
(Int -> BasicTypeTag -> ShowS)
-> (BasicTypeTag -> String)
-> ([BasicTypeTag] -> ShowS)
-> Show BasicTypeTag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BasicTypeTag] -> ShowS
$cshowList :: [BasicTypeTag] -> ShowS
show :: BasicTypeTag -> String
$cshow :: BasicTypeTag -> String
showsPrec :: Int -> BasicTypeTag -> ShowS
$cshowsPrec :: Int -> BasicTypeTag -> ShowS
Show, Typeable, Typeable BasicTypeTag
DataType
Constr
Typeable BasicTypeTag =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BasicTypeTag -> c BasicTypeTag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BasicTypeTag)
-> (BasicTypeTag -> Constr)
-> (BasicTypeTag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BasicTypeTag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c BasicTypeTag))
-> ((forall b. Data b => b -> b) -> BasicTypeTag -> BasicTypeTag)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BasicTypeTag -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BasicTypeTag -> r)
-> (forall u. (forall d. Data d => d -> u) -> BasicTypeTag -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BasicTypeTag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag)
-> Data BasicTypeTag
BasicTypeTag -> DataType
BasicTypeTag -> Constr
(forall b. Data b => b -> b) -> BasicTypeTag -> BasicTypeTag
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BasicTypeTag -> c BasicTypeTag
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BasicTypeTag
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> BasicTypeTag -> u
forall u. (forall d. Data d => d -> u) -> BasicTypeTag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BasicTypeTag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BasicTypeTag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BasicTypeTag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BasicTypeTag -> c BasicTypeTag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BasicTypeTag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BasicTypeTag)
$cUnspecifiedType :: Constr
$cBaseType :: Constr
$tBasicTypeTag :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag
gmapMp :: (forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag
gmapM :: (forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag
gmapQi :: Int -> (forall d. Data d => d -> u) -> BasicTypeTag -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BasicTypeTag -> u
gmapQ :: (forall d. Data d => d -> u) -> BasicTypeTag -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BasicTypeTag -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BasicTypeTag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BasicTypeTag -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BasicTypeTag -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BasicTypeTag -> r
gmapT :: (forall b. Data b => b -> b) -> BasicTypeTag -> BasicTypeTag
$cgmapT :: (forall b. Data b => b -> b) -> BasicTypeTag -> BasicTypeTag
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BasicTypeTag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BasicTypeTag)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c BasicTypeTag)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BasicTypeTag)
dataTypeOf :: BasicTypeTag -> DataType
$cdataTypeOf :: BasicTypeTag -> DataType
toConstr :: BasicTypeTag -> Constr
$ctoConstr :: BasicTypeTag -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BasicTypeTag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BasicTypeTag
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BasicTypeTag -> c BasicTypeTag
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BasicTypeTag -> c BasicTypeTag
$cp1Data :: Typeable BasicTypeTag
Data, (forall x. BasicTypeTag -> Rep BasicTypeTag x)
-> (forall x. Rep BasicTypeTag x -> BasicTypeTag)
-> Generic BasicTypeTag
forall x. Rep BasicTypeTag x -> BasicTypeTag
forall x. BasicTypeTag -> Rep BasicTypeTag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BasicTypeTag x -> BasicTypeTag
$cfrom :: forall x. BasicTypeTag -> Rep BasicTypeTag x
Generic)

-- <https://llvm.org/doxygen/classllvm_1_1DIType.html>
data DIType
  = DIBasicType DIBasicType
  | DICompositeType DICompositeType
  | DIDerivedType DIDerivedType
  | DISubroutineType DISubroutineType
  deriving (DIType -> DIType -> Bool
(DIType -> DIType -> Bool)
-> (DIType -> DIType -> Bool) -> Eq DIType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIType -> DIType -> Bool
$c/= :: DIType -> DIType -> Bool
== :: DIType -> DIType -> Bool
$c== :: DIType -> DIType -> Bool
Eq, Eq DIType
Eq DIType =>
(DIType -> DIType -> Ordering)
-> (DIType -> DIType -> Bool)
-> (DIType -> DIType -> Bool)
-> (DIType -> DIType -> Bool)
-> (DIType -> DIType -> Bool)
-> (DIType -> DIType -> DIType)
-> (DIType -> DIType -> DIType)
-> Ord DIType
DIType -> DIType -> Bool
DIType -> DIType -> Ordering
DIType -> DIType -> DIType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DIType -> DIType -> DIType
$cmin :: DIType -> DIType -> DIType
max :: DIType -> DIType -> DIType
$cmax :: DIType -> DIType -> DIType
>= :: DIType -> DIType -> Bool
$c>= :: DIType -> DIType -> Bool
> :: DIType -> DIType -> Bool
$c> :: DIType -> DIType -> Bool
<= :: DIType -> DIType -> Bool
$c<= :: DIType -> DIType -> Bool
< :: DIType -> DIType -> Bool
$c< :: DIType -> DIType -> Bool
compare :: DIType -> DIType -> Ordering
$ccompare :: DIType -> DIType -> Ordering
$cp1Ord :: Eq DIType
Ord, ReadPrec [DIType]
ReadPrec DIType
Int -> ReadS DIType
ReadS [DIType]
(Int -> ReadS DIType)
-> ReadS [DIType]
-> ReadPrec DIType
-> ReadPrec [DIType]
-> Read DIType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DIType]
$creadListPrec :: ReadPrec [DIType]
readPrec :: ReadPrec DIType
$creadPrec :: ReadPrec DIType
readList :: ReadS [DIType]
$creadList :: ReadS [DIType]
readsPrec :: Int -> ReadS DIType
$creadsPrec :: Int -> ReadS DIType
Read, Int -> DIType -> ShowS
[DIType] -> ShowS
DIType -> String
(Int -> DIType -> ShowS)
-> (DIType -> String) -> ([DIType] -> ShowS) -> Show DIType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DIType] -> ShowS
$cshowList :: [DIType] -> ShowS
show :: DIType -> String
$cshow :: DIType -> String
showsPrec :: Int -> DIType -> ShowS
$cshowsPrec :: Int -> DIType -> ShowS
Show, Typeable, Typeable DIType
DataType
Constr
Typeable DIType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIType -> c DIType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIType)
-> (DIType -> Constr)
-> (DIType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIType))
-> ((forall b. Data b => b -> b) -> DIType -> DIType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIType -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DIType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIType -> m DIType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIType -> m DIType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIType -> m DIType)
-> Data DIType
DIType -> DataType
DIType -> Constr
(forall b. Data b => b -> b) -> DIType -> DIType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIType -> c DIType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DIType -> u
forall u. (forall d. Data d => d -> u) -> DIType -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIType -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIType -> m DIType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIType -> m DIType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIType -> c DIType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIType)
$cDISubroutineType :: Constr
$cDIDerivedType :: Constr
$cDICompositeType :: Constr
$cDIBasicType :: Constr
$tDIType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DIType -> m DIType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIType -> m DIType
gmapMp :: (forall d. Data d => d -> m d) -> DIType -> m DIType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIType -> m DIType
gmapM :: (forall d. Data d => d -> m d) -> DIType -> m DIType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIType -> m DIType
gmapQi :: Int -> (forall d. Data d => d -> u) -> DIType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIType -> u
gmapQ :: (forall d. Data d => d -> u) -> DIType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIType -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIType -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIType -> r
gmapT :: (forall b. Data b => b -> b) -> DIType -> DIType
$cgmapT :: (forall b. Data b => b -> b) -> DIType -> DIType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DIType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIType)
dataTypeOf :: DIType -> DataType
$cdataTypeOf :: DIType -> DataType
toConstr :: DIType -> Constr
$ctoConstr :: DIType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIType -> c DIType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIType -> c DIType
$cp1Data :: Typeable DIType
Data, (forall x. DIType -> Rep DIType x)
-> (forall x. Rep DIType x -> DIType) -> Generic DIType
forall x. Rep DIType x -> DIType
forall x. DIType -> Rep DIType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DIType x -> DIType
$cfrom :: forall x. DIType -> Rep DIType x
Generic)

-- | <https://llvm.org/docs/LangRef.html#dibasictype>
data DIBasicType = BasicType
  { DIBasicType -> ShortByteString
name :: ShortByteString
  , DIBasicType -> Word64
sizeInBits :: Word64
  , DIBasicType -> Word32
alignInBits :: Word32
  , DIBasicType -> Maybe Encoding
encoding :: Maybe Encoding
  , DIBasicType -> BasicTypeTag
tag :: BasicTypeTag
  , DIBasicType -> [DIFlag]
flags :: [DIFlag]
  } deriving (DIBasicType -> DIBasicType -> Bool
(DIBasicType -> DIBasicType -> Bool)
-> (DIBasicType -> DIBasicType -> Bool) -> Eq DIBasicType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIBasicType -> DIBasicType -> Bool
$c/= :: DIBasicType -> DIBasicType -> Bool
== :: DIBasicType -> DIBasicType -> Bool
$c== :: DIBasicType -> DIBasicType -> Bool
Eq, Eq DIBasicType
Eq DIBasicType =>
(DIBasicType -> DIBasicType -> Ordering)
-> (DIBasicType -> DIBasicType -> Bool)
-> (DIBasicType -> DIBasicType -> Bool)
-> (DIBasicType -> DIBasicType -> Bool)
-> (DIBasicType -> DIBasicType -> Bool)
-> (DIBasicType -> DIBasicType -> DIBasicType)
-> (DIBasicType -> DIBasicType -> DIBasicType)
-> Ord DIBasicType
DIBasicType -> DIBasicType -> Bool
DIBasicType -> DIBasicType -> Ordering
DIBasicType -> DIBasicType -> DIBasicType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DIBasicType -> DIBasicType -> DIBasicType
$cmin :: DIBasicType -> DIBasicType -> DIBasicType
max :: DIBasicType -> DIBasicType -> DIBasicType
$cmax :: DIBasicType -> DIBasicType -> DIBasicType
>= :: DIBasicType -> DIBasicType -> Bool
$c>= :: DIBasicType -> DIBasicType -> Bool
> :: DIBasicType -> DIBasicType -> Bool
$c> :: DIBasicType -> DIBasicType -> Bool
<= :: DIBasicType -> DIBasicType -> Bool
$c<= :: DIBasicType -> DIBasicType -> Bool
< :: DIBasicType -> DIBasicType -> Bool
$c< :: DIBasicType -> DIBasicType -> Bool
compare :: DIBasicType -> DIBasicType -> Ordering
$ccompare :: DIBasicType -> DIBasicType -> Ordering
$cp1Ord :: Eq DIBasicType
Ord, ReadPrec [DIBasicType]
ReadPrec DIBasicType
Int -> ReadS DIBasicType
ReadS [DIBasicType]
(Int -> ReadS DIBasicType)
-> ReadS [DIBasicType]
-> ReadPrec DIBasicType
-> ReadPrec [DIBasicType]
-> Read DIBasicType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DIBasicType]
$creadListPrec :: ReadPrec [DIBasicType]
readPrec :: ReadPrec DIBasicType
$creadPrec :: ReadPrec DIBasicType
readList :: ReadS [DIBasicType]
$creadList :: ReadS [DIBasicType]
readsPrec :: Int -> ReadS DIBasicType
$creadsPrec :: Int -> ReadS DIBasicType
Read, Int -> DIBasicType -> ShowS
[DIBasicType] -> ShowS
DIBasicType -> String
(Int -> DIBasicType -> ShowS)
-> (DIBasicType -> String)
-> ([DIBasicType] -> ShowS)
-> Show DIBasicType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DIBasicType] -> ShowS
$cshowList :: [DIBasicType] -> ShowS
show :: DIBasicType -> String
$cshow :: DIBasicType -> String
showsPrec :: Int -> DIBasicType -> ShowS
$cshowsPrec :: Int -> DIBasicType -> ShowS
Show, Typeable, Typeable DIBasicType
DataType
Constr
Typeable DIBasicType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIBasicType -> c DIBasicType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIBasicType)
-> (DIBasicType -> Constr)
-> (DIBasicType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIBasicType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIBasicType))
-> ((forall b. Data b => b -> b) -> DIBasicType -> DIBasicType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIBasicType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIBasicType -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIBasicType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIBasicType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType)
-> Data DIBasicType
DIBasicType -> DataType
DIBasicType -> Constr
(forall b. Data b => b -> b) -> DIBasicType -> DIBasicType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIBasicType -> c DIBasicType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIBasicType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DIBasicType -> u
forall u. (forall d. Data d => d -> u) -> DIBasicType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIBasicType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIBasicType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIBasicType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIBasicType -> c DIBasicType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIBasicType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIBasicType)
$cBasicType :: Constr
$tDIBasicType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
gmapMp :: (forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
gmapM :: (forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
gmapQi :: Int -> (forall d. Data d => d -> u) -> DIBasicType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIBasicType -> u
gmapQ :: (forall d. Data d => d -> u) -> DIBasicType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIBasicType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIBasicType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIBasicType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIBasicType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIBasicType -> r
gmapT :: (forall b. Data b => b -> b) -> DIBasicType -> DIBasicType
$cgmapT :: (forall b. Data b => b -> b) -> DIBasicType -> DIBasicType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIBasicType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIBasicType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DIBasicType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIBasicType)
dataTypeOf :: DIBasicType -> DataType
$cdataTypeOf :: DIBasicType -> DataType
toConstr :: DIBasicType -> Constr
$ctoConstr :: DIBasicType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIBasicType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIBasicType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIBasicType -> c DIBasicType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIBasicType -> c DIBasicType
$cp1Data :: Typeable DIBasicType
Data, (forall x. DIBasicType -> Rep DIBasicType x)
-> (forall x. Rep DIBasicType x -> DIBasicType)
-> Generic DIBasicType
forall x. Rep DIBasicType x -> DIBasicType
forall x. DIBasicType -> Rep DIBasicType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DIBasicType x -> DIBasicType
$cfrom :: forall x. DIBasicType -> Rep DIBasicType x
Generic)

-- | <https://llvm.org/docs/LangRef.html#disubroutinetype>
data DISubroutineType = SubroutineType
  { DISubroutineType -> [DIFlag]
flags :: [DIFlag]
  , DISubroutineType -> Word8
cc :: Word8
  , DISubroutineType -> [Maybe (MDRef DIType)]
typeArray :: [Maybe (MDRef DIType)]
  -- ^ The first element is the return type, the following are the
  -- operand types. `Nothing` corresponds to @void@.
  } deriving (DISubroutineType -> DISubroutineType -> Bool
(DISubroutineType -> DISubroutineType -> Bool)
-> (DISubroutineType -> DISubroutineType -> Bool)
-> Eq DISubroutineType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DISubroutineType -> DISubroutineType -> Bool
$c/= :: DISubroutineType -> DISubroutineType -> Bool
== :: DISubroutineType -> DISubroutineType -> Bool
$c== :: DISubroutineType -> DISubroutineType -> Bool
Eq, Eq DISubroutineType
Eq DISubroutineType =>
(DISubroutineType -> DISubroutineType -> Ordering)
-> (DISubroutineType -> DISubroutineType -> Bool)
-> (DISubroutineType -> DISubroutineType -> Bool)
-> (DISubroutineType -> DISubroutineType -> Bool)
-> (DISubroutineType -> DISubroutineType -> Bool)
-> (DISubroutineType -> DISubroutineType -> DISubroutineType)
-> (DISubroutineType -> DISubroutineType -> DISubroutineType)
-> Ord DISubroutineType
DISubroutineType -> DISubroutineType -> Bool
DISubroutineType -> DISubroutineType -> Ordering
DISubroutineType -> DISubroutineType -> DISubroutineType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DISubroutineType -> DISubroutineType -> DISubroutineType
$cmin :: DISubroutineType -> DISubroutineType -> DISubroutineType
max :: DISubroutineType -> DISubroutineType -> DISubroutineType
$cmax :: DISubroutineType -> DISubroutineType -> DISubroutineType
>= :: DISubroutineType -> DISubroutineType -> Bool
$c>= :: DISubroutineType -> DISubroutineType -> Bool
> :: DISubroutineType -> DISubroutineType -> Bool
$c> :: DISubroutineType -> DISubroutineType -> Bool
<= :: DISubroutineType -> DISubroutineType -> Bool
$c<= :: DISubroutineType -> DISubroutineType -> Bool
< :: DISubroutineType -> DISubroutineType -> Bool
$c< :: DISubroutineType -> DISubroutineType -> Bool
compare :: DISubroutineType -> DISubroutineType -> Ordering
$ccompare :: DISubroutineType -> DISubroutineType -> Ordering
$cp1Ord :: Eq DISubroutineType
Ord, ReadPrec [DISubroutineType]
ReadPrec DISubroutineType
Int -> ReadS DISubroutineType
ReadS [DISubroutineType]
(Int -> ReadS DISubroutineType)
-> ReadS [DISubroutineType]
-> ReadPrec DISubroutineType
-> ReadPrec [DISubroutineType]
-> Read DISubroutineType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DISubroutineType]
$creadListPrec :: ReadPrec [DISubroutineType]
readPrec :: ReadPrec DISubroutineType
$creadPrec :: ReadPrec DISubroutineType
readList :: ReadS [DISubroutineType]
$creadList :: ReadS [DISubroutineType]
readsPrec :: Int -> ReadS DISubroutineType
$creadsPrec :: Int -> ReadS DISubroutineType
Read, Int -> DISubroutineType -> ShowS
[DISubroutineType] -> ShowS
DISubroutineType -> String
(Int -> DISubroutineType -> ShowS)
-> (DISubroutineType -> String)
-> ([DISubroutineType] -> ShowS)
-> Show DISubroutineType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DISubroutineType] -> ShowS
$cshowList :: [DISubroutineType] -> ShowS
show :: DISubroutineType -> String
$cshow :: DISubroutineType -> String
showsPrec :: Int -> DISubroutineType -> ShowS
$cshowsPrec :: Int -> DISubroutineType -> ShowS
Show, Typeable, Typeable DISubroutineType
DataType
Constr
Typeable DISubroutineType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DISubroutineType -> c DISubroutineType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DISubroutineType)
-> (DISubroutineType -> Constr)
-> (DISubroutineType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DISubroutineType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DISubroutineType))
-> ((forall b. Data b => b -> b)
    -> DISubroutineType -> DISubroutineType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DISubroutineType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DISubroutineType -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DISubroutineType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DISubroutineType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DISubroutineType -> m DISubroutineType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DISubroutineType -> m DISubroutineType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DISubroutineType -> m DISubroutineType)
-> Data DISubroutineType
DISubroutineType -> DataType
DISubroutineType -> Constr
(forall b. Data b => b -> b)
-> DISubroutineType -> DISubroutineType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubroutineType -> c DISubroutineType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubroutineType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DISubroutineType -> u
forall u. (forall d. Data d => d -> u) -> DISubroutineType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DISubroutineType -> m DISubroutineType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DISubroutineType -> m DISubroutineType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubroutineType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubroutineType -> c DISubroutineType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DISubroutineType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DISubroutineType)
$cSubroutineType :: Constr
$tDISubroutineType :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> DISubroutineType -> m DISubroutineType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DISubroutineType -> m DISubroutineType
gmapMp :: (forall d. Data d => d -> m d)
-> DISubroutineType -> m DISubroutineType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DISubroutineType -> m DISubroutineType
gmapM :: (forall d. Data d => d -> m d)
-> DISubroutineType -> m DISubroutineType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DISubroutineType -> m DISubroutineType
gmapQi :: Int -> (forall d. Data d => d -> u) -> DISubroutineType -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DISubroutineType -> u
gmapQ :: (forall d. Data d => d -> u) -> DISubroutineType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DISubroutineType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType -> r
gmapT :: (forall b. Data b => b -> b)
-> DISubroutineType -> DISubroutineType
$cgmapT :: (forall b. Data b => b -> b)
-> DISubroutineType -> DISubroutineType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DISubroutineType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DISubroutineType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DISubroutineType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DISubroutineType)
dataTypeOf :: DISubroutineType -> DataType
$cdataTypeOf :: DISubroutineType -> DataType
toConstr :: DISubroutineType -> Constr
$ctoConstr :: DISubroutineType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubroutineType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubroutineType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubroutineType -> c DISubroutineType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubroutineType -> c DISubroutineType
$cp1Data :: Typeable DISubroutineType
Data, (forall x. DISubroutineType -> Rep DISubroutineType x)
-> (forall x. Rep DISubroutineType x -> DISubroutineType)
-> Generic DISubroutineType
forall x. Rep DISubroutineType x -> DISubroutineType
forall x. DISubroutineType -> Rep DISubroutineType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DISubroutineType x -> DISubroutineType
$cfrom :: forall x. DISubroutineType -> Rep DISubroutineType x
Generic)

data DerivedTypeTag
  = Typedef
  | PointerType
  | PtrToMemberType
  | ReferenceType
  | RValueReferenceType
  | ConstType
  | VolatileType
  | RestrictType
  | AtomicType
  | Member
  | Inheritance
  | Friend
  deriving (DerivedTypeTag -> DerivedTypeTag -> Bool
(DerivedTypeTag -> DerivedTypeTag -> Bool)
-> (DerivedTypeTag -> DerivedTypeTag -> Bool) -> Eq DerivedTypeTag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DerivedTypeTag -> DerivedTypeTag -> Bool
$c/= :: DerivedTypeTag -> DerivedTypeTag -> Bool
== :: DerivedTypeTag -> DerivedTypeTag -> Bool
$c== :: DerivedTypeTag -> DerivedTypeTag -> Bool
Eq, Eq DerivedTypeTag
Eq DerivedTypeTag =>
(DerivedTypeTag -> DerivedTypeTag -> Ordering)
-> (DerivedTypeTag -> DerivedTypeTag -> Bool)
-> (DerivedTypeTag -> DerivedTypeTag -> Bool)
-> (DerivedTypeTag -> DerivedTypeTag -> Bool)
-> (DerivedTypeTag -> DerivedTypeTag -> Bool)
-> (DerivedTypeTag -> DerivedTypeTag -> DerivedTypeTag)
-> (DerivedTypeTag -> DerivedTypeTag -> DerivedTypeTag)
-> Ord DerivedTypeTag
DerivedTypeTag -> DerivedTypeTag -> Bool
DerivedTypeTag -> DerivedTypeTag -> Ordering
DerivedTypeTag -> DerivedTypeTag -> DerivedTypeTag
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DerivedTypeTag -> DerivedTypeTag -> DerivedTypeTag
$cmin :: DerivedTypeTag -> DerivedTypeTag -> DerivedTypeTag
max :: DerivedTypeTag -> DerivedTypeTag -> DerivedTypeTag
$cmax :: DerivedTypeTag -> DerivedTypeTag -> DerivedTypeTag
>= :: DerivedTypeTag -> DerivedTypeTag -> Bool
$c>= :: DerivedTypeTag -> DerivedTypeTag -> Bool
> :: DerivedTypeTag -> DerivedTypeTag -> Bool
$c> :: DerivedTypeTag -> DerivedTypeTag -> Bool
<= :: DerivedTypeTag -> DerivedTypeTag -> Bool
$c<= :: DerivedTypeTag -> DerivedTypeTag -> Bool
< :: DerivedTypeTag -> DerivedTypeTag -> Bool
$c< :: DerivedTypeTag -> DerivedTypeTag -> Bool
compare :: DerivedTypeTag -> DerivedTypeTag -> Ordering
$ccompare :: DerivedTypeTag -> DerivedTypeTag -> Ordering
$cp1Ord :: Eq DerivedTypeTag
Ord, ReadPrec [DerivedTypeTag]
ReadPrec DerivedTypeTag
Int -> ReadS DerivedTypeTag
ReadS [DerivedTypeTag]
(Int -> ReadS DerivedTypeTag)
-> ReadS [DerivedTypeTag]
-> ReadPrec DerivedTypeTag
-> ReadPrec [DerivedTypeTag]
-> Read DerivedTypeTag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DerivedTypeTag]
$creadListPrec :: ReadPrec [DerivedTypeTag]
readPrec :: ReadPrec DerivedTypeTag
$creadPrec :: ReadPrec DerivedTypeTag
readList :: ReadS [DerivedTypeTag]
$creadList :: ReadS [DerivedTypeTag]
readsPrec :: Int -> ReadS DerivedTypeTag
$creadsPrec :: Int -> ReadS DerivedTypeTag
Read, Int -> DerivedTypeTag -> ShowS
[DerivedTypeTag] -> ShowS
DerivedTypeTag -> String
(Int -> DerivedTypeTag -> ShowS)
-> (DerivedTypeTag -> String)
-> ([DerivedTypeTag] -> ShowS)
-> Show DerivedTypeTag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DerivedTypeTag] -> ShowS
$cshowList :: [DerivedTypeTag] -> ShowS
show :: DerivedTypeTag -> String
$cshow :: DerivedTypeTag -> String
showsPrec :: Int -> DerivedTypeTag -> ShowS
$cshowsPrec :: Int -> DerivedTypeTag -> ShowS
Show, Typeable, Typeable DerivedTypeTag
DataType
Constr
Typeable DerivedTypeTag =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DerivedTypeTag -> c DerivedTypeTag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DerivedTypeTag)
-> (DerivedTypeTag -> Constr)
-> (DerivedTypeTag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DerivedTypeTag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DerivedTypeTag))
-> ((forall b. Data b => b -> b)
    -> DerivedTypeTag -> DerivedTypeTag)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivedTypeTag -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivedTypeTag -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DerivedTypeTag -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DerivedTypeTag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DerivedTypeTag -> m DerivedTypeTag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DerivedTypeTag -> m DerivedTypeTag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DerivedTypeTag -> m DerivedTypeTag)
-> Data DerivedTypeTag
DerivedTypeTag -> DataType
DerivedTypeTag -> Constr
(forall b. Data b => b -> b) -> DerivedTypeTag -> DerivedTypeTag
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivedTypeTag -> c DerivedTypeTag
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivedTypeTag
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DerivedTypeTag -> u
forall u. (forall d. Data d => d -> u) -> DerivedTypeTag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivedTypeTag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivedTypeTag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DerivedTypeTag -> m DerivedTypeTag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivedTypeTag -> m DerivedTypeTag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivedTypeTag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivedTypeTag -> c DerivedTypeTag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivedTypeTag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivedTypeTag)
$cFriend :: Constr
$cInheritance :: Constr
$cMember :: Constr
$cAtomicType :: Constr
$cRestrictType :: Constr
$cVolatileType :: Constr
$cConstType :: Constr
$cRValueReferenceType :: Constr
$cReferenceType :: Constr
$cPtrToMemberType :: Constr
$cPointerType :: Constr
$cTypedef :: Constr
$tDerivedTypeTag :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> DerivedTypeTag -> m DerivedTypeTag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivedTypeTag -> m DerivedTypeTag
gmapMp :: (forall d. Data d => d -> m d)
-> DerivedTypeTag -> m DerivedTypeTag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivedTypeTag -> m DerivedTypeTag
gmapM :: (forall d. Data d => d -> m d)
-> DerivedTypeTag -> m DerivedTypeTag
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DerivedTypeTag -> m DerivedTypeTag
gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivedTypeTag -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DerivedTypeTag -> u
gmapQ :: (forall d. Data d => d -> u) -> DerivedTypeTag -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DerivedTypeTag -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivedTypeTag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivedTypeTag -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivedTypeTag -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivedTypeTag -> r
gmapT :: (forall b. Data b => b -> b) -> DerivedTypeTag -> DerivedTypeTag
$cgmapT :: (forall b. Data b => b -> b) -> DerivedTypeTag -> DerivedTypeTag
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivedTypeTag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivedTypeTag)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DerivedTypeTag)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivedTypeTag)
dataTypeOf :: DerivedTypeTag -> DataType
$cdataTypeOf :: DerivedTypeTag -> DataType
toConstr :: DerivedTypeTag -> Constr
$ctoConstr :: DerivedTypeTag -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivedTypeTag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivedTypeTag
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivedTypeTag -> c DerivedTypeTag
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivedTypeTag -> c DerivedTypeTag
$cp1Data :: Typeable DerivedTypeTag
Data, (forall x. DerivedTypeTag -> Rep DerivedTypeTag x)
-> (forall x. Rep DerivedTypeTag x -> DerivedTypeTag)
-> Generic DerivedTypeTag
forall x. Rep DerivedTypeTag x -> DerivedTypeTag
forall x. DerivedTypeTag -> Rep DerivedTypeTag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DerivedTypeTag x -> DerivedTypeTag
$cfrom :: forall x. DerivedTypeTag -> Rep DerivedTypeTag x
Generic)

-- | <https://llvm.org/docs/LangRef.html#diderivedtype>
data DIDerivedType =
  DerivedType
    { DIDerivedType -> DerivedTypeTag
tag :: DerivedTypeTag
    , DIDerivedType -> ShortByteString
name :: ShortByteString
    , DIDerivedType -> Maybe (MDRef DIFile)
file :: Maybe (MDRef DIFile)
    , DIDerivedType -> Word32
line :: Word32
    , DIDerivedType -> Maybe (MDRef DIScope)
scope :: Maybe (MDRef DIScope)
    , DIDerivedType -> Maybe (MDRef DIType)
baseType :: Maybe (MDRef DIType)
    -- ^ This can be `Nothing` to represent @void *@
    , DIDerivedType -> Word64
sizeInBits :: Word64
    , DIDerivedType -> Word32
alignInBits :: Word32
    , DIDerivedType -> Word64
offsetInBits :: Word64
    , DIDerivedType -> Maybe Word32
addressSpace :: Maybe Word32
    , DIDerivedType -> [DIFlag]
flags :: [DIFlag]
    } deriving (DIDerivedType -> DIDerivedType -> Bool
(DIDerivedType -> DIDerivedType -> Bool)
-> (DIDerivedType -> DIDerivedType -> Bool) -> Eq DIDerivedType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIDerivedType -> DIDerivedType -> Bool
$c/= :: DIDerivedType -> DIDerivedType -> Bool
== :: DIDerivedType -> DIDerivedType -> Bool
$c== :: DIDerivedType -> DIDerivedType -> Bool
Eq, Eq DIDerivedType
Eq DIDerivedType =>
(DIDerivedType -> DIDerivedType -> Ordering)
-> (DIDerivedType -> DIDerivedType -> Bool)
-> (DIDerivedType -> DIDerivedType -> Bool)
-> (DIDerivedType -> DIDerivedType -> Bool)
-> (DIDerivedType -> DIDerivedType -> Bool)
-> (DIDerivedType -> DIDerivedType -> DIDerivedType)
-> (DIDerivedType -> DIDerivedType -> DIDerivedType)
-> Ord DIDerivedType
DIDerivedType -> DIDerivedType -> Bool
DIDerivedType -> DIDerivedType -> Ordering
DIDerivedType -> DIDerivedType -> DIDerivedType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DIDerivedType -> DIDerivedType -> DIDerivedType
$cmin :: DIDerivedType -> DIDerivedType -> DIDerivedType
max :: DIDerivedType -> DIDerivedType -> DIDerivedType
$cmax :: DIDerivedType -> DIDerivedType -> DIDerivedType
>= :: DIDerivedType -> DIDerivedType -> Bool
$c>= :: DIDerivedType -> DIDerivedType -> Bool
> :: DIDerivedType -> DIDerivedType -> Bool
$c> :: DIDerivedType -> DIDerivedType -> Bool
<= :: DIDerivedType -> DIDerivedType -> Bool
$c<= :: DIDerivedType -> DIDerivedType -> Bool
< :: DIDerivedType -> DIDerivedType -> Bool
$c< :: DIDerivedType -> DIDerivedType -> Bool
compare :: DIDerivedType -> DIDerivedType -> Ordering
$ccompare :: DIDerivedType -> DIDerivedType -> Ordering
$cp1Ord :: Eq DIDerivedType
Ord, ReadPrec [DIDerivedType]
ReadPrec DIDerivedType
Int -> ReadS DIDerivedType
ReadS [DIDerivedType]
(Int -> ReadS DIDerivedType)
-> ReadS [DIDerivedType]
-> ReadPrec DIDerivedType
-> ReadPrec [DIDerivedType]
-> Read DIDerivedType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DIDerivedType]
$creadListPrec :: ReadPrec [DIDerivedType]
readPrec :: ReadPrec DIDerivedType
$creadPrec :: ReadPrec DIDerivedType
readList :: ReadS [DIDerivedType]
$creadList :: ReadS [DIDerivedType]
readsPrec :: Int -> ReadS DIDerivedType
$creadsPrec :: Int -> ReadS DIDerivedType
Read, Int -> DIDerivedType -> ShowS
[DIDerivedType] -> ShowS
DIDerivedType -> String
(Int -> DIDerivedType -> ShowS)
-> (DIDerivedType -> String)
-> ([DIDerivedType] -> ShowS)
-> Show DIDerivedType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DIDerivedType] -> ShowS
$cshowList :: [DIDerivedType] -> ShowS
show :: DIDerivedType -> String
$cshow :: DIDerivedType -> String
showsPrec :: Int -> DIDerivedType -> ShowS
$cshowsPrec :: Int -> DIDerivedType -> ShowS
Show, Typeable, Typeable DIDerivedType
DataType
Constr
Typeable DIDerivedType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIDerivedType -> c DIDerivedType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIDerivedType)
-> (DIDerivedType -> Constr)
-> (DIDerivedType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIDerivedType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIDerivedType))
-> ((forall b. Data b => b -> b) -> DIDerivedType -> DIDerivedType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIDerivedType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIDerivedType -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIDerivedType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIDerivedType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType)
-> Data DIDerivedType
DIDerivedType -> DataType
DIDerivedType -> Constr
(forall b. Data b => b -> b) -> DIDerivedType -> DIDerivedType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIDerivedType -> c DIDerivedType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIDerivedType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DIDerivedType -> u
forall u. (forall d. Data d => d -> u) -> DIDerivedType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIDerivedType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIDerivedType -> c DIDerivedType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIDerivedType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIDerivedType)
$cDerivedType :: Constr
$tDIDerivedType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType
gmapMp :: (forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType
gmapM :: (forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType
gmapQi :: Int -> (forall d. Data d => d -> u) -> DIDerivedType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIDerivedType -> u
gmapQ :: (forall d. Data d => d -> u) -> DIDerivedType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIDerivedType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType -> r
gmapT :: (forall b. Data b => b -> b) -> DIDerivedType -> DIDerivedType
$cgmapT :: (forall b. Data b => b -> b) -> DIDerivedType -> DIDerivedType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIDerivedType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIDerivedType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DIDerivedType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIDerivedType)
dataTypeOf :: DIDerivedType -> DataType
$cdataTypeOf :: DIDerivedType -> DataType
toConstr :: DIDerivedType -> Constr
$ctoConstr :: DIDerivedType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIDerivedType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIDerivedType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIDerivedType -> c DIDerivedType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIDerivedType -> c DIDerivedType
$cp1Data :: Typeable DIDerivedType
Data, (forall x. DIDerivedType -> Rep DIDerivedType x)
-> (forall x. Rep DIDerivedType x -> DIDerivedType)
-> Generic DIDerivedType
forall x. Rep DIDerivedType x -> DIDerivedType
forall x. DIDerivedType -> Rep DIDerivedType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DIDerivedType x -> DIDerivedType
$cfrom :: forall x. DIDerivedType -> Rep DIDerivedType x
Generic)

-- | <https://llvm.org/docs/LangRef.html#dicompositetype>
data DICompositeType
  = DIArrayType
    { DICompositeType -> [DISubrange]
subscripts :: [DISubrange]
    , DICompositeType -> Maybe (MDRef DIType)
elementTy :: Maybe (MDRef DIType)
    , DICompositeType -> Word64
sizeInBits :: Word64
    , DICompositeType -> Word32
alignInBits :: Word32
    , DICompositeType -> [DIFlag]
flags :: [DIFlag]
    }
  | DIClassType
    { DICompositeType -> Maybe (MDRef DIScope)
scope :: Maybe (MDRef DIScope)
    , DICompositeType -> ShortByteString
name :: ShortByteString
    , DICompositeType -> Maybe (MDRef DIFile)
file :: Maybe (MDRef DIFile)
    , DICompositeType -> Word32
line :: Word32
    , flags :: [DIFlag]
    , DICompositeType -> Maybe (MDRef DIType)
derivedFrom :: Maybe (MDRef DIType)
    , DICompositeType -> [MDRef (Either DIDerivedType DISubprogram)]
elements :: [MDRef (Either DIDerivedType DISubprogram)]
    -- ^ `DIDerivedType` with tag set to one of `Member`, `Inheritance`, `Friend`
    -- or `DISubprogram` with `definition` set to `True`.
    , DICompositeType -> Maybe (MDRef DIType)
vtableHolder :: Maybe (MDRef DIType)
    , DICompositeType -> [DITemplateParameter]
templateParams :: [DITemplateParameter]
    , DICompositeType -> ShortByteString
identifier :: ShortByteString
    , sizeInBits :: Word64
    , alignInBits :: Word32
    }
  | DIEnumerationType
    { scope :: Maybe (MDRef DIScope)
    , name :: ShortByteString
    , file :: Maybe (MDRef DIFile)
    , line :: Word32
    , DICompositeType -> [DIEnumerator]
values :: [DIEnumerator]
    , DICompositeType -> Maybe (MDRef DIType)
baseType :: Maybe (MDRef DIType)
    , identifier :: ShortByteString
    , sizeInBits :: Word64
    , alignInBits :: Word32
    }
  | DIStructureType
    { scope :: Maybe (MDRef DIScope)
    , name :: ShortByteString
    , file :: Maybe (MDRef DIFile)
    , line :: Word32
    , flags :: [DIFlag]
    , derivedFrom :: Maybe (MDRef DIType)
    , elements :: [MDRef (Either DIDerivedType DISubprogram)]
    -- ^ `DIDerivedType` with tag set to one of `Member`, `Inheritance`, `Friend`
    -- or `DISubprogram` with `definition` set to `True`.
    , DICompositeType -> Word16
runtimeLang :: Word16
    , vtableHolder :: Maybe (MDRef DIType)
    , identifier :: ShortByteString
    , sizeInBits :: Word64
    , alignInBits :: Word32
    }
  | DIUnionType
    { scope :: Maybe (MDRef DIScope)
    , name :: ShortByteString
    , file :: Maybe (MDRef DIFile)
    , line :: Word32
    , flags :: [DIFlag]
    , elements :: [MDRef (Either DIDerivedType DISubprogram)]
    -- ^ `DIDerivedType` with tag set to one of `Member`, `Inheritance`, `Friend`
    -- or `DISubprogram` with `definition` set to `True`.
    , runtimeLang :: Word16
    , identifier :: ShortByteString
    , sizeInBits :: Word64
    , alignInBits :: Word32
    }
  deriving (DICompositeType -> DICompositeType -> Bool
(DICompositeType -> DICompositeType -> Bool)
-> (DICompositeType -> DICompositeType -> Bool)
-> Eq DICompositeType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DICompositeType -> DICompositeType -> Bool
$c/= :: DICompositeType -> DICompositeType -> Bool
== :: DICompositeType -> DICompositeType -> Bool
$c== :: DICompositeType -> DICompositeType -> Bool
Eq, Eq DICompositeType
Eq DICompositeType =>
(DICompositeType -> DICompositeType -> Ordering)
-> (DICompositeType -> DICompositeType -> Bool)
-> (DICompositeType -> DICompositeType -> Bool)
-> (DICompositeType -> DICompositeType -> Bool)
-> (DICompositeType -> DICompositeType -> Bool)
-> (DICompositeType -> DICompositeType -> DICompositeType)
-> (DICompositeType -> DICompositeType -> DICompositeType)
-> Ord DICompositeType
DICompositeType -> DICompositeType -> Bool
DICompositeType -> DICompositeType -> Ordering
DICompositeType -> DICompositeType -> DICompositeType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DICompositeType -> DICompositeType -> DICompositeType
$cmin :: DICompositeType -> DICompositeType -> DICompositeType
max :: DICompositeType -> DICompositeType -> DICompositeType
$cmax :: DICompositeType -> DICompositeType -> DICompositeType
>= :: DICompositeType -> DICompositeType -> Bool
$c>= :: DICompositeType -> DICompositeType -> Bool
> :: DICompositeType -> DICompositeType -> Bool
$c> :: DICompositeType -> DICompositeType -> Bool
<= :: DICompositeType -> DICompositeType -> Bool
$c<= :: DICompositeType -> DICompositeType -> Bool
< :: DICompositeType -> DICompositeType -> Bool
$c< :: DICompositeType -> DICompositeType -> Bool
compare :: DICompositeType -> DICompositeType -> Ordering
$ccompare :: DICompositeType -> DICompositeType -> Ordering
$cp1Ord :: Eq DICompositeType
Ord, ReadPrec [DICompositeType]
ReadPrec DICompositeType
Int -> ReadS DICompositeType
ReadS [DICompositeType]
(Int -> ReadS DICompositeType)
-> ReadS [DICompositeType]
-> ReadPrec DICompositeType
-> ReadPrec [DICompositeType]
-> Read DICompositeType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DICompositeType]
$creadListPrec :: ReadPrec [DICompositeType]
readPrec :: ReadPrec DICompositeType
$creadPrec :: ReadPrec DICompositeType
readList :: ReadS [DICompositeType]
$creadList :: ReadS [DICompositeType]
readsPrec :: Int -> ReadS DICompositeType
$creadsPrec :: Int -> ReadS DICompositeType
Read, Int -> DICompositeType -> ShowS
[DICompositeType] -> ShowS
DICompositeType -> String
(Int -> DICompositeType -> ShowS)
-> (DICompositeType -> String)
-> ([DICompositeType] -> ShowS)
-> Show DICompositeType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DICompositeType] -> ShowS
$cshowList :: [DICompositeType] -> ShowS
show :: DICompositeType -> String
$cshow :: DICompositeType -> String
showsPrec :: Int -> DICompositeType -> ShowS
$cshowsPrec :: Int -> DICompositeType -> ShowS
Show, Typeable, Typeable DICompositeType
DataType
Constr
Typeable DICompositeType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DICompositeType -> c DICompositeType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DICompositeType)
-> (DICompositeType -> Constr)
-> (DICompositeType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DICompositeType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DICompositeType))
-> ((forall b. Data b => b -> b)
    -> DICompositeType -> DICompositeType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DICompositeType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DICompositeType -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DICompositeType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DICompositeType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DICompositeType -> m DICompositeType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DICompositeType -> m DICompositeType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DICompositeType -> m DICompositeType)
-> Data DICompositeType
DICompositeType -> DataType
DICompositeType -> Constr
(forall b. Data b => b -> b) -> DICompositeType -> DICompositeType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICompositeType -> c DICompositeType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICompositeType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DICompositeType -> u
forall u. (forall d. Data d => d -> u) -> DICompositeType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DICompositeType -> m DICompositeType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DICompositeType -> m DICompositeType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICompositeType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICompositeType -> c DICompositeType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DICompositeType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DICompositeType)
$cDIUnionType :: Constr
$cDIStructureType :: Constr
$cDIEnumerationType :: Constr
$cDIClassType :: Constr
$cDIArrayType :: Constr
$tDICompositeType :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> DICompositeType -> m DICompositeType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DICompositeType -> m DICompositeType
gmapMp :: (forall d. Data d => d -> m d)
-> DICompositeType -> m DICompositeType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DICompositeType -> m DICompositeType
gmapM :: (forall d. Data d => d -> m d)
-> DICompositeType -> m DICompositeType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DICompositeType -> m DICompositeType
gmapQi :: Int -> (forall d. Data d => d -> u) -> DICompositeType -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DICompositeType -> u
gmapQ :: (forall d. Data d => d -> u) -> DICompositeType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DICompositeType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType -> r
gmapT :: (forall b. Data b => b -> b) -> DICompositeType -> DICompositeType
$cgmapT :: (forall b. Data b => b -> b) -> DICompositeType -> DICompositeType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DICompositeType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DICompositeType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DICompositeType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DICompositeType)
dataTypeOf :: DICompositeType -> DataType
$cdataTypeOf :: DICompositeType -> DataType
toConstr :: DICompositeType -> Constr
$ctoConstr :: DICompositeType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICompositeType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICompositeType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICompositeType -> c DICompositeType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICompositeType -> c DICompositeType
$cp1Data :: Typeable DICompositeType
Data, (forall x. DICompositeType -> Rep DICompositeType x)
-> (forall x. Rep DICompositeType x -> DICompositeType)
-> Generic DICompositeType
forall x. Rep DICompositeType x -> DICompositeType
forall x. DICompositeType -> Rep DICompositeType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DICompositeType x -> DICompositeType
$cfrom :: forall x. DICompositeType -> Rep DICompositeType x
Generic)

data Encoding
  = AddressEncoding
  | BooleanEncoding
  | FloatEncoding
  | SignedEncoding
  | SignedCharEncoding
  | UnsignedEncoding
  | UnsignedCharEncoding
  | UTFEncoding
  deriving (Encoding -> Encoding -> Bool
(Encoding -> Encoding -> Bool)
-> (Encoding -> Encoding -> Bool) -> Eq Encoding
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Encoding -> Encoding -> Bool
$c/= :: Encoding -> Encoding -> Bool
== :: Encoding -> Encoding -> Bool
$c== :: Encoding -> Encoding -> Bool
Eq, Eq Encoding
Eq Encoding =>
(Encoding -> Encoding -> Ordering)
-> (Encoding -> Encoding -> Bool)
-> (Encoding -> Encoding -> Bool)
-> (Encoding -> Encoding -> Bool)
-> (Encoding -> Encoding -> Bool)
-> (Encoding -> Encoding -> Encoding)
-> (Encoding -> Encoding -> Encoding)
-> Ord Encoding
Encoding -> Encoding -> Bool
Encoding -> Encoding -> Ordering
Encoding -> Encoding -> Encoding
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Encoding -> Encoding -> Encoding
$cmin :: Encoding -> Encoding -> Encoding
max :: Encoding -> Encoding -> Encoding
$cmax :: Encoding -> Encoding -> Encoding
>= :: Encoding -> Encoding -> Bool
$c>= :: Encoding -> Encoding -> Bool
> :: Encoding -> Encoding -> Bool
$c> :: Encoding -> Encoding -> Bool
<= :: Encoding -> Encoding -> Bool
$c<= :: Encoding -> Encoding -> Bool
< :: Encoding -> Encoding -> Bool
$c< :: Encoding -> Encoding -> Bool
compare :: Encoding -> Encoding -> Ordering
$ccompare :: Encoding -> Encoding -> Ordering
$cp1Ord :: Eq Encoding
Ord, ReadPrec [Encoding]
ReadPrec Encoding
Int -> ReadS Encoding
ReadS [Encoding]
(Int -> ReadS Encoding)
-> ReadS [Encoding]
-> ReadPrec Encoding
-> ReadPrec [Encoding]
-> Read Encoding
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Encoding]
$creadListPrec :: ReadPrec [Encoding]
readPrec :: ReadPrec Encoding
$creadPrec :: ReadPrec Encoding
readList :: ReadS [Encoding]
$creadList :: ReadS [Encoding]
readsPrec :: Int -> ReadS Encoding
$creadsPrec :: Int -> ReadS Encoding
Read, Int -> Encoding -> ShowS
[Encoding] -> ShowS
Encoding -> String
(Int -> Encoding -> ShowS)
-> (Encoding -> String) -> ([Encoding] -> ShowS) -> Show Encoding
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Encoding] -> ShowS
$cshowList :: [Encoding] -> ShowS
show :: Encoding -> String
$cshow :: Encoding -> String
showsPrec :: Int -> Encoding -> ShowS
$cshowsPrec :: Int -> Encoding -> ShowS
Show, Typeable, Typeable Encoding
DataType
Constr
Typeable Encoding =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Encoding -> c Encoding)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Encoding)
-> (Encoding -> Constr)
-> (Encoding -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Encoding))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Encoding))
-> ((forall b. Data b => b -> b) -> Encoding -> Encoding)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Encoding -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Encoding -> r)
-> (forall u. (forall d. Data d => d -> u) -> Encoding -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Encoding -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Encoding -> m Encoding)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Encoding -> m Encoding)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Encoding -> m Encoding)
-> Data Encoding
Encoding -> DataType
Encoding -> Constr
(forall b. Data b => b -> b) -> Encoding -> Encoding
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Encoding -> c Encoding
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Encoding
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Encoding -> u
forall u. (forall d. Data d => d -> u) -> Encoding -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Encoding -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Encoding -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Encoding -> m Encoding
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Encoding -> m Encoding
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Encoding
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Encoding -> c Encoding
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Encoding)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Encoding)
$cUTFEncoding :: Constr
$cUnsignedCharEncoding :: Constr
$cUnsignedEncoding :: Constr
$cSignedCharEncoding :: Constr
$cSignedEncoding :: Constr
$cFloatEncoding :: Constr
$cBooleanEncoding :: Constr
$cAddressEncoding :: Constr
$tEncoding :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Encoding -> m Encoding
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Encoding -> m Encoding
gmapMp :: (forall d. Data d => d -> m d) -> Encoding -> m Encoding
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Encoding -> m Encoding
gmapM :: (forall d. Data d => d -> m d) -> Encoding -> m Encoding
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Encoding -> m Encoding
gmapQi :: Int -> (forall d. Data d => d -> u) -> Encoding -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Encoding -> u
gmapQ :: (forall d. Data d => d -> u) -> Encoding -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Encoding -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Encoding -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Encoding -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Encoding -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Encoding -> r
gmapT :: (forall b. Data b => b -> b) -> Encoding -> Encoding
$cgmapT :: (forall b. Data b => b -> b) -> Encoding -> Encoding
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Encoding)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Encoding)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Encoding)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Encoding)
dataTypeOf :: Encoding -> DataType
$cdataTypeOf :: Encoding -> DataType
toConstr :: Encoding -> Constr
$ctoConstr :: Encoding -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Encoding
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Encoding
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Encoding -> c Encoding
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Encoding -> c Encoding
$cp1Data :: Typeable Encoding
Data, (forall x. Encoding -> Rep Encoding x)
-> (forall x. Rep Encoding x -> Encoding) -> Generic Encoding
forall x. Rep Encoding x -> Encoding
forall x. Encoding -> Rep Encoding x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Encoding x -> Encoding
$cfrom :: forall x. Encoding -> Rep Encoding x
Generic)

data TemplateValueParameterTag
  = TemplateValueParameter
  | GNUTemplateTemplateParam
  | GNUTemplateParameterPack
  deriving (TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
(TemplateValueParameterTag -> TemplateValueParameterTag -> Bool)
-> (TemplateValueParameterTag -> TemplateValueParameterTag -> Bool)
-> Eq TemplateValueParameterTag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
$c/= :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
== :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
$c== :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
Eq, Eq TemplateValueParameterTag
Eq TemplateValueParameterTag =>
(TemplateValueParameterTag
 -> TemplateValueParameterTag -> Ordering)
-> (TemplateValueParameterTag -> TemplateValueParameterTag -> Bool)
-> (TemplateValueParameterTag -> TemplateValueParameterTag -> Bool)
-> (TemplateValueParameterTag -> TemplateValueParameterTag -> Bool)
-> (TemplateValueParameterTag -> TemplateValueParameterTag -> Bool)
-> (TemplateValueParameterTag
    -> TemplateValueParameterTag -> TemplateValueParameterTag)
-> (TemplateValueParameterTag
    -> TemplateValueParameterTag -> TemplateValueParameterTag)
-> Ord TemplateValueParameterTag
TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
TemplateValueParameterTag -> TemplateValueParameterTag -> Ordering
TemplateValueParameterTag
-> TemplateValueParameterTag -> TemplateValueParameterTag
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TemplateValueParameterTag
-> TemplateValueParameterTag -> TemplateValueParameterTag
$cmin :: TemplateValueParameterTag
-> TemplateValueParameterTag -> TemplateValueParameterTag
max :: TemplateValueParameterTag
-> TemplateValueParameterTag -> TemplateValueParameterTag
$cmax :: TemplateValueParameterTag
-> TemplateValueParameterTag -> TemplateValueParameterTag
>= :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
$c>= :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
> :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
$c> :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
<= :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
$c<= :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
< :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
$c< :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
compare :: TemplateValueParameterTag -> TemplateValueParameterTag -> Ordering
$ccompare :: TemplateValueParameterTag -> TemplateValueParameterTag -> Ordering
$cp1Ord :: Eq TemplateValueParameterTag
Ord, ReadPrec [TemplateValueParameterTag]
ReadPrec TemplateValueParameterTag
Int -> ReadS TemplateValueParameterTag
ReadS [TemplateValueParameterTag]
(Int -> ReadS TemplateValueParameterTag)
-> ReadS [TemplateValueParameterTag]
-> ReadPrec TemplateValueParameterTag
-> ReadPrec [TemplateValueParameterTag]
-> Read TemplateValueParameterTag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TemplateValueParameterTag]
$creadListPrec :: ReadPrec [TemplateValueParameterTag]
readPrec :: ReadPrec TemplateValueParameterTag
$creadPrec :: ReadPrec TemplateValueParameterTag
readList :: ReadS [TemplateValueParameterTag]
$creadList :: ReadS [TemplateValueParameterTag]
readsPrec :: Int -> ReadS TemplateValueParameterTag
$creadsPrec :: Int -> ReadS TemplateValueParameterTag
Read, Int -> TemplateValueParameterTag -> ShowS
[TemplateValueParameterTag] -> ShowS
TemplateValueParameterTag -> String
(Int -> TemplateValueParameterTag -> ShowS)
-> (TemplateValueParameterTag -> String)
-> ([TemplateValueParameterTag] -> ShowS)
-> Show TemplateValueParameterTag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TemplateValueParameterTag] -> ShowS
$cshowList :: [TemplateValueParameterTag] -> ShowS
show :: TemplateValueParameterTag -> String
$cshow :: TemplateValueParameterTag -> String
showsPrec :: Int -> TemplateValueParameterTag -> ShowS
$cshowsPrec :: Int -> TemplateValueParameterTag -> ShowS
Show, Typeable, Typeable TemplateValueParameterTag
DataType
Constr
Typeable TemplateValueParameterTag =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> TemplateValueParameterTag
 -> c TemplateValueParameterTag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TemplateValueParameterTag)
-> (TemplateValueParameterTag -> Constr)
-> (TemplateValueParameterTag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c TemplateValueParameterTag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TemplateValueParameterTag))
-> ((forall b. Data b => b -> b)
    -> TemplateValueParameterTag -> TemplateValueParameterTag)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> TemplateValueParameterTag
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> TemplateValueParameterTag
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> TemplateValueParameterTag -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u) -> TemplateValueParameterTag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TemplateValueParameterTag -> m TemplateValueParameterTag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TemplateValueParameterTag -> m TemplateValueParameterTag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TemplateValueParameterTag -> m TemplateValueParameterTag)
-> Data TemplateValueParameterTag
TemplateValueParameterTag -> DataType
TemplateValueParameterTag -> Constr
(forall b. Data b => b -> b)
-> TemplateValueParameterTag -> TemplateValueParameterTag
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TemplateValueParameterTag
-> c TemplateValueParameterTag
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TemplateValueParameterTag
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int
-> (forall d. Data d => d -> u) -> TemplateValueParameterTag -> u
forall u.
(forall d. Data d => d -> u) -> TemplateValueParameterTag -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> TemplateValueParameterTag
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> TemplateValueParameterTag
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TemplateValueParameterTag -> m TemplateValueParameterTag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TemplateValueParameterTag -> m TemplateValueParameterTag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TemplateValueParameterTag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TemplateValueParameterTag
-> c TemplateValueParameterTag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c TemplateValueParameterTag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TemplateValueParameterTag)
$cGNUTemplateParameterPack :: Constr
$cGNUTemplateTemplateParam :: Constr
$cTemplateValueParameter :: Constr
$tTemplateValueParameterTag :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> TemplateValueParameterTag -> m TemplateValueParameterTag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TemplateValueParameterTag -> m TemplateValueParameterTag
gmapMp :: (forall d. Data d => d -> m d)
-> TemplateValueParameterTag -> m TemplateValueParameterTag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TemplateValueParameterTag -> m TemplateValueParameterTag
gmapM :: (forall d. Data d => d -> m d)
-> TemplateValueParameterTag -> m TemplateValueParameterTag
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TemplateValueParameterTag -> m TemplateValueParameterTag
gmapQi :: Int
-> (forall d. Data d => d -> u) -> TemplateValueParameterTag -> u
$cgmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> TemplateValueParameterTag -> u
gmapQ :: (forall d. Data d => d -> u) -> TemplateValueParameterTag -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> TemplateValueParameterTag -> [u]
gmapQr :: (r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> TemplateValueParameterTag
-> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> TemplateValueParameterTag
-> r
gmapQl :: (r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> TemplateValueParameterTag
-> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> TemplateValueParameterTag
-> r
gmapT :: (forall b. Data b => b -> b)
-> TemplateValueParameterTag -> TemplateValueParameterTag
$cgmapT :: (forall b. Data b => b -> b)
-> TemplateValueParameterTag -> TemplateValueParameterTag
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TemplateValueParameterTag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TemplateValueParameterTag)
dataCast1 :: (forall d. Data d => c (t d))
-> Maybe (c TemplateValueParameterTag)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c TemplateValueParameterTag)
dataTypeOf :: TemplateValueParameterTag -> DataType
$cdataTypeOf :: TemplateValueParameterTag -> DataType
toConstr :: TemplateValueParameterTag -> Constr
$ctoConstr :: TemplateValueParameterTag -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TemplateValueParameterTag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TemplateValueParameterTag
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TemplateValueParameterTag
-> c TemplateValueParameterTag
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TemplateValueParameterTag
-> c TemplateValueParameterTag
$cp1Data :: Typeable TemplateValueParameterTag
Data, (forall x.
 TemplateValueParameterTag -> Rep TemplateValueParameterTag x)
-> (forall x.
    Rep TemplateValueParameterTag x -> TemplateValueParameterTag)
-> Generic TemplateValueParameterTag
forall x.
Rep TemplateValueParameterTag x -> TemplateValueParameterTag
forall x.
TemplateValueParameterTag -> Rep TemplateValueParameterTag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep TemplateValueParameterTag x -> TemplateValueParameterTag
$cfrom :: forall x.
TemplateValueParameterTag -> Rep TemplateValueParameterTag x
Generic)

-- | <https://llvm.org/doxygen/classllvm_1_1DITemplateParameter.html>
data DITemplateParameter
  = DITemplateTypeParameter
    { DITemplateParameter -> ShortByteString
name :: ShortByteString
    , DITemplateParameter -> Maybe (MDRef DIType)
type' :: Maybe (MDRef DIType)
    -- ^ For DITemplateTypeParameter this field is required,
    -- for DITemplateValueParameter it is optional.
    }
  -- ^ <https://llvm.org/docs/LangRef.html#ditemplatetypeparameter>
  | DITemplateValueParameter
    { name :: ShortByteString
    , type' :: Maybe (MDRef DIType)
    , DITemplateParameter -> Maybe Metadata
value :: Maybe Metadata
    , DITemplateParameter -> TemplateValueParameterTag
tag :: TemplateValueParameterTag
    }
  -- ^ <https://llvm.org/docs/LangRef.html#ditemplatevalueparameter>
  deriving (DITemplateParameter -> DITemplateParameter -> Bool
(DITemplateParameter -> DITemplateParameter -> Bool)
-> (DITemplateParameter -> DITemplateParameter -> Bool)
-> Eq DITemplateParameter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DITemplateParameter -> DITemplateParameter -> Bool
$c/= :: DITemplateParameter -> DITemplateParameter -> Bool
== :: DITemplateParameter -> DITemplateParameter -> Bool
$c== :: DITemplateParameter -> DITemplateParameter -> Bool
Eq, Eq DITemplateParameter
Eq DITemplateParameter =>
(DITemplateParameter -> DITemplateParameter -> Ordering)
-> (DITemplateParameter -> DITemplateParameter -> Bool)
-> (DITemplateParameter -> DITemplateParameter -> Bool)
-> (DITemplateParameter -> DITemplateParameter -> Bool)
-> (DITemplateParameter -> DITemplateParameter -> Bool)
-> (DITemplateParameter
    -> DITemplateParameter -> DITemplateParameter)
-> (DITemplateParameter
    -> DITemplateParameter -> DITemplateParameter)
-> Ord DITemplateParameter
DITemplateParameter -> DITemplateParameter -> Bool
DITemplateParameter -> DITemplateParameter -> Ordering
DITemplateParameter -> DITemplateParameter -> DITemplateParameter
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DITemplateParameter -> DITemplateParameter -> DITemplateParameter
$cmin :: DITemplateParameter -> DITemplateParameter -> DITemplateParameter
max :: DITemplateParameter -> DITemplateParameter -> DITemplateParameter
$cmax :: DITemplateParameter -> DITemplateParameter -> DITemplateParameter
>= :: DITemplateParameter -> DITemplateParameter -> Bool
$c>= :: DITemplateParameter -> DITemplateParameter -> Bool
> :: DITemplateParameter -> DITemplateParameter -> Bool
$c> :: DITemplateParameter -> DITemplateParameter -> Bool
<= :: DITemplateParameter -> DITemplateParameter -> Bool
$c<= :: DITemplateParameter -> DITemplateParameter -> Bool
< :: DITemplateParameter -> DITemplateParameter -> Bool
$c< :: DITemplateParameter -> DITemplateParameter -> Bool
compare :: DITemplateParameter -> DITemplateParameter -> Ordering
$ccompare :: DITemplateParameter -> DITemplateParameter -> Ordering
$cp1Ord :: Eq DITemplateParameter
Ord, ReadPrec [DITemplateParameter]
ReadPrec DITemplateParameter
Int -> ReadS DITemplateParameter
ReadS [DITemplateParameter]
(Int -> ReadS DITemplateParameter)
-> ReadS [DITemplateParameter]
-> ReadPrec DITemplateParameter
-> ReadPrec [DITemplateParameter]
-> Read DITemplateParameter
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DITemplateParameter]
$creadListPrec :: ReadPrec [DITemplateParameter]
readPrec :: ReadPrec DITemplateParameter
$creadPrec :: ReadPrec DITemplateParameter
readList :: ReadS [DITemplateParameter]
$creadList :: ReadS [DITemplateParameter]
readsPrec :: Int -> ReadS DITemplateParameter
$creadsPrec :: Int -> ReadS DITemplateParameter
Read, Int -> DITemplateParameter -> ShowS
[DITemplateParameter] -> ShowS
DITemplateParameter -> String
(Int -> DITemplateParameter -> ShowS)
-> (DITemplateParameter -> String)
-> ([DITemplateParameter] -> ShowS)
-> Show DITemplateParameter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DITemplateParameter] -> ShowS
$cshowList :: [DITemplateParameter] -> ShowS
show :: DITemplateParameter -> String
$cshow :: DITemplateParameter -> String
showsPrec :: Int -> DITemplateParameter -> ShowS
$cshowsPrec :: Int -> DITemplateParameter -> ShowS
Show, Typeable, Typeable DITemplateParameter
DataType
Constr
Typeable DITemplateParameter =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DITemplateParameter
 -> c DITemplateParameter)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DITemplateParameter)
-> (DITemplateParameter -> Constr)
-> (DITemplateParameter -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DITemplateParameter))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DITemplateParameter))
-> ((forall b. Data b => b -> b)
    -> DITemplateParameter -> DITemplateParameter)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DITemplateParameter -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DITemplateParameter -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DITemplateParameter -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DITemplateParameter -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DITemplateParameter -> m DITemplateParameter)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DITemplateParameter -> m DITemplateParameter)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DITemplateParameter -> m DITemplateParameter)
-> Data DITemplateParameter
DITemplateParameter -> DataType
DITemplateParameter -> Constr
(forall b. Data b => b -> b)
-> DITemplateParameter -> DITemplateParameter
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DITemplateParameter
-> c DITemplateParameter
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DITemplateParameter
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DITemplateParameter -> u
forall u.
(forall d. Data d => d -> u) -> DITemplateParameter -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DITemplateParameter -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DITemplateParameter -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DITemplateParameter -> m DITemplateParameter
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DITemplateParameter -> m DITemplateParameter
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DITemplateParameter
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DITemplateParameter
-> c DITemplateParameter
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DITemplateParameter)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DITemplateParameter)
$cDITemplateValueParameter :: Constr
$cDITemplateTypeParameter :: Constr
$tDITemplateParameter :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> DITemplateParameter -> m DITemplateParameter
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DITemplateParameter -> m DITemplateParameter
gmapMp :: (forall d. Data d => d -> m d)
-> DITemplateParameter -> m DITemplateParameter
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DITemplateParameter -> m DITemplateParameter
gmapM :: (forall d. Data d => d -> m d)
-> DITemplateParameter -> m DITemplateParameter
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DITemplateParameter -> m DITemplateParameter
gmapQi :: Int -> (forall d. Data d => d -> u) -> DITemplateParameter -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DITemplateParameter -> u
gmapQ :: (forall d. Data d => d -> u) -> DITemplateParameter -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> DITemplateParameter -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DITemplateParameter -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DITemplateParameter -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DITemplateParameter -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DITemplateParameter -> r
gmapT :: (forall b. Data b => b -> b)
-> DITemplateParameter -> DITemplateParameter
$cgmapT :: (forall b. Data b => b -> b)
-> DITemplateParameter -> DITemplateParameter
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DITemplateParameter)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DITemplateParameter)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DITemplateParameter)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DITemplateParameter)
dataTypeOf :: DITemplateParameter -> DataType
$cdataTypeOf :: DITemplateParameter -> DataType
toConstr :: DITemplateParameter -> Constr
$ctoConstr :: DITemplateParameter -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DITemplateParameter
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DITemplateParameter
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DITemplateParameter
-> c DITemplateParameter
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DITemplateParameter
-> c DITemplateParameter
$cp1Data :: Typeable DITemplateParameter
Data, (forall x. DITemplateParameter -> Rep DITemplateParameter x)
-> (forall x. Rep DITemplateParameter x -> DITemplateParameter)
-> Generic DITemplateParameter
forall x. Rep DITemplateParameter x -> DITemplateParameter
forall x. DITemplateParameter -> Rep DITemplateParameter x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DITemplateParameter x -> DITemplateParameter
$cfrom :: forall x. DITemplateParameter -> Rep DITemplateParameter x
Generic)

-- | <https://llvm.org/doxygen/classllvm_1_1DILexicalBlockBase.html>
data DILexicalBlockBase
  = DILexicalBlock
    { DILexicalBlockBase -> MDRef DILocalScope
scope :: MDRef DILocalScope
    , DILexicalBlockBase -> Maybe (MDRef DIFile)
file :: Maybe (MDRef DIFile)
    , DILexicalBlockBase -> Word32
line :: Word32
    , DILexicalBlockBase -> Word16
column :: Word16
    }
  -- ^ <https://llvm.org/docs/LangRef.html#dilexicalblock>
  | DILexicalBlockFile
    { scope :: MDRef DILocalScope
    , file :: Maybe (MDRef DIFile)
    , DILexicalBlockBase -> Word32
discriminator :: Word32
    }
  -- ^ <https://llvm.org/docs/LangRef.html#dilexicalblockfile>
  deriving (DILexicalBlockBase -> DILexicalBlockBase -> Bool
(DILexicalBlockBase -> DILexicalBlockBase -> Bool)
-> (DILexicalBlockBase -> DILexicalBlockBase -> Bool)
-> Eq DILexicalBlockBase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
$c/= :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
== :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
$c== :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
Eq, Eq DILexicalBlockBase
Eq DILexicalBlockBase =>
(DILexicalBlockBase -> DILexicalBlockBase -> Ordering)
-> (DILexicalBlockBase -> DILexicalBlockBase -> Bool)
-> (DILexicalBlockBase -> DILexicalBlockBase -> Bool)
-> (DILexicalBlockBase -> DILexicalBlockBase -> Bool)
-> (DILexicalBlockBase -> DILexicalBlockBase -> Bool)
-> (DILexicalBlockBase -> DILexicalBlockBase -> DILexicalBlockBase)
-> (DILexicalBlockBase -> DILexicalBlockBase -> DILexicalBlockBase)
-> Ord DILexicalBlockBase
DILexicalBlockBase -> DILexicalBlockBase -> Bool
DILexicalBlockBase -> DILexicalBlockBase -> Ordering
DILexicalBlockBase -> DILexicalBlockBase -> DILexicalBlockBase
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DILexicalBlockBase -> DILexicalBlockBase -> DILexicalBlockBase
$cmin :: DILexicalBlockBase -> DILexicalBlockBase -> DILexicalBlockBase
max :: DILexicalBlockBase -> DILexicalBlockBase -> DILexicalBlockBase
$cmax :: DILexicalBlockBase -> DILexicalBlockBase -> DILexicalBlockBase
>= :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
$c>= :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
> :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
$c> :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
<= :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
$c<= :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
< :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
$c< :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
compare :: DILexicalBlockBase -> DILexicalBlockBase -> Ordering
$ccompare :: DILexicalBlockBase -> DILexicalBlockBase -> Ordering
$cp1Ord :: Eq DILexicalBlockBase
Ord, ReadPrec [DILexicalBlockBase]
ReadPrec DILexicalBlockBase
Int -> ReadS DILexicalBlockBase
ReadS [DILexicalBlockBase]
(Int -> ReadS DILexicalBlockBase)
-> ReadS [DILexicalBlockBase]
-> ReadPrec DILexicalBlockBase
-> ReadPrec [DILexicalBlockBase]
-> Read DILexicalBlockBase
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DILexicalBlockBase]
$creadListPrec :: ReadPrec [DILexicalBlockBase]
readPrec :: ReadPrec DILexicalBlockBase
$creadPrec :: ReadPrec DILexicalBlockBase
readList :: ReadS [DILexicalBlockBase]
$creadList :: ReadS [DILexicalBlockBase]
readsPrec :: Int -> ReadS DILexicalBlockBase
$creadsPrec :: Int -> ReadS DILexicalBlockBase
Read, Int -> DILexicalBlockBase -> ShowS
[DILexicalBlockBase] -> ShowS
DILexicalBlockBase -> String
(Int -> DILexicalBlockBase -> ShowS)
-> (DILexicalBlockBase -> String)
-> ([DILexicalBlockBase] -> ShowS)
-> Show DILexicalBlockBase
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DILexicalBlockBase] -> ShowS
$cshowList :: [DILexicalBlockBase] -> ShowS
show :: DILexicalBlockBase -> String
$cshow :: DILexicalBlockBase -> String
showsPrec :: Int -> DILexicalBlockBase -> ShowS
$cshowsPrec :: Int -> DILexicalBlockBase -> ShowS
Show, Typeable, Typeable DILexicalBlockBase
DataType
Constr
Typeable DILexicalBlockBase =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DILexicalBlockBase
 -> c DILexicalBlockBase)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DILexicalBlockBase)
-> (DILexicalBlockBase -> Constr)
-> (DILexicalBlockBase -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DILexicalBlockBase))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DILexicalBlockBase))
-> ((forall b. Data b => b -> b)
    -> DILexicalBlockBase -> DILexicalBlockBase)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DILexicalBlockBase -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DILexicalBlockBase -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DILexicalBlockBase -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DILexicalBlockBase -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DILexicalBlockBase -> m DILexicalBlockBase)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DILexicalBlockBase -> m DILexicalBlockBase)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DILexicalBlockBase -> m DILexicalBlockBase)
-> Data DILexicalBlockBase
DILexicalBlockBase -> DataType
DILexicalBlockBase -> Constr
(forall b. Data b => b -> b)
-> DILexicalBlockBase -> DILexicalBlockBase
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILexicalBlockBase
-> c DILexicalBlockBase
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILexicalBlockBase
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DILexicalBlockBase -> u
forall u. (forall d. Data d => d -> u) -> DILexicalBlockBase -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlockBase -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlockBase -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DILexicalBlockBase -> m DILexicalBlockBase
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILexicalBlockBase -> m DILexicalBlockBase
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILexicalBlockBase
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILexicalBlockBase
-> c DILexicalBlockBase
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILexicalBlockBase)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DILexicalBlockBase)
$cDILexicalBlockFile :: Constr
$cDILexicalBlock :: Constr
$tDILexicalBlockBase :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> DILexicalBlockBase -> m DILexicalBlockBase
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILexicalBlockBase -> m DILexicalBlockBase
gmapMp :: (forall d. Data d => d -> m d)
-> DILexicalBlockBase -> m DILexicalBlockBase
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILexicalBlockBase -> m DILexicalBlockBase
gmapM :: (forall d. Data d => d -> m d)
-> DILexicalBlockBase -> m DILexicalBlockBase
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DILexicalBlockBase -> m DILexicalBlockBase
gmapQi :: Int -> (forall d. Data d => d -> u) -> DILexicalBlockBase -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DILexicalBlockBase -> u
gmapQ :: (forall d. Data d => d -> u) -> DILexicalBlockBase -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DILexicalBlockBase -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlockBase -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlockBase -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlockBase -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlockBase -> r
gmapT :: (forall b. Data b => b -> b)
-> DILexicalBlockBase -> DILexicalBlockBase
$cgmapT :: (forall b. Data b => b -> b)
-> DILexicalBlockBase -> DILexicalBlockBase
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DILexicalBlockBase)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DILexicalBlockBase)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DILexicalBlockBase)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILexicalBlockBase)
dataTypeOf :: DILexicalBlockBase -> DataType
$cdataTypeOf :: DILexicalBlockBase -> DataType
toConstr :: DILexicalBlockBase -> Constr
$ctoConstr :: DILexicalBlockBase -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILexicalBlockBase
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILexicalBlockBase
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILexicalBlockBase
-> c DILexicalBlockBase
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILexicalBlockBase
-> c DILexicalBlockBase
$cp1Data :: Typeable DILexicalBlockBase
Data, (forall x. DILexicalBlockBase -> Rep DILexicalBlockBase x)
-> (forall x. Rep DILexicalBlockBase x -> DILexicalBlockBase)
-> Generic DILexicalBlockBase
forall x. Rep DILexicalBlockBase x -> DILexicalBlockBase
forall x. DILexicalBlockBase -> Rep DILexicalBlockBase x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DILexicalBlockBase x -> DILexicalBlockBase
$cfrom :: forall x. DILexicalBlockBase -> Rep DILexicalBlockBase x
Generic)

-- | <https://llvm.org/doxygen/classllvm_1_1DIVariable.html>
data DIVariable
  = DIGlobalVariable DIGlobalVariable
  | DILocalVariable DILocalVariable
  deriving (DIVariable -> DIVariable -> Bool
(DIVariable -> DIVariable -> Bool)
-> (DIVariable -> DIVariable -> Bool) -> Eq DIVariable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIVariable -> DIVariable -> Bool
$c/= :: DIVariable -> DIVariable -> Bool
== :: DIVariable -> DIVariable -> Bool
$c== :: DIVariable -> DIVariable -> Bool
Eq, Eq DIVariable
Eq DIVariable =>
(DIVariable -> DIVariable -> Ordering)
-> (DIVariable -> DIVariable -> Bool)
-> (DIVariable -> DIVariable -> Bool)
-> (DIVariable -> DIVariable -> Bool)
-> (DIVariable -> DIVariable -> Bool)
-> (DIVariable -> DIVariable -> DIVariable)
-> (DIVariable -> DIVariable -> DIVariable)
-> Ord DIVariable
DIVariable -> DIVariable -> Bool
DIVariable -> DIVariable -> Ordering
DIVariable -> DIVariable -> DIVariable
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DIVariable -> DIVariable -> DIVariable
$cmin :: DIVariable -> DIVariable -> DIVariable
max :: DIVariable -> DIVariable -> DIVariable
$cmax :: DIVariable -> DIVariable -> DIVariable
>= :: DIVariable -> DIVariable -> Bool
$c>= :: DIVariable -> DIVariable -> Bool
> :: DIVariable -> DIVariable -> Bool
$c> :: DIVariable -> DIVariable -> Bool
<= :: DIVariable -> DIVariable -> Bool
$c<= :: DIVariable -> DIVariable -> Bool
< :: DIVariable -> DIVariable -> Bool
$c< :: DIVariable -> DIVariable -> Bool
compare :: DIVariable -> DIVariable -> Ordering
$ccompare :: DIVariable -> DIVariable -> Ordering
$cp1Ord :: Eq DIVariable
Ord, ReadPrec [DIVariable]
ReadPrec DIVariable
Int -> ReadS DIVariable
ReadS [DIVariable]
(Int -> ReadS DIVariable)
-> ReadS [DIVariable]
-> ReadPrec DIVariable
-> ReadPrec [DIVariable]
-> Read DIVariable
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DIVariable]
$creadListPrec :: ReadPrec [DIVariable]
readPrec :: ReadPrec DIVariable
$creadPrec :: ReadPrec DIVariable
readList :: ReadS [DIVariable]
$creadList :: ReadS [DIVariable]
readsPrec :: Int -> ReadS DIVariable
$creadsPrec :: Int -> ReadS DIVariable
Read, Int -> DIVariable -> ShowS
[DIVariable] -> ShowS
DIVariable -> String
(Int -> DIVariable -> ShowS)
-> (DIVariable -> String)
-> ([DIVariable] -> ShowS)
-> Show DIVariable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DIVariable] -> ShowS
$cshowList :: [DIVariable] -> ShowS
show :: DIVariable -> String
$cshow :: DIVariable -> String
showsPrec :: Int -> DIVariable -> ShowS
$cshowsPrec :: Int -> DIVariable -> ShowS
Show, Typeable, Typeable DIVariable
DataType
Constr
Typeable DIVariable =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIVariable -> c DIVariable)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIVariable)
-> (DIVariable -> Constr)
-> (DIVariable -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIVariable))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIVariable))
-> ((forall b. Data b => b -> b) -> DIVariable -> DIVariable)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIVariable -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIVariable -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIVariable -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIVariable -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIVariable -> m DIVariable)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIVariable -> m DIVariable)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIVariable -> m DIVariable)
-> Data DIVariable
DIVariable -> DataType
DIVariable -> Constr
(forall b. Data b => b -> b) -> DIVariable -> DIVariable
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIVariable -> c DIVariable
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIVariable
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DIVariable -> u
forall u. (forall d. Data d => d -> u) -> DIVariable -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIVariable -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIVariable -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIVariable -> m DIVariable
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIVariable -> m DIVariable
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIVariable
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIVariable -> c DIVariable
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIVariable)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIVariable)
$cDILocalVariable :: Constr
$cDIGlobalVariable :: Constr
$tDIVariable :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DIVariable -> m DIVariable
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIVariable -> m DIVariable
gmapMp :: (forall d. Data d => d -> m d) -> DIVariable -> m DIVariable
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIVariable -> m DIVariable
gmapM :: (forall d. Data d => d -> m d) -> DIVariable -> m DIVariable
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIVariable -> m DIVariable
gmapQi :: Int -> (forall d. Data d => d -> u) -> DIVariable -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIVariable -> u
gmapQ :: (forall d. Data d => d -> u) -> DIVariable -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIVariable -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIVariable -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIVariable -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIVariable -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIVariable -> r
gmapT :: (forall b. Data b => b -> b) -> DIVariable -> DIVariable
$cgmapT :: (forall b. Data b => b -> b) -> DIVariable -> DIVariable
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIVariable)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIVariable)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DIVariable)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIVariable)
dataTypeOf :: DIVariable -> DataType
$cdataTypeOf :: DIVariable -> DataType
toConstr :: DIVariable -> Constr
$ctoConstr :: DIVariable -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIVariable
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIVariable
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIVariable -> c DIVariable
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIVariable -> c DIVariable
$cp1Data :: Typeable DIVariable
Data, (forall x. DIVariable -> Rep DIVariable x)
-> (forall x. Rep DIVariable x -> DIVariable) -> Generic DIVariable
forall x. Rep DIVariable x -> DIVariable
forall x. DIVariable -> Rep DIVariable x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DIVariable x -> DIVariable
$cfrom :: forall x. DIVariable -> Rep DIVariable x
Generic)

-- | <https://llvm.org/docs/LangRef.html#diglobalvariable>
data DIGlobalVariable = GlobalVariable
  { DIGlobalVariable -> ShortByteString
name :: ShortByteString
  , DIGlobalVariable -> Maybe (MDRef DIScope)
scope :: Maybe (MDRef DIScope)
  , DIGlobalVariable -> Maybe (MDRef DIFile)
file :: Maybe (MDRef DIFile)
  , DIGlobalVariable -> Word32
line :: Word32
  , DIGlobalVariable -> Maybe (MDRef DIType)
type' :: Maybe (MDRef DIType)
  , DIGlobalVariable -> ShortByteString
linkageName :: ShortByteString
  , DIGlobalVariable -> Bool
local :: Bool
  , DIGlobalVariable -> Bool
definition :: Bool
  , DIGlobalVariable -> Maybe (MDRef DIDerivedType)
staticDataMemberDeclaration :: Maybe (MDRef DIDerivedType)
  , DIGlobalVariable -> [MDRef DITemplateParameter]
templateParams :: [MDRef DITemplateParameter]
  , DIGlobalVariable -> Word32
alignInBits :: Word32
  } deriving (DIGlobalVariable -> DIGlobalVariable -> Bool
(DIGlobalVariable -> DIGlobalVariable -> Bool)
-> (DIGlobalVariable -> DIGlobalVariable -> Bool)
-> Eq DIGlobalVariable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIGlobalVariable -> DIGlobalVariable -> Bool
$c/= :: DIGlobalVariable -> DIGlobalVariable -> Bool
== :: DIGlobalVariable -> DIGlobalVariable -> Bool
$c== :: DIGlobalVariable -> DIGlobalVariable -> Bool
Eq, Eq DIGlobalVariable
Eq DIGlobalVariable =>
(DIGlobalVariable -> DIGlobalVariable -> Ordering)
-> (DIGlobalVariable -> DIGlobalVariable -> Bool)
-> (DIGlobalVariable -> DIGlobalVariable -> Bool)
-> (DIGlobalVariable -> DIGlobalVariable -> Bool)
-> (DIGlobalVariable -> DIGlobalVariable -> Bool)
-> (DIGlobalVariable -> DIGlobalVariable -> DIGlobalVariable)
-> (DIGlobalVariable -> DIGlobalVariable -> DIGlobalVariable)
-> Ord DIGlobalVariable
DIGlobalVariable -> DIGlobalVariable -> Bool
DIGlobalVariable -> DIGlobalVariable -> Ordering
DIGlobalVariable -> DIGlobalVariable -> DIGlobalVariable
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DIGlobalVariable -> DIGlobalVariable -> DIGlobalVariable
$cmin :: DIGlobalVariable -> DIGlobalVariable -> DIGlobalVariable
max :: DIGlobalVariable -> DIGlobalVariable -> DIGlobalVariable
$cmax :: DIGlobalVariable -> DIGlobalVariable -> DIGlobalVariable
>= :: DIGlobalVariable -> DIGlobalVariable -> Bool
$c>= :: DIGlobalVariable -> DIGlobalVariable -> Bool
> :: DIGlobalVariable -> DIGlobalVariable -> Bool
$c> :: DIGlobalVariable -> DIGlobalVariable -> Bool
<= :: DIGlobalVariable -> DIGlobalVariable -> Bool
$c<= :: DIGlobalVariable -> DIGlobalVariable -> Bool
< :: DIGlobalVariable -> DIGlobalVariable -> Bool
$c< :: DIGlobalVariable -> DIGlobalVariable -> Bool
compare :: DIGlobalVariable -> DIGlobalVariable -> Ordering
$ccompare :: DIGlobalVariable -> DIGlobalVariable -> Ordering
$cp1Ord :: Eq DIGlobalVariable
Ord, ReadPrec [DIGlobalVariable]
ReadPrec DIGlobalVariable
Int -> ReadS DIGlobalVariable
ReadS [DIGlobalVariable]
(Int -> ReadS DIGlobalVariable)
-> ReadS [DIGlobalVariable]
-> ReadPrec DIGlobalVariable
-> ReadPrec [DIGlobalVariable]
-> Read DIGlobalVariable
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DIGlobalVariable]
$creadListPrec :: ReadPrec [DIGlobalVariable]
readPrec :: ReadPrec DIGlobalVariable
$creadPrec :: ReadPrec DIGlobalVariable
readList :: ReadS [DIGlobalVariable]
$creadList :: ReadS [DIGlobalVariable]
readsPrec :: Int -> ReadS DIGlobalVariable
$creadsPrec :: Int -> ReadS DIGlobalVariable
Read, Int -> DIGlobalVariable -> ShowS
[DIGlobalVariable] -> ShowS
DIGlobalVariable -> String
(Int -> DIGlobalVariable -> ShowS)
-> (DIGlobalVariable -> String)
-> ([DIGlobalVariable] -> ShowS)
-> Show DIGlobalVariable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DIGlobalVariable] -> ShowS
$cshowList :: [DIGlobalVariable] -> ShowS
show :: DIGlobalVariable -> String
$cshow :: DIGlobalVariable -> String
showsPrec :: Int -> DIGlobalVariable -> ShowS
$cshowsPrec :: Int -> DIGlobalVariable -> ShowS
Show, Typeable, Typeable DIGlobalVariable
DataType
Constr
Typeable DIGlobalVariable =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIGlobalVariable -> c DIGlobalVariable)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIGlobalVariable)
-> (DIGlobalVariable -> Constr)
-> (DIGlobalVariable -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIGlobalVariable))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIGlobalVariable))
-> ((forall b. Data b => b -> b)
    -> DIGlobalVariable -> DIGlobalVariable)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIGlobalVariable -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIGlobalVariable -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DIGlobalVariable -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIGlobalVariable -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DIGlobalVariable -> m DIGlobalVariable)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIGlobalVariable -> m DIGlobalVariable)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIGlobalVariable -> m DIGlobalVariable)
-> Data DIGlobalVariable
DIGlobalVariable -> DataType
DIGlobalVariable -> Constr
(forall b. Data b => b -> b)
-> DIGlobalVariable -> DIGlobalVariable
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIGlobalVariable -> c DIGlobalVariable
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIGlobalVariable
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DIGlobalVariable -> u
forall u. (forall d. Data d => d -> u) -> DIGlobalVariable -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable -> m DIGlobalVariable
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable -> m DIGlobalVariable
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIGlobalVariable
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIGlobalVariable -> c DIGlobalVariable
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIGlobalVariable)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIGlobalVariable)
$cGlobalVariable :: Constr
$tDIGlobalVariable :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> DIGlobalVariable -> m DIGlobalVariable
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable -> m DIGlobalVariable
gmapMp :: (forall d. Data d => d -> m d)
-> DIGlobalVariable -> m DIGlobalVariable
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable -> m DIGlobalVariable
gmapM :: (forall d. Data d => d -> m d)
-> DIGlobalVariable -> m DIGlobalVariable
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable -> m DIGlobalVariable
gmapQi :: Int -> (forall d. Data d => d -> u) -> DIGlobalVariable -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DIGlobalVariable -> u
gmapQ :: (forall d. Data d => d -> u) -> DIGlobalVariable -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIGlobalVariable -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable -> r
gmapT :: (forall b. Data b => b -> b)
-> DIGlobalVariable -> DIGlobalVariable
$cgmapT :: (forall b. Data b => b -> b)
-> DIGlobalVariable -> DIGlobalVariable
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIGlobalVariable)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIGlobalVariable)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DIGlobalVariable)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIGlobalVariable)
dataTypeOf :: DIGlobalVariable -> DataType
$cdataTypeOf :: DIGlobalVariable -> DataType
toConstr :: DIGlobalVariable -> Constr
$ctoConstr :: DIGlobalVariable -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIGlobalVariable
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIGlobalVariable
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIGlobalVariable -> c DIGlobalVariable
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIGlobalVariable -> c DIGlobalVariable
$cp1Data :: Typeable DIGlobalVariable
Data, (forall x. DIGlobalVariable -> Rep DIGlobalVariable x)
-> (forall x. Rep DIGlobalVariable x -> DIGlobalVariable)
-> Generic DIGlobalVariable
forall x. Rep DIGlobalVariable x -> DIGlobalVariable
forall x. DIGlobalVariable -> Rep DIGlobalVariable x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DIGlobalVariable x -> DIGlobalVariable
$cfrom :: forall x. DIGlobalVariable -> Rep DIGlobalVariable x
Generic)

-- | <https://llvm.org/docs/LangRef.html#dilocalvariable>
data DILocalVariable = LocalVariable
  { DILocalVariable -> ShortByteString
name :: ShortByteString
  , DILocalVariable -> MDRef DIScope
scope :: MDRef DIScope
  , DILocalVariable -> Maybe (MDRef DIFile)
file :: Maybe (MDRef DIFile)
  , DILocalVariable -> Word32
line :: Word32
  , DILocalVariable -> Maybe (MDRef DIType)
type' :: Maybe (MDRef DIType)
  , DILocalVariable -> [DIFlag]
flags :: [DIFlag]
  , DILocalVariable -> Word16
arg :: Word16
  , DILocalVariable -> Word32
alignInBits :: Word32
  } deriving (DILocalVariable -> DILocalVariable -> Bool
(DILocalVariable -> DILocalVariable -> Bool)
-> (DILocalVariable -> DILocalVariable -> Bool)
-> Eq DILocalVariable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DILocalVariable -> DILocalVariable -> Bool
$c/= :: DILocalVariable -> DILocalVariable -> Bool
== :: DILocalVariable -> DILocalVariable -> Bool
$c== :: DILocalVariable -> DILocalVariable -> Bool
Eq, Eq DILocalVariable
Eq DILocalVariable =>
(DILocalVariable -> DILocalVariable -> Ordering)
-> (DILocalVariable -> DILocalVariable -> Bool)
-> (DILocalVariable -> DILocalVariable -> Bool)
-> (DILocalVariable -> DILocalVariable -> Bool)
-> (DILocalVariable -> DILocalVariable -> Bool)
-> (DILocalVariable -> DILocalVariable -> DILocalVariable)
-> (DILocalVariable -> DILocalVariable -> DILocalVariable)
-> Ord DILocalVariable
DILocalVariable -> DILocalVariable -> Bool
DILocalVariable -> DILocalVariable -> Ordering
DILocalVariable -> DILocalVariable -> DILocalVariable
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DILocalVariable -> DILocalVariable -> DILocalVariable
$cmin :: DILocalVariable -> DILocalVariable -> DILocalVariable
max :: DILocalVariable -> DILocalVariable -> DILocalVariable
$cmax :: DILocalVariable -> DILocalVariable -> DILocalVariable
>= :: DILocalVariable -> DILocalVariable -> Bool
$c>= :: DILocalVariable -> DILocalVariable -> Bool
> :: DILocalVariable -> DILocalVariable -> Bool
$c> :: DILocalVariable -> DILocalVariable -> Bool
<= :: DILocalVariable -> DILocalVariable -> Bool
$c<= :: DILocalVariable -> DILocalVariable -> Bool
< :: DILocalVariable -> DILocalVariable -> Bool
$c< :: DILocalVariable -> DILocalVariable -> Bool
compare :: DILocalVariable -> DILocalVariable -> Ordering
$ccompare :: DILocalVariable -> DILocalVariable -> Ordering
$cp1Ord :: Eq DILocalVariable
Ord, ReadPrec [DILocalVariable]
ReadPrec DILocalVariable
Int -> ReadS DILocalVariable
ReadS [DILocalVariable]
(Int -> ReadS DILocalVariable)
-> ReadS [DILocalVariable]
-> ReadPrec DILocalVariable
-> ReadPrec [DILocalVariable]
-> Read DILocalVariable
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DILocalVariable]
$creadListPrec :: ReadPrec [DILocalVariable]
readPrec :: ReadPrec DILocalVariable
$creadPrec :: ReadPrec DILocalVariable
readList :: ReadS [DILocalVariable]
$creadList :: ReadS [DILocalVariable]
readsPrec :: Int -> ReadS DILocalVariable
$creadsPrec :: Int -> ReadS DILocalVariable
Read, Int -> DILocalVariable -> ShowS
[DILocalVariable] -> ShowS
DILocalVariable -> String
(Int -> DILocalVariable -> ShowS)
-> (DILocalVariable -> String)
-> ([DILocalVariable] -> ShowS)
-> Show DILocalVariable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DILocalVariable] -> ShowS
$cshowList :: [DILocalVariable] -> ShowS
show :: DILocalVariable -> String
$cshow :: DILocalVariable -> String
showsPrec :: Int -> DILocalVariable -> ShowS
$cshowsPrec :: Int -> DILocalVariable -> ShowS
Show, Typeable, Typeable DILocalVariable
DataType
Constr
Typeable DILocalVariable =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DILocalVariable -> c DILocalVariable)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DILocalVariable)
-> (DILocalVariable -> Constr)
-> (DILocalVariable -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DILocalVariable))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DILocalVariable))
-> ((forall b. Data b => b -> b)
    -> DILocalVariable -> DILocalVariable)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DILocalVariable -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DILocalVariable -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DILocalVariable -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DILocalVariable -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DILocalVariable -> m DILocalVariable)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DILocalVariable -> m DILocalVariable)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DILocalVariable -> m DILocalVariable)
-> Data DILocalVariable
DILocalVariable -> DataType
DILocalVariable -> Constr
(forall b. Data b => b -> b) -> DILocalVariable -> DILocalVariable
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocalVariable -> c DILocalVariable
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocalVariable
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DILocalVariable -> u
forall u. (forall d. Data d => d -> u) -> DILocalVariable -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DILocalVariable -> m DILocalVariable
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILocalVariable -> m DILocalVariable
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocalVariable
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocalVariable -> c DILocalVariable
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILocalVariable)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DILocalVariable)
$cLocalVariable :: Constr
$tDILocalVariable :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> DILocalVariable -> m DILocalVariable
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILocalVariable -> m DILocalVariable
gmapMp :: (forall d. Data d => d -> m d)
-> DILocalVariable -> m DILocalVariable
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILocalVariable -> m DILocalVariable
gmapM :: (forall d. Data d => d -> m d)
-> DILocalVariable -> m DILocalVariable
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DILocalVariable -> m DILocalVariable
gmapQi :: Int -> (forall d. Data d => d -> u) -> DILocalVariable -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DILocalVariable -> u
gmapQ :: (forall d. Data d => d -> u) -> DILocalVariable -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DILocalVariable -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable -> r
gmapT :: (forall b. Data b => b -> b) -> DILocalVariable -> DILocalVariable
$cgmapT :: (forall b. Data b => b -> b) -> DILocalVariable -> DILocalVariable
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DILocalVariable)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DILocalVariable)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DILocalVariable)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILocalVariable)
dataTypeOf :: DILocalVariable -> DataType
$cdataTypeOf :: DILocalVariable -> DataType
toConstr :: DILocalVariable -> Constr
$ctoConstr :: DILocalVariable -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocalVariable
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocalVariable
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocalVariable -> c DILocalVariable
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocalVariable -> c DILocalVariable
$cp1Data :: Typeable DILocalVariable
Data, (forall x. DILocalVariable -> Rep DILocalVariable x)
-> (forall x. Rep DILocalVariable x -> DILocalVariable)
-> Generic DILocalVariable
forall x. Rep DILocalVariable x -> DILocalVariable
forall x. DILocalVariable -> Rep DILocalVariable x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DILocalVariable x -> DILocalVariable
$cfrom :: forall x. DILocalVariable -> Rep DILocalVariable x
Generic)