language-c-quote-0.12.2: 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 HaskellNone
LanguageHaskell98

Language.C.Syntax

Description

 
Synopsis

Documentation

data Id #

Constructors

Id String !SrcLoc 
AntiId String !SrcLoc 
Instances
Eq Id # 
Instance details

Defined in Language.C.Syntax

Methods

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

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

Data Id # 
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 #

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

toConstr :: Id -> Constr #

dataTypeOf :: Id -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Id # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: Id -> Id -> Ordering #

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

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

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

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

max :: Id -> Id -> Id #

min :: Id -> Id -> Id #

Show Id # 
Instance details

Defined in Language.C.Syntax

Methods

showsPrec :: Int -> Id -> ShowS #

show :: Id -> String #

showList :: [Id] -> ShowS #

IsString Id # 
Instance details

Defined in Language.C.Syntax

Methods

fromString :: String -> Id #

Pretty Id # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Id -> Doc #

pprPrec :: Int -> Id -> Doc #

pprList :: [Id] -> Doc #

Located Id # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Id -> Loc #

locOfList :: [Id] -> Loc #

Relocatable Id # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Id -> Id #

ToIdent Id # 
Instance details

Defined in Language.C.Quote.Base

Methods

toIdent :: Id -> SrcLoc -> Id #

ToIdent (SrcLoc -> Id) # 
Instance details

Defined in Language.C.Quote.Base

Methods

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

data StringLit #

Constructors

StringLit [String] String !SrcLoc 
Instances
Eq StringLit # 
Instance details

Defined in Language.C.Syntax

Data StringLit # 
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 #

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

toConstr :: StringLit -> Constr #

dataTypeOf :: StringLit -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord StringLit # 
Instance details

Defined in Language.C.Syntax

Show StringLit # 
Instance details

Defined in Language.C.Syntax

IsString StringLit # 
Instance details

Defined in Language.C.Syntax

Pretty StringLit # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: StringLit -> Doc #

pprPrec :: Int -> StringLit -> Doc #

pprList :: [StringLit] -> Doc #

Located StringLit # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: StringLit -> Loc #

locOfList :: [StringLit] -> Loc #

Relocatable StringLit # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> StringLit -> StringLit #

data Storage #

Instances
Eq Storage # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: Storage -> Storage -> Bool #

(/=) :: Storage -> Storage -> Bool #

Data Storage # 
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 #

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

toConstr :: Storage -> Constr #

dataTypeOf :: Storage -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Storage # 
Instance details

Defined in Language.C.Syntax

Show Storage # 
Instance details

Defined in Language.C.Syntax

Pretty Storage # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Storage -> Doc #

pprPrec :: Int -> Storage -> Doc #

pprList :: [Storage] -> Doc #

Located Storage # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Storage -> Loc #

locOfList :: [Storage] -> Loc #

Relocatable Storage # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Storage -> Storage #

data TypeQual #

Instances
Eq TypeQual # 
Instance details

Defined in Language.C.Syntax

Data TypeQual # 
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 #

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

toConstr :: TypeQual -> Constr #

dataTypeOf :: TypeQual -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord TypeQual # 
Instance details

Defined in Language.C.Syntax

Show TypeQual # 
Instance details

Defined in Language.C.Syntax

Pretty TypeQual # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: TypeQual -> Doc #

pprPrec :: Int -> TypeQual -> Doc #

pprList :: [TypeQual] -> Doc #

Located TypeQual # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: TypeQual -> Loc #

locOfList :: [TypeQual] -> Loc #

Relocatable TypeQual # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> TypeQual -> TypeQual #

data Sign #

Constructors

Tsigned !SrcLoc 
Tunsigned !SrcLoc 
Instances
Eq Sign # 
Instance details

Defined in Language.C.Syntax

Methods

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

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

Data Sign # 
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 #

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

toConstr :: Sign -> Constr #

dataTypeOf :: Sign -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Sign # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: Sign -> Sign -> Ordering #

(<) :: Sign -> Sign -> Bool #

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

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

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

max :: Sign -> Sign -> Sign #

min :: Sign -> Sign -> Sign #

Show Sign # 
Instance details

Defined in Language.C.Syntax

Methods

showsPrec :: Int -> Sign -> ShowS #

show :: Sign -> String #

showList :: [Sign] -> ShowS #

Pretty Sign # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Sign -> Doc #

pprPrec :: Int -> Sign -> Doc #

pprList :: [Sign] -> Doc #

Located Sign # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Sign -> Loc #

locOfList :: [Sign] -> Loc #

Relocatable Sign # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Sign -> Sign #

data TypeSpec #

Instances
Eq TypeSpec # 
Instance details

Defined in Language.C.Syntax

Data TypeSpec # 
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 #

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

toConstr :: TypeSpec -> Constr #

dataTypeOf :: TypeSpec -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord TypeSpec # 
Instance details

Defined in Language.C.Syntax

Show TypeSpec # 
Instance details

Defined in Language.C.Syntax

Pretty TypeSpec # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: TypeSpec -> Doc #

pprPrec :: Int -> TypeSpec -> Doc #

pprList :: [TypeSpec] -> Doc #

