--  C -> Haskell Compiler: Abstract Syntax for Header Files
--
--  Author : Manuel M T Chakravarty
--  Created: 7 March 99
--
--  Version $Revision: 1.10 $ from $Date: 2004/06/11 07:10:16 $
--
--  Copyright (c) [1999..2004] Manuel M T Chakravarty
--
--  This file is free software; you can redistribute it and/or modify
--  it under the terms of the GNU General Public License as published by
--  the Free Software Foundation; either version 2 of the License, or
--  (at your option) any later version.
--
--  This file is distributed in the hope that it will be useful,
--  but WITHOUT ANY WARRANTY; without even the implied warranty of
--  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--  GNU General Public License for more details.
--
--- DESCRIPTION ---------------------------------------------------------------
--
--  Abstract syntax of C header files.
--
--- DOCU ----------------------------------------------------------------------
--
--  language: Haskell 98
--
--  The tree structure corresponds to the grammar in Appendix A of K&R.  This
--  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.  This module
--  supports the C99 `restrict' extension
--  <http://www.lysator.liu.se/c/restrict.html>, `inline' functions, and also
--  the GNU C `alignof' extension.
--
--- TODO ----------------------------------------------------------------------
--

module CAST (CHeader(..), CExtDecl(..), CFunDef(..), CStat(..), CBlockItem(..),
             CDecl(..), CDeclSpec(..), CStorageSpec(..), CTypeSpec(..),
             CTypeQual(..), CStructUnion(..),  CStructTag(..), CEnum(..),
             CDeclr(..), CInit(..), CInitList, CDesignator(..), CExpr(..),
             CAssignOp(..), CBinaryOp(..), CUnaryOp(..), CConst (..))
where

import Position   (Position, Pos(posOf), nopos)
import Idents     (Ident)
import Attributes (Attrs)
import Binary     (Binary(..), putByte, getByte)


-- a complete C header file (K&R A10) (EXPORTED)
--
data CHeader = CHeader [CExtDecl]
                       Attrs

instance Pos CHeader where
  posOf :: CHeader -> Position
posOf (CHeader _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at

instance Eq CHeader where
  (CHeader _ at1 :: Attrs
at1) == :: CHeader -> CHeader -> Bool
== (CHeader _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2

-- external C declaration (K&R A10) (EXPORTED)
--
data CExtDecl = CDeclExt CDecl
              | CFDefExt CFunDef
              | CAsmExt  Attrs          -- a chunk of assembly code (which is
                                        -- not itself recorded)

instance Pos CExtDecl where
  posOf :: CExtDecl -> Position
posOf (CDeclExt decl :: CDecl
decl) = CDecl -> Position
forall a. Pos a => a -> Position
posOf CDecl
decl
  posOf (CFDefExt fdef :: CFunDef
fdef) = CFunDef -> Position
forall a. Pos a => a -> Position
posOf CFunDef
fdef
  posOf (CAsmExt at :: Attrs
at)    = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at

instance Eq CExtDecl where
  CDeclExt decl1 :: CDecl
decl1 == :: CExtDecl -> CExtDecl -> Bool
== CDeclExt decl2 :: CDecl
decl2 = CDecl
decl1 CDecl -> CDecl -> Bool
forall a. Eq a => a -> a -> Bool
== CDecl
decl2
  CFDefExt fdef1 :: CFunDef
fdef1 == CFDefExt fdef2 :: CFunDef
fdef2 = CFunDef
fdef1 CFunDef -> CFunDef -> Bool
forall a. Eq a => a -> a -> Bool
== CFunDef
fdef2
  CAsmExt at1 :: Attrs
at1    == CAsmExt at2 :: Attrs
at2    =   Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2

-- C function definition (K&R A10.1) (EXPORTED)
--
--  * The only type specifiers allowed are `extern' and `static'.
--
--  * The declarator must specify explicitly that the declared identifier has
--   function type.
--
--  * The optional declaration list is for old-style function declarations.
--
--  * The statement must be a compound statement.
--
data CFunDef = CFunDef [CDeclSpec]      -- type specifier and qualifier
                       CDeclr           -- declarator
                       [CDecl]          -- optional declaration list
                       CStat            -- compound statement
                       Attrs

instance Pos CFunDef where
  posOf :: CFunDef -> Position
