--------------------------------------------------------------------------------
--                                                                 2016.09.08
-- |
-- Module      :  Language.Hakaru.CodeGen.AST
-- Copyright   :  Copyright (c) 2016 the Hakaru team
-- License     :  BSD3
-- Maintainer  :  zsulliva@indiana.edu
-- Stability   :  experimental
-- Portability :  GHC-only
--
--   An AST for the C Family and preprocessor. Much of this was originally based
-- on Manuel M T Chakravarty and Benedikt Hubar's "language-c" package.
--
-- It is an AST for the C99 standard and should compile with the -pedantic flag
--
--------------------------------------------------------------------------------

module Language.Hakaru.CodeGen.AST
  ( Preprocessor(..), Ident(..), CAST(..), CExtDecl(..), CFunDef(..)

  -- declaration constructors
  , CDecl(..), CDeclr(..), CDeclSpec(..), CStorageSpec(..), CTypeQual(..)
  , CDirectDeclr(..), CTypeSpec(..), CTypeName(..), CSUSpec(..), CSUTag(..)
  , CEnum(..), CInit(..), CPartDesig(..), CFunSpec(..), CPtrDeclr(..)

  -- statements and expression constructors
  , CStat(..), CCompoundBlockItem(..), CExpr(..), CConst(..), CUnaryOp(..)
  , CBinaryOp(..), CAssignOp(..)

  -- infix and smart constructors
  , (.>.),(.<.),(.==.),(.!=.),(.||.),(.&&.),(.*.),(./.),(.-.),(.+.),(.=.),(.+=.)
  , (.*=.),(.>=.),(.<=.),(...),(.->.)
  , seqCStat
  , indirect, address, index, intE, charE, floatE, stringE, mkCallE, mkUnaryE
  , nullE

  -- util
  , cNameStream
  ) where

import Control.Monad (mplus)


--------------------------------------------------------------------------------
--                               Top Level                                    --
--------------------------------------------------------------------------------

data CAST
  = CAST [CExtDecl]
  deriving (Int -> CAST -> ShowS
[CAST] -> ShowS
CAST -> String
(Int -> CAST -> ShowS)
-> (CAST -> String) -> ([CAST] -> ShowS) -> Show CAST
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CAST] -> ShowS
$cshowList :: [CAST] -> ShowS
show :: CAST -> String
$cshow :: CAST -> String
showsPrec :: Int -> CAST -> ShowS
$cshowsPrec :: Int -> CAST -> ShowS
Show, CAST -> CAST -> Bool
(CAST -> CAST -> Bool) -> (CAST -> CAST -> Bool) -> Eq CAST
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CAST -> CAST -> Bool
$c/= :: CAST -> CAST -> Bool
== :: CAST -> CAST -> Bool
$c== :: CAST -> CAST -> Bool
Eq, Eq CAST
Eq CAST
-> (CAST -> CAST -> Ordering)
-> (CAST -> CAST -> Bool)
-> (CAST -> CAST -> Bool)
-> (CAST -> CAST -> Bool)
-> (CAST -> CAST -> Bool)
-> (CAST -> CAST -> CAST)
-> (CAST -> CAST -> CAST)
-> Ord CAST
CAST -> CAST -> Bool
CAST -> CAST -> Ordering
CAST -> CAST -> CAST
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CAST -> CAST -> CAST
$cmin :: CAST -> CAST -> CAST
max :: CAST -> CAST -> CAST
$cmax :: CAST -> CAST -> CAST
>= :: CAST -> CAST -> Bool
$c>= :: CAST -> CAST -> Bool
> :: CAST -> CAST -> Bool
$c> :: CAST -> CAST -> Bool
<= :: CAST -> CAST -> Bool
$c<= :: CAST -> CAST -> Bool
< :: CAST -> CAST -> Bool
$c< :: CAST -> CAST -> Bool
compare :: CAST -> CAST -> Ordering
$ccompare :: CAST -> CAST -> Ordering
$cp1Ord :: Eq CAST
Ord)


data CExtDecl
  = CDeclExt    CDecl
  | CFunDefExt  CFunDef
  | CCommentExt String
  | CPPExt      Preprocessor
  deriving (Int -> CExtDecl -> ShowS
[CExtDecl] -> ShowS
CExtDecl -> String
(Int -> CExtDecl -> ShowS)
-> (CExtDecl -> String) -> ([CExtDecl] -> ShowS) -> Show CExtDecl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CExtDecl] -> ShowS
$cshowList :: [CExtDecl] -> ShowS
show :: CExtDecl -> String
$cshow :: CExtDecl -> String
showsPrec :: Int -> CExtDecl -> ShowS
$cshowsPrec :: Int -> CExtDecl -> ShowS
Show, CExtDecl -> CExtDecl -> Bool
(CExtDecl -> CExtDecl -> Bool)
-> (CExtDecl -> CExtDecl -> Bool) -> Eq CExtDecl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CExtDecl -> CExtDecl -> Bool
$c/= :: CExtDecl -> CExtDecl -> Bool
== :: CExtDecl -> CExtDecl -> Bool
$c== :: CExtDecl -> CExtDecl -> Bool
Eq, Eq CExtDecl
Eq CExtDecl
-> (CExtDecl -> CExtDecl -> Ordering)
-> (CExtDecl -> CExtDecl -> Bool)
-> (CExtDecl -> CExtDecl -> Bool)
-> (CExtDecl -> CExtDecl -> Bool)
-> (CExtDecl -> CExtDecl -> Bool)
-> (CExtDecl -> CExtDecl -> CExtDecl)
-> (CExtDecl -> CExtDecl -> CExtDecl)
-> Ord CExtDecl
CExtDecl -> CExtDecl -> Bool
CExtDecl -> CExtDecl -> Ordering
CExtDecl -> CExtDecl -> CExtDecl
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CExtDecl -> CExtDecl -> CExtDecl
$cmin :: CExtDecl -> CExtDecl -> CExtDecl
max :: CExtDecl -> CExtDecl -> CExtDecl
$cmax :: CExtDecl -> CExtDecl -> CExtDecl
>= :: CExtDecl -> CExtDecl -> Bool
$c>= :: CExtDecl -> CExtDecl -> Bool
> :: CExtDecl -> CExtDecl -> Bool
$c> :: CExtDecl -> CExtDecl -> Bool
<= :: CExtDecl -> CExtDecl -> Bool
$c<= :: CExtDecl -> CExtDecl -> Bool
< :: CExtDecl -> CExtDecl -> Bool
$c< :: CExtDecl -> CExtDecl -> Bool
compare :: CExtDecl -> CExtDecl -> Ordering
$ccompare :: CExtDecl -> CExtDecl -> Ordering
$cp1Ord :: Eq CExtDecl
Ord)

data CFunDef
  = CFunDef [CDeclSpec] CDeclr [CDecl] CStat
  deriving (Int -> CFunDef -> ShowS
[CFunDef] -> ShowS
CFunDef -> String
(Int -> CFunDef -> ShowS)
-> (CFunDef -> String) -> ([CFunDef] -> ShowS) -> Show CFunDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CFunDef] -> ShowS
$cshowList :: [CFunDef] -> ShowS
show :: CFunDef -> String
$cshow :: CFunDef -> String
showsPrec :: Int -> CFunDef -> ShowS
$cshowsPrec :: Int -> CFunDef -> ShowS
Show, CFunDef -> CFunDef -> Bool
(CFunDef -> CFunDef -> Bool)
-> (CFunDef -> CFunDef -> Bool) -> Eq CFunDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CFunDef -> CFunDef -> Bool
$c/= :: CFunDef -> CFunDef -> Bool
== :: CFunDef -> CFunDef -> Bool
$c== :: CFunDef -> CFunDef -> Bool
Eq, Eq CFunDef
Eq CFunDef
-> (CFunDef -> CFunDef -> Ordering)
-> (CFunDef -> CFunDef -> Bool)
-> (CFunDef -> CFunDef -> Bool)
-> (CFunDef -> CFunDef -> Bool)
-> (CFunDef -> CFunDef -> Bool)
-> (CFunDef -> CFunDef -> CFunDef)
-> (CFunDef -> CFunDef -> CFunDef)
-> Ord CFunDef
CFunDef -> CFunDef -> Bool
CFunDef -> CFunDef -> Ordering
CFunDef -> CFunDef -> CFunDef
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CFunDef -> CFunDef -> CFunDef
$cmin :: CFunDef -> CFunDef -> CFunDef
max :: CFunDef -> CFunDef -> CFunDef
$cmax :: CFunDef -> CFunDef -> CFunDef
>= :: CFunDef -> CFunDef -> Bool
$c>= :: CFunDef -> CFunDef -> Bool
> :: CFunDef -> CFunDef -> Bool
$c> :: CFunDef -> CFunDef -> Bool
<= :: CFunDef -> CFunDef -> Bool
$c<= :: CFunDef -> CFunDef -> Bool
< :: CFunDef -> CFunDef -> Bool
$c< :: CFunDef -> CFunDef -> Bool
compare :: CFunDef -> CFunDef -> Ordering
$ccompare :: CFunDef -> CFunDef -> Ordering
$cp1Ord :: Eq CFunDef
Ord)

