-- |
-- Module      :  Language.C.Syntax
-- Copyright   :  (c) 2006-2011 Harvard University
--                (c) 2011-2013 Geoffrey Mainland
--                (c) 2013 Manuel M T Chakravarty
--             :  (c) 2013-2016 Drexel University
-- License     :  BSD-style
-- Maintainer  :  mainland@drexel.edu

{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE FlexibleInstances #-}

module Language.C.Syntax where

import Data.Data (Data(..))
import Data.Loc
import Data.String (IsString(..))
import Data.Typeable (Typeable)

data Extensions = Antiquotation
                | C99
                | C11
                | Gcc
                | Blocks
                | ObjC
                | CUDA
                | OpenCL
  deriving (Extensions -> Extensions -> Bool
(Extensions -> Extensions -> Bool)
-> (Extensions -> Extensions -> Bool) -> Eq Extensions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Extensions -> Extensions -> Bool
$c/= :: Extensions -> Extensions -> Bool
== :: Extensions -> Extensions -> Bool
$c== :: Extensions -> Extensions -> Bool
Eq, Eq Extensions
Eq Extensions
-> (Extensions -> Extensions -> Ordering)
-> (Extensions -> Extensions -> Bool)
-> (Extensions -> Extensions -> Bool)
-> (Extensions -> Extensions -> Bool)
-> (Extensions -> Extensions -> Bool)
-> (Extensions -> Extensions -> Extensions)
-> (Extensions -> Extensions -> Extensions)
-> Ord Extensions
Extensions -> Extensions -> Bool
Extensions -> Extensions -> Ordering
Extensions -> Extensions -> Extensions
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Extensions -> Extensions -> Extensions
$cmin :: Extensions -> Extensions -> Extensions
max :: Extensions -> Extensions -> Extensions
$cmax :: Extensions -> Extensions -> Extensions
>= :: Extensions -> Extensions -> Bool
$c>= :: Extensions -> Extensions -> Bool
> :: Extensions -> Extensions -> Bool
$c> :: Extensions -> Extensions -> Bool
<= :: Extensions -> Extensions -> Bool
$c<= :: Extensions -> Extensions -> Bool
< :: Extensions -> Extensions -> Bool
$c< :: Extensions -> Extensions -> Bool
compare :: Extensions -> Extensions -> Ordering
$ccompare :: Extensions -> Extensions -> Ordering
$cp1Ord :: Eq Extensions
Ord, Int -> Extensions
Extensions -> Int
Extensions -> [Extensions]
Extensions -> Extensions
Extensions -> Extensions -> [Extensions]
Extensions -> Extensions -> Extensions -> [Extensions]
(Extensions -> Extensions)
-> (Extensions -> Extensions)
-> (Int -> Extensions)
-> (Extensions -> Int)
-> (Extensions -> [Extensions])
-> (Extensions -> Extensions -> [Extensions])
-> (Extensions -> Extensions -> [Extensions])
-> (Extensions -> Extensions -> Extensions -> [Extensions])
-> Enum Extensions
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Extensions -> Extensions -> Extensions -> [Extensions]
$cenumFromThenTo :: Extensions -> Extensions -> Extensions -> [Extensions]
enumFromTo :: Extensions -> Extensions -> [Extensions]
$cenumFromTo :: Extensions -> Extensions -> [Extensions]
enumFromThen :: Extensions -> Extensions -> [Extensions]
$cenumFromThen :: Extensions -> Extensions -> [Extensions]
enumFrom :: Extensions -> [Extensions]
$cenumFrom :: Extensions -> [Extensions]
fromEnum :: Extensions -> Int
$cfromEnum :: Extensions -> Int
toEnum :: Int -> Extensions
$ctoEnum :: Int -> Extensions
pred :: Extensions -> Extensions
$cpred :: Extensions -> Extensions
succ :: Extensions -> Extensions
$csucc :: Extensions -> Extensions
Enum, Int -> Extensions -> ShowS
[Extensions] -> ShowS
Extensions -> String
(Int -> Extensions -> ShowS)
-> (Extensions -> String)
-> ([Extensions] -> ShowS)
-> Show Extensions
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Extensions] -> ShowS
$cshowList :: [Extensions] -> ShowS
show :: Extensions -> String
$cshow :: Extensions -> String
showsPrec :: Int -> Extensions -> ShowS
$cshowsPrec :: Int -> Extensions -> ShowS
Show)

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

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

type Linkage = StringLit

data Storage = Tauto                   !SrcLoc
             | Tregister               !SrcLoc
             | Tstatic                 !SrcLoc
             | Textern (Maybe Linkage) !SrcLoc
             | Ttypedef                !SrcLoc

             -- Clang blocks
             | T__block !SrcLoc

             -- Objective-C
             | TObjC__weak              !SrcLoc
             | TObjC__strong            !SrcLoc
             | TObjC__unsafe_unretained !SrcLoc
    deriving (Storage -> Storage -> Bool
(Storage -> Storage -> Bool)
-> (Storage -> Storage -> Bool) -> Eq Storage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Storage -> Storage -> Bool
$c/= :: Storage -> Storage -> Bool
== :: Storage -> Storage -> Bool
$c== :: Storage -> Storage -> Bool
Eq, Eq Storage
Eq Storage
-> (Storage -> Storage -> Ordering)
-> (Storage -> Storage -> Bool)
-> (Storage -> Storage -> Bool)
-> (Storage -> Storage -> Bool)
-> (Storage -> Storage -> Bool)
-> (Storage -> Storage -> Storage)
-> (Storage -> Storage -> Storage)
-> Ord Storage
Storage -> Storage -> Bool
Storage -> Storage -> Ordering
Storage -> Storage -> Storage
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Storage -> Storage -> Storage
$cmin :: Storage -> Storage -> Storage
max :: Storage -> Storage -> Storage
$cmax :: Storage -> Storage -> Storage
>= :: Storage -> Storage -> Bool
$c>= :: Storage -> Storage -> Bool
> :: Storage -> Storage -> Bool
$c> :: Storage -> Storage -> Bool
<= :: Storage -> Storage -> Bool
$c<= :: Storage -> Storage -> Bool
< :: Storage -> Storage -> Bool
$c< :: Storage -> Storage -> Bool
compare :: Storage -> Storage -> Ordering
$ccompare :: Storage -> Storage -> Ordering
$cp1Ord :: Eq Storage
Ord, Int -> Storage -> ShowS
[Storage] -> ShowS
Storage -> String
(Int -> Storage -> ShowS)
-> (Storage -> String) -> ([Storage] -> ShowS) -> Show Storage
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Storage] -> ShowS
$cshowList :: [Storage] -> ShowS
show :: Storage -> String
$cshow :: Storage -> String
showsPrec :: Int -> Storage -> ShowS
$cshowsPrec :: Int -> Storage -> ShowS
Show, Typeable Storage
DataType
Constr
Typeable Storage
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Storage -> c Storage)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Storage)
-> (Storage -> Constr)
-> (Storage -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Storage))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Storage))
-> ((forall b. Data b => b -> b) -> Storage -> Storage)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Storage -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Storage -> r)
-> (forall u. (forall d. Data d => d -> u) -> Storage -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Storage -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Storage -> m Storage)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Storage -> m Storage)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Storage -> m Storage)
-> Data Storage
Storage -> DataType
Storage -> Constr
(forall b. Data b => b -> b) -> Storage -> Storage
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Storage -> c Storage
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Storage
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) -> Storage -> u
forall u. (forall d. Data d => d -> u) -> Storage -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Storage -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Storage -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Storage -> m Storage
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Storage -> m Storage
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Storage
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Storage -> c Storage
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Storage)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Storage)
$cTObjC__unsafe_unretained :: Constr
$cTObjC__strong :: Constr
$cTObjC__weak :: Constr
$cT__block :: Constr
$cTtypedef :: Constr
$cTextern :: Constr
$cTstatic :: Constr
$cTregister :: Constr
$cTauto :: Constr
$tStorage :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Storage -> m Storage
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Storage -> m Storage
gmapMp :: (forall d. Data d => d -> m d) -> Storage -> m Storage
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Storage -> m Storage
gmapM :: (forall d. Data d => d -> m d) -> Storage -> m Storage
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Storage -> m Storage
gmapQi :: Int -> (forall d. Data d => d -> u) -> Storage -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Storage -> u
gmapQ :: (forall d. Data d => d -> u) -> Storage -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Storage -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Storage -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Storage -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Storage -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Storage -> r
gmapT :: (forall b. Data b => b -> b) -> Storage -> Storage
$cgmapT :: (forall b. Data b => b -> b) -> Storage -> Storage
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Storage)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Storage)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Storage)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Storage)
dataTypeOf :: Storage -> DataType
$cdataTypeOf :: Storage -> DataType
toConstr :: Storage -> Constr
$ctoConstr :: Storage -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Storage
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Storage
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Storage -> c Storage
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Storage -> c Storage
$cp1Data :: Typeable Storage
Data, Typeable)

