    {-# LANGUAGE DeriveDataTypeable #-}
    -----------------------------------------------------------------------------
    -- |
    -- Module      :  Language.C.Syntax.AST
    -- Copyright   :  (c) [1999..2007] Manuel M T Chakravarty
    --                (c) 2008 Benedikt Huber
    -- License     :  BSD-style
    -- Maintainer  : benedikt.huber@gmail.com
    -- Stability   : experimental
    -- Portability : ghc
    --
    -- 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>.
    -----------------------------------------------------------------------------
    module Language.C.Syntax.AST (
      -- * C translation units
      CTranslUnit(..),  CExtDecl(..),
      -- * Declarations
      CFunDef(..),  CDecl(..),
      CStructUnion(..),  CStructTag(..), CEnum(..),
      -- * Declaration attributes
      CDeclSpec(..), partitionDeclSpecs,
      CStorageSpec(..), CTypeSpec(..), isSUEDef, CTypeQual(..), CAttr(..),
      -- * Declarators
      CDeclr(..),CDerivedDeclr(..),CArrSize(..),
      -- * Initialization
      CInit(..), CInitList, CDesignator(..),
      -- * Statements
      CStat(..), CBlockItem(..),
      CAsmStmt(..), CAsmOperand(..),
      -- * Expressions
      CExpr(..),
      CAssignOp(..), CBinaryOp(..), CUnaryOp(..),
      CBuiltin(..),
      -- * Constants
      CConst(..),CStrLit(..),cstringOfLit,liftStrLit,
    ) where
    import Data.List
    import Language.C.Syntax.Constants
    import Language.C.Syntax.Ops
    import Language.C.Data.Ident
    import Language.C.Data.Node
    import Language.C.Data.Position
    import Data.Generics

    -- | 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.
    data CTranslUnit = CTranslUnit [CExtDecl] NodeInfo
                       deriving (Data,Typeable {-! CNode !-})

    -- | External C declaration (C99 6.9, K&R A10)
    --
    -- Either a toplevel declaration, function definition or external assembler.
    data CExtDecl = CDeclExt CDecl
                  | CFDefExt CFunDef
                  | CAsmExt  CStrLit
                  deriving (Data,Typeable {-! CNode !-})

    -- | 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.
    data CFunDef = CFunDef [CDeclSpec]      -- type specifier and qualifier
                           CDeclr           -- declarator
                           [CDecl]          -- optional declaration list
                           CStat            -- compound statement
                           NodeInfo
                   deriving (Data,Typeable {-! CNode !-})

    -- | 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)
    --
    data CDecl = CDecl [CDeclSpec]          -- type specifier and qualifier, __attribute__
                       [(Maybe CDeclr,      -- declarator (may be omitted)
                         Maybe CInit,       -- optional initialize
                         Maybe CExpr)]      -- optional size (const expr)
                       NodeInfo
                 deriving (Data,Typeable {-! CNode !-})

    -- | 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 []]
    data CDeclr = CDeclr (Maybe Ident) [CDerivedDeclr] (Maybe CStrLit) [CAttr] NodeInfo
                  deriving (Data,Typeable {-! CNode !-})

    -- | 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)@
    data CDerivedDeclr =
                  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@
                deriving (Data,Typeable {-! CNode !-})

    -- | Size of an array
    data CArrSize = CNoArrSize Bool     -- ^ @CUnknownSize isCompleteType@
                  | CArrSize Bool CExpr -- ^ @CArrSize isStatic expr@
                  deriving (Data,Typeable)

    -- | C statement (K&R A9, C99 6.8)
    --
    data CStat = 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
               deriving (Data,Typeable {-! CNode !-})

    -- | 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
    data CAsmStmt
      = CAsmStmt (Maybe CTypeQual)     -- maybe volatile
                        CStrLit        -- assembler expression (String)
                       [CAsmOperand]   -- output operands
                       [CAsmOperand]   -- input operands
                       [CStrLit]       -- Clobbers
                        NodeInfo
        deriving (Data,Typeable {-! CNode !-})
    -- | Assembler operand
    --
    -- @CAsmOperand argName? constraintExpr arg@ specifies an operand for an assembler
    -- statement.
    data CAsmOperand = CAsmOperand (Maybe Ident)   -- argument name
                                    CStrLit        -- constraint expr
                                    CExpr          -- argument
                                    NodeInfo
                       deriving (Data,Typeable {-! CNode !-})
    -- | C99 Block items
    --
    --  Things that may appear in compound statements: either statements, declarations
    --   or nested function definitions.
    data CBlockItem = CBlockStmt    CStat           -- ^ A statement
                    | CBlockDecl    CDecl           -- ^ A local declaration
                    | CNestedFunDef CFunDef         -- ^ A nested function (GNU C)
                      deriving (Data,Typeable {-! CNode !-})
    -- | 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).
    data CDeclSpec = CStorageSpec CStorageSpec  -- ^ storage-class specifier or typedef
                   | CTypeSpec    CTypeSpec     -- ^ type name
                   | CTypeQual    CTypeQual     -- ^ type qualifier
                     deriving (Data,Typeable {-! CNode !-})

    -- | 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.
    partitionDeclSpecs :: [CDeclSpec] -> ([CStorageSpec], [CAttr], [CTypeQual], [CTypeSpec], Bool)
    partitionDeclSpecs = foldr deals ([],[],[],[],False) where
        deals (CTypeQual (CInlineQual _)) (sts,ats,tqs,tss,_) = (sts,ats,tqs,tss,True)
        deals (CStorageSpec sp) (sts,ats,tqs,tss,inline)  = (sp:sts,ats,tqs,tss,inline)
        deals (CTypeQual (CAttrQual attr)) (sts,ats,tqs,tss,inline)  = (sts,attr:ats,tqs,tss,inline)
        deals (CTypeQual tq) (sts,ats,tqs,tss,inline)     = (sts,ats,tq:tqs,tss,inline)
        deals (CTypeSpec ts) (sts,ats,tqs,tss,inline)     = (sts,ats,tqs,ts:tss,inline)

    -- | C storage class specifier (and typedefs) (K&R A8.1, C99 6.7.1)
    data CStorageSpec = CAuto     NodeInfo     -- ^ auto
                      | CRegister NodeInfo     -- ^ register
                      | CStatic   NodeInfo     -- ^ static
                      | CExtern   NodeInfo     -- ^ extern
                      | CTypedef  NodeInfo     -- ^ typedef
                      | CThread   NodeInfo     -- ^ GNUC thread local storage
                     deriving (Eq,Ord,Data,Typeable {-! CNode !-})
    instance Show CStorageSpec where
        show (CAuto _) = "auto"
        show (CRegister _) = "register"
        show (CStatic _) = "static"
        show (CExtern _) = "extern"
        show (CTypedef _) = "typedef"
        show (CThread _) = "__thread"

    -- | 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.
    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  -- ^ Struct or Union specifier
                   | CEnumType    CEnum        NodeInfo  -- ^ Enumeration specifier
                   | CTypeDef     Ident        NodeInfo  -- ^ Typedef name
                   | CTypeOfExpr  CExpr        NodeInfo  -- ^ @typeof(expr)@
                   | CTypeOfType  CDecl        NodeInfo  -- ^ @typeof(type)@
                   deriving (Data,Typeable {-! CNode !-})

    -- | returns @True@ if the given typespec is a struct, union or enum /definition/
    isSUEDef :: CTypeSpec -> Bool
    isSUEDef (CSUType (CStruct _ _ (Just _) _ _) _) = True
    isSUEDef (CEnumType (CEnum _ (Just _) _ _) _) = True
    isSUEDef _ = False

    -- | 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.
    data CTypeQual = CConstQual NodeInfo
                   | CVolatQual NodeInfo
                   | CRestrQual NodeInfo
                   | CInlineQual NodeInfo
                   | CAttrQual  CAttr
                   deriving (Data,Typeable {-! CNode !-})

    -- | 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
    data CStructUnion = CStruct CStructTag
                                (Maybe Ident)
                                (Maybe [CDecl])    -- member declarations
                                [CAttr]            -- __attribute__s
                                NodeInfo
                        deriving (Data,Typeable {-! CNode !-})

    -- | A tag to determine wheter we refer to a @struct@ or @union@, see 'CStructUnion'.
    data CStructTag = CStructTag
                    | CUnionTag
                    deriving (Eq,Data,Typeable)

    -- | 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 CEnum = CEnum (Maybe Ident)
                       (Maybe [(Ident,             -- variant name
                                Maybe CExpr)])     -- explicit variant value
                       [CAttr]                     -- __attribute__s
                       NodeInfo
                 deriving (Data,Typeable {-! CNode !-})

    -- | 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.
    data CInit = CInitExpr CExpr
                           NodeInfo            -- ^ assignment expression
               | CInitList CInitList
                           NodeInfo            -- ^ initialization list (see 'CInitList')
                 deriving (Data,Typeable {-! CNode !-})

    -- | Initializer List
    --
    -- The members of an initializer list are of the form @(designator-list,initializer)@.
    -- @designator-list@ 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):
    --
    -- > -- { [0], [3] = 4, [2] = 5, 8 }
    -- > let init1 = ([CArrDesig 0, CArrDesig 3], CInitExpr 4)
    -- >     init2 = ([CArrDesig 2], CInitExpr 5)
    -- >     init3 = ([], CInitExpr 8)
    -- > in  CInitList [init1, init2, init3]
    --
    -- > -- { .s = { {2,3} , .a = { 1 } } }
    -- > let init_1  = [ ([], CInitExpr 1) ]
    -- >     init_23 = zip (repeat []) [CInitExpr 2, CInitExpr 3]
    -- >     init_s_1 = ([], CInitList init_23)
    -- >     init_s_a = ([CMemberDesig "a"], CInitList init_1)
    -- >     init_s  = ((CMemberDesig "s"), CInitList [init_s_1,init_s_a])
    -- > in  CInitList [init_s]
    type CInitList = [([CDesignator], CInit)]

    -- | 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 CDesignator = CArrDesig     CExpr
                                     NodeInfo  -- ^ array position designator
                     | CMemberDesig  Ident
                                     NodeInfo  -- ^ member designator
                     | CRangeDesig   CExpr
                                     CExpr
                                     NodeInfo  -- ^ array range designator @CRangeDesig from to _@ (GNU C)
                       deriving (Data,Typeable {-! CNode !-})

    -- | @__attribute__@ annotations
    --
    -- Those are of the form @CAttr attribute-name attribute-parameters@,
    -- and serve as generic properties of some syntax tree elements.
    data CAttr = CAttr Ident [CExpr] NodeInfo
                 deriving (Data,Typeable {-! CNode !-})

    -- | 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 CExpr = CComma       [CExpr]       -- comma expression list, n >= 2
                              NodeInfo
               | CAssign      CAssignOp     -- assignment operator
                              CExpr         -- l-value
                              CExpr         -- r-value
                              NodeInfo
               | CCond        CExpr         -- conditional
                       (Maybe CExpr)        -- true-expression (GNU allows omitting)
                              CExpr         -- false-expression
                              NodeInfo
               | CBinary      CBinaryOp     -- binary operator
                              CExpr         -- lhs
                              CExpr         -- rhs
                              NodeInfo
               | CCast        CDecl         -- type name
                              CExpr
                              NodeInfo
               | CUnary       CUnaryOp      -- unary operator
                              CExpr
                              NodeInfo
               | CSizeofExpr  CExpr
                              NodeInfo
               | CSizeofType  CDecl         -- type name
                              NodeInfo
               | CAlignofExpr CExpr
                              NodeInfo
               | CAlignofType CDecl         -- type name
                              NodeInfo
               | CComplexReal CExpr         -- real part of complex number
                              NodeInfo
               | CComplexImag CExpr         -- imaginary part of complex number
                              NodeInfo
               | CIndex       CExpr         -- array
                              CExpr         -- index
                              NodeInfo
               | CCall        CExpr         -- function
                              [CExpr]       -- arguments
                              NodeInfo
               | CMember      CExpr         -- structure
                              Ident         -- member name
                              Bool          -- deref structure? (True for `->')
                              NodeInfo
               | CVar         Ident         -- identifier (incl. enumeration const)
                              NodeInfo
               | CConst       CConst        -- ^ integer, character, floating point and string constants
               | CCompoundLit CDecl
                              CInitList     -- type name & initialiser list
                              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'
               deriving (Data,Typeable {-! CNode !-})

    -- | GNU Builtins, which cannot be typed in C99
    data CBuiltin =
              CBuiltinVaArg CExpr CDecl NodeInfo            -- ^ @(expr, type)@
            | CBuiltinOffsetOf CDecl [CDesignator] NodeInfo -- ^ @(type, designator-list)@
            | CBuiltinTypesCompatible CDecl CDecl NodeInfo  -- ^ @(type,type)@
            deriving (Data,Typeable {-! CNode !-})

    -- | C constant (K&R A2.5 & A7.2)
    data CConst = CIntConst   CInteger NodeInfo
                | CCharConst  CChar NodeInfo
                | CFloatConst CFloat NodeInfo
                | CStrConst   CString NodeInfo
                deriving (Data,Typeable {-! CNode !-})

    -- | Attributed string literals
    data CStrLit = CStrLit CString NodeInfo
                deriving (Data,Typeable {-! CNode !-})

    cstringOfLit :: CStrLit -> CString
    cstringOfLit (CStrLit cstr _) = cstr

    -- | Lift a string literal to a C constant
    liftStrLit :: CStrLit -> CConst
    liftStrLit (CStrLit str at) = CStrConst str at

    --------------------------------------------------------
    -- DERIVES GENERATED CODE
    -- DO NOT MODIFY BELOW THIS LINE
    -- CHECKSUM: 1181183062

    instance CNode CTranslUnit
        where nodeInfo (CTranslUnit _ nodeinfo) = nodeinfo
    instance Pos CTranslUnit
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CExtDecl
        where nodeInfo (CDeclExt d) = nodeInfo d
              nodeInfo (CFDefExt d) = nodeInfo d
              nodeInfo (CAsmExt d) = nodeInfo d
    instance Pos CExtDecl
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CFunDef
        where nodeInfo (CFunDef _ _ _ _ nodeinfo) = nodeinfo
    instance Pos CFunDef
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CDecl
        where nodeInfo (CDecl _ _ nodeinfo) = nodeinfo
    instance Pos CDecl
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CDeclr
        where nodeInfo (CDeclr _ _ _ _ nodeinfo) = nodeinfo
    instance Pos CDeclr
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CDerivedDeclr
        where nodeInfo (CPtrDeclr _ nodeinfo) = nodeinfo
              nodeInfo (CArrDeclr _ _ nodeinfo) = nodeinfo
              nodeInfo (CFunDeclr _ _ nodeinfo) = nodeinfo
    instance Pos CDerivedDeclr
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CStat
        where nodeInfo (CLabel _ _ _ nodeinfo) = nodeinfo
              nodeInfo (CCase _ _ nodeinfo) = nodeinfo
              nodeInfo (CCases _ _ _ nodeinfo) = nodeinfo
              nodeInfo (CDefault _ nodeinfo) = nodeinfo
              nodeInfo (CExpr _ nodeinfo) = nodeinfo
              nodeInfo (CCompound _ _ nodeinfo) = nodeinfo
              nodeInfo (CIf _ _ _ nodeinfo) = nodeinfo
              nodeInfo (CSwitch _ _ nodeinfo) = nodeinfo
              nodeInfo (CWhile _ _ _ nodeinfo) = nodeinfo
              nodeInfo (CFor _ _ _ _ nodeinfo) = nodeinfo
              nodeInfo (CGoto _ nodeinfo) = nodeinfo
              nodeInfo (CGotoPtr _ nodeinfo) = nodeinfo
              nodeInfo (CCont nodeinfo) = nodeinfo
              nodeInfo (CBreak nodeinfo) = nodeinfo
              nodeInfo (CReturn _ nodeinfo) = nodeinfo
              nodeInfo (CAsm _ nodeinfo) = nodeinfo
    instance Pos CStat
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CAsmStmt
        where nodeInfo (CAsmStmt _ _ _ _ _ nodeinfo) = nodeinfo
    instance Pos CAsmStmt
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CAsmOperand
        where nodeInfo (CAsmOperand _ _ _ nodeinfo) = nodeinfo
    instance Pos CAsmOperand
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CBlockItem
        where nodeInfo (CBlockStmt d) = nodeInfo d
              nodeInfo (CBlockDecl d) = nodeInfo d
              nodeInfo (CNestedFunDef d) = nodeInfo d
    instance Pos CBlockItem
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CDeclSpec
        where nodeInfo (CStorageSpec d) = nodeInfo d
              nodeInfo (CTypeSpec d) = nodeInfo d
              nodeInfo (CTypeQual d) = nodeInfo d
    instance Pos CDeclSpec
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CStorageSpec
        where nodeInfo (CAuto nodeinfo) = nodeinfo
              nodeInfo (CRegister nodeinfo) = nodeinfo
              nodeInfo (CStatic nodeinfo) = nodeinfo
              nodeInfo (CExtern nodeinfo) = nodeinfo
              nodeInfo (CTypedef nodeinfo) = nodeinfo
              nodeInfo (CThread nodeinfo) = nodeinfo
    instance Pos CStorageSpec
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CTypeSpec
        where nodeInfo (CVoidType nodeinfo) = nodeinfo
              nodeInfo (CCharType nodeinfo) = nodeinfo
              nodeInfo (CShortType nodeinfo) = nodeinfo
              nodeInfo (CIntType nodeinfo) = nodeinfo
              nodeInfo (CLongType nodeinfo) = nodeinfo
              nodeInfo (CFloatType nodeinfo) = nodeinfo
              nodeInfo (CDoubleType nodeinfo) = nodeinfo
              nodeInfo (CSignedType nodeinfo) = nodeinfo
              nodeInfo (CUnsigType nodeinfo) = nodeinfo
              nodeInfo (CBoolType nodeinfo) = nodeinfo
              nodeInfo (CComplexType nodeinfo) = nodeinfo
              nodeInfo (CSUType _ nodeinfo) = nodeinfo
              nodeInfo (CEnumType _ nodeinfo) = nodeinfo
              nodeInfo (CTypeDef _ nodeinfo) = nodeinfo
              nodeInfo (CTypeOfExpr _ nodeinfo) = nodeinfo
              nodeInfo (CTypeOfType _ nodeinfo) = nodeinfo
    instance Pos CTypeSpec
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CTypeQual
        where nodeInfo (CConstQual nodeinfo) = nodeinfo
              nodeInfo (CVolatQual nodeinfo) = nodeinfo
              nodeInfo (CRestrQual nodeinfo) = nodeinfo
              nodeInfo (CInlineQual nodeinfo) = nodeinfo
              nodeInfo (CAttrQual d) = nodeInfo d
    instance Pos CTypeQual
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CStructUnion
        where nodeInfo (CStruct _ _ _ _ nodeinfo) = nodeinfo
    instance Pos CStructUnion
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CEnum
        where nodeInfo (CEnum _ _ _ nodeinfo) = nodeinfo
    instance Pos CEnum
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CInit
        where nodeInfo (CInitExpr _ nodeinfo) = nodeinfo
              nodeInfo (CInitList _ nodeinfo) = nodeinfo
    instance Pos CInit
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CDesignator
        where nodeInfo (CArrDesig _ nodeinfo) = nodeinfo
              nodeInfo (CMemberDesig _ nodeinfo) = nodeinfo
              nodeInfo (CRangeDesig _ _ nodeinfo) = nodeinfo
    instance Pos CDesignator
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CAttr
        where nodeInfo (CAttr _ _ nodeinfo) = nodeinfo
    instance Pos CAttr
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CExpr
        where nodeInfo (CComma _ nodeinfo) = nodeinfo
              nodeInfo (CAssign _ _ _ nodeinfo) = nodeinfo
              nodeInfo (CCond _ _ _ nodeinfo) = nodeinfo
              nodeInfo (CBinary _ _ _ nodeinfo) = nodeinfo
              nodeInfo (CCast _ _ nodeinfo) = nodeinfo
              nodeInfo (CUnary _ _ nodeinfo) = nodeinfo
              nodeInfo (CSizeofExpr _ nodeinfo) = nodeinfo
              nodeInfo (CSizeofType _ nodeinfo) = nodeinfo
              nodeInfo (CAlignofExpr _ nodeinfo) = nodeinfo
              nodeInfo (CAlignofType _ nodeinfo) = nodeinfo
              nodeInfo (CComplexReal _ nodeinfo) = nodeinfo
              nodeInfo (CComplexImag _ nodeinfo) = nodeinfo
              nodeInfo (CIndex _ _ nodeinfo) = nodeinfo
              nodeInfo (CCall _ _ nodeinfo) = nodeinfo
              nodeInfo (CMember _ _ _ nodeinfo) = nodeinfo
              nodeInfo (CVar _ nodeinfo) = nodeinfo
              nodeInfo (CConst d) = nodeInfo d
              nodeInfo (CCompoundLit _ _ nodeinfo) = nodeinfo
              nodeInfo (CStatExpr _ nodeinfo) = nodeinfo
              nodeInfo (CLabAddrExpr _ nodeinfo) = nodeinfo
              nodeInfo (CBuiltinExpr d) = nodeInfo d
    instance Pos CExpr
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CBuiltin
        where nodeInfo (CBuiltinVaArg _ _ nodeinfo) = nodeinfo
              nodeInfo (CBuiltinOffsetOf _ _ nodeinfo) = nodeinfo
              nodeInfo (CBuiltinTypesCompatible _ _ nodeinfo) = nodeinfo
    instance Pos CBuiltin
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CConst
        where nodeInfo (CIntConst _ nodeinfo) = nodeinfo
              nodeInfo (CCharConst _ nodeinfo) = nodeinfo
              nodeInfo (CFloatConst _ nodeinfo) = nodeinfo
              nodeInfo (CStrConst _ nodeinfo) = nodeinfo
    instance Pos CConst
        where posOf x = posOfNode (nodeInfo x)

    instance CNode CStrLit
        where nodeInfo (CStrLit _ nodeinfo) = nodeinfo
    instance Pos CStrLit
        where posOf x = posOfNode (nodeInfo x)