{-
  This is currently a very rough AST for preprocessor. Preprocessor macros
  can be inserted at the top level and at the statement level
-}
data Preprocessor
  = PPDefine  String String
  | PPInclude String
  | PPUndef   String
  | PPIf      String
  | PPIfDef   String
  | PPIfNDef  String
  | PPElse    String
  | PPElif    String
  | PPEndif   String
  | PPError   String
  | PPPragma  [String]
  deriving (Int -> Preprocessor -> ShowS
[Preprocessor] -> ShowS
Preprocessor -> String
(Int -> Preprocessor -> ShowS)
-> (Preprocessor -> String)
-> ([Preprocessor] -> ShowS)
-> Show Preprocessor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Preprocessor] -> ShowS
$cshowList :: [Preprocessor] -> ShowS
show :: Preprocessor -> String
$cshow :: Preprocessor -> String
showsPrec :: Int -> Preprocessor -> ShowS
$cshowsPrec :: Int -> Preprocessor -> ShowS
Show, Preprocessor -> Preprocessor -> Bool
(Preprocessor -> Preprocessor -> Bool)
-> (Preprocessor -> Preprocessor -> Bool) -> Eq Preprocessor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Preprocessor -> Preprocessor -> Bool
$c/= :: Preprocessor -> Preprocessor -> Bool
== :: Preprocessor -> Preprocessor -> Bool
$c== :: Preprocessor -> Preprocessor -> Bool
Eq, Eq Preprocessor
Eq Preprocessor
-> (Preprocessor -> Preprocessor -> Ordering)
-> (Preprocessor -> Preprocessor -> Bool)
-> (Preprocessor -> Preprocessor -> Bool)
-> (Preprocessor -> Preprocessor -> Bool)
-> (Preprocessor -> Preprocessor -> Bool)
-> (Preprocessor -> Preprocessor -> Preprocessor)
-> (Preprocessor -> Preprocessor -> Preprocessor)
-> Ord Preprocessor
Preprocessor -> Preprocessor -> Bool
Preprocessor -> Preprocessor -> Ordering
Preprocessor -> Preprocessor -> Preprocessor
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Preprocessor -> Preprocessor -> Preprocessor
$cmin :: Preprocessor -> Preprocessor -> Preprocessor
max :: Preprocessor -> Preprocessor -> Preprocessor
$cmax :: Preprocessor -> Preprocessor -> Preprocessor
>= :: Preprocessor -> Preprocessor -> Bool
$c>= :: Preprocessor -> Preprocessor -> Bool
> :: Preprocessor -> Preprocessor -> Bool
$c> :: Preprocessor -> Preprocessor -> Bool
<= :: Preprocessor -> Preprocessor -> Bool
$c<= :: Preprocessor -> Preprocessor -> Bool
< :: Preprocessor -> Preprocessor -> Bool
$c< :: Preprocessor -> Preprocessor -> Bool
compare :: Preprocessor -> Preprocessor -> Ordering
$ccompare :: Preprocessor -> Preprocessor -> Ordering
$cp1Ord :: Eq Preprocessor
Ord)

data Ident
 = Ident String
 deriving (Int -> Ident -> ShowS
[Ident] -> ShowS
Ident -> String
(Int -> Ident -> ShowS)
-> (Ident -> String) -> ([Ident] -> ShowS) -> Show Ident
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Ident] -> ShowS
$cshowList :: [Ident] -> ShowS
show :: Ident -> String
$cshow :: Ident -> String
showsPrec :: Int -> Ident -> ShowS
$cshowsPrec :: Int -> Ident -> ShowS
Show, Ident -> Ident -> Bool
(Ident -> Ident -> Bool) -> (Ident -> Ident -> Bool) -> Eq Ident
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Ident -> Ident -> Bool
$c/= :: Ident -> Ident -> Bool
== :: Ident -> Ident -> Bool
$c== :: Ident -> Ident -> Bool
Eq, Eq Ident
Eq Ident
-> (Ident -> Ident -> Ordering)
-> (Ident -> Ident -> Bool)
-> (Ident -> Ident -> Bool)
-> (Ident -> Ident -> Bool)
-> (Ident -> Ident -> Bool)
-> (Ident -> Ident -> Ident)
-> (Ident -> Ident -> Ident)
-> Ord Ident
Ident -> Ident -> Bool
Ident -> Ident -> Ordering
Ident -> Ident -> Ident
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Ident -> Ident -> Ident
$cmin :: Ident -> Ident -> Ident
max :: Ident -> Ident -> Ident
$cmax :: Ident -> Ident -> Ident
>= :: Ident -> Ident -> Bool
$c>= :: Ident -> Ident -> Bool
> :: Ident -> Ident -> Bool
$c> :: Ident -> Ident -> Bool
<= :: Ident -> Ident -> Bool
$c<= :: Ident -> Ident -> Bool
< :: Ident -> Ident -> Bool
$c< :: Ident -> Ident -> Bool
compare :: Ident -> Ident -> Ordering
$ccompare :: Ident -> Ident -> Ordering
$cp1Ord :: Eq Ident
Ord)


--------------------------------------------------------------------------------
--                               C Declarations                               --
--------------------------------------------------------------------------------
{-
  C Declarations provide tools for laying out memory objections.
-}

data CDecl
  = CDecl [CDeclSpec] [(CDeclr, Maybe CInit)]
  deriving (Int -> CDecl -> ShowS
[CDecl] -> ShowS
CDecl -> String
(Int -> CDecl -> ShowS)
-> (CDecl -> String) -> ([CDecl] -> ShowS) -> Show CDecl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CDecl] -> ShowS
$cshowList :: [CDecl] -> ShowS
show :: CDecl -> String
$cshow :: CDecl -> String
showsPrec :: Int -> CDecl -> ShowS
$cshowsPrec :: Int -> CDecl -> ShowS
Show, CDecl -> CDecl -> Bool
(CDecl -> CDecl -> Bool) -> (CDecl -> CDecl -> Bool) -> Eq CDecl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CDecl -> CDecl -> Bool
$c/= :: CDecl -> CDecl -> Bool
== :: CDecl -> CDecl -> Bool
$c== :: CDecl -> CDecl -> Bool
Eq, Eq CDecl
Eq CDecl
-> (CDecl -> CDecl -> Ordering)
-> (CDecl -> CDecl -> Bool)
-> (CDecl -> CDecl -> Bool)
-> (CDecl -> CDecl -> Bool)
-> (CDecl -> CDecl -> Bool)
-> (CDecl -> CDecl -> CDecl)
-> (CDecl -> CDecl -> CDecl)
-> Ord CDecl
CDecl -> CDecl -> Bool
CDecl -> CDecl -> Ordering
CDecl -> CDecl -> CDecl
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CDecl -> CDecl -> CDecl
$cmin :: CDecl -> CDecl -> CDecl
max :: CDecl -> CDecl -> CDecl
$cmax :: CDecl -> CDecl -> CDecl
>= :: CDecl -> CDecl -> Bool
$c>= :: CDecl -> CDecl -> Bool
> :: CDecl -> CDecl -> Bool
$c> :: CDecl -> CDecl -> Bool
<= :: CDecl -> CDecl -> Bool
$c<= :: CDecl -> CDecl -> Bool
< :: CDecl -> CDecl -> Bool
$c< :: CDecl -> CDecl -> Bool
compare :: CDecl -> CDecl -> Ordering
$ccompare :: CDecl -> CDecl -> Ordering
$cp1Ord :: Eq CDecl
Ord)

----------------
-- Specifiers --
----------------

-- top level specifier
data CDeclSpec
  = CStorageSpec CStorageSpec
  | CTypeSpec    CTypeSpec
  | CTypeQual    CTypeQual
  | CFunSpec     CFunSpec
  deriving (Int -> CDeclSpec -> ShowS
[CDeclSpec] -> ShowS
CDeclSpec -> String
(Int -> CDeclSpec -> ShowS)
-> (CDeclSpec -> String)
-> ([CDeclSpec] -> ShowS)
-> Show CDeclSpec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CDeclSpec] -> ShowS
$cshowList :: [CDeclSpec] -> ShowS
show :: CDeclSpec -> String
$cshow :: CDeclSpec -> String
showsPrec :: Int -> CDeclSpec -> ShowS
$cshowsPrec :: Int -> CDeclSpec -> ShowS
Show, 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, Eq CDeclSpec
Eq CDeclSpec
-> (CDeclSpec -> CDeclSpec -> Ordering)
-> (CDeclSpec -> CDeclSpec -> Bool)
-> (CDeclSpec -> CDeclSpec -> Bool)
-> (CDeclSpec -> CDeclSpec -> Bool)
-> (CDeclSpec -> CDeclSpec -> Bool)
-> (CDeclSpec -> CDeclSpec -> CDeclSpec)
-> (CDeclSpec -> CDeclSpec -> CDeclSpec)
-> Ord CDeclSpec
CDeclSpec -> CDeclSpec -> Bool
CDeclSpec -> CDeclSpec -> Ordering
CDeclSpec -> CDeclSpec -> CDeclSpec
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CDeclSpec -> CDeclSpec -> CDeclSpec
$cmin :: CDeclSpec -> CDeclSpec -> CDeclSpec
max :: CDeclSpec -> CDeclSpec -> CDeclSpec
$cmax :: CDeclSpec -> CDeclSpec -> CDeclSpec
>= :: CDeclSpec -> CDeclSpec -> Bool
$c>= :: CDeclSpec -> CDeclSpec -> Bool
> :: CDeclSpec -> CDeclSpec -> Bool
$c> :: CDeclSpec -> CDeclSpec -> Bool
<= :: CDeclSpec -> CDeclSpec -> Bool
$c<= :: CDeclSpec -> CDeclSpec -> Bool
< :: CDeclSpec -> CDeclSpec -> Bool
$c< :: CDeclSpec -> CDeclSpec -> Bool
compare :: CDeclSpec -> CDeclSpec -> Ordering
$ccompare :: CDeclSpec -> CDeclSpec -> Ordering
$cp1Ord :: Eq CDeclSpec
Ord)