data TypeQual = Tconst    !SrcLoc
              | Tvolatile !SrcLoc

              | EscTypeQual String !SrcLoc

              | AntiTypeQual  String !SrcLoc
              | AntiTypeQuals String !SrcLoc

              -- C99
              | Tinline   !SrcLoc
              | Trestrict !SrcLoc

              -- GCC
              | T__restrict !SrcLoc
              | TAttr Attr

              -- CUDA
              | TCUDAdevice   !SrcLoc
              | TCUDAglobal   !SrcLoc
              | TCUDAhost     !SrcLoc
              | TCUDAconstant !SrcLoc
              | TCUDAshared   !SrcLoc
              | TCUDArestrict !SrcLoc
              | TCUDAnoinline !SrcLoc

              -- OpenCL
              | TCLprivate   !SrcLoc
              | TCLlocal     !SrcLoc
              | TCLglobal    !SrcLoc
              | TCLconstant  !SrcLoc
              | TCLreadonly  !SrcLoc
              | TCLwriteonly !SrcLoc
              | TCLkernel    !SrcLoc
    deriving (TypeQual -> TypeQual -> Bool
(TypeQual -> TypeQual -> Bool)
-> (TypeQual -> TypeQual -> Bool) -> Eq TypeQual
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeQual -> TypeQual -> Bool
$c/= :: TypeQual -> TypeQual -> Bool
== :: TypeQual -> TypeQual -> Bool
$c== :: TypeQual -> TypeQual -> Bool
Eq, Eq TypeQual
Eq TypeQual
-> (TypeQual -> TypeQual -> Ordering)
-> (TypeQual -> TypeQual -> Bool)
-> (TypeQual -> TypeQual -> Bool)
-> (TypeQual -> TypeQual -> Bool)
-> (TypeQual -> TypeQual -> Bool)
-> (TypeQual -> TypeQual -> TypeQual)
-> (TypeQual -> TypeQual -> TypeQual)
-> Ord TypeQual
TypeQual -> TypeQual -> Bool
TypeQual -> TypeQual -> Ordering
TypeQual -> TypeQual -> TypeQual
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TypeQual -> TypeQual -> TypeQual
$cmin :: TypeQual -> TypeQual -> TypeQual
max :: TypeQual -> TypeQual -> TypeQual
$cmax :: TypeQual -> TypeQual -> TypeQual
>= :: TypeQual -> TypeQual -> Bool
$c>= :: TypeQual -> TypeQual -> Bool
> :: TypeQual -> TypeQual -> Bool
$c> :: TypeQual -> TypeQual -> Bool
<= :: TypeQual -> TypeQual -> Bool
$c<= :: TypeQual -> TypeQual -> Bool
< :: TypeQual -> TypeQual -> Bool
$c< :: TypeQual -> TypeQual -> Bool
compare :: TypeQual -> TypeQual -> Ordering
$ccompare :: TypeQual -> TypeQual -> Ordering
$cp1Ord :: Eq TypeQual
Ord, Int -> TypeQual -> ShowS
[TypeQual] -> ShowS
TypeQual -> String
(Int -> TypeQual -> ShowS)
-> (TypeQual -> String) -> ([TypeQual] -> ShowS) -> Show TypeQual
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TypeQual] -> ShowS
$cshowList :: [TypeQual] -> ShowS
show :: TypeQual -> String
$cshow :: TypeQual -> String
showsPrec :: Int -> TypeQual -> ShowS
$cshowsPrec :: Int -> TypeQual -> ShowS
Show, Typeable TypeQual
DataType
Constr
Typeable TypeQual
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TypeQual -> c TypeQual)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TypeQual)
-> (TypeQual -> Constr)
-> (TypeQual -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TypeQual))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeQual))
-> ((forall b. Data b => b -> b) -> TypeQual -> TypeQual)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeQual -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeQual -> r)
-> (forall u. (forall d. Data d => d -> u) -> TypeQual -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TypeQual -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypeQual -> m TypeQual)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeQual -> m TypeQual)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeQual -> m TypeQual)
-> Data TypeQual
TypeQual -> DataType
TypeQual -> Constr
(forall b. Data b => b -> b) -> TypeQual -> TypeQual
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeQual -> c TypeQual
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeQual
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) -> TypeQual -> u
forall u. (forall d. Data d => d -> u) -> TypeQual -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeQual -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeQual -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeQual -> m TypeQual
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeQual -> m TypeQual
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeQual
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeQual -> c TypeQual
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeQual)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeQual)
$cTCLkernel :: Constr
$cTCLwriteonly :: Constr
$cTCLreadonly :: Constr
$cTCLconstant :: Constr
$cTCLglobal :: Constr
$cTCLlocal :: Constr
$cTCLprivate :: Constr
$cTCUDAnoinline :: Constr
$cTCUDArestrict :: Constr
$cTCUDAshared :: Constr
$cTCUDAconstant :: Constr
$cTCUDAhost :: Constr
$cTCUDAglobal :: Constr
$cTCUDAdevice :: Constr
$cTAttr :: Constr
$cT__restrict :: Constr
$cTrestrict :: Constr
$cTinline :: Constr
$cAntiTypeQuals :: Constr
$cAntiTypeQual :: Constr
$cEscTypeQual :: Constr
$cTvolatile :: Constr
$cTconst :: Constr
$tTypeQual :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TypeQual -> m TypeQual
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeQual -> m TypeQual
gmapMp :: (forall d. Data d => d -> m d) -> TypeQual -> m TypeQual
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeQual -> m TypeQual
gmapM :: (forall d. Data d => d -> m d) -> TypeQual -> m TypeQual
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeQual -> m TypeQual
gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeQual -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeQual -> u
gmapQ :: (forall d. Data d => d -> u) -> TypeQual -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypeQual -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeQual -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeQual -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeQual -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeQual -> r
gmapT :: (forall b. Data b => b -> b) -> TypeQual -> TypeQual
$cgmapT :: (forall b. Data b => b -> b) -> TypeQual -> TypeQual
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeQual)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeQual)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TypeQual)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeQual)
dataTypeOf :: TypeQual -> DataType
$cdataTypeOf :: TypeQual -> DataType
toConstr :: TypeQual -> Constr
$ctoConstr :: TypeQual -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeQual
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeQual
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeQual -> c TypeQual
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeQual -> c TypeQual
$cp1Data :: Typeable TypeQual
Data, Typeable)

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

data TypeSpec = Tvoid                   !SrcLoc
              | Tchar      (Maybe Sign) !SrcLoc
              | Tshort     (Maybe Sign) !SrcLoc
              | Tint       (Maybe Sign) !SrcLoc
              | Tlong      (Maybe Sign) !SrcLoc
              | Tlong_long (Maybe Sign) !SrcLoc
              | Tfloat                  !SrcLoc
              | Tdouble                 !SrcLoc
              | Tlong_double            !SrcLoc
              | Tstruct (Maybe Id) (Maybe [FieldGroup]) [Attr] !SrcLoc
              | Tunion  (Maybe Id) (Maybe [FieldGroup]) [Attr] !SrcLoc
              | Tenum   (Maybe Id) [CEnum]              [Attr] !SrcLoc
              | Tnamed Id       -- A typedef name
                       [Id]     -- Objective-C protocol references
                       !SrcLoc

              -- C99
              | T_Bool                 !SrcLoc
              | Tfloat_Complex         !SrcLoc
              | Tdouble_Complex        !SrcLoc
              | Tlong_double_Complex   !SrcLoc
              | Tfloat_Imaginary       !SrcLoc
              | Tdouble_Imaginary      !SrcLoc
              | Tlong_double_Imaginary !SrcLoc

              -- Gcc
              | TtypeofExp  Exp  !SrcLoc
              | TtypeofType Type !SrcLoc
              | Tva_list         !SrcLoc
    deriving (TypeSpec -> TypeSpec -> Bool
(TypeSpec -> TypeSpec -> Bool)
-> (TypeSpec -> TypeSpec -> Bool) -> Eq TypeSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeSpec -> TypeSpec -> Bool
$c/= :: TypeSpec -> TypeSpec -> Bool
== :: TypeSpec -> TypeSpec -> Bool
$c== :: TypeSpec -> TypeSpec -> Bool
Eq, Eq TypeSpec
Eq TypeSpec
-> (TypeSpec -> TypeSpec -> Ordering)
-> (TypeSpec -> TypeSpec -> Bool)
-> (TypeSpec -> TypeSpec -> Bool)
-> (TypeSpec -> TypeSpec -> Bool)
-> (TypeSpec -> TypeSpec -> Bool)
-> (TypeSpec -> TypeSpec -> TypeSpec)
-> (TypeSpec -> TypeSpec -> TypeSpec)
-> Ord TypeSpec
TypeSpec -> TypeSpec -> Bool
TypeSpec -> TypeSpec -> Ordering
TypeSpec -> TypeSpec -> TypeSpec
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TypeSpec -> TypeSpec -> TypeSpec
$cmin :: TypeSpec -> TypeSpec -> TypeSpec
max :: TypeSpec -> TypeSpec -> TypeSpec
$cmax :: TypeSpec -> TypeSpec -> TypeSpec
>= :: TypeSpec -> TypeSpec -> Bool
$c>= :: TypeSpec -> TypeSpec -> Bool
> :: TypeSpec -> TypeSpec -> Bool
$c> :: TypeSpec -> TypeSpec -> Bool
<= :: TypeSpec -> TypeSpec -> Bool
$c<= :: TypeSpec -> TypeSpec -> Bool
< :: TypeSpec -> TypeSpec -> Bool
$c< :: TypeSpec -> TypeSpec -> Bool
compare :: TypeSpec -> TypeSpec -> Ordering
$ccompare :: TypeSpec -> TypeSpec -> Ordering
$cp1Ord :: Eq TypeSpec
Ord, Int -> TypeSpec -> ShowS
[TypeSpec] -> ShowS
TypeSpec -> String
(Int -> TypeSpec -> ShowS)
-> (TypeSpec -> String) -> ([TypeSpec] -> ShowS) -> Show TypeSpec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TypeSpec] -> ShowS
$cshowList :: [TypeSpec] -> ShowS
show :: TypeSpec -> String
$cshow :: TypeSpec -> String
showsPrec :: Int -> TypeSpec -> ShowS
$cshowsPrec :: Int -> TypeSpec -> ShowS
Show, Typeable TypeSpec
DataType
Constr
Typeable TypeSpec
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TypeSpec -> c TypeSpec)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TypeSpec)
-> (TypeSpec -> Constr)
-> (TypeSpec -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TypeSpec))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeSpec))
-> ((forall b. Data b => b -> b) -> TypeSpec -> TypeSpec)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeSpec -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeSpec -> r)
-> (forall u. (forall d. Data d => d -> u) -> TypeSpec -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TypeSpec -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypeSpec -> m TypeSpec)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeSpec -> m TypeSpec)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeSpec -> m TypeSpec)
-> Data TypeSpec
TypeSpec -> DataType
TypeSpec -> Constr
(forall b. Data b => b -> b) -> TypeSpec -> TypeSpec
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeSpec -> c TypeSpec
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeSpec
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) -> TypeSpec -> u
forall u. (forall d. Data d => d -> u) -> TypeSpec -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSpec -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSpec -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeSpec -> m TypeSpec
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeSpec -> m TypeSpec
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeSpec
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeSpec -> c TypeSpec
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeSpec)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeSpec)
$cTva_list :: Constr
$cTtypeofType :: Constr
$cTtypeofExp :: Constr
$cTlong_double_Imaginary :: Constr
$cTdouble_Imaginary :: Constr
$cTfloat_Imaginary :: Constr
$cTlong_double_Complex :: Constr
$cTdouble_Complex :: Constr
$cTfloat_Complex :: Constr
$cT_Bool :: Constr
$cTnamed :: Constr
$cTenum :: Constr
$cTunion :: Constr
$cTstruct :: Constr
$cTlong_double :: Constr
$cTdouble :: Constr
$cTfloat :: Constr
$cTlong_long :: Constr
$cTlong :: Constr
$cTint :: Constr
$cTshort :: Constr
$cTchar :: Constr
$cTvoid :: Constr
$tTypeSpec :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TypeSpec -> m TypeSpec
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeSpec -> m TypeSpec
gmapMp :: (forall d. Data d => d -> m d) -> TypeSpec -> m TypeSpec
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeSpec -> m TypeSpec
gmapM :: (forall d. Data d => d -> m d) -> TypeSpec -> m TypeSpec
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeSpec -> m TypeSpec
gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeSpec -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeSpec -> u
gmapQ :: (forall d. Data d => d -> u) -> TypeSpec -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypeSpec -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSpec -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSpec -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSpec -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSpec -> r
gmapT :: (forall b. Data b => b -> b) -> TypeSpec -> TypeSpec
$cgmapT :: (forall b. Data b => b -> b) -> TypeSpec -> TypeSpec
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeSpec)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeSpec)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TypeSpec)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeSpec)
dataTypeOf :: TypeSpec -> DataType
$cdataTypeOf :: TypeSpec -> DataType
toConstr :: TypeSpec -> Constr
$ctoConstr :: TypeSpec -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeSpec
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeSpec
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeSpec -> c TypeSpec
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeSpec -> c TypeSpec
$cp1Data :: Typeable TypeSpec
Data, Typeable)

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

