{-# LANGUAGE DeriveDataTypeable #-}
module ABI.Itanium.Types (
  DecodedName(..),
  CVQualifier(..),
  CXXType(..),
  Name(..),
  Prefix(..),
  UnqualifiedName(..),
  UName(..),
  CtorDtor(..),
  Operator(..),
  Expression(..),
  CallOffset(..),
  Substitution(..),
  TemplateArg(..),
  TemplateParam(..),
  ExprPrimary(..)
  ) where

import Data.Data

data DecodedName = Function Name [CXXType]
                 | Data Name
                 | VirtualTable CXXType
                 | VTTStructure CXXType
                 | TypeInfo CXXType
                 | TypeInfoName CXXType
                 | GuardVariable Name
                 | OverrideThunk CallOffset DecodedName
                 | OverrideThunkCovariant CallOffset CallOffset DecodedName

                 | ConstStructData UnqualifiedName
                   -- ^ Const data that is not a builtin data type (as
                   -- a <special-name>).
                   --
                   -- This construct is not specifically identified in
                   -- the documentation, but for the following input:
                   --
                   --   struct mystr { int val; };
                   --   const struct mystr here = { 9 };
                   --
                   -- Also works with:
                   --
                   --   class mycls { public: int val; }
                   --   const class mycls here = { 8 };
                   --
                   -- When compiled with Clang/LLVM results in Global
                   -- Variable (apparently always using the
                   -- length-specified <source-name> syntax):
                   --
                   --    _ZL4here
                   --
                   -- This is apparently only used for const
                   -- declarations and only for non-builtin datatypes.

                 deriving (DecodedName -> DecodedName -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DecodedName -> DecodedName -> Bool
$c/= :: DecodedName -> DecodedName -> Bool
== :: DecodedName -> DecodedName -> Bool
$c== :: DecodedName -> DecodedName -> Bool
Eq, Eq DecodedName
DecodedName -> DecodedName -> Bool
DecodedName -> DecodedName -> Ordering
DecodedName -> DecodedName -> DecodedName
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 :: DecodedName -> DecodedName -> DecodedName
$cmin :: DecodedName -> DecodedName -> DecodedName
max :: DecodedName -> DecodedName -> DecodedName
$cmax :: DecodedName -> DecodedName -> DecodedName
>= :: DecodedName -> DecodedName -> Bool
$c>= :: DecodedName -> DecodedName -> Bool
> :: DecodedName -> DecodedName -> Bool
$c> :: DecodedName -> DecodedName -> Bool
<= :: DecodedName -> DecodedName -> Bool
$c<= :: DecodedName -> DecodedName -> Bool
< :: DecodedName -> DecodedName -> Bool
$c< :: DecodedName -> DecodedName -> Bool
compare :: DecodedName -> DecodedName -> Ordering
$ccompare :: DecodedName -> DecodedName -> Ordering
Ord, Int -> DecodedName -> ShowS
[DecodedName] -> ShowS
DecodedName -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DecodedName] -> ShowS
$cshowList :: [DecodedName] -> ShowS
show :: DecodedName -> String
$cshow :: DecodedName -> String
showsPrec :: Int -> DecodedName -> ShowS
$cshowsPrec :: Int -> DecodedName -> ShowS
Show, Typeable DecodedName
DecodedName -> DataType
DecodedName -> Constr
(forall b. Data b => b -> b) -> DecodedName -> DecodedName
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) -> DecodedName -> u
forall u. (forall d. Data d => d -> u) -> DecodedName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DecodedName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DecodedName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DecodedName -> m DecodedName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DecodedName -> m DecodedName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DecodedName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DecodedName -> c DecodedName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DecodedName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DecodedName)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DecodedName -> m DecodedName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DecodedName -> m DecodedName
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DecodedName -> m DecodedName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DecodedName -> m DecodedName
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DecodedName -> m DecodedName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DecodedName -> m DecodedName
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DecodedName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DecodedName -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> DecodedName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DecodedName -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DecodedName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DecodedName -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DecodedName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DecodedName -> r
gmapT :: (forall b. Data b => b -> b) -> DecodedName -> DecodedName
$cgmapT :: (forall b. Data b => b -> b) -> DecodedName -> DecodedName
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DecodedName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DecodedName)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DecodedName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DecodedName)
dataTypeOf :: DecodedName -> DataType
$cdataTypeOf :: DecodedName -> DataType
toConstr :: DecodedName -> Constr
$ctoConstr :: DecodedName -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DecodedName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DecodedName
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DecodedName -> c DecodedName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DecodedName -> c DecodedName
Data, Typeable)

data CallOffset = VirtualOffset Int Int
                | NonVirtualOffset Int
                deriving (CallOffset -> CallOffset -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CallOffset -> CallOffset -> Bool
$c/= :: CallOffset -> CallOffset -> Bool
== :: CallOffset -> CallOffset -> Bool
$c== :: CallOffset -> CallOffset -> Bool
Eq, Eq CallOffset
CallOffset -> CallOffset -> Bool
CallOffset -> CallOffset -> Ordering
CallOffset -> CallOffset -> CallOffset
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 :: CallOffset -> CallOffset -> CallOffset
$cmin :: CallOffset -> CallOffset -> CallOffset
max :: CallOffset -> CallOffset -> CallOffset
$cmax :: CallOffset -> CallOffset -> CallOffset
>= :: CallOffset -> CallOffset -> Bool
$c>= :: CallOffset -> CallOffset -> Bool
> :: CallOffset -> CallOffset -> Bool
$c> :: CallOffset -> CallOffset -> Bool
<= :: CallOffset -> CallOffset -> Bool
$c<= :: CallOffset -> CallOffset -> Bool
< :: CallOffset -> CallOffset -> Bool
$c< :: CallOffset -> CallOffset -> Bool
compare :: CallOffset -> CallOffset -> Ordering
$ccompare :: CallOffset -> CallOffset -> Ordering
Ord, Int -> CallOffset -> ShowS
[CallOffset] -> ShowS
CallOffset -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CallOffset] -> ShowS
$cshowList :: [CallOffset] -> ShowS
show :: CallOffset -> String
$cshow :: CallOffset -> String
showsPrec :: Int -> CallOffset -> ShowS
$cshowsPrec :: Int -> CallOffset -> ShowS
Show, Typeable CallOffset
CallOffset -> DataType
CallOffset -> Constr
(forall b. Data b => b -> b) -> CallOffset -> CallOffset
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) -> CallOffset -> u
forall u. (forall d. Data d => d -> u) -> CallOffset -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CallOffset -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CallOffset -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CallOffset -> m CallOffset
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CallOffset -> m CallOffset
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CallOffset
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CallOffset -> c CallOffset
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CallOffset)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CallOffset)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CallOffset -> m CallOffset
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CallOffset -> m CallOffset
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CallOffset -> m CallOffset
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CallOffset -> m CallOffset
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CallOffset -> m CallOffset
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CallOffset -> m CallOffset
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CallOffset -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CallOffset -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CallOffset -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CallOffset -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CallOffset -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CallOffset -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CallOffset -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CallOffset -> r
gmapT :: (forall b. Data b => b -> b) -> CallOffset -> CallOffset
$cgmapT :: (forall b. Data b => b -> b) -> CallOffset -> CallOffset
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CallOffset)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CallOffset)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CallOffset)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CallOffset)
dataTypeOf :: CallOffset -> DataType
$cdataTypeOf :: CallOffset -> DataType
toConstr :: CallOffset -> Constr
$ctoConstr :: CallOffset -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CallOffset
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CallOffset
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CallOffset -> c CallOffset
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CallOffset -> c CallOffset
Data, Typeable)