data CStorageSpec
  = CTypeDef
  | CExtern
  | CStatic
  | CAuto
  | CRegister
  deriving (Int -> CStorageSpec -> ShowS
[CStorageSpec] -> ShowS
CStorageSpec -> String
(Int -> CStorageSpec -> ShowS)
-> (CStorageSpec -> String)
-> ([CStorageSpec] -> ShowS)
-> Show CStorageSpec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CStorageSpec] -> ShowS
$cshowList :: [CStorageSpec] -> ShowS
show :: CStorageSpec -> String
$cshow :: CStorageSpec -> String
showsPrec :: Int -> CStorageSpec -> ShowS
$cshowsPrec :: Int -> CStorageSpec -> ShowS
Show, CStorageSpec -> CStorageSpec -> Bool
(CStorageSpec -> CStorageSpec -> Bool)
-> (CStorageSpec -> CStorageSpec -> Bool) -> Eq CStorageSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CStorageSpec -> CStorageSpec -> Bool
$c/= :: CStorageSpec -> CStorageSpec -> Bool
== :: CStorageSpec -> CStorageSpec -> Bool
$c== :: CStorageSpec -> CStorageSpec -> Bool
Eq, Eq CStorageSpec
Eq CStorageSpec
-> (CStorageSpec -> CStorageSpec -> Ordering)
-> (CStorageSpec -> CStorageSpec -> Bool)
-> (CStorageSpec -> CStorageSpec -> Bool)
-> (CStorageSpec -> CStorageSpec -> Bool)
-> (CStorageSpec -> CStorageSpec -> Bool)
-> (CStorageSpec -> CStorageSpec -> CStorageSpec)
-> (CStorageSpec -> CStorageSpec -> CStorageSpec)
-> Ord CStorageSpec
CStorageSpec -> CStorageSpec -> Bool
CStorageSpec -> CStorageSpec -> Ordering
CStorageSpec -> CStorageSpec -> CStorageSpec
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CStorageSpec -> CStorageSpec -> CStorageSpec
$cmin :: CStorageSpec -> CStorageSpec -> CStorageSpec
max :: CStorageSpec -> CStorageSpec -> CStorageSpec
$cmax :: CStorageSpec -> CStorageSpec -> CStorageSpec
>= :: CStorageSpec -> CStorageSpec -> Bool
$c>= :: CStorageSpec -> CStorageSpec -> Bool
> :: CStorageSpec -> CStorageSpec -> Bool
$c> :: CStorageSpec -> CStorageSpec -> Bool
<= :: CStorageSpec -> CStorageSpec -> Bool
$c<= :: CStorageSpec -> CStorageSpec -> Bool
< :: CStorageSpec -> CStorageSpec -> Bool
$c< :: CStorageSpec -> CStorageSpec -> Bool
compare :: CStorageSpec -> CStorageSpec -> Ordering
$ccompare :: CStorageSpec -> CStorageSpec -> Ordering
$cp1Ord :: Eq CStorageSpec
Ord)

data CTypeQual
  = CConstQual
  | CVolatQual
  deriving (Int -> CTypeQual -> ShowS
[CTypeQual] -> ShowS
CTypeQual -> String
(Int -> CTypeQual -> ShowS)
-> (CTypeQual -> String)
-> ([CTypeQual] -> ShowS)
-> Show CTypeQual
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CTypeQual] -> ShowS
$cshowList :: [CTypeQual] -> ShowS
show :: CTypeQual -> String
$cshow :: CTypeQual -> String
showsPrec :: Int -> CTypeQual -> ShowS
$cshowsPrec :: Int -> CTypeQual -> ShowS
Show, CTypeQual -> CTypeQual -> Bool
(CTypeQual -> CTypeQual -> Bool)
-> (CTypeQual -> CTypeQual -> Bool) -> Eq CTypeQual
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CTypeQual -> CTypeQual -> Bool
$c/= :: CTypeQual -> CTypeQual -> Bool
== :: CTypeQual -> CTypeQual -> Bool
$c== :: CTypeQual -> CTypeQual -> Bool
Eq, Eq CTypeQual
Eq CTypeQual
-> (CTypeQual -> CTypeQual -> Ordering)
-> (CTypeQual -> CTypeQual -> Bool)
-> (CTypeQual -> CTypeQual -> Bool)
-> (CTypeQual -> CTypeQual -> Bool)
-> (CTypeQual -> CTypeQual -> Bool)
-> (CTypeQual -> CTypeQual -> CTypeQual)
-> (CTypeQual -> CTypeQual -> CTypeQual)
-> Ord CTypeQual
CTypeQual -> CTypeQual -> Bool
CTypeQual -> CTypeQual -> Ordering
CTypeQual -> CTypeQual -> CTypeQual
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CTypeQual -> CTypeQual -> CTypeQual
$cmin :: CTypeQual -> CTypeQual -> CTypeQual
max :: CTypeQual -> CTypeQual -> CTypeQual
$cmax :: CTypeQual -> CTypeQual -> CTypeQual
>= :: CTypeQual -> CTypeQual -> Bool
$c>= :: CTypeQual -> CTypeQual -> Bool
> :: CTypeQual -> CTypeQual -> Bool
$c> :: CTypeQual -> CTypeQual -> Bool
<= :: CTypeQual -> CTypeQual -> Bool
$c<= :: CTypeQual -> CTypeQual -> Bool
< :: CTypeQual -> CTypeQual -> Bool
$c< :: CTypeQual -> CTypeQual -> Bool
compare :: CTypeQual -> CTypeQual -> Ordering
$ccompare :: CTypeQual -> CTypeQual -> Ordering
$cp1Ord :: Eq CTypeQual
Ord)

data CFunSpec = Inline
  deriving (Int -> CFunSpec -> ShowS
[CFunSpec] -> ShowS
CFunSpec -> String
(Int -> CFunSpec -> ShowS)
-> (CFunSpec -> String) -> ([CFunSpec] -> ShowS) -> Show CFunSpec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CFunSpec] -> ShowS
$cshowList :: [CFunSpec] -> ShowS
show :: CFunSpec -> String
$cshow :: CFunSpec -> String
showsPrec :: Int -> CFunSpec -> ShowS
$cshowsPrec :: Int -> CFunSpec -> ShowS
Show, CFunSpec -> CFunSpec -> Bool
(CFunSpec -> CFunSpec -> Bool)
-> (CFunSpec -> CFunSpec -> Bool) -> Eq CFunSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CFunSpec -> CFunSpec -> Bool
$c/= :: CFunSpec -> CFunSpec -> Bool
== :: CFunSpec -> CFunSpec -> Bool
$c== :: CFunSpec -> CFunSpec -> Bool
Eq, Eq CFunSpec
Eq CFunSpec
-> (CFunSpec -> CFunSpec -> Ordering)
-> (CFunSpec -> CFunSpec -> Bool)
-> (CFunSpec -> CFunSpec -> Bool)
-> (CFunSpec -> CFunSpec -> Bool)
-> (CFunSpec -> CFunSpec -> Bool)
-> (CFunSpec -> CFunSpec -> CFunSpec)
-> (CFunSpec -> CFunSpec -> CFunSpec)
-> Ord CFunSpec
CFunSpec -> CFunSpec -> Bool
CFunSpec -> CFunSpec -> Ordering
CFunSpec -> CFunSpec -> CFunSpec
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CFunSpec -> CFunSpec -> CFunSpec
$cmin :: CFunSpec -> CFunSpec -> CFunSpec
max :: CFunSpec -> CFunSpec -> CFunSpec
$cmax :: CFunSpec -> CFunSpec -> CFunSpec
>= :: CFunSpec -> CFunSpec -> Bool
$c>= :: CFunSpec -> CFunSpec -> Bool
> :: CFunSpec -> CFunSpec -> Bool
$c> :: CFunSpec -> CFunSpec -> Bool
<= :: CFunSpec -> CFunSpec -> Bool
$c<= :: CFunSpec -> CFunSpec -> Bool
< :: CFunSpec -> CFunSpec -> Bool
$c< :: CFunSpec -> CFunSpec -> Bool
compare :: CFunSpec -> CFunSpec -> Ordering
$ccompare :: CFunSpec -> CFunSpec -> Ordering
$cp1Ord :: Eq CFunSpec
Ord)

data CTypeSpec
  = CVoid
  | CChar
  | CShort
  | CInt
  | CLong
  | CFloat
  | CDouble
  | CSigned
  | CUnsigned
  | CSUType      CSUSpec
  | CTypeDefType Ident
  | CEnumType    CEnum
  deriving (Int -> CTypeSpec -> ShowS
[CTypeSpec] -> ShowS
CTypeSpec -> String
(Int -> CTypeSpec -> ShowS)
-> (CTypeSpec -> String)
-> ([CTypeSpec] -> ShowS)
-> Show CTypeSpec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CTypeSpec] -> ShowS
$cshowList :: [CTypeSpec] -> ShowS
show :: CTypeSpec -> String
$cshow :: CTypeSpec -> String
showsPrec :: Int -> CTypeSpec -> ShowS
$cshowsPrec :: Int -> CTypeSpec -> ShowS
Show, CTypeSpec -> CTypeSpec -> Bool
(CTypeSpec -> CTypeSpec -> Bool)
-> (CTypeSpec -> CTypeSpec -> Bool) -> Eq CTypeSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CTypeSpec -> CTypeSpec -> Bool
$c/= :: CTypeSpec -> CTypeSpec -> Bool
== :: CTypeSpec -> CTypeSpec -> Bool
$c== :: CTypeSpec -> CTypeSpec -> Bool
Eq, Eq CTypeSpec
Eq CTypeSpec
-> (CTypeSpec -> CTypeSpec -> Ordering)
-> (CTypeSpec -> CTypeSpec -> Bool)
-> (CTypeSpec -> CTypeSpec -> Bool)
-> (CTypeSpec -> CTypeSpec -> Bool)
-> (CTypeSpec -> CTypeSpec -> Bool)
-> (CTypeSpec -> CTypeSpec -> CTypeSpec)
-> (CTypeSpec -> CTypeSpec -> CTypeSpec)
-> Ord CTypeSpec
CTypeSpec -> CTypeSpec -> Bool
CTypeSpec -> CTypeSpec -> Ordering
CTypeSpec -> CTypeSpec -> CTypeSpec
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CTypeSpec -> CTypeSpec -> CTypeSpec
$cmin :: CTypeSpec -> CTypeSpec -> CTypeSpec
max :: CTypeSpec -> CTypeSpec -> CTypeSpec
$cmax :: CTypeSpec -> CTypeSpec -> CTypeSpec
>= :: CTypeSpec -> CTypeSpec -> Bool
$c>= :: CTypeSpec -> CTypeSpec -> Bool
> :: CTypeSpec -> CTypeSpec -> Bool
$c> :: CTypeSpec -> CTypeSpec -> Bool
<= :: CTypeSpec -> CTypeSpec -> Bool
$c<= :: CTypeSpec -> CTypeSpec -> Bool
< :: CTypeSpec -> CTypeSpec -> Bool
$c< :: CTypeSpec -> CTypeSpec -> Bool
compare :: CTypeSpec -> CTypeSpec -> Ordering
$ccompare :: CTypeSpec -> CTypeSpec -> Ordering
$cp1Ord :: Eq CTypeSpec
Ord)