-- | There are two types of declarators in C, regular declarators and abstract
-- declarators. The former is for declaring variables, function parameters,
-- typedefs, etc. and the latter for abstract types---@typedef int
-- ({*}foo)(void)@ vs. @\tt int ({*})(void)@. The difference between the two is
-- just whether or not an identifier is attached to the declarator. We therefore
-- only define one 'Decl' type and use it for both cases.

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

data Decl = DeclRoot !SrcLoc
          | Ptr [TypeQual] Decl !SrcLoc
          | Array [TypeQual] ArraySize Decl !SrcLoc
          | Proto Decl Params !SrcLoc
          | OldProto Decl [Id] !SrcLoc
          | AntiTypeDecl String !SrcLoc

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

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

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

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

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

type AsmLabel = StringLit

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

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

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

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

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

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

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

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

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

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

data Definition  =  FuncDef    Func      !SrcLoc
                 |  DecDef     InitGroup !SrcLoc
                 |  EscDef     String    !SrcLoc
                 |  AntiFunc   String    !SrcLoc
                 |  AntiEsc    String    !SrcLoc
                 |  AntiEdecl  String    !SrcLoc
                 |  AntiEdecls String    !SrcLoc

                 -- Objective-C
                 |  ObjCClassDec   [Id] !SrcLoc
                 |  ObjCClassIface Id (Maybe Id) [Id] [ObjCIvarDecl] [ObjCIfaceDecl] [Attr] !SrcLoc
                 |  ObjCCatIface   Id (Maybe Id) [Id] [ObjCIvarDecl] [ObjCIfaceDecl]        !SrcLoc
                 |  ObjCProtDec    [Id] !SrcLoc
                 |  ObjCProtDef    Id [Id] [ObjCIfaceDecl] !SrcLoc
                 |  ObjCClassImpl  Id (Maybe Id) [ObjCIvarDecl] [Definition] !SrcLoc
                 |  ObjCCatImpl    Id Id [Definition] !SrcLoc
                 |  ObjCSynDef     [(Id, Maybe Id)] !SrcLoc
                 |  ObjCDynDef     [Id] !SrcLoc
                 |  ObjCMethDef    ObjCMethodProto [BlockItem] !SrcLoc
                 |  ObjCCompAlias  Id Id !SrcLoc

                 |  AntiObjCMeth  String !SrcLoc
                 |  AntiObjCMeths String !SrcLoc
    deriving (Definition -> Definition -> Bool
(Definition -> Definition -> Bool)
-> (Definition -> Definition -> Bool) -> Eq Definition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Definition -> Definition -> Bool
$c/= :: Definition -> Definition -> Bool
== :: Definition -> Definition -> Bool
$c== :: Definition -> Definition -> Bool
Eq, Eq Definition
Eq Definition
-> (Definition -> Definition -> Ordering)
-> (Definition -> Definition -> Bool)
-> (Definition -> Definition -> Bool)
-> (Definition -> Definition -> Bool)
-> (Definition -> Definition -> Bool)
-> (Definition -> Definition -> Definition)
-> (Definition -> Definition -> Definition)
-> Ord Definition
Definition -> Definition -> Bool
Definition -> Definition -> Ordering
Definition -> Definition -> Definition
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Definition -> Definition -> Definition
$cmin :: Definition -> Definition -> Definition
max :: Definition -> Definition -> Definition
$cmax :: Definition -> Definition -> Definition
>= :: Definition -> Definition -> Bool
$c>= :: Definition -> Definition -> Bool
> :: Definition -> Definition -> Bool
$c> :: Definition -> Definition -> Bool
<= :: Definition -> Definition -> Bool
$c<= :: Definition -> Definition -> Bool
< :: Definition -> Definition -> Bool
$c< :: Definition -> Definition -> Bool
compare :: Definition -> Definition -> Ordering
$ccompare :: Definition -> Definition -> Ordering
$cp1Ord :: Eq Definition
Ord, Int -> Definition -> ShowS
[Definition] -> ShowS
Definition -> String
(Int -> Definition -> ShowS)
-> (Definition -> String)
-> ([Definition] -> ShowS)
-> Show Definition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Definition] -> ShowS
$cshowList :: [Definition] -> ShowS
show :: Definition -> String
$cshow :: Definition -> String
showsPrec :: Int -> Definition -> ShowS
$cshowsPrec :: Int -> Definition -> ShowS
Show, Typeable Definition
DataType
Constr
Typeable Definition
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Definition -> c Definition)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Definition)
-> (Definition -> Constr)
-> (Definition -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Definition))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Definition))
-> ((forall b. Data b => b -> b) -> Definition -> Definition)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Definition -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Definition -> r)
-> (forall u. (forall d. Data d => d -> u) -> Definition -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Definition -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Definition -> m Definition)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Definition -> m Definition)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Definition -> m Definition)
-> Data Definition
Definition -> DataType
Definition -> Constr
(forall b. Data b => b -> b) -> Definition -> Definition
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Definition -> c Definition
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Definition
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) -> Definition -> u
forall u. (forall d. Data d => d -> u) -> Definition -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Definition -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Definition -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Definition -> m Definition
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Definition -> m Definition
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Definition
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Definition -> c Definition
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Definition)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Definition)
$cAntiObjCMeths :: Constr
$cAntiObjCMeth :: Constr
$cObjCCompAlias :: Constr
$cObjCMethDef :: Constr
$cObjCDynDef :: Constr
$cObjCSynDef :: Constr
$cObjCCatImpl :: Constr
$cObjCClassImpl :: Constr
$cObjCProtDef :: Constr
$cObjCProtDec :: Constr
$cObjCCatIface :: Constr
$cObjCClassIface :: Constr
$cObjCClassDec :: Constr
$cAntiEdecls :: Constr
$cAntiEdecl :: Constr
$cAntiEsc :: Constr
$cAntiFunc :: Constr
$cEscDef :: Constr
$cDecDef :: Constr
$cFuncDef :: Constr
$tDefinition :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Definition -> m Definition
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Definition -> m Definition
gmapMp :: (forall d. Data d => d -> m d) -> Definition -> m Definition
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Definition -> m Definition
gmapM :: (forall d. Data d => d -> m d) -> Definition -> m Definition
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Definition -> m Definition
gmapQi :: Int -> (forall d. Data d => d -> u) -> Definition -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Definition -> u
gmapQ :: (forall d. Data d => d -> u) -> Definition -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Definition -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Definition -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Definition -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Definition -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Definition -> r
gmapT :: (forall b. Data b => b -> b) -> Definition -> Definition
$cgmapT :: (forall b. Data b => b -> b) -> Definition -> Definition
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Definition)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Definition)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Definition)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Definition)
dataTypeOf :: Definition -> DataType
$cdataTypeOf :: Definition -> DataType
toConstr :: Definition -> Constr
$ctoConstr :: Definition -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Definition
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Definition
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Definition -> c Definition
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Definition -> c Definition
$cp1Data :: Typeable Definition
Data, Typeable)