data CVQualifier = Restrict
                 | Volatile
                 | Const
                 deriving (CVQualifier -> CVQualifier -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CVQualifier -> CVQualifier -> Bool
$c/= :: CVQualifier -> CVQualifier -> Bool
== :: CVQualifier -> CVQualifier -> Bool
$c== :: CVQualifier -> CVQualifier -> Bool
Eq, Eq CVQualifier
CVQualifier -> CVQualifier -> Bool
CVQualifier -> CVQualifier -> Ordering
CVQualifier -> CVQualifier -> CVQualifier
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 :: CVQualifier -> CVQualifier -> CVQualifier
$cmin :: CVQualifier -> CVQualifier -> CVQualifier
max :: CVQualifier -> CVQualifier -> CVQualifier
$cmax :: CVQualifier -> CVQualifier -> CVQualifier
>= :: CVQualifier -> CVQualifier -> Bool
$c>= :: CVQualifier -> CVQualifier -> Bool
> :: CVQualifier -> CVQualifier -> Bool
$c> :: CVQualifier -> CVQualifier -> Bool
<= :: CVQualifier -> CVQualifier -> Bool
$c<= :: CVQualifier -> CVQualifier -> Bool
< :: CVQualifier -> CVQualifier -> Bool
$c< :: CVQualifier -> CVQualifier -> Bool
compare :: CVQualifier -> CVQualifier -> Ordering
$ccompare :: CVQualifier -> CVQualifier -> Ordering
Ord, Int -> CVQualifier -> ShowS
[CVQualifier] -> ShowS
CVQualifier -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CVQualifier] -> ShowS
$cshowList :: [CVQualifier] -> ShowS
show :: CVQualifier -> String
$cshow :: CVQualifier -> String
showsPrec :: Int -> CVQualifier -> ShowS
$cshowsPrec :: Int -> CVQualifier -> ShowS
Show, Typeable CVQualifier
CVQualifier -> DataType
CVQualifier -> Constr
(forall b. Data b => b -> b) -> CVQualifier -> CVQualifier
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) -> CVQualifier -> u
forall u. (forall d. Data d => d -> u) -> CVQualifier -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CVQualifier -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CVQualifier -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CVQualifier -> m CVQualifier
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CVQualifier -> m CVQualifier
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CVQualifier
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CVQualifier -> c CVQualifier
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CVQualifier)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CVQualifier)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CVQualifier -> m CVQualifier
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CVQualifier -> m CVQualifier
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CVQualifier -> m CVQualifier
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CVQualifier -> m CVQualifier
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CVQualifier -> m CVQualifier
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CVQualifier -> m CVQualifier
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CVQualifier -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CVQualifier -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CVQualifier -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CVQualifier -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CVQualifier -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CVQualifier -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CVQualifier -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CVQualifier -> r
gmapT :: (forall b. Data b => b -> b) -> CVQualifier -> CVQualifier
$cgmapT :: (forall b. Data b => b -> b) -> CVQualifier -> CVQualifier
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CVQualifier)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CVQualifier)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CVQualifier)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CVQualifier)
dataTypeOf :: CVQualifier -> DataType
$cdataTypeOf :: CVQualifier -> DataType
toConstr :: CVQualifier -> Constr
$ctoConstr :: CVQualifier -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CVQualifier
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CVQualifier
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CVQualifier -> c CVQualifier
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CVQualifier -> c CVQualifier
Data, Typeable)

data Substitution = Substitution (Maybe String)
                  | SubStdNamespace
                  | SubStdAllocator
                  | SubBasicString
                  | SubBasicStringArgs
                  | SubBasicIstream
                  | SubBasicOstream
                  | SubBasicIostream
                  deriving (Substitution -> Substitution -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Substitution -> Substitution -> Bool
$c/= :: Substitution -> Substitution -> Bool
== :: Substitution -> Substitution -> Bool
$c== :: Substitution -> Substitution -> Bool
Eq, Eq Substitution
Substitution -> Substitution -> Bool
Substitution -> Substitution -> Ordering
Substitution -> Substitution -> Substitution
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 :: Substitution -> Substitution -> Substitution
$cmin :: Substitution -> Substitution -> Substitution
max :: Substitution -> Substitution -> Substitution
$cmax :: Substitution -> Substitution -> Substitution
>= :: Substitution -> Substitution -> Bool
$c>= :: Substitution -> Substitution -> Bool
> :: Substitution -> Substitution -> Bool
$c> :: Substitution -> Substitution -> Bool
<= :: Substitution -> Substitution -> Bool
$c<= :: Substitution -> Substitution -> Bool
< :: Substitution -> Substitution -> Bool
$c< :: Substitution -> Substitution -> Bool
compare :: Substitution -> Substitution -> Ordering
$ccompare :: Substitution -> Substitution -> Ordering
Ord, Int -> Substitution -> ShowS
[Substitution] -> ShowS
Substitution -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Substitution] -> ShowS
$cshowList :: [Substitution] -> ShowS
show :: Substitution -> String
$cshow :: Substitution -> String
showsPrec :: Int -> Substitution -> ShowS
$cshowsPrec :: Int -> Substitution -> ShowS
Show, Typeable Substitution
Substitution -> DataType
Substitution -> Constr
(forall b. Data b => b -> b) -> Substitution -> Substitution
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) -> Substitution -> u
forall u. (forall d. Data d => d -> u) -> Substitution -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Substitution -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Substitution -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Substitution -> m Substitution
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Substitution -> m Substitution
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Substitution
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Substitution -> c Substitution
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Substitution)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Substitution)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Substitution -> m Substitution
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Substitution -> m Substitution
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Substitution -> m Substitution
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Substitution -> m Substitution
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Substitution -> m Substitution
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Substitution -> m Substitution
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Substitution -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Substitution -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Substitution -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Substitution -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Substitution -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Substitution -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Substitution -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Substitution -> r
gmapT :: (forall b. Data b => b -> b) -> Substitution -> Substitution
$cgmapT :: (forall b. Data b => b -> b) -> Substitution -> Substitution
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Substitution)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Substitution)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Substitution)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Substitution)
dataTypeOf :: Substitution -> DataType
$cdataTypeOf :: Substitution -> DataType
toConstr :: Substitution -> Constr
$ctoConstr :: Substitution -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Substitution
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Substitution
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Substitution -> c Substitution
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Substitution -> c Substitution
Data, Typeable)