Located TypeSpec # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: TypeSpec -> Loc #

locOfList :: [TypeSpec] -> Loc #

Relocatable TypeSpec # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> TypeSpec -> TypeSpec #

data DeclSpec #

Instances
Eq DeclSpec # 
Instance details

Defined in Language.C.Syntax

Data DeclSpec # 
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 #

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

toConstr :: DeclSpec -> Constr #

dataTypeOf :: DeclSpec -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord DeclSpec # 
Instance details

Defined in Language.C.Syntax

Show DeclSpec # 
Instance details

Defined in Language.C.Syntax

Pretty DeclSpec # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: DeclSpec -> Doc #

pprPrec :: Int -> DeclSpec -> Doc #

pprList :: [DeclSpec] -> Doc #

Located DeclSpec # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: DeclSpec -> Loc #

locOfList :: [DeclSpec] -> Loc #

Relocatable DeclSpec # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> DeclSpec -> DeclSpec #

data ArraySize #

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
Eq ArraySize # 
Instance details

Defined in Language.C.Syntax

Data ArraySize # 
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 #

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

toConstr :: ArraySize -> Constr #

dataTypeOf :: ArraySize -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord ArraySize # 
Instance details

Defined in Language.C.Syntax

Show ArraySize # 
Instance details

Defined in Language.C.Syntax

Pretty ArraySize # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: ArraySize -> Doc #

pprPrec :: Int -> ArraySize -> Doc #

pprList :: [ArraySize] -> Doc #

Located ArraySize # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: ArraySize -> Loc #

locOfList :: [ArraySize] -> Loc #

Relocatable ArraySize # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> ArraySize -> ArraySize #

data Decl #

Instances
Eq Decl # 
Instance details

Defined in Language.C.Syntax

Methods

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

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

Data Decl # 
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 #

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

toConstr :: Decl -> Constr #

dataTypeOf :: Decl -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Decl # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: Decl -> Decl -> Ordering #

(<) :: Decl -> Decl -> Bool #

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

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

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

max :: Decl -> Decl -> Decl #

min :: Decl -> Decl -> Decl #

Show Decl # 
Instance details

Defined in Language.C.Syntax

Methods

showsPrec :: Int -> Decl -> ShowS #

show :: Decl -> String #

showList :: [Decl] -> ShowS #

Located Decl # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Decl -> Loc #

locOfList :: [Decl] -> Loc #

Relocatable Decl # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Decl -> Decl #

data Type #

Instances
Eq Type # 
Instance details

Defined in Language.C.Syntax

Methods

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

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

Data Type # 
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 #

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

toConstr :: Type -> Constr #

dataTypeOf :: Type -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Type # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: Type -> Type -> Ordering #

(<) :: Type -> Type -> Bool #

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

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

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

max :: Type -> Type -> Type #

min :: Type -> Type -> Type #

Show Type # 
Instance details

Defined in Language.C.Syntax

Methods

showsPrec :: Int -> Type -> ShowS #

show :: Type -> String #

showList :: [Type] -> ShowS #

Pretty Type # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Type -> Doc #

pprPrec :: Int -> Type -> Doc #

pprList :: [Type] -> Doc #

Located Type # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Type -> Loc #

locOfList :: [Type] -> Loc #

Relocatable Type # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Type -> Type #

data Designator #

Instances
Eq Designator # 
Instance details

Defined in Language.C.Syntax

Data Designator # 
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 #

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

toConstr :: Designator -> Constr #

dataTypeOf :: Designator -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Designator # 
Instance details

Defined in Language.C.Syntax

Show Designator # 
Instance details

Defined in Language.C.Syntax

Pretty Designator # 
Instance details

Defined in Language.C.Pretty

Located Designator # 
Instance details

Defined in Language.C.Syntax

Relocatable Designator # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Designator -> Designator #

data Designation #

Constructors

Designation [Designator] !SrcLoc 
Instances
Eq Designation # 
Instance details

Defined in Language.C.Syntax

Data Designation # 
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 #

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

toConstr :: Designation -> Constr #

dataTypeOf :: Designation -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Designation # 
Instance details

Defined in Language.C.Syntax

Show Designation # 
Instance details

Defined in Language.C.Syntax

Pretty Designation # 
Instance details

Defined in Language.C.Pretty

Located Designation # 
Instance details

Defined in Language.C.Syntax

Relocatable Designation # 
Instance details

Defined in Language.C.Syntax

data Initializer #

Instances
Eq Initializer # 
Instance details

Defined in Language.C.Syntax

Data Initializer # 
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 #

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

toConstr :: Initializer -> Constr #

dataTypeOf :: Initializer -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Initializer # 
Instance details

Defined in Language.C.Syntax

Show Initializer # 
Instance details

Defined in Language.C.Syntax

Pretty Initializer # 
Instance details

Defined in Language.C.Pretty

Located Initializer # 
Instance details

Defined in Language.C.Syntax

Relocatable Initializer # 
Instance details

Defined in Language.C.Syntax

data Init #

Instances
Eq Init # 
Instance details

Defined in Language.C.Syntax

Methods

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

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

Data Init # 
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 #

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

toConstr :: Init -> Constr #

