language-c-quote-0.13.0.1: C/CUDA/OpenCL/Objective-C quasiquoting library.
Copyright(c) 2006-2011 Harvard University
(c) 2011-2013 Geoffrey Mainland
(c) 2013 Manuel M T Chakravarty
: (c) 2013-2016 Drexel University
LicenseBSD-style
Maintainermainland@drexel.edu
Safe HaskellSafe-Inferred
LanguageHaskell2010

Language.C.Syntax

Description

 
Synopsis

Documentation

data Id Source #

Constructors

Id String !SrcLoc 
AntiId String !SrcLoc 

Instances

Instances details
Data Id Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Id -> c Id Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Id Source #

toConstr :: Id -> Constr Source #

dataTypeOf :: Id -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Id) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Id) Source #

gmapT :: (forall b. Data b => b -> b) -> Id -> Id Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Id -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Id -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Id -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Id -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Id -> m Id Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Id -> m Id Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Id -> m Id Source #

IsString Id Source # 
Instance details

Defined in Language.C.Syntax

Methods

fromString :: String -> Id Source #

Show Id Source # 
Instance details

Defined in Language.C.Syntax

Eq Id Source # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: Id -> Id -> Bool Source #

(/=) :: Id -> Id -> Bool Source #

Ord Id Source # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: Id -> Id -> Ordering Source #

(<) :: Id -> Id -> Bool Source #

(<=) :: Id -> Id -> Bool Source #

(>) :: Id -> Id -> Bool Source #

(>=) :: Id -> Id -> Bool Source #

max :: Id -> Id -> Id Source #

min :: Id -> Id -> Id Source #

ToIdent Id Source # 
Instance details

Defined in Language.C.Quote.Base

Methods

toIdent :: Id -> SrcLoc -> Id Source #

Pretty Id Source # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Id -> Doc Source #

pprPrec :: Int -> Id -> Doc Source #

pprList :: [Id] -> Doc Source #

Located Id Source # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Id -> Loc Source #

locOfList :: [Id] -> Loc Source #

Relocatable Id Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Id -> Id Source #

ToIdent (SrcLoc -> Id) Source # 
Instance details

Defined in Language.C.Quote.Base

Methods

toIdent :: (SrcLoc -> Id) -> SrcLoc -> Id Source #

data StringLit Source #

Constructors

StringLit [String] String !SrcLoc 

Instances

Instances details
Data StringLit Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StringLit -> c StringLit Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c StringLit Source #

toConstr :: StringLit -> Constr Source #

dataTypeOf :: StringLit -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c StringLit) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c StringLit) Source #

gmapT :: (forall b. Data b => b -> b) -> StringLit -> StringLit Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StringLit -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StringLit -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> StringLit -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> StringLit -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StringLit -> m StringLit Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StringLit -> m StringLit Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StringLit -> m StringLit Source #

IsString StringLit Source # 
Instance details

Defined in Language.C.Syntax

Show StringLit Source # 
Instance details

Defined in Language.C.Syntax

Eq StringLit Source # 
Instance details

Defined in Language.C.Syntax

Ord StringLit Source # 
Instance details

Defined in Language.C.Syntax

Pretty StringLit Source # 
Instance details

Defined in Language.C.Pretty

Located StringLit Source # 
Instance details

Defined in Language.C.Syntax

Relocatable StringLit Source # 
Instance details

Defined in Language.C.Syntax

data Storage Source #

Instances

Instances details
Data Storage Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Storage -> c Storage Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Storage Source #

toConstr :: Storage -> Constr Source #

dataTypeOf :: Storage -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Storage) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Storage) Source #

gmapT :: (forall b. Data b => b -> b) -> Storage -> Storage Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Storage -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Storage -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Storage -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Storage -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Storage -> m Storage Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Storage -> m Storage Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Storage -> m Storage Source #

Show Storage Source # 
Instance details

Defined in Language.C.Syntax

Eq Storage Source # 
Instance details

Defined in Language.C.Syntax

Ord Storage Source # 
Instance details

Defined in Language.C.Syntax

Pretty Storage Source # 
Instance details

Defined in Language.C.Pretty

Located Storage Source # 
Instance details

Defined in Language.C.Syntax

Relocatable Storage Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Storage -> Storage Source #

data TypeQual Source #

Instances

Instances details
Data TypeQual Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeQual -> c TypeQual Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeQual Source #

toConstr :: TypeQual -> Constr Source #

dataTypeOf :: TypeQual -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TypeQual) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeQual) Source #

gmapT :: (forall b. Data b => b -> b) -> TypeQual -> TypeQual Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeQual -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeQual -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> TypeQual -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeQual -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeQual -> m TypeQual Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeQual -> m TypeQual Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeQual -> m TypeQual Source #

Show TypeQual Source # 
Instance details

Defined in Language.C.Syntax

Eq TypeQual Source # 
Instance details

Defined in Language.C.Syntax

Ord TypeQual Source # 
Instance details

Defined in Language.C.Syntax

Pretty TypeQual Source # 
Instance details

Defined in Language.C.Pretty

Located TypeQual Source # 
Instance details

Defined in Language.C.Syntax

Relocatable TypeQual Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> TypeQual -> TypeQual Source #

data Sign Source #

Constructors

Tsigned !SrcLoc 
Tunsigned !SrcLoc 

Instances

Instances details
Data Sign Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Sign -> c Sign Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Sign Source #

toConstr :: Sign -> Constr Source #

dataTypeOf :: Sign -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Sign) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign) Source #

gmapT :: (forall b. Data b => b -> b) -> Sign -> Sign Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Sign -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Sign -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sign -> m Sign Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sign -> m Sign Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sign -> m Sign Source #

Show Sign Source # 
Instance details

Defined in Language.C.Syntax

Eq Sign Source # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: Sign -> Sign -> Bool Source #

(/=) :: Sign -> Sign -> Bool Source #

Ord Sign Source # 
Instance details

Defined in Language.C.Syntax

Pretty Sign Source # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Sign -> Doc Source #

pprPrec :: Int -> Sign -> Doc Source #

pprList :: [Sign] -> Doc Source #

Located Sign Source # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Sign -> Loc Source #

locOfList :: [Sign] -> Loc Source #

Relocatable Sign Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Sign -> Sign Source #

data TypeSpec Source #

Instances

Instances details
Data TypeSpec Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeSpec -> c TypeSpec Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeSpec Source #

toConstr :: TypeSpec -> Constr Source #

dataTypeOf :: TypeSpec -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TypeSpec) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeSpec) Source #

gmapT :: (forall b. Data b => b -> b) -> TypeSpec -> TypeSpec Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeSpec -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeSpec -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> TypeSpec -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeSpec -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeSpec -> m TypeSpec Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeSpec -> m TypeSpec Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeSpec -> m TypeSpec Source #

Show TypeSpec Source # 
Instance details