data Stm  = Label Id [Attr] Stm !SrcLoc
          | Case Exp Stm !SrcLoc
          | CaseRange Exp Exp Stm !SrcLoc
          | Default Stm !SrcLoc
          | Exp (Maybe Exp) !SrcLoc
          | Block [BlockItem] !SrcLoc
          | If Exp Stm (Maybe Stm) !SrcLoc
          | Switch Exp Stm !SrcLoc
          | While Exp Stm !SrcLoc
          | DoWhile Stm Exp !SrcLoc
          | For (Either InitGroup (Maybe Exp)) (Maybe Exp) (Maybe Exp) Stm !SrcLoc
          | Goto Id !SrcLoc
          | Continue !SrcLoc
          | Break !SrcLoc
          | Return (Maybe Exp) !SrcLoc
          | Pragma String !SrcLoc
          | Comment String Stm !SrcLoc
          | EscStm String !SrcLoc
          | AntiEscStm String !SrcLoc
          | AntiPragma String !SrcLoc
          | AntiComment String Stm !SrcLoc
          | AntiStm String !SrcLoc
          | AntiStms String !SrcLoc

          -- GCC
          | Asm Bool         -- @True@ if volatile, @False@ otherwise
                [Attr]       -- Attributes
                AsmTemplate  -- Assembly template
                [AsmOut]     -- Output operands
                [AsmIn]      -- Input operands
                [AsmClobber] -- Clobbered registers
                !SrcLoc
          | AsmGoto Bool         -- @True@ if volatile, @False@ otherwise
                    [Attr]       -- Attributes
                    AsmTemplate  -- Assembly template
                    [AsmIn]      -- Input operands
                    [AsmClobber] -- Clobbered registers
                    [Id]         -- Labels
                    !SrcLoc

          -- Objective-C
          | ObjCTry [BlockItem] [ObjCCatch] (Maybe [BlockItem]) !SrcLoc
            -- ^Invariant: There is either at least one 'ObjCCatch' or the finally block is present.
          | ObjCThrow (Maybe Exp) !SrcLoc
          | ObjCSynchronized Exp [BlockItem] !SrcLoc
          | ObjCAutoreleasepool [BlockItem] !SrcLoc
    deriving (Stm -> Stm -> Bool
(Stm -> Stm -> Bool) -> (Stm -> Stm -> Bool) -> Eq Stm
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Stm -> Stm -> Bool
$c/= :: Stm -> Stm -> Bool
== :: Stm -> Stm -> Bool
$c== :: Stm -> Stm -> Bool
Eq, Eq Stm
Eq Stm
-> (Stm -> Stm -> Ordering)
-> (Stm -> Stm -> Bool)
-> (Stm -> Stm -> Bool)
-> (Stm -> Stm -> Bool)
-> (Stm -> Stm -> Bool)
-> (Stm -> Stm -> Stm)
-> (Stm -> Stm -> Stm)
-> Ord Stm
Stm -> Stm -> Bool
Stm -> Stm -> Ordering
Stm -> Stm -> Stm
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Stm -> Stm -> Stm
$cmin :: Stm -> Stm -> Stm
max :: Stm -> Stm -> Stm
$cmax :: Stm -> Stm -> Stm
>= :: Stm -> Stm -> Bool
$c>= :: Stm -> Stm -> Bool
> :: Stm -> Stm -> Bool
$c> :: Stm -> Stm -> Bool
<= :: Stm -> Stm -> Bool
$c<= :: Stm -> Stm -> Bool
< :: Stm -> Stm -> Bool
$c< :: Stm -> Stm -> Bool
compare :: Stm -> Stm -> Ordering
$ccompare :: Stm -> Stm -> Ordering
$cp1Ord :: Eq Stm
Ord, Int -> Stm -> ShowS
[Stm] -> ShowS
Stm -> String
(Int -> Stm -> ShowS)
-> (Stm -> String) -> ([Stm] -> ShowS) -> Show Stm
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Stm] -> ShowS
$cshowList :: [Stm] -> ShowS
show :: Stm -> String
$cshow :: Stm -> String
showsPrec :: Int -> Stm -> ShowS
$cshowsPrec :: Int -> Stm -> ShowS
Show, Typeable Stm
DataType
Constr
Typeable Stm
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Stm -> c Stm)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Stm)
-> (Stm -> Constr)
-> (Stm -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Stm))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stm))
-> ((forall b. Data b => b -> b) -> Stm -> Stm)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stm -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stm -> r)
-> (forall u. (forall d. Data d => d -> u) -> Stm -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Stm -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Stm -> m Stm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Stm -> m Stm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Stm -> m Stm)
-> Data Stm
Stm -> DataType
Stm -> Constr
(forall b. Data b => b -> b) -> Stm -> Stm
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stm -> c Stm
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Stm
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) -> Stm -> u
forall u. (forall d. Data d => d -> u) -> Stm -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stm -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stm -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Stm -> m Stm
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stm -> m Stm
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Stm
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stm -> c Stm
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Stm)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stm)
$cObjCAutoreleasepool :: Constr
$cObjCSynchronized :: Constr
$cObjCThrow :: Constr
$cObjCTry :: Constr
$cAsmGoto :: Constr
$cAsm :: Constr
$cAntiStms :: Constr
$cAntiStm :: Constr
$cAntiComment :: Constr
$cAntiPragma :: Constr
$cAntiEscStm :: Constr
$cEscStm :: Constr
$cComment :: Constr
$cPragma :: Constr
$cReturn :: Constr
$cBreak :: Constr
$cContinue :: Constr
$cGoto :: Constr
$cFor :: Constr
$cDoWhile :: Constr
$cWhile :: Constr
$cSwitch :: Constr
$cIf :: Constr
$cBlock :: Constr
$cExp :: Constr
$cDefault :: Constr
$cCaseRange :: Constr
$cCase :: Constr
$cLabel :: Constr
$tStm :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Stm -> m Stm
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stm -> m Stm
gmapMp :: (forall d. Data d => d -> m d) -> Stm -> m Stm
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stm -> m Stm
gmapM :: (forall d. Data d => d -> m d) -> Stm -> m Stm
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Stm -> m Stm
gmapQi :: Int -> (forall d. Data d => d -> u) -> Stm -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Stm -> u
gmapQ :: (forall d. Data d => d -> u) -> Stm -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Stm -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stm -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stm -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stm -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stm -> r
gmapT :: (forall b. Data b => b -> b) -> Stm -> Stm
$cgmapT :: (forall b. Data b => b -> b) -> Stm -> Stm
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stm)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stm)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Stm)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Stm)
dataTypeOf :: Stm -> DataType
$cdataTypeOf :: Stm -> DataType
toConstr :: Stm -> Constr
$ctoConstr :: Stm -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Stm
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Stm
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stm -> c Stm
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stm -> c Stm
$cp1Data :: Typeable Stm
Data, Typeable)

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

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

-- | The 'String' parameter to 'Const' data constructors is the raw string
-- representation of the constant as it was parsed.
data Const = IntConst         String   Signed Integer !SrcLoc
           | LongIntConst     String   Signed Integer !SrcLoc
           | LongLongIntConst String   Signed Integer !SrcLoc
           | FloatConst       String   Float          !SrcLoc
           | DoubleConst      String   Double         !SrcLoc
           | LongDoubleConst  String   Double         !SrcLoc
           | CharConst        String   Char           !SrcLoc
           | StringConst      [String] String         !SrcLoc

           | AntiConst      String !SrcLoc
           | AntiInt        String !SrcLoc
           | AntiUInt       String !SrcLoc
           | AntiLInt       String !SrcLoc
           | AntiULInt      String !SrcLoc
           | AntiLLInt      String !SrcLoc
           | AntiULLInt     String !SrcLoc
           | AntiFloat      String !SrcLoc
           | AntiDouble     String !SrcLoc
           | AntiLongDouble String !SrcLoc
           | AntiChar       String !SrcLoc
           | AntiString     String !SrcLoc
    deriving (Const -> Const -> Bool
(Const -> Const -> Bool) -> (Const -> Const -> Bool) -> Eq Const
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Const -> Const -> Bool
$c/= :: Const -> Const -> Bool
== :: Const -> Const -> Bool
$c== :: Const -> Const -> Bool
Eq, Eq Const
Eq Const
-> (Const -> Const -> Ordering)
-> (Const -> Const -> Bool)
-> (Const -> Const -> Bool)
-> (Const -> Const -> Bool)
-> (Const -> Const -> Bool)
-> (Const -> Const -> Const)
-> (Const -> Const -> Const)
-> Ord Const
Const -> Const -> Bool
Const -> Const -> Ordering
Const -> Const -> Const
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Const -> Const -> Const
$cmin :: Const -> Const -> Const
max :: Const -> Const -> Const
$cmax :: Const -> Const -> Const
>= :: Const -> Const -> Bool
$c>= :: Const -> Const -> Bool
> :: Const -> Const -> Bool
$c> :: Const -> Const -> Bool
<= :: Const -> Const -> Bool
$c<= :: Const -> Const -> Bool
< :: Const -> Const -> Bool
$c< :: Const -> Const -> Bool
compare :: Const -> Const -> Ordering
$ccompare :: Const -> Const -> Ordering
$cp1Ord :: Eq Const
Ord, Int -> Const -> ShowS
[Const] -> ShowS
Const -> String
(Int -> Const -> ShowS)
-> (Const -> String) -> ([Const] -> ShowS) -> Show Const
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Const] -> ShowS
$cshowList :: [Const] -> ShowS
show :: Const -> String
$cshow :: Const -> String
showsPrec :: Int -> Const -> ShowS
$cshowsPrec :: Int -> Const -> ShowS
Show, Typeable Const
DataType
Constr
Typeable Const
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Const -> c Const)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Const)
-> (Const -> Constr)
-> (Const -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Const))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Const))
-> ((forall b. Data b => b -> b) -> Const -> Const)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r)
-> (forall u. (forall d. Data d => d -> u) -> Const -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Const -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Const -> m Const)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Const -> m Const)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Const -> m Const)
-> Data Const
Const -> DataType
Const -> Constr
(forall b. Data b => b -> b) -> Const -> Const
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Const -> c Const
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Const
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) -> Const -> u
forall u. (forall d. Data d => d -> u) -> Const -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Const -> m Const
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Const -> m Const
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Const
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Const -> c Const
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Const)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Const)
$cAntiString :: Constr
$cAntiChar :: Constr
$cAntiLongDouble :: Constr
$cAntiDouble :: Constr
$cAntiFloat :: Constr
$cAntiULLInt :: Constr
$cAntiLLInt :: Constr
$cAntiULInt :: Constr
$cAntiLInt :: Constr
$cAntiUInt :: Constr
$cAntiInt :: Constr
$cAntiConst :: Constr
$cStringConst :: Constr
$cCharConst :: Constr
$cLongDoubleConst :: Constr
$cDoubleConst :: Constr
$cFloatConst :: Constr
$cLongLongIntConst :: Constr
$cLongIntConst :: Constr
$cIntConst :: Constr
$tConst :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Const -> m Const
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Const -> m Const
gmapMp :: (forall d. Data d => d -> m d) -> Const -> m Const
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Const -> m Const
gmapM :: (forall d. Data d => d -> m d) -> Const -> m Const
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Const -> m Const
gmapQi :: Int -> (forall d. Data d => d -> u) -> Const -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Const -> u
gmapQ :: (forall d. Data d => d -> u) -> Const -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Const -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r
gmapT :: (forall b. Data b => b -> b) -> Const -> Const
$cgmapT :: (forall b. Data b => b -> b) -> Const -> Const
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Const)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Const)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Const)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Const)
dataTypeOf :: Const -> DataType
$cdataTypeOf :: Const -> DataType
toConstr :: Const -> Constr
$ctoConstr :: Const -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Const
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Const
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Const -> c Const
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Const -> c Const
$cp1Data :: Typeable Const
Data, Typeable)