posOf (CFunDef _ _ _ _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at

instance Eq CFunDef where
  CFunDef _ _ _ _ at1 :: Attrs
at1 == :: CFunDef -> CFunDef -> Bool
== CFunDef _ _ _ _ at2 :: Attrs
at2 = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2

-- C statement (A9) (EXPORTED)
--
data CStat = CLabel    Ident            -- label
                       CStat
                       Attrs
           | CCase     CExpr            -- constant expression
                       CStat
                       Attrs
           | CCases    CExpr            -- case range
                       CExpr            -- `case lower .. upper :'
                       CStat
                       Attrs
           | CDefault  CStat            -- default case
                       Attrs
           | CExpr     (Maybe CExpr)    -- expression statement, maybe empty
                       Attrs
           | CCompound [CBlockItem]     -- list of declarations and statements
                       Attrs
           | CIf       CExpr            -- conditional expression
                       CStat
                       (Maybe CStat)    -- optional "else" case
                       Attrs
           | CSwitch   CExpr            -- selector
                       CStat
                       Attrs
           | CWhile    CExpr
                       CStat
                       Bool             -- `True' implies "do-while" statement
                       Attrs
           | CFor      (Either (Maybe CExpr)
                               CDecl)
                       (Maybe CExpr)
                       (Maybe CExpr)
                       CStat
                       Attrs
           | CGoto     Ident            -- label
                       Attrs
           | CGotoPtr  CExpr            -- computed address
                       Attrs
           | CCont     Attrs            -- continue statement
           | CBreak    Attrs            -- break statement
           | CReturn   (Maybe CExpr)
                       Attrs
           | CAsm      Attrs            -- a chunk of assembly code (which is
                                        -- not itself recorded)

instance Pos CStat where
  posOf :: CStat -> Position
posOf (CLabel    _ _     at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CCase     _ _     at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CCases    _ _ _   at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CDefault  _       at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CExpr     _       at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CCompound _       at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CIf       _ _ _   at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CSwitch   _ _     at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CWhile    _ _ _   at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CFor      _ _ _ _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CGoto     _       at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CGotoPtr     _    at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CCont             at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CBreak            at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CReturn   _       at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CAsm              at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at

instance Eq CStat where
  (CLabel    _ _     at1 :: Attrs
at1) == :: CStat -> CStat -> Bool
== (CLabel    _ _     at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CCase     _ _     at1 :: Attrs
at1) == (CCase     _ _     at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CCases    _ _ _   at1 :: Attrs
at1) == (CCases    _ _ _   at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CDefault  _       at1 :: Attrs
at1) == (CDefault  _       at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CExpr     _       at1 :: Attrs
at1) == (CExpr     _       at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CCompound _       at1 :: Attrs
at1) == (CCompound _       at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CIf       _ _ _   at1 :: Attrs
at1) == (CIf       _ _ _   at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CSwitch   _ _     at1 :: Attrs
at1) == (CSwitch   _ _     at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CWhile    _ _ _   at1 :: Attrs
at1) == (CWhile    _ _ _   at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CFor      _ _ _ _ at1 :: Attrs
at1) == (CFor      _ _ _ _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CGoto     _       at1 :: Attrs
at1) == (CGoto     _       at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CGotoPtr  _       at1 :: Attrs
at1) == (CGotoPtr  _       at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CCont             at1 :: Attrs
at1) == (CCont             at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CBreak            at1 :: Attrs
at1) == (CBreak            at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CReturn   _       at1 :: Attrs
at1) == (CReturn   _       at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CAsm              at1 :: Attrs
at1) == (CAsm              at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2

-- C99 Block items, things that may appear in compound statements
data CBlockItem = CBlockStmt    CStat
                | CBlockDecl    CDecl
                | CNestedFunDef CFunDef         -- GNU C has nested functions

instance Pos CBlockItem where
  posOf :: CBlockItem -> Position
posOf (CBlockStmt stmt :: CStat
stmt)  = CStat -> Position
forall a. Pos a => a -> Position
posOf CStat
stmt
  posOf (CBlockDecl decl :: CDecl
decl)  = CDecl -> Position
forall a. Pos a => a -> Position
posOf CDecl
decl
  posOf (CNestedFunDef fdef :: CFunDef
fdef) = CFunDef -> Position
forall a. Pos a => a -> Position
posOf CFunDef
fdef

instance Eq CBlockItem where
  CBlockStmt    stmt1 :: CStat
stmt1 == :: CBlockItem -> CBlockItem -> Bool
== CBlockStmt    stmt2 :: CStat
stmt2 = CStat
stmt1 CStat -> CStat -> Bool
forall a. Eq a => a -> a -> Bool
== CStat
stmt2
  CBlockDecl    decl1 :: CDecl
decl1 == CBlockDecl    decl2 :: CDecl
decl2 = CDecl
decl1 CDecl -> CDecl -> Bool
forall a. Eq a => a -> a -> Bool
== CDecl
decl2
  CNestedFunDef fdef1 :: CFunDef
fdef1 == CNestedFunDef fdef2 :: CFunDef
fdef2 = CFunDef
fdef1 CFunDef -> CFunDef -> Bool
forall a. Eq a => a -> a -> Bool
== CFunDef
fdef2


-- C declaration (K&R A8), structure declaration (K&R A8.3), parameter
-- declaration (K&R A8.6.3), and type name (K&R A8.8) (EXPORTED) 
--
--  * Toplevel declarations (K&R A8): 
--
--   - they require that the type specifier and qualifier list is not empty,
--     but gcc allows it and just issues a warning; for the time being, we
--     also allow it;
--   - at most one storage class specifier is allowed per declaration;
--   - declarators must be present and size expressions are not allowed, ie,
--     the elements of K&R's init-declarator-list are represented by triples
--     of the form `(Just declr, oinit, Nothing)', where `oinit' maybe
--     `Nothing' or `Just init'; and
--   - abstract declarators are not allowed.
--
--  * Structure declarations (K&R A8.3):
--
--   - do not allow storage specifiers;
--   - do not allow initializers; 
--   - require a non-empty declarator-triple list, where abstract declarators 
--     are not allowed; and
--   - each of the declarator-triples has to contain either a declarator or a
--     size expression, or both, ie, it has the form `(Just decl, Nothing,
--     Nothing)', `(Nothing, Nothing, Just size)', or `(Just decl, Nothing,
--     Just size)'.
--
--  * Parameter declarations (K&R A8.6.3):
--
--   - allow neither initializers nor size expressions;
--   - allow at most one declarator triple of the form `(Just declr, Nothing, 
--     Nothing)' (in case of an empty declarator, the list must be empty); and
--   - allow abstract declarators.
--
--  * Type names (A8.8):
--
--   - do not allow storage specifiers;
--   - allow neither initializers nor size expressions; and
--   - allow at most one declarator triple of the form `(Just declr, Nothing, 
--     Nothing)' (in case of an empty declarator, the list must be empty),
--     where the declarator must be abstract, ie, must not contain a declared
--     identifier. 
--
data CDecl = CDecl [CDeclSpec]          -- type specifier and qualifier
                   [(Maybe CDeclr,      -- declarator (may be omitted)
                     Maybe CInit,       -- optional initializer
                     Maybe CExpr)]      -- optional size (const expr)
                   Attrs

instance Pos CDecl where
  posOf :: CDecl -> Position
posOf (CDecl _ _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at

instance Eq CDecl where
  (CDecl _ _ at1 :: Attrs
at1) == :: CDecl -> CDecl -> Bool
== (CDecl _ _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2

-- C declaration specifiers and qualifiers (EXPORTED)
--
data CDeclSpec = CStorageSpec CStorageSpec
               | CTypeSpec    CTypeSpec
               | CTypeQual    CTypeQual
               deriving (CDeclSpec -> CDeclSpec -> Bool
(CDeclSpec -> CDeclSpec -> Bool)
-> (CDeclSpec -> CDeclSpec -> Bool) -> Eq CDeclSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CDeclSpec -> CDeclSpec -> Bool
$c/= :: CDeclSpec -> CDeclSpec -> Bool
== :: CDeclSpec -> CDeclSpec -> Bool
$c== :: CDeclSpec -> CDeclSpec -> Bool
Eq)

instance Pos CDeclSpec where
  posOf :: CDeclSpec -> Position
posOf (CStorageSpec sspec :: CStorageSpec
sspec) = CStorageSpec -> Position
forall a. Pos a => a -> Position
posOf CStorageSpec
sspec
  posOf (CTypeSpec    tspec :: CTypeSpec
tspec) = CTypeSpec -> Position
forall a. Pos a => a -> Position
posOf CTypeSpec
tspec
  posOf (CTypeQual    tqual :: CTypeQual
tqual) = CTypeQual -> Position
forall a. Pos a => a -> Position
posOf CTypeQual
tqual

-- C storage class specifier (K&R A8.1) (EXPORTED)
--
data CStorageSpec = CAuto     Attrs
                  | CRegister Attrs
                  | CStatic   Attrs
                  | CExtern   Attrs
                  | CTypedef  Attrs     -- syntactic awkwardness of C
                  | CThread   Attrs     -- GNUC thread local storage

instance Pos CStorageSpec where
  posOf :: CStorageSpec -> Position
posOf (CAuto     at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CRegister at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CStatic   at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CExtern   at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CTypedef  at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CThread   at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at

instance Eq CStorageSpec where
  (CAuto     at1 :: Attrs
at1) == :: CStorageSpec -> CStorageSpec -> Bool
== (CAuto     at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CRegister at1 :: Attrs
at1) == (CRegister at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CStatic   at1 :: Attrs
at1) == (CStatic   at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CExtern   at1 :: Attrs
at1) == (CExtern   at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CTypedef  at1 :: Attrs
at1) == (CTypedef  at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CThread   at1 :: Attrs
at1) == (CThread   at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2

-- C type specifier (K&R A8.2) (EXPORTED)
--
data CTypeSpec = CVoidType    Attrs
               | CCharType    Attrs
               | CShortType   Attrs
               | CIntType     Attrs
               | CLongType    Attrs
               | CFloatType   Attrs
               | CFloat128Type Attrs
               | CDoubleType  Attrs
               | CSignedType  Attrs
               | CUnsigType   Attrs
               | CBoolType    Attrs
               | CComplexType Attrs
               | CSUType      CStructUnion
                              Attrs
               | CEnumType    CEnum
                              Attrs
               | CTypeDef     Ident             -- typedef name
                              Attrs
               | CTypeOfExpr  CExpr
                              Attrs
               | CTypeOfType  CDecl
                              Attrs

instance Pos CTypeSpec where
  posOf :: CTypeSpec -> Position
posOf (CVoidType      at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CCharType      at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CShortType     at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CIntType       at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CLongType      at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CFloatType     at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CFloat128Type  at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CDoubleType    at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CSignedType    at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CUnsigType     at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CBoolType      at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CComplexType   at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CSUType     _  at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CEnumType   _  at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CTypeDef    _  at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CTypeOfExpr _  at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CTypeOfType _  at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at

instance Eq CTypeSpec where
  (CVoidType     at1 :: Attrs
at1) == :: CTypeSpec -> CTypeSpec -> Bool
== (CVoidType     at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CCharType     at1 :: Attrs
at1) == (CCharType     at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CShortType    at1 :: Attrs
at1) == (CShortType    at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CIntType      at1 :: Attrs
at1) == (CIntType      at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CLongType     at1 :: Attrs
at1) == (CLongType     at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CFloatType    at1 :: Attrs
at1) == (CFloatType    at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CFloat128Type at1 :: Attrs
at1) == (CFloat128Type at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CDoubleType   at1 :: Attrs
at1) == (CDoubleType   at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CSignedType   at1 :: Attrs
at1) == (CSignedType   at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CUnsigType    at1 :: Attrs
at1) == (CUnsigType    at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CBoolType     at1 :: Attrs
at1) == (CBoolType     at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CComplexType  at1 :: Attrs
at1) == (CComplexType  at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CSUType     _ at1 :: Attrs
at1) == (CSUType     _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CEnumType   _ at1 :: Attrs
at1) == (CEnumType   _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CTypeDef    _ at1 :: Attrs
at1) == (CTypeDef    _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CTypeOfExpr _ at1 :: Attrs
at1) == (CTypeOfExpr _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CTypeOfType _ at1 :: Attrs
at1) == (CTypeOfType _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2

-- C type qualifier (K&R A8.2) (EXPORTED)
--
--  * plus `restrict' from C99 and `inline'
--
data CTypeQual = CConstQual Attrs
               | CVolatQual Attrs
               | CRestrQual Attrs
               | CInlinQual Attrs

instance Pos CTypeQual where
 posOf :: CTypeQual -> Position
posOf (CConstQual at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
 posOf (CVolatQual at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
 posOf (CRestrQual at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
 posOf (CInlinQual at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at

instance Eq CTypeQual where
  (CConstQual at1 :: Attrs
at1) == :: CTypeQual -> CTypeQual -> Bool
== (CConstQual at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CVolatQual at1 :: Attrs
at1) == (CVolatQual at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CRestrQual at1 :: Attrs
at1) == (CRestrQual at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CInlinQual at1 :: Attrs
at1) == (CInlinQual at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2

-- C structure of union declaration (K&R A8.3) (EXPORTED)
--
--  * in both case, either the identifier is present or the list must be
--   non-empty 
--
data CStructUnion = CStruct CStructTag
                            (Maybe Ident)
                            [CDecl]     --  *structure* declaration
                            Attrs

instance Pos CStructUnion where
  posOf :: CStructUnion -> Position
posOf (CStruct _ _ _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at

instance Eq CStructUnion where
  (CStruct _ _ _ at1 :: Attrs
at1) == :: CStructUnion -> CStructUnion -> Bool
== (CStruct _ _ _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2

-- (EXPORTED)
--
data CStructTag = CStructTag
                | CUnionTag
                deriving (CStructTag -> CStructTag -> Bool
(CStructTag -> CStructTag -> Bool)
-> (CStructTag -> CStructTag -> Bool) -> Eq CStructTag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CStructTag -> CStructTag -> Bool
$c/= :: CStructTag -> CStructTag -> Bool
== :: CStructTag -> CStructTag -> Bool
$c== :: CStructTag -> CStructTag -> Bool
Eq)

-- C enumeration declaration (K&R A8.4) (EXPORTED)
--
data CEnum = CEnum (Maybe Ident)
                   [(Ident,                     -- variant name
                     Maybe CExpr)]              -- explicit variant value
                   Attrs

instance Pos CEnum where
  posOf :: CEnum -> Position
posOf (CEnum _ _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at

instance Eq CEnum where
  (CEnum _ _ at1 :: Attrs
at1) == :: CEnum -> CEnum -> Bool
== (CEnum _ _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2

-- C declarator (K&R A8.5) and abstract declarator (K&R A8.8) (EXPORTED)
--
--  * We have one type qualifer list `[CTypeQual]' for each indirection (ie,
--   each occurrence of `*' in the concrete syntax).
--
--  * We unfold K&R's direct-declarators nonterminal into declarators.  Note
--   that `*(*x)' is equivalent to `**x'.
--
--  * Declarators (A8.5) and abstract declarators (A8.8) are represented in the 
--   same structure.  In the case of a declarator, the identifier in
--   `CVarDeclr' must be present; in an abstract declarator it misses.
--   `CVarDeclr Nothing ...' on its own is meaningless, it may only occur as
--   part of a larger type (ie, there must be a pointer, an array, or function
--   declarator around).
--
--  * The qualifiers list in a `CPtrDeclr' may not be empty.
--
--  * Old and new style function definitions are merged into a single case
--   `CFunDeclr'.  In case of an old style definition, the parameter list is
--   empty and the variadic flag is `False' (ie, the parameter names are not
--   stored in the tree).  Remember, a new style definition with no parameters 
--   requires a single `void' in the argument list (according to the standard).
--
--  * We unfold K&R's parameter-type-list nonterminal into the declarator
--   variant for functions.
--
data CDeclr = CVarDeclr (Maybe Ident)           -- declared identifier
                        Attrs
            | CPtrDeclr [CTypeQual]             -- indirections
                        CDeclr
                        Attrs
            | CArrDeclr CDeclr
                        [CTypeQual]
                        (Maybe CExpr)           -- array size
                        Attrs
            | CFunDeclr CDeclr
                        [CDecl]                 --  *parameter* declarations
                        Bool                    -- is variadic?
                        Attrs

instance Pos CDeclr where
  posOf :: CDeclr -> Position
posOf (CVarDeclr _     at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CPtrDeclr _ _   at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CArrDeclr _ _ _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CFunDeclr _ _ _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at

instance Eq CDeclr where
  (CVarDeclr _     at1 :: Attrs
at1) == :: CDeclr -> CDeclr -> Bool
== (CVarDeclr _     at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CPtrDeclr _ _   at1 :: Attrs
at1) == (CPtrDeclr _ _   at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CArrDeclr _ _ _ at1 :: Attrs
at1) == (CArrDeclr _ _ _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CFunDeclr _ _ _ at1 :: Attrs
at1) == (CFunDeclr _ _ _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2

-- C initializer (K&R A8.7) (EXPORTED)
--
data CInit = CInitExpr CExpr
                       Attrs            -- assignment expression
           | CInitList CInitList
                       Attrs

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

instance Pos CInit where
  posOf :: CInit -> Position
posOf (CInitExpr _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CInitList _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at

instance Eq CInit where
  (CInitExpr _ at1 :: Attrs
at1) == :: CInit -> CInit -> Bool
== (CInitExpr _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CInitList _ at1 :: Attrs
at1) == (CInitList _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2

-- C initializer designator (EXPORTED)
--
data CDesignator = CArrDesig     CExpr
                                 Attrs
                 | CMemberDesig  Ident
                                 Attrs
                 | CRangeDesig   CExpr  -- GNUC array range designator
                                 CExpr
                                 Attrs

instance Pos CDesignator where
  posOf :: CDesignator -> Position
posOf (CArrDesig     _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CMemberDesig  _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CRangeDesig _ _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at

instance Eq CDesignator where
  (CArrDesig     _ at1 :: Attrs
at1) == :: CDesignator -> CDesignator -> Bool
== (CArrDesig     _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CMemberDesig  _ at1 :: Attrs
at1) == (CMemberDesig  _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CRangeDesig _ _ at1 :: Attrs
at1) == (CRangeDesig _ _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2

-- C expression (K&R A7) (EXPORTED)
--
--  * these can be arbitrary expression, as the argument of `sizeof' can be
--   arbitrary, even if appearing in a constant expression
--
--  * GNU C extension: `alignof'
--
data CExpr = CComma       [CExpr]       -- comma expression list, n >= 2
                          Attrs
           | CAssign      CAssignOp     -- assignment operator
                          CExpr         -- l-value
                          CExpr         -- r-value
                          Attrs
           | CCond        CExpr         -- conditional
                   (Maybe CExpr)        -- true-expression (GNU allows omitting)
                          CExpr         -- false-expression
                          Attrs
           | CBinary      CBinaryOp     -- binary operator
                          CExpr         -- lhs
                          CExpr         -- rhs
                          Attrs
           | CCast        CDecl         -- type name
                          CExpr
                          Attrs
           | CUnary       CUnaryOp      -- unary operator
                          CExpr
                          Attrs
           | CSizeofExpr  CExpr
                          Attrs
           | CSizeofType  CDecl         -- type name
                          Attrs
           | CAlignofExpr CExpr
                          Attrs
           | CAlignofType CDecl         -- type name
                          Attrs
           | CIndex       CExpr         -- array
                          CExpr         -- index
                          Attrs
           | CCall        CExpr         -- function
                          [CExpr]       -- arguments
                          Attrs
           | CMember      CExpr         -- structure
                          Ident         -- member name
                          Bool          -- deref structure? (True for `->')
                          Attrs
           | CVar         Ident         -- identifier (incl. enumeration const)
                          Attrs
           | CConst       CConst                -- includes strings
                          Attrs
           | CCompoundLit CDecl         -- C99 compound literal
                          CInitList     -- type name & initialiser list
                          Attrs
           | CStatExpr    CStat         -- GNUC compound statement as expr
                          Attrs
           | CLabAddrExpr Ident         -- GNUC address of label
                          Attrs
           | CBuiltinExpr Attrs         -- place holder for GNUC builtin exprs

instance Pos CExpr where
  posOf :: CExpr -> Position
posOf (CComma       _     at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CAssign      _ _ _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CCond        _ _ _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CBinary      _ _ _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CCast        _ _   at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CUnary       _ _   at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CSizeofExpr  _     at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CSizeofType  _     at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CAlignofExpr _     at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CAlignofType _     at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CIndex       _ _   at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CCall        _ _   at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CMember      _ _ _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CVar         _     at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CConst       _     at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CCompoundLit _ _   at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CStatExpr    _     at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CLabAddrExpr _     at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CBuiltinExpr       at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at

instance Eq CExpr where
  (CComma       _     at1 :: Attrs
at1) == :: CExpr -> CExpr -> Bool
== (CComma       _     at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CAssign      _ _ _ at1 :: Attrs
at1) == (CAssign      _ _ _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CCond        _ _ _ at1 :: Attrs
at1) == (CCond        _ _ _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CBinary      _ _ _ at1 :: Attrs
at1) == (CBinary      _ _ _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CCast        _ _   at1 :: Attrs
at1) == (CCast        _ _   at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CUnary       _ _   at1 :: Attrs
at1) == (CUnary       _ _   at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CSizeofExpr  _     at1 :: Attrs
at1) == (CSizeofExpr  _     at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CSizeofType  _     at1 :: Attrs
at1) == (CSizeofType  _     at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CAlignofExpr _     at1 :: Attrs
at1) == (CAlignofExpr _     at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CAlignofType _     at1 :: Attrs
at1) == (CAlignofType _     at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CIndex       _ _   at1 :: Attrs
at1) == (CIndex       _ _   at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CCall        _ _   at1 :: Attrs
at1) == (CCall        _ _   at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CMember      _ _ _ at1 :: Attrs
at1) == (CMember      _ _ _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CVar         _     at1 :: Attrs
at1) == (CVar         _     at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CConst       _     at1 :: Attrs
at1) == (CConst       _     at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CCompoundLit _ _   at1 :: Attrs
at1) == (CCompoundLit _ _   at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CStatExpr    _     at1 :: Attrs
at1) == (CStatExpr    _     at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CLabAddrExpr _     at1 :: Attrs
at1) == (CLabAddrExpr _     at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CBuiltinExpr       at1 :: Attrs
at1) == (CBuiltinExpr       at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2

-- C assignment operators (K&R A7.17) (EXPORTED)
--
data CAssignOp = CAssignOp
               | CMulAssOp
               | CDivAssOp
               | CRmdAssOp              -- remainder and assignment
               | CAddAssOp
               | CSubAssOp
               | CShlAssOp
               | CShrAssOp
               | CAndAssOp
               | CXorAssOp
               | COrAssOp
               deriving (CAssignOp -> CAssignOp -> Bool
(CAssignOp -> CAssignOp -> Bool)
-> (CAssignOp -> CAssignOp -> Bool) -> Eq CAssignOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CAssignOp -> CAssignOp -> Bool
$c/= :: CAssignOp -> CAssignOp -> Bool
== :: CAssignOp -> CAssignOp -> Bool
$c== :: CAssignOp -> CAssignOp -> Bool
Eq)

-- C binary operators (K&R A7.6-15) (EXPORTED)
--
data CBinaryOp = 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
               deriving (CBinaryOp -> CBinaryOp -> Bool
(CBinaryOp -> CBinaryOp -> Bool)
-> (CBinaryOp -> CBinaryOp -> Bool) -> Eq CBinaryOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CBinaryOp -> CBinaryOp -> Bool
$c/= :: CBinaryOp -> CBinaryOp -> Bool
== :: CBinaryOp -> CBinaryOp -> Bool
$c== :: CBinaryOp -> CBinaryOp -> Bool
Eq)

-- C unary operator (K&R A7.3-4) (EXPORTED)
--
data CUnaryOp = 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
              deriving (CUnaryOp -> CUnaryOp -> Bool
(CUnaryOp -> CUnaryOp -> Bool)
-> (CUnaryOp -> CUnaryOp -> Bool) -> Eq CUnaryOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CUnaryOp -> CUnaryOp -> Bool
$c/= :: CUnaryOp -> CUnaryOp -> Bool
== :: CUnaryOp -> CUnaryOp -> Bool
$c== :: CUnaryOp -> CUnaryOp -> Bool
Eq)

-- C constant (K&R A2.5 & A7.2) (EXPORTED)
--
--  * we do not list enumeration constants here, as they are identifiers
--
data CConst = CIntConst   Integer
                          Attrs
            | CCharConst  Char
                          Attrs
            | CFloatConst String
                          Attrs
            | CStrConst   String
                          Attrs

instance Pos CConst where
  posOf :: CConst -> Position
posOf (CIntConst   _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CCharConst  _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CFloatConst _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at
  posOf (CStrConst   _ at :: Attrs
at) = Attrs -> Position
forall a. Pos a => a -> Position
posOf Attrs
at

instance Eq CConst where
  (CIntConst   _ at1 :: Attrs
at1) == :: CConst -> CConst -> Bool
== (CIntConst   _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CCharConst  _ at1 :: Attrs
at1) == (CCharConst  _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CFloatConst _ at1 :: Attrs
at1) == (CFloatConst _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2
  (CStrConst   _ at1 :: Attrs
at1) == (CStrConst   _ at2 :: Attrs
at2) = Attrs
at1 Attrs -> Attrs -> Bool
forall a. Eq a => a -> a -> Bool
== Attrs
at2


{-! for CDecl derive : GhcBinary !-}
{-! for CEnum derive : GhcBinary !-}
{-! for CStructUnion derive : GhcBinary !-}
{-! for CStructTag derive : GhcBinary !-}
{-! for CExpr derive : GhcBinary !-}
{-! for CInit derive : GhcBinary !-}
{-! for CDeclr derive : GhcBinary !-}
{-! for CDeclSpec derive : GhcBinary !-}
{-! for CTypeSpec derive : GhcBinary !-}
{-! for CStorageSpec derive : GhcBinary !-}
{-! for CTypeQual derive : GhcBinary !-}
{-! for CConst derive : GhcBinary !-}
{-! for CUnaryOp derive : GhcBinary !-}
{-! for CBinaryOp derive : GhcBinary !-}
{-! for CAssignOp derive : GhcBinary !-}
{-* Generated by DrIFT : Look, but Don't Touch. *-}
instance Binary CDecl where
    put_ :: BinHandle -> CDecl -> IO ()
put_ bh :: BinHandle
bh (CDecl aa :: [CDeclSpec]
aa ab :: [(Maybe CDeclr, Maybe CInit, Maybe CExpr)]
ab ac :: Attrs
ac) = do
            BinHandle -> [CDeclSpec] -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh [CDeclSpec]
aa
            BinHandle -> [(Maybe CDeclr, Maybe CInit, Maybe CExpr)] -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh [(Maybe CDeclr, Maybe CInit, Maybe CExpr)]
ab
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ac
    get :: BinHandle -> IO CDecl
get bh :: BinHandle
bh = do
    [CDeclSpec]
aa <- BinHandle -> IO [CDeclSpec]
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
    [(Maybe CDeclr, Maybe CInit, Maybe CExpr)]
ab <- BinHandle -> IO [(Maybe CDeclr, Maybe CInit, Maybe CExpr)]
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
    Attrs
ac <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
    CDecl -> IO CDecl
forall (m :: * -> *) a. Monad m => a -> m a
return ([CDeclSpec]
-> [(Maybe CDeclr, Maybe CInit, Maybe CExpr)] -> Attrs -> CDecl
CDecl [CDeclSpec]
aa [(Maybe CDeclr, Maybe CInit, Maybe CExpr)]
ab Attrs
ac)

instance Binary CEnum where
    put_ :: BinHandle -> CEnum -> IO ()
put_ bh :: BinHandle
bh (CEnum aa :: Maybe Ident
aa ab :: [(Ident, Maybe CExpr)]
ab ac :: Attrs
ac) = do
            BinHandle -> Maybe Ident -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Maybe Ident
aa
            BinHandle -> [(Ident, Maybe CExpr)] -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh [(Ident, Maybe CExpr)]
ab
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ac
    get :: BinHandle -> IO CEnum
get bh :: BinHandle
bh = do
    Maybe Ident
aa <- BinHandle -> IO (Maybe Ident)
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
    [(Ident, Maybe CExpr)]
ab <- BinHandle -> IO [(Ident, Maybe CExpr)]
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
    Attrs
ac <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
    CEnum -> IO CEnum
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Ident -> [(Ident, Maybe CExpr)] -> Attrs -> CEnum
CEnum Maybe Ident
aa [(Ident, Maybe CExpr)]
ab Attrs
ac)

instance Binary CStructUnion where
    put_ :: BinHandle -> CStructUnion -> IO ()
put_ bh :: BinHandle
bh (CStruct aa :: CStructTag
aa ab :: Maybe Ident
ab ac :: [CDecl]
ac ad :: Attrs
ad) = do
            BinHandle -> CStructTag -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CStructTag
aa
            BinHandle -> Maybe Ident -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Maybe Ident
ab
            BinHandle -> [CDecl] -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh [CDecl]
ac
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ad
    get :: BinHandle -> IO CStructUnion
get bh :: BinHandle
bh = do
    CStructTag
aa <- BinHandle -> IO CStructTag
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
    Maybe Ident
ab <- BinHandle -> IO (Maybe Ident)
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
    [CDecl]
ac <- BinHandle -> IO [CDecl]
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
    Attrs
ad <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
    CStructUnion -> IO CStructUnion
forall (m :: * -> *) a. Monad m => a -> m a
return (CStructTag -> Maybe Ident -> [CDecl] -> Attrs -> CStructUnion
CStruct CStructTag
aa Maybe Ident
ab [CDecl]
ac Attrs
ad)

instance Binary CStructTag where
    put_ :: BinHandle -> CStructTag -> IO ()
put_ bh :: BinHandle
bh CStructTag = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 0
    put_ bh :: BinHandle
bh CUnionTag = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 1
    get :: BinHandle -> IO CStructTag
get bh :: BinHandle
bh = do
            Word8
h <- BinHandle -> IO Word8
getByte BinHandle
bh
            case Word8
h of
              0 -> do
                    CStructTag -> IO CStructTag
forall (m :: * -> *) a. Monad m => a -> m a
return CStructTag
CStructTag
              1 -> do
                    CStructTag -> IO CStructTag
forall (m :: * -> *) a. Monad m => a -> m a
return CStructTag
CUnionTag

instance Binary CExpr where
    put_ :: BinHandle -> CExpr -> IO ()
put_ bh :: BinHandle
bh (CComma aa :: [CExpr]
aa ab :: Attrs
ab) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 0
            BinHandle -> [CExpr] -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh [CExpr]
aa
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ab
    put_ bh :: BinHandle
bh (CAssign ac :: CAssignOp
ac ad :: CExpr
ad ae :: CExpr
ae af :: Attrs
af) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 1
            BinHandle -> CAssignOp -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CAssignOp
ac
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
ad
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
ae
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
af
    put_ bh :: BinHandle
bh (CCond ag :: CExpr
ag ah :: Maybe CExpr
ah ai :: CExpr
ai aj :: Attrs
aj) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 2
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
ag
            BinHandle -> Maybe CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Maybe CExpr
ah
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
ai
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
aj
    put_ bh :: BinHandle
bh (CBinary ak :: CBinaryOp
ak al :: CExpr
al am :: CExpr
am an :: Attrs
an) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 3
            BinHandle -> CBinaryOp -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CBinaryOp
ak
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
al
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
am
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
an
    put_ bh :: BinHandle
bh (CCast ao :: CDecl
ao ap :: CExpr
ap aq :: Attrs
aq) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 4
            BinHandle -> CDecl -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CDecl
ao
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
ap
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
aq
    put_ bh :: BinHandle
bh (CUnary ar :: CUnaryOp
ar as :: CExpr
as at :: Attrs
at) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 5
            BinHandle -> CUnaryOp -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CUnaryOp
ar
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
as
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
at
    put_ bh :: BinHandle
bh (CSizeofExpr au :: CExpr
au av :: Attrs
av) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 6
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
au
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
av
    put_ bh :: BinHandle
bh (CSizeofType aw :: CDecl
aw ax :: Attrs
ax) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 7
            BinHandle -> CDecl -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CDecl
aw
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ax
    put_ bh :: BinHandle
bh (CAlignofExpr ay :: CExpr
ay az :: Attrs
az) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 8
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
ay
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
az
    put_ bh :: BinHandle
bh (CAlignofType aA :: CDecl
aA aB :: Attrs
aB) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 9
            BinHandle -> CDecl -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CDecl
aA
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
aB
    put_ bh :: BinHandle
bh (CIndex aC :: CExpr
aC aD :: CExpr
aD aE :: Attrs
aE) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 10
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
aC
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
aD
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
aE
    put_ bh :: BinHandle
bh (CCall aF :: CExpr
aF aG :: [CExpr]
aG aH :: Attrs
aH) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 11
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
aF
            BinHandle -> [CExpr] -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh [CExpr]
aG
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
aH
    put_ bh :: BinHandle
bh (CMember aI :: CExpr
aI aJ :: Ident
aJ aK :: Bool
aK aL :: Attrs
aL) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 12
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
aI
            BinHandle -> Ident -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Ident
aJ
            BinHandle -> Bool -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Bool
aK
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
aL
    put_ bh :: BinHandle
bh (CVar aM :: Ident
aM aN :: Attrs
aN) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 13
            BinHandle -> Ident -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Ident
aM
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
aN
    put_ bh :: BinHandle
bh (CConst aO :: CConst
aO aP :: Attrs
aP) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 14
            BinHandle -> CConst -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CConst
aO
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
aP
    get :: BinHandle -> IO CExpr
get bh :: BinHandle
bh = do
            Word8
h <- BinHandle -> IO Word8
getByte BinHandle
bh
            case Word8
h of
              0 -> do
                    [CExpr]
aa <- BinHandle -> IO [CExpr]
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
ab <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr -> IO CExpr
forall (m :: * -> *) a. Monad m => a -> m a
return ([CExpr] -> Attrs -> CExpr
CComma [CExpr]
aa Attrs
ab)
              1 -> do
                    CAssignOp
ac <- BinHandle -> IO CAssignOp
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr
ad <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr
ae <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
af <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr -> IO CExpr
forall (m :: * -> *) a. Monad m => a -> m a
return (CAssignOp -> CExpr -> CExpr -> Attrs -> CExpr
CAssign CAssignOp
ac CExpr
ad CExpr
ae Attrs
af)
              2 -> do
                    CExpr
ag <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Maybe CExpr
ah <- BinHandle -> IO (Maybe CExpr)
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr
ai <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
aj <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr -> IO CExpr
forall (m :: * -> *) a. Monad m => a -> m a
return (CExpr -> Maybe CExpr -> CExpr -> Attrs -> CExpr
CCond CExpr
ag Maybe CExpr
ah CExpr
ai Attrs
aj)
              3 -> do
                    CBinaryOp
ak <- BinHandle -> IO CBinaryOp
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr
al <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr
am <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
an <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr -> IO CExpr
forall (m :: * -> *) a. Monad m => a -> m a
return (CBinaryOp -> CExpr -> CExpr -> Attrs -> CExpr
CBinary CBinaryOp
ak CExpr
al CExpr
am Attrs
an)
              4 -> do
                    CDecl
ao <- BinHandle -> IO CDecl
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr
ap <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
aq <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr -> IO CExpr
forall (m :: * -> *) a. Monad m => a -> m a
return (CDecl -> CExpr -> Attrs -> CExpr
CCast CDecl
ao CExpr
ap Attrs
aq)
              5 -> do
                    CUnaryOp
ar <- BinHandle -> IO CUnaryOp
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr
as <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
at <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr -> IO CExpr
forall (m :: * -> *) a. Monad m => a -> m a
return (CUnaryOp -> CExpr -> Attrs -> CExpr
CUnary CUnaryOp
ar CExpr
as Attrs
at)
              6 -> do
                    CExpr
au <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
av <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr -> IO CExpr
forall (m :: * -> *) a. Monad m => a -> m a
return (CExpr -> Attrs -> CExpr
CSizeofExpr CExpr
au Attrs
av)
              7 -> do
                    CDecl
aw <- BinHandle -> IO CDecl
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
ax <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr -> IO CExpr
forall (m :: * -> *) a. Monad m => a -> m a
return (CDecl -> Attrs -> CExpr
CSizeofType CDecl
aw Attrs
ax)
              8 -> do
                    CExpr
ay <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
az <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr -> IO CExpr
forall (m :: * -> *) a. Monad m => a -> m a
return (CExpr -> Attrs -> CExpr
CAlignofExpr CExpr
ay Attrs
az)
              9 -> do
                    CDecl
aA <- BinHandle -> IO CDecl
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
aB <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr -> IO CExpr
forall (m :: * -> *) a. Monad m => a -> m a
return (CDecl -> Attrs -> CExpr
CAlignofType CDecl
aA Attrs
aB)
              10 -> do
                    CExpr
aC <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr
aD <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
aE <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr -> IO CExpr
forall (m :: * -> *) a. Monad m => a -> m a
return (CExpr -> CExpr -> Attrs -> CExpr
CIndex CExpr
aC CExpr
aD Attrs
aE)
              11 -> do
                    CExpr
aF <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    [CExpr]
aG <- BinHandle -> IO [CExpr]
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
aH <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr -> IO CExpr
forall (m :: * -> *) a. Monad m => a -> m a
return (CExpr -> [CExpr] -> Attrs -> CExpr
CCall CExpr
aF [CExpr]
aG Attrs
aH)
              12 -> do
                    CExpr
aI <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Ident
aJ <- BinHandle -> IO Ident
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Bool
aK <- BinHandle -> IO Bool
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
aL <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr -> IO CExpr
forall (m :: * -> *) a. Monad m => a -> m a
return (CExpr -> Ident -> Bool -> Attrs -> CExpr
CMember CExpr
aI Ident
aJ Bool
aK Attrs
aL)
              13 -> do
                    Ident
aM <- BinHandle -> IO Ident
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
aN <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr -> IO CExpr
forall (m :: * -> *) a. Monad m => a -> m a
return (Ident -> Attrs -> CExpr
CVar Ident
aM Attrs
aN)
              14 -> do
                    CConst
aO <- BinHandle -> IO CConst
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
aP <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr -> IO CExpr
forall (m :: * -> *) a. Monad m => a -> m a
return (CConst -> Attrs -> CExpr
CConst CConst
aO Attrs
aP)

instance Binary CInit where
    put_ :: BinHandle -> CInit -> IO ()
put_ bh :: BinHandle
bh (CInitExpr aa :: CExpr
aa ab :: Attrs
ab) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 0
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
aa
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ab
    put_ bh :: BinHandle
bh (CInitList ac :: CInitList
ac ad :: Attrs
ad) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 1
            BinHandle -> CInitList -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CInitList
ac
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ad
    get :: BinHandle -> IO CInit
get bh :: BinHandle
bh = do
            Word8
h <- BinHandle -> IO Word8
getByte BinHandle
bh
            case Word8
h of
              0 -> do
                    CExpr
aa <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
ab <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CInit -> IO CInit
forall (m :: * -> *) a. Monad m => a -> m a
return (CExpr -> Attrs -> CInit
CInitExpr CExpr
aa Attrs
ab)
              1 -> do
                    CInitList
ac <- BinHandle -> IO CInitList
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
ad <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CInit -> IO CInit
forall (m :: * -> *) a. Monad m => a -> m a
return (CInitList -> Attrs -> CInit
CInitList CInitList
ac Attrs
ad)

instance Binary CDesignator where
    put_ :: BinHandle -> CDesignator -> IO ()
put_ bh :: BinHandle
bh (CArrDesig aa :: CExpr
aa ab :: Attrs
ab) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 0
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
aa
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ab
    put_ bh :: BinHandle
bh (CMemberDesig ac :: Ident
ac ad :: Attrs
ad) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 1
            BinHandle -> Ident -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Ident
ac
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ad
    put_ bh :: BinHandle
bh (CRangeDesig ae :: CExpr
ae af :: CExpr
af ag :: Attrs
ag) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 2
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
ae
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
af
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ag
    get :: BinHandle -> IO CDesignator
get bh :: BinHandle
bh = do
            Word8
h <- BinHandle -> IO Word8
getByte BinHandle
bh
            case Word8
h of
              0 -> do
                    CExpr
aa <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
ab <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CDesignator -> IO CDesignator
forall (m :: * -> *) a. Monad m => a -> m a
return (CExpr -> Attrs -> CDesignator
CArrDesig CExpr
aa Attrs
ab)
              1 -> do
                    Ident
ac <- BinHandle -> IO Ident
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
ad <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CDesignator -> IO CDesignator
forall (m :: * -> *) a. Monad m => a -> m a
return (Ident -> Attrs -> CDesignator
CMemberDesig Ident
ac Attrs
ad)
              2 -> do
                    CExpr
ae <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CExpr
af <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
ag <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CDesignator -> IO CDesignator
forall (m :: * -> *) a. Monad m => a -> m a
return (CExpr -> CExpr -> Attrs -> CDesignator
CRangeDesig CExpr
ae CExpr
af Attrs
ag)

instance Binary CDeclr where
    put_ :: BinHandle -> CDeclr -> IO ()
put_ bh :: BinHandle
bh (CVarDeclr aa :: Maybe Ident
aa ab :: Attrs
ab) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 0
            BinHandle -> Maybe Ident -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Maybe Ident
aa
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ab
    put_ bh :: BinHandle
bh (CPtrDeclr ac :: [CTypeQual]
ac ad :: CDeclr
ad ae :: Attrs
ae) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 1
            BinHandle -> [CTypeQual] -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh [CTypeQual]
ac
            BinHandle -> CDeclr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CDeclr
ad
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ae
    put_ bh :: BinHandle
bh (CArrDeclr af :: CDeclr
af ag :: [CTypeQual]
ag ah :: Maybe CExpr
ah ai :: Attrs
ai) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 2
            BinHandle -> CDeclr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CDeclr
af
            BinHandle -> [CTypeQual] -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh [CTypeQual]
ag
            BinHandle -> Maybe CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Maybe CExpr
ah
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ai
    put_ bh :: BinHandle
bh (CFunDeclr ai :: CDeclr
ai aj :: [CDecl]
aj ak :: Bool
ak al :: Attrs
al) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 3
            BinHandle -> CDeclr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CDeclr
ai
            BinHandle -> [CDecl] -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh [CDecl]
aj
            BinHandle -> Bool -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Bool
ak
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
al
    get :: BinHandle -> IO CDeclr
get bh :: BinHandle
bh = do
            Word8
h <- BinHandle -> IO Word8
getByte BinHandle
bh
            case Word8
h of
              0 -> do
                    Maybe Ident
aa <- BinHandle -> IO (Maybe Ident)
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
ab <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CDeclr -> IO CDeclr
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Ident -> Attrs -> CDeclr
CVarDeclr Maybe Ident
aa Attrs
ab)
              1 -> do
                    [CTypeQual]
ac <- BinHandle -> IO [CTypeQual]
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CDeclr
ad <- BinHandle -> IO CDeclr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
ae <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CDeclr -> IO CDeclr
forall (m :: * -> *) a. Monad m => a -> m a
return ([CTypeQual] -> CDeclr -> Attrs -> CDeclr
CPtrDeclr [CTypeQual]
ac CDeclr
ad Attrs
ae)
              2 -> do
                    CDeclr
af <- BinHandle -> IO CDeclr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    [CTypeQual]
ag <- BinHandle -> IO [CTypeQual]
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Maybe CExpr
ah <- BinHandle -> IO (Maybe CExpr)
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
ai <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CDeclr -> IO CDeclr
forall (m :: * -> *) a. Monad m => a -> m a
return (CDeclr -> [CTypeQual] -> Maybe CExpr -> Attrs -> CDeclr
CArrDeclr CDeclr
af [CTypeQual]
ag Maybe CExpr
ah Attrs
ai)
              3 -> do
                    CDeclr
ai <- BinHandle -> IO CDeclr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    [CDecl]
aj <- BinHandle -> IO [CDecl]
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Bool
ak <- BinHandle -> IO Bool
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
al <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CDeclr -> IO CDeclr
forall (m :: * -> *) a. Monad m => a -> m a
return (CDeclr -> [CDecl] -> Bool -> Attrs -> CDeclr
CFunDeclr CDeclr
ai [CDecl]
aj Bool
ak Attrs
al)

instance Binary CDeclSpec where
    put_ :: BinHandle -> CDeclSpec -> IO ()
put_ bh :: BinHandle
bh (CStorageSpec aa :: CStorageSpec
aa) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 0
            BinHandle -> CStorageSpec -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CStorageSpec
aa
    put_ bh :: BinHandle
bh (CTypeSpec ab :: CTypeSpec
ab) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 1
            BinHandle -> CTypeSpec -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CTypeSpec
ab
    put_ bh :: BinHandle
bh (CTypeQual ac :: CTypeQual
ac) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 2
            BinHandle -> CTypeQual -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CTypeQual
ac
    get :: BinHandle -> IO CDeclSpec
get bh :: BinHandle
bh = do
            Word8
h <- BinHandle -> IO Word8
getByte BinHandle
bh
            case Word8
h of
              0 -> do
                    CStorageSpec
aa <- BinHandle -> IO CStorageSpec
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CDeclSpec -> IO CDeclSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (CStorageSpec -> CDeclSpec
CStorageSpec CStorageSpec
aa)
              1 -> do
                    CTypeSpec
ab <- BinHandle -> IO CTypeSpec
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CDeclSpec -> IO CDeclSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (CTypeSpec -> CDeclSpec
CTypeSpec CTypeSpec
ab)
              2 -> do
                    CTypeQual
ac <- BinHandle -> IO CTypeQual
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CDeclSpec -> IO CDeclSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (CTypeQual -> CDeclSpec
CTypeQual CTypeQual
ac)

instance Binary CTypeSpec where
    put_ :: BinHandle -> CTypeSpec -> IO ()
put_ bh :: BinHandle
bh (CVoidType aa :: Attrs
aa) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 0
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
aa
    put_ bh :: BinHandle
bh (CCharType ab :: Attrs
ab) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 1
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ab
    put_ bh :: BinHandle
bh (CShortType ac :: Attrs
ac) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 2
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ac
    put_ bh :: BinHandle
bh (CIntType ad :: Attrs
ad) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 3
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ad
    put_ bh :: BinHandle
bh (CLongType ae :: Attrs
ae) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 4
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ae
    put_ bh :: BinHandle
bh (CFloatType af :: Attrs
af) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 5
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
af
    put_ bh :: BinHandle
bh (CDoubleType ag :: Attrs
ag) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 6
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ag
    put_ bh :: BinHandle
bh (CSignedType ah :: Attrs
ah) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 7
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ah
    put_ bh :: BinHandle
bh (CUnsigType ai :: Attrs
ai) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 8
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ai
    put_ bh :: BinHandle
bh (CSUType aj :: CStructUnion
aj ak :: Attrs
ak) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 9
            BinHandle -> CStructUnion -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CStructUnion
aj
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ak
    put_ bh :: BinHandle
bh (CEnumType al :: CEnum
al am :: Attrs
am) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 10
            BinHandle -> CEnum -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CEnum
al
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
am
    put_ bh :: BinHandle
bh (CTypeDef an :: Ident
an ao :: Attrs
ao) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 11
            BinHandle -> Ident -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Ident
an
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ao
    put_ bh :: BinHandle
bh (CTypeOfExpr ap :: CExpr
ap aq :: Attrs
aq) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 12
            BinHandle -> CExpr -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CExpr
ap
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
aq
    put_ bh :: BinHandle
bh (CTypeOfType ar :: CDecl
ar as :: Attrs
as) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 13
            BinHandle -> CDecl -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CDecl
ar
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
as
    put_ bh :: BinHandle
bh (CFloat128Type at :: Attrs
at) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 14
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
at
    put_ bh :: BinHandle
bh (CBoolType at :: Attrs
at) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 15
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
at
    get :: BinHandle -> IO CTypeSpec
get bh :: BinHandle
bh = do
            Word8
h <- BinHandle -> IO Word8
getByte BinHandle
bh
            case Word8
h of
              0 -> do
                    Attrs
aa <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeSpec -> IO CTypeSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CTypeSpec
CVoidType Attrs
aa)
              1 -> do
                    Attrs
ab <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeSpec -> IO CTypeSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CTypeSpec
CCharType Attrs
ab)
              2 -> do
                    Attrs
ac <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeSpec -> IO CTypeSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CTypeSpec
CShortType Attrs
ac)
              3 -> do
                    Attrs
ad <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeSpec -> IO CTypeSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CTypeSpec
CIntType Attrs
ad)
              4 -> do
                    Attrs
ae <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeSpec -> IO CTypeSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CTypeSpec
CLongType Attrs
ae)
              5 -> do
                    Attrs
af <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeSpec -> IO CTypeSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CTypeSpec
CFloatType Attrs
af)
              6 -> do
                    Attrs
ag <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeSpec -> IO CTypeSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CTypeSpec
CDoubleType Attrs
ag)
              7 -> do
                    Attrs
ah <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeSpec -> IO CTypeSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CTypeSpec
CSignedType Attrs
ah)
              8 -> do
                    Attrs
ai <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeSpec -> IO CTypeSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CTypeSpec
CUnsigType Attrs
ai)
              9 -> do
                    CStructUnion
aj <- BinHandle -> IO CStructUnion
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
ak <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeSpec -> IO CTypeSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (CStructUnion -> Attrs -> CTypeSpec
CSUType CStructUnion
aj Attrs
ak)
              10 -> do
                    CEnum
al <- BinHandle -> IO CEnum
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
am <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeSpec -> IO CTypeSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (CEnum -> Attrs -> CTypeSpec
CEnumType CEnum
al Attrs
am)
              11 -> do
                    Ident
an <- BinHandle -> IO Ident
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
ao <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeSpec -> IO CTypeSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (Ident -> Attrs -> CTypeSpec
CTypeDef Ident
an Attrs
ao)
              12 -> do
                    CExpr
ap <- BinHandle -> IO CExpr
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
aq <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeSpec -> IO CTypeSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (CExpr -> Attrs -> CTypeSpec
CTypeOfExpr CExpr
ap Attrs
aq)
              13 -> do
                    CDecl
ar <- BinHandle -> IO CDecl
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
as <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeSpec -> IO CTypeSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (CDecl -> Attrs -> CTypeSpec
CTypeOfType CDecl
ar Attrs
as)
              14 -> do
                    Attrs
at <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeSpec -> IO CTypeSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CTypeSpec
CFloat128Type Attrs
at)
              15 -> do
                    Attrs
at <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeSpec -> IO CTypeSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CTypeSpec
CBoolType Attrs
at)

instance Binary CStorageSpec where
    put_ :: BinHandle -> CStorageSpec -> IO ()
put_ bh :: BinHandle
bh (CAuto aa :: Attrs
aa) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 0
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
aa
    put_ bh :: BinHandle
bh (CRegister ab :: Attrs
ab) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 1
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ab
    put_ bh :: BinHandle
bh (CStatic ac :: Attrs
ac) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 2
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ac
    put_ bh :: BinHandle
bh (CExtern ad :: Attrs
ad) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 3
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ad
    put_ bh :: BinHandle
bh (CTypedef ae :: Attrs
ae) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 4
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ae
    get :: BinHandle -> IO CStorageSpec
get bh :: BinHandle
bh = do
            Word8
h <- BinHandle -> IO Word8
getByte BinHandle
bh
            case Word8
h of
              0 -> do
                    Attrs
aa <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CStorageSpec -> IO CStorageSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CStorageSpec
CAuto Attrs
aa)
              1 -> do
                    Attrs
ab <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CStorageSpec -> IO CStorageSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CStorageSpec
CRegister Attrs
ab)
              2 -> do
                    Attrs
ac <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CStorageSpec -> IO CStorageSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CStorageSpec
CStatic Attrs
ac)
              3 -> do
                    Attrs
ad <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CStorageSpec -> IO CStorageSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CStorageSpec
CExtern Attrs
ad)
              4 -> do
                    Attrs
ae <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CStorageSpec -> IO CStorageSpec
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CStorageSpec
CTypedef Attrs
ae)

instance Binary CTypeQual where
    put_ :: BinHandle -> CTypeQual -> IO ()
put_ bh :: BinHandle
bh (CConstQual aa :: Attrs
aa) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 0
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
aa
    put_ bh :: BinHandle
bh (CVolatQual ab :: Attrs
ab) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 1
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ab
    put_ bh :: BinHandle
bh (CRestrQual ac :: Attrs
ac) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 2
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ac
    put_ bh :: BinHandle
bh (CInlinQual ad :: Attrs
ad) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 3
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ad
    get :: BinHandle -> IO CTypeQual
get bh :: BinHandle
bh = do
            Word8
h <- BinHandle -> IO Word8
getByte BinHandle
bh
            case Word8
h of
              0 -> do
                    Attrs
aa <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeQual -> IO CTypeQual
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CTypeQual
CConstQual Attrs
aa)
              1 -> do
                    Attrs
ab <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeQual -> IO CTypeQual
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CTypeQual
CVolatQual Attrs
ab)
              2 -> do
                    Attrs
ac <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeQual -> IO CTypeQual
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CTypeQual
CRestrQual Attrs
ac)
              3 -> do
                    Attrs
ad <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CTypeQual -> IO CTypeQual
forall (m :: * -> *) a. Monad m => a -> m a
return (Attrs -> CTypeQual
CInlinQual Attrs
ad)

instance Binary CConst where
    put_ :: BinHandle -> CConst -> IO ()
put_ bh :: BinHandle
bh (CIntConst aa :: Integer
aa ab :: Attrs
ab) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 0
            BinHandle -> Integer -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Integer
aa
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ab
    put_ bh :: BinHandle
bh (CCharConst ac :: Char
ac ad :: Attrs
ad) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 1
            BinHandle -> Char -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Char
ac
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ad
    put_ bh :: BinHandle
bh (CFloatConst ae :: String
ae af :: Attrs
af) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 2
            BinHandle -> String -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh String
ae
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
af
    put_ bh :: BinHandle
bh (CStrConst ag :: String
ag ah :: Attrs
ah) = do
            BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 3
            BinHandle -> String -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh String
ag
            BinHandle -> Attrs -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Attrs
ah
    get :: BinHandle -> IO CConst
get bh :: BinHandle
bh = do
            Word8
h <- BinHandle -> IO Word8
getByte BinHandle
bh
            case Word8
h of
              0 -> do
                    Integer
aa <- BinHandle -> IO Integer
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
ab <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CConst -> IO CConst
forall (m :: * -> *) a. Monad m => a -> m a
return (Integer -> Attrs -> CConst
CIntConst Integer
aa Attrs
ab)
              1 -> do
                    Char
ac <- BinHandle -> IO Char
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
ad <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CConst -> IO CConst
forall (m :: * -> *) a. Monad m => a -> m a
return (Char -> Attrs -> CConst
CCharConst Char
ac Attrs
ad)
              2 -> do
                    String
ae <- BinHandle -> IO String
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
af <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CConst -> IO CConst
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Attrs -> CConst
CFloatConst String
ae Attrs
af)
              3 -> do
                    String
ag <- BinHandle -> IO String
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Attrs
ah <- BinHandle -> IO Attrs
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    CConst -> IO CConst
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Attrs -> CConst
CStrConst String
ag Attrs
ah)

instance Binary CUnaryOp where
    put_ :: BinHandle -> CUnaryOp -> IO ()
put_ bh :: BinHandle
bh CPreIncOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 0
    put_ bh :: BinHandle
bh CPreDecOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 1
    put_ bh :: BinHandle
bh CPostIncOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 2
    put_ bh :: BinHandle
bh CPostDecOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 3
    put_ bh :: BinHandle
bh CAdrOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 4
    put_ bh :: BinHandle
bh CIndOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 5
    put_ bh :: BinHandle
bh CPlusOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 6
    put_ bh :: BinHandle
bh CMinOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 7
    put_ bh :: BinHandle
bh CCompOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 8
    put_ bh :: BinHandle
bh CNegOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 9
    get :: BinHandle -> IO CUnaryOp
get bh :: BinHandle
bh = do
            Word8
h <- BinHandle -> IO Word8
getByte BinHandle
bh
            case Word8
h of
              0 -> CUnaryOp -> IO CUnaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CUnaryOp
CPreIncOp
              1 -> CUnaryOp -> IO CUnaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CUnaryOp
CPreDecOp
              2 -> CUnaryOp -> IO CUnaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CUnaryOp
CPostIncOp
              3 -> CUnaryOp -> IO CUnaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CUnaryOp
CPostDecOp
              4 -> CUnaryOp -> IO CUnaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CUnaryOp
CAdrOp
              5 -> CUnaryOp -> IO CUnaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CUnaryOp
CIndOp
              6 -> CUnaryOp -> IO CUnaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CUnaryOp
CPlusOp
              7 -> CUnaryOp -> IO CUnaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CUnaryOp
CMinOp
              8 -> CUnaryOp -> IO CUnaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CUnaryOp
CCompOp
              9 -> CUnaryOp -> IO CUnaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CUnaryOp
CNegOp

instance Binary CBinaryOp where
    put_ :: BinHandle -> CBinaryOp -> IO ()
put_ bh :: BinHandle
bh CMulOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 0
    put_ bh :: BinHandle
bh CDivOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 1
    put_ bh :: BinHandle
bh CRmdOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 2
    put_ bh :: BinHandle
bh CAddOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 3
    put_ bh :: BinHandle
bh CSubOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 4
    put_ bh :: BinHandle
bh CShlOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 5
    put_ bh :: BinHandle
bh CShrOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 6
    put_ bh :: BinHandle
bh CLeOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 7
    put_ bh :: BinHandle
bh CGrOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 8
    put_ bh :: BinHandle
bh CLeqOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 9
    put_ bh :: BinHandle
bh CGeqOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 10
    put_ bh :: BinHandle
bh CEqOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 11
    put_ bh :: BinHandle
bh CNeqOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 12
    put_ bh :: BinHandle
bh CAndOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 13
    put_ bh :: BinHandle
bh CXorOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 14
    put_ bh :: BinHandle
bh COrOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 15
    put_ bh :: BinHandle
bh CLndOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 16
    put_ bh :: BinHandle
bh CLorOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 17
    get :: BinHandle -> IO CBinaryOp
get bh :: BinHandle
bh = do
            Word8
h <- BinHandle -> IO Word8
getByte BinHandle
bh
            case Word8
h of
              0 -> CBinaryOp -> IO CBinaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CBinaryOp
CMulOp
              1 -> CBinaryOp -> IO CBinaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CBinaryOp
CDivOp
              2 -> CBinaryOp -> IO CBinaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CBinaryOp
CRmdOp
              3 -> CBinaryOp -> IO CBinaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CBinaryOp
CAddOp
              4 -> CBinaryOp -> IO CBinaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CBinaryOp
CSubOp
              5 -> CBinaryOp -> IO CBinaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CBinaryOp
CShlOp
              6 -> CBinaryOp -> IO CBinaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CBinaryOp
CShrOp
              7 -> CBinaryOp -> IO CBinaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CBinaryOp
CLeOp
              8 -> CBinaryOp -> IO CBinaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CBinaryOp
CGrOp
              9 -> CBinaryOp -> IO CBinaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CBinaryOp
CLeqOp
              10 -> CBinaryOp -> IO CBinaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CBinaryOp
CGeqOp
              11 -> CBinaryOp -> IO CBinaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CBinaryOp
CEqOp
              12 -> CBinaryOp -> IO CBinaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CBinaryOp
CNeqOp
              13 -> CBinaryOp -> IO CBinaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CBinaryOp
CAndOp
              14 -> CBinaryOp -> IO CBinaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CBinaryOp
CXorOp
              15 -> CBinaryOp -> IO CBinaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CBinaryOp
COrOp
              16 -> CBinaryOp -> IO CBinaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CBinaryOp
CLndOp
              17 -> CBinaryOp -> IO CBinaryOp
forall (m :: * -> *) a. Monad m => a -> m a
return CBinaryOp
CLorOp

instance Binary CAssignOp where
    put_ :: BinHandle -> CAssignOp -> IO ()
put_ bh :: BinHandle
bh CAssignOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 0
    put_ bh :: BinHandle
bh CMulAssOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 1
    put_ bh :: BinHandle
bh CDivAssOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 2
    put_ bh :: BinHandle
bh CRmdAssOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 3
    put_ bh :: BinHandle
bh CAddAssOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 4
    put_ bh :: BinHandle
bh CSubAssOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 5
    put_ bh :: BinHandle
bh CShlAssOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 6
    put_ bh :: BinHandle
bh CShrAssOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 7
    put_ bh :: BinHandle
bh CAndAssOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 8
    put_ bh :: BinHandle
bh CXorAssOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 9
    put_ bh :: BinHandle
bh COrAssOp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh 10
    get :: BinHandle -> IO CAssignOp
get bh :: BinHandle
bh = do
            Word8
h <- BinHandle -> IO Word8
getByte BinHandle
bh
            case Word8
h of
              0 -> CAssignOp -> IO CAssignOp
forall (m :: * -> *) a. Monad m => a -> m a
return CAssignOp
CAssignOp
              1 -> CAssignOp -> IO CAssignOp
forall (m :: * -> *) a. Monad m => a -> m a
return CAssignOp
CMulAssOp
              2 -> CAssignOp -> IO CAssignOp
forall (m :: * -> *) a. Monad m => a -> m a
return CAssignOp
CDivAssOp
              3 -> CAssignOp -> IO CAssignOp
forall (m :: * -> *) a. Monad m => a -> m a
return CAssignOp
CRmdAssOp
              4 -> CAssignOp -> IO CAssignOp
forall (m :: * -> *) a. Monad m => a -> m a
return CAssignOp
CAddAssOp
              5 -> CAssignOp -> IO CAssignOp
forall (m :: * -> *) a. Monad m => a -> m a
return CAssignOp
CSubAssOp
              6 -> CAssignOp -> IO CAssignOp
forall (m :: * -> *) a. Monad m => a -> m a
return CAssignOp
CShlAssOp
              7 -> CAssignOp -> IO CAssignOp
forall (m :: * -> *) a. Monad m => a -> m a
return CAssignOp
CShrAssOp
              8 -> CAssignOp -> IO CAssignOp
forall (m :: * -> *) a. Monad m => a -> m a
return CAssignOp
CAndAssOp
              9 -> CAssignOp -> IO CAssignOp
forall (m :: * -> *) a. Monad m => a -> m a
return CAssignOp
CXorAssOp
              10 -> CAssignOp -> IO CAssignOp
forall (m :: * -> *) a. Monad m => a -> m a
return CAssignOp
COrAssOp