data CXXType = QualifiedType [CVQualifier] CXXType
             | PointerToType CXXType
             | ReferenceToType CXXType
             | RValueReferenceToType CXXType
             | ComplexPairType CXXType
             | ImaginaryType CXXType
             | ParameterPack CXXType
             -- | DeclTypeExpression <expression>
             -- | DeclTypeOther <expression>
             | VendorTypeQualifier String CXXType
             | VoidType
             | Wchar_tType
             | BoolType
             | CharType
             | SignedCharType
             | UnsignedCharType
             | ShortType
             | UnsignedShortType
             | IntType
             | UnsignedIntType
             | LongType
             | UnsignedLongType
             | LongLongType
             | UnsignedLongLongType
             | Int128Type
             | UnsignedInt128Type
             | FloatType
             | DoubleType
             | LongDoubleType
             | Float128Type
             | EllipsisType
               -- There are also four IEEE 754r types and I don't know what that is
             | Char32Type
             | Char16Type
             | AutoType
             | NullPtrType
             | VendorBuiltinType String
             | FunctionType [CXXType]
             | ExternCFunctionType [CXXType]
             | ArrayTypeN (Maybe Int) CXXType
               -- ^ int[5], normal array parameters.  The dimension is
               -- elided for C99 VLAs
             | ArrayTypeE Expression
               -- ^ int[I + 1], expresions due to templates.  The
               -- dimension is not optional here; if it was it would
               -- just be an ArrayTypeN
             | PtrToMemberType CXXType CXXType
               -- ^ Class type, member type
             | ClassEnumType Name
             | SubstitutionType Substitution
             | TemplateParamType TemplateParam
             | TemplateTemplateParamType TemplateParam [TemplateArg]
             | TemplateTemplateParamSubstitutionType Substitution [TemplateArg]
             deriving (CXXType -> CXXType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CXXType -> CXXType -> Bool
$c/= :: CXXType -> CXXType -> Bool
== :: CXXType -> CXXType -> Bool
$c== :: CXXType -> CXXType -> Bool
Eq, Eq CXXType
CXXType -> CXXType -> Bool
CXXType -> CXXType -> Ordering
CXXType -> CXXType -> CXXType
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 :: CXXType -> CXXType -> CXXType
$cmin :: CXXType -> CXXType -> CXXType
max :: CXXType -> CXXType -> CXXType
$cmax :: CXXType -> CXXType -> CXXType
>= :: CXXType -> CXXType -> Bool
$c>= :: CXXType -> CXXType -> Bool
> :: CXXType -> CXXType -> Bool
$c> :: CXXType -> CXXType -> Bool
<= :: CXXType -> CXXType -> Bool
$c<= :: CXXType -> CXXType -> Bool
< :: CXXType -> CXXType -> Bool
$c< :: CXXType -> CXXType -> Bool
compare :: CXXType -> CXXType -> Ordering
$ccompare :: CXXType -> CXXType -> Ordering
Ord, Int -> CXXType -> ShowS
[CXXType] -> ShowS
CXXType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CXXType] -> ShowS
$cshowList :: [CXXType] -> ShowS
show :: CXXType -> String
$cshow :: CXXType -> String
showsPrec :: Int -> CXXType -> ShowS
$cshowsPrec :: Int -> CXXType -> ShowS
Show, Typeable CXXType
CXXType -> DataType
CXXType -> Constr
(forall b. Data b => b -> b) -> CXXType -> CXXType
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) -> CXXType -> u
forall u. (forall d. Data d => d -> u) -> CXXType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CXXType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CXXType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CXXType -> m CXXType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CXXType -> m CXXType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CXXType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CXXType -> c CXXType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CXXType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CXXType)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CXXType -> m CXXType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CXXType -> m CXXType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CXXType -> m CXXType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CXXType -> m CXXType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CXXType -> m CXXType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CXXType -> m CXXType
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CXXType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CXXType -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CXXType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CXXType -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CXXType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CXXType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CXXType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CXXType -> r
gmapT :: (forall b. Data b => b -> b) -> CXXType -> CXXType
$cgmapT :: (forall b. Data b => b -> b) -> CXXType -> CXXType
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CXXType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CXXType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CXXType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CXXType)
dataTypeOf :: CXXType -> DataType
$cdataTypeOf :: CXXType -> DataType
toConstr :: CXXType -> Constr
$ctoConstr :: CXXType -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CXXType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CXXType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CXXType -> c CXXType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CXXType -> c CXXType
Data, Typeable)