dataTypeOf :: Init -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Init # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: Init -> Init -> Ordering #

(<) :: Init -> Init -> Bool #

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

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

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

max :: Init -> Init -> Init #

min :: Init -> Init -> Init #

Show Init # 
Instance details

Defined in Language.C.Syntax

Methods

showsPrec :: Int -> Init -> ShowS #

show :: Init -> String #

showList :: [Init] -> ShowS #

Pretty Init # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Init -> Doc #

pprPrec :: Int -> Init -> Doc #

pprList :: [Init] -> Doc #

Located Init # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Init -> Loc #

locOfList :: [Init] -> Loc #

Relocatable Init # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Init -> Init #

data Typedef #

Constructors

Typedef Id Decl [Attr] !SrcLoc 
Instances
Eq Typedef # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: Typedef -> Typedef -> Bool #

(/=) :: Typedef -> Typedef -> Bool #

Data Typedef # 
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 #

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

toConstr :: Typedef -> Constr #

dataTypeOf :: Typedef -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Typedef # 
Instance details

Defined in Language.C.Syntax

Show Typedef # 
Instance details

Defined in Language.C.Syntax

Pretty Typedef # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Typedef -> Doc #

pprPrec :: Int -> Typedef -> Doc #

pprList :: [Typedef] -> Doc #

Located Typedef # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Typedef -> Loc #

locOfList :: [Typedef] -> Loc #

Relocatable Typedef # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Typedef -> Typedef #

data InitGroup #

Instances
Eq InitGroup # 
Instance details

Defined in Language.C.Syntax

Data InitGroup # 
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 #

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

toConstr :: InitGroup -> Constr #

dataTypeOf :: InitGroup -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord InitGroup # 
Instance details

Defined in Language.C.Syntax

Show InitGroup # 
Instance details

Defined in Language.C.Syntax

Pretty InitGroup # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: InitGroup -> Doc #

pprPrec :: Int -> InitGroup -> Doc #

pprList :: [InitGroup] -> Doc #

Located InitGroup # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: InitGroup -> Loc #

locOfList :: [InitGroup] -> Loc #

Relocatable InitGroup # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> InitGroup -> InitGroup #

data Field #

Constructors

Field (Maybe Id) (Maybe Decl) (Maybe Exp) !SrcLoc 
Instances
Eq Field # 
Instance details

Defined in Language.C.Syntax

Methods

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

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

Data Field # 
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 #

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

toConstr :: Field -> Constr #

dataTypeOf :: Field -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Field # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: Field -> Field -> Ordering #

(<) :: Field -> Field -> Bool #

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

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

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

max :: Field -> Field -> Field #

min :: Field -> Field -> Field #

Show Field # 
Instance details

Defined in Language.C.Syntax

Methods

showsPrec :: Int -> Field -> ShowS #

show :: Field -> String #

showList :: [Field] -> ShowS #

Pretty Field # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Field -> Doc #

pprPrec :: Int -> Field -> Doc #

pprList :: [Field] -> Doc #

Located Field # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Field -> Loc #

locOfList :: [Field] -> Loc #

Relocatable Field # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Field -> Field #

data FieldGroup #

Instances
Eq FieldGroup # 
Instance details

Defined in Language.C.Syntax

Data FieldGroup # 
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 #

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

toConstr :: FieldGroup -> Constr #

dataTypeOf :: FieldGroup -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord FieldGroup # 
Instance details

Defined in Language.C.Syntax

Show FieldGroup # 
Instance details

Defined in Language.C.Syntax

Pretty FieldGroup # 
Instance details

Defined in Language.C.Pretty

Located FieldGroup # 
Instance details

Defined in Language.C.Syntax

Relocatable FieldGroup # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> FieldGroup -> FieldGroup #

data CEnum #

Instances
Eq CEnum # 
Instance details

Defined in Language.C.Syntax

Methods

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

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

Data CEnum # 
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 #

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

toConstr :: CEnum -> Constr #

dataTypeOf :: CEnum -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord CEnum # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: CEnum -> CEnum -> Ordering #

(<) :: CEnum -> CEnum -> Bool #

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

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

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

max :: CEnum -> CEnum -> CEnum #

min :: CEnum -> CEnum -> CEnum #

Show CEnum # 
Instance details

Defined in Language.C.Syntax

Methods

showsPrec :: Int -> CEnum -> ShowS #

show :: CEnum -> String #

showList :: [CEnum] -> ShowS #

Pretty CEnum # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: CEnum -> Doc #

pprPrec :: Int -> CEnum -> Doc #

pprList :: [CEnum] -> Doc #

Located CEnum # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: CEnum -> Loc #

locOfList :: [CEnum] -> Loc #

Relocatable CEnum # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> CEnum -> CEnum #

data Attr #

Constructors

Attr Id [Exp] !SrcLoc 
Instances
Eq Attr # 
Instance details

Defined in Language.C.Syntax

Methods

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

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

Data Attr # 
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 #

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

toConstr :: Attr -> Constr #

dataTypeOf :: Attr -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Attr # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: Attr -> Attr -> Ordering #

(<) :: Attr -> Attr -> Bool #

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

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

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

max :: Attr -> Attr -> Attr #

