Language.C.Syntax.AST

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

Portability | ghc
Stability | experimental
Maintainer | benedikt.huber@gmail.com
Safe Haskell | None

Language.C.Syntax.AST

Contents

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

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

- data CTranslUnit = CTranslUnit [CExtDecl] NodeInfo
- data CExtDecl
  - = CDeclExt CDecl
  - | CFDefExt CFunDef
  - | CAsmExt CStrLit
- data CFunDef = CFunDef [CDeclSpec] CDeclr [CDecl] CStat NodeInfo
- data CDecl = CDecl [CDeclSpec] [(Maybe CDeclr, Maybe CInit, Maybe CExpr)] NodeInfo
- data CStructUnion = CStruct CStructTag (Maybe Ident) (Maybe [CDecl]) [CAttr] NodeInfo
- data CStructTag
  - = CStructTag
  - | CUnionTag
- data CEnum = CEnum (Maybe Ident) (Maybe [(Ident, Maybe CExpr)]) [CAttr] NodeInfo
- data CDeclSpec
  - = CStorageSpec CStorageSpec
  - | CTypeSpec CTypeSpec
  - | CTypeQual CTypeQual
- partitionDeclSpecs :: [CDeclSpec] -> ([CStorageSpec], [CAttr], [CTypeQual], [CTypeSpec], Bool)
- data CStorageSpec
  - = CAuto NodeInfo
  - | CRegister NodeInfo
  - | CStatic NodeInfo
  - | CExtern NodeInfo
  - | CTypedef NodeInfo
  - | CThread NodeInfo
- data CTypeSpec
  - = CVoidType NodeInfo
  - | CCharType NodeInfo
  - | CShortType NodeInfo
  - | CIntType NodeInfo
  - | CLongType NodeInfo
  - | CFloatType NodeInfo
  - | CDoubleType NodeInfo
  - | CSignedType NodeInfo
  - | CUnsigType NodeInfo
  - | CBoolType NodeInfo
  - | CComplexType NodeInfo
  - | CSUType CStructUnion NodeInfo
  - | CEnumType CEnum NodeInfo
  - | CTypeDef Ident NodeInfo
  - | CTypeOfExpr CExpr NodeInfo
  - | CTypeOfType CDecl NodeInfo
- isSUEDef :: CTypeSpec -> Bool
- data CTypeQual
  - = CConstQual NodeInfo
  - | CVolatQual NodeInfo
  - | CRestrQual NodeInfo
  - | CInlineQual NodeInfo
  - | CAttrQual CAttr
- data CAttr = CAttr Ident [CExpr] NodeInfo
- data CDeclr = CDeclr (Maybe Ident) [CDerivedDeclr] (Maybe CStrLit) [CAttr] NodeInfo
- data CDerivedDeclr
  - = CPtrDeclr [CTypeQual] NodeInfo
  - | CArrDeclr [CTypeQual] CArrSize NodeInfo
  - | CFunDeclr (Either [Ident] ([CDecl], Bool)) [CAttr] NodeInfo
- data CArrSize
  - = CNoArrSize Bool
  - | CArrSize Bool CExpr
- data CInit
  - = CInitExpr CExpr NodeInfo
  - | CInitList CInitList NodeInfo
- type CInitList = [([CDesignator], CInit)]
- data CDesignator
  - = CArrDesig CExpr NodeInfo
  - | CMemberDesig Ident NodeInfo
  - | CRangeDesig CExpr CExpr NodeInfo