data Expression = Expression
                deriving (Expression -> Expression -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Expression -> Expression -> Bool
$c/= :: Expression -> Expression -> Bool
== :: Expression -> Expression -> Bool
$c== :: Expression -> Expression -> Bool
Eq, Eq Expression
Expression -> Expression -> Bool
Expression -> Expression -> Ordering
Expression -> Expression -> Expression
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 :: Expression -> Expression -> Expression
$cmin :: Expression -> Expression -> Expression
max :: Expression -> Expression -> Expression
$cmax :: Expression -> Expression -> Expression
>= :: Expression -> Expression -> Bool
$c>= :: Expression -> Expression -> Bool
> :: Expression -> Expression -> Bool
$c> :: Expression -> Expression -> Bool
<= :: Expression -> Expression -> Bool
$c<= :: Expression -> Expression -> Bool
< :: Expression -> Expression -> Bool
$c< :: Expression -> Expression -> Bool
compare :: Expression -> Expression -> Ordering
$ccompare :: Expression -> Expression -> Ordering
Ord, Int -> Expression -> ShowS
[Expression] -> ShowS
Expression -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Expression] -> ShowS
$cshowList :: [Expression] -> ShowS
show :: Expression -> String
$cshow :: Expression -> String
showsPrec :: Int -> Expression -> ShowS
$cshowsPrec :: Int -> Expression -> ShowS
Show, Typeable Expression
Expression -> DataType
Expression -> Constr
(forall b. Data b => b -> b) -> Expression -> Expression
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) -> Expression -> u
forall u. (forall d. Data d => d -> u) -> Expression -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expression -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expression -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expression -> m Expression
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expression -> m Expression
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Expression
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expression -> c Expression
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Expression)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expression)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expression -> m Expression
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expression -> m Expression
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expression -> m Expression
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expression -> m Expression
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expression -> m Expression
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expression -> m Expression
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Expression -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Expression -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Expression -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Expression -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expression -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expression -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expression -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expression -> r
gmapT :: (forall b. Data b => b -> b) -> Expression -> Expression
$cgmapT :: (forall b. Data b => b -> b) -> Expression -> Expression
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expression)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expression)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Expression)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Expression)
dataTypeOf :: Expression -> DataType
$cdataTypeOf :: Expression -> DataType
toConstr :: Expression -> Constr
$ctoConstr :: Expression -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Expression
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Expression
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expression -> c Expression
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expression -> c Expression
Data, Typeable)

data Name = NestedName [CVQualifier] [Prefix] UnqualifiedName
          | NestedTemplateName [CVQualifier] [Prefix] [TemplateArg]
          | UnscopedName UName
          | UnscopedTemplateName UName [TemplateArg]
          | UnscopedTemplateSubstitution Substitution [TemplateArg]
            -- Still need local-name
          deriving (Name -> Name -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c== :: Name -> Name -> Bool
Eq, Eq Name
Name -> Name -> Bool
Name -> Name -> Ordering
Name -> Name -> Name
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 :: Name -> Name -> Name
$cmin :: Name -> Name -> Name
max :: Name -> Name -> Name
$cmax :: Name -> Name -> Name
>= :: Name -> Name -> Bool
$c>= :: Name -> Name -> Bool
> :: Name -> Name -> Bool
$c> :: Name -> Name -> Bool
<= :: Name -> Name -> Bool
$c<= :: Name -> Name -> Bool
< :: Name -> Name -> Bool
$c< :: Name -> Name -> Bool
compare :: Name -> Name -> Ordering
$ccompare :: Name -> Name -> Ordering
Ord, Int -> Name -> ShowS
[Name] -> ShowS
Name -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Name] -> ShowS
$cshowList :: [Name] -> ShowS
show :: Name -> String
$cshow :: Name -> String
showsPrec :: Int -> Name -> ShowS
$cshowsPrec :: Int -> Name -> ShowS
Show, Typeable Name
Name -> DataType
Name -> Constr
(forall b. Data b => b -> b) -> Name -> Name
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) -> Name -> u
forall u. (forall d. Data d => d -> u) -> Name -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Name -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Name -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Name -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Name -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapT :: (forall b. Data b => b -> b) -> Name -> Name
$cgmapT :: (forall b. Data b => b -> b) -> Name -> Name
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
dataTypeOf :: Name -> DataType
$cdataTypeOf :: Name -> DataType
toConstr :: Name -> Constr
$ctoConstr :: Name -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
Data, Typeable)

data UName = UName UnqualifiedName
           | UStdName UnqualifiedName
           deriving (UName -> UName -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UName -> UName -> Bool
$c/= :: UName -> UName -> Bool
== :: UName -> UName -> Bool
$c== :: UName -> UName -> Bool
Eq, Eq UName
UName -> UName -> Bool
UName -> UName -> Ordering
UName -> UName -> UName
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 :: UName -> UName -> UName
$cmin :: UName -> UName -> UName
max :: UName -> UName -> UName
$cmax :: UName -> UName -> UName
>= :: UName -> UName -> Bool
$c>= :: UName -> UName -> Bool
> :: UName -> UName -> Bool
$c> :: UName -> UName -> Bool
<= :: UName -> UName -> Bool
$c<= :: UName -> UName -> Bool
< :: UName -> UName -> Bool
$c< :: UName -> UName -> Bool
compare :: UName -> UName -> Ordering
$ccompare :: UName -> UName -> Ordering
Ord, Int -> UName -> ShowS
[UName] -> ShowS
UName -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UName] -> ShowS
$cshowList :: [UName] -> ShowS
show :: UName -> String
$cshow :: UName -> String
showsPrec :: Int -> UName -> ShowS
$cshowsPrec :: Int -> UName -> ShowS
Show, Typeable UName
UName -> DataType
UName -> Constr
(forall b. Data b => b -> b) -> UName -> UName
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) -> UName -> u
forall u. (forall d. Data d => d -> u) -> UName -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UName -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UName -> m UName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UName -> m UName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UName -> c UName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UName)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UName -> m UName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UName -> m UName
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UName -> m UName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UName -> m UName
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UName -> m UName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UName -> m UName
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UName -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> UName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UName -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UName -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UName -> r
gmapT :: (forall b. Data b => b -> b) -> UName -> UName
$cgmapT :: (forall b. Data b => b -> b) -> UName -> UName
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UName)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UName)
dataTypeOf :: UName -> DataType
$cdataTypeOf :: UName -> DataType
toConstr :: UName -> Constr
$ctoConstr :: UName -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UName
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UName -> c UName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UName -> c UName
Data, Typeable)