min :: Attr -> Attr -> Attr #

Show Attr # 
Instance details

Defined in Language.C.Syntax

Methods

showsPrec :: Int -> Attr -> ShowS #

show :: Attr -> String #

showList :: [Attr] -> ShowS #

Pretty Attr # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Attr -> Doc #

pprPrec :: Int -> Attr -> Doc #

pprList :: [Attr] -> Doc #

Located Attr # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Attr -> Loc #

locOfList :: [Attr] -> Loc #

Relocatable Attr # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Attr -> Attr #

data Param #

Instances
Eq Param # 
Instance details

Defined in Language.C.Syntax

Methods

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

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

Data Param # 
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 #

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

toConstr :: Param -> Constr #

dataTypeOf :: Param -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Param # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: Param -> Param -> Ordering #

(<) :: Param -> Param -> Bool #

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

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

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

max :: Param -> Param -> Param #

min :: Param -> Param -> Param #

Show Param # 
Instance details

Defined in Language.C.Syntax

Methods

showsPrec :: Int -> Param -> ShowS #

show :: Param -> String #

showList :: [Param] -> ShowS #

Pretty Param # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Param -> Doc #

pprPrec :: Int -> Param -> Doc #

pprList :: [Param] -> Doc #

Located Param # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Param -> Loc #

locOfList :: [Param] -> Loc #

Relocatable Param # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Param -> Param #

data Params #

Constructors

Params [Param] Bool !SrcLoc 
Instances
Eq Params # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: Params -> Params -> Bool #

(/=) :: Params -> Params -> Bool #

Data Params # 
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 #

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

toConstr :: Params -> Constr #

dataTypeOf :: Params -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Params # 
Instance details

Defined in Language.C.Syntax

Show Params # 
Instance details

Defined in Language.C.Syntax

Pretty Params # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Params -> Doc #

pprPrec :: Int -> Params -> Doc #

pprList :: [Params] -> Doc #

Located Params # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Params -> Loc #

locOfList :: [Params] -> Loc #

Relocatable Params # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Params -> Params #

data Func #

Instances
Eq Func # 
Instance details

Defined in Language.C.Syntax

Methods

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

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

Data Func # 
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 #

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

toConstr :: Func -> Constr #

dataTypeOf :: Func -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Func # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: Func -> Func -> Ordering #

(<) :: Func -> Func -> Bool #

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

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

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

max :: Func -> Func -> Func #

min :: Func -> Func -> Func #

Show Func # 
Instance details

Defined in Language.C.Syntax

Methods

showsPrec :: Int -> Func -> ShowS #

show :: Func -> String #

showList :: [Func] -> ShowS #

Pretty Func # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Func -> Doc #

pprPrec :: Int -> Func -> Doc #

pprList :: [Func] -> Doc #

Located Func # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Func -> Loc #

locOfList :: [Func] -> Loc #

Relocatable Func # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Func -> Func #

data Definition #

Instances
Eq Definition # 
Instance details

Defined in Language.C.Syntax

Data Definition # 
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 #

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

toConstr :: Definition -> Constr #

dataTypeOf :: Definition -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Definition # 
Instance details

Defined in Language.C.Syntax

Show Definition # 
Instance details

Defined in Language.C.Syntax

Pretty Definition # 
Instance details

Defined in Language.C.Pretty

Located Definition # 
Instance details

Defined in Language.C.Syntax

Relocatable Definition # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Definition -> Definition #

data Stm #

Instances
Eq Stm # 
Instance details

Defined in Language.C.Syntax

Methods

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

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

Data Stm # 
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 #

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

toConstr :: Stm -> Constr #

dataTypeOf :: Stm -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Stm # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: Stm -> Stm -> Ordering #

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

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

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

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

max :: Stm -> Stm -> Stm #

min :: Stm -> Stm -> Stm #

Show Stm # 
Instance details

Defined in Language.C.Syntax

Methods

showsPrec :: Int -> Stm -> ShowS #

show :: Stm -> String #

showList :: [Stm] -> ShowS #

Pretty Stm # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Stm -> Doc #

pprPrec :: Int -> Stm -> Doc #

pprList :: [Stm] -> Doc #

Located Stm # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Stm -> Loc #

locOfList :: [Stm] -> Loc #

Relocatable Stm # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Stm -> Stm #

data BlockItem #

Instances
Eq BlockItem # 
Instance details

Defined in Language.C.Syntax

Data BlockItem # 
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 #

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

toConstr :: BlockItem -> Constr #

dataTypeOf :: BlockItem -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord BlockItem # 
Instance details

Defined in Language.C.Syntax

Show BlockItem # 
Instance details

Defined in Language.C.Syntax

Pretty BlockItem # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: BlockItem -> Doc #

pprPrec :: Int -> BlockItem -> Doc #

pprList :: [BlockItem] -> Doc #

Located BlockItem # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: BlockItem -> Loc #

locOfList :: [BlockItem] -> Loc #

Relocatable BlockItem # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> BlockItem -> BlockItem #

data Signed #

Constructors

Signed 
Unsigned 
Instances
Eq Signed # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: Signed -> Signed -> Bool #