- data CStat
  - = CLabel Ident CStat [CAttr] NodeInfo
  - | CCase CExpr CStat NodeInfo
  - | CCases CExpr CExpr CStat NodeInfo
  - | CDefault CStat NodeInfo
  - | CExpr (Maybe CExpr) NodeInfo
  - | CCompound [Ident] [CBlockItem] NodeInfo
  - | CIf CExpr CStat (Maybe CStat) NodeInfo
  - | CSwitch CExpr CStat NodeInfo
  - | CWhile CExpr CStat Bool NodeInfo
  - | CFor (Either (Maybe CExpr) CDecl) (Maybe CExpr) (Maybe CExpr) CStat NodeInfo
  - | CGoto Ident NodeInfo
  - | CGotoPtr CExpr NodeInfo
  - | CCont NodeInfo
  - | CBreak NodeInfo
  - | CReturn (Maybe CExpr) NodeInfo
  - | CAsm CAsmStmt NodeInfo
- data CBlockItem
  - = CBlockStmt CStat
  - | CBlockDecl CDecl
  - | CNestedFunDef CFunDef
- data CAsmStmt = CAsmStmt (Maybe CTypeQual) CStrLit [CAsmOperand] [CAsmOperand] [CStrLit] NodeInfo
- data CAsmOperand = CAsmOperand (Maybe Ident) CStrLit CExpr NodeInfo
- data CExpr
  - = CComma [CExpr] NodeInfo
  - | CAssign CAssignOp CExpr CExpr NodeInfo
  - | CCond CExpr (Maybe CExpr) CExpr NodeInfo
  - | CBinary CBinaryOp CExpr CExpr NodeInfo
  - | CCast CDecl CExpr NodeInfo
  - | CUnary CUnaryOp CExpr NodeInfo
  - | CSizeofExpr CExpr NodeInfo
  - | CSizeofType CDecl NodeInfo
  - | CAlignofExpr CExpr NodeInfo
  - | CAlignofType CDecl NodeInfo
  - | CComplexReal CExpr NodeInfo
  - | CComplexImag CExpr NodeInfo
  - | CIndex CExpr CExpr NodeInfo
  - | CCall CExpr [CExpr] NodeInfo
  - | CMember CExpr Ident Bool NodeInfo
  - | CVar Ident NodeInfo
  - | CConst CConst
  - | CCompoundLit CDecl CInitList NodeInfo
  - | CStatExpr CStat NodeInfo
  - | CLabAddrExpr Ident NodeInfo
  - | CBuiltinExpr CBuiltin
- 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
- data CBuiltin
  - = CBuiltinVaArg CExpr CDecl NodeInfo
  - | CBuiltinOffsetOf CDecl [CDesignator] NodeInfo
  - | CBuiltinTypesCompatible CDecl CDecl NodeInfo
- data CConst
  - = CIntConst CInteger NodeInfo
  - | CCharConst CChar NodeInfo
  - | CFloatConst CFloat NodeInfo
  - | CStrConst CString NodeInfo
- data CStrLit = CStrLit CString NodeInfo
- cstringOfLit :: CStrLit -> CString
- liftStrLit :: CStrLit -> CConst

# C translation units

data CTranslUnit

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.

Constructors

CTranslUnit [CExtDecl] NodeInfo |

Instances

Data CTranslUnit |
Typeable CTranslUnit |
Pos CTranslUnit |
CNode CTranslUnit |
Pretty CTranslUnit |

data CExtDecl

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

Either a toplevel declaration, function definition or external assembler.

Constructors

CDeclExt CDecl |
CFDefExt CFunDef |
CAsmExt CStrLit |

Instances

Data CExtDecl |
Typeable CExtDecl |
Pos CExtDecl |
CNode CExtDecl |
Pretty CExtDecl |

# Declarations

data CFunDef

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.

Constructors

CFunDef [CDeclSpec] CDeclr [CDecl] CStat NodeInfo |

Instances

Data CFunDef |
Typeable CFunDef |
Pos CFunDef |
CNode CFunDef |
Pretty CFunDef |

data CDecl

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)

Constructors

CDecl [CDeclSpec] [(Maybe CDeclr, Maybe CInit, Maybe CExpr)] NodeInfo |

Instances

Data CDecl |
Typeable CDecl |
Pos CDecl |
CNode CDecl |
Pretty CDecl |

data CStructUnion

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

Constructors