{-
<prefix> ::= <prefix> <unqualified-name>
	     ::= <template-prefix> <template-args>
             ::= <template-param>
             ::= <decltype>
	     ::= # empty
	     ::= <substitution>
             ::= <prefix> <data-member-prefix>

<data-member-prefix> := <member source-name> M

This is currently massively incomplete
-}
data Prefix = DataMemberPrefix String
            | UnqualifiedPrefix UnqualifiedName
            | SubstitutionPrefix Substitution
            | TemplateParamPrefix TemplateParam
            | TemplateArgsPrefix [TemplateArg]
            deriving (Prefix -> Prefix -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Prefix -> Prefix -> Bool
$c/= :: Prefix -> Prefix -> Bool
== :: Prefix -> Prefix -> Bool
$c== :: Prefix -> Prefix -> Bool
Eq, Eq Prefix
Prefix -> Prefix -> Bool
Prefix -> Prefix -> Ordering
Prefix -> Prefix -> Prefix
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 :: Prefix -> Prefix -> Prefix
$cmin :: Prefix -> Prefix -> Prefix
max :: Prefix -> Prefix -> Prefix
$cmax :: Prefix -> Prefix -> Prefix
>= :: Prefix -> Prefix -> Bool
$c>= :: Prefix -> Prefix -> Bool
> :: Prefix -> Prefix -> Bool
$c> :: Prefix -> Prefix -> Bool
<= :: Prefix -> Prefix -> Bool
$c<= :: Prefix -> Prefix -> Bool
< :: Prefix -> Prefix -> Bool
$c< :: Prefix -> Prefix -> Bool
compare :: Prefix -> Prefix -> Ordering
$ccompare :: Prefix -> Prefix -> Ordering
Ord, Int -> Prefix -> ShowS
[Prefix] -> ShowS
Prefix -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Prefix] -> ShowS
$cshowList :: [Prefix] -> ShowS
show :: Prefix -> String
$cshow :: Prefix -> String
showsPrec :: Int -> Prefix -> ShowS
$cshowsPrec :: Int -> Prefix -> ShowS
Show, Typeable Prefix
Prefix -> DataType
Prefix -> Constr
(forall b. Data b => b -> b) -> Prefix -> Prefix
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) -> Prefix -> u
forall u. (forall d. Data d => d -> u) -> Prefix -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Prefix -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Prefix -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Prefix -> m Prefix
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Prefix -> m Prefix
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Prefix
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Prefix -> c Prefix
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Prefix)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Prefix)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Prefix -> m Prefix
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Prefix -> m Prefix
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Prefix -> m Prefix
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Prefix -> m Prefix
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Prefix -> m Prefix
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Prefix -> m Prefix
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Prefix -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Prefix -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Prefix -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Prefix -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Prefix -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Prefix -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Prefix -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Prefix -> r
gmapT :: (forall b. Data b => b -> b) -> Prefix -> Prefix
$cgmapT :: (forall b. Data b => b -> b) -> Prefix -> Prefix
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Prefix)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Prefix)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Prefix)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Prefix)
dataTypeOf :: Prefix -> DataType
$cdataTypeOf :: Prefix -> DataType
toConstr :: Prefix -> Constr
$ctoConstr :: Prefix -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Prefix
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Prefix
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Prefix -> c Prefix
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Prefix -> c Prefix
Data, Typeable)

data TemplateArg = TypeTemplateArg CXXType
                 | ExprPrimaryTemplateArg ExprPrimary
                 deriving (TemplateArg -> TemplateArg -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TemplateArg -> TemplateArg -> Bool
$c/= :: TemplateArg -> TemplateArg -> Bool
== :: TemplateArg -> TemplateArg -> Bool
$c== :: TemplateArg -> TemplateArg -> Bool
Eq, Eq TemplateArg
TemplateArg -> TemplateArg -> Bool
TemplateArg -> TemplateArg -> Ordering
TemplateArg -> TemplateArg -> TemplateArg
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 :: TemplateArg -> TemplateArg -> TemplateArg
$cmin :: TemplateArg -> TemplateArg -> TemplateArg
max :: TemplateArg -> TemplateArg -> TemplateArg
$cmax :: TemplateArg -> TemplateArg -> TemplateArg
>= :: TemplateArg -> TemplateArg -> Bool
$c>= :: TemplateArg -> TemplateArg -> Bool
> :: TemplateArg -> TemplateArg -> Bool
$c> :: TemplateArg -> TemplateArg -> Bool
<= :: TemplateArg -> TemplateArg -> Bool
$c<= :: TemplateArg -> TemplateArg -> Bool
< :: TemplateArg -> TemplateArg -> Bool
$c< :: TemplateArg -> TemplateArg -> Bool
compare :: TemplateArg -> TemplateArg -> Ordering
$ccompare :: TemplateArg -> TemplateArg -> Ordering
Ord, Int -> TemplateArg -> ShowS
[TemplateArg] -> ShowS
TemplateArg -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TemplateArg] -> ShowS
$cshowList :: [TemplateArg] -> ShowS
show :: TemplateArg -> String
$cshow :: TemplateArg -> String
showsPrec :: Int -> TemplateArg -> ShowS
$cshowsPrec :: Int -> TemplateArg -> ShowS
Show, Typeable TemplateArg
TemplateArg -> DataType
TemplateArg -> Constr
(forall b. Data b => b -> b) -> TemplateArg -> TemplateArg
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) -> TemplateArg -> u
forall u. (forall d. Data d => d -> u) -> TemplateArg -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TemplateArg -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TemplateArg -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TemplateArg -> m TemplateArg
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TemplateArg -> m TemplateArg
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TemplateArg
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TemplateArg -> c TemplateArg
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TemplateArg)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TemplateArg)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TemplateArg -> m TemplateArg
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TemplateArg -> m TemplateArg
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TemplateArg -> m TemplateArg
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TemplateArg -> m TemplateArg
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TemplateArg -> m TemplateArg
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TemplateArg -> m TemplateArg
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TemplateArg -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TemplateArg -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> TemplateArg -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TemplateArg -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TemplateArg -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TemplateArg -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TemplateArg -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TemplateArg -> r
gmapT :: (forall b. Data b => b -> b) -> TemplateArg -> TemplateArg
$cgmapT :: (forall b. Data b => b -> b) -> TemplateArg -> TemplateArg
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TemplateArg)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TemplateArg)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TemplateArg)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TemplateArg)
dataTypeOf :: TemplateArg -> DataType
$cdataTypeOf :: TemplateArg -> DataType
toConstr :: TemplateArg -> Constr
$ctoConstr :: TemplateArg -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TemplateArg
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TemplateArg
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TemplateArg -> c TemplateArg
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TemplateArg -> c TemplateArg
Data, Typeable)