(/=) :: Signed -> Signed -> Bool #

Data Signed # 
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 #

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

toConstr :: Signed -> Constr #

dataTypeOf :: Signed -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Signed # 
Instance details

Defined in Language.C.Syntax

Show Signed # 
Instance details

Defined in Language.C.Syntax

data Const #

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

Instances
Eq Const # 
Instance details

Defined in Language.C.Syntax

Methods

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

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

Data Const # 
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 #

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

toConstr :: Const -> Constr #

dataTypeOf :: Const -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Const # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: Const -> Const -> Ordering #

(<) :: Const -> Const -> Bool #

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

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

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

max :: Const -> Const -> Const #

min :: Const -> Const -> Const #

Show Const # 
Instance details

Defined in Language.C.Syntax

Methods

showsPrec :: Int -> Const -> ShowS #

show :: Const -> String #

showList :: [Const] -> ShowS #

Pretty Const # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Const -> Doc #

pprPrec :: Int -> Const -> Doc #

pprList :: [Const] -> Doc #

Located Const # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Const -> Loc #

locOfList :: [Const] -> Loc #

Relocatable Const # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Const -> Const #

ToConst Const # 
Instance details

Defined in Language.C.Quote.Base

Methods

toConst :: Const -> SrcLoc -> Const #

data Exp #

Instances
Enum Exp # 
Instance details

Defined in Language.C.Smart

Methods

succ :: Exp -> Exp #

pred :: Exp -> Exp #

toEnum :: Int -> Exp #

fromEnum :: Exp -> Int #

enumFrom :: Exp -> [Exp] #

enumFromThen :: Exp -> Exp -> [Exp] #

enumFromTo :: Exp -> Exp -> [Exp] #

enumFromThenTo :: Exp -> Exp -> Exp -> [Exp] #

Eq Exp # 
Instance details

Defined in Language.C.Syntax

Methods

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

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

Floating Exp # 
Instance details

Defined in Language.C.Smart

Methods

pi :: Exp #

exp :: Exp -> Exp #

log :: Exp -> Exp #

sqrt :: Exp -> Exp #

(**) :: Exp -> Exp -> Exp #

logBase :: Exp -> Exp -> Exp #

sin :: Exp -> Exp #

cos :: Exp -> Exp #

tan :: Exp -> Exp #

asin :: Exp -> Exp #

acos :: Exp -> Exp #

atan :: Exp -> Exp #

sinh :: Exp -> Exp #

cosh :: Exp -> Exp #

tanh :: Exp -> Exp #

asinh :: Exp -> Exp #

acosh :: Exp -> Exp #

atanh :: Exp -> Exp #

log1p :: Exp -> Exp #

expm1 :: Exp -> Exp #

log1pexp :: Exp -> Exp #

log1mexp :: Exp -> Exp #

Fractional Exp # 
Instance details

Defined in Language.C.Smart

Methods

(/) :: Exp -> Exp -> Exp #

recip :: Exp -> Exp #

fromRational :: Rational -> Exp #

Integral Exp # 
Instance details

Defined in Language.C.Smart

Methods

quot :: Exp -> Exp -> Exp #

rem :: Exp -> Exp -> Exp #

div :: Exp -> Exp -> Exp #

mod :: Exp -> Exp -> Exp #

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

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

toInteger :: Exp -> Integer #

Data Exp # 
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 #

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

toConstr :: Exp -> Constr #

dataTypeOf :: Exp -> DataType #

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

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

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

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

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

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

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

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

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

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

Num Exp # 
Instance details

Defined in Language.C.Smart

Methods

(+) :: Exp -> Exp -> Exp #

(-) :: Exp -> Exp -> Exp #

(*) :: Exp -> Exp -> Exp #

negate :: Exp -> Exp #

abs :: Exp -> Exp #

signum :: Exp -> Exp #

fromInteger :: Integer -> Exp #

Ord Exp # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: Exp -> Exp -> Ordering #

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

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

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

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

max :: Exp -> Exp -> Exp #

min :: Exp -> Exp -> Exp #

Real Exp # 
Instance details

Defined in Language.C.Smart

Methods

toRational :: Exp -> Rational #

Show Exp # 
Instance details

Defined in Language.C.Syntax

Methods

showsPrec :: Int -> Exp -> ShowS #

show :: Exp -> String #

showList :: [Exp] -> ShowS #

Pretty Exp # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: Exp -> Doc #

pprPrec :: Int -> Exp -> Doc #

pprList :: [Exp] -> Doc #

Located Exp # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: Exp -> Loc #

locOfList :: [Exp] -> Loc #

Relocatable Exp # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> Exp -> Exp #

ToExp Exp # 
Instance details

Defined in Language.C.Quote.Base

Methods

toExp :: Exp -> SrcLoc -> Exp #

data BinOp #

Constructors

Add 
Sub 
Mul 
Div 
Mod 
Eq 
Ne 
Lt 
Gt 
Le 
Ge 
Land 
Lor 
And 
Or 
Xor 
Lsh 
Rsh 
Instances
Eq BinOp # 
Instance details

Defined in Language.C.Syntax

Methods

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

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

Data BinOp # 
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 #

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