-- CTypeName is necessary for cast operations, see C99 pp81 and pp122
-- For now, we only need to use these casts for malloc, so this is
-- incomplete with respect to C99
data CTypeName
  = CTypeName [CTypeSpec] Bool
  deriving (Int -> CTypeName -> ShowS
[CTypeName] -> ShowS
CTypeName -> String
(Int -> CTypeName -> ShowS)
-> (CTypeName -> String)
-> ([CTypeName] -> ShowS)
-> Show CTypeName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CTypeName] -> ShowS
$cshowList :: [CTypeName] -> ShowS
show :: CTypeName -> String
$cshow :: CTypeName -> String
showsPrec :: Int -> CTypeName -> ShowS
$cshowsPrec :: Int -> CTypeName -> ShowS
Show, CTypeName -> CTypeName -> Bool
(CTypeName -> CTypeName -> Bool)
-> (CTypeName -> CTypeName -> Bool) -> Eq CTypeName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CTypeName -> CTypeName -> Bool
$c/= :: CTypeName -> CTypeName -> Bool
== :: CTypeName -> CTypeName -> Bool
$c== :: CTypeName -> CTypeName -> Bool
Eq, Eq CTypeName
Eq CTypeName
-> (CTypeName -> CTypeName -> Ordering)
-> (CTypeName -> CTypeName -> Bool)
-> (CTypeName -> CTypeName -> Bool)
-> (CTypeName -> CTypeName -> Bool)
-> (CTypeName -> CTypeName -> Bool)
-> (CTypeName -> CTypeName -> CTypeName)
-> (CTypeName -> CTypeName -> CTypeName)
-> Ord CTypeName
CTypeName -> CTypeName -> Bool
CTypeName -> CTypeName -> Ordering
CTypeName -> CTypeName -> CTypeName
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CTypeName -> CTypeName -> CTypeName
$cmin :: CTypeName -> CTypeName -> CTypeName
max :: CTypeName -> CTypeName -> CTypeName
$cmax :: CTypeName -> CTypeName -> CTypeName
>= :: CTypeName -> CTypeName -> Bool
$c>= :: CTypeName -> CTypeName -> Bool
> :: CTypeName -> CTypeName -> Bool
$c> :: CTypeName -> CTypeName -> Bool
<= :: CTypeName -> CTypeName -> Bool
$c<= :: CTypeName -> CTypeName -> Bool
< :: CTypeName -> CTypeName -> Bool
$c< :: CTypeName -> CTypeName -> Bool
compare :: CTypeName -> CTypeName -> Ordering
$ccompare :: CTypeName -> CTypeName -> Ordering
$cp1Ord :: Eq CTypeName
Ord)

data CSUSpec
  = CSUSpec CSUTag (Maybe Ident) [CDecl]
  deriving (Int -> CSUSpec -> ShowS
[CSUSpec] -> ShowS
CSUSpec -> String
(Int -> CSUSpec -> ShowS)
-> (CSUSpec -> String) -> ([CSUSpec] -> ShowS) -> Show CSUSpec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CSUSpec] -> ShowS
$cshowList :: [CSUSpec] -> ShowS
show :: CSUSpec -> String
$cshow :: CSUSpec -> String
showsPrec :: Int -> CSUSpec -> ShowS
$cshowsPrec :: Int -> CSUSpec -> ShowS
Show, CSUSpec -> CSUSpec -> Bool
(CSUSpec -> CSUSpec -> Bool)
-> (CSUSpec -> CSUSpec -> Bool) -> Eq CSUSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CSUSpec -> CSUSpec -> Bool
$c/= :: CSUSpec -> CSUSpec -> Bool
== :: CSUSpec -> CSUSpec -> Bool
$c== :: CSUSpec -> CSUSpec -> Bool
Eq, Eq CSUSpec
Eq CSUSpec
-> (CSUSpec -> CSUSpec -> Ordering)
-> (CSUSpec -> CSUSpec -> Bool)
-> (CSUSpec -> CSUSpec -> Bool)
-> (CSUSpec -> CSUSpec -> Bool)
-> (CSUSpec -> CSUSpec -> Bool)
-> (CSUSpec -> CSUSpec -> CSUSpec)
-> (CSUSpec -> CSUSpec -> CSUSpec)
-> Ord CSUSpec
CSUSpec -> CSUSpec -> Bool
CSUSpec -> CSUSpec -> Ordering
CSUSpec -> CSUSpec -> CSUSpec
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CSUSpec -> CSUSpec -> CSUSpec
$cmin :: CSUSpec -> CSUSpec -> CSUSpec
max :: CSUSpec -> CSUSpec -> CSUSpec
$cmax :: CSUSpec -> CSUSpec -> CSUSpec
>= :: CSUSpec -> CSUSpec -> Bool
$c>= :: CSUSpec -> CSUSpec -> Bool
> :: CSUSpec -> CSUSpec -> Bool
$c> :: CSUSpec -> CSUSpec -> Bool
<= :: CSUSpec -> CSUSpec -> Bool
$c<= :: CSUSpec -> CSUSpec -> Bool
< :: CSUSpec -> CSUSpec -> Bool
$c< :: CSUSpec -> CSUSpec -> Bool
compare :: CSUSpec -> CSUSpec -> Ordering
$ccompare :: CSUSpec -> CSUSpec -> Ordering
$cp1Ord :: Eq CSUSpec
Ord)

data CSUTag
  = CStructTag
  | CUnionTag
  deriving (Int -> CSUTag -> ShowS
[CSUTag] -> ShowS
CSUTag -> String
(Int -> CSUTag -> ShowS)
-> (CSUTag -> String) -> ([CSUTag] -> ShowS) -> Show CSUTag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CSUTag] -> ShowS
$cshowList :: [CSUTag] -> ShowS
show :: CSUTag -> String
$cshow :: CSUTag -> String
showsPrec :: Int -> CSUTag -> ShowS
$cshowsPrec :: Int -> CSUTag -> ShowS
Show, CSUTag -> CSUTag -> Bool
(CSUTag -> CSUTag -> Bool)
-> (CSUTag -> CSUTag -> Bool) -> Eq CSUTag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CSUTag -> CSUTag -> Bool
$c/= :: CSUTag -> CSUTag -> Bool
== :: CSUTag -> CSUTag -> Bool
$c== :: CSUTag -> CSUTag -> Bool
Eq, Eq CSUTag
Eq CSUTag
-> (CSUTag -> CSUTag -> Ordering)
-> (CSUTag -> CSUTag -> Bool)
-> (CSUTag -> CSUTag -> Bool)
-> (CSUTag -> CSUTag -> Bool)
-> (CSUTag -> CSUTag -> Bool)
-> (CSUTag -> CSUTag -> CSUTag)
-> (CSUTag -> CSUTag -> CSUTag)
-> Ord CSUTag
CSUTag -> CSUTag -> Bool
CSUTag -> CSUTag -> Ordering
CSUTag -> CSUTag -> CSUTag
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CSUTag -> CSUTag -> CSUTag
$cmin :: CSUTag -> CSUTag -> CSUTag
max :: CSUTag -> CSUTag -> CSUTag
$cmax :: CSUTag -> CSUTag -> CSUTag
>= :: CSUTag -> CSUTag -> Bool
$c>= :: CSUTag -> CSUTag -> Bool
> :: CSUTag -> CSUTag -> Bool
$c> :: CSUTag -> CSUTag -> Bool
<= :: CSUTag -> CSUTag -> Bool
$c<= :: CSUTag -> CSUTag -> Bool
< :: CSUTag -> CSUTag -> Bool
$c< :: CSUTag -> CSUTag -> Bool
compare :: CSUTag -> CSUTag -> Ordering
$ccompare :: CSUTag -> CSUTag -> Ordering
$cp1Ord :: Eq CSUTag
Ord)

data CEnum
  = CEnum (Maybe Ident) [(Ident, Maybe CExpr)]
  deriving (Int -> CEnum -> ShowS
[CEnum] -> ShowS
CEnum -> String
(Int -> CEnum -> ShowS)
-> (CEnum -> String) -> ([CEnum] -> ShowS) -> Show CEnum
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CEnum] -> ShowS
$cshowList :: [CEnum] -> ShowS
show :: CEnum -> String
$cshow :: CEnum -> String
showsPrec :: Int -> CEnum -> ShowS
$cshowsPrec :: Int -> CEnum -> ShowS
Show, CEnum -> CEnum -> Bool
(CEnum -> CEnum -> Bool) -> (CEnum -> CEnum -> Bool) -> Eq CEnum
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CEnum -> CEnum -> Bool
$c/= :: CEnum -> CEnum -> Bool
== :: CEnum -> CEnum -> Bool
$c== :: CEnum -> CEnum -> Bool
Eq, Eq CEnum
Eq CEnum
-> (CEnum -> CEnum -> Ordering)
-> (CEnum -> CEnum -> Bool)
-> (CEnum -> CEnum -> Bool)
-> (CEnum -> CEnum -> Bool)
-> (CEnum -> CEnum -> Bool)
-> (CEnum -> CEnum -> CEnum)
-> (CEnum -> CEnum -> CEnum)
-> Ord CEnum
CEnum -> CEnum -> Bool
CEnum -> CEnum -> Ordering
CEnum -> CEnum -> CEnum
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CEnum -> CEnum -> CEnum
$cmin :: CEnum -> CEnum -> CEnum
max :: CEnum -> CEnum -> CEnum
$cmax :: CEnum -> CEnum -> CEnum
>= :: CEnum -> CEnum -> Bool
$c>= :: CEnum -> CEnum -> Bool
> :: CEnum -> CEnum -> Bool
$c> :: CEnum -> CEnum -> Bool
<= :: CEnum -> CEnum -> Bool
$c<= :: CEnum -> CEnum -> Bool
< :: CEnum -> CEnum -> Bool
$c< :: CEnum -> CEnum -> Bool
compare :: CEnum -> CEnum -> Ordering
$ccompare :: CEnum -> CEnum -> Ordering
$cp1Ord :: Eq CEnum
Ord)

-----------------
-- Declarators --
-----------------
{-
  Declarators give us labels to point at and describe the level of indirection.
  between a label and the underlieing memory

  this is incomplete, see c99 reference p115
-}