CStruct CStructTag (Maybe Ident) (Maybe [CDecl]) [CAttr] NodeInfo |

Instances

Data CStructUnion |
Typeable CStructUnion |
Pos CStructUnion |
CNode CStructUnion |
Pretty CStructUnion |

data CStructTag

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

Constructors

CStructTag |
CUnionTag |

Instances

Eq CStructTag |
Data CStructTag |
Typeable CStructTag |
Pretty CStructTag |

data CEnum

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

Constructors

CEnum (Maybe Ident) (Maybe [(Ident, Maybe CExpr)]) [CAttr] NodeInfo |

Instances

Data CEnum |
Typeable CEnum |
Pos CEnum |
CNode CEnum |
Pretty CEnum |

# Declaration attributes

data CDeclSpec

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).

Constructors

CStorageSpec CStorageSpec | storage-class specifier or typedef
CTypeSpec CTypeSpec | type name
CTypeQual CTypeQual | type qualifier

Instances

Data CDeclSpec |
Typeable CDeclSpec |
Pos CDeclSpec |
CNode CDeclSpec |
Pretty CDeclSpec |

partitionDeclSpecs :: [CDeclSpec] -> ([CStorageSpec], [CAttr], [CTypeQual], [CTypeSpec], Bool)

Seperate 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 seperated as well.

data CStorageSpec

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

Constructors

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

Instances

Eq CStorageSpec |
Data CStorageSpec |
Ord CStorageSpec |
Show CStorageSpec |
Typeable CStorageSpec |
Pos CStorageSpec |
CNode CStorageSpec |
Pretty CStorageSpec |

data CTypeSpec

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.

Constructors

CVoidType NodeInfo |
CCharType NodeInfo |
CShortType NodeInfo |
CIntType NodeInfo |
CLongType NodeInfo |
CFloatType NodeInfo |
CDoubleType NodeInfo |
CSignedType NodeInfo |
CUnsigType NodeInfo |
CBoolType NodeInfo |
CComplexType NodeInfo |
CSUType CStructUnion NodeInfo | Struct or Union specifier
CEnumType CEnum NodeInfo | Enumeration specifier
CTypeDef Ident NodeInfo | Typedef name
CTypeOfExpr CExpr NodeInfo |
    typeof(expr)
CTypeOfType CDecl NodeInfo |
    typeof(type)

Instances

Data CTypeSpec |
Typeable CTypeSpec |
Pos CTypeSpec |
CNode CTypeSpec |
Pretty CTypeSpec |

isSUEDef :: CTypeSpec -> Bool

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

data CTypeQual

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.

Constructors

CConstQual NodeInfo |
CVolatQual NodeInfo |
CRestrQual NodeInfo |
CInlineQual NodeInfo |
CAttrQual CAttr |

Instances

Data CTypeQual |
Typeable CTypeQual |
Pos CTypeQual |
CNode CTypeQual |
Pretty CTypeQual |

data CAttr

`__attribute__` annotations

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

Constructors

CAttr Ident [CExpr] NodeInfo |

Instances

Data CAttr |
Typeable CAttr |
Pos CAttr |
CNode CAttr |
Pretty CAttr |

# Declarators

data CDeclr

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 []]

Constructors

CDeclr (Maybe Ident) [CDerivedDeclr] (Maybe CStrLit) [CAttr] NodeInfo |

Instances

Data CDeclr |
Typeable CDeclr |
Pos CDeclr |
CNode CDeclr |
Pretty CDeclr |