data Exp = Var Id !SrcLoc
         | Const Const !SrcLoc
         | BinOp BinOp Exp Exp !SrcLoc
         | Assign Exp AssignOp Exp !SrcLoc
         | PreInc Exp !SrcLoc
         | PostInc Exp !SrcLoc
         | PreDec Exp !SrcLoc
         | PostDec Exp !SrcLoc
         | UnOp UnOp Exp !SrcLoc
         | SizeofExp Exp !SrcLoc
         | SizeofType Type !SrcLoc
         | Cast Type Exp !SrcLoc
         | Cond Exp Exp Exp !SrcLoc
         | Member Exp Id !SrcLoc
         | PtrMember Exp Id !SrcLoc
         | Index Exp Exp !SrcLoc
         | FnCall Exp [Exp] !SrcLoc
         | CudaCall Exp ExeConfig [Exp] !SrcLoc
         | Seq Exp Exp !SrcLoc
         | CompoundLit Type [(Maybe Designation, Initializer)] !SrcLoc
         | StmExpr [BlockItem] !SrcLoc
         | EscExp String !SrcLoc
         | AntiEscExp String !SrcLoc
         | AntiExp String !SrcLoc
         | AntiArgs String !SrcLoc

         -- GCC
         | BuiltinVaArg Exp Type !SrcLoc

         -- Clang blocks
         | BlockLit BlockType [Attr] [BlockItem] !SrcLoc

         -- Objective-C
         | ObjCMsg ObjCRecv [ObjCArg] [Exp] !SrcLoc
           -- ^Invariant: First argument must at least have either a selector or an expression;
           --  all other arguments must have an expression.
         | ObjCLitConst (Maybe UnOp)
                        Const        -- Anything except 'StringConst'
                        !SrcLoc
         | ObjCLitString [Const] -- Must all be 'StringConst'
                         !SrcLoc
         | ObjCLitBool Bool !SrcLoc
         | ObjCLitArray [Exp] !SrcLoc
         | ObjCLitDict [ObjCDictElem] !SrcLoc
         | ObjCLitBoxed Exp !SrcLoc
         | ObjCEncode Type !SrcLoc
         | ObjCProtocol Id !SrcLoc
         | ObjCSelector String !SrcLoc

         -- CUDA: C++11 lambda-expression
         | Lambda LambdaIntroducer (Maybe LambdaDeclarator) [BlockItem] !SrcLoc
    deriving (Exp -> Exp -> Bool
(Exp -> Exp -> Bool) -> (Exp -> Exp -> Bool) -> Eq Exp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Exp -> Exp -> Bool
$c/= :: Exp -> Exp -> Bool
== :: Exp -> Exp -> Bool
$c== :: Exp -> Exp -> Bool
Eq, Eq Exp
Eq Exp
-> (Exp -> Exp -> Ordering)
-> (Exp -> Exp -> Bool)
-> (Exp -> Exp -> Bool)
-> (Exp -> Exp -> Bool)
-> (Exp -> Exp -> Bool)
-> (Exp -> Exp -> Exp)
-> (Exp -> Exp -> Exp)
-> Ord Exp
Exp -> Exp -> Bool
Exp -> Exp -> Ordering
Exp -> Exp -> Exp
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Exp -> Exp -> Exp
$cmin :: Exp -> Exp -> Exp
max :: Exp -> Exp -> Exp
$cmax :: Exp -> Exp -> Exp
>= :: Exp -> Exp -> Bool
$c>= :: Exp -> Exp -> Bool
> :: Exp -> Exp -> Bool
$c> :: Exp -> Exp -> Bool
<= :: Exp -> Exp -> Bool
$c<= :: Exp -> Exp -> Bool
< :: Exp -> Exp -> Bool
$c< :: Exp -> Exp -> Bool
compare :: Exp -> Exp -> Ordering
$ccompare :: Exp -> Exp -> Ordering
$cp1Ord :: Eq Exp
Ord, Int -> Exp -> ShowS
[Exp] -> ShowS
Exp -> String
(Int -> Exp -> ShowS)
-> (Exp -> String) -> ([Exp] -> ShowS) -> Show Exp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Exp] -> ShowS
$cshowList :: [Exp] -> ShowS
show :: Exp -> String
$cshow :: Exp -> String
showsPrec :: Int -> Exp -> ShowS
$cshowsPrec :: Int -> Exp -> ShowS
Show, Typeable Exp
DataType
Constr
Typeable Exp
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Exp -> c Exp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Exp)
-> (Exp -> Constr)
-> (Exp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Exp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp))
-> ((forall b. Data b => b -> b) -> Exp -> Exp)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r)
-> (forall u. (forall d. Data d => d -> u) -> Exp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Exp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Exp -> m Exp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Exp -> m Exp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Exp -> m Exp)
-> Data Exp
Exp -> DataType
Exp -> Constr
(forall b. Data b => b -> b) -> Exp -> Exp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp -> c Exp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Exp
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) -> Exp -> u
forall u. (forall d. Data d => d -> u) -> Exp -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Exp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp -> c Exp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Exp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp)
$cLambda :: Constr
$cObjCSelector :: Constr
$cObjCProtocol :: Constr
$cObjCEncode :: Constr
$cObjCLitBoxed :: Constr
$cObjCLitDict :: Constr
$cObjCLitArray :: Constr
$cObjCLitBool :: Constr
$cObjCLitString :: Constr
$cObjCLitConst :: Constr
$cObjCMsg :: Constr
$cBlockLit :: Constr
$cBuiltinVaArg :: Constr
$cAntiArgs :: Constr
$cAntiExp :: Constr
$cAntiEscExp :: Constr
$cEscExp :: Constr
$cStmExpr :: Constr
$cCompoundLit :: Constr
$cSeq :: Constr
$cCudaCall :: Constr
$cFnCall :: Constr
$cIndex :: Constr
$cPtrMember :: Constr
$cMember :: Constr
$cCond :: Constr
$cCast :: Constr
$cSizeofType :: Constr
$cSizeofExp :: Constr
$cUnOp :: Constr
$cPostDec :: Constr
$cPreDec :: Constr
$cPostInc :: Constr
$cPreInc :: Constr
$cAssign :: Constr
$cBinOp :: Constr
$cConst :: Constr
$cVar :: Constr
$tExp :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Exp -> m Exp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
gmapMp :: (forall d. Data d => d -> m d) -> Exp -> m Exp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
gmapM :: (forall d. Data d => d -> m d) -> Exp -> m Exp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
gmapQi :: Int -> (forall d. Data d => d -> u) -> Exp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Exp -> u
gmapQ :: (forall d. Data d => d -> u) -> Exp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Exp -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
gmapT :: (forall b. Data b => b -> b) -> Exp -> Exp
$cgmapT :: (forall b. Data b => b -> b) -> Exp -> Exp
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Exp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Exp)
dataTypeOf :: Exp -> DataType
$cdataTypeOf :: Exp -> DataType
toConstr :: Exp -> Constr
$ctoConstr :: Exp -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Exp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Exp
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp -> c Exp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp -> c Exp
$cp1Data :: Typeable Exp
Data, Typeable)

data BinOp = Add
           | Sub
           | Mul
           | Div
           | Mod
           | Eq
           | Ne
           | Lt
           | Gt
           | Le
           | Ge
           | Land
           | Lor
           | And
           | Or
           | Xor
           | Lsh
           | Rsh
    deriving (BinOp -> BinOp -> Bool
(BinOp -> BinOp -> Bool) -> (BinOp -> BinOp -> Bool) -> Eq BinOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BinOp -> BinOp -> Bool
$c/= :: BinOp -> BinOp -> Bool
== :: BinOp -> BinOp -> Bool
$c== :: BinOp -> BinOp -> Bool
Eq, Eq BinOp
Eq BinOp
-> (BinOp -> BinOp -> Ordering)
-> (BinOp -> BinOp -> Bool)
-> (BinOp -> BinOp -> Bool)
-> (BinOp -> BinOp -> Bool)
-> (BinOp -> BinOp -> Bool)
-> (BinOp -> BinOp -> BinOp)
-> (BinOp -> BinOp -> BinOp)
-> Ord BinOp
BinOp -> BinOp -> Bool
BinOp -> BinOp -> Ordering
BinOp -> BinOp -> BinOp
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BinOp -> BinOp -> BinOp
$cmin :: BinOp -> BinOp -> BinOp
max :: BinOp -> BinOp -> BinOp
$cmax :: BinOp -> BinOp -> BinOp
>= :: BinOp -> BinOp -> Bool
$c>= :: BinOp -> BinOp -> Bool
> :: BinOp -> BinOp -> Bool
$c> :: BinOp -> BinOp -> Bool
<= :: BinOp -> BinOp -> Bool
$c<= :: BinOp -> BinOp -> Bool
< :: BinOp -> BinOp -> Bool
$c< :: BinOp -> BinOp -> Bool
compare :: BinOp -> BinOp -> Ordering
$ccompare :: BinOp -> BinOp -> Ordering
$cp1Ord :: Eq BinOp
Ord, Int -> BinOp -> ShowS
[BinOp] -> ShowS
BinOp -> String
(Int -> BinOp -> ShowS)
-> (BinOp -> String) -> ([BinOp] -> ShowS) -> Show BinOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BinOp] -> ShowS
$cshowList :: [BinOp] -> ShowS
show :: BinOp -> String
$cshow :: BinOp -> String
showsPrec :: Int -> BinOp -> ShowS
$cshowsPrec :: Int -> BinOp -> ShowS
Show, Typeable BinOp
DataType
Constr
Typeable BinOp
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BinOp -> c BinOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BinOp)
-> (BinOp -> Constr)
-> (BinOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BinOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BinOp))
-> ((forall b. Data b => b -> b) -> BinOp -> BinOp)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BinOp -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BinOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> BinOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> BinOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BinOp -> m BinOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BinOp -> m BinOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BinOp -> m BinOp)
-> Data BinOp
BinOp -> DataType
BinOp -> Constr
(forall b. Data b => b -> b) -> BinOp -> BinOp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BinOp -> c BinOp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BinOp
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) -> BinOp -> u
forall u. (forall d. Data d => d -> u) -> BinOp -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BinOp -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BinOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BinOp -> m BinOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BinOp -> m BinOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BinOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BinOp -> c BinOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BinOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BinOp)
$cRsh :: Constr
$cLsh :: Constr
$cXor :: Constr
$cOr :: Constr
$cAnd :: Constr
$cLor :: Constr
$cLand :: Constr
$cGe :: Constr
$cLe :: Constr
$cGt :: Constr
$cLt :: Constr
$cNe :: Constr
$cEq :: Constr
$cMod :: Constr
$cDiv :: Constr
$cMul :: Constr
$cSub :: Constr
$cAdd :: Constr
$tBinOp :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> BinOp -> m BinOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BinOp -> m BinOp
gmapMp :: (forall d. Data d => d -> m d) -> BinOp -> m BinOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BinOp -> m BinOp
gmapM :: (forall d. Data d => d -> m d) -> BinOp -> m BinOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BinOp -> m BinOp
gmapQi :: Int -> (forall d. Data d => d -> u) -> BinOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BinOp -> u
gmapQ :: (forall d. Data d => d -> u) -> BinOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BinOp -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BinOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BinOp -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BinOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BinOp -> r
gmapT :: (forall b. Data b => b -> b) -> BinOp -> BinOp
$cgmapT :: (forall b. Data b => b -> b) -> BinOp -> BinOp
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BinOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BinOp)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c BinOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BinOp)
dataTypeOf :: BinOp -> DataType
$cdataTypeOf :: BinOp -> DataType
toConstr :: BinOp -> Constr
$ctoConstr :: BinOp -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BinOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BinOp
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BinOp -> c BinOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BinOp -> c BinOp
$cp1Data :: Typeable BinOp
Data, Typeable)