data CDeclr
  = CDeclr (Maybe CPtrDeclr) CDirectDeclr
  deriving (Int -> CDeclr -> ShowS
[CDeclr] -> ShowS
CDeclr -> String
(Int -> CDeclr -> ShowS)
-> (CDeclr -> String) -> ([CDeclr] -> ShowS) -> Show CDeclr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CDeclr] -> ShowS
$cshowList :: [CDeclr] -> ShowS
show :: CDeclr -> String
$cshow :: CDeclr -> String
showsPrec :: Int -> CDeclr -> ShowS
$cshowsPrec :: Int -> CDeclr -> ShowS
Show, CDeclr -> CDeclr -> Bool
(CDeclr -> CDeclr -> Bool)
-> (CDeclr -> CDeclr -> Bool) -> Eq CDeclr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CDeclr -> CDeclr -> Bool
$c/= :: CDeclr -> CDeclr -> Bool
== :: CDeclr -> CDeclr -> Bool
$c== :: CDeclr -> CDeclr -> Bool
Eq, Eq CDeclr
Eq CDeclr
-> (CDeclr -> CDeclr -> Ordering)
-> (CDeclr -> CDeclr -> Bool)
-> (CDeclr -> CDeclr -> Bool)
-> (CDeclr -> CDeclr -> Bool)
-> (CDeclr -> CDeclr -> Bool)
-> (CDeclr -> CDeclr -> CDeclr)
-> (CDeclr -> CDeclr -> CDeclr)
-> Ord CDeclr
CDeclr -> CDeclr -> Bool
CDeclr -> CDeclr -> Ordering
CDeclr -> CDeclr -> CDeclr
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CDeclr -> CDeclr -> CDeclr
$cmin :: CDeclr -> CDeclr -> CDeclr
max :: CDeclr -> CDeclr -> CDeclr
$cmax :: CDeclr -> CDeclr -> CDeclr
>= :: CDeclr -> CDeclr -> Bool
$c>= :: CDeclr -> CDeclr -> Bool
> :: CDeclr -> CDeclr -> Bool
$c> :: CDeclr -> CDeclr -> Bool
<= :: CDeclr -> CDeclr -> Bool
$c<= :: CDeclr -> CDeclr -> Bool
< :: CDeclr -> CDeclr -> Bool
$c< :: CDeclr -> CDeclr -> Bool
compare :: CDeclr -> CDeclr -> Ordering
$ccompare :: CDeclr -> CDeclr -> Ordering
$cp1Ord :: Eq CDeclr
Ord)

data CPtrDeclr = CPtrDeclr [CTypeQual]
  deriving (Int -> CPtrDeclr -> ShowS
[CPtrDeclr] -> ShowS
CPtrDeclr -> String
(Int -> CPtrDeclr -> ShowS)
-> (CPtrDeclr -> String)
-> ([CPtrDeclr] -> ShowS)
-> Show CPtrDeclr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CPtrDeclr] -> ShowS
$cshowList :: [CPtrDeclr] -> ShowS
show :: CPtrDeclr -> String
$cshow :: CPtrDeclr -> String
showsPrec :: Int -> CPtrDeclr -> ShowS
$cshowsPrec :: Int -> CPtrDeclr -> ShowS
Show, CPtrDeclr -> CPtrDeclr -> Bool
(CPtrDeclr -> CPtrDeclr -> Bool)
-> (CPtrDeclr -> CPtrDeclr -> Bool) -> Eq CPtrDeclr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CPtrDeclr -> CPtrDeclr -> Bool
$c/= :: CPtrDeclr -> CPtrDeclr -> Bool
== :: CPtrDeclr -> CPtrDeclr -> Bool
$c== :: CPtrDeclr -> CPtrDeclr -> Bool
Eq, Eq CPtrDeclr
Eq CPtrDeclr
-> (CPtrDeclr -> CPtrDeclr -> Ordering)
-> (CPtrDeclr -> CPtrDeclr -> Bool)
-> (CPtrDeclr -> CPtrDeclr -> Bool)
-> (CPtrDeclr -> CPtrDeclr -> Bool)
-> (CPtrDeclr -> CPtrDeclr -> Bool)
-> (CPtrDeclr -> CPtrDeclr -> CPtrDeclr)
-> (CPtrDeclr -> CPtrDeclr -> CPtrDeclr)
-> Ord CPtrDeclr
CPtrDeclr -> CPtrDeclr -> Bool
CPtrDeclr -> CPtrDeclr -> Ordering
CPtrDeclr -> CPtrDeclr -> CPtrDeclr
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CPtrDeclr -> CPtrDeclr -> CPtrDeclr
$cmin :: CPtrDeclr -> CPtrDeclr -> CPtrDeclr
max :: CPtrDeclr -> CPtrDeclr -> CPtrDeclr
$cmax :: CPtrDeclr -> CPtrDeclr -> CPtrDeclr
>= :: CPtrDeclr -> CPtrDeclr -> Bool
$c>= :: CPtrDeclr -> CPtrDeclr -> Bool
> :: CPtrDeclr -> CPtrDeclr -> Bool
$c> :: CPtrDeclr -> CPtrDeclr -> Bool
<= :: CPtrDeclr -> CPtrDeclr -> Bool
$c<= :: CPtrDeclr -> CPtrDeclr -> Bool
< :: CPtrDeclr -> CPtrDeclr -> Bool
$c< :: CPtrDeclr -> CPtrDeclr -> Bool
compare :: CPtrDeclr -> CPtrDeclr -> Ordering
$ccompare :: CPtrDeclr -> CPtrDeclr -> Ordering
$cp1Ord :: Eq CPtrDeclr
Ord)

data CDirectDeclr
  = CDDeclrIdent Ident
  | CDDeclrArr   CDirectDeclr (Maybe CExpr)
  | CDDeclrFun   CDirectDeclr [[CTypeSpec]]
  | CDDeclrRec   CDeclr
  deriving (Int -> CDirectDeclr -> ShowS
[CDirectDeclr] -> ShowS
CDirectDeclr -> String
(Int -> CDirectDeclr -> ShowS)
-> (CDirectDeclr -> String)
-> ([CDirectDeclr] -> ShowS)
-> Show CDirectDeclr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CDirectDeclr] -> ShowS
$cshowList :: [CDirectDeclr] -> ShowS
show :: CDirectDeclr -> String
$cshow :: CDirectDeclr -> String
showsPrec :: Int -> CDirectDeclr -> ShowS
$cshowsPrec :: Int -> CDirectDeclr -> ShowS
Show, CDirectDeclr -> CDirectDeclr -> Bool
(CDirectDeclr -> CDirectDeclr -> Bool)
-> (CDirectDeclr -> CDirectDeclr -> Bool) -> Eq CDirectDeclr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CDirectDeclr -> CDirectDeclr -> Bool
$c/= :: CDirectDeclr -> CDirectDeclr -> Bool
== :: CDirectDeclr -> CDirectDeclr -> Bool
$c== :: CDirectDeclr -> CDirectDeclr -> Bool
Eq, Eq CDirectDeclr
Eq CDirectDeclr
-> (CDirectDeclr -> CDirectDeclr -> Ordering)
-> (CDirectDeclr -> CDirectDeclr -> Bool)
-> (CDirectDeclr -> CDirectDeclr -> Bool)
-> (CDirectDeclr -> CDirectDeclr -> Bool)
-> (CDirectDeclr -> CDirectDeclr -> Bool)
-> (CDirectDeclr -> CDirectDeclr -> CDirectDeclr)
-> (CDirectDeclr -> CDirectDeclr -> CDirectDeclr)
-> Ord CDirectDeclr
CDirectDeclr -> CDirectDeclr -> Bool
CDirectDeclr -> CDirectDeclr -> Ordering
CDirectDeclr -> CDirectDeclr -> CDirectDeclr
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CDirectDeclr -> CDirectDeclr -> CDirectDeclr
$cmin :: CDirectDeclr -> CDirectDeclr -> CDirectDeclr
max :: CDirectDeclr -> CDirectDeclr -> CDirectDeclr
$cmax :: CDirectDeclr -> CDirectDeclr -> CDirectDeclr
>= :: CDirectDeclr -> CDirectDeclr -> Bool
$c>= :: CDirectDeclr -> CDirectDeclr -> Bool
> :: CDirectDeclr -> CDirectDeclr -> Bool
$c> :: CDirectDeclr -> CDirectDeclr -> Bool
<= :: CDirectDeclr -> CDirectDeclr -> Bool
$c<= :: CDirectDeclr -> CDirectDeclr -> Bool
< :: CDirectDeclr -> CDirectDeclr -> Bool
$c< :: CDirectDeclr -> CDirectDeclr -> Bool
compare :: CDirectDeclr -> CDirectDeclr -> Ordering
$ccompare :: CDirectDeclr -> CDirectDeclr -> Ordering
$cp1Ord :: Eq CDirectDeclr
Ord)

------------------
-- Initializers --
------------------
{-
  Initializers allow us to fill our objects with values right as they are
  declared rather than as a side-effect later in the program.
-}

data CInit
  = CInitExpr CExpr
  | CInitList [([CPartDesig], CInit)]
  deriving (Int -> CInit -> ShowS
[CInit] -> ShowS
CInit -> String
(Int -> CInit -> ShowS)
-> (CInit -> String) -> ([CInit] -> ShowS) -> Show CInit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CInit] -> ShowS
$cshowList :: [CInit] -> ShowS
show :: CInit -> String
$cshow :: CInit -> String
showsPrec :: Int -> CInit -> ShowS
$cshowsPrec :: Int -> CInit -> ShowS
Show, CInit -> CInit -> Bool
(CInit -> CInit -> Bool) -> (CInit -> CInit -> Bool) -> Eq CInit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CInit -> CInit -> Bool
$c/= :: CInit -> CInit -> Bool
== :: CInit -> CInit -> Bool
$c== :: CInit -> CInit -> Bool
Eq, Eq CInit
Eq CInit
-> (CInit -> CInit -> Ordering)
-> (CInit -> CInit -> Bool)
-> (CInit -> CInit -> Bool)
-> (CInit -> CInit -> Bool)
-> (CInit -> CInit -> Bool)
-> (CInit -> CInit -> CInit)
-> (CInit -> CInit -> CInit)
-> Ord CInit
CInit -> CInit -> Bool
CInit -> CInit -> Ordering
CInit -> CInit -> CInit
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CInit -> CInit -> CInit
$cmin :: CInit -> CInit -> CInit
max :: CInit -> CInit -> CInit
$cmax :: CInit -> CInit -> CInit
>= :: CInit -> CInit -> Bool
$c>= :: CInit -> CInit -> Bool
> :: CInit -> CInit -> Bool
$c> :: CInit -> CInit -> Bool
<= :: CInit -> CInit -> Bool
$c<= :: CInit -> CInit -> Bool
< :: CInit -> CInit -> Bool
$c< :: CInit -> CInit -> Bool
compare :: CInit -> CInit -> Ordering
$ccompare :: CInit -> CInit -> Ordering
$cp1Ord :: Eq CInit
Ord)

