Language.C.Syntax.AST

language-c-0.5.0: Analysis and generation of C code

Copyright | (c) [1999..2007] Manuel M T Chakravarty (c) 2008 Benedikt Huber
License | BSD-style
Maintainer | benedikt.huber@gmail.com
Stability | experimental
Portability | ghc
Safe Haskell | None
Language | Haskell98

Language.C.Syntax.AST

Contents

- C translation units
- Declarations
- Declaration attributes
- Declarators
- Initialization
- Statements
- Expressions
- Constants
- Annoated type class

Description

Abstract syntax of C source and header files.

The tree structure is based on the grammar in Appendix A of K&R. The abstract syntax simplifies the concrete syntax by merging similar concrete constructs into a single type of abstract tree structure: declarations are merged with structure declarations, parameter declarations and type names, and declarators are merged with abstract declarators.

With K&R we refer to ``The C Programming Language'', second edition, Brain W. Kernighan and Dennis M. Ritchie, Prentice Hall, 1988. The AST supports all of C99 http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf and several GNU extensions http://gcc.gnu.org/onlinedocs/gcc/C-Extensions.html.

Synopsis

- type CTranslUnit = CTranslationUnit NodeInfo
- type CExtDecl = CExternalDeclaration NodeInfo
- data CTranslationUnit a = CTranslUnit [CExternalDeclaration a] a
- data CExternalDeclaration a
  - = CDeclExt (CDeclaration a)
  - | CFDefExt (CFunctionDef a)
  - | CAsmExt (CStringLiteral a) a
- type CFunDef = CFunctionDef NodeInfo
- type CDecl = CDeclaration NodeInfo
- type CStructUnion = CStructureUnion NodeInfo
- type CEnum = CEnumeration NodeInfo
- data CFunctionDef a = CFunDef [CDeclarationSpecifier a] (CDeclarator a) [CDeclaration a] (CStatement a) a
- data CDeclaration a = CDecl [CDeclarationSpecifier a] [(Maybe (CDeclarator a), Maybe (CInitializer a), Maybe (CExpression a))] a
- data CStructTag
  - = CStructTag
  - | CUnionTag
- data CStructureUnion a = CStruct CStructTag (Maybe Ident) (Maybe [CDeclaration a]) [CAttribute a] a
- data CEnumeration a = CEnum (Maybe Ident) (Maybe [(Ident, Maybe (CExpression a))]) [CAttribute a] a
- type CDeclSpec = CDeclarationSpecifier NodeInfo
- partitionDeclSpecs :: [CDeclarationSpecifier a] -> ([CStorageSpecifier a], [CAttribute a], [CTypeQualifier a], [CTypeSpecifier a], Bool)
- type CStorageSpec = CStorageSpecifier NodeInfo
- type CTypeSpec = CTypeSpecifier NodeInfo
- isSUEDef :: CTypeSpecifier a -> Bool
- type CTypeQual = CTypeQualifier NodeInfo
- type CAttr = CAttribute NodeInfo
- data CDeclarationSpecifier a
  - = CStorageSpec (CStorageSpecifier a)
  - | CTypeSpec (CTypeSpecifier a)
  - | CTypeQual (CTypeQualifier a)
- data CStorageSpecifier a
  - = CAuto a
  - | CRegister a
  - | CStatic a
  - | CExtern a
  - | CTypedef a
  - | CThread a
- data CTypeSpecifier a
  - = CVoidType a
  - | CCharType a
  - | CShortType a
  - | CIntType a
  - | CLongType a
  - | CFloatType a
  - | CDoubleType a
  - | CSignedType a
  - | CUnsigType a
  - | CBoolType a
  - | CComplexType a
  - | CInt128Type a
  - | CSUType (CStructureUnion a) a
  - | CEnumType (CEnumeration a) a
  - | CTypeDef Ident a
  - | CTypeOfExpr (CExpression a) a
  - | CTypeOfType (CDeclaration a) a
- data CTypeQualifier a
  - = CConstQual a
  - | CVolatQual a
  - | CRestrQual a
  - | CInlineQual a
  - | CAttrQual (CAttribute a)
- data CAttribute a = CAttr Ident [CExpression a] a
- type CDeclr = CDeclarator NodeInfo
- type CDerivedDeclr = CDerivedDeclarator NodeInfo
- type CArrSize = CArraySize NodeInfo
- data CDeclarator a = CDeclr (Maybe Ident) [CDerivedDeclarator a] (Maybe (CStringLiteral a)) [CAttribute a] a
- data CDerivedDeclarator a
  - = CPtrDeclr [CTypeQualifier a] a
  - | CArrDeclr [CTypeQualifier a] (CArraySize a) a
  - | CFunDeclr (Either [Ident] ([CDeclaration a], Bool)) [CAttribute a] a
- data CArraySize a
  - = CNoArrSize Bool
  - | CArrSize Bool (CExpression a)
- type CInit = CInitializer NodeInfo
- type CInitList = CInitializerList NodeInfo
- type CDesignator = CPartDesignator NodeInfo
- data CInitializer a
  - = CInitExpr (CExpression a) a
  - | CInitList (CInitializerList a) a
- type CInitializerList a = [([CPartDesignator a], CInitializer a)]
- data CPartDesignator a
  - = CArrDesig (CExpression a) a
  - | CMemberDesig Ident a
  - | CRangeDesig (CExpression a) (CExpression a) a
- type CStat = CStatement NodeInfo
- type CBlockItem = CCompoundBlockItem NodeInfo
- type CAsmStmt = CAssemblyStatement NodeInfo
- type CAsmOperand = CAssemblyOperand NodeInfo
- data CStatement a
  - = CLabel Ident (CStatement a) [CAttribute a] a
  - | CCase (CExpression a) (CStatement a) a
  - | CCases (CExpression a) (CExpression a) (CStatement a) a
  - | CDefault (CStatement a) a
  - | CExpr (Maybe (CExpression a)) a
  - | CCompound [Ident] [CCompoundBlockItem a] a
  - | CIf (CExpression a) (CStatement a) (Maybe (CStatement a)) a
  - | CSwitch (CExpression a) (CStatement a) a
  - | CWhile (CExpression a) (CStatement a) Bool a
  - | CFor (Either (Maybe (CExpression a)) (CDeclaration a)) (Maybe (CExpression a)) (Maybe (CExpression a)) (CStatement a) a
  - | CGoto Ident a
  - | CGotoPtr (CExpression a) a
  - | CCont a
  - | CBreak a
  - | CReturn (Maybe (CExpression a)) a
  - | CAsm (CAssemblyStatement a) a
- data CCompoundBlockItem a
  - = CBlockStmt (CStatement a)
  - | CBlockDecl (CDeclaration a)
  - | CNestedFunDef (CFunctionDef a)
- data CAssemblyStatement a = CAsmStmt (Maybe (CTypeQualifier a)) (CStringLiteral a) [CAssemblyOperand a] [CAssemblyOperand a] [CStringLiteral a] a
- data CAssemblyOperand a = CAsmOperand (Maybe Ident) (CStringLiteral a) (CExpression a) a
- type CExpr = CExpression NodeInfo
- data CExpression a
  - = CComma [CExpression a] a
  - | CAssign CAssignOp (CExpression a) (CExpression a) a
  - | CCond (CExpression a) (Maybe (CExpression a)) (CExpression a) a
  - | CBinary CBinaryOp (CExpression a) (CExpression a) a
  - | CCast (CDeclaration a) (CExpression a) a
  - | CUnary CUnaryOp (CExpression a) a
  - | CSizeofExpr (CExpression a) a
  - | CSizeofType (CDeclaration a) a
  - | CAlignofExpr (CExpression a) a
  - | CAlignofType (CDeclaration a) a
  - | CComplexReal (CExpression a) a
  - | CComplexImag (CExpression a) a
  - | CIndex (CExpression a) (CExpression a) a
  - | CCall (CExpression a) [CExpression a] a
  - | CMember (CExpression a) Ident Bool a
  - | CVar Ident a
  - | CConst (CConstant a)
  - | CCompoundLit (CDeclaration a) (CInitializerList a) a
  - | CStatExpr (CStatement a) a
  - | CLabAddrExpr Ident a
  - | CBuiltinExpr (CBuiltinThing a)
- data CAssignOp
  - = CAssignOp
  - | CMulAssOp
  - | CDivAssOp
  - | CRmdAssOp
  - | CAddAssOp
  - | CSubAssOp
  - | CShlAssOp
  - | CShrAssOp
  - | CAndAssOp
  - | CXorAssOp
  - | COrAssOp
- data CBinaryOp
  - = CMulOp
  - | CDivOp
  - | CRmdOp
  - | CAddOp
  - | CSubOp
  - | CShlOp
  - | CShrOp
  - | CLeOp
  - | CGrOp
  - | CLeqOp
  - | CGeqOp
  - | CEqOp
  - | CNeqOp
  - | CAndOp
  - | CXorOp
  - | COrOp
  - | CLndOp
  - | CLorOp
- data CUnaryOp
  - = CPreIncOp
  - | CPreDecOp
  - | CPostIncOp
  - | CPostDecOp
  - | CAdrOp
  - | CIndOp
  - | CPlusOp
  - | CMinOp
  - | CCompOp
  - | CNegOp
- type CBuiltin = CBuiltinThing NodeInfo
- data CBuiltinThing a
  - = CBuiltinVaArg (CExpression a) (CDeclaration a) a
  - | CBuiltinOffsetOf (CDeclaration a) [CPartDesignator a] a
  - | CBuiltinTypesCompatible (CDeclaration a) (CDeclaration a) a
- type CConst = CConstant NodeInfo
- type CStrLit = CStringLiteral NodeInfo
- cstringOfLit :: CStringLiteral a -> CString
- liftStrLit :: CStringLiteral a -> CConstant a
- data CConstant a
  - = CIntConst CInteger a
  - | CCharConst CChar a
  - | CFloatConst CFloat a
  - | CStrConst CString a