data TemplateParam = TemplateParam (Maybe String)
                   deriving (TemplateParam -> TemplateParam -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TemplateParam -> TemplateParam -> Bool
$c/= :: TemplateParam -> TemplateParam -> Bool
== :: TemplateParam -> TemplateParam -> Bool
$c== :: TemplateParam -> TemplateParam -> Bool
Eq, Eq TemplateParam
TemplateParam -> TemplateParam -> Bool
TemplateParam -> TemplateParam -> Ordering
TemplateParam -> TemplateParam -> TemplateParam
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 :: TemplateParam -> TemplateParam -> TemplateParam
$cmin :: TemplateParam -> TemplateParam -> TemplateParam
max :: TemplateParam -> TemplateParam -> TemplateParam
$cmax :: TemplateParam -> TemplateParam -> TemplateParam
>= :: TemplateParam -> TemplateParam -> Bool
$c>= :: TemplateParam -> TemplateParam -> Bool
> :: TemplateParam -> TemplateParam -> Bool
$c> :: TemplateParam -> TemplateParam -> Bool
<= :: TemplateParam -> TemplateParam -> Bool
$c<= :: TemplateParam -> TemplateParam -> Bool
< :: TemplateParam -> TemplateParam -> Bool
$c< :: TemplateParam -> TemplateParam -> Bool
compare :: TemplateParam -> TemplateParam -> Ordering
$ccompare :: TemplateParam -> TemplateParam -> Ordering
Ord, Int -> TemplateParam -> ShowS
[TemplateParam] -> ShowS
TemplateParam -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TemplateParam] -> ShowS
$cshowList :: [TemplateParam] -> ShowS
show :: TemplateParam -> String
$cshow :: TemplateParam -> String
showsPrec :: Int -> TemplateParam -> ShowS
$cshowsPrec :: Int -> TemplateParam -> ShowS
Show, Typeable TemplateParam
TemplateParam -> DataType
TemplateParam -> Constr
(forall b. Data b => b -> b) -> TemplateParam -> TemplateParam
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) -> TemplateParam -> u
forall u. (forall d. Data d => d -> u) -> TemplateParam -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TemplateParam -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TemplateParam -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TemplateParam -> m TemplateParam
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TemplateParam -> m TemplateParam
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TemplateParam
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TemplateParam -> c TemplateParam
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TemplateParam)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TemplateParam)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TemplateParam -> m TemplateParam
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TemplateParam -> m TemplateParam
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TemplateParam -> m TemplateParam
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TemplateParam -> m TemplateParam
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TemplateParam -> m TemplateParam
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TemplateParam -> m TemplateParam
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TemplateParam -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TemplateParam -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> TemplateParam -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TemplateParam -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TemplateParam -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TemplateParam -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TemplateParam -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TemplateParam -> r
gmapT :: (forall b. Data b => b -> b) -> TemplateParam -> TemplateParam
$cgmapT :: (forall b. Data b => b -> b) -> TemplateParam -> TemplateParam
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TemplateParam)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TemplateParam)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TemplateParam)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TemplateParam)
dataTypeOf :: TemplateParam -> DataType
$cdataTypeOf :: TemplateParam -> DataType
toConstr :: TemplateParam -> Constr
$ctoConstr :: TemplateParam -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TemplateParam
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TemplateParam
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TemplateParam -> c TemplateParam
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TemplateParam -> c TemplateParam
Data, Typeable)

data ExprPrimary = ExprIntLit CXXType Int
                 | ExprFloatLit CXXType Float
                 | ExprStringLit String
                 | ExprNullPtrLit -- ?
                 | ExprNullPointerTemplateArg
                 | ExprComplexFloatLit CXXType Float Float
                 | ExprExternName DecodedName
                     deriving (ExprPrimary -> ExprPrimary -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExprPrimary -> ExprPrimary -> Bool
$c/= :: ExprPrimary -> ExprPrimary -> Bool
== :: ExprPrimary -> ExprPrimary -> Bool
$c== :: ExprPrimary -> ExprPrimary -> Bool
Eq, Eq ExprPrimary
ExprPrimary -> ExprPrimary -> Bool
ExprPrimary -> ExprPrimary -> Ordering
ExprPrimary -> ExprPrimary -> ExprPrimary
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 :: ExprPrimary -> ExprPrimary -> ExprPrimary
$cmin :: ExprPrimary -> ExprPrimary -> ExprPrimary
max :: ExprPrimary -> ExprPrimary -> ExprPrimary
$cmax :: ExprPrimary -> ExprPrimary -> ExprPrimary
>= :: ExprPrimary -> ExprPrimary -> Bool
$c>= :: ExprPrimary -> ExprPrimary -> Bool
> :: ExprPrimary -> ExprPrimary -> Bool
$c> :: ExprPrimary -> ExprPrimary -> Bool
<= :: ExprPrimary -> ExprPrimary -> Bool
$c<= :: ExprPrimary -> ExprPrimary -> Bool
< :: ExprPrimary -> ExprPrimary -> Bool
$c< :: ExprPrimary -> ExprPrimary -> Bool
compare :: ExprPrimary -> ExprPrimary -> Ordering
$ccompare :: ExprPrimary -> ExprPrimary -> Ordering
Ord, Int -> ExprPrimary -> ShowS
[ExprPrimary] -> ShowS
ExprPrimary -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExprPrimary] -> ShowS
$cshowList :: [ExprPrimary] -> ShowS
show :: ExprPrimary -> String
$cshow :: ExprPrimary -> String
showsPrec :: Int -> ExprPrimary -> ShowS
$cshowsPrec :: Int -> ExprPrimary -> ShowS
Show, Typeable ExprPrimary
ExprPrimary -> DataType
ExprPrimary -> Constr
(forall b. Data b => b -> b) -> ExprPrimary -> ExprPrimary
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) -> ExprPrimary -> u
forall u. (forall d. Data d => d -> u) -> ExprPrimary -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExprPrimary -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExprPrimary -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExprPrimary -> m ExprPrimary
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExprPrimary -> m ExprPrimary
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExprPrimary
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExprPrimary -> c ExprPrimary
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExprPrimary)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ExprPrimary)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExprPrimary -> m ExprPrimary
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExprPrimary -> m ExprPrimary
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExprPrimary -> m ExprPrimary
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExprPrimary -> m ExprPrimary
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExprPrimary -> m ExprPrimary
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExprPrimary -> m ExprPrimary
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExprPrimary -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExprPrimary -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ExprPrimary -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ExprPrimary -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExprPrimary -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExprPrimary -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExprPrimary -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExprPrimary -> r
gmapT :: (forall b. Data b => b -> b) -> ExprPrimary -> ExprPrimary
$cgmapT :: (forall b. Data b => b -> b) -> ExprPrimary -> ExprPrimary
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ExprPrimary)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ExprPrimary)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExprPrimary)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExprPrimary)
dataTypeOf :: ExprPrimary -> DataType
$cdataTypeOf :: ExprPrimary -> DataType
toConstr :: ExprPrimary -> Constr
$ctoConstr :: ExprPrimary -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExprPrimary
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExprPrimary
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExprPrimary -> c ExprPrimary
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExprPrimary -> c ExprPrimary
Data, Typeable)