data AssignOp = JustAssign
              | AddAssign
              | SubAssign
              | MulAssign
              | DivAssign
              | ModAssign
              | LshAssign
              | RshAssign
              | AndAssign
              | XorAssign
              | OrAssign
    deriving (AssignOp -> AssignOp -> Bool
(AssignOp -> AssignOp -> Bool)
-> (AssignOp -> AssignOp -> Bool) -> Eq AssignOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AssignOp -> AssignOp -> Bool
$c/= :: AssignOp -> AssignOp -> Bool
== :: AssignOp -> AssignOp -> Bool
$c== :: AssignOp -> AssignOp -> Bool
Eq, Eq AssignOp
Eq AssignOp
-> (AssignOp -> AssignOp -> Ordering)
-> (AssignOp -> AssignOp -> Bool)
-> (AssignOp -> AssignOp -> Bool)
-> (AssignOp -> AssignOp -> Bool)
-> (AssignOp -> AssignOp -> Bool)
-> (AssignOp -> AssignOp -> AssignOp)
-> (AssignOp -> AssignOp -> AssignOp)
-> Ord AssignOp
AssignOp -> AssignOp -> Bool
AssignOp -> AssignOp -> Ordering
AssignOp -> AssignOp -> AssignOp
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: AssignOp -> AssignOp -> AssignOp
$cmin :: AssignOp -> AssignOp -> AssignOp
max :: AssignOp -> AssignOp -> AssignOp
$cmax :: AssignOp -> AssignOp -> AssignOp
>= :: AssignOp -> AssignOp -> Bool
$c>= :: AssignOp -> AssignOp -> Bool
> :: AssignOp -> AssignOp -> Bool
$c> :: AssignOp -> AssignOp -> Bool
<= :: AssignOp -> AssignOp -> Bool
$c<= :: AssignOp -> AssignOp -> Bool
< :: AssignOp -> AssignOp -> Bool
$c< :: AssignOp -> AssignOp -> Bool
compare :: AssignOp -> AssignOp -> Ordering
$ccompare :: AssignOp -> AssignOp -> Ordering
$cp1Ord :: Eq AssignOp
Ord, Int -> AssignOp -> ShowS
[AssignOp] -> ShowS
AssignOp -> String
(Int -> AssignOp -> ShowS)
-> (AssignOp -> String) -> ([AssignOp] -> ShowS) -> Show AssignOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AssignOp] -> ShowS
$cshowList :: [AssignOp] -> ShowS
show :: AssignOp -> String
$cshow :: AssignOp -> String
showsPrec :: Int -> AssignOp -> ShowS
$cshowsPrec :: Int -> AssignOp -> ShowS
Show, Typeable AssignOp
DataType
Constr
Typeable AssignOp
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AssignOp -> c AssignOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AssignOp)
-> (AssignOp -> Constr)
-> (AssignOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AssignOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AssignOp))
-> ((forall b. Data b => b -> b) -> AssignOp -> AssignOp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AssignOp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AssignOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> AssignOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> AssignOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AssignOp -> m AssignOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AssignOp -> m AssignOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AssignOp -> m AssignOp)
-> Data AssignOp
AssignOp -> DataType
AssignOp -> Constr
(forall b. Data b => b -> b) -> AssignOp -> AssignOp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AssignOp -> c AssignOp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AssignOp
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) -> AssignOp -> u
forall u. (forall d. Data d => d -> u) -> AssignOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AssignOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AssignOp -> c AssignOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AssignOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AssignOp)
$cOrAssign :: Constr
$cXorAssign :: Constr
$cAndAssign :: Constr
$cRshAssign :: Constr
$cLshAssign :: Constr
$cModAssign :: Constr
$cDivAssign :: Constr
$cMulAssign :: Constr
$cSubAssign :: Constr
$cAddAssign :: Constr
$cJustAssign :: Constr
$tAssignOp :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
gmapMp :: (forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
gmapM :: (forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
gmapQi :: Int -> (forall d. Data d => d -> u) -> AssignOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AssignOp -> u
gmapQ :: (forall d. Data d => d -> u) -> AssignOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AssignOp -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
gmapT :: (forall b. Data b => b -> b) -> AssignOp -> AssignOp
$cgmapT :: (forall b. Data b => b -> b) -> AssignOp -> AssignOp
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AssignOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AssignOp)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c AssignOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AssignOp)
dataTypeOf :: AssignOp -> DataType
$cdataTypeOf :: AssignOp -> DataType
toConstr :: AssignOp -> Constr
$ctoConstr :: AssignOp -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AssignOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AssignOp
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AssignOp -> c AssignOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AssignOp -> c AssignOp
$cp1Data :: Typeable AssignOp
Data, Typeable)

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

{------------------------------------------------------------------------------
 -
 - GCC extensions
 -
 ------------------------------------------------------------------------------}

type AsmTemplate = StringLit

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

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

type AsmClobber = String

{------------------------------------------------------------------------------
 -
 - Clang blocks
 -
 ------------------------------------------------------------------------------}
data BlockType = BlockVoid !SrcLoc
               | BlockParam [Param] !SrcLoc
               | BlockType Type !SrcLoc
                 -- NB: Type may be something other than 'Proto', in which case clang defaults to
                 --     regard the type as the return type and assume the arguments to be 'void'.
    deriving (BlockType -> BlockType -> Bool
(BlockType -> BlockType -> Bool)
-> (BlockType -> BlockType -> Bool) -> Eq BlockType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BlockType -> BlockType -> Bool
$c/= :: BlockType -> BlockType -> Bool
== :: BlockType -> BlockType -> Bool
$c== :: BlockType -> BlockType -> Bool
Eq, Eq BlockType
Eq BlockType
-> (BlockType -> BlockType -> Ordering)
-> (BlockType -> BlockType -> Bool)
-> (BlockType -> BlockType -> Bool)
-> (BlockType -> BlockType -> Bool)
-> (BlockType -> BlockType -> Bool)
-> (BlockType -> BlockType -> BlockType)
-> (BlockType -> BlockType -> BlockType)
-> Ord BlockType
BlockType -> BlockType -> Bool
BlockType -> BlockType -> Ordering
BlockType -> BlockType -> BlockType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BlockType -> BlockType -> BlockType
$cmin :: BlockType -> BlockType -> BlockType
max :: BlockType -> BlockType -> BlockType
$cmax :: BlockType -> BlockType -> BlockType
>= :: BlockType -> BlockType -> Bool
$c>= :: BlockType -> BlockType -> Bool
> :: BlockType -> BlockType -> Bool
$c> :: BlockType -> BlockType -> Bool
<= :: BlockType -> BlockType -> Bool
$c<= :: BlockType -> BlockType -> Bool
< :: BlockType -> BlockType -> Bool
$c< :: BlockType -> BlockType -> Bool
compare :: BlockType -> BlockType -> Ordering
$ccompare :: BlockType -> BlockType -> Ordering
$cp1Ord :: Eq BlockType
Ord, Int -> BlockType -> ShowS
[BlockType] -> ShowS
BlockType -> String
(Int -> BlockType -> ShowS)
-> (BlockType -> String)
-> ([BlockType] -> ShowS)
-> Show BlockType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BlockType] -> ShowS
$cshowList :: [BlockType] -> ShowS
show :: BlockType -> String
$cshow :: BlockType -> String
showsPrec :: Int -> BlockType -> ShowS
$cshowsPrec :: Int -> BlockType -> ShowS
Show, Typeable BlockType
DataType
Constr
Typeable BlockType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BlockType -> c BlockType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BlockType)
-> (BlockType -> Constr)
-> (BlockType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BlockType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlockType))
-> ((forall b. Data b => b -> b) -> BlockType -> BlockType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BlockType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BlockType -> r)
-> (forall u. (forall d. Data d => d -> u) -> BlockType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BlockType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BlockType -> m BlockType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BlockType -> m BlockType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BlockType -> m BlockType)
-> Data BlockType
BlockType -> DataType
BlockType -> Constr
(forall b. Data b => b -> b) -> BlockType -> BlockType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BlockType -> c BlockType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BlockType
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) -> BlockType -> u
forall u. (forall d. Data d => d -> u) -> BlockType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BlockType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BlockType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BlockType -> m BlockType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BlockType -> m BlockType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BlockType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BlockType -> c BlockType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BlockType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlockType)
$cBlockType :: Constr
$cBlockParam :: Constr
$cBlockVoid :: Constr
$tBlockType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> BlockType -> m BlockType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BlockType -> m BlockType
gmapMp :: (forall d. Data d => d -> m d) -> BlockType -> m BlockType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BlockType -> m BlockType
gmapM :: (forall d. Data d => d -> m d) -> BlockType -> m BlockType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BlockType -> m BlockType
gmapQi :: Int -> (forall d. Data d => d -> u) -> BlockType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BlockType -> u
gmapQ :: (forall d. Data d => d -> u) -> BlockType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BlockType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BlockType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BlockType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BlockType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BlockType -> r
gmapT :: (forall b. Data b => b -> b) -> BlockType -> BlockType
$cgmapT :: (forall b. Data b => b -> b) -> BlockType -> BlockType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlockType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlockType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c BlockType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BlockType)
dataTypeOf :: BlockType -> DataType
$cdataTypeOf :: BlockType -> DataType
toConstr :: BlockType -> Constr
$ctoConstr :: BlockType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BlockType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BlockType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BlockType -> c BlockType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BlockType -> c BlockType
$cp1Data :: Typeable BlockType
Data, Typeable)

{------------------------------------------------------------------------------
 -
 - Objective-C
 -
 ------------------------------------------------------------------------------}

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

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

data ObjCIfaceDecl = ObjCIfaceProp [ObjCPropAttr] FieldGroup !SrcLoc
                   | ObjCIfaceReq ObjCMethodReq !SrcLoc
                   | ObjCIfaceMeth ObjCMethodProto !SrcLoc
                   | ObjCIfaceDecl InitGroup !SrcLoc

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