- data CStringLiteral a = CStrLit CString a
- class Functor ast => Annotated ast where

# C translation units

type CTranslUnit = CTranslationUnit NodeInfo #

Complete C tranlsation unit (C99 6.9, K&R A10)

A complete C translation unit, for example representing a C header or source file. It consists of a list of external (i.e. toplevel) declarations.

type CExtDecl = CExternalDeclaration NodeInfo #

External C declaration (C99 6.9, K&R A10)

Either a toplevel declaration, function definition or external assembler.

data CTranslationUnit a #

Constructors

CTranslUnit [CExternalDeclaration a] a |

Instances

Functor CTranslationUnit # |
Methods fmap :: (a -> b) -> CTranslationUnit a -> CTranslationUnit b # (<$) :: a -> CTranslationUnit b -> CTranslationUnit a #
Annotated CTranslationUnit # |
Methods annotation :: CTranslationUnit a -> a # amap :: (a -> a) -> CTranslationUnit a -> CTranslationUnit a #
Pretty CTranslUnit # |
Methods pretty :: CTranslUnit -> Doc # prettyPrec :: Int -> CTranslUnit -> Doc #
Data a => Data (CTranslationUnit a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CTranslationUnit a -> c (CTranslationUnit a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CTranslationUnit a) # toConstr :: CTranslationUnit a -> Constr # dataTypeOf :: CTranslationUnit a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CTranslationUnit a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CTranslationUnit a)) # gmapT :: (forall b. Data b => b -> b) -> CTranslationUnit a -> CTranslationUnit a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CTranslationUnit a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CTranslationUnit a -> r # gmapQ :: (forall d. Data d => d -> u) -> CTranslationUnit a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CTranslationUnit a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CTranslationUnit a -> m (CTranslationUnit a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CTranslationUnit a -> m (CTranslationUnit a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CTranslationUnit a -> m (CTranslationUnit a) #
Show a => Show (CTranslationUnit a) # |
Methods showsPrec :: Int -> CTranslationUnit a -> ShowS # show :: CTranslationUnit a -> String # showList :: [CTranslationUnit a] -> ShowS #
CNode t1 => Pos (CTranslationUnit t1) # |
Methods posOf :: CTranslationUnit t1 -> Position #
CNode t1 => CNode (CTranslationUnit t1) # |
Methods nodeInfo :: CTranslationUnit t1 -> NodeInfo #

data CExternalDeclaration a #

Constructors

CDeclExt (CDeclaration a) |
CFDefExt (CFunctionDef a) |
CAsmExt (CStringLiteral a) a |

Instances

Functor CExternalDeclaration # |
Methods fmap :: (a -> b) -> CExternalDeclaration a -> CExternalDeclaration b # (<$) :: a -> CExternalDeclaration b -> CExternalDeclaration a #
Annotated CExternalDeclaration # |
Methods annotation :: CExternalDeclaration a -> a # amap :: (a -> a) -> CExternalDeclaration a -> CExternalDeclaration a #
Pretty CExtDecl # |
Methods pretty :: CExtDecl -> Doc # prettyPrec :: Int -> CExtDecl -> Doc #
Data a => Data (CExternalDeclaration a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CExternalDeclaration a -> c (CExternalDeclaration a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CExternalDeclaration a) # toConstr :: CExternalDeclaration a -> Constr # dataTypeOf :: CExternalDeclaration a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CExternalDeclaration a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CExternalDeclaration a)) # gmapT :: (forall b. Data b => b -> b) -> CExternalDeclaration a -> CExternalDeclaration a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CExternalDeclaration a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CExternalDeclaration a -> r # gmapQ :: (forall d. Data d => d -> u) -> CExternalDeclaration a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CExternalDeclaration a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CExternalDeclaration a -> m (CExternalDeclaration a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CExternalDeclaration a -> m (CExternalDeclaration a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CExternalDeclaration a -> m (CExternalDeclaration a) #
Show a => Show (CExternalDeclaration a) # |
Methods showsPrec :: Int -> CExternalDeclaration a -> ShowS # show :: CExternalDeclaration a -> String # showList :: [CExternalDeclaration a] -> ShowS #
CNode t1 => Pos (CExternalDeclaration t1) # |
Methods posOf :: CExternalDeclaration t1 -> Position #
CNode t1 => CNode (CExternalDeclaration t1) # |
Methods nodeInfo :: CExternalDeclaration t1 -> NodeInfo #

# Declarations

type CFunDef = CFunctionDef NodeInfo #

C function definition (C99 6.9.1, K&R A10.1)

A function definition is of the form `CFunDef specifiers declarator decllist? stmt`.

- `specifiers` are the type and storage-class specifiers of the function. The only storage-class specifiers allowed are extern and static.
- The `declarator` must be such that the declared identifier has function type. The return type shall be void or an object type other than array type.
- The optional declaration list `decllist` is for old-style function declarations.
- The statement `stmt` is a compound statement.

type CDecl = CDeclaration NodeInfo #

C declarations (K&R A8, C99 6.7), including structure declarations, parameter declarations and type names.

A declaration is of the form `CDecl specifiers init-declarator-list`, where the form of the declarator list's elements depends on the kind of declaration:

1) Toplevel declarations (K&R A8, C99 6.7 declaration)

- C99 requires that there is at least one specifier, though this is merely a syntactic restriction
- at most one storage class specifier is allowed per declaration
- the elements of the non-empty `init-declarator-list` are of the form `(Just declr, init?, Nothing)`. The declarator `declr` has to be present and non-abstract and the initialization expression is optional.

2) Structure declarations (K&R A8.3, C99 6.7.2.1 struct-declaration)

Those are the declarations of a structure's members.

- do not allow storage specifiers
- in strict C99, the list of declarators has to be non-empty
- the elements of `init-declarator-list` are either of the form `(Just declr, Nothing, size?)`, representing a member with optional bit-field size, or of the form `(Nothing, Nothing, Just size)`, for unnamed bitfields. `declr` has to be non-abstract.
- no member of a structure shall have incomplete type

3) Parameter declarations (K&R A8.6.3, C99 6.7.5 parameter-declaration)

- `init-declarator-list` must contain at most one triple of the form `(Just declr, Nothing, Nothing)`, i.e. consist of a single declarator, which is allowed to be abstract (i.e. unnamed).

4) Type names (A8.8, C99 6.7.6)