toConstr :: BinOp -> Constr #

dataTypeOf :: BinOp -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord BinOp # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: BinOp -> BinOp -> Ordering #

(<) :: BinOp -> BinOp -> Bool #

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

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

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

max :: BinOp -> BinOp -> BinOp #

min :: BinOp -> BinOp -> BinOp #

Show BinOp # 
Instance details

Defined in Language.C.Syntax

Methods

showsPrec :: Int -> BinOp -> ShowS #

show :: BinOp -> String #

showList :: [BinOp] -> ShowS #

Pretty BinOp # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: BinOp -> Doc #

pprPrec :: Int -> BinOp -> Doc #

pprList :: [BinOp] -> Doc #

CFixity BinOp # 
Instance details

Defined in Language.C.Pretty

Methods

fixity :: BinOp -> Fixity #

parensOp :: Int -> BinOp -> Doc -> Doc #

data AssignOp #

Instances
Eq AssignOp # 
Instance details

Defined in Language.C.Syntax

Data AssignOp # 
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 #

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

toConstr :: AssignOp -> Constr #

dataTypeOf :: AssignOp -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord AssignOp # 
Instance details

Defined in Language.C.Syntax

Show AssignOp # 
Instance details

Defined in Language.C.Syntax

Pretty AssignOp # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: AssignOp -> Doc #

pprPrec :: Int -> AssignOp -> Doc #

pprList :: [AssignOp] -> Doc #

CFixity AssignOp # 
Instance details

Defined in Language.C.Pretty

Methods

fixity :: AssignOp -> Fixity #

parensOp :: Int -> AssignOp -> Doc -> Doc #

data UnOp #

Constructors

AddrOf 
Deref 
Positive 
Negate 
Not 
Lnot 
Instances
Eq UnOp # 
Instance details

Defined in Language.C.Syntax

Methods

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

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

Data UnOp # 
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 #

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

toConstr :: UnOp -> Constr #

dataTypeOf :: UnOp -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord UnOp # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: UnOp -> UnOp -> Ordering #

(<) :: UnOp -> UnOp -> Bool #

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

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

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

max :: UnOp -> UnOp -> UnOp #

min :: UnOp -> UnOp -> UnOp #

Show UnOp # 
Instance details

Defined in Language.C.Syntax

Methods

showsPrec :: Int -> UnOp -> ShowS #

show :: UnOp -> String #

showList :: [UnOp] -> ShowS #

Pretty UnOp # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: UnOp -> Doc #

pprPrec :: Int -> UnOp -> Doc #

pprList :: [UnOp] -> Doc #

CFixity UnOp # 
Instance details

Defined in Language.C.Pretty

Methods

fixity :: UnOp -> Fixity #

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

data AsmOut #

Constructors

AsmOut (Maybe Id) String Id 
Instances
Eq AsmOut # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: AsmOut -> AsmOut -> Bool #

(/=) :: AsmOut -> AsmOut -> Bool #

Data AsmOut # 
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 #

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

toConstr :: AsmOut -> Constr #

dataTypeOf :: AsmOut -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord AsmOut # 
Instance details

Defined in Language.C.Syntax

Show AsmOut # 
Instance details

Defined in Language.C.Syntax

Pretty AsmOut # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: AsmOut -> Doc #

pprPrec :: Int -> AsmOut -> Doc #

pprList :: [AsmOut] -> Doc #

data AsmIn #

Constructors

AsmIn (Maybe Id) String Exp 
Instances
Eq AsmIn # 
Instance details

Defined in Language.C.Syntax

Methods

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

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

Data AsmIn # 
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 #

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

toConstr :: AsmIn -> Constr #

dataTypeOf :: AsmIn -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord AsmIn # 
Instance details

Defined in Language.C.Syntax

Methods

compare :: AsmIn -> AsmIn -> Ordering #

(<) :: AsmIn -> AsmIn -> Bool #

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

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

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

max :: AsmIn -> AsmIn -> AsmIn #

min :: AsmIn -> AsmIn -> AsmIn #

Show AsmIn # 
Instance details

Defined in Language.C.Syntax

Methods

showsPrec :: Int -> AsmIn -> ShowS #

show :: AsmIn -> String #

showList :: [AsmIn] -> ShowS #

Pretty AsmIn # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: AsmIn -> Doc #

pprPrec :: Int -> AsmIn -> Doc #

pprList :: [AsmIn] -> Doc #

data BlockType #

Instances
Eq BlockType # 
Instance details

Defined in Language.C.Syntax

Data BlockType # 
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 #

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

toConstr :: BlockType -> Constr #

dataTypeOf :: BlockType -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord BlockType # 
Instance details

Defined in Language.C.Syntax

Show BlockType # 
Instance details

Defined in Language.C.Syntax

Pretty BlockType # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: BlockType -> Doc #

pprPrec :: Int -> BlockType -> Doc #

pprList :: [BlockType] -> Doc #

Located BlockType # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: BlockType -> Loc #

locOfList :: [BlockType] -> Loc #

Relocatable BlockType # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> BlockType -> BlockType #

data ObjCIvarDecl #

Instances
Eq ObjCIvarDecl # 
Instance details