data ObjCPropAttr = ObjCGetter Id !SrcLoc
                  | ObjCSetter Id !SrcLoc
                  | ObjCReadonly !SrcLoc
                  | ObjCReadwrite !SrcLoc
                  | ObjCAssign !SrcLoc
                  | ObjCRetain !SrcLoc
                  | ObjCCopy !SrcLoc
                  | ObjCNonatomic !SrcLoc
                  | ObjCAtomic !SrcLoc
                  | ObjCStrong !SrcLoc
                  | ObjCWeak !SrcLoc
                  | ObjCUnsafeUnretained !SrcLoc

                  | AntiObjCAttr  String !SrcLoc
                  | AntiObjCAttrs String !SrcLoc
    deriving (ObjCPropAttr -> ObjCPropAttr -> Bool
(ObjCPropAttr -> ObjCPropAttr -> Bool)
-> (ObjCPropAttr -> ObjCPropAttr -> Bool) -> Eq ObjCPropAttr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ObjCPropAttr -> ObjCPropAttr -> Bool
$c/= :: ObjCPropAttr -> ObjCPropAttr -> Bool
== :: ObjCPropAttr -> ObjCPropAttr -> Bool
$c== :: ObjCPropAttr -> ObjCPropAttr -> Bool
Eq, Eq ObjCPropAttr
Eq ObjCPropAttr
-> (ObjCPropAttr -> ObjCPropAttr -> Ordering)
-> (ObjCPropAttr -> ObjCPropAttr -> Bool)
-> (ObjCPropAttr -> ObjCPropAttr -> Bool)
-> (ObjCPropAttr -> ObjCPropAttr -> Bool)
-> (ObjCPropAttr -> ObjCPropAttr -> Bool)
-> (ObjCPropAttr -> ObjCPropAttr -> ObjCPropAttr)
-> (ObjCPropAttr -> ObjCPropAttr -> ObjCPropAttr)
-> Ord ObjCPropAttr
ObjCPropAttr -> ObjCPropAttr -> Bool
ObjCPropAttr -> ObjCPropAttr -> Ordering
ObjCPropAttr -> ObjCPropAttr -> ObjCPropAttr
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ObjCPropAttr -> ObjCPropAttr -> ObjCPropAttr
$cmin :: ObjCPropAttr -> ObjCPropAttr -> ObjCPropAttr
max :: ObjCPropAttr -> ObjCPropAttr -> ObjCPropAttr
$cmax :: ObjCPropAttr -> ObjCPropAttr -> ObjCPropAttr
>= :: ObjCPropAttr -> ObjCPropAttr -> Bool
$c>= :: ObjCPropAttr -> ObjCPropAttr -> Bool
> :: ObjCPropAttr -> ObjCPropAttr -> Bool
$c> :: ObjCPropAttr -> ObjCPropAttr -> Bool
<= :: ObjCPropAttr -> ObjCPropAttr -> Bool
$c<= :: ObjCPropAttr -> ObjCPropAttr -> Bool
< :: ObjCPropAttr -> ObjCPropAttr -> Bool
$c< :: ObjCPropAttr -> ObjCPropAttr -> Bool
compare :: ObjCPropAttr -> ObjCPropAttr -> Ordering
$ccompare :: ObjCPropAttr -> ObjCPropAttr -> Ordering
$cp1Ord :: Eq ObjCPropAttr
Ord, Int -> ObjCPropAttr -> ShowS
[ObjCPropAttr] -> ShowS
ObjCPropAttr -> String
(Int -> ObjCPropAttr -> ShowS)
-> (ObjCPropAttr -> String)
-> ([ObjCPropAttr] -> ShowS)
-> Show ObjCPropAttr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ObjCPropAttr] -> ShowS
$cshowList :: [ObjCPropAttr] -> ShowS
show :: ObjCPropAttr -> String
$cshow :: ObjCPropAttr -> String
showsPrec :: Int -> ObjCPropAttr -> ShowS
$cshowsPrec :: Int -> ObjCPropAttr -> ShowS
Show, Typeable ObjCPropAttr
DataType
Constr
Typeable ObjCPropAttr
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ObjCPropAttr -> c ObjCPropAttr)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ObjCPropAttr)
-> (ObjCPropAttr -> Constr)
-> (ObjCPropAttr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ObjCPropAttr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ObjCPropAttr))
-> ((forall b. Data b => b -> b) -> ObjCPropAttr -> ObjCPropAttr)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ObjCPropAttr -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ObjCPropAttr -> r)
-> (forall u. (forall d. Data d => d -> u) -> ObjCPropAttr -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ObjCPropAttr -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ObjCPropAttr -> m ObjCPropAttr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ObjCPropAttr -> m ObjCPropAttr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ObjCPropAttr -> m ObjCPropAttr)
-> Data ObjCPropAttr
ObjCPropAttr -> DataType
ObjCPropAttr -> Constr
(forall b. Data b => b -> b) -> ObjCPropAttr -> ObjCPropAttr
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjCPropAttr -> c ObjCPropAttr
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjCPropAttr
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) -> ObjCPropAttr -> u
forall u. (forall d. Data d => d -> u) -> ObjCPropAttr -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjCPropAttr -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjCPropAttr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ObjCPropAttr -> m ObjCPropAttr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjCPropAttr -> m ObjCPropAttr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjCPropAttr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjCPropAttr -> c ObjCPropAttr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ObjCPropAttr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ObjCPropAttr)
$cAntiObjCAttrs :: Constr
$cAntiObjCAttr :: Constr
$cObjCUnsafeUnretained :: Constr
$cObjCWeak :: Constr
$cObjCStrong :: Constr
$cObjCAtomic :: Constr
$cObjCNonatomic :: Constr
$cObjCCopy :: Constr
$cObjCRetain :: Constr
$cObjCAssign :: Constr
$cObjCReadwrite :: Constr
$cObjCReadonly :: Constr
$cObjCSetter :: Constr
$cObjCGetter :: Constr
$tObjCPropAttr :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ObjCPropAttr -> m ObjCPropAttr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjCPropAttr -> m ObjCPropAttr
gmapMp :: (forall d. Data d => d -> m d) -> ObjCPropAttr -> m ObjCPropAttr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjCPropAttr -> m ObjCPropAttr
gmapM :: (forall d. Data d => d -> m d) -> ObjCPropAttr -> m ObjCPropAttr
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ObjCPropAttr -> m ObjCPropAttr
gmapQi :: Int -> (forall d. Data d => d -> u) -> ObjCPropAttr -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ObjCPropAttr -> u
gmapQ :: (forall d. Data d => d -> u) -> ObjCPropAttr -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ObjCPropAttr -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjCPropAttr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjCPropAttr -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjCPropAttr -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjCPropAttr -> r
gmapT :: (forall b. Data b => b -> b) -> ObjCPropAttr -> ObjCPropAttr
$cgmapT :: (forall b. Data b => b -> b) -> ObjCPropAttr -> ObjCPropAttr
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ObjCPropAttr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ObjCPropAttr)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ObjCPropAttr)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ObjCPropAttr)
dataTypeOf :: ObjCPropAttr -> DataType
$cdataTypeOf :: ObjCPropAttr -> DataType
toConstr :: ObjCPropAttr -> Constr
$ctoConstr :: ObjCPropAttr -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjCPropAttr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjCPropAttr
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjCPropAttr -> c ObjCPropAttr
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjCPropAttr -> c ObjCPropAttr
$cp1Data :: Typeable ObjCPropAttr
Data, Typeable)

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

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

data ObjCMethodProto = ObjCMethodProto Bool (Maybe Type) [Attr] [ObjCParam] Bool [Attr] !SrcLoc
                       -- ^Invariant: First parameter must at least either have a selector or
                       --  an identifier; all other parameters must have an identifier.
                     | AntiObjCMethodProto String !SrcLoc
    deriving (ObjCMethodProto -> ObjCMethodProto -> Bool
(ObjCMethodProto -> ObjCMethodProto -> Bool)
-> (ObjCMethodProto -> ObjCMethodProto -> Bool)
-> Eq ObjCMethodProto
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ObjCMethodProto -> ObjCMethodProto -> Bool
$c/= :: ObjCMethodProto -> ObjCMethodProto -> Bool
== :: ObjCMethodProto -> ObjCMethodProto -> Bool
$c== :: ObjCMethodProto -> ObjCMethodProto -> Bool
Eq, Eq ObjCMethodProto
Eq ObjCMethodProto
-> (ObjCMethodProto -> ObjCMethodProto -> Ordering)
-> (ObjCMethodProto -> ObjCMethodProto -> Bool)
-> (ObjCMethodProto -> ObjCMethodProto -> Bool)
-> (ObjCMethodProto -> ObjCMethodProto -> Bool)
-> (ObjCMethodProto -> ObjCMethodProto -> Bool)
-> (ObjCMethodProto -> ObjCMethodProto -> ObjCMethodProto)
-> (ObjCMethodProto -> ObjCMethodProto -> ObjCMethodProto)
-> Ord ObjCMethodProto
ObjCMethodProto -> ObjCMethodProto -> Bool
ObjCMethodProto -> ObjCMethodProto -> Ordering
ObjCMethodProto -> ObjCMethodProto -> ObjCMethodProto
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ObjCMethodProto -> ObjCMethodProto -> ObjCMethodProto
$cmin :: ObjCMethodProto -> ObjCMethodProto -> ObjCMethodProto
max :: ObjCMethodProto -> ObjCMethodProto -> ObjCMethodProto
$cmax :: ObjCMethodProto -> ObjCMethodProto -> ObjCMethodProto
>= :: ObjCMethodProto -> ObjCMethodProto -> Bool
$c>= :: ObjCMethodProto -> ObjCMethodProto -> Bool
> :: ObjCMethodProto -> ObjCMethodProto -> Bool
$c> :: ObjCMethodProto -> ObjCMethodProto -> Bool
<= :: ObjCMethodProto -> ObjCMethodProto -> Bool
$c<= :: ObjCMethodProto -> ObjCMethodProto -> Bool
< :: ObjCMethodProto -> ObjCMethodProto -> Bool
$c< :: ObjCMethodProto -> ObjCMethodProto -> Bool
compare :: ObjCMethodProto -> ObjCMethodProto -> Ordering
$ccompare :: ObjCMethodProto -> ObjCMethodProto -> Ordering
$cp1Ord :: Eq ObjCMethodProto
Ord, Int -> ObjCMethodProto -> ShowS
[ObjCMethodProto] -> ShowS
ObjCMethodProto -> String
(Int -> ObjCMethodProto -> ShowS)
-> (ObjCMethodProto -> String)
-> ([ObjCMethodProto] -> ShowS)
-> Show ObjCMethodProto
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ObjCMethodProto] -> ShowS
$cshowList :: [ObjCMethodProto] -> ShowS
show :: ObjCMethodProto -> String
$cshow :: ObjCMethodProto -> String
showsPrec :: Int -> ObjCMethodProto -> ShowS
$cshowsPrec :: Int -> ObjCMethodProto -> ShowS
Show, Typeable ObjCMethodProto
DataType
Constr
Typeable ObjCMethodProto
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ObjCMethodProto -> c ObjCMethodProto)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ObjCMethodProto)
-> (ObjCMethodProto -> Constr)
-> (ObjCMethodProto -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ObjCMethodProto))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ObjCMethodProto))
-> ((forall b. Data b => b -> b)
    -> ObjCMethodProto -> ObjCMethodProto)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ObjCMethodProto -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ObjCMethodProto -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ObjCMethodProto -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ObjCMethodProto -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ObjCMethodProto -> m ObjCMethodProto)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ObjCMethodProto -> m ObjCMethodProto)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ObjCMethodProto -> m ObjCMethodProto)