- do not allow storage specifiers
- `init-declarator-list` must contain at most one triple of the form `(Just declr, Nothing, Nothing)`. where `declr` is an abstract declarator (i.e. doesn't contain a declared identifier)

type CStructUnion = CStructureUnion NodeInfo #

C structure or union specifiers (K&R A8.3, C99 6.7.2.1)

`CStruct tag identifier struct-decls c-attrs` represents a struct or union specifier (depending on `tag`).

- either `identifier` or the declaration list `struct-decls` (or both) have to be present.

Example: in `struct foo x;`, the identifier is present, in `struct { int y; } x` the declaration list, and in `struct foo { int y; } x;` both of them.

- `c-attrs` is a list of `attribute` annotations associated with the struct or union specifier

type CEnum = CEnumeration NodeInfo #

C enumeration specifier (K&R A8.4, C99 6.7.2.2)

`CEnum identifier enumerator-list attrs` represent as enum specifier

- Either the identifier or the enumerator-list (or both) have to be present.
- If `enumerator-list` is present, it has to be non-empty.
- The enumerator list is of the form `(enumeration-constant, enumeration-value?)`, where the latter is an optional constant integral expression.
- `attrs` is a list of `attribute` annotations associated with the enumeration specifier

data CFunctionDef a #

Constructors

CFunDef [CDeclarationSpecifier a] (CDeclarator a) [CDeclaration a] (CStatement a) a |

Instances

Functor CFunctionDef # |
Methods fmap :: (a -> b) -> CFunctionDef a -> CFunctionDef b # (<$) :: a -> CFunctionDef b -> CFunctionDef a #
Annotated CFunctionDef # |
Methods annotation :: CFunctionDef a -> a # amap :: (a -> a) -> CFunctionDef a -> CFunctionDef a #
Pretty CFunDef # |
Methods pretty :: CFunDef -> Doc # prettyPrec :: Int -> CFunDef -> Doc #
Data a => Data (CFunctionDef a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CFunctionDef a -> c (CFunctionDef a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CFunctionDef a) # toConstr :: CFunctionDef a -> Constr # dataTypeOf :: CFunctionDef a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CFunctionDef a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CFunctionDef a)) # gmapT :: (forall b. Data b => b -> b) -> CFunctionDef a -> CFunctionDef a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CFunctionDef a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CFunctionDef a -> r # gmapQ :: (forall d. Data d => d -> u) -> CFunctionDef a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CFunctionDef a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CFunctionDef a -> m (CFunctionDef a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CFunctionDef a -> m (CFunctionDef a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CFunctionDef a -> m (CFunctionDef a) #
Show a => Show (CFunctionDef a) # |
Methods showsPrec :: Int -> CFunctionDef a -> ShowS # show :: CFunctionDef a -> String # showList :: [CFunctionDef a] -> ShowS #
CNode t1 => Pos (CFunctionDef t1) # |
Methods posOf :: CFunctionDef t1 -> Position #
CNode t1 => CNode (CFunctionDef t1) # |
Methods nodeInfo :: CFunctionDef t1 -> NodeInfo #

data CDeclaration a #

Constructors

CDecl [CDeclarationSpecifier a] [(Maybe (CDeclarator a), Maybe (CInitializer a), Maybe (CExpression a))] a |

Instances

Functor CDeclaration # |
Methods fmap :: (a -> b) -> CDeclaration a -> CDeclaration b # (<$) :: a -> CDeclaration b -> CDeclaration a #
Annotated CDeclaration # |
Methods annotation :: CDeclaration a -> a # amap :: (a -> a) -> CDeclaration a -> CDeclaration a #
Pretty CDecl # |
Methods pretty :: CDecl -> Doc # prettyPrec :: Int -> CDecl -> Doc #
Data a => Data (CDeclaration a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CDeclaration a -> c (CDeclaration a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CDeclaration a) # toConstr :: CDeclaration a -> Constr # dataTypeOf :: CDeclaration a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CDeclaration a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CDeclaration a)) # gmapT :: (forall b. Data b => b -> b) -> CDeclaration a -> CDeclaration a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CDeclaration a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CDeclaration a -> r # gmapQ :: (forall d. Data d => d -> u) -> CDeclaration a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CDeclaration a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CDeclaration a -> m (CDeclaration a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CDeclaration a -> m (CDeclaration a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CDeclaration a -> m (CDeclaration a) #
Show a => Show (CDeclaration a) # |
Methods showsPrec :: Int -> CDeclaration a -> ShowS # show :: CDeclaration a -> String # showList :: [CDeclaration a] -> ShowS #
CNode t1 => Pos (CDeclaration t1) # |
Methods posOf :: CDeclaration t1 -> Position #
CNode t1 => CNode (CDeclaration t1) # |
Methods nodeInfo :: CDeclaration t1 -> NodeInfo #

data CStructTag #

A tag to determine wheter we refer to a `struct` or `union`, see `CStructUnion`.

Constructors

CStructTag |
CUnionTag |

Instances

Eq CStructTag # |
Methods (==) :: CStructTag -> CStructTag -> Bool # (/=) :: CStructTag -> CStructTag -> Bool #
Data CStructTag # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CStructTag -> c CStructTag # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CStructTag # toConstr :: CStructTag -> Constr # dataTypeOf :: CStructTag -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c CStructTag) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CStructTag) # gmapT :: (forall b. Data b => b -> b) -> CStructTag -> CStructTag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CStructTag -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CStructTag -> r # gmapQ :: (forall d. Data d => d -> u) -> CStructTag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CStructTag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CStructTag -> m CStructTag # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CStructTag -> m CStructTag # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CStructTag -> m CStructTag #
Show CStructTag # |
Methods showsPrec :: Int -> CStructTag -> ShowS # show :: CStructTag -> String # showList :: [CStructTag] -> ShowS #
Pretty CStructTag # |
Methods pretty :: CStructTag -> Doc # prettyPrec :: Int -> CStructTag -> Doc #

data CStructureUnion a #

Constructors

CStruct CStructTag (Maybe Ident) (Maybe [CDeclaration a]) [CAttribute a] a |

Instances

Functor CStructureUnion # |
Methods fmap :: (a -> b) -> CStructureUnion a -> CStructureUnion b # (<$) :: a -> CStructureUnion b -> CStructureUnion a #
Annotated CStructureUnion # |
Methods annotation :: CStructureUnion a -> a # amap :: (a -> a) -> CStructureUnion a -> CStructureUnion a #
Pretty CStructUnion # |
Methods pretty :: CStructUnion -> Doc # prettyPrec :: Int -> CStructUnion -> Doc #
Data a => Data (CStructureUnion a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CStructureUnion a -> c (CStructureUnion a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CStructureUnion a) # toConstr :: CStructureUnion a -> Constr # dataTypeOf :: CStructureUnion a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CStructureUnion a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CStructureUnion a)) # gmapT :: (forall b. Data b => b -> b) -> CStructureUnion a -> CStructureUnion a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CStructureUnion a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CStructureUnion a -> r # gmapQ :: (forall d. Data d => d -> u) -> CStructureUnion a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CStructureUnion a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CStructureUnion a -> m (CStructureUnion a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CStructureUnion a -> m (CStructureUnion a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CStructureUnion a -> m (CStructureUnion a) #
Show a => Show (CStructureUnion a) # |
Methods showsPrec :: Int -> CStructureUnion a -> ShowS # show :: CStructureUnion a -> String # showList :: [CStructureUnion a] -> ShowS #
CNode t1 => Pos (CStructureUnion t1) # |
Methods posOf :: CStructureUnion t1 -> Position #
CNode t1 => CNode (CStructureUnion t1) # |
Methods nodeInfo :: CStructureUnion t1 -> NodeInfo #

data CEnumeration a #

Constructors

CEnum (Maybe Ident) (Maybe [(Ident, Maybe (CExpression a))]) [CAttribute a] a |

Instances

Functor CEnumeration # |
Methods fmap :: (a -> b) -> CEnumeration a -> CEnumeration b # (<$) :: a -> CEnumeration b -> CEnumeration a #
Annotated CEnumeration # |
Methods annotation :: CEnumeration a -> a # amap :: (a -> a) -> CEnumeration a -> CEnumeration a #
Pretty CEnum # |
Methods pretty :: CEnum -> Doc # prettyPrec :: Int -> CEnum -> Doc #
Data a => Data (CEnumeration a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CEnumeration a -> c (CEnumeration a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CEnumeration a) # toConstr :: CEnumeration a -> Constr # dataTypeOf :: CEnumeration a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CEnumeration a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CEnumeration a)) # gmapT :: (forall b. Data b => b -> b) -> CEnumeration a -> CEnumeration a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CEnumeration a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CEnumeration a -> r # gmapQ :: (forall d. Data d => d -> u) -> CEnumeration a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CEnumeration a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CEnumeration a -> m (CEnumeration a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CEnumeration a -> m (CEnumeration a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CEnumeration a -> m (CEnumeration a) #
Show a => Show (CEnumeration a) # |
Methods showsPrec :: Int -> CEnumeration a -> ShowS # show :: CEnumeration a -> String # showList :: [CEnumeration a] -> ShowS #
CNode t1 => Pos (CEnumeration t1) # |
Methods posOf :: CEnumeration t1 -> Position #
CNode t1 => CNode (CEnumeration t1) # |
Methods nodeInfo :: CEnumeration t1 -> NodeInfo #

# Declaration attributes

type CDeclSpec = CDeclarationSpecifier NodeInfo #

C declaration specifiers and qualifiers

Declaration specifiers include at most one storage-class specifier (C99 6.7.1), type specifiers (6.7.2) and type qualifiers (6.7.3).

partitionDeclSpecs :: [CDeclarationSpecifier a] -> ([CStorageSpecifier a], [CAttribute a], [CTypeQualifier a], [CTypeSpecifier a], Bool) #

Separate the declaration specifiers

Note that inline isn't actually a type qualifier, but a function specifier. `attribute` of a declaration qualify declarations or declarators (but not types), and are therefore separated as well.

type CStorageSpec = CStorageSpecifier NodeInfo #

C storage class specifier (and typedefs) (K&R A8.1, C99 6.7.1)

type CTypeSpec = CTypeSpecifier NodeInfo #

C type specifier (K&R A8.2, C99 6.7.2)

Type specifiers are either basic types such as `char` or `int`, `struct`, `union` or `enum` specifiers or typedef names.

As a GNU extension, a `typeof` expression also is a type specifier.

isSUEDef :: CTypeSpecifier a -> Bool #

returns `True` if the given typespec is a struct, union or enum definition

type CTypeQual = CTypeQualifier NodeInfo #

C type qualifiers (K&R A8.2, C99 6.7.3), function specifiers (C99 6.7.4), and attributes.

`const`, `volatile` and `restrict` type qualifiers and `inline` function specifier. Additionally, `attribute` annotations for declarations and declarators.

type CAttr = CAttribute NodeInfo #

`attribute` annotations

Those are of the form `CAttr attribute-name attribute-parameters`, and serve as generic properties of some syntax tree elements.

data CDeclarationSpecifier a #

Constructors

CStorageSpec (CStorageSpecifier a) | storage-class specifier or typedef
CTypeSpec (CTypeSpecifier a) | type name
CTypeQual (CTypeQualifier a) | type qualifier

Instances

Functor CDeclarationSpecifier # |
Methods fmap :: (a -> b) -> CDeclarationSpecifier a -> CDeclarationSpecifier b # (<$) :: a -> CDeclarationSpecifier b -> CDeclarationSpecifier a #
Annotated CDeclarationSpecifier # |
Methods annotation :: CDeclarationSpecifier a -> a # amap :: (a -> a) -> CDeclarationSpecifier a -> CDeclarationSpecifier a #
Pretty CDeclSpec # |
Methods pretty :: CDeclSpec -> Doc # prettyPrec :: Int -> CDeclSpec -> Doc #
Data a => Data (CDeclarationSpecifier a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CDeclarationSpecifier a -> c (CDeclarationSpecifier a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CDeclarationSpecifier a) # toConstr :: CDeclarationSpecifier a -> Constr # dataTypeOf :: CDeclarationSpecifier a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CDeclarationSpecifier a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CDeclarationSpecifier a)) # gmapT :: (forall b. Data b => b -> b) -> CDeclarationSpecifier a -> CDeclarationSpecifier a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CDeclarationSpecifier a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CDeclarationSpecifier a -> r # gmapQ :: (forall d. Data d => d -> u) -> CDeclarationSpecifier a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CDeclarationSpecifier a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CDeclarationSpecifier a -> m (CDeclarationSpecifier a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CDeclarationSpecifier a -> m (CDeclarationSpecifier a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CDeclarationSpecifier a -> m (CDeclarationSpecifier a) #
Show a => Show (CDeclarationSpecifier a) # |
Methods showsPrec :: Int -> CDeclarationSpecifier a -> ShowS # show :: CDeclarationSpecifier a -> String # showList :: [CDeclarationSpecifier a] -> ShowS #
CNode t1 => Pos (CDeclarationSpecifier t1) # |
Methods posOf :: CDeclarationSpecifier t1 -> Position #
CNode t1 => CNode (CDeclarationSpecifier t1) # |
Methods nodeInfo :: CDeclarationSpecifier t1 -> NodeInfo #

data CStorageSpecifier a #

Constructors

CAuto a | auto
CRegister a | register
CStatic a | static
CExtern a | extern
CTypedef a | typedef
CThread a | GNUC thread local storage

Instances

Functor CStorageSpecifier # |
Methods fmap :: (a -> b) -> CStorageSpecifier a -> CStorageSpecifier b # (<$) :: a -> CStorageSpecifier b -> CStorageSpecifier a #
Annotated CStorageSpecifier # |
Methods annotation :: CStorageSpecifier a -> a # amap :: (a -> a) -> CStorageSpecifier a -> CStorageSpecifier a #
Pretty CStorageSpec # |
Methods pretty :: CStorageSpec -> Doc # prettyPrec :: Int -> CStorageSpec -> Doc #
Eq a => Eq (CStorageSpecifier a) # |
Methods (==) :: CStorageSpecifier a -> CStorageSpecifier a -> Bool # (/=) :: CStorageSpecifier a -> CStorageSpecifier a -> Bool #
Data a => Data (CStorageSpecifier a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CStorageSpecifier a -> c (CStorageSpecifier a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CStorageSpecifier a) # toConstr :: CStorageSpecifier a -> Constr # dataTypeOf :: CStorageSpecifier a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CStorageSpecifier a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CStorageSpecifier a)) # gmapT :: (forall b. Data b => b -> b) -> CStorageSpecifier a -> CStorageSpecifier a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CStorageSpecifier a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CStorageSpecifier a -> r # gmapQ :: (forall d. Data d => d -> u) -> CStorageSpecifier a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CStorageSpecifier a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CStorageSpecifier a -> m (CStorageSpecifier a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CStorageSpecifier a -> m (CStorageSpecifier a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CStorageSpecifier a -> m (CStorageSpecifier a) #
Ord a => Ord (CStorageSpecifier a) # |
Methods compare :: CStorageSpecifier a -> CStorageSpecifier a -> Ordering # (<) :: CStorageSpecifier a -> CStorageSpecifier a -> Bool # (<=) :: CStorageSpecifier a -> CStorageSpecifier a -> Bool # (>) :: CStorageSpecifier a -> CStorageSpecifier a -> Bool # (>=) :: CStorageSpecifier a -> CStorageSpecifier a -> Bool # max :: CStorageSpecifier a -> CStorageSpecifier a -> CStorageSpecifier a # min :: CStorageSpecifier a -> CStorageSpecifier a -> CStorageSpecifier a #
Show a => Show (CStorageSpecifier a) # |
Methods showsPrec :: Int -> CStorageSpecifier a -> ShowS # show :: CStorageSpecifier a -> String # showList :: [CStorageSpecifier a] -> ShowS #
CNode t1 => Pos (CStorageSpecifier t1) # |
Methods posOf :: CStorageSpecifier t1 -> Position #
CNode t1 => CNode (CStorageSpecifier t1) # |
Methods nodeInfo :: CStorageSpecifier t1 -> NodeInfo #

data CTypeSpecifier a #

Constructors

CVoidType a |
CCharType a |
CShortType a |
CIntType a |
CLongType a |
CFloatType a |
CDoubleType a |
CSignedType a |
CUnsigType a |
CBoolType a |
CComplexType a |
CInt128Type a |
CSUType (CStructureUnion a) a | Struct or Union specifier
CEnumType (CEnumeration a) a | Enumeration specifier
CTypeDef Ident a | Typedef name
CTypeOfExpr (CExpression a) a |
    typeof(expr)
CTypeOfType (CDeclaration a) a |
    typeof(type)

Instances

Functor CTypeSpecifier # |
Methods fmap :: (a -> b) -> CTypeSpecifier a -> CTypeSpecifier b # (<$) :: a -> CTypeSpecifier b -> CTypeSpecifier a #
Annotated CTypeSpecifier # |
Methods annotation :: CTypeSpecifier a -> a # amap :: (a -> a) -> CTypeSpecifier a -> CTypeSpecifier a #
Pretty CTypeSpec # |
Methods pretty :: CTypeSpec -> Doc # prettyPrec :: Int -> CTypeSpec -> Doc #
Data a => Data (CTypeSpecifier a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CTypeSpecifier a -> c (CTypeSpecifier a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CTypeSpecifier a) # toConstr :: CTypeSpecifier a -> Constr # dataTypeOf :: CTypeSpecifier a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CTypeSpecifier a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CTypeSpecifier a)) # gmapT :: (forall b. Data b => b -> b) -> CTypeSpecifier a -> CTypeSpecifier a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CTypeSpecifier a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CTypeSpecifier a -> r # gmapQ :: (forall d. Data d => d -> u) -> CTypeSpecifier a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CTypeSpecifier a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CTypeSpecifier a -> m (CTypeSpecifier a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CTypeSpecifier a -> m (CTypeSpecifier a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CTypeSpecifier a -> m (CTypeSpecifier a) #
Show a => Show (CTypeSpecifier a) # |
Methods showsPrec :: Int -> CTypeSpecifier a -> ShowS # show :: CTypeSpecifier a -> String # showList :: [CTypeSpecifier a] -> ShowS #
CNode t1 => Pos (CTypeSpecifier t1) # |
Methods posOf :: CTypeSpecifier t1 -> Position #
CNode t1 => CNode (CTypeSpecifier t1) # |
Methods nodeInfo :: CTypeSpecifier t1 -> NodeInfo #

data CTypeQualifier a #

Constructors

CConstQual a |
CVolatQual a |
CRestrQual a |
CInlineQual a |
CAttrQual (CAttribute a) |

Instances

Functor CTypeQualifier # |
Methods fmap :: (a -> b) -> CTypeQualifier a -> CTypeQualifier b # (<$) :: a -> CTypeQualifier b -> CTypeQualifier a #
Annotated CTypeQualifier # |
Methods annotation :: CTypeQualifier a -> a # amap :: (a -> a) -> CTypeQualifier a -> CTypeQualifier a #
Pretty CTypeQual # |
Methods pretty :: CTypeQual -> Doc # prettyPrec :: Int -> CTypeQual -> Doc #
Data a => Data (CTypeQualifier a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CTypeQualifier a -> c (CTypeQualifier a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CTypeQualifier a) # toConstr :: CTypeQualifier a -> Constr # dataTypeOf :: CTypeQualifier a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CTypeQualifier a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CTypeQualifier a)) # gmapT :: (forall b. Data b => b -> b) -> CTypeQualifier a -> CTypeQualifier a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CTypeQualifier a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CTypeQualifier a -> r # gmapQ :: (forall d. Data d => d -> u) -> CTypeQualifier a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CTypeQualifier a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CTypeQualifier a -> m (CTypeQualifier a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CTypeQualifier a -> m (CTypeQualifier a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CTypeQualifier a -> m (CTypeQualifier a) #
Show a => Show (CTypeQualifier a) # |
Methods showsPrec :: Int -> CTypeQualifier a -> ShowS # show :: CTypeQualifier a -> String # showList :: [CTypeQualifier a] -> ShowS #
CNode t1 => Pos (CTypeQualifier t1) # |
Methods posOf :: CTypeQualifier t1 -> Position #
CNode t1 => CNode (CTypeQualifier t1) # |
Methods nodeInfo :: CTypeQualifier t1 -> NodeInfo #

data CAttribute a #

Constructors

CAttr Ident [CExpression a] a |

Instances

Functor CAttribute # |
Methods fmap :: (a -> b) -> CAttribute a -> CAttribute b # (<$) :: a -> CAttribute b -> CAttribute a #
Annotated CAttribute # |
Methods annotation :: CAttribute a -> a # amap :: (a -> a) -> CAttribute a -> CAttribute a #
Pretty CAttr # |
Methods pretty :: CAttr -> Doc # prettyPrec :: Int -> CAttr -> Doc #
Data a => Data (CAttribute a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CAttribute a -> c (CAttribute a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CAttribute a) # toConstr :: CAttribute a -> Constr # dataTypeOf :: CAttribute a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CAttribute a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CAttribute a)) # gmapT :: (forall b. Data b => b -> b) -> CAttribute a -> CAttribute a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CAttribute a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CAttribute a -> r # gmapQ :: (forall d. Data d => d -> u) -> CAttribute a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CAttribute a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CAttribute a -> m (CAttribute a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CAttribute a -> m (CAttribute a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CAttribute a -> m (CAttribute a) #
Show a => Show (CAttribute a) # |
Methods showsPrec :: Int -> CAttribute a -> ShowS # show :: CAttribute a -> String # showList :: [CAttribute a] -> ShowS #
CNode t1 => Pos (CAttribute t1) # |
Methods posOf :: CAttribute t1 -> Position #
CNode t1 => CNode (CAttribute t1) # |
Methods nodeInfo :: CAttribute t1 -> NodeInfo #

# Declarators

type CDeclr = CDeclarator NodeInfo #

C declarator (K&R A8.5, C99 6.7.5) and abstract declarator (K&R A8.8, C99 6.7.6)

A declarator declares a single object, function, or type. It is always associated with a declaration (`CDecl`), which specifies the declaration's type and the additional storage qualifiers and attributes, which apply to the declared object.

A declarator is of the form `CDeclr name? indirections asm-name? attrs _`, where `name` is the name of the declared object (missing for abstract declarators), `declquals` is a set of additional declaration specifiers, `asm-name` is the optional assembler name and attributes is a set of attrs is a set of `attribute` annotations for the declared object.

`indirections` is a set of pointer, array and function declarators, which modify the type of the declared object as described below. If the declaration specifies the non-derived type `T`, and we have `indirections = [D1, D2, ..., Dn]` than the declared object has type `(D1 `indirect` (D2 `indirect` ... (Dn `indirect` T)))`, where

- `(CPtrDeclr attrs) `indirect` T` is attributed pointer to T
- `(CFunDeclr attrs) `indirect` T` is attributed function returning T
- `(CArrayDeclr attrs) `indirect` T` is attributed array of elemements of type T

Examples (simplified attributes):

- x is an int

    int x;
    CDeclr "x" []

- x is a restrict pointer to a const pointer to int

    const int * const * restrict x;
    CDeclr "x" [CPtrDeclr [restrict], CPtrDeclr [const]]

- f is an function return a constant pointer to int

    int* const f();
    CDeclr "f" [CFunDeclr [],CPtrDeclr [const]]

- f is a constant pointer to a function returning int

    int (* const f)(); ==>
    CDeclr "f" [CPtrDeclr [const], CFunDeclr []]

type CDerivedDeclr = CDerivedDeclarator NodeInfo #

Derived declarators, see `CDeclr`

Indirections are qualified using type-qualifiers and generic attributes, and additionally

- The size of an array is either a constant expression, variable length (`*`) or missing; in the last case, the type of the array is incomplete. The qualifier static is allowed for function arguments only, indicating that the supplied argument is an array of at least the given size.
- New style parameter lists have the form `Right (declarations, isVariadic)`, old style parameter lists have the form `Left (parameter-names)`

type CArrSize = CArraySize NodeInfo #

Size of an array

data CDeclarator a #

Constructors

CDeclr (Maybe Ident) [CDerivedDeclarator a] (Maybe (CStringLiteral a)) [CAttribute a] a |

Instances

Functor CDeclarator # |
Methods fmap :: (a -> b) -> CDeclarator a -> CDeclarator b # (<$) :: a -> CDeclarator b -> CDeclarator a #
Annotated CDeclarator # |
Methods annotation :: CDeclarator a -> a # amap :: (a -> a) -> CDeclarator a -> CDeclarator a #
Pretty CDeclr # |
Methods pretty :: CDeclr -> Doc # prettyPrec :: Int -> CDeclr -> Doc #
Data a => Data (CDeclarator a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CDeclarator a -> c (CDeclarator a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CDeclarator a) # toConstr :: CDeclarator a -> Constr # dataTypeOf :: CDeclarator a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CDeclarator a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CDeclarator a)) # gmapT :: (forall b. Data b => b -> b) -> CDeclarator a -> CDeclarator a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CDeclarator a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CDeclarator a -> r # gmapQ :: (forall d. Data d => d -> u) -> CDeclarator a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CDeclarator a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CDeclarator a -> m (CDeclarator a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CDeclarator a -> m (CDeclarator a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CDeclarator a -> m (CDeclarator a) #
Show a => Show (CDeclarator a) # |
Methods showsPrec :: Int -> CDeclarator a -> ShowS # show :: CDeclarator a -> String # showList :: [CDeclarator a] -> ShowS #
CNode t1 => Pos (CDeclarator t1) # |
Methods posOf :: CDeclarator t1 -> Position #
CNode t1 => CNode (CDeclarator t1) # |
Methods nodeInfo :: CDeclarator t1 -> NodeInfo #

data CDerivedDeclarator a #

Constructors

CPtrDeclr [CTypeQualifier a] a | Pointer declarator `CPtrDeclr tyquals declr`
CArrDeclr [CTypeQualifier a] (CArraySize a) a | Array declarator `CArrDeclr declr tyquals size-expr?`
CFunDeclr (Either [Ident] ([CDeclaration a], Bool)) [CAttribute a] a | Function declarator `CFunDeclr declr (old-style-params | new-style-params) c-attrs`

Instances

Functor CDerivedDeclarator # |
Methods fmap :: (a -> b) -> CDerivedDeclarator a -> CDerivedDeclarator b # (<$) :: a -> CDerivedDeclarator b -> CDerivedDeclarator a #
Annotated CDerivedDeclarator # |
Methods annotation :: CDerivedDeclarator a -> a # amap :: (a -> a) -> CDerivedDeclarator a -> CDerivedDeclarator a #
Data a => Data (CDerivedDeclarator a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CDerivedDeclarator a -> c (CDerivedDeclarator a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CDerivedDeclarator a) # toConstr :: CDerivedDeclarator a -> Constr # dataTypeOf :: CDerivedDeclarator a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CDerivedDeclarator a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CDerivedDeclarator a)) # gmapT :: (forall b. Data b => b -> b) -> CDerivedDeclarator a -> CDerivedDeclarator a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CDerivedDeclarator a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CDerivedDeclarator a -> r # gmapQ :: (forall d. Data d => d -> u) -> CDerivedDeclarator a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CDerivedDeclarator a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CDerivedDeclarator a -> m (CDerivedDeclarator a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CDerivedDeclarator a -> m (CDerivedDeclarator a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CDerivedDeclarator a -> m (CDerivedDeclarator a) #
Show a => Show (CDerivedDeclarator a) # |
Methods showsPrec :: Int -> CDerivedDeclarator a -> ShowS # show :: CDerivedDeclarator a -> String # showList :: [CDerivedDeclarator a] -> ShowS #
CNode t1 => Pos (CDerivedDeclarator t1) # |
Methods posOf :: CDerivedDeclarator t1 -> Position #
CNode t1 => CNode (CDerivedDeclarator t1) # |
Methods nodeInfo :: CDerivedDeclarator t1 -> NodeInfo #

data CArraySize a #

Constructors

CNoArrSize Bool |
    CUnknownSize isCompleteType
CArrSize Bool (CExpression a) |
    CArrSize isStatic expr

Instances

Functor CArraySize # |
Methods fmap :: (a -> b) -> CArraySize a -> CArraySize b # (<$) :: a -> CArraySize b -> CArraySize a #
Pretty CArrSize # |
Methods pretty :: CArrSize -> Doc # prettyPrec :: Int -> CArrSize -> Doc #
Data a => Data (CArraySize a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CArraySize a -> c (CArraySize a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CArraySize a) # toConstr :: CArraySize a -> Constr # dataTypeOf :: CArraySize a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CArraySize a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CArraySize a)) # gmapT :: (forall b. Data b => b -> b) -> CArraySize a -> CArraySize a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CArraySize a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CArraySize a -> r # gmapQ :: (forall d. Data d => d -> u) -> CArraySize a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CArraySize a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CArraySize a -> m (CArraySize a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CArraySize a -> m (CArraySize a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CArraySize a -> m (CArraySize a) #
Show a => Show (CArraySize a) # |
Methods showsPrec :: Int -> CArraySize a -> ShowS # show :: CArraySize a -> String # showList :: [CArraySize a] -> ShowS #

# Initialization

type CInit = CInitializer NodeInfo #

C initialization (K&R A8.7, C99 6.7.8)

Initializers are either assignment expressions or initializer lists (surrounded in curly braces), whose elements are themselves initializers, paired with an optional list of designators.

type CInitList = CInitializerList NodeInfo #

Initializer List

The members of an initializer list are of the form `(designator-list,initializer)`. The `designator-list` specifies one member of the compound type which is initialized. It is allowed to be empty - in this case the initializer refers to the '`next'` member of the compound type (see C99 6.7.8).

Examples (simplified expressions and identifiers):

    -- int x[3][4] = { [0][3] = 4, [2] = 5, 8 };
    --   corresponds to the assignments
    -- x[0][3] = 4; x[2][0] = 5; x[2][1] = 8;
    let init1 = ([CArrDesig 0, CArrDesig 3], CInitExpr 4)
        init2 = ([CArrDesig 2]             , CInitExpr 5)
        init3 = ([]                        , CInitExpr 8)
    in  CInitList [init1, init2, init3]

    -- struct { struct { int a[2]; int b[2]; int c[2]; } s; } x = { .s = { {2,3} , .c[0] = 1 } };
    --   corresponds to the assignments
    -- x.s.a[0] = 2; x.s.a[1] = 3; x.s.c[0] = 1;
    let init_s_0 = CInitList [ ([], CInitExpr 2), ([], CInitExpr 3)]
        init_s   = CInitList [
                               ([], init_s_0),
                               ([CMemberDesig "c", CArrDesig 0], CInitExpr 1)
                             ]
    in  CInitList [(CMemberDesig "s", init_s)]

type CDesignator = CPartDesignator NodeInfo #

Designators

A designator specifies a member of an object, either an element or range of an array, or the named member of a struct / union.

data CInitializer a #

Constructors

CInitExpr (CExpression a) a | assignment expression
CInitList (CInitializerList a) a | initialization list (see `CInitList`)

Instances

Functor CInitializer # |
Methods fmap :: (a -> b) -> CInitializer a -> CInitializer b # (<$) :: a -> CInitializer b -> CInitializer a #
Annotated CInitializer # |
Methods annotation :: CInitializer a -> a # amap :: (a -> a) -> CInitializer a -> CInitializer a #
Pretty CInit # |
Methods pretty :: CInit -> Doc # prettyPrec :: Int -> CInit -> Doc #
Data a => Data (CInitializer a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CInitializer a -> c (CInitializer a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CInitializer a) # toConstr :: CInitializer a -> Constr # dataTypeOf :: CInitializer a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CInitializer a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CInitializer a)) # gmapT :: (forall b. Data b => b -> b) -> CInitializer a -> CInitializer a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CInitializer a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CInitializer a -> r # gmapQ :: (forall d. Data d => d -> u) -> CInitializer a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CInitializer a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CInitializer a -> m (CInitializer a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CInitializer a -> m (CInitializer a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CInitializer a -> m (CInitializer a) #
Show a => Show (CInitializer a) # |
Methods showsPrec :: Int -> CInitializer a -> ShowS # show :: CInitializer a -> String # showList :: [CInitializer a] -> ShowS #
CNode t1 => Pos (CInitializer t1) # |
Methods posOf :: CInitializer t1 -> Position #
CNode t1 => CNode (CInitializer t1) # |
Methods nodeInfo :: CInitializer t1 -> NodeInfo #

type CInitializerList a = [([CPartDesignator a], CInitializer a)] #

data CPartDesignator a #

Constructors

CArrDesig (CExpression a) a | array position designator
CMemberDesig Ident a | member designator
CRangeDesig (CExpression a) (CExpression a) a | array range designator `CRangeDesig from to _` (GNU C)

Instances

Functor CPartDesignator # |
Methods fmap :: (a -> b) -> CPartDesignator a -> CPartDesignator b # (<$) :: a -> CPartDesignator b -> CPartDesignator a #
Annotated CPartDesignator # |
Methods annotation :: CPartDesignator a -> a # amap :: (a -> a) -> CPartDesignator a -> CPartDesignator a #
Pretty CDesignator # |
Methods pretty :: CDesignator -> Doc # prettyPrec :: Int -> CDesignator -> Doc #
Data a => Data (CPartDesignator a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CPartDesignator a -> c (CPartDesignator a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CPartDesignator a) # toConstr :: CPartDesignator a -> Constr # dataTypeOf :: CPartDesignator a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CPartDesignator a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CPartDesignator a)) # gmapT :: (forall b. Data b => b -> b) -> CPartDesignator a -> CPartDesignator a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CPartDesignator a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CPartDesignator a -> r # gmapQ :: (forall d. Data d => d -> u) -> CPartDesignator a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CPartDesignator a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CPartDesignator a -> m (CPartDesignator a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CPartDesignator a -> m (CPartDesignator a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CPartDesignator a -> m (CPartDesignator a) #
Show a => Show (CPartDesignator a) # |
Methods showsPrec :: Int -> CPartDesignator a -> ShowS # show :: CPartDesignator a -> String # showList :: [CPartDesignator a] -> ShowS #
CNode t1 => Pos (CPartDesignator t1) # |
Methods posOf :: CPartDesignator t1 -> Position #
CNode t1 => CNode (CPartDesignator t1) # |
Methods nodeInfo :: CPartDesignator t1 -> NodeInfo #

# Statements

type CStat = CStatement NodeInfo #

C statement (K&R A9, C99 6.8)

type CBlockItem = CCompoundBlockItem NodeInfo #

C99 Block items

Things that may appear in compound statements: either statements, declarations or nested function definitions.

type CAsmStmt = CAssemblyStatement NodeInfo #

GNU Assembler statement

    CAssemblyStatement type-qual? asm-expr out-ops in-ops clobbers _

is an inline assembler statement. The only type-qualifier (if any) allowed is volatile. `asm-expr` is the actual assembler epxression (a string), `out-ops` and `in-ops` are the input and output operands of the statement. `clobbers` is a list of registers which are clobbered when executing the assembler statement

type CAsmOperand = CAssemblyOperand NodeInfo #

Assembler operand

`CAsmOperand argName? constraintExpr arg` specifies an operand for an assembler statement.

data CStatement a #

Constructors

CLabel Ident (CStatement a) [CAttribute a] a | An (attributed) label followed by a statement
CCase (CExpression a) (CStatement a) a | A statement of the form `case expr : stmt`
CCases (CExpression a) (CExpression a) (CStatement a) a | A case range of the form `case lower ... upper : stmt`
CDefault (CStatement a) a | The default case `default : stmt`
CExpr (Maybe (CExpression a)) a | A simple statement, that is in C: evaluating an expression with side-effects and discarding the result.
CCompound [Ident] [CCompoundBlockItem a] a | compound statement `CCompound localLabels blockItems at`
CIf (CExpression a) (CStatement a) (Maybe (CStatement a)) a | conditional statement `CIf ifExpr thenStmt maybeElseStmt at`
CSwitch (CExpression a) (CStatement a) a | switch statement `CSwitch selectorExpr switchStmt`, where `switchStmt` usually includes case, break and default statements
CWhile (CExpression a) (CStatement a) Bool a | while or do-while statement `CWhile guard stmt isDoWhile at`
CFor (Either (Maybe (CExpression a)) (CDeclaration a)) (Maybe (CExpression a)) (Maybe (CExpression a)) (CStatement a) a | for statement `CFor init expr-2 expr-3 stmt`, where `init` is either a declaration or initializing expression
CGoto Ident a | goto statement `CGoto label`
CGotoPtr (CExpression a) a | computed goto `CGotoPtr labelExpr`
CCont a | continue statement
CBreak a | break statement
CReturn (Maybe (CExpression a)) a | return statement `CReturn returnExpr`
CAsm (CAssemblyStatement a) a | assembly statement

Instances

Functor CStatement # |
Methods fmap :: (a -> b) -> CStatement a -> CStatement b # (<$) :: a -> CStatement b -> CStatement a #
Annotated CStatement # |
Methods annotation :: CStatement a -> a # amap :: (a -> a) -> CStatement a -> CStatement a #
Pretty CStat # |
Methods pretty :: CStat -> Doc # prettyPrec :: Int -> CStat -> Doc #
Data a => Data (CStatement a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CStatement a -> c (CStatement a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CStatement a) # toConstr :: CStatement a -> Constr # dataTypeOf :: CStatement a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CStatement a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CStatement a)) # gmapT :: (forall b. Data b => b -> b) -> CStatement a -> CStatement a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CStatement a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CStatement a -> r # gmapQ :: (forall d. Data d => d -> u) -> CStatement a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CStatement a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CStatement a -> m (CStatement a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CStatement a -> m (CStatement a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CStatement a -> m (CStatement a) #
Show a => Show (CStatement a) # |
Methods showsPrec :: Int -> CStatement a -> ShowS # show :: CStatement a -> String # showList :: [CStatement a] -> ShowS #
CNode t1 => Pos (CStatement t1) # |
Methods posOf :: CStatement t1 -> Position #
CNode t1 => CNode (CStatement t1) # |
Methods nodeInfo :: CStatement t1 -> NodeInfo #

data CCompoundBlockItem a #

Constructors

CBlockStmt (CStatement a) | A statement
CBlockDecl (CDeclaration a) | A local declaration
CNestedFunDef (CFunctionDef a) | A nested function (GNU C)

Instances

Functor CCompoundBlockItem # |
Methods fmap :: (a -> b) -> CCompoundBlockItem a -> CCompoundBlockItem b # (<$) :: a -> CCompoundBlockItem b -> CCompoundBlockItem a #
Annotated CCompoundBlockItem # |
Methods annotation :: CCompoundBlockItem a -> a # amap :: (a -> a) -> CCompoundBlockItem a -> CCompoundBlockItem a #
Pretty CBlockItem # |
Methods pretty :: CBlockItem -> Doc # prettyPrec :: Int -> CBlockItem -> Doc #
Data a => Data (CCompoundBlockItem a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CCompoundBlockItem a -> c (CCompoundBlockItem a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CCompoundBlockItem a) # toConstr :: CCompoundBlockItem a -> Constr # dataTypeOf :: CCompoundBlockItem a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CCompoundBlockItem a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CCompoundBlockItem a)) # gmapT :: (forall b. Data b => b -> b) -> CCompoundBlockItem a -> CCompoundBlockItem a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CCompoundBlockItem a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CCompoundBlockItem a -> r # gmapQ :: (forall d. Data d => d -> u) -> CCompoundBlockItem a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CCompoundBlockItem a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CCompoundBlockItem a -> m (CCompoundBlockItem a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CCompoundBlockItem a -> m (CCompoundBlockItem a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CCompoundBlockItem a -> m (CCompoundBlockItem a) #
Show a => Show (CCompoundBlockItem a) # |
Methods showsPrec :: Int -> CCompoundBlockItem a -> ShowS # show :: CCompoundBlockItem a -> String # showList :: [CCompoundBlockItem a] -> ShowS #
CNode t1 => Pos (CCompoundBlockItem t1) # |
Methods posOf :: CCompoundBlockItem t1 -> Position #
CNode t1 => CNode (CCompoundBlockItem t1) # |
Methods nodeInfo :: CCompoundBlockItem t1 -> NodeInfo #

data CAssemblyStatement a #

Constructors

CAsmStmt (Maybe (CTypeQualifier a)) (CStringLiteral a) [CAssemblyOperand a] [CAssemblyOperand a] [CStringLiteral a] a |

Instances

Functor CAssemblyStatement # |
Methods fmap :: (a -> b) -> CAssemblyStatement a -> CAssemblyStatement b # (<$) :: a -> CAssemblyStatement b -> CAssemblyStatement a #
Annotated CAssemblyStatement # |
Methods annotation :: CAssemblyStatement a -> a # amap :: (a -> a) -> CAssemblyStatement a -> CAssemblyStatement a #
Pretty CAsmStmt # |
Methods pretty :: CAsmStmt -> Doc # prettyPrec :: Int -> CAsmStmt -> Doc #
Data a => Data (CAssemblyStatement a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CAssemblyStatement a -> c (CAssemblyStatement a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CAssemblyStatement a) # toConstr :: CAssemblyStatement a -> Constr # dataTypeOf :: CAssemblyStatement a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CAssemblyStatement a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CAssemblyStatement a)) # gmapT :: (forall b. Data b => b -> b) -> CAssemblyStatement a -> CAssemblyStatement a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CAssemblyStatement a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CAssemblyStatement a -> r # gmapQ :: (forall d. Data d => d -> u) -> CAssemblyStatement a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CAssemblyStatement a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CAssemblyStatement a -> m (CAssemblyStatement a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CAssemblyStatement a -> m (CAssemblyStatement a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CAssemblyStatement a -> m (CAssemblyStatement a) #
Show a => Show (CAssemblyStatement a) # |
Methods showsPrec :: Int -> CAssemblyStatement a -> ShowS # show :: CAssemblyStatement a -> String # showList :: [CAssemblyStatement a] -> ShowS #
CNode t1 => Pos (CAssemblyStatement t1) # |
Methods posOf :: CAssemblyStatement t1 -> Position #
CNode t1 => CNode (CAssemblyStatement t1) # |
Methods nodeInfo :: CAssemblyStatement t1 -> NodeInfo #

data CAssemblyOperand a #

Constructors

CAsmOperand (Maybe Ident) (CStringLiteral a) (CExpression a) a |

Instances

Functor CAssemblyOperand # |
Methods fmap :: (a -> b) -> CAssemblyOperand a -> CAssemblyOperand b # (<$) :: a -> CAssemblyOperand b -> CAssemblyOperand a #
Annotated CAssemblyOperand # |
Methods annotation :: CAssemblyOperand a -> a # amap :: (a -> a) -> CAssemblyOperand a -> CAssemblyOperand a #
Pretty CAsmOperand # |
Methods pretty :: CAsmOperand -> Doc # prettyPrec :: Int -> CAsmOperand -> Doc #
Data a => Data (CAssemblyOperand a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CAssemblyOperand a -> c (CAssemblyOperand a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CAssemblyOperand a) # toConstr :: CAssemblyOperand a -> Constr # dataTypeOf :: CAssemblyOperand a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CAssemblyOperand a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CAssemblyOperand a)) # gmapT :: (forall b. Data b => b -> b) -> CAssemblyOperand a -> CAssemblyOperand a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CAssemblyOperand a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CAssemblyOperand a -> r # gmapQ :: (forall d. Data d => d -> u) -> CAssemblyOperand a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CAssemblyOperand a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CAssemblyOperand a -> m (CAssemblyOperand a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CAssemblyOperand a -> m (CAssemblyOperand a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CAssemblyOperand a -> m (CAssemblyOperand a) #
Show a => Show (CAssemblyOperand a) # |
Methods showsPrec :: Int -> CAssemblyOperand a -> ShowS # show :: CAssemblyOperand a -> String # showList :: [CAssemblyOperand a] -> ShowS #
CNode t1 => Pos (CAssemblyOperand t1) # |
Methods posOf :: CAssemblyOperand t1 -> Position #
CNode t1 => CNode (CAssemblyOperand t1) # |
Methods nodeInfo :: CAssemblyOperand t1 -> NodeInfo #

# Expressions

type CExpr = CExpression NodeInfo #

C expression (K&R A7)

- these can be arbitrary expression, as the argument of `sizeof` can be arbitrary, even if appearing in a constant expression
- GNU C extensions: `alignof`, `__real`, `__imag`, `({ stmt-expr })`, `&& label` and built-ins

data CExpression a #

Constructors

CComma [CExpression a] a |
CAssign CAssignOp (CExpression a) (CExpression a) a |
CCond (CExpression a) (Maybe (CExpression a)) (CExpression a) a |
CBinary CBinaryOp (CExpression a) (CExpression a) a |
CCast (CDeclaration a) (CExpression a) a |
CUnary CUnaryOp (CExpression a) a |
CSizeofExpr (CExpression a) a |
CSizeofType (CDeclaration a) a |
CAlignofExpr (CExpression a) a |
CAlignofType (CDeclaration a) a |
CComplexReal (CExpression a) a |
CComplexImag (CExpression a) a |
CIndex (CExpression a) (CExpression a) a |
CCall (CExpression a) [CExpression a] a |
CMember (CExpression a) Ident Bool a |
CVar Ident a |
CConst (CConstant a) | integer, character, floating point and string constants
CCompoundLit (CDeclaration a) (CInitializerList a) a | C99 compound literal
CStatExpr (CStatement a) a | GNU C compound statement as expr
CLabAddrExpr Ident a | GNU C address of label
CBuiltinExpr (CBuiltinThing a) | builtin expressions, see `CBuiltin`

Instances

Functor CExpression # |
Methods fmap :: (a -> b) -> CExpression a -> CExpression b # (<$) :: a -> CExpression b -> CExpression a #
Annotated CExpression # |
Methods annotation :: CExpression a -> a # amap :: (a -> a) -> CExpression a -> CExpression a #
Pretty CExpr # |
Methods pretty :: CExpr -> Doc # prettyPrec :: Int -> CExpr -> Doc #
Data a => Data (CExpression a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CExpression a -> c (CExpression a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CExpression a) # toConstr :: CExpression a -> Constr # dataTypeOf :: CExpression a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CExpression a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CExpression a)) # gmapT :: (forall b. Data b => b -> b) -> CExpression a -> CExpression a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CExpression a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CExpression a -> r # gmapQ :: (forall d. Data d => d -> u) -> CExpression a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CExpression a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CExpression a -> m (CExpression a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CExpression a -> m (CExpression a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CExpression a -> m (CExpression a) #
Show a => Show (CExpression a) # |
Methods showsPrec :: Int -> CExpression a -> ShowS # show :: CExpression a -> String # showList :: [CExpression a] -> ShowS #
CNode t1 => Pos (CExpression t1) # |
Methods posOf :: CExpression t1 -> Position #
CNode t1 => CNode (CExpression t1) # |
Methods nodeInfo :: CExpression t1 -> NodeInfo #

data CAssignOp #

C assignment operators (K&R A7.17)

Constructors

CAssignOp |
CMulAssOp |
CDivAssOp |
CRmdAssOp | remainder and assignment
CAddAssOp |
CSubAssOp |
CShlAssOp |
CShrAssOp |
CAndAssOp |
CXorAssOp |
COrAssOp |

Instances

Eq CAssignOp # |
Methods (==) :: CAssignOp -> CAssignOp -> Bool # (/=) :: CAssignOp -> CAssignOp -> Bool #
Data CAssignOp # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CAssignOp -> c CAssignOp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CAssignOp # toConstr :: CAssignOp -> Constr # dataTypeOf :: CAssignOp -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c CAssignOp) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CAssignOp) # gmapT :: (forall b. Data b => b -> b) -> CAssignOp -> CAssignOp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CAssignOp -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CAssignOp -> r # gmapQ :: (forall d. Data d => d -> u) -> CAssignOp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CAssignOp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp #
Ord CAssignOp # |
Methods compare :: CAssignOp -> CAssignOp -> Ordering # (<) :: CAssignOp -> CAssignOp -> Bool # (<=) :: CAssignOp -> CAssignOp -> Bool # (>) :: CAssignOp -> CAssignOp -> Bool # (>=) :: CAssignOp -> CAssignOp -> Bool # max :: CAssignOp -> CAssignOp -> CAssignOp # min :: CAssignOp -> CAssignOp -> CAssignOp #
Show CAssignOp # |
Methods showsPrec :: Int -> CAssignOp -> ShowS # show :: CAssignOp -> String # showList :: [CAssignOp] -> ShowS #
Pretty CAssignOp # |
Methods pretty :: CAssignOp -> Doc # prettyPrec :: Int -> CAssignOp -> Doc #

data CBinaryOp #

C binary operators (K&R A7.6-15)

Constructors

CMulOp |
CDivOp |
CRmdOp | remainder of division
CAddOp |
CSubOp |
CShlOp | shift left
CShrOp | shift right
CLeOp | less
CGrOp | greater
CLeqOp | less or equal
CGeqOp | greater or equal
CEqOp | equal
CNeqOp | not equal
CAndOp | bitwise and
CXorOp | exclusive bitwise or
COrOp | inclusive bitwise or
CLndOp | logical and
CLorOp | logical or

Instances

Eq CBinaryOp # |
Methods (==) :: CBinaryOp -> CBinaryOp -> Bool # (/=) :: CBinaryOp -> CBinaryOp -> Bool #
Data CBinaryOp # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CBinaryOp -> c CBinaryOp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CBinaryOp # toConstr :: CBinaryOp -> Constr # dataTypeOf :: CBinaryOp -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c CBinaryOp) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CBinaryOp) # gmapT :: (forall b. Data b => b -> b) -> CBinaryOp -> CBinaryOp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CBinaryOp -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CBinaryOp -> r # gmapQ :: (forall d. Data d => d -> u) -> CBinaryOp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CBinaryOp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp #
Ord CBinaryOp # |
Methods compare :: CBinaryOp -> CBinaryOp -> Ordering # (<) :: CBinaryOp -> CBinaryOp -> Bool # (<=) :: CBinaryOp -> CBinaryOp -> Bool # (>) :: CBinaryOp -> CBinaryOp -> Bool # (>=) :: CBinaryOp -> CBinaryOp -> Bool # max :: CBinaryOp -> CBinaryOp -> CBinaryOp # min :: CBinaryOp -> CBinaryOp -> CBinaryOp #
Show CBinaryOp # |
Methods showsPrec :: Int -> CBinaryOp -> ShowS # show :: CBinaryOp -> String # showList :: [CBinaryOp] -> ShowS #
Pretty CBinaryOp # |
Methods pretty :: CBinaryOp -> Doc # prettyPrec :: Int -> CBinaryOp -> Doc #

data CUnaryOp #

C unary operator (K&R A7.3-4)

Constructors

CPreIncOp | prefix increment operator
CPreDecOp | prefix decrement operator
CPostIncOp | postfix increment operator
CPostDecOp | postfix decrement operator
CAdrOp | address operator
CIndOp | indirection operator
CPlusOp | prefix plus
CMinOp | prefix minus
CCompOp | one's complement
CNegOp | logical negation

Instances

Eq CUnaryOp # |
Methods (==) :: CUnaryOp -> CUnaryOp -> Bool # (/=) :: CUnaryOp -> CUnaryOp -> Bool #
Data CUnaryOp # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CUnaryOp -> c CUnaryOp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CUnaryOp # toConstr :: CUnaryOp -> Constr # dataTypeOf :: CUnaryOp -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c CUnaryOp) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CUnaryOp) # gmapT :: (forall b. Data b => b -> b) -> CUnaryOp -> CUnaryOp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CUnaryOp -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CUnaryOp -> r # gmapQ :: (forall d. Data d => d -> u) -> CUnaryOp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CUnaryOp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp #
Ord CUnaryOp # |
Methods compare :: CUnaryOp -> CUnaryOp -> Ordering # (<) :: CUnaryOp -> CUnaryOp -> Bool # (<=) :: CUnaryOp -> CUnaryOp -> Bool # (>) :: CUnaryOp -> CUnaryOp -> Bool # (>=) :: CUnaryOp -> CUnaryOp -> Bool # max :: CUnaryOp -> CUnaryOp -> CUnaryOp # min :: CUnaryOp -> CUnaryOp -> CUnaryOp #
Show CUnaryOp # |
Methods showsPrec :: Int -> CUnaryOp -> ShowS # show :: CUnaryOp -> String # showList :: [CUnaryOp] -> ShowS #
Pretty CUnaryOp # |
Methods pretty :: CUnaryOp -> Doc # prettyPrec :: Int -> CUnaryOp -> Doc #

type CBuiltin = CBuiltinThing NodeInfo #

GNU Builtins, which cannot be typed in C99

data CBuiltinThing a #

Constructors

CBuiltinVaArg (CExpression a) (CDeclaration a) a |
    (expr, type)
CBuiltinOffsetOf (CDeclaration a) [CPartDesignator a] a |
    (type, designator-list)
CBuiltinTypesCompatible (CDeclaration a) (CDeclaration a) a |
    (type,type)

Instances

Functor CBuiltinThing # |
Methods fmap :: (a -> b) -> CBuiltinThing a -> CBuiltinThing b # (<$) :: a -> CBuiltinThing b -> CBuiltinThing a #
Annotated CBuiltinThing # |
Methods annotation :: CBuiltinThing a -> a # amap :: (a -> a) -> CBuiltinThing a -> CBuiltinThing a #
Pretty CBuiltin # |
Methods pretty :: CBuiltin -> Doc # prettyPrec :: Int -> CBuiltin -> Doc #
Data a => Data (CBuiltinThing a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CBuiltinThing a -> c (CBuiltinThing a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CBuiltinThing a) # toConstr :: CBuiltinThing a -> Constr # dataTypeOf :: CBuiltinThing a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CBuiltinThing a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CBuiltinThing a)) # gmapT :: (forall b. Data b => b -> b) -> CBuiltinThing a -> CBuiltinThing a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CBuiltinThing a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CBuiltinThing a -> r # gmapQ :: (forall d. Data d => d -> u) -> CBuiltinThing a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CBuiltinThing a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CBuiltinThing a -> m (CBuiltinThing a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CBuiltinThing a -> m (CBuiltinThing a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CBuiltinThing a -> m (CBuiltinThing a) #
Show a => Show (CBuiltinThing a) # |
Methods showsPrec :: Int -> CBuiltinThing a -> ShowS # show :: CBuiltinThing a -> String # showList :: [CBuiltinThing a] -> ShowS #
CNode t1 => Pos (CBuiltinThing t1) # |
Methods posOf :: CBuiltinThing t1 -> Position #
CNode t1 => CNode (CBuiltinThing t1) # |
Methods nodeInfo :: CBuiltinThing t1 -> NodeInfo #

# Constants

type CConst = CConstant NodeInfo #

C constant (K&R A2.5 & A7.2)

type CStrLit = CStringLiteral NodeInfo #

Attributed string literals

cstringOfLit :: CStringLiteral a -> CString #

liftStrLit :: CStringLiteral a -> CConstant a #

Lift a string literal to a C constant

data CConstant a #

Constructors

CIntConst CInteger a |
CCharConst CChar a |
CFloatConst CFloat a |
CStrConst CString a |

Instances

Functor CConstant # |
Methods fmap :: (a -> b) -> CConstant a -> CConstant b # (<$) :: a -> CConstant b -> CConstant a #
Annotated CConstant # |
Methods annotation :: CConstant a -> a # amap :: (a -> a) -> CConstant a -> CConstant a #
Pretty CConst # |
Methods pretty :: CConst -> Doc # prettyPrec :: Int -> CConst -> Doc #
Data a => Data (CConstant a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CConstant a -> c (CConstant a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CConstant a) # toConstr :: CConstant a -> Constr # dataTypeOf :: CConstant a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CConstant a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CConstant a)) # gmapT :: (forall b. Data b => b -> b) -> CConstant a -> CConstant a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CConstant a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CConstant a -> r # gmapQ :: (forall d. Data d => d -> u) -> CConstant a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CConstant a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CConstant a -> m (CConstant a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CConstant a -> m (CConstant a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CConstant a -> m (CConstant a) #
Show a => Show (CConstant a) # |
Methods showsPrec :: Int -> CConstant a -> ShowS # show :: CConstant a -> String # showList :: [CConstant a] -> ShowS #
CNode t1 => Pos (CConstant t1) # |
Methods posOf :: CConstant t1 -> Position #
CNode t1 => CNode (CConstant t1) # |
Methods nodeInfo :: CConstant t1 -> NodeInfo #

data CStringLiteral a #

Constructors

CStrLit CString a |

Instances

Functor CStringLiteral # |
Methods fmap :: (a -> b) -> CStringLiteral a -> CStringLiteral b # (<$) :: a -> CStringLiteral b -> CStringLiteral a #
Annotated CStringLiteral # |
Methods annotation :: CStringLiteral a -> a # amap :: (a -> a) -> CStringLiteral a -> CStringLiteral a #
Pretty CStrLit # |
Methods pretty :: CStrLit -> Doc # prettyPrec :: Int -> CStrLit -> Doc #
Data a => Data (CStringLiteral a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CStringLiteral a -> c (CStringLiteral a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CStringLiteral a) # toConstr :: CStringLiteral a -> Constr # dataTypeOf :: CStringLiteral a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CStringLiteral a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CStringLiteral a)) # gmapT :: (forall b. Data b => b -> b) -> CStringLiteral a -> CStringLiteral a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CStringLiteral a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CStringLiteral a -> r # gmapQ :: (forall d. Data d => d -> u) -> CStringLiteral a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CStringLiteral a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CStringLiteral a -> m (CStringLiteral a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CStringLiteral a -> m (CStringLiteral a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CStringLiteral a -> m (CStringLiteral a) #
Show a => Show (CStringLiteral a) # |
Methods showsPrec :: Int -> CStringLiteral a -> ShowS # show :: CStringLiteral a -> String # showList :: [CStringLiteral a] -> ShowS #
CNode t1 => Pos (CStringLiteral t1) # |
Methods posOf :: CStringLiteral t1 -> Position #
CNode t1 => CNode (CStringLiteral t1) # |
Methods nodeInfo :: CStringLiteral t1 -> NodeInfo #

# Annoated type class

class Functor ast => Annotated ast where #

All AST nodes are annotated. Inspired by the Annotated class of Niklas Broberg's haskell-src-exts package. In principle, we could have Copointed superclass instead of `ann`, for the price of another dependency.

Minimal complete definition

annotation, amap

Methods

annotation :: ast a -> a #

get the annotation of an AST node

amap :: (a -> a) -> ast a -> ast a #

change the annotation (non-recursively) of an AST node. Use fmap for recursively modifying the annotation.

Instances

Annotated CStringLiteral # |
Methods annotation :: CStringLiteral a -> a # amap :: (a -> a) -> CStringLiteral a -> CStringLiteral a #
Annotated CConstant # |
Methods annotation :: CConstant a -> a # amap :: (a -> a) -> CConstant a -> CConstant a #
Annotated CBuiltinThing # |
Methods annotation :: CBuiltinThing a -> a # amap :: (a -> a) -> CBuiltinThing a -> CBuiltinThing a #
Annotated CExpression # |
Methods annotation :: CExpression a -> a # amap :: (a -> a) -> CExpression a -> CExpression a #
Annotated CAttribute # |
Methods annotation :: CAttribute a -> a # amap :: (a -> a) -> CAttribute a -> CAttribute a #
Annotated CPartDesignator # |
Methods annotation :: CPartDesignator a -> a # amap :: (a -> a) -> CPartDesignator a -> CPartDesignator a #
Annotated CInitializer # |
Methods annotation :: CInitializer a -> a # amap :: (a -> a) -> CInitializer a -> CInitializer a #
Annotated CEnumeration # |
Methods annotation :: CEnumeration a -> a # amap :: (a -> a) -> CEnumeration a -> CEnumeration a #
Annotated CStructureUnion # |
Methods annotation :: CStructureUnion a -> a # amap :: (a -> a) -> CStructureUnion a -> CStructureUnion a #
Annotated CTypeQualifier # |
Methods annotation :: CTypeQualifier a -> a # amap :: (a -> a) -> CTypeQualifier a -> CTypeQualifier a #
Annotated CTypeSpecifier # |
Methods annotation :: CTypeSpecifier a -> a # amap :: (a -> a) -> CTypeSpecifier a -> CTypeSpecifier a #
Annotated CStorageSpecifier # |
Methods annotation :: CStorageSpecifier a -> a # amap :: (a -> a) -> CStorageSpecifier a -> CStorageSpecifier a #
Annotated CDeclarationSpecifier # |
Methods annotation :: CDeclarationSpecifier a -> a # amap :: (a -> a) -> CDeclarationSpecifier a -> CDeclarationSpecifier a #
Annotated CCompoundBlockItem # |
Methods annotation :: CCompoundBlockItem a -> a # amap :: (a -> a) -> CCompoundBlockItem a -> CCompoundBlockItem a #
Annotated CAssemblyOperand # |
Methods annotation :: CAssemblyOperand a -> a # amap :: (a -> a) -> CAssemblyOperand a -> CAssemblyOperand a #
Annotated CAssemblyStatement # |
Methods annotation :: CAssemblyStatement a -> a # amap :: (a -> a) -> CAssemblyStatement a -> CAssemblyStatement a #
Annotated CStatement # |
Methods annotation :: CStatement a -> a # amap :: (a -> a) -> CStatement a -> CStatement a #
Annotated CDerivedDeclarator # |
Methods annotation :: CDerivedDeclarator a -> a # amap :: (a -> a) -> CDerivedDeclarator a -> CDerivedDeclarator a #
Annotated CDeclarator # |
Methods annotation :: CDeclarator a -> a # amap :: (a -> a) -> CDeclarator a -> CDeclarator a #
Annotated CDeclaration # |
Methods annotation :: CDeclaration a -> a # amap :: (a -> a) -> CDeclaration a -> CDeclaration a #
Annotated CFunctionDef # |
Methods annotation :: CFunctionDef a -> a # amap :: (a -> a) -> CFunctionDef a -> CFunctionDef a #
Annotated CExternalDeclaration # |
Methods annotation :: CExternalDeclaration a -> a # amap :: (a -> a) -> CExternalDeclaration a -> CExternalDeclaration a #
Annotated CTranslationUnit # |
Methods annotation :: CTranslationUnit a -> a # amap :: (a -> a) -> CTranslationUnit a -> CTranslationUnit a #