data CDerivedDeclr

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)`

Constructors

CPtrDeclr [CTypeQual] NodeInfo | Pointer declarator `CPtrDeclr tyquals declr`
CArrDeclr [CTypeQual] CArrSize NodeInfo | Array declarator `CArrDeclr declr tyquals size-expr?`
CFunDeclr (Either [Ident] ([CDecl], Bool)) [CAttr] NodeInfo | Function declarator `CFunDeclr declr (old-style-params | new-style-params) c-attrs`

Instances

Data CDerivedDeclr |
Typeable CDerivedDeclr |
Pos CDerivedDeclr |
CNode CDerivedDeclr |

data CArrSize

Size of an array

Constructors

CNoArrSize Bool |
    CUnknownSize isCompleteType
CArrSize Bool CExpr |
    CArrSize isStatic expr

Instances

Data CArrSize |
Typeable CArrSize |
Pretty CArrSize |

# Initialization

data CInit

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.

Constructors

CInitExpr CExpr NodeInfo | assignment expression
CInitList CInitList NodeInfo | initialization list (see `CInitList`)

Instances

Data CInit |
Typeable CInit |
Pos CInit |
CNode CInit |
Pretty CInit |

type CInitList = [([CDesignator], CInit)]

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)]

data CDesignator

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.

Constructors

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

Instances

Data CDesignator |
Typeable CDesignator |
Pos CDesignator |
CNode CDesignator |
Pretty CDesignator |

# Statements

data CStat

C statement (K&R A9, C99 6.8)

Constructors

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

Instances

Data CStat |
Typeable CStat |
Pos CStat |
CNode CStat |
Pretty CStat |

data CBlockItem

C99 Block items

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

Constructors

CBlockStmt CStat | A statement
CBlockDecl CDecl | A local declaration
CNestedFunDef CFunDef | A nested function (GNU C)

Instances

Data CBlockItem |
Typeable CBlockItem |
Pos CBlockItem |
CNode CBlockItem |
Pretty CBlockItem |

data CAsmStmt

GNU Assembler statement

     CAsmStatement 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

Constructors

CAsmStmt (Maybe CTypeQual) CStrLit [CAsmOperand] [CAsmOperand] [CStrLit] NodeInfo |

Instances

Data CAsmStmt |
Typeable CAsmStmt |
Pos CAsmStmt |
CNode CAsmStmt |
Pretty CAsmStmt |

data CAsmOperand

Assembler operand

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

Constructors

CAsmOperand (Maybe Ident) CStrLit CExpr NodeInfo |

Instances

Data CAsmOperand |
Typeable CAsmOperand |
Pos CAsmOperand |
CNode CAsmOperand |
Pretty CAsmOperand |

# Expressions

data CExpr

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

Constructors

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

Instances

Data CExpr |
Typeable CExpr |
Pos CExpr |
CNode CExpr |
Pretty CExpr |

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 |
Data CAssignOp |
Ord CAssignOp |
Show CAssignOp |
Typeable CAssignOp |
Pretty CAssignOp |

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 |
Data CBinaryOp |
Ord CBinaryOp |
Show CBinaryOp |
Typeable CBinaryOp |
Pretty CBinaryOp |

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 |
Data CUnaryOp |
Ord CUnaryOp |
Show CUnaryOp |
Typeable CUnaryOp |
Pretty CUnaryOp |

data CBuiltin

GNU Builtins, which cannot be typed in C99

Constructors

CBuiltinVaArg CExpr CDecl NodeInfo |
    (expr, type)
CBuiltinOffsetOf CDecl [CDesignator] NodeInfo |
    (type, designator-list)
CBuiltinTypesCompatible CDecl CDecl NodeInfo |
    (type,type)

Instances

Data CBuiltin |
Typeable CBuiltin |
Pos CBuiltin |
CNode CBuiltin |
Pretty CBuiltin |

# Constants

data CConst

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

Constructors

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

Instances

Data CConst |
Typeable CConst |
Pos CConst |
CNode CConst |
Pretty CConst |

data CStrLit

Attributed string literals

Constructors

CStrLit CString NodeInfo |

Instances

Data CStrLit |
Typeable CStrLit |
Pos CStrLit |
CNode CStrLit |
Pretty CStrLit |

cstringOfLit :: CStrLit -> CString

liftStrLit :: CStrLit -> CConst

Lift a string literal to a C constant