data UnqualifiedName = OperatorName Operator
                     | CtorDtorName CtorDtor
                     | SourceName String
                     -- UnnamedTypeName String
                     deriving (UnqualifiedName -> UnqualifiedName -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnqualifiedName -> UnqualifiedName -> Bool
$c/= :: UnqualifiedName -> UnqualifiedName -> Bool
== :: UnqualifiedName -> UnqualifiedName -> Bool
$c== :: UnqualifiedName -> UnqualifiedName -> Bool
Eq, Eq UnqualifiedName
UnqualifiedName -> UnqualifiedName -> Bool
UnqualifiedName -> UnqualifiedName -> Ordering
UnqualifiedName -> UnqualifiedName -> UnqualifiedName
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 :: UnqualifiedName -> UnqualifiedName -> UnqualifiedName
$cmin :: UnqualifiedName -> UnqualifiedName -> UnqualifiedName
max :: UnqualifiedName -> UnqualifiedName -> UnqualifiedName
$cmax :: UnqualifiedName -> UnqualifiedName -> UnqualifiedName
>= :: UnqualifiedName -> UnqualifiedName -> Bool
$c>= :: UnqualifiedName -> UnqualifiedName -> Bool
> :: UnqualifiedName -> UnqualifiedName -> Bool
$c> :: UnqualifiedName -> UnqualifiedName -> Bool
<= :: UnqualifiedName -> UnqualifiedName -> Bool
$c<= :: UnqualifiedName -> UnqualifiedName -> Bool
< :: UnqualifiedName -> UnqualifiedName -> Bool
$c< :: UnqualifiedName -> UnqualifiedName -> Bool
compare :: UnqualifiedName -> UnqualifiedName -> Ordering
$ccompare :: UnqualifiedName -> UnqualifiedName -> Ordering
Ord, Int -> UnqualifiedName -> ShowS
[UnqualifiedName] -> ShowS
UnqualifiedName -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UnqualifiedName] -> ShowS
$cshowList :: [UnqualifiedName] -> ShowS
show :: UnqualifiedName -> String
$cshow :: UnqualifiedName -> String
showsPrec :: Int -> UnqualifiedName -> ShowS
$cshowsPrec :: Int -> UnqualifiedName -> ShowS
Show, Typeable UnqualifiedName
UnqualifiedName -> DataType
UnqualifiedName -> Constr
(forall b. Data b => b -> b) -> UnqualifiedName -> UnqualifiedName
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) -> UnqualifiedName -> u
forall u. (forall d. Data d => d -> u) -> UnqualifiedName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnqualifiedName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnqualifiedName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> UnqualifiedName -> m UnqualifiedName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UnqualifiedName -> m UnqualifiedName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnqualifiedName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnqualifiedName -> c UnqualifiedName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnqualifiedName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnqualifiedName)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UnqualifiedName -> m UnqualifiedName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UnqualifiedName -> m UnqualifiedName
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UnqualifiedName -> m UnqualifiedName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UnqualifiedName -> m UnqualifiedName
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> UnqualifiedName -> m UnqualifiedName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> UnqualifiedName -> m UnqualifiedName
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> UnqualifiedName -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> UnqualifiedName -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> UnqualifiedName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UnqualifiedName -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnqualifiedName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnqualifiedName -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnqualifiedName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnqualifiedName -> r
gmapT :: (forall b. Data b => b -> b) -> UnqualifiedName -> UnqualifiedName
$cgmapT :: (forall b. Data b => b -> b) -> UnqualifiedName -> UnqualifiedName
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnqualifiedName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnqualifiedName)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnqualifiedName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnqualifiedName)
dataTypeOf :: UnqualifiedName -> DataType
$cdataTypeOf :: UnqualifiedName -> DataType
toConstr :: UnqualifiedName -> Constr
$ctoConstr :: UnqualifiedName -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnqualifiedName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnqualifiedName
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnqualifiedName -> c UnqualifiedName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnqualifiedName -> c UnqualifiedName
Data, Typeable)

data CtorDtor = C1 -- Complete object constructor
              | C2 -- Base object constructor
              | C3 -- Complete object allocating constructor
              | D0 -- Deleting destructor
              | D1 -- Complete object destructor
              | D2 -- Base object destructor
              deriving (CtorDtor -> CtorDtor -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CtorDtor -> CtorDtor -> Bool
$c/= :: CtorDtor -> CtorDtor -> Bool
== :: CtorDtor -> CtorDtor -> Bool
$c== :: CtorDtor -> CtorDtor -> Bool
Eq, Eq CtorDtor
CtorDtor -> CtorDtor -> Bool
CtorDtor -> CtorDtor -> Ordering
CtorDtor -> CtorDtor -> CtorDtor
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 :: CtorDtor -> CtorDtor -> CtorDtor
$cmin :: CtorDtor -> CtorDtor -> CtorDtor
max :: CtorDtor -> CtorDtor -> CtorDtor
$cmax :: CtorDtor -> CtorDtor -> CtorDtor
>= :: CtorDtor -> CtorDtor -> Bool
$c>= :: CtorDtor -> CtorDtor -> Bool
> :: CtorDtor -> CtorDtor -> Bool
$c> :: CtorDtor -> CtorDtor -> Bool
<= :: CtorDtor -> CtorDtor -> Bool
$c<= :: CtorDtor -> CtorDtor -> Bool
< :: CtorDtor -> CtorDtor -> Bool
$c< :: CtorDtor -> CtorDtor -> Bool
compare :: CtorDtor -> CtorDtor -> Ordering
$ccompare :: CtorDtor -> CtorDtor -> Ordering
Ord, Int -> CtorDtor -> ShowS
[CtorDtor] -> ShowS
CtorDtor -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CtorDtor] -> ShowS
$cshowList :: [CtorDtor] -> ShowS
show :: CtorDtor -> String
$cshow :: CtorDtor -> String
showsPrec :: Int -> CtorDtor -> ShowS
$cshowsPrec :: Int -> CtorDtor -> ShowS
Show, Typeable CtorDtor
CtorDtor -> DataType
CtorDtor -> Constr
(forall b. Data b => b -> b) -> CtorDtor -> CtorDtor
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) -> CtorDtor -> u
forall u. (forall d. Data d => d -> u) -> CtorDtor -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CtorDtor -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CtorDtor -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CtorDtor -> m CtorDtor
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CtorDtor -> m CtorDtor
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CtorDtor
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CtorDtor -> c CtorDtor
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CtorDtor)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CtorDtor)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CtorDtor -> m CtorDtor
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CtorDtor -> m CtorDtor
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CtorDtor -> m CtorDtor
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CtorDtor -> m CtorDtor
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CtorDtor -> m CtorDtor
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CtorDtor -> m CtorDtor
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CtorDtor -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CtorDtor -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CtorDtor -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CtorDtor -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CtorDtor -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CtorDtor -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CtorDtor -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CtorDtor -> r
gmapT :: (forall b. Data b => b -> b) -> CtorDtor -> CtorDtor
$cgmapT :: (forall b. Data b => b -> b) -> CtorDtor -> CtorDtor
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CtorDtor)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CtorDtor)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CtorDtor)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CtorDtor)
dataTypeOf :: CtorDtor -> DataType
$cdataTypeOf :: CtorDtor -> DataType
toConstr :: CtorDtor -> Constr
$ctoConstr :: CtorDtor -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CtorDtor
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CtorDtor
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CtorDtor -> c CtorDtor
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CtorDtor -> c CtorDtor
Data, Typeable)

data Operator = OpNew           -- ^ new
              | OpNewArray      -- ^ new[]
              | OpDelete        -- ^ delete
              | OpDeleteArray   -- ^ delete[]
              | OpUPlus         -- ^ + (unary)
              | OpUMinus        -- ^ - (unary)
              | OpAddressOf     -- ^ & (unary)
              | OpDeref         -- ^ * (unary)
              | OpBitNot        -- ^ ~
              | OpPlus          -- ^ +
              | OpMinus         -- ^ -
              | OpMul           -- ^ *
              | OpDiv           -- ^ /
              | OpMod           -- ^ %
              | OpBitAnd        -- ^ &
              | OpBitOr         -- ^ \|
              | OpBitXor        -- ^ \^
              | OpAssign        -- ^ =
              | OpPlusAssign
              | OpMinusAssign
              | OpMulAssign
              | OpDivAssign
              | OpModAssign
              | OpAndAssign
              | OpOrAssign
              | OpXorAssign
              | OpShl
              | OpShr
              | OpShlAssign
              | OpShrAssign
              | OpEquals
              | OpNotEquals
              | OpLt
              | OpGt
              | OpLte
              | OpGte
              | OpNot
              | OpAnd
              | OpOr
              | OpPlusPlus
              | OpMinusMinus
              | OpComma
              | OpArrowStar
              | OpArrow
              | OpCall
              | OpIndex
              | OpQuestion -- ? ??
              | OpSizeofType
              | OpSizeofExpr
              | OpAlignofType
              | OpAlignofExpr
              | OpCast CXXType
              | OpVendor Int String
              deriving (Operator -> Operator -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Operator -> Operator -> Bool
$c/= :: Operator -> Operator -> Bool
== :: Operator -> Operator -> Bool
$c== :: Operator -> Operator -> Bool
Eq, Eq Operator
Operator -> Operator -> Bool
Operator -> Operator -> Ordering
Operator -> Operator -> Operator
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 :: Operator -> Operator -> Operator
$cmin :: Operator -> Operator -> Operator
max :: Operator -> Operator -> Operator
$cmax :: Operator -> Operator -> Operator
>= :: Operator -> Operator -> Bool
$c>= :: Operator -> Operator -> Bool
> :: Operator -> Operator -> Bool
$c> :: Operator -> Operator -> Bool
<= :: Operator -> Operator -> Bool
$c<= :: Operator -> Operator -> Bool
< :: Operator -> Operator -> Bool
$c< :: Operator -> Operator -> Bool
compare :: Operator -> Operator -> Ordering
$ccompare :: Operator -> Operator -> Ordering
Ord, Int -> Operator -> ShowS
[Operator] -> ShowS
Operator -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Operator] -> ShowS
$cshowList :: [Operator] -> ShowS
show :: Operator -> String
$cshow :: Operator -> String
showsPrec :: Int -> Operator -> ShowS
$cshowsPrec :: Int -> Operator -> ShowS
Show, Typeable Operator
Operator -> DataType
Operator -> Constr
(forall b. Data b => b -> b) -> Operator -> Operator
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) -> Operator -> u
forall u. (forall d. Data d => d -> u) -> Operator -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Operator -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Operator -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Operator -> m Operator
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Operator -> m Operator
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Operator
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Operator -> c Operator
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Operator)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Operator)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Operator -> m Operator
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Operator -> m Operator
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Operator -> m Operator
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Operator -> m Operator
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Operator -> m Operator
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Operator -> m Operator
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Operator -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Operator -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Operator -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Operator -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Operator -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Operator -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Operator -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Operator -> r
gmapT :: (forall b. Data b => b -> b) -> Operator -> Operator
$cgmapT :: (forall b. Data b => b -> b) -> Operator -> Operator
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Operator)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Operator)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Operator)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Operator)
dataTypeOf :: Operator -> DataType
$cdataTypeOf :: Operator -> DataType
toConstr :: Operator -> Constr
$ctoConstr :: Operator -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Operator
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Operator
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Operator -> c Operator
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Operator -> c Operator
Data, Typeable)