data CPartDesig
  = CArrDesig    CExpr
  | CMemberDesig CExpr
  deriving (Int -> CPartDesig -> ShowS
[CPartDesig] -> ShowS
CPartDesig -> String
(Int -> CPartDesig -> ShowS)
-> (CPartDesig -> String)
-> ([CPartDesig] -> ShowS)
-> Show CPartDesig
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CPartDesig] -> ShowS
$cshowList :: [CPartDesig] -> ShowS
show :: CPartDesig -> String
$cshow :: CPartDesig -> String
showsPrec :: Int -> CPartDesig -> ShowS
$cshowsPrec :: Int -> CPartDesig -> ShowS
Show, CPartDesig -> CPartDesig -> Bool
(CPartDesig -> CPartDesig -> Bool)
-> (CPartDesig -> CPartDesig -> Bool) -> Eq CPartDesig
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CPartDesig -> CPartDesig -> Bool
$c/= :: CPartDesig -> CPartDesig -> Bool
== :: CPartDesig -> CPartDesig -> Bool
$c== :: CPartDesig -> CPartDesig -> Bool
Eq, Eq CPartDesig
Eq CPartDesig
-> (CPartDesig -> CPartDesig -> Ordering)
-> (CPartDesig -> CPartDesig -> Bool)
-> (CPartDesig -> CPartDesig -> Bool)
-> (CPartDesig -> CPartDesig -> Bool)
-> (CPartDesig -> CPartDesig -> Bool)
-> (CPartDesig -> CPartDesig -> CPartDesig)
-> (CPartDesig -> CPartDesig -> CPartDesig)
-> Ord CPartDesig
CPartDesig -> CPartDesig -> Bool
CPartDesig -> CPartDesig -> Ordering
CPartDesig -> CPartDesig -> CPartDesig
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CPartDesig -> CPartDesig -> CPartDesig
$cmin :: CPartDesig -> CPartDesig -> CPartDesig
max :: CPartDesig -> CPartDesig -> CPartDesig
$cmax :: CPartDesig -> CPartDesig -> CPartDesig
>= :: CPartDesig -> CPartDesig -> Bool
$c>= :: CPartDesig -> CPartDesig -> Bool
> :: CPartDesig -> CPartDesig -> Bool
$c> :: CPartDesig -> CPartDesig -> Bool
<= :: CPartDesig -> CPartDesig -> Bool
$c<= :: CPartDesig -> CPartDesig -> Bool
< :: CPartDesig -> CPartDesig -> Bool
$c< :: CPartDesig -> CPartDesig -> Bool
compare :: CPartDesig -> CPartDesig -> Ordering
$ccompare :: CPartDesig -> CPartDesig -> Ordering
$cp1Ord :: Eq CPartDesig
Ord)

--------------------------------------------------------------------------------
--                                C Statments                                 --
--------------------------------------------------------------------------------
{-
  The separation between C Statements and C Expressions is fuzzy. Here we take
  statements as side-effecting operations sequenced by the ";" in pedantic C
  concrete syntax. Though operators like "++" that are represented as C
  Expressions in this AST also perform side-effects.
-}

data CStat
  = CLabel    Ident CStat
  | CGoto     Ident
  | CSwitch   CExpr CStat
  | CCase     CExpr CStat
  | CDefault  CStat
  | CExpr     (Maybe CExpr)
  | CCompound [CCompoundBlockItem]
  | CIf       CExpr CStat (Maybe CStat)
  | CWhile    CExpr CStat Bool
  | CFor      (Maybe CExpr) (Maybe CExpr) (Maybe CExpr) CStat
  | CCont
  | CBreak
  | CReturn   (Maybe CExpr)
  | CComment  String
  | CPPStat   Preprocessor
  deriving (Int -> CStat -> ShowS
[CStat] -> ShowS
CStat -> String
(Int -> CStat -> ShowS)
-> (CStat -> String) -> ([CStat] -> ShowS) -> Show CStat
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CStat] -> ShowS
$cshowList :: [CStat] -> ShowS
show :: CStat -> String
$cshow :: CStat -> String
showsPrec :: Int -> CStat -> ShowS
$cshowsPrec :: Int -> CStat -> ShowS
Show, CStat -> CStat -> Bool
(CStat -> CStat -> Bool) -> (CStat -> CStat -> Bool) -> Eq CStat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CStat -> CStat -> Bool
$c/= :: CStat -> CStat -> Bool
== :: CStat -> CStat -> Bool
$c== :: CStat -> CStat -> Bool
Eq, Eq CStat
Eq CStat
-> (CStat -> CStat -> Ordering)
-> (CStat -> CStat -> Bool)
-> (CStat -> CStat -> Bool)
-> (CStat -> CStat -> Bool)
-> (CStat -> CStat -> Bool)
-> (CStat -> CStat -> CStat)
-> (CStat -> CStat -> CStat)
-> Ord CStat
CStat -> CStat -> Bool
CStat -> CStat -> Ordering
CStat -> CStat -> CStat
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CStat -> CStat -> CStat
$cmin :: CStat -> CStat -> CStat
max :: CStat -> CStat -> CStat
$cmax :: CStat -> CStat -> CStat
>= :: CStat -> CStat -> Bool
$c>= :: CStat -> CStat -> Bool
> :: CStat -> CStat -> Bool
$c> :: CStat -> CStat -> Bool
<= :: CStat -> CStat -> Bool
$c<= :: CStat -> CStat -> Bool
< :: CStat -> CStat -> Bool
$c< :: CStat -> CStat -> Bool
compare :: CStat -> CStat -> Ordering
$ccompare :: CStat -> CStat -> Ordering
$cp1Ord :: Eq CStat
Ord)

data CCompoundBlockItem
  = CBlockStat CStat
  | CBlockDecl CDecl
  deriving (Int -> CCompoundBlockItem -> ShowS
[CCompoundBlockItem] -> ShowS
CCompoundBlockItem -> String
(Int -> CCompoundBlockItem -> ShowS)
-> (CCompoundBlockItem -> String)
-> ([CCompoundBlockItem] -> ShowS)
-> Show CCompoundBlockItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CCompoundBlockItem] -> ShowS
$cshowList :: [CCompoundBlockItem] -> ShowS
show :: CCompoundBlockItem -> String
$cshow :: CCompoundBlockItem -> String
showsPrec :: Int -> CCompoundBlockItem -> ShowS
$cshowsPrec :: Int -> CCompoundBlockItem -> ShowS
Show, CCompoundBlockItem -> CCompoundBlockItem -> Bool
(CCompoundBlockItem -> CCompoundBlockItem -> Bool)
-> (CCompoundBlockItem -> CCompoundBlockItem -> Bool)
-> Eq CCompoundBlockItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CCompoundBlockItem -> CCompoundBlockItem -> Bool
$c/= :: CCompoundBlockItem -> CCompoundBlockItem -> Bool
== :: CCompoundBlockItem -> CCompoundBlockItem -> Bool
$c== :: CCompoundBlockItem -> CCompoundBlockItem -> Bool
Eq, Eq CCompoundBlockItem
Eq CCompoundBlockItem
-> (CCompoundBlockItem -> CCompoundBlockItem -> Ordering)
-> (CCompoundBlockItem -> CCompoundBlockItem -> Bool)
-> (CCompoundBlockItem -> CCompoundBlockItem -> Bool)
-> (CCompoundBlockItem -> CCompoundBlockItem -> Bool)
-> (CCompoundBlockItem -> CCompoundBlockItem -> Bool)
-> (CCompoundBlockItem -> CCompoundBlockItem -> CCompoundBlockItem)
-> (CCompoundBlockItem -> CCompoundBlockItem -> CCompoundBlockItem)
-> Ord CCompoundBlockItem
CCompoundBlockItem -> CCompoundBlockItem -> Bool
CCompoundBlockItem -> CCompoundBlockItem -> Ordering
CCompoundBlockItem -> CCompoundBlockItem -> CCompoundBlockItem
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CCompoundBlockItem -> CCompoundBlockItem -> CCompoundBlockItem
$cmin :: CCompoundBlockItem -> CCompoundBlockItem -> CCompoundBlockItem
max :: CCompoundBlockItem -> CCompoundBlockItem -> CCompoundBlockItem
$cmax :: CCompoundBlockItem -> CCompoundBlockItem -> CCompoundBlockItem
>= :: CCompoundBlockItem -> CCompoundBlockItem -> Bool
$c>= :: CCompoundBlockItem -> CCompoundBlockItem -> Bool
> :: CCompoundBlockItem -> CCompoundBlockItem -> Bool
$c> :: CCompoundBlockItem -> CCompoundBlockItem -> Bool
<= :: CCompoundBlockItem -> CCompoundBlockItem -> Bool
$c<= :: CCompoundBlockItem -> CCompoundBlockItem -> Bool
< :: CCompoundBlockItem -> CCompoundBlockItem -> Bool
$c< :: CCompoundBlockItem -> CCompoundBlockItem -> Bool
compare :: CCompoundBlockItem -> CCompoundBlockItem -> Ordering
$ccompare :: CCompoundBlockItem -> CCompoundBlockItem -> Ordering
$cp1Ord :: Eq CCompoundBlockItem
Ord)

--------------------------------------------------------------------------------
--                                C Expressions                               --
--------------------------------------------------------------------------------
{-
  See C Statments...
-}