Defined in Language.C.Syntax

Data ObjCIvarDecl # 
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 #

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

toConstr :: ObjCIvarDecl -> Constr #

dataTypeOf :: ObjCIvarDecl -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord ObjCIvarDecl # 
Instance details

Defined in Language.C.Syntax

Show ObjCIvarDecl # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCIvarDecl # 
Instance details

Defined in Language.C.Pretty

Located ObjCIvarDecl # 
Instance details

Defined in Language.C.Syntax

Relocatable ObjCIvarDecl # 
Instance details

Defined in Language.C.Syntax

data ObjCVisibilitySpec #

Instances
Eq ObjCVisibilitySpec # 
Instance details

Defined in Language.C.Syntax

Data ObjCVisibilitySpec # 
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 #

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

toConstr :: ObjCVisibilitySpec -> Constr #

dataTypeOf :: ObjCVisibilitySpec -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord ObjCVisibilitySpec # 
Instance details

Defined in Language.C.Syntax

Show ObjCVisibilitySpec # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCVisibilitySpec # 
Instance details

Defined in Language.C.Pretty

Located ObjCVisibilitySpec # 
Instance details

Defined in Language.C.Syntax

Relocatable ObjCVisibilitySpec # 
Instance details

Defined in Language.C.Syntax

data ObjCIfaceDecl #

Instances
Eq ObjCIfaceDecl # 
Instance details

Defined in Language.C.Syntax

Data ObjCIfaceDecl # 
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 #

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

toConstr :: ObjCIfaceDecl -> Constr #

dataTypeOf :: ObjCIfaceDecl -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord ObjCIfaceDecl # 
Instance details

Defined in Language.C.Syntax

Show ObjCIfaceDecl # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCIfaceDecl # 
Instance details

Defined in Language.C.Pretty

Located ObjCIfaceDecl # 
Instance details

Defined in Language.C.Syntax

Relocatable ObjCIfaceDecl # 
Instance details

Defined in Language.C.Syntax

data ObjCPropAttr #

Instances
Eq ObjCPropAttr # 
Instance details

Defined in Language.C.Syntax

Data ObjCPropAttr # 
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 #

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

toConstr :: ObjCPropAttr -> Constr #

dataTypeOf :: ObjCPropAttr -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord ObjCPropAttr # 
Instance details

Defined in Language.C.Syntax

Show ObjCPropAttr # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCPropAttr # 
Instance details

Defined in Language.C.Pretty

Located ObjCPropAttr # 
Instance details

Defined in Language.C.Syntax

Relocatable ObjCPropAttr # 
Instance details

Defined in Language.C.Syntax

data ObjCMethodReq #

Instances
Eq ObjCMethodReq # 
Instance details

Defined in Language.C.Syntax

Data ObjCMethodReq # 
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 #

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

toConstr :: ObjCMethodReq -> Constr #

dataTypeOf :: ObjCMethodReq -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord ObjCMethodReq # 
Instance details

Defined in Language.C.Syntax

Show ObjCMethodReq # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCMethodReq # 
Instance details

Defined in Language.C.Pretty

Located ObjCMethodReq # 
Instance details

Defined in Language.C.Syntax

Relocatable ObjCMethodReq # 
Instance details

Defined in Language.C.Syntax

data ObjCParam #

Instances
Eq ObjCParam # 
Instance details

Defined in Language.C.Syntax

Data ObjCParam # 
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 #

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

toConstr :: ObjCParam -> Constr #

dataTypeOf :: ObjCParam -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord ObjCParam # 
Instance details

Defined in Language.C.Syntax

Show ObjCParam # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCParam # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: ObjCParam -> Doc #

pprPrec :: Int -> ObjCParam -> Doc #

pprList :: [ObjCParam] -> Doc #

Located ObjCParam # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: ObjCParam -> Loc #

locOfList :: [ObjCParam] -> Loc #

Relocatable ObjCParam # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> ObjCParam -> ObjCParam #

data ObjCMethodProto #

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
Eq ObjCMethodProto # 
Instance details

Defined in Language.C.Syntax

Data ObjCMethodProto # 
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 #

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

toConstr :: ObjCMethodProto -> Constr #

dataTypeOf :: ObjCMethodProto -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord ObjCMethodProto # 
Instance details

Defined in Language.C.Syntax

Show ObjCMethodProto # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCMethodProto # 
Instance details

Defined in Language.C.Pretty

Located ObjCMethodProto # 
Instance details

Defined in Language.C.Syntax

Relocatable ObjCMethodProto # 
Instance details

Defined in Language.C.Syntax

data ObjCCatch #

Constructors

ObjCCatch (Maybe Param) [BlockItem] !SrcLoc 
Instances
Eq ObjCCatch # 
Instance details

Defined in Language.C.Syntax

Data ObjCCatch # 
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 #

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

toConstr :: ObjCCatch -> Constr #

dataTypeOf :: ObjCCatch -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord ObjCCatch # 
Instance details

Defined in Language.C.Syntax

Show ObjCCatch # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCCatch # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: ObjCCatch -> Doc #

pprPrec :: Int -> ObjCCatch -> Doc #

pprList :: [ObjCCatch] -> Doc #