Defined in Language.C.Syntax

Eq TypeSpec Source # 
Instance details

Defined in Language.C.Syntax

Ord TypeSpec Source # 
Instance details

Defined in Language.C.Syntax

Pretty TypeSpec Source # 
Instance details

Defined in Language.C.Pretty

Located TypeSpec Source # 
Instance details

Defined in Language.C.Syntax

Relocatable TypeSpec Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> TypeSpec -> TypeSpec Source #

data DeclSpec Source #

Instances

Instances details
Data DeclSpec Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DeclSpec -> c DeclSpec Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DeclSpec Source #

toConstr :: DeclSpec -> Constr Source #

dataTypeOf :: DeclSpec -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DeclSpec) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeclSpec) Source #

gmapT :: (forall b. Data b => b -> b) -> DeclSpec -> DeclSpec Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DeclSpec -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DeclSpec -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> DeclSpec -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DeclSpec -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DeclSpec -> m DeclSpec Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DeclSpec -> m DeclSpec Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DeclSpec -> m DeclSpec Source #

Show DeclSpec Source # 
Instance details

Defined in Language.C.Syntax

Eq DeclSpec Source # 
Instance details

Defined in Language.C.Syntax

Ord DeclSpec Source # 
Instance details

Defined in Language.C.Syntax

Pretty DeclSpec Source # 
Instance details

Defined in Language.C.Pretty

Located DeclSpec Source # 
Instance details

Defined in Language.C.Syntax

Relocatable DeclSpec Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> DeclSpec -> DeclSpec Source #

data ArraySize Source #

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.

Instances

Instances details
Data ArraySize Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ArraySize -> c ArraySize Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ArraySize Source #

toConstr :: ArraySize -> Constr Source #

dataTypeOf :: ArraySize -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ArraySize) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArraySize) Source #

gmapT :: (forall b. Data b => b -> b) -> ArraySize -> ArraySize Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ArraySize -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ArraySize -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ArraySize -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ArraySize -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ArraySize -> m ArraySize Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ArraySize -> m ArraySize Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ArraySize -> m ArraySize Source #

Show ArraySize Source # 
Instance details

Defined in Language.C.Syntax

Eq ArraySize Source # 
Instance details

Defined in Language.C.Syntax

Ord ArraySize Source # 
Instance details

Defined in Language.C.Syntax

Pretty ArraySize Source # 
Instance details

Defined in Language.C.Pretty

Located ArraySize Source # 
Instance details

Defined in Language.C.Syntax

Relocatable ArraySize Source # 
Instance details

Defined in Language.C.Syntax

data Decl Source #

Instances

Instances details
Data Decl Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Decl -> c Decl Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Decl Source #

toConstr :: Decl -> Constr Source #

dataTypeOf :: Decl -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Decl) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Decl) Source #

gmapT :: (forall b. Data b => b -> b) -> Decl -> Decl Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Decl -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Decl -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Decl -> m Decl Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Decl -> m Decl Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Decl -> m Decl Source #

Show Decl Source # 
Instance details

Defined in Language.C.Syntax

Eq Decl Source # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: Decl -> Decl -> Bool Source #

(/=) :: Decl -> Decl -> Bool Source #

Ord Decl Source # 
Instance details

Defined in Language.C.Syntax

Located Decl Source # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Decl -> Loc Source #

locOfList :: [Decl] -> Loc Source #

Relocatable Decl Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Decl -> Decl Source #

data Type Source #

Instances

Instances details
Data Type Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Type -> c Type Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Type Source #

toConstr :: Type -> Constr Source #

dataTypeOf :: Type -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Type) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type) Source #

gmapT :: (forall b. Data b => b -> b) -> Type -> Type Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Type -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type -> m Type Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type Source #

Show Type Source # 
Instance details

Defined in Language.C.Syntax

Eq Type Source # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: Type -> Type -> Bool Source #

(/=) :: Type -> Type -> Bool Source #

Ord Type Source # 
Instance details

Defined in Language.C.Syntax

Pretty Type Source # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Type -> Doc Source #

pprPrec :: Int -> Type -> Doc Source #

pprList :: [Type] -> Doc Source #

Located Type Source # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Type -> Loc Source #

locOfList :: [Type] -> Loc Source #

Relocatable Type Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Type -> Type Source #

data Designator Source #

Instances

Instances details
Data Designator Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Designator -> c Designator Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Designator Source #

toConstr :: Designator -> Constr Source #

dataTypeOf :: Designator -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Designator) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Designator) Source #

gmapT :: (forall b. Data b => b -> b) -> Designator -> Designator Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Designator -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Designator -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Designator -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Designator -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Designator -> m Designator Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Designator -> m Designator Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Designator -> m Designator Source #

Show Designator Source # 
Instance details

Defined in Language.C.Syntax

Eq Designator Source # 
Instance details

Defined in Language.C.Syntax

Ord Designator Source # 
Instance details

Defined in Language.C.Syntax

Pretty Designator Source # 
Instance details

Defined in Language.C.Pretty

Located Designator Source # 
Instance details

Defined in Language.C.Syntax

Relocatable Designator Source # 
Instance details

Defined in Language.C.Syntax

data Designation Source #

Constructors

Designation [Designator] !SrcLoc 

Instances

Instances details
Data Designation Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Designation -> c Designation Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Designation Source #

toConstr :: Designation -> Constr Source #

dataTypeOf :: Designation -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Designation) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Designation) Source #

gmapT :: (forall b. Data b => b -> b) -> Designation -> Designation Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Designation -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Designation -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Designation -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Designation -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Designation -> m Designation Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Designation -> m Designation Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Designation -> m Designation Source #

Show Designation Source # 
Instance details

Defined in Language.C.Syntax

Eq Designation Source # 
Instance details

Defined in Language.C.Syntax

Ord Designation Source # 
Instance details

Defined in Language.C.Syntax

Pretty Designation Source # 
Instance details

Defined in Language.C.Pretty

Located Designation Source # 
Instance details

Defined in Language.C.Syntax

Relocatable Designation Source # 
Instance details

Defined in Language.C.Syntax

data Initializer Source #

Instances

Instances details
Data Initializer Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Initializer -> c Initializer Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Initializer Source #

toConstr :: Initializer -> Constr Source #

dataTypeOf :: Initializer -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Initializer) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Initializer) Source #

gmapT :: (forall b. Data b => b -> b) -> Initializer -> Initializer Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Initializer -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Initializer -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Initializer -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Initializer -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Initializer -> m Initializer Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Initializer -> m Initializer Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Initializer -> m Initializer Source #

Show Initializer Source # 
Instance details

Defined in Language.C.Syntax

Eq Initializer Source # 
Instance details

Defined in Language.C.Syntax

Ord Initializer Source # 
Instance details

Defined in Language.C.Syntax

Pretty Initializer Source # 
Instance details