data CExpr
  = CComma       [CExpr]
  | CAssign      CAssignOp CExpr CExpr
  | CCond        CExpr CExpr CExpr
  | CBinary      CBinaryOp CExpr CExpr
  | CCast        CTypeName CExpr
  | CUnary       CUnaryOp CExpr
  | CSizeOfExpr  CExpr
  | CSizeOfType  CTypeName
  | CIndex       CExpr CExpr
  | CCall        CExpr [CExpr]
  | CMember      CExpr Ident Bool
  | CVar         Ident
  | CConstant    CConst
  | CCompoundLit CDecl CInit
  deriving (Int -> CExpr -> ShowS
[CExpr] -> ShowS
CExpr -> String
(Int -> CExpr -> ShowS)
-> (CExpr -> String) -> ([CExpr] -> ShowS) -> Show CExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CExpr] -> ShowS
$cshowList :: [CExpr] -> ShowS
show :: CExpr -> String
$cshow :: CExpr -> String
showsPrec :: Int -> CExpr -> ShowS
$cshowsPrec :: Int -> CExpr -> ShowS
Show, CExpr -> CExpr -> Bool
(CExpr -> CExpr -> Bool) -> (CExpr -> CExpr -> Bool) -> Eq CExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CExpr -> CExpr -> Bool
$c/= :: CExpr -> CExpr -> Bool
== :: CExpr -> CExpr -> Bool
$c== :: CExpr -> CExpr -> Bool
Eq, Eq CExpr
Eq CExpr
-> (CExpr -> CExpr -> Ordering)
-> (CExpr -> CExpr -> Bool)
-> (CExpr -> CExpr -> Bool)
-> (CExpr -> CExpr -> Bool)
-> (CExpr -> CExpr -> Bool)
-> (CExpr -> CExpr -> CExpr)
-> (CExpr -> CExpr -> CExpr)
-> Ord CExpr
CExpr -> CExpr -> Bool
CExpr -> CExpr -> Ordering
CExpr -> CExpr -> CExpr
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CExpr -> CExpr -> CExpr
$cmin :: CExpr -> CExpr -> CExpr
max :: CExpr -> CExpr -> CExpr
$cmax :: CExpr -> CExpr -> CExpr
>= :: CExpr -> CExpr -> Bool
$c>= :: CExpr -> CExpr -> Bool
> :: CExpr -> CExpr -> Bool
$c> :: CExpr -> CExpr -> Bool
<= :: CExpr -> CExpr -> Bool
$c<= :: CExpr -> CExpr -> Bool
< :: CExpr -> CExpr -> Bool
$c< :: CExpr -> CExpr -> Bool
compare :: CExpr -> CExpr -> Ordering
$ccompare :: CExpr -> CExpr -> Ordering
$cp1Ord :: Eq CExpr
Ord)


data CAssignOp
  = CAssignOp
  | CMulAssOp
  | CDivAssOp
  | CRmdAssOp
  | CAddAssOp
  | CSubAssOp
  | CShlAssOp
  | CShrAssOp
  | CAndAssOp
  | CXorAssOp
  | COrAssOp
  deriving (Int -> CAssignOp -> ShowS
[CAssignOp] -> ShowS
CAssignOp -> String
(Int -> CAssignOp -> ShowS)
-> (CAssignOp -> String)
-> ([CAssignOp] -> ShowS)
-> Show CAssignOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CAssignOp] -> ShowS
$cshowList :: [CAssignOp] -> ShowS
show :: CAssignOp -> String
$cshow :: CAssignOp -> String
showsPrec :: Int -> CAssignOp -> ShowS
$cshowsPrec :: Int -> CAssignOp -> ShowS
Show, 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, Eq CAssignOp
Eq CAssignOp
-> (CAssignOp -> CAssignOp -> Ordering)
-> (CAssignOp -> CAssignOp -> Bool)
-> (CAssignOp -> CAssignOp -> Bool)
-> (CAssignOp -> CAssignOp -> Bool)
-> (CAssignOp -> CAssignOp -> Bool)
-> (CAssignOp -> CAssignOp -> CAssignOp)
-> (CAssignOp -> CAssignOp -> CAssignOp)
-> Ord CAssignOp
CAssignOp -> CAssignOp -> Bool
CAssignOp -> CAssignOp -> Ordering
CAssignOp -> CAssignOp -> CAssignOp
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CAssignOp -> CAssignOp -> CAssignOp
$cmin :: CAssignOp -> CAssignOp -> CAssignOp
max :: CAssignOp -> CAssignOp -> CAssignOp
$cmax :: CAssignOp -> CAssignOp -> CAssignOp
>= :: CAssignOp -> CAssignOp -> Bool
$c>= :: CAssignOp -> CAssignOp -> Bool
> :: CAssignOp -> CAssignOp -> Bool
$c> :: CAssignOp -> CAssignOp -> Bool
<= :: CAssignOp -> CAssignOp -> Bool
$c<= :: CAssignOp -> CAssignOp -> Bool
< :: CAssignOp -> CAssignOp -> Bool
$c< :: CAssignOp -> CAssignOp -> Bool
compare :: CAssignOp -> CAssignOp -> Ordering
$ccompare :: CAssignOp -> CAssignOp -> Ordering
$cp1Ord :: Eq CAssignOp
Ord)


data CBinaryOp
  = CMulOp
  | CDivOp
  | CRmdOp
  | CAddOp
  | CSubOp
  | CShlOp
  | CShrOp
  | CLeOp
  | CGrOp
  | CLeqOp
  | CGeqOp
  | CEqOp
  | CNeqOp
  | CAndOp
  | CXorOp
  | COrOp
  | CLndOp
  | CLorOp
  deriving (Int -> CBinaryOp -> ShowS
[CBinaryOp] -> ShowS
CBinaryOp -> String
(Int -> CBinaryOp -> ShowS)
-> (CBinaryOp -> String)
-> ([CBinaryOp] -> ShowS)
-> Show CBinaryOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CBinaryOp] -> ShowS
$cshowList :: [CBinaryOp] -> ShowS
show :: CBinaryOp -> String
$cshow :: CBinaryOp -> String
showsPrec :: Int -> CBinaryOp -> ShowS
$cshowsPrec :: Int -> CBinaryOp -> ShowS
Show, 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, Eq CBinaryOp
Eq CBinaryOp
-> (CBinaryOp -> CBinaryOp -> Ordering)
-> (CBinaryOp -> CBinaryOp -> Bool)
-> (CBinaryOp -> CBinaryOp -> Bool)
-> (CBinaryOp -> CBinaryOp -> Bool)
-> (CBinaryOp -> CBinaryOp -> Bool)
-> (CBinaryOp -> CBinaryOp -> CBinaryOp)
-> (CBinaryOp -> CBinaryOp -> CBinaryOp)
-> Ord CBinaryOp
CBinaryOp -> CBinaryOp -> Bool
CBinaryOp -> CBinaryOp -> Ordering
CBinaryOp -> CBinaryOp -> CBinaryOp
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CBinaryOp -> CBinaryOp -> CBinaryOp
$cmin :: CBinaryOp -> CBinaryOp -> CBinaryOp
max :: CBinaryOp -> CBinaryOp -> CBinaryOp
$cmax :: CBinaryOp -> CBinaryOp -> CBinaryOp
>= :: CBinaryOp -> CBinaryOp -> Bool
$c>= :: CBinaryOp -> CBinaryOp -> Bool
> :: CBinaryOp -> CBinaryOp -> Bool
$c> :: CBinaryOp -> CBinaryOp -> Bool
<= :: CBinaryOp -> CBinaryOp -> Bool
$c<= :: CBinaryOp -> CBinaryOp -> Bool
< :: CBinaryOp -> CBinaryOp -> Bool
$c< :: CBinaryOp -> CBinaryOp -> Bool
compare :: CBinaryOp -> CBinaryOp -> Ordering
$ccompare :: CBinaryOp -> CBinaryOp -> Ordering
$cp1Ord :: Eq CBinaryOp
Ord)


data CUnaryOp
  = CPreIncOp
  | CPreDecOp
  | CPostIncOp
  | CPostDecOp
  | CAdrOp
  | CIndOp
  | CPlusOp
  | CMinOp
  | CCompOp
  | CNegOp
  deriving (Int -> CUnaryOp -> ShowS
[CUnaryOp] -> ShowS
CUnaryOp -> String
(Int -> CUnaryOp -> ShowS)
-> (CUnaryOp -> String) -> ([CUnaryOp] -> ShowS) -> Show CUnaryOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CUnaryOp] -> ShowS
$cshowList :: [CUnaryOp] -> ShowS
show :: CUnaryOp -> String
$cshow :: CUnaryOp -> String
showsPrec :: Int -> CUnaryOp -> ShowS
$cshowsPrec :: Int -> CUnaryOp -> ShowS
Show, 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, Eq CUnaryOp
Eq CUnaryOp
-> (CUnaryOp -> CUnaryOp -> Ordering)
-> (CUnaryOp -> CUnaryOp -> Bool)
-> (CUnaryOp -> CUnaryOp -> Bool)
-> (CUnaryOp -> CUnaryOp -> Bool)
-> (CUnaryOp -> CUnaryOp -> Bool)
-> (CUnaryOp -> CUnaryOp -> CUnaryOp)
-> (CUnaryOp -> CUnaryOp -> CUnaryOp)
-> Ord CUnaryOp
CUnaryOp -> CUnaryOp -> Bool
CUnaryOp -> CUnaryOp -> Ordering
CUnaryOp -> CUnaryOp -> CUnaryOp
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CUnaryOp -> CUnaryOp -> CUnaryOp
$cmin :: CUnaryOp -> CUnaryOp -> CUnaryOp
max :: CUnaryOp -> CUnaryOp -> CUnaryOp
$cmax :: CUnaryOp -> CUnaryOp -> CUnaryOp
>= :: CUnaryOp -> CUnaryOp -> Bool
$c>= :: CUnaryOp -> CUnaryOp -> Bool
> :: CUnaryOp -> CUnaryOp -> Bool
$c> :: CUnaryOp -> CUnaryOp -> Bool
<= :: CUnaryOp -> CUnaryOp -> Bool
$c<= :: CUnaryOp -> CUnaryOp -> Bool
< :: CUnaryOp -> CUnaryOp -> Bool
$c< :: CUnaryOp -> CUnaryOp -> Bool
compare :: CUnaryOp -> CUnaryOp -> Ordering
$ccompare :: CUnaryOp -> CUnaryOp -> Ordering
$cp1Ord :: Eq CUnaryOp
Ord)


data CConst
  = CIntConst    Integer
  | CCharConst   Char
  | CFloatConst  Float
  | CStringConst String
  deriving (Int -> CConst -> ShowS
[CConst] -> ShowS
CConst -> String
(Int -> CConst -> ShowS)
-> (CConst -> String) -> ([CConst] -> ShowS) -> Show CConst
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CConst] -> ShowS
$cshowList :: [CConst] -> ShowS
show :: CConst -> String
$cshow :: CConst -> String
showsPrec :: Int -> CConst -> ShowS
$cshowsPrec :: Int -> CConst -> ShowS
Show, CConst -> CConst -> Bool
(CConst -> CConst -> Bool)
-> (CConst -> CConst -> Bool) -> Eq CConst
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CConst -> CConst -> Bool
$c/= :: CConst -> CConst -> Bool
== :: CConst -> CConst -> Bool
$c== :: CConst -> CConst -> Bool
Eq, Eq CConst
Eq CConst
-> (CConst -> CConst -> Ordering)
-> (CConst -> CConst -> Bool)
-> (CConst -> CConst -> Bool)
-> (CConst -> CConst -> Bool)
-> (CConst -> CConst -> Bool)
-> (CConst -> CConst -> CConst)
-> (CConst -> CConst -> CConst)
-> Ord CConst
CConst -> CConst -> Bool
CConst -> CConst -> Ordering
CConst -> CConst -> CConst
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CConst -> CConst -> CConst
$cmin :: CConst -> CConst -> CConst
max :: CConst -> CConst -> CConst
$cmax :: CConst -> CConst -> CConst
>= :: CConst -> CConst -> Bool
$c>= :: CConst -> CConst -> Bool
> :: CConst -> CConst -> Bool
$c> :: CConst -> CConst -> Bool
<= :: CConst -> CConst -> Bool
$c<= :: CConst -> CConst -> Bool
< :: CConst -> CConst -> Bool
$c< :: CConst -> CConst -> Bool
compare :: CConst -> CConst -> Ordering
$ccompare :: CConst -> CConst -> Ordering
$cp1Ord :: Eq CConst
Ord)


--------------------------------------------------------------------------------
--                      Infix and Smart Constructors                          --
--------------------------------------------------------------------------------
{-
  These are helpful when building up ASTs in Haskell code. They correspond to
  the concrete syntax of C. This is an incomplete set...
-}

seqCStat :: [CStat] -> CStat
seqCStat :: [CStat] -> CStat
seqCStat = [CCompoundBlockItem] -> CStat
CCompound ([CCompoundBlockItem] -> CStat)
-> ([CStat] -> [CCompoundBlockItem]) -> [CStat] -> CStat
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CStat -> CCompoundBlockItem) -> [CStat] -> [CCompoundBlockItem]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CStat -> CCompoundBlockItem
CBlockStat

(.<.),(.>.),(.==.),(.!=.),(.||.),(.&&.),(.*.),(./.),(.-.),(.+.),(.=.),(.+=.),(.*=.),(.<=.),(.>=.)
  :: CExpr -> CExpr -> CExpr
CExpr
a .<. :: CExpr -> CExpr -> CExpr
.<. CExpr
b  = CBinaryOp -> CExpr -> CExpr -> CExpr
CBinary CBinaryOp
CLeOp CExpr
a CExpr
b
CExpr
a .>. :: CExpr -> CExpr -> CExpr
.>. CExpr
b  = CBinaryOp -> CExpr -> CExpr -> CExpr
CBinary CBinaryOp
CGrOp CExpr
a CExpr
b
CExpr
a .==. :: CExpr -> CExpr -> CExpr
.==. CExpr
b = CBinaryOp -> CExpr -> CExpr -> CExpr
CBinary CBinaryOp
CEqOp CExpr
a CExpr
b
CExpr
a .!=. :: CExpr -> CExpr -> CExpr
.!=. CExpr
b = CBinaryOp -> CExpr -> CExpr -> CExpr
CBinary CBinaryOp
CNeqOp CExpr
a CExpr
b
CExpr
a .||. :: CExpr -> CExpr -> CExpr
.||. CExpr
b = CBinaryOp -> CExpr -> CExpr -> CExpr
CBinary CBinaryOp
CLorOp CExpr
a CExpr
b
CExpr
a .&&. :: CExpr -> CExpr -> CExpr
.&&. CExpr
b = CBinaryOp -> CExpr -> CExpr -> CExpr
CBinary CBinaryOp
CLndOp CExpr
a CExpr
b
CExpr
a .*. :: CExpr -> CExpr -> CExpr
.*. CExpr
b  = CBinaryOp -> CExpr -> CExpr -> CExpr
CBinary CBinaryOp
CMulOp CExpr
a CExpr
b
CExpr
a ./. :: CExpr -> CExpr -> CExpr
./. CExpr
b  = CBinaryOp -> CExpr -> CExpr -> CExpr
CBinary CBinaryOp
CDivOp CExpr
a CExpr
b
CExpr
a .-. :: CExpr -> CExpr -> CExpr
.-. CExpr
b  = CBinaryOp -> CExpr -> CExpr -> CExpr
CBinary CBinaryOp
CSubOp CExpr
a CExpr
b
CExpr
a .+. :: CExpr -> CExpr -> CExpr
.+. CExpr
b  = CBinaryOp -> CExpr -> CExpr -> CExpr
CBinary CBinaryOp
CAddOp CExpr
a CExpr
b
CExpr
a .<=. :: CExpr -> CExpr -> CExpr
.<=. CExpr
b = CBinaryOp -> CExpr -> CExpr -> CExpr
CBinary CBinaryOp
CLeqOp CExpr
a CExpr
b
CExpr
a .>=. :: CExpr -> CExpr -> CExpr
.>=. CExpr
b = CBinaryOp -> CExpr -> CExpr -> CExpr
CBinary CBinaryOp
CGeqOp CExpr
a CExpr
b
CExpr
a .=. :: CExpr -> CExpr -> CExpr
.=. CExpr
b  = CAssignOp -> CExpr -> CExpr -> CExpr
CAssign CAssignOp
CAssignOp CExpr
a CExpr
b
CExpr
a .+=. :: CExpr -> CExpr -> CExpr
.+=. CExpr
b = CAssignOp -> CExpr -> CExpr -> CExpr
CAssign CAssignOp
CAddAssOp CExpr
a CExpr
b
CExpr
a .*=. :: CExpr -> CExpr -> CExpr
.*=. CExpr
b = CAssignOp -> CExpr -> CExpr -> CExpr
CAssign CAssignOp
CMulAssOp CExpr
a CExpr
b


indirect, address :: CExpr -> CExpr
indirect :: CExpr -> CExpr
indirect = CUnaryOp -> CExpr -> CExpr
CUnary CUnaryOp
CIndOp
address :: CExpr -> CExpr
address  = CUnaryOp -> CExpr -> CExpr
CUnary CUnaryOp
CAdrOp

index :: CExpr -> CExpr -> CExpr
index :: CExpr -> CExpr -> CExpr
index = CExpr -> CExpr -> CExpr
CIndex

(...),(.->.) :: CExpr -> String -> CExpr
CExpr
i ... :: CExpr -> String -> CExpr
... String
n  = CExpr -> Ident -> Bool -> CExpr
CMember CExpr
i (String -> Ident
Ident String
n) Bool
True
CExpr
i .->. :: CExpr -> String -> CExpr
.->. String
n = CExpr -> Ident -> Bool -> CExpr
CMember CExpr
i (String -> Ident
Ident String
n) Bool
False

intE :: Integer -> CExpr
intE :: Integer -> CExpr
intE = CConst -> CExpr
CConstant (CConst -> CExpr) -> (Integer -> CConst) -> Integer -> CExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> CConst
CIntConst

floatE :: Float -> CExpr
floatE :: Float -> CExpr
floatE = CConst -> CExpr
CConstant (CConst -> CExpr) -> (Float -> CConst) -> Float -> CExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> CConst
CFloatConst

charE :: Char -> CExpr
charE :: Char -> CExpr
charE = CConst -> CExpr
CConstant (CConst -> CExpr) -> (Char -> CConst) -> Char -> CExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> CConst
CCharConst

stringE :: String -> CExpr
stringE :: String -> CExpr
stringE = CConst -> CExpr
CConstant (CConst -> CExpr) -> (String -> CConst) -> String -> CExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> CConst
CStringConst

mkCallE :: String -> [CExpr] -> CExpr
mkCallE :: String -> [CExpr] -> CExpr
mkCallE String
s = CExpr -> [CExpr] -> CExpr
CCall (Ident -> CExpr
CVar (Ident -> CExpr) -> (String -> Ident) -> String -> CExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Ident
Ident (String -> CExpr) -> String -> CExpr
forall a b. (a -> b) -> a -> b
$ String
s)

mkUnaryE :: String -> CExpr -> CExpr
mkUnaryE :: String -> CExpr -> CExpr
mkUnaryE String
s CExpr
a = String -> [CExpr] -> CExpr
mkCallE String
s [CExpr
a]

nullE :: CExpr
nullE :: CExpr
nullE = Ident -> CExpr
CVar (Ident -> CExpr) -> (String -> Ident) -> String -> CExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Ident
Ident (String -> CExpr) -> String -> CExpr
forall a b. (a -> b) -> a -> b
$ String
"NULL"

--------------------------------------------------------------------------------

cNameStream :: [String]
cNameStream :: [String]
cNameStream = (String -> Bool) -> [String] -> [String]
forall a. (a -> Bool) -> [a] -> [a]
filter (\String
n -> Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem (String -> Char
forall a. [a] -> a
head String
n) [Char
'0'..Char
'9']) [String]
names
  where base :: [Char]
        base :: String
base = [Char
'0'..Char
'9'] String -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char
'a'..Char
'z']
        names :: [String]
names = [[Char
x] | Char
x <- String
base] [String] -> [String] -> [String]
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` (do String
n <- [String]
names
                                              [String
nString -> ShowS
forall a. [a] -> [a] -> [a]
++[Char
x] | Char
x <- String
base])