Located ObjCCatch # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: ObjCCatch -> Loc #

locOfList :: [ObjCCatch] -> Loc #

Relocatable ObjCCatch # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> ObjCCatch -> ObjCCatch #

data ObjCDictElem #

Instances
Eq ObjCDictElem # 
Instance details

Defined in Language.C.Syntax

Data ObjCDictElem # 
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 #

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

toConstr :: ObjCDictElem -> Constr #

dataTypeOf :: ObjCDictElem -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord ObjCDictElem # 
Instance details

Defined in Language.C.Syntax

Show ObjCDictElem # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCDictElem # 
Instance details

Defined in Language.C.Pretty

Located ObjCDictElem # 
Instance details

Defined in Language.C.Syntax

Relocatable ObjCDictElem # 
Instance details

Defined in Language.C.Syntax

data ObjCRecv #

Instances
Eq ObjCRecv # 
Instance details

Defined in Language.C.Syntax

Data ObjCRecv # 
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 #

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

toConstr :: ObjCRecv -> Constr #

dataTypeOf :: ObjCRecv -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord ObjCRecv # 
Instance details

Defined in Language.C.Syntax

Show ObjCRecv # 
Instance details

Defined in Language.C.Syntax

Pretty ObjCRecv # 
Instance details

Defined in Language.C.Pretty

Methods

ppr :: ObjCRecv -> Doc #

pprPrec :: Int -> ObjCRecv -> Doc #

pprList :: [ObjCRecv] -> Doc #

Located ObjCRecv # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: ObjCRecv -> Loc #

locOfList :: [ObjCRecv] -> Loc #

Relocatable ObjCRecv # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> ObjCRecv -> ObjCRecv #

data ObjCArg #

Instances
Eq ObjCArg # 
Instance details

Defined in Language.C.Syntax

Methods

(==) :: ObjCArg -> ObjCArg -> Bool #

(/=) :: ObjCArg -> ObjCArg -> Bool #

Data ObjCArg # 
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 #

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

toConstr :: ObjCArg -> Constr #

dataTypeOf :: ObjCArg -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord ObjCArg # 
Instance details

Defined in Language.C.Syntax

Show ObjCArg # 
Instance details

Defined in Language.C.Syntax

Located ObjCArg # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: ObjCArg -> Loc #

locOfList :: [ObjCArg] -> Loc #

Relocatable ObjCArg # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> ObjCArg -> ObjCArg #

data LambdaIntroducer #

Instances
Eq LambdaIntroducer # 
Instance details

Defined in Language.C.Syntax

Data LambdaIntroducer # 
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 #

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

toConstr :: LambdaIntroducer -> Constr #

dataTypeOf :: LambdaIntroducer -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord LambdaIntroducer # 
Instance details

Defined in Language.C.Syntax

Show LambdaIntroducer # 
Instance details

Defined in Language.C.Syntax

Pretty LambdaIntroducer # 
Instance details

Defined in Language.C.Pretty

Located LambdaIntroducer # 
Instance details

Defined in Language.C.Syntax

Relocatable LambdaIntroducer # 
Instance details

Defined in Language.C.Syntax

data LambdaDeclarator #

Instances
Eq LambdaDeclarator # 
Instance details

Defined in Language.C.Syntax

Data LambdaDeclarator # 
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 #

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

toConstr :: LambdaDeclarator -> Constr #

dataTypeOf :: LambdaDeclarator -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord LambdaDeclarator # 
Instance details

Defined in Language.C.Syntax

Show LambdaDeclarator # 
Instance details

Defined in Language.C.Syntax

Pretty LambdaDeclarator # 
Instance details

Defined in Language.C.Pretty

Located LambdaDeclarator # 
Instance details

Defined in Language.C.Syntax

Relocatable LambdaDeclarator # 
Instance details

Defined in Language.C.Syntax

data CaptureListEntry #

Instances
Eq CaptureListEntry # 
Instance details

Defined in Language.C.Syntax

Data CaptureListEntry # 
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 #

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

toConstr :: CaptureListEntry -> Constr #

dataTypeOf :: CaptureListEntry -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord CaptureListEntry # 
Instance details

Defined in Language.C.Syntax

Show CaptureListEntry # 
Instance details

Defined in Language.C.Syntax

Pretty CaptureListEntry # 
Instance details

Defined in Language.C.Pretty

data ExeConfig #

Instances
Eq ExeConfig # 
Instance details

Defined in Language.C.Syntax

Data ExeConfig # 
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 #

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

toConstr :: ExeConfig -> Constr #

dataTypeOf :: ExeConfig -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord ExeConfig # 
Instance details

Defined in Language.C.Syntax

Show ExeConfig # 
Instance details

Defined in Language.C.Syntax

Located ExeConfig # 
Instance details

Defined in Language.C.Syntax

Methods

locOf :: ExeConfig -> Loc #

locOfList :: [ExeConfig] -> Loc #

Relocatable ExeConfig # 
Instance details

Defined in Language.C.Syntax

Methods

reloc :: Loc -> ExeConfig -> ExeConfig #

ctypedef :: Id -> Decl -> [Attr] -> Typedef #