-> Data ObjCMethodProto
ObjCMethodProto -> DataType
ObjCMethodProto -> Constr
(forall b. Data b => b -> b) -> ObjCMethodProto -> ObjCMethodProto
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjCMethodProto -> c ObjCMethodProto
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjCMethodProto
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) -> ObjCMethodProto -> u
forall u. (forall d. Data d => d -> u) -> ObjCMethodProto -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjCMethodProto -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjCMethodProto -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ObjCMethodProto -> m ObjCMethodProto
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ObjCMethodProto -> m ObjCMethodProto
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjCMethodProto
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjCMethodProto -> c ObjCMethodProto
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ObjCMethodProto)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ObjCMethodProto)
$cAntiObjCMethodProto :: Constr
$cObjCMethodProto :: Constr
$tObjCMethodProto :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> ObjCMethodProto -> m ObjCMethodProto
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ObjCMethodProto -> m ObjCMethodProto
gmapMp :: (forall d. Data d => d -> m d)
-> ObjCMethodProto -> m ObjCMethodProto
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ObjCMethodProto -> m ObjCMethodProto
gmapM :: (forall d. Data d => d -> m d)
-> ObjCMethodProto -> m ObjCMethodProto
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ObjCMethodProto -> m ObjCMethodProto
gmapQi :: Int -> (forall d. Data d => d -> u) -> ObjCMethodProto -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ObjCMethodProto -> u
gmapQ :: (forall d. Data d => d -> u) -> ObjCMethodProto -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ObjCMethodProto -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjCMethodProto -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjCMethodProto -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjCMethodProto -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjCMethodProto -> r
gmapT :: (forall b. Data b => b -> b) -> ObjCMethodProto -> ObjCMethodProto
$cgmapT :: (forall b. Data b => b -> b) -> ObjCMethodProto -> ObjCMethodProto
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ObjCMethodProto)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ObjCMethodProto)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ObjCMethodProto)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ObjCMethodProto)
dataTypeOf :: ObjCMethodProto -> DataType
$cdataTypeOf :: ObjCMethodProto -> DataType
toConstr :: ObjCMethodProto -> Constr
$ctoConstr :: ObjCMethodProto -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjCMethodProto
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjCMethodProto
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjCMethodProto -> c ObjCMethodProto
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjCMethodProto -> c ObjCMethodProto
$cp1Data :: Typeable ObjCMethodProto
Data, Typeable)

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

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

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

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

{------------------------------------------------------------------------------
 -
 - CUDA
 -
 ------------------------------------------------------------------------------}

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

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

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

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

{------------------------------------------------------------------------------
 -
 - Instances
 -
 ------------------------------------------------------------------------------}

instance IsString Id where
    fromString :: String -> Id
fromString String
s = String -> SrcLoc -> Id
Id String
s SrcLoc
forall a. IsLocation a => a
noLoc

instance IsString StringLit where
    fromString :: String -> StringLit
fromString String
s = [String] -> String -> SrcLoc -> StringLit
StringLit [String
s] String
s SrcLoc
forall a. IsLocation a => a
noLoc

#if !defined(ONLY_TYPEDEFS)
#include "Language/C/Syntax-instances.hs"

{------------------------------------------------------------------------------
 -
 - Utilities
 -
 ------------------------------------------------------------------------------}

funcProto :: Func -> InitGroup
funcProto :: Func -> InitGroup
funcProto f :: Func
f@(Func DeclSpec
decl_spec Id
ident Decl
decl Params
params [BlockItem]
_ SrcLoc
_) =
    DeclSpec -> [Attr] -> [Init] -> SrcLoc -> InitGroup
InitGroup DeclSpec
decl_spec []
      [Id
-> Decl
-> Maybe StringLit
-> Maybe Initializer
-> [Attr]
-> SrcLoc
-> Init
Init Id
ident (Decl -> Params -> SrcLoc -> Decl
Proto Decl
decl Params
params SrcLoc
l) Maybe StringLit
forall a. Maybe a
Nothing Maybe Initializer
forall a. Maybe a
Nothing [] SrcLoc
l] SrcLoc
l
  where
    l :: SrcLoc
l = Func -> SrcLoc
forall a. Located a => a -> SrcLoc
srclocOf Func
f

funcProto f :: Func
f@(OldFunc DeclSpec
decl_spec Id
ident Decl
decl [Id]
params Maybe [InitGroup]
_ [BlockItem]
_ SrcLoc
_) =
    DeclSpec -> [Attr] -> [Init] -> SrcLoc -> InitGroup
InitGroup DeclSpec
decl_spec []
      [Id
-> Decl
-> Maybe StringLit
-> Maybe Initializer
-> [Attr]
-> SrcLoc
-> Init
Init Id
ident (Decl -> [Id] -> SrcLoc -> Decl
OldProto Decl
decl [Id]
params SrcLoc
l) Maybe StringLit
forall a. Maybe a
Nothing Maybe Initializer
forall a. Maybe a
Nothing [] SrcLoc
l] SrcLoc
l
  where
    l :: SrcLoc
l = Func -> SrcLoc
forall a. Located a => a -> SrcLoc
srclocOf Func
f

isPtr :: Type -> Bool
isPtr :: Type -> Bool
isPtr  (Type DeclSpec
_ Decl
decl SrcLoc
_)  = Decl -> Bool
go Decl
decl
  where
    go :: Decl -> Bool
go  (DeclRoot SrcLoc
_)        = Bool
False
    go  (Ptr [TypeQual]
_ Decl
_ SrcLoc
_)         = Bool
True
    go  (BlockPtr [TypeQual]
_ Decl
_ SrcLoc
_)    = Bool
True
    go  (Array [TypeQual]
_ ArraySize
_ Decl
_ SrcLoc
_)     = Bool
True
    go  (Proto Decl
_ Params
_ SrcLoc
_)       = Bool
False
    go  (OldProto Decl
_ [Id]
_ SrcLoc
_)    = Bool
False
    go  (AntiTypeDecl String
_ SrcLoc
_)  = String -> Bool
forall a. HasCallStack => String -> a
error String
"isPtr: encountered antiquoted type declaration"
isPtr  (AntiType String
_ SrcLoc
_)       = String -> Bool
forall a. HasCallStack => String -> a
error String
"isPtr: encountered antiquoted type"

ctypedef :: Id -> Decl -> [Attr] -> Typedef
ctypedef :: Id -> Decl -> [Attr] -> Typedef
ctypedef Id
ident Decl
decl [Attr]
attrs =
    Id -> Decl -> [Attr] -> SrcLoc -> Typedef
Typedef Id
ident Decl
decl [Attr]
attrs (Id
ident Id -> Decl -> SrcLoc
forall a b. (Located a, Located b) => a -> b -> SrcLoc
`srcspan` Decl
decl SrcLoc -> [Attr] -> SrcLoc
forall a b. (Located a, Located b) => a -> b -> SrcLoc
`srcspan` [Attr]
attrs)

cdeclSpec :: [Storage] -> [TypeQual] -> TypeSpec -> DeclSpec
cdeclSpec :: [Storage] -> [TypeQual] -> TypeSpec -> DeclSpec
cdeclSpec [Storage]
storage [TypeQual]
quals TypeSpec
spec =
    [Storage] -> [TypeQual] -> TypeSpec -> SrcLoc -> DeclSpec
DeclSpec [Storage]
storage [TypeQual]
quals TypeSpec
spec ([Storage]
storage [Storage] -> [TypeQual] -> SrcLoc
forall a b. (Located a, Located b) => a -> b -> SrcLoc
`srcspan` [TypeQual]
quals SrcLoc -> TypeSpec -> SrcLoc
forall a b. (Located a, Located b) => a -> b -> SrcLoc
`srcspan` TypeSpec
spec)

cinitGroup :: DeclSpec -> [Attr] -> [Init] -> InitGroup
cinitGroup :: DeclSpec -> [Attr] -> [Init] -> InitGroup
cinitGroup DeclSpec
dspec [Attr]
attrs [Init]
inis =
    DeclSpec -> [Attr] -> [Init] -> SrcLoc -> InitGroup
InitGroup DeclSpec
dspec [Attr]
attrs [Init]
inis (DeclSpec
dspec DeclSpec -> [Attr] -> SrcLoc
forall a b. (Located a, Located b) => a -> b -> SrcLoc
`srcspan` [Attr]
attrs SrcLoc -> [Init] -> SrcLoc
forall a b. (Located a, Located b) => a -> b -> SrcLoc
`srcspan` [Init]
inis)

ctypedefGroup :: DeclSpec -> [Attr] -> [Typedef] -> InitGroup
ctypedefGroup :: DeclSpec -> [Attr] -> [Typedef] -> InitGroup
ctypedefGroup DeclSpec
dspec [Attr]
attrs [Typedef]
typedefs =
    DeclSpec -> [Attr] -> [Typedef] -> SrcLoc -> InitGroup
TypedefGroup DeclSpec
dspec [Attr]
attrs [Typedef]
typedefs (DeclSpec
dspec DeclSpec -> [Attr] -> SrcLoc
forall a b. (Located a, Located b) => a -> b -> SrcLoc
`srcspan` [Attr]
attrs SrcLoc -> [Typedef] -> SrcLoc
forall a b. (Located a, Located b) => a -> b -> SrcLoc
`srcspan` [Typedef]
typedefs)
#endif /* !defined(ONLY_TYPEDEFS) */