Defined in Language.C.Pretty

Located Initializer Source # 
Instance details

Defined in Language.C.Syntax

Relocatable Initializer Source # 
Instance details

Defined in Language.C.Syntax

data Init Source #

Instances

Instances details
Data Init Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Init -> c Init Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Init Source #

toConstr :: Init -> Constr Source #

dataTypeOf :: Init -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Init) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Init) Source #

gmapT :: (forall b. Data b => b -> b) -> Init -> Init Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Init -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Init -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Init -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Init -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Init -> m Init Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Init -> m Init Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Init -> m Init Source #

Show Init Source # 
Instance details

Defined in Language.C.Syntax

Eq Init Source # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: Init -> Init -> Bool Source #

(/=) :: Init -> Init -> Bool Source #

Ord Init Source # 
Instance details

Defined in Language.C.Syntax

Pretty Init Source # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Init -> Doc Source #

pprPrec :: Int -> Init -> Doc Source #

pprList :: [Init] -> Doc Source #

Located Init Source # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Init -> Loc Source #

locOfList :: [Init] -> Loc Source #

Relocatable Init Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Init -> Init Source #

data Typedef Source #

Constructors

Typedef Id Decl [Attr] !SrcLoc 

Instances

Instances details
Data Typedef Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Typedef -> c Typedef Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Typedef Source #

toConstr :: Typedef -> Constr Source #

dataTypeOf :: Typedef -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Typedef) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Typedef) Source #

gmapT :: (forall b. Data b => b -> b) -> Typedef -> Typedef Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Typedef -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Typedef -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Typedef -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Typedef -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Typedef -> m Typedef Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Typedef -> m Typedef Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Typedef -> m Typedef Source #

Show Typedef Source # 
Instance details

Defined in Language.C.Syntax

Eq Typedef Source # 
Instance details

Defined in Language.C.Syntax

Ord Typedef Source # 
Instance details

Defined in Language.C.Syntax

Pretty Typedef Source # 
Instance details

Defined in Language.C.Pretty

Located Typedef Source # 
Instance details

Defined in Language.C.Syntax

Relocatable Typedef Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Typedef -> Typedef Source #

data InitGroup Source #

Instances

Instances details
Data InitGroup Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InitGroup -> c InitGroup Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InitGroup Source #

toConstr :: InitGroup -> Constr Source #

dataTypeOf :: InitGroup -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c InitGroup) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InitGroup) Source #

gmapT :: (forall b. Data b => b -> b) -> InitGroup -> InitGroup Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InitGroup -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InitGroup -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> InitGroup -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> InitGroup -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InitGroup -> m InitGroup Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InitGroup -> m InitGroup Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InitGroup -> m InitGroup Source #

Show InitGroup Source # 
Instance details

Defined in Language.C.Syntax

Eq InitGroup Source # 
Instance details

Defined in Language.C.Syntax

Ord InitGroup Source # 
Instance details

Defined in Language.C.Syntax

Pretty InitGroup Source # 
Instance details

Defined in Language.C.Pretty

Located InitGroup Source # 
Instance details

Defined in Language.C.Syntax

Relocatable InitGroup Source # 
Instance details

Defined in Language.C.Syntax

data Field Source #

Constructors

Field (Maybe Id) (Maybe Decl) (Maybe Exp) !SrcLoc 

Instances

Instances details
Data Field Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Field -> c Field Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Field Source #

toConstr :: Field -> Constr Source #

dataTypeOf :: Field -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Field) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Field) Source #

gmapT :: (forall b. Data b => b -> b) -> Field -> Field Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Field -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Field -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Field -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Field -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Field -> m Field Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Field -> m Field Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Field -> m Field Source #

Show Field Source # 
Instance details

Defined in Language.C.Syntax

Eq Field Source # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: Field -> Field -> Bool Source #

(/=) :: Field -> Field -> Bool Source #

Ord Field Source # 
Instance details

Defined in Language.C.Syntax

Pretty Field Source # 
Instance details

Defined in Language.C.Pretty

Located Field Source # 
Instance details

Defined in Language.C.Syntax

Relocatable Field Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Field -> Field Source #

data FieldGroup Source #

Instances

Instances details
Data FieldGroup Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldGroup -> c FieldGroup Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FieldGroup Source #

toConstr :: FieldGroup -> Constr Source #

dataTypeOf :: FieldGroup -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FieldGroup) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldGroup) Source #

gmapT :: (forall b. Data b => b -> b) -> FieldGroup -> FieldGroup Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldGroup -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldGroup -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> FieldGroup -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldGroup -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldGroup -> m FieldGroup Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldGroup -> m FieldGroup Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldGroup -> m FieldGroup Source #

Show FieldGroup Source # 
Instance details

Defined in Language.C.Syntax

Eq FieldGroup Source # 
Instance details

Defined in Language.C.Syntax

Ord FieldGroup Source # 
Instance details

Defined in Language.C.Syntax

Pretty FieldGroup Source # 
Instance details

Defined in Language.C.Pretty

Located FieldGroup Source # 
Instance details

Defined in Language.C.Syntax

Relocatable FieldGroup Source # 
Instance details

Defined in Language.C.Syntax

data CEnum Source #

Instances

Instances details
Data CEnum Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CEnum -> c CEnum Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CEnum Source #

toConstr :: CEnum -> Constr Source #

dataTypeOf :: CEnum -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CEnum) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CEnum) Source #

gmapT :: (forall b. Data b => b -> b) -> CEnum -> CEnum Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CEnum -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CEnum -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> CEnum -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CEnum -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CEnum -> m CEnum Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CEnum -> m CEnum Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CEnum -> m CEnum Source #

Show CEnum Source # 
Instance details

Defined in Language.C.Syntax

Eq CEnum Source # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: CEnum -> CEnum -> Bool Source #

(/=) :: CEnum -> CEnum -> Bool Source #

Ord CEnum Source # 
Instance details

Defined in Language.C.Syntax

Pretty CEnum Source # 
Instance details

Defined in Language.C.Pretty

Located CEnum Source # 
Instance details

Defined in Language.C.Syntax

Relocatable CEnum Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> CEnum -> CEnum Source #

data Attr Source #

Instances

Instances details
Data Attr Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Attr -> c Attr Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Attr Source #

toConstr :: Attr -> Constr Source #

dataTypeOf :: Attr -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Attr) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attr) Source #

gmapT :: (forall b. Data b => b -> b) -> Attr -> Attr Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Attr -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Attr -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Attr -> m Attr Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Attr -> m Attr Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Attr -> m Attr Source #

Show Attr Source # 
Instance details

Defined in Language.C.Syntax

Eq Attr Source # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: Attr -> Attr -> Bool Source #

(/=) :: Attr -> Attr -> Bool Source #

Ord Attr Source # 
Instance details

Defined in Language.C.Syntax

Pretty Attr Source # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Attr -> Doc Source #

pprPrec :: Int -> Attr -> Doc Source #

pprList :: [Attr] -> Doc Source #

Located Attr Source # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Attr -> Loc Source #

locOfList :: [Attr] -> Loc Source #

Relocatable Attr Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Attr -> Attr Source #

data Param Source #

Instances

Instances details
Data Param Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Param -> c Param Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Param Source #

toConstr :: Param -> Constr Source #

dataTypeOf :: Param -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Param) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Param) Source #

gmapT :: (forall b. Data b => b -> b) -> Param -> Param Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Param -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Param -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Param -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Param -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Param -> m Param Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Param -> m Param Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Param -> m Param Source #

Show Param Source # 
Instance details

Defined in Language.C.Syntax

Eq Param Source # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: Param -> Param -> Bool Source #

(/=) :: Param -> Param -> Bool Source #

Ord Param Source # 
Instance details

Defined in Language.C.Syntax

Pretty Param Source # 
Instance details

Defined in Language.C.Pretty

Located Param Source # 
Instance details

Defined in Language.C.Syntax

Relocatable Param Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Param -> Param Source #

data Params Source #

Constructors

Params [Param] Bool !SrcLoc 

Instances

Instances details
Data Params Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Params -> c Params Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Params Source #

toConstr :: Params -> Constr Source #

dataTypeOf :: Params -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Params) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Params) Source #

gmapT :: (forall b. Data b => b -> b) -> Params -> Params Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Params -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Params -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Params -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Params -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Params -> m Params Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Params -> m Params Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Params -> m Params Source #

Show Params Source # 
Instance details

Defined in Language.C.Syntax

Eq Params Source # 
Instance details

Defined in Language.C.Syntax

Ord Params Source # 
Instance details

Defined in Language.C.Syntax

Pretty Params Source # 
Instance details

Defined in Language.C.Pretty

Located Params Source # 
Instance details

Defined in Language.C.Syntax

Relocatable Params Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Params -> Params Source #

data Func Source #

Instances

Instances details
Data Func Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Func -> c Func Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Func Source #

toConstr :: Func -> Constr Source #

dataTypeOf :: Func -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Func) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Func) Source #

gmapT :: (forall b. Data b => b -> b) -> Func -> Func Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Func -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Func -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Func -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Func -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Func -> m Func Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Func -> m Func Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Func -> m Func Source #

Show Func Source # 
Instance details

Defined in Language.C.Syntax

Eq Func Source # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: Func -> Func -> Bool Source #

(/=) :: Func -> Func -> Bool Source #

Ord Func Source # 
Instance details

Defined in Language.C.Syntax

Pretty Func Source # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Func -> Doc Source #

pprPrec :: Int -> Func -> Doc Source #

pprList :: [Func] -> Doc Source #

Located Func Source # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Func -> Loc Source #

locOfList :: [Func] -> Loc Source #

Relocatable Func Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Func -> Func Source #

data Definition Source #

Instances

Instances details
Data Definition Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Definition -> c Definition Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Definition Source #

toConstr :: Definition -> Constr Source #

dataTypeOf :: Definition -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Definition) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Definition) Source #

gmapT :: (forall b. Data b => b -> b) -> Definition -> Definition Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Definition -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Definition -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Definition -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Definition -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Definition -> m Definition Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Definition -> m Definition Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Definition -> m Definition Source #

Show Definition Source # 
Instance details

Defined in Language.C.Syntax

Eq Definition Source # 
Instance details

Defined in Language.C.Syntax

Ord Definition Source # 
Instance details

Defined in Language.C.Syntax

Pretty Definition Source # 
Instance details

Defined in Language.C.Pretty

Located Definition Source # 
Instance details

Defined in Language.C.Syntax

Relocatable Definition Source # 
Instance details

Defined in Language.C.Syntax

data Stm Source #

Instances

Instances details
Data Stm Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Stm -> c Stm Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Stm Source #

toConstr :: Stm -> Constr Source #

dataTypeOf :: Stm -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Stm) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stm) Source #

gmapT :: (forall b. Data b => b -> b) -> Stm -> Stm Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stm -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stm -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Stm -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Stm -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Stm -> m Stm Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Stm -> m Stm Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Stm -> m Stm Source #

Show Stm Source # 
Instance details

Defined in Language.C.Syntax

Eq Stm Source # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: Stm -> Stm -> Bool Source #

(/=) :: Stm -> Stm -> Bool Source #

Ord Stm Source # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: Stm -> Stm -> Ordering Source #

(<) :: Stm -> Stm -> Bool Source #

(<=) :: Stm -> Stm -> Bool Source #

(>) :: Stm -> Stm -> Bool Source #

(>=) :: Stm -> Stm -> Bool Source #

max :: Stm -> Stm -> Stm Source #

min :: Stm -> Stm -> Stm Source #

Pretty Stm Source # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Stm -> Doc Source #

pprPrec :: Int -> Stm -> Doc Source #

pprList :: [Stm] -> Doc Source #

Located Stm Source # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Stm -> Loc Source #

locOfList :: [Stm] -> Loc Source #

Relocatable Stm Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Stm -> Stm Source #

data BlockItem Source #

Instances

Instances details
Data BlockItem Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BlockItem -> c BlockItem Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BlockItem Source #

toConstr :: BlockItem -> Constr Source #

dataTypeOf :: BlockItem -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c BlockItem) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlockItem) Source #

gmapT :: (forall b. Data b => b -> b) -> BlockItem -> BlockItem Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BlockItem -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BlockItem -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> BlockItem -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> BlockItem -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BlockItem -> m BlockItem Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BlockItem -> m BlockItem Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BlockItem -> m BlockItem Source #

Show BlockItem Source # 
Instance details

Defined in Language.C.Syntax

Eq BlockItem Source # 
Instance details

Defined in Language.C.Syntax

Ord BlockItem Source # 
Instance details

Defined in Language.C.Syntax

Pretty BlockItem Source # 
Instance details

Defined in Language.C.Pretty

Located BlockItem Source # 
Instance details

Defined in Language.C.Syntax

Relocatable BlockItem Source # 
Instance details

Defined in Language.C.Syntax

data Signed Source #

Constructors

Signed 
Unsigned 

Instances

Instances details
Data Signed Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Signed -> c Signed Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Signed Source #

toConstr :: Signed -> Constr Source #

dataTypeOf :: Signed -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Signed) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Signed) Source #

gmapT :: (forall b. Data b => b -> b) -> Signed -> Signed Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Signed -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Signed -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Signed -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Signed -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Signed -> m Signed Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Signed -> m Signed Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Signed -> m Signed Source #

Show Signed Source # 
Instance details

Defined in Language.C.Syntax

Eq Signed Source # 
Instance details

Defined in Language.C.Syntax

Ord Signed Source # 
Instance details

Defined in Language.C.Syntax

data Const Source #

The String parameter to Const data constructors is the raw string representation of the constant as it was parsed.

Instances

Instances details
Data Const Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Const -> c Const Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Const Source #

toConstr :: Const -> Constr Source #

dataTypeOf :: Const -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Const) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Const) Source #

gmapT :: (forall b. Data b => b -> b) -> Const -> Const Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Const -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Const -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Const -> m Const Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Const -> m Const Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Const -> m Const Source #

Show Const Source # 
Instance details

Defined in Language.C.Syntax

Eq Const Source # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: Const -> Const -> Bool Source #

(/=) :: Const -> Const -> Bool Source #

Ord Const Source # 
Instance details

Defined in Language.C.Syntax

ToConst Const Source # 
Instance details

Defined in Language.C.Quote.Base

Methods

toConst :: Const -> SrcLoc -> Const Source #

Pretty Const Source # 
Instance details

Defined in Language.C.Pretty

Located Const Source # 
Instance details

Defined in Language.C.Syntax

Relocatable Const Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Const -> Const Source #

data Exp Source #

Instances

Instances details
Data Exp Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Exp -> c Exp Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Exp Source #

toConstr :: Exp -> Constr Source #

dataTypeOf :: Exp -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Exp) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp) Source #

gmapT :: (forall b. Data b => b -> b) -> Exp -> Exp Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Exp -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Exp -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Exp -> m Exp Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp Source #

Enum Exp Source # 
Instance details

Defined in Language.C.Smart

Floating Exp Source # 
Instance details

Defined in Language.C.Smart

Num Exp Source # 
Instance details

Defined in Language.C.Smart

Fractional Exp Source # 
Instance details

Defined in Language.C.Smart

Integral Exp Source # 
Instance details

Defined in Language.C.Smart

Methods

quot :: Exp -> Exp -> Exp Source #

rem :: Exp -> Exp -> Exp Source #

div :: Exp -> Exp -> Exp Source #

mod :: Exp -> Exp -> Exp Source #

quotRem :: Exp -> Exp -> (Exp, Exp) Source #

divMod :: Exp -> Exp -> (Exp, Exp) Source #

toInteger :: Exp -> Integer Source #

Real Exp Source # 
Instance details

Defined in Language.C.Smart

Show Exp Source # 
Instance details

Defined in Language.C.Syntax

Eq Exp Source # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: Exp -> Exp -> Bool Source #

(/=) :: Exp -> Exp -> Bool Source #

Ord Exp Source # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: Exp -> Exp -> Ordering Source #

(<) :: Exp -> Exp -> Bool Source #

(<=) :: Exp -> Exp -> Bool Source #

(>) :: Exp -> Exp -> Bool Source #

(>=) :: Exp -> Exp -> Bool Source #

max :: Exp -> Exp -> Exp Source #

min :: Exp -> Exp -> Exp Source #

ToExp Exp Source # 
Instance details

Defined in Language.C.Quote.Base

Methods

toExp :: Exp -> SrcLoc -> Exp Source #

Pretty Exp Source # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Exp -> Doc Source #

pprPrec :: Int -> Exp -> Doc Source #

pprList :: [Exp] -> Doc Source #

Located Exp Source # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Exp -> Loc Source #

locOfList :: [Exp] -> Loc Source #

Relocatable Exp Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Exp -> Exp Source #

data BinOp Source #

Constructors

Add 
Sub 
Mul 
Div 
Mod 
Eq 
Ne 
Lt 
Gt 
Le 
Ge 
Land 
Lor 
And 
Or 
Xor 
Lsh 
Rsh 

Instances

Instances details
Data BinOp Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BinOp -> c BinOp Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BinOp Source #

toConstr :: BinOp -> Constr Source #

dataTypeOf :: BinOp -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c BinOp) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BinOp) Source #

gmapT :: (forall b. Data b => b -> b) -> BinOp -> BinOp Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BinOp -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BinOp -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> BinOp -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> BinOp -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BinOp -> m BinOp Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BinOp -> m BinOp Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BinOp -> m BinOp Source #

Show BinOp Source # 
Instance details

Defined in Language.C.Syntax

Eq BinOp Source # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: BinOp -> BinOp -> Bool Source #

(/=) :: BinOp -> BinOp -> Bool Source #

Ord BinOp Source # 
Instance details

Defined in Language.C.Syntax

CFixity BinOp Source # 
Instance details

Defined in Language.C.Pretty

Pretty BinOp Source # 
Instance details

Defined in Language.C.Pretty

data AssignOp Source #

Instances

Instances details
Data AssignOp Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AssignOp -> c AssignOp Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AssignOp Source #

toConstr :: AssignOp -> Constr Source #

dataTypeOf :: AssignOp -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AssignOp) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AssignOp) Source #

gmapT :: (forall b. Data b => b -> b) -> AssignOp -> AssignOp Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AssignOp -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AssignOp -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> AssignOp -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> AssignOp -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AssignOp -> m AssignOp Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AssignOp -> m AssignOp Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AssignOp -> m AssignOp Source #

Show AssignOp Source # 
Instance details

Defined in Language.C.Syntax

Eq AssignOp Source # 
Instance details

Defined in Language.C.Syntax

Ord AssignOp Source # 
Instance details

Defined in Language.C.Syntax

CFixity AssignOp Source # 
Instance details

Defined in Language.C.Pretty

Pretty AssignOp Source # 
Instance details

Defined in Language.C.Pretty

data UnOp Source #

Constructors

AddrOf 
Deref 
Positive 
Negate 
Not 
Lnot 

Instances

Instances details
Data UnOp Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnOp -> c UnOp Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnOp Source #

toConstr :: UnOp -> Constr Source #

dataTypeOf :: UnOp -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnOp) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnOp) Source #

gmapT :: (forall b. Data b => b -> b) -> UnOp -> UnOp Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnOp -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnOp -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> UnOp -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UnOp -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnOp -> m UnOp Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnOp -> m UnOp Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnOp -> m UnOp Source #

Show UnOp Source # 
Instance details

Defined in Language.C.Syntax

Eq UnOp Source # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: UnOp -> UnOp -> Bool Source #

(/=) :: UnOp -> UnOp -> Bool Source #

Ord UnOp Source # 
Instance details

Defined in Language.C.Syntax

CFixity UnOp Source # 
Instance details

Defined in Language.C.Pretty

Methods

fixity :: UnOp -> Fixity Source #

parensOp :: Int -> UnOp -> Doc -> Doc Source #

Pretty UnOp Source # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: UnOp -> Doc Source #

pprPrec :: Int -> UnOp -> Doc Source #

pprList :: [UnOp] -> Doc Source #

data AsmOut Source #

Constructors

AsmOut (Maybe Id) String Id 

Instances

Instances details
Data AsmOut Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AsmOut -> c AsmOut Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AsmOut Source #

toConstr :: AsmOut -> Constr Source #

dataTypeOf :: AsmOut -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AsmOut) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AsmOut) Source #

gmapT :: (forall b. Data b => b -> b) -> AsmOut -> AsmOut Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AsmOut -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AsmOut -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> AsmOut -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> AsmOut -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AsmOut -> m AsmOut Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AsmOut -> m AsmOut Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AsmOut -> m AsmOut Source #

Show AsmOut Source # 
Instance details

Defined in Language.C.Syntax

Eq AsmOut Source # 
Instance details

Defined in Language.C.Syntax

Ord AsmOut Source # 
Instance details

Defined in Language.C.Syntax

Pretty AsmOut Source # 
Instance details

Defined in Language.C.Pretty

data AsmIn Source #

Constructors

AsmIn (Maybe Id) String Exp 

Instances

Instances details
Data AsmIn Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AsmIn -> c AsmIn Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AsmIn Source #

toConstr :: AsmIn -> Constr Source #

dataTypeOf :: AsmIn -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AsmIn) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AsmIn) Source #

gmapT :: (forall b. Data b => b -> b) -> AsmIn -> AsmIn Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AsmIn -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AsmIn -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> AsmIn -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> AsmIn -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AsmIn -> m AsmIn Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AsmIn -> m AsmIn Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AsmIn -> m AsmIn Source #

Show AsmIn Source # 
Instance details

Defined in Language.C.Syntax

Eq AsmIn Source # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: AsmIn -> AsmIn -> Bool Source #

(/=) :: AsmIn -> AsmIn -> Bool Source #

Ord AsmIn Source # 
Instance details

Defined in Language.C.Syntax

Pretty AsmIn Source # 
Instance details

Defined in Language.C.Pretty

data BlockType Source #

Instances

Instances details
Data BlockType Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BlockType -> c BlockType Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BlockType Source #

toConstr :: BlockType -> Constr Source #

dataTypeOf :: BlockType -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c BlockType) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlockType) Source #

gmapT :: (forall b. Data b => b -> b) -> BlockType -> BlockType Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BlockType -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BlockType -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> BlockType -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> BlockType -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BlockType -> m BlockType Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BlockType -> m BlockType Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BlockType -> m BlockType Source #

Show BlockType Source # 
Instance details

Defined in Language.C.Syntax

Eq BlockType Source # 
Instance details

Defined in Language.C.Syntax

Ord BlockType Source # 
Instance details

Defined in Language.C.Syntax

Pretty BlockType Source # 
Instance details

Defined in Language.C.Pretty

Located BlockType Source # 
Instance details

Defined in Language.C.Syntax

Relocatable BlockType Source # 
Instance details

Defined in Language.C.Syntax

data ObjCIvarDecl Source #

Instances

Instances details
Data ObjCIvarDecl Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ObjCIvarDecl -> c ObjCIvarDecl Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ObjCIvarDecl Source #

toConstr :: ObjCIvarDecl -> Constr Source #

dataTypeOf :: ObjCIvarDecl -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ObjCIvarDecl) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ObjCIvarDecl) Source #

gmapT :: (forall b. Data b => b -> b) -> ObjCIvarDecl -> ObjCIvarDecl Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ObjCIvarDecl -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ObjCIvarDecl -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ObjCIvarDecl -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ObjCIvarDecl -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ObjCIvarDecl -> m ObjCIvarDecl Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCIvarDecl -> m ObjCIvarDecl Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCIvarDecl -> m ObjCIvarDecl Source #

Show ObjCIvarDecl Source # 
Instance details

Defined in Language.C.Syntax

Eq ObjCIvarDecl Source # 
Instance details

Defined in Language.C.Syntax

Ord ObjCIvarDecl Source # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCIvarDecl Source # 
Instance details

Defined in Language.C.Pretty

Located ObjCIvarDecl Source # 
Instance details

Defined in Language.C.Syntax

Relocatable ObjCIvarDecl Source # 
Instance details

Defined in Language.C.Syntax

data ObjCVisibilitySpec Source #

Instances

Instances details
Data ObjCVisibilitySpec Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ObjCVisibilitySpec -> c ObjCVisibilitySpec Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ObjCVisibilitySpec Source #

toConstr :: ObjCVisibilitySpec -> Constr Source #

dataTypeOf :: ObjCVisibilitySpec -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ObjCVisibilitySpec) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ObjCVisibilitySpec) Source #

gmapT :: (forall b. Data b => b -> b) -> ObjCVisibilitySpec -> ObjCVisibilitySpec Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ObjCVisibilitySpec -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ObjCVisibilitySpec -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ObjCVisibilitySpec -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ObjCVisibilitySpec -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ObjCVisibilitySpec -> m ObjCVisibilitySpec Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCVisibilitySpec -> m ObjCVisibilitySpec Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCVisibilitySpec -> m ObjCVisibilitySpec Source #

Show ObjCVisibilitySpec Source # 
Instance details

Defined in Language.C.Syntax

Eq ObjCVisibilitySpec Source # 
Instance details

Defined in Language.C.Syntax

Ord ObjCVisibilitySpec Source # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCVisibilitySpec Source # 
Instance details

Defined in Language.C.Pretty

Located ObjCVisibilitySpec Source # 
Instance details

Defined in Language.C.Syntax

Relocatable ObjCVisibilitySpec Source # 
Instance details

Defined in Language.C.Syntax

data ObjCIfaceDecl Source #

Instances

Instances details
Data ObjCIfaceDecl Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ObjCIfaceDecl -> c ObjCIfaceDecl Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ObjCIfaceDecl Source #

toConstr :: ObjCIfaceDecl -> Constr Source #

dataTypeOf :: ObjCIfaceDecl -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ObjCIfaceDecl) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ObjCIfaceDecl) Source #

gmapT :: (forall b. Data b => b -> b) -> ObjCIfaceDecl -> ObjCIfaceDecl Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ObjCIfaceDecl -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ObjCIfaceDecl -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ObjCIfaceDecl -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ObjCIfaceDecl -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ObjCIfaceDecl -> m ObjCIfaceDecl Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCIfaceDecl -> m ObjCIfaceDecl Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCIfaceDecl -> m ObjCIfaceDecl Source #

Show ObjCIfaceDecl Source # 
Instance details

Defined in Language.C.Syntax

Eq ObjCIfaceDecl Source # 
Instance details

Defined in Language.C.Syntax

Ord ObjCIfaceDecl Source # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCIfaceDecl Source # 
Instance details

Defined in Language.C.Pretty

Located ObjCIfaceDecl Source # 
Instance details

Defined in Language.C.Syntax

Relocatable ObjCIfaceDecl Source # 
Instance details

Defined in Language.C.Syntax

data ObjCPropAttr Source #

Instances

Instances details
Data ObjCPropAttr Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ObjCPropAttr -> c ObjCPropAttr Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ObjCPropAttr Source #

toConstr :: ObjCPropAttr -> Constr Source #

dataTypeOf :: ObjCPropAttr -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ObjCPropAttr) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ObjCPropAttr) Source #

gmapT :: (forall b. Data b => b -> b) -> ObjCPropAttr -> ObjCPropAttr Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ObjCPropAttr -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ObjCPropAttr -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ObjCPropAttr -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ObjCPropAttr -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ObjCPropAttr -> m ObjCPropAttr Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCPropAttr -> m ObjCPropAttr Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCPropAttr -> m ObjCPropAttr Source #

Show ObjCPropAttr Source # 
Instance details

Defined in Language.C.Syntax

Eq ObjCPropAttr Source # 
Instance details

Defined in Language.C.Syntax

Ord ObjCPropAttr Source # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCPropAttr Source # 
Instance details

Defined in Language.C.Pretty

Located ObjCPropAttr Source # 
Instance details

Defined in Language.C.Syntax

Relocatable ObjCPropAttr Source # 
Instance details

Defined in Language.C.Syntax

data ObjCMethodReq Source #

Instances

Instances details
Data ObjCMethodReq Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ObjCMethodReq -> c ObjCMethodReq Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ObjCMethodReq Source #

toConstr :: ObjCMethodReq -> Constr Source #

dataTypeOf :: ObjCMethodReq -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ObjCMethodReq) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ObjCMethodReq) Source #

gmapT :: (forall b. Data b => b -> b) -> ObjCMethodReq -> ObjCMethodReq Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ObjCMethodReq -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ObjCMethodReq -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ObjCMethodReq -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ObjCMethodReq -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ObjCMethodReq -> m ObjCMethodReq Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCMethodReq -> m ObjCMethodReq Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCMethodReq -> m ObjCMethodReq Source #

Show ObjCMethodReq Source # 
Instance details

Defined in Language.C.Syntax

Eq ObjCMethodReq Source # 
Instance details

Defined in Language.C.Syntax

Ord ObjCMethodReq Source # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCMethodReq Source # 
Instance details

Defined in Language.C.Pretty

Located ObjCMethodReq Source # 
Instance details

Defined in Language.C.Syntax

Relocatable ObjCMethodReq Source # 
Instance details

Defined in Language.C.Syntax

data ObjCParam Source #

Instances

Instances details
Data ObjCParam Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ObjCParam -> c ObjCParam Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ObjCParam Source #

toConstr :: ObjCParam -> Constr Source #

dataTypeOf :: ObjCParam -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ObjCParam) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ObjCParam) Source #

gmapT :: (forall b. Data b => b -> b) -> ObjCParam -> ObjCParam Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ObjCParam -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ObjCParam -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ObjCParam -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ObjCParam -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ObjCParam -> m ObjCParam Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCParam -> m ObjCParam Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCParam -> m ObjCParam Source #

Show ObjCParam Source # 
Instance details

Defined in Language.C.Syntax

Eq ObjCParam Source # 
Instance details

Defined in Language.C.Syntax

Ord ObjCParam Source # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCParam Source # 
Instance details

Defined in Language.C.Pretty

Located ObjCParam Source # 
Instance details

Defined in Language.C.Syntax

Relocatable ObjCParam Source # 
Instance details

Defined in Language.C.Syntax

data ObjCMethodProto Source #

Constructors

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 

Instances

Instances details
Data ObjCMethodProto Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ObjCMethodProto -> c ObjCMethodProto Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ObjCMethodProto Source #

toConstr :: ObjCMethodProto -> Constr Source #

dataTypeOf :: ObjCMethodProto -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ObjCMethodProto) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ObjCMethodProto) Source #

gmapT :: (forall b. Data b => b -> b) -> ObjCMethodProto -> ObjCMethodProto Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ObjCMethodProto -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ObjCMethodProto -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ObjCMethodProto -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ObjCMethodProto -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ObjCMethodProto -> m ObjCMethodProto Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCMethodProto -> m ObjCMethodProto Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCMethodProto -> m ObjCMethodProto Source #

Show ObjCMethodProto Source # 
Instance details

Defined in Language.C.Syntax

Eq ObjCMethodProto Source # 
Instance details

Defined in Language.C.Syntax

Ord ObjCMethodProto Source # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCMethodProto Source # 
Instance details

Defined in Language.C.Pretty

Located ObjCMethodProto Source # 
Instance details

Defined in Language.C.Syntax

Relocatable ObjCMethodProto Source # 
Instance details

Defined in Language.C.Syntax

data ObjCCatch Source #

Constructors

ObjCCatch (Maybe Param) [BlockItem] !SrcLoc 

Instances

Instances details
Data ObjCCatch Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ObjCCatch -> c ObjCCatch Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ObjCCatch Source #

toConstr :: ObjCCatch -> Constr Source #

dataTypeOf :: ObjCCatch -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ObjCCatch) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ObjCCatch) Source #

gmapT :: (forall b. Data b => b -> b) -> ObjCCatch -> ObjCCatch Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ObjCCatch -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ObjCCatch -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ObjCCatch -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ObjCCatch -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ObjCCatch -> m ObjCCatch Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCCatch -> m ObjCCatch Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCCatch -> m ObjCCatch Source #

Show ObjCCatch Source # 
Instance details

Defined in Language.C.Syntax

Eq ObjCCatch Source # 
Instance details

Defined in Language.C.Syntax

Ord ObjCCatch Source # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCCatch Source # 
Instance details

Defined in Language.C.Pretty

Located ObjCCatch Source # 
Instance details

Defined in Language.C.Syntax

Relocatable ObjCCatch Source # 
Instance details

Defined in Language.C.Syntax

data ObjCDictElem Source #

Instances

Instances details
Data ObjCDictElem Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ObjCDictElem -> c ObjCDictElem Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ObjCDictElem Source #

toConstr :: ObjCDictElem -> Constr Source #

dataTypeOf :: ObjCDictElem -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ObjCDictElem) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ObjCDictElem) Source #

gmapT :: (forall b. Data b => b -> b) -> ObjCDictElem -> ObjCDictElem Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ObjCDictElem -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ObjCDictElem -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ObjCDictElem -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ObjCDictElem -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ObjCDictElem -> m ObjCDictElem Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCDictElem -> m ObjCDictElem Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCDictElem -> m ObjCDictElem Source #

Show ObjCDictElem Source # 
Instance details

Defined in Language.C.Syntax

Eq ObjCDictElem Source # 
Instance details

Defined in Language.C.Syntax

Ord ObjCDictElem Source # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCDictElem Source # 
Instance details

Defined in Language.C.Pretty

Located ObjCDictElem Source # 
Instance details

Defined in Language.C.Syntax

Relocatable ObjCDictElem Source # 
Instance details

Defined in Language.C.Syntax

data ObjCRecv Source #

Instances

Instances details
Data ObjCRecv Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ObjCRecv -> c ObjCRecv Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ObjCRecv Source #

toConstr :: ObjCRecv -> Constr Source #

dataTypeOf :: ObjCRecv -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ObjCRecv) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ObjCRecv) Source #

gmapT :: (forall b. Data b => b -> b) -> ObjCRecv -> ObjCRecv Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ObjCRecv -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ObjCRecv -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ObjCRecv -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ObjCRecv -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ObjCRecv -> m ObjCRecv Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCRecv -> m ObjCRecv Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCRecv -> m ObjCRecv Source #

Show ObjCRecv Source # 
Instance details

Defined in Language.C.Syntax

Eq ObjCRecv Source # 
Instance details

Defined in Language.C.Syntax

Ord ObjCRecv Source # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCRecv Source # 
Instance details

Defined in Language.C.Pretty

Located ObjCRecv Source # 
Instance details

Defined in Language.C.Syntax

Relocatable ObjCRecv Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> ObjCRecv -> ObjCRecv Source #

data ObjCArg Source #

Instances

Instances details
Data ObjCArg Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ObjCArg -> c ObjCArg Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ObjCArg Source #

toConstr :: ObjCArg -> Constr Source #

dataTypeOf :: ObjCArg -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ObjCArg) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ObjCArg) Source #

gmapT :: (forall b. Data b => b -> b) -> ObjCArg -> ObjCArg Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ObjCArg -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ObjCArg -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ObjCArg -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ObjCArg -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ObjCArg -> m ObjCArg Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCArg -> m ObjCArg Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjCArg -> m ObjCArg Source #

Show ObjCArg Source # 
Instance details

Defined in Language.C.Syntax

Eq ObjCArg Source # 
Instance details

Defined in Language.C.Syntax

Ord ObjCArg Source # 
Instance details

Defined in Language.C.Syntax

Located ObjCArg Source # 
Instance details

Defined in Language.C.Syntax

Relocatable ObjCArg Source # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> ObjCArg -> ObjCArg Source #

data LambdaIntroducer Source #

Instances

Instances details
Data LambdaIntroducer Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LambdaIntroducer -> c LambdaIntroducer Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LambdaIntroducer Source #

toConstr :: LambdaIntroducer -> Constr Source #

dataTypeOf :: LambdaIntroducer -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c LambdaIntroducer) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LambdaIntroducer) Source #

gmapT :: (forall b. Data b => b -> b) -> LambdaIntroducer -> LambdaIntroducer Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LambdaIntroducer -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LambdaIntroducer -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> LambdaIntroducer -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> LambdaIntroducer -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LambdaIntroducer -> m LambdaIntroducer Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LambdaIntroducer -> m LambdaIntroducer Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LambdaIntroducer -> m LambdaIntroducer Source #

Show LambdaIntroducer Source # 
Instance details

Defined in Language.C.Syntax

Eq LambdaIntroducer Source # 
Instance details

Defined in Language.C.Syntax

Ord LambdaIntroducer Source # 
Instance details

Defined in Language.C.Syntax

Pretty LambdaIntroducer Source # 
Instance details

Defined in Language.C.Pretty

Located LambdaIntroducer Source # 
Instance details

Defined in Language.C.Syntax

Relocatable LambdaIntroducer Source # 
Instance details

Defined in Language.C.Syntax

data LambdaDeclarator Source #

Instances

Instances details
Data LambdaDeclarator Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LambdaDeclarator -> c LambdaDeclarator Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LambdaDeclarator Source #

toConstr :: LambdaDeclarator -> Constr Source #

dataTypeOf :: LambdaDeclarator -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c LambdaDeclarator) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LambdaDeclarator) Source #

gmapT :: (forall b. Data b => b -> b) -> LambdaDeclarator -> LambdaDeclarator Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LambdaDeclarator -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LambdaDeclarator -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> LambdaDeclarator -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> LambdaDeclarator -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LambdaDeclarator -> m LambdaDeclarator Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LambdaDeclarator -> m LambdaDeclarator Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LambdaDeclarator -> m LambdaDeclarator Source #

Show LambdaDeclarator Source # 
Instance details

Defined in Language.C.Syntax

Eq LambdaDeclarator Source # 
Instance details

Defined in Language.C.Syntax

Ord LambdaDeclarator Source # 
Instance details

Defined in Language.C.Syntax

Pretty LambdaDeclarator Source # 
Instance details

Defined in Language.C.Pretty

Located LambdaDeclarator Source # 
Instance details

Defined in Language.C.Syntax

Relocatable LambdaDeclarator Source # 
Instance details

Defined in Language.C.Syntax

data CaptureListEntry Source #

Instances

Instances details
Data CaptureListEntry Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CaptureListEntry -> c CaptureListEntry Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CaptureListEntry Source #

toConstr :: CaptureListEntry -> Constr Source #

dataTypeOf :: CaptureListEntry -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CaptureListEntry) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CaptureListEntry) Source #

gmapT :: (forall b. Data b => b -> b) -> CaptureListEntry -> CaptureListEntry Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CaptureListEntry -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CaptureListEntry -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> CaptureListEntry -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CaptureListEntry -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CaptureListEntry -> m CaptureListEntry Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CaptureListEntry -> m CaptureListEntry Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CaptureListEntry -> m CaptureListEntry Source #

Show CaptureListEntry Source # 
Instance details

Defined in Language.C.Syntax

Eq CaptureListEntry Source # 
Instance details

Defined in Language.C.Syntax

Ord CaptureListEntry Source # 
Instance details

Defined in Language.C.Syntax

Pretty CaptureListEntry Source # 
Instance details

Defined in Language.C.Pretty

data ExeConfig Source #

Instances

Instances details
Data ExeConfig Source # 
Instance details

Defined in Language.C.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ExeConfig -> c ExeConfig Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ExeConfig Source #

toConstr :: ExeConfig -> Constr Source #

dataTypeOf :: ExeConfig -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ExeConfig) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExeConfig) Source #

gmapT :: (forall b. Data b => b -> b) -> ExeConfig -> ExeConfig Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExeConfig -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExeConfig -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ExeConfig -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ExeConfig -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExeConfig -> m ExeConfig Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExeConfig -> m ExeConfig Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExeConfig -> m ExeConfig Source #

Show ExeConfig Source # 
Instance details

Defined in Language.C.Syntax

Eq ExeConfig Source # 
Instance details

Defined in Language.C.Syntax

Ord ExeConfig Source # 
Instance details

Defined in Language.C.Syntax

Located ExeConfig Source # 
Instance details

Defined in Language.C.Syntax

Relocatable ExeConfig Source # 
Instance details

Defined in Language.C.Syntax