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

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

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

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

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

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

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

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

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