module Language.C99.Simple.Translate where

import Prelude hiding (LT, GT)

import GHC.Exts             (fromList)
import Control.Monad.State  (State, execState, get, put)

import           Language.C99.Simple.AST
import qualified Language.C99.AST         as C

import Language.C99.Util
import Language.C99.Simple.Util

translate :: TransUnit -> TransUnit
translate = TransUnit -> TransUnit
transtransunit

transtransunit :: TransUnit -> C.TransUnit
transtransunit :: TransUnit -> TransUnit
transtransunit (TransUnit [Decln]
declns [FunDef]
fundefs) = [Item TransUnit] -> TransUnit
forall l. IsList l => [Item l] -> l
fromList ([ExtDecln]
declns' [ExtDecln] -> [ExtDecln] -> [ExtDecln]
forall a. [a] -> [a] -> [a]
++ [ExtDecln]
fundefs') where
  declns' :: [ExtDecln]
declns'  = (Decln -> ExtDecln) -> [Decln] -> [ExtDecln]
forall a b. (a -> b) -> [a] -> [b]
map (Decln -> ExtDecln
C.ExtDecln (Decln -> ExtDecln) -> (Decln -> Decln) -> Decln -> ExtDecln
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decln -> Decln
transdecln) [Decln]
declns
  fundefs' :: [ExtDecln]
fundefs' = (FunDef -> ExtDecln) -> [FunDef] -> [ExtDecln]
forall a b. (a -> b) -> [a] -> [b]
map (FunDef -> ExtDecln
C.ExtFun   (FunDef -> ExtDecln) -> (FunDef -> FunDef) -> FunDef -> ExtDecln
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FunDef -> FunDef
transfundef) [FunDef]
fundefs

transfundef :: FunDef -> C.FunDef
transfundef :: FunDef -> FunDef
transfundef (FunDef Type
ty Ident
name [Param]
params [Decln]
decln [Stmt]
ss) =
  DeclnSpecs -> Declr -> Maybe DeclnList -> CompoundStmt -> FunDef
C.FunDef DeclnSpecs
dspecs Declr
declr Maybe DeclnList
forall a. Maybe a
Nothing CompoundStmt
body where
    dspecs :: DeclnSpecs
dspecs   = Maybe StorageSpec -> Type -> DeclnSpecs
getdeclnspecs Maybe StorageSpec
forall a. Maybe a
Nothing Type
ty
    body :: CompoundStmt
body     = [Decln] -> [Stmt] -> CompoundStmt
compound [Decln]
decln [Stmt]
ss
    declr :: Declr
declr    = State Declr () -> Declr -> Declr
forall s a. State s a -> s -> s
execState (Type -> State Declr ()
getdeclr Type
ty) Declr
fundeclr
    fundeclr :: Declr
fundeclr = Maybe Ptr -> DirectDeclr -> Declr
C.Declr Maybe Ptr
forall a. Maybe a
Nothing (Ident -> [Param] -> DirectDeclr
fundirectdeclr Ident
name [Param]
params)

transdecln :: Decln -> C.Decln
transdecln :: Decln -> Decln
transdecln Decln
decln = case Decln
decln of
  FunDecln Maybe StorageSpec
storespec Type
ty Ident
name [Param]
params -> DeclnSpecs -> Maybe InitDeclrList -> Decln
C.Decln DeclnSpecs
dspecs Maybe InitDeclrList
dlist where
    dspecs :: DeclnSpecs
dspecs     = Maybe StorageSpec -> Type -> DeclnSpecs
getdeclnspecs Maybe StorageSpec
storespec Type
ty
    dlist :: Maybe InitDeclrList
dlist      = InitDeclrList -> Maybe InitDeclrList
forall a. a -> Maybe a
Just (InitDeclrList -> Maybe InitDeclrList)
-> InitDeclrList -> Maybe InitDeclrList
forall a b. (a -> b) -> a -> b
$ InitDeclr -> InitDeclrList
C.InitDeclrBase (InitDeclr -> InitDeclrList) -> InitDeclr -> InitDeclrList
forall a b. (a -> b) -> a -> b
$ Declr -> InitDeclr
C.InitDeclr Declr
declr
    declr :: Declr
declr      = State Declr () -> Declr -> Declr
forall s a. State s a -> s -> s
execState (Type -> State Declr ()
getdeclr Type
ty) Declr
fundeclr
    fundeclr :: Declr
fundeclr   = Maybe Ptr -> DirectDeclr -> Declr
C.Declr Maybe Ptr
forall a. Maybe a
Nothing (Ident -> [Param] -> DirectDeclr
fundirectdeclr Ident
name [Param]
params)

  VarDecln Maybe StorageSpec
storespec Type
ty Ident
name Maybe Init
init -> DeclnSpecs -> Maybe InitDeclrList -> Decln
C.Decln DeclnSpecs
dspecs Maybe InitDeclrList
dlist where
    dspecs :: DeclnSpecs
dspecs = Maybe StorageSpec -> Type -> DeclnSpecs
getdeclnspecs Maybe StorageSpec
storespec Type
ty
    dlist :: Maybe InitDeclrList
dlist  = InitDeclrList -> Maybe InitDeclrList
forall a. a -> Maybe a
Just (InitDeclrList -> Maybe InitDeclrList)
-> InitDeclrList -> Maybe InitDeclrList
forall a b. (a -> b) -> a -> b
$ case Maybe Init
init of
      Maybe Init
Nothing  -> InitDeclr -> InitDeclrList
C.InitDeclrBase (InitDeclr -> InitDeclrList) -> InitDeclr -> InitDeclrList
forall a b. (a -> b) -> a -> b
$ Declr -> InitDeclr
C.InitDeclr      Declr
declr
      Just Init
val -> InitDeclr -> InitDeclrList
C.InitDeclrBase (InitDeclr -> InitDeclrList) -> InitDeclr -> InitDeclrList
forall a b. (a -> b) -> a -> b
$ Declr -> Init -> InitDeclr
C.InitDeclrInitr Declr
declr (Init -> Init
transinit Init
val)
    declr :: Declr
declr  = State Declr () -> Declr -> Declr
forall s a. State s a -> s -> s
execState (Type -> State Declr ()
getdeclr Type
ty) (Ident -> Declr
identdeclr Ident
name)

  TypeDecln Type
ty -> DeclnSpecs -> Maybe InitDeclrList -> Decln
C.Decln DeclnSpecs
dspecs Maybe InitDeclrList
forall a. Maybe a
Nothing where
    dspecs :: DeclnSpecs
dspecs = Maybe StorageSpec -> Type -> DeclnSpecs
getdeclnspecs Maybe StorageSpec
forall a. Maybe a
Nothing Type
ty

transparamdecln :: Param -> C.ParamDecln
transparamdecln :: Param -> ParamDecln
transparamdecln (Param Type
ty Ident
name) = DeclnSpecs -> Declr -> ParamDecln
C.ParamDecln DeclnSpecs
dspecs Declr
declr where
  dspecs :: DeclnSpecs
dspecs = Maybe StorageSpec -> Type -> DeclnSpecs
getdeclnspecs Maybe StorageSpec
forall a. Maybe a
Nothing Type
ty
  declr :: Declr
declr  = State Declr () -> Declr -> Declr
forall s a. State s a -> s -> s
execState (Type -> State Declr ()
getdeclr Type
ty) (Ident -> Declr
identdeclr Ident
name)

transparam :: Param -> C.Decln
transparam :: Param -> Decln
transparam (Param Type
ty Ident
name) = DeclnSpecs -> Maybe InitDeclrList -> Decln
C.Decln DeclnSpecs
dspecs Maybe InitDeclrList
dlist where
  dspecs :: DeclnSpecs
dspecs = Maybe StorageSpec -> Type -> DeclnSpecs
getdeclnspecs Maybe StorageSpec
forall a. Maybe a
Nothing Type
ty
  dlist :: Maybe InitDeclrList
dlist  = InitDeclrList -> Maybe InitDeclrList
forall a. a -> Maybe a
Just (InitDeclrList -> Maybe InitDeclrList)
-> InitDeclrList -> Maybe InitDeclrList
forall a b. (a -> b) -> a -> b
$ InitDeclr -> InitDeclrList
C.InitDeclrBase (InitDeclr -> InitDeclrList) -> InitDeclr -> InitDeclrList
forall a b. (a -> b) -> a -> b
$ Declr -> InitDeclr
C.InitDeclr Declr
declr
  declr :: Declr
declr  = State Declr () -> Declr -> Declr
forall s a. State s a -> s -> s
execState (Type -> State Declr ()
getdeclr Type
ty) (Ident -> Declr
identdeclr Ident
name)

getdeclr :: Type -> State C.Declr ()
getdeclr :: Type -> State Declr ()
getdeclr Type
ty = case Type
ty of
  Type      Type
ty'     -> do
    Type -> State Declr ()
getdeclr Type
ty'
    Declr
declr <- StateT Declr Identity Declr
forall s (m :: * -> *). MonadState s m => m s
get
    Declr -> State Declr ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (Declr -> State Declr ()) -> Declr -> State Declr ()
forall a b. (a -> b) -> a -> b
$ Maybe Ptr -> DirectDeclr -> Declr
C.Declr Maybe Ptr
forall a. Maybe a
Nothing (Declr -> DirectDeclr
C.DirectDeclrDeclr Declr
declr)

  TypeSpec  TypeSpec
ty' -> () -> State Declr ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

  Ptr       Type
ty' -> do
    let (Maybe TypeQualList
quals, Type
ty'') = Type -> (Maybe TypeQualList, Type)
gettypequals Type
ty'
    Declr
declr <- StateT Declr Identity Declr
forall s (m :: * -> *). MonadState s m => m s
get
    Declr -> State Declr ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (Declr -> State Declr ()) -> Declr -> State Declr ()
forall a b. (a -> b) -> a -> b
$ Ptr -> Declr -> Declr
insertptr (Maybe TypeQualList -> Ptr
C.PtrBase Maybe TypeQualList
quals) Declr
declr
    Type -> State Declr ()
getdeclr Type
ty''

  Array Type
ty' Maybe Expr
len -> do
    let lenexpr :: Maybe AssignExpr
lenexpr = (Expr -> AssignExpr
forall a b. Wrap a b => a -> b
wrap(Expr -> AssignExpr) -> (Expr -> Expr) -> Expr -> AssignExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Expr -> Expr
transexpr) (Expr -> AssignExpr) -> Maybe Expr -> Maybe AssignExpr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Expr
len
    C.Declr Maybe Ptr
ptr DirectDeclr
declr <- StateT Declr Identity Declr
forall s (m :: * -> *). MonadState s m => m s
get
    let ddeclr :: DirectDeclr
ddeclr = case Maybe Ptr
ptr of
          Maybe Ptr
Nothing -> DirectDeclr
declr
          Just Ptr
_  -> Declr -> DirectDeclr
C.DirectDeclrDeclr (Declr -> DirectDeclr) -> Declr -> DirectDeclr
forall a b. (a -> b) -> a -> b
$ Maybe Ptr -> DirectDeclr -> Declr
C.Declr Maybe Ptr
ptr DirectDeclr
declr
    Declr -> State Declr ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (Declr -> State Declr ()) -> Declr -> State Declr ()
forall a b. (a -> b) -> a -> b
$ Maybe Ptr -> DirectDeclr -> Declr
C.Declr Maybe Ptr
forall a. Maybe a
Nothing (DirectDeclr
-> Maybe TypeQualList -> Maybe AssignExpr -> DirectDeclr
C.DirectDeclrArray1 DirectDeclr
ddeclr Maybe TypeQualList
forall a. Maybe a
Nothing Maybe AssignExpr
lenexpr)
    Type -> State Declr ()
getdeclr Type
ty'

  Const    Type
ty' -> Type -> State Declr ()
getdeclr Type
ty'
  Restrict Type
ty' -> Type -> State Declr ()
getdeclr Type
ty'
  Volatile Type
ty' -> Type -> State Declr ()
getdeclr Type
ty'


getdeclnspecs :: Maybe StorageSpec -> Type -> C.DeclnSpecs
getdeclnspecs :: Maybe StorageSpec -> Type -> DeclnSpecs
getdeclnspecs Maybe StorageSpec
storespec Type
ty = DeclnSpecs
dspecs where
  dspecs :: DeclnSpecs
dspecs = case Maybe StorageSpec
storespec of
    Maybe StorageSpec
Nothing   -> DeclnSpecs
tyspec
    Just StorageSpec
spec -> StorageClassSpec -> Maybe DeclnSpecs -> DeclnSpecs
C.DeclnSpecsStorage (StorageSpec -> StorageClassSpec
transstorespec StorageSpec
spec) (DeclnSpecs -> Maybe DeclnSpecs
forall a. a -> Maybe a
Just DeclnSpecs
tyspec)

  tyspec :: DeclnSpecs
tyspec = case Type
ty of
    Type     Type
ty'   -> Type -> DeclnSpecs
rec Type
ty'
    TypeSpec TypeSpec
ty'   -> [TypeSpec] -> DeclnSpecs
foldtypespecs ([TypeSpec] -> DeclnSpecs) -> [TypeSpec] -> DeclnSpecs
forall a b. (a -> b) -> a -> b
$ TypeSpec -> [TypeSpec]
spec2spec TypeSpec
ty'
    Ptr      Type
ty'   -> Type -> DeclnSpecs
rec ((Maybe TypeQualList, Type) -> Type
forall a b. (a, b) -> b
snd ((Maybe TypeQualList, Type) -> Type)
-> (Maybe TypeQualList, Type) -> Type
forall a b. (a -> b) -> a -> b
$ Type -> (Maybe TypeQualList, Type)
gettypequals Type
ty')
    Array    Type
ty' Maybe Expr
_ -> Type -> DeclnSpecs
rec Type
ty'
    Const    Type
ty'   -> TypeQual -> Maybe DeclnSpecs -> DeclnSpecs
C.DeclnSpecsQual TypeQual
C.QConst    (DeclnSpecs -> Maybe DeclnSpecs
forall a. a -> Maybe a
Just (DeclnSpecs -> Maybe DeclnSpecs) -> DeclnSpecs -> Maybe DeclnSpecs
forall a b. (a -> b) -> a -> b
$ Type -> DeclnSpecs
rec Type
ty')
    Restrict Type
ty'   -> TypeQual -> Maybe DeclnSpecs -> DeclnSpecs
C.DeclnSpecsQual TypeQual
C.QRestrict (DeclnSpecs -> Maybe DeclnSpecs
forall a. a -> Maybe a
Just (DeclnSpecs -> Maybe DeclnSpecs) -> DeclnSpecs -> Maybe DeclnSpecs
forall a b. (a -> b) -> a -> b
$ Type -> DeclnSpecs
rec Type
ty')
    Volatile Type
ty'   -> TypeQual -> Maybe DeclnSpecs -> DeclnSpecs
C.DeclnSpecsQual TypeQual
C.QVolatile (DeclnSpecs -> Maybe DeclnSpecs
forall a. a -> Maybe a
Just (DeclnSpecs -> Maybe DeclnSpecs) -> DeclnSpecs -> Maybe DeclnSpecs
forall a b. (a -> b) -> a -> b
$ Type -> DeclnSpecs
rec Type
ty')

  rec :: Type -> DeclnSpecs
rec = Maybe StorageSpec -> Type -> DeclnSpecs
getdeclnspecs Maybe StorageSpec
forall a. Maybe a
Nothing

transstorespec :: StorageSpec -> C.StorageClassSpec
transstorespec :: StorageSpec -> StorageClassSpec
transstorespec StorageSpec
spec = case StorageSpec
spec of
  StorageSpec
Typedef  -> StorageClassSpec
C.STypedef
  StorageSpec
Extern   -> StorageClassSpec
C.SExtern
  StorageSpec
Static   -> StorageClassSpec
C.SStatic
  StorageSpec
Auto     -> StorageClassSpec
C.SAuto
  StorageSpec
Register -> StorageClassSpec
C.SRegister

spec2spec :: TypeSpec -> [C.TypeSpec]
spec2spec :: TypeSpec -> [TypeSpec]
spec2spec TypeSpec
ts = case TypeSpec
ts of
  TypeSpec
Void                -> [TypeSpec
C.TVoid]
  TypeSpec
Char                -> [TypeSpec
C.TChar]
  TypeSpec
Signed_Char         -> [TypeSpec
C.TSigned, TypeSpec
C.TChar]
  TypeSpec
Unsigned_Char       -> [TypeSpec
C.TUnsigned, TypeSpec
C.TChar]

  TypeSpec
Short               -> [TypeSpec
C.TShort]
  TypeSpec
Signed_Short        -> [TypeSpec
C.TSigned, TypeSpec
C.TShort]
  TypeSpec
Short_Int           -> [TypeSpec
C.TShort, TypeSpec
C.TInt]
  TypeSpec
Signed_Short_Int    -> [TypeSpec
C.TSigned, TypeSpec
C.TShort, TypeSpec
C.TInt]

  TypeSpec
Unsigned_Short      -> [TypeSpec
C.TUnsigned, TypeSpec
C.TShort]
  TypeSpec
Unsigned_Short_Int  -> [TypeSpec
C.TUnsigned, TypeSpec
C.TShort, TypeSpec
C.TInt]

  TypeSpec
Int                 -> [TypeSpec
C.TInt]
  TypeSpec
Signed              -> [TypeSpec
C.TSigned]
  TypeSpec
Signed_Int          -> [TypeSpec
C.TSigned, TypeSpec
C.TInt]

  TypeSpec
Unsigned            -> [TypeSpec
C.TUnsigned]
  TypeSpec
Unsigned_Int        -> [TypeSpec
C.TUnsigned, TypeSpec
C.TInt]

  TypeSpec
Long                -> [TypeSpec
C.TLong]
  TypeSpec
Signed_Long         -> [TypeSpec
C.TSigned, TypeSpec
C.TLong]
  TypeSpec
Long_Int            -> [TypeSpec
C.TLong, TypeSpec
C.TInt]
  TypeSpec
Signed_Long_Int     -> [TypeSpec
C.TSigned, TypeSpec
C.TLong, TypeSpec
C.TInt]

  TypeSpec
Unsigned_Long       -> [TypeSpec
C.TUnsigned, TypeSpec
C.TLong]
  TypeSpec
Unsgined_Long_Int   -> [TypeSpec
C.TUnsigned, TypeSpec
C.TLong, TypeSpec
C.TInt]

  TypeSpec
Long_Long           -> [TypeSpec
C.TLong, TypeSpec
C.TLong]
  TypeSpec
Signed_Long_Long    -> [TypeSpec
C.TSigned, TypeSpec
C.TLong, TypeSpec
C.TLong]
  TypeSpec
Long_Long_Int       -> [TypeSpec
C.TLong, TypeSpec
C.TLong, TypeSpec
C.TInt]
  TypeSpec
Signed_Long_Long_Int-> [TypeSpec
C.TSigned, TypeSpec
C.TLong, TypeSpec
C.TLong, TypeSpec
C.TInt]

  TypeSpec
Unsigned_Long_Long      -> [TypeSpec
C.TUnsigned, TypeSpec
C.TLong, TypeSpec
C.TLong]
  TypeSpec
Unsigned_Long_Long_Int  -> [TypeSpec
C.TUnsigned, TypeSpec
C.TLong, TypeSpec
C.TLong, TypeSpec
C.TInt]

  TypeSpec
Float               -> [TypeSpec
C.TFloat]
  TypeSpec
Double              -> [TypeSpec
C.TDouble]
  TypeSpec
Long_Double         -> [TypeSpec
C.TLong, TypeSpec
C.TDouble]
  TypeSpec
Bool                -> [TypeSpec
C.TBool]
  TypeSpec
Float_Complex       -> [TypeSpec
C.TComplex, TypeSpec
C.TFloat]
  TypeSpec
Double_Complex      -> [TypeSpec
C.TComplex, TypeSpec
C.TDouble]
  TypeSpec
Long_Double_Complex -> [TypeSpec
C.TLong, TypeSpec
C.TDouble, TypeSpec
C.TComplex]
  TypedefName Ident
name -> [TypedefName -> TypeSpec
C.TTypedef (TypedefName -> TypeSpec) -> TypedefName -> TypeSpec
forall a b. (a -> b) -> a -> b
$ Ident -> TypedefName
C.TypedefName (Ident -> TypedefName) -> Ident -> TypedefName
forall a b. (a -> b) -> a -> b
$ Ident -> Ident
ident Ident
name]
  Struct      Ident
name -> [StructOrUnionSpec -> TypeSpec
C.TStructOrUnion (StructOrUnionSpec -> TypeSpec) -> StructOrUnionSpec -> TypeSpec
forall a b. (a -> b) -> a -> b
$ StructOrUnion -> Ident -> StructOrUnionSpec
C.StructOrUnionForwDecln StructOrUnion
C.Struct (Ident -> Ident
ident Ident
name)]
  StructDecln Maybe Ident
name [FieldDecln]
declns -> [StructOrUnionSpec -> TypeSpec
C.TStructOrUnion (StructOrUnionSpec -> TypeSpec) -> StructOrUnionSpec -> TypeSpec
forall a b. (a -> b) -> a -> b
$ StructOrUnion
-> Maybe Ident -> StructDeclnList -> StructOrUnionSpec
C.StructOrUnionDecln StructOrUnion
C.Struct (Ident -> Ident
ident (Ident -> Ident) -> Maybe Ident -> Maybe Ident
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Ident
name) StructDeclnList
declns'] where
    declns' :: StructDeclnList
declns' = [Item StructDeclnList] -> StructDeclnList
forall l. IsList l => [Item l] -> l
fromList ([Item StructDeclnList] -> StructDeclnList)
-> [Item StructDeclnList] -> StructDeclnList
forall a b. (a -> b) -> a -> b
$ (FieldDecln -> StructDecln) -> [FieldDecln] -> [StructDecln]
forall a b. (a -> b) -> [a] -> [b]
map FieldDecln -> StructDecln
transfielddecln [FieldDecln]
declns

transfielddecln :: FieldDecln -> C.StructDecln
transfielddecln :: FieldDecln -> StructDecln
transfielddecln (FieldDecln Type
ty Ident
name) = SpecQualList -> StructDeclrList -> StructDecln
C.StructDecln SpecQualList
quals StructDeclrList
declrlist where
  declrlist :: StructDeclrList
declrlist = StructDeclr -> StructDeclrList
C.StructDeclrBase (StructDeclr -> StructDeclrList) -> StructDeclr -> StructDeclrList
forall a b. (a -> b) -> a -> b
$ Declr -> StructDeclr
C.StructDeclr Declr
declr
  declr :: Declr
declr = State Declr () -> Declr -> Declr
forall s a. State s a -> s -> s
execState (Type -> State Declr ()
getdeclr Type
ty) (Ident -> Declr
identdeclr Ident
name)
  quals :: SpecQualList
quals = Type -> SpecQualList
getspecquals Type
ty


getspecquals :: Type -> C.SpecQualList
getspecquals :: Type -> SpecQualList
getspecquals Type
ty = case Type
ty of
  Type     Type
ty'     -> Type -> SpecQualList
getspecquals Type
ty'
  TypeSpec TypeSpec
ts      -> [TypeSpec] -> SpecQualList
foldtypequals ([TypeSpec] -> SpecQualList) -> [TypeSpec] -> SpecQualList
forall a b. (a -> b) -> a -> b
$ TypeSpec -> [TypeSpec]
spec2spec TypeSpec
ts
  Ptr      Type
ty'     -> Type -> SpecQualList
getspecquals Type
ty'
  Array    Type
ty' Maybe Expr
len -> Type -> SpecQualList
getspecquals Type
ty'
  Const    Type
ty'     -> TypeQual -> Maybe SpecQualList -> SpecQualList
C.SpecQualQual TypeQual
C.QConst    (SpecQualList -> Maybe SpecQualList
forall a. a -> Maybe a
Just (SpecQualList -> Maybe SpecQualList)
-> SpecQualList -> Maybe SpecQualList
forall a b. (a -> b) -> a -> b
$ Type -> SpecQualList
getspecquals Type
ty')
  Restrict Type
ty'     -> TypeQual -> Maybe SpecQualList -> SpecQualList
C.SpecQualQual TypeQual
C.QRestrict (SpecQualList -> Maybe SpecQualList
forall a. a -> Maybe a
Just (SpecQualList -> Maybe SpecQualList)
-> SpecQualList -> Maybe SpecQualList
forall a b. (a -> b) -> a -> b
$ Type -> SpecQualList
getspecquals Type
ty')
  Volatile Type
ty'     -> TypeQual -> Maybe SpecQualList -> SpecQualList
C.SpecQualQual TypeQual
C.QVolatile (SpecQualList -> Maybe SpecQualList
forall a. a -> Maybe a
Just (SpecQualList -> Maybe SpecQualList)
-> SpecQualList -> Maybe SpecQualList
forall a b. (a -> b) -> a -> b
$ Type -> SpecQualList
getspecquals Type
ty')


transexpr :: Expr -> C.Expr
transexpr :: Expr -> Expr
transexpr Expr
e = case Expr
e of
  Ident     Ident
i         -> PrimExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (PrimExpr -> Expr) -> PrimExpr -> Expr
forall a b. (a -> b) -> a -> b
$ Ident -> PrimExpr
C.PrimIdent (Ident -> PrimExpr) -> Ident -> PrimExpr
forall a b. (a -> b) -> a -> b
$ Ident -> Ident
ident Ident
i
  LitBool   Bool
b         -> PrimExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (PrimExpr -> Expr) -> PrimExpr -> Expr
forall a b. (a -> b) -> a -> b
$ Bool -> PrimExpr
litbool   Bool
b
  LitInt    Integer
i         -> UnaryExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (UnaryExpr -> Expr) -> UnaryExpr -> Expr
forall a b. (a -> b) -> a -> b
$ Integer -> UnaryExpr
litint    Integer
i
  LitFloat  Float
f         -> UnaryExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (UnaryExpr -> Expr) -> UnaryExpr -> Expr
forall a b. (a -> b) -> a -> b
$ Float -> UnaryExpr
litfloat  Float
f
  LitDouble Double
d         -> UnaryExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (UnaryExpr -> Expr) -> UnaryExpr -> Expr
forall a b. (a -> b) -> a -> b
$ Double -> UnaryExpr
litdouble Double
d
  LitString Ident
s         -> UnaryExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (UnaryExpr -> Expr) -> UnaryExpr -> Expr
forall a b. (a -> b) -> a -> b
$ Ident -> UnaryExpr
litstring Ident
s
  Index     Expr
arr Expr
idx   -> PostfixExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (PostfixExpr -> Expr) -> PostfixExpr -> Expr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr -> PostfixExpr
indexexpr Expr
arr Expr
idx
  Funcall   Expr
fun [Expr]
args  -> PostfixExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (PostfixExpr -> Expr) -> PostfixExpr -> Expr
forall a b. (a -> b) -> a -> b
$ Expr -> [Expr] -> PostfixExpr
funcall   Expr
fun [Expr]
args
  Dot       Expr
e   Ident
field -> PostfixExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (PostfixExpr -> Expr) -> PostfixExpr -> Expr
forall a b. (a -> b) -> a -> b
$ Expr -> Ident -> PostfixExpr
dotexpr   Expr
e Ident
field
  Arrow     Expr
e   Ident
field -> PostfixExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (PostfixExpr -> Expr) -> PostfixExpr -> Expr
forall a b. (a -> b) -> a -> b
$ Expr -> Ident -> PostfixExpr
arrowexpr Expr
e Ident
field
  InitVal   TypeName
ty  [Init]
init  -> PostfixExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (PostfixExpr -> Expr) -> PostfixExpr -> Expr
forall a b. (a -> b) -> a -> b
$ TypeName -> [Init] -> PostfixExpr
initexpr  TypeName
ty [Init]
init
  UnaryOp   UnaryOp
op Expr
e      -> UnaryExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (UnaryExpr -> Expr) -> UnaryExpr -> Expr
forall a b. (a -> b) -> a -> b
$ UnaryOp -> Expr -> UnaryExpr
unaryop UnaryOp
op Expr
e
  Cast      TypeName
ty Expr
e      -> CastExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (CastExpr -> Expr) -> CastExpr -> Expr
forall a b. (a -> b) -> a -> b
$ TypeName -> Expr -> CastExpr
castexpr TypeName
ty Expr
e
  BinaryOp  BinaryOp
op Expr
e1 Expr
e2  -> BinaryOp -> Expr -> Expr -> Expr
binaryop BinaryOp
op Expr
e1 Expr
e2
  AssignOp  AssignOp
op Expr
e1 Expr
e2  -> AssignExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (AssignExpr -> Expr) -> AssignExpr -> Expr
forall a b. (a -> b) -> a -> b
$ AssignOp -> Expr -> Expr -> AssignExpr
assignop AssignOp
op Expr
e1 Expr
e2
  Cond      Expr
c Expr
e1 Expr
e2   -> CondExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (CondExpr -> Expr) -> CondExpr -> Expr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr -> Expr -> CondExpr
condexpr Expr
c Expr
e1 Expr
e2


unaryop :: UnaryOp -> Expr -> C.UnaryExpr
unaryop :: UnaryOp -> Expr -> UnaryExpr
unaryop UnaryOp
op Expr
e = case UnaryOp
op of
    UnaryOp
Inc     -> UnaryExpr -> UnaryExpr
C.UnaryInc          (Expr -> UnaryExpr
forall a b. Wrap a b => a -> b
wrap Expr
e')
    UnaryOp
Dec     -> UnaryExpr -> UnaryExpr
C.UnaryDec          (Expr -> UnaryExpr
forall a b. Wrap a b => a -> b
wrap Expr
e')
    UnaryOp
Ref     -> UnaryOp -> CastExpr -> UnaryExpr
C.UnaryOp UnaryOp
C.UORef   (Expr -> CastExpr
forall a b. Wrap a b => a -> b
wrap Expr
e')
    UnaryOp
DeRef   -> UnaryOp -> CastExpr -> UnaryExpr
C.UnaryOp UnaryOp
C.UODeref (Expr -> CastExpr
forall a b. Wrap a b => a -> b
wrap Expr
e')
    UnaryOp
Plus    -> UnaryOp -> CastExpr -> UnaryExpr
C.UnaryOp UnaryOp
C.UOPlus  (Expr -> CastExpr
forall a b. Wrap a b => a -> b
wrap Expr
e')
    UnaryOp
Min     -> UnaryOp -> CastExpr -> UnaryExpr
C.UnaryOp UnaryOp
C.UOMin   (Expr -> CastExpr
forall a b. Wrap a b => a -> b
wrap Expr
e')
    UnaryOp
BoolNot -> UnaryOp -> CastExpr -> UnaryExpr
C.UnaryOp UnaryOp
C.UOBNot  (Expr -> CastExpr
forall a b. Wrap a b => a -> b
wrap Expr
e')
    UnaryOp
Not     -> UnaryOp -> CastExpr -> UnaryExpr
C.UnaryOp UnaryOp
C.UONot   (Expr -> CastExpr
forall a b. Wrap a b => a -> b
wrap Expr
e')
  where
    e' :: Expr
e' = Expr -> Expr
transexpr Expr
e

binaryop :: BinaryOp -> Expr -> Expr -> C.Expr
binaryop :: BinaryOp -> Expr -> Expr -> Expr
binaryop BinaryOp
op Expr
e1 Expr
e2 = case BinaryOp
op of
    BinaryOp
Mult   -> MultExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (MultExpr -> Expr) -> MultExpr -> Expr
forall a b. (a -> b) -> a -> b
$ MultExpr -> CastExpr -> MultExpr
C.MultMult   (Expr -> MultExpr
forall a b. Wrap a b => a -> b
wrap Expr
e1') (Expr -> CastExpr
forall a b. Wrap a b => a -> b
wrap Expr
e2')
    BinaryOp
Div    -> MultExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (MultExpr -> Expr) -> MultExpr -> Expr
forall a b. (a -> b) -> a -> b
$ MultExpr -> CastExpr -> MultExpr
C.MultDiv    (Expr -> MultExpr
forall a b. Wrap a b => a -> b
wrap Expr
e1') (Expr -> CastExpr
forall a b. Wrap a b => a -> b
wrap Expr
e2')
    BinaryOp
Mod    -> MultExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (MultExpr -> Expr) -> MultExpr -> Expr
forall a b. (a -> b) -> a -> b
$ MultExpr -> CastExpr -> MultExpr
C.MultMod    (Expr -> MultExpr
forall a b. Wrap a b => a -> b
wrap Expr
e1') (Expr -> CastExpr
forall a b. Wrap a b => a -> b
wrap Expr
e2')
    BinaryOp
Add    -> AddExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (AddExpr -> Expr) -> AddExpr -> Expr
forall a b. (a -> b) -> a -> b
$ AddExpr -> MultExpr -> AddExpr
C.AddPlus    (Expr -> AddExpr
forall a b. Wrap a b => a -> b
wrap Expr
e1') (Expr -> MultExpr
forall a b. Wrap a b => a -> b
wrap Expr
e2')
    BinaryOp
Sub    -> AddExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (AddExpr -> Expr) -> AddExpr -> Expr
forall a b. (a -> b) -> a -> b
$ AddExpr -> MultExpr -> AddExpr
C.AddMin     (Expr -> AddExpr
forall a b. Wrap a b => a -> b
wrap Expr
e1') (Expr -> MultExpr
forall a b. Wrap a b => a -> b
wrap Expr
e2')
    BinaryOp
ShiftL -> ShiftExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (ShiftExpr -> Expr) -> ShiftExpr -> Expr
forall a b. (a -> b) -> a -> b
$ ShiftExpr -> AddExpr -> ShiftExpr
C.ShiftLeft  (Expr -> ShiftExpr
forall a b. Wrap a b => a -> b
wrap Expr
e1') (Expr -> AddExpr
forall a b. Wrap a b => a -> b
wrap Expr
e2')
    BinaryOp
ShiftR -> ShiftExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (ShiftExpr -> Expr) -> ShiftExpr -> Expr
forall a b. (a -> b) -> a -> b
$ ShiftExpr -> AddExpr -> ShiftExpr
C.ShiftRight (Expr -> ShiftExpr
forall a b. Wrap a b => a -> b
wrap Expr
e1') (Expr -> AddExpr
forall a b. Wrap a b => a -> b
wrap Expr
e2')
    BinaryOp
LT     -> RelExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (RelExpr -> Expr) -> RelExpr -> Expr
forall a b. (a -> b) -> a -> b
$ RelExpr -> ShiftExpr -> RelExpr
C.RelLT      (Expr -> RelExpr
forall a b. Wrap a b => a -> b
wrap Expr
e1') (Expr -> ShiftExpr
forall a b. Wrap a b => a -> b
wrap Expr
e2')
    BinaryOp
GT     -> RelExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (RelExpr -> Expr) -> RelExpr -> Expr
forall a b. (a -> b) -> a -> b
$ RelExpr -> ShiftExpr -> RelExpr
C.RelGT      (Expr -> RelExpr
forall a b. Wrap a b => a -> b
wrap Expr
e1') (Expr -> ShiftExpr
forall a b. Wrap a b => a -> b
wrap Expr
e2')
    BinaryOp
LE     -> RelExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (RelExpr -> Expr) -> RelExpr -> Expr
forall a b. (a -> b) -> a -> b
$ RelExpr -> ShiftExpr -> RelExpr
C.RelLE      (Expr -> RelExpr
forall a b. Wrap a b => a -> b
wrap Expr
e1') (Expr -> ShiftExpr
forall a b. Wrap a b => a -> b
wrap Expr
e2')
    BinaryOp
GE     -> RelExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (RelExpr -> Expr) -> RelExpr -> Expr
forall a b. (a -> b) -> a -> b
$ RelExpr -> ShiftExpr -> RelExpr
C.RelGE      (Expr -> RelExpr
forall a b. Wrap a b => a -> b
wrap Expr
e1') (Expr -> ShiftExpr
forall a b. Wrap a b => a -> b
wrap Expr
e2')
    BinaryOp
Eq     -> EqExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (EqExpr -> Expr) -> EqExpr -> Expr
forall a b. (a -> b) -> a -> b
$ EqExpr -> RelExpr -> EqExpr
C.EqEq       (Expr -> EqExpr
forall a b. Wrap a b => a -> b
wrap Expr
e1') (Expr -> RelExpr
forall a b. Wrap a b => a -> b
wrap Expr
e2')
    BinaryOp
NEq    -> EqExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (EqExpr -> Expr) -> EqExpr -> Expr
forall a b. (a -> b) -> a -> b
$ EqExpr -> RelExpr -> EqExpr
C.EqNEq      (Expr -> EqExpr
forall a b. Wrap a b => a -> b
wrap Expr
e1') (Expr -> RelExpr
forall a b. Wrap a b => a -> b
wrap Expr
e2')
    BinaryOp
And    -> AndExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (AndExpr -> Expr) -> AndExpr -> Expr
forall a b. (a -> b) -> a -> b
$ AndExpr -> EqExpr -> AndExpr
C.And        (Expr -> AndExpr
forall a b. Wrap a b => a -> b
wrap Expr
e1') (Expr -> EqExpr
forall a b. Wrap a b => a -> b
wrap Expr
e2')
    BinaryOp
XOr    -> XOrExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (XOrExpr -> Expr) -> XOrExpr -> Expr
forall a b. (a -> b) -> a -> b
$ XOrExpr -> AndExpr -> XOrExpr
C.XOr        (Expr -> XOrExpr
forall a b. Wrap a b => a -> b
wrap Expr
e1') (Expr -> AndExpr
forall a b. Wrap a b => a -> b
wrap Expr
e2')
    BinaryOp
Or     -> OrExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (OrExpr -> Expr) -> OrExpr -> Expr
forall a b. (a -> b) -> a -> b
$ OrExpr -> XOrExpr -> OrExpr
C.Or         (Expr -> OrExpr
forall a b. Wrap a b => a -> b
wrap Expr
e1') (Expr -> XOrExpr
forall a b. Wrap a b => a -> b
wrap Expr
e2')
    BinaryOp
LAnd   -> LAndExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (LAndExpr -> Expr) -> LAndExpr -> Expr
forall a b. (a -> b) -> a -> b
$ LAndExpr -> OrExpr -> LAndExpr
C.LAnd       (Expr -> LAndExpr
forall a b. Wrap a b => a -> b
wrap Expr
e1') (Expr -> OrExpr
forall a b. Wrap a b => a -> b
wrap Expr
e2')
    BinaryOp
LOr    -> LOrExpr -> Expr
forall a b. Wrap a b => a -> b
wrap (LOrExpr -> Expr) -> LOrExpr -> Expr
forall a b. (a -> b) -> a -> b
$ LOrExpr -> LAndExpr -> LOrExpr
C.LOr        (Expr -> LOrExpr
forall a b. Wrap a b => a -> b
wrap Expr
e1') (Expr -> LAndExpr
forall a b. Wrap a b => a -> b
wrap Expr
e2')
  where
    e1' :: Expr
e1' = Expr -> Expr
transexpr Expr
e1
    e2' :: Expr
e2' = Expr -> Expr
transexpr Expr
e2

assignop :: AssignOp -> Expr -> Expr -> C.AssignExpr
assignop :: AssignOp -> Expr -> Expr -> AssignExpr
assignop AssignOp
op Expr
e1 Expr
e2 = UnaryExpr -> AssignOp -> AssignExpr -> AssignExpr
C.Assign UnaryExpr
e1' AssignOp
op' AssignExpr
e2' where
  e1' :: UnaryExpr
e1' = Expr -> UnaryExpr
forall a b. Wrap a b => a -> b
wrap (Expr -> UnaryExpr) -> Expr -> UnaryExpr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
transexpr Expr
e1
  e2' :: AssignExpr
e2' = Expr -> AssignExpr
forall a b. Wrap a b => a -> b
wrap (Expr -> AssignExpr) -> Expr -> AssignExpr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
transexpr Expr
e2
  op' :: AssignOp
op' = case AssignOp
op of
    AssignOp
Assign       -> AssignOp
C.AEq
    AssignOp
AssignMult   -> AssignOp
C.ATimes
    AssignOp
AssignDiv    -> AssignOp
C.ADiv
    AssignOp
AssignMod    -> AssignOp
C.AMod
    AssignOp
AssignAdd    -> AssignOp
C.AAdd
    AssignOp
AssignSub    -> AssignOp
C.ASub
    AssignOp
AssignShiftL -> AssignOp
C.AShiftL
    AssignOp
AssignShiftR -> AssignOp
C.AShiftR
    AssignOp
AssignAnd    -> AssignOp
C.AAnd
    AssignOp
AssignXOr    -> AssignOp
C.AXOr
    AssignOp
AssignOr     -> AssignOp
C.AOr

transinit :: Init -> C.Init
transinit :: Init -> Init
transinit (InitExpr Expr
e)   = AssignExpr -> Init
C.InitExpr (Expr -> AssignExpr
forall a b. Wrap a b => a -> b
wrap (Expr -> AssignExpr) -> Expr -> AssignExpr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
transexpr Expr
e)
transinit (InitArray [Init]
es) = InitList -> Init
C.InitArray ([Item InitList] -> InitList
forall l. IsList l => [Item l] -> l
fromList ([Item InitList] -> InitList) -> [Item InitList] -> InitList
forall a b. (a -> b) -> a -> b
$ (Init -> Init) -> [Init] -> [Init]
forall a b. (a -> b) -> [a] -> [b]
map Init -> Init
transinit [Init]
es)

initexpr :: TypeName -> [Init] -> PostfixExpr
initexpr TypeName
ty [Init]
init = TypeName -> InitList -> PostfixExpr
C.PostfixInits TypeName
ty' InitList
init' where
  ty' :: TypeName
ty'   = TypeName -> TypeName
transtypename TypeName
ty
  init' :: InitList
init' = [Item InitList] -> InitList
forall l. IsList l => [Item l] -> l
fromList ([Item InitList] -> InitList) -> [Item InitList] -> InitList
forall a b. (a -> b) -> a -> b
$ (Init -> Init) -> [Init] -> [Init]
forall a b. (a -> b) -> [a] -> [b]
map Init -> Init
transinit [Init]
init

indexexpr :: Expr -> Expr -> PostfixExpr
indexexpr Expr
arr Expr
idx = PostfixExpr -> Expr -> PostfixExpr
C.PostfixIndex PostfixExpr
arr' Expr
idx' where
  arr' :: PostfixExpr
arr' = Expr -> PostfixExpr
forall a b. Wrap a b => a -> b
wrap (Expr -> PostfixExpr) -> Expr -> PostfixExpr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
transexpr Expr
arr
  idx' :: Expr
idx' = Expr -> Expr
forall a b. Wrap a b => a -> b
wrap (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
transexpr Expr
idx

dotexpr :: Expr -> Ident -> PostfixExpr
dotexpr Expr
e Ident
field = PostfixExpr -> Ident -> PostfixExpr
C.PostfixDot PostfixExpr
e' Ident
field' where
  e' :: PostfixExpr
e'     = Expr -> PostfixExpr
forall a b. Wrap a b => a -> b
wrap (Expr -> PostfixExpr) -> Expr -> PostfixExpr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
transexpr Expr
e
  field' :: Ident
field' = Ident -> Ident
ident Ident
field

arrowexpr :: Expr -> Ident -> PostfixExpr
arrowexpr Expr
e Ident
field = PostfixExpr -> Ident -> PostfixExpr
C.PostfixArrow PostfixExpr
e' Ident
field' where
  e' :: PostfixExpr
e'     = Expr -> PostfixExpr
forall a b. Wrap a b => a -> b
wrap (Expr -> PostfixExpr) -> Expr -> PostfixExpr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
transexpr Expr
e
  field' :: Ident
field' = Ident -> Ident
ident Ident
field

castexpr :: TypeName -> Expr -> CastExpr
castexpr TypeName
ty Expr
e = TypeName -> CastExpr -> CastExpr
C.Cast TypeName
ty' CastExpr
e' where
  ty' :: TypeName
ty' = TypeName -> TypeName
transtypename TypeName
ty
  e' :: CastExpr
e'  = Expr -> CastExpr
forall a b. Wrap a b => a -> b
wrap (Expr -> CastExpr) -> Expr -> CastExpr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
transexpr Expr
e

funcall :: Expr -> [Expr] -> PostfixExpr
funcall Expr
fun [Expr]
args = PostfixExpr -> Maybe ArgExprList -> PostfixExpr
C.PostfixFunction PostfixExpr
fun' Maybe ArgExprList
args' where
  fun' :: PostfixExpr
fun'  = Expr -> PostfixExpr
forall a b. Wrap a b => a -> b
wrap (Expr -> PostfixExpr) -> Expr -> PostfixExpr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
transexpr Expr
fun
  args' :: Maybe ArgExprList
args' = case [AssignExpr]
argses of
    [] -> Maybe ArgExprList
forall a. Maybe a
Nothing
    [AssignExpr]
_  -> ArgExprList -> Maybe ArgExprList
forall a. a -> Maybe a
Just (ArgExprList -> Maybe ArgExprList)
-> ArgExprList -> Maybe ArgExprList
forall a b. (a -> b) -> a -> b
$ [Item ArgExprList] -> ArgExprList
forall l. IsList l => [Item l] -> l
fromList [Item ArgExprList]
[AssignExpr]
argses

  argses :: [C.AssignExpr]
  argses :: [AssignExpr]
argses = (Expr -> AssignExpr) -> [Expr] -> [AssignExpr]
forall a b. (a -> b) -> [a] -> [b]
map Expr -> AssignExpr
forall a b. Wrap a b => a -> b
wrap [Expr]
exprs

  exprs :: [C.Expr]
  exprs :: [Expr]
exprs = (Expr -> Expr) -> [Expr] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map Expr -> Expr
transexpr [Expr]
args

condexpr :: Expr -> Expr -> Expr -> CondExpr
condexpr Expr
c Expr
e1 Expr
e2 = LOrExpr -> Expr -> CondExpr -> CondExpr
C.Cond LOrExpr
c' Expr
e1' CondExpr
e2' where
  c' :: LOrExpr
c'  = Expr -> LOrExpr
forall a b. Wrap a b => a -> b
wrap (Expr -> LOrExpr) -> Expr -> LOrExpr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
transexpr Expr
c
  e1' :: Expr
e1' = Expr -> Expr
forall a b. Wrap a b => a -> b
wrap (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
transexpr Expr
e1
  e2' :: CondExpr
e2' = Expr -> CondExpr
forall a b. Wrap a b => a -> b
wrap (Expr -> CondExpr) -> Expr -> CondExpr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
transexpr Expr
e2

transtypename :: TypeName -> C.TypeName
transtypename :: TypeName -> TypeName
transtypename (TypeName Type
ty) = SpecQualList -> Maybe AbstractDeclr -> TypeName
C.TypeName SpecQualList
specquals Maybe AbstractDeclr
adeclr where
  specquals :: SpecQualList
specquals = Type -> SpecQualList
getspecquals Type
ty
  adeclr :: Maybe AbstractDeclr
adeclr    = State (Maybe AbstractDeclr) ()
-> Maybe AbstractDeclr -> Maybe AbstractDeclr
forall s a. State s a -> s -> s
execState (Type -> State (Maybe AbstractDeclr) ()
getabstractdeclr Type
ty) Maybe AbstractDeclr
forall a. Maybe a
Nothing

getabstractdeclr :: Type -> State (Maybe C.AbstractDeclr) ()
getabstractdeclr :: Type -> State (Maybe AbstractDeclr) ()
getabstractdeclr Type
ty = case Type
ty of
  Type Type
ty' -> do
    Type -> State (Maybe AbstractDeclr) ()
getabstractdeclr Type
ty'
    Maybe AbstractDeclr
adeclr <- StateT (Maybe AbstractDeclr) Identity (Maybe AbstractDeclr)
forall s (m :: * -> *). MonadState s m => m s
get
    case Maybe AbstractDeclr
adeclr of
      Maybe AbstractDeclr
Nothing      -> () -> State (Maybe AbstractDeclr) ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      Just AbstractDeclr
adeclr' -> Maybe AbstractDeclr -> State (Maybe AbstractDeclr) ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (Maybe AbstractDeclr -> State (Maybe AbstractDeclr) ())
-> Maybe AbstractDeclr -> State (Maybe AbstractDeclr) ()
forall a b. (a -> b) -> a -> b
$ AbstractDeclr -> Maybe AbstractDeclr
forall a. a -> Maybe a
Just (AbstractDeclr -> Maybe AbstractDeclr)
-> AbstractDeclr -> Maybe AbstractDeclr
forall a b. (a -> b) -> a -> b
$ Maybe Ptr -> DirectAbstractDeclr -> AbstractDeclr
C.AbstractDeclrDirect Maybe Ptr
forall a. Maybe a
Nothing DirectAbstractDeclr
dadeclr where
        dadeclr :: DirectAbstractDeclr
dadeclr = AbstractDeclr -> DirectAbstractDeclr
C.DirectAbstractDeclr AbstractDeclr
adeclr'

  TypeSpec TypeSpec
ts -> () -> State (Maybe AbstractDeclr) ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

  Ptr Type
ty' -> do
    let (Maybe TypeQualList
quals, Type
ty'') = Type -> (Maybe TypeQualList, Type)
gettypequals Type
ty'
        ptr :: Ptr
ptr           = Maybe TypeQualList -> Ptr
C.PtrBase Maybe TypeQualList
quals
    Maybe AbstractDeclr
adeclr <- StateT (Maybe AbstractDeclr) Identity (Maybe AbstractDeclr)
forall s (m :: * -> *). MonadState s m => m s
get
    case Maybe AbstractDeclr
adeclr of
      Maybe AbstractDeclr
Nothing      -> Maybe AbstractDeclr -> State (Maybe AbstractDeclr) ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (Maybe AbstractDeclr -> State (Maybe AbstractDeclr) ())
-> Maybe AbstractDeclr -> State (Maybe AbstractDeclr) ()
forall a b. (a -> b) -> a -> b
$ AbstractDeclr -> Maybe AbstractDeclr
forall a. a -> Maybe a
Just (AbstractDeclr -> Maybe AbstractDeclr)
-> AbstractDeclr -> Maybe AbstractDeclr
forall a b. (a -> b) -> a -> b
$ Ptr -> AbstractDeclr
C.AbstractDeclr Ptr
ptr
      Just AbstractDeclr
adeclr' -> Maybe AbstractDeclr -> State (Maybe AbstractDeclr) ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (Maybe AbstractDeclr -> State (Maybe AbstractDeclr) ())
-> Maybe AbstractDeclr -> State (Maybe AbstractDeclr) ()
forall a b. (a -> b) -> a -> b
$ AbstractDeclr -> Maybe AbstractDeclr
forall a. a -> Maybe a
Just (AbstractDeclr -> Maybe AbstractDeclr)
-> AbstractDeclr -> Maybe AbstractDeclr
forall a b. (a -> b) -> a -> b
$ Maybe Ptr -> DirectAbstractDeclr -> AbstractDeclr
C.AbstractDeclrDirect (Ptr -> Maybe Ptr
forall a. a -> Maybe a
Just Ptr
ptr) DirectAbstractDeclr
dadeclr where
        dadeclr :: DirectAbstractDeclr
dadeclr = AbstractDeclr -> DirectAbstractDeclr
C.DirectAbstractDeclr AbstractDeclr
adeclr'
    Type -> State (Maybe AbstractDeclr) ()
getabstractdeclr Type
ty''

  Array Type
ty' Maybe Expr
len -> do
    let lenexpr :: Maybe AssignExpr
lenexpr       = (Expr -> AssignExpr
forall a b. Wrap a b => a -> b
wrap(Expr -> AssignExpr) -> (Expr -> Expr) -> Expr -> AssignExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Expr -> Expr
transexpr) (Expr -> AssignExpr) -> Maybe Expr -> Maybe AssignExpr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Expr
len
        emptyarrdeclr :: DirectAbstractDeclr
emptyarrdeclr = Maybe DirectAbstractDeclr
-> Maybe TypeQualList -> Maybe AssignExpr -> DirectAbstractDeclr
C.DirectAbstractDeclrArray1 Maybe DirectAbstractDeclr
forall a. Maybe a
Nothing Maybe TypeQualList
forall a. Maybe a
Nothing Maybe AssignExpr
lenexpr
    Maybe AbstractDeclr
adeclr <- StateT (Maybe AbstractDeclr) Identity (Maybe AbstractDeclr)
forall s (m :: * -> *). MonadState s m => m s
get
    let declr :: AbstractDeclr
declr = case Maybe AbstractDeclr
adeclr of
          Maybe AbstractDeclr
Nothing -> Maybe Ptr -> DirectAbstractDeclr -> AbstractDeclr
C.AbstractDeclrDirect Maybe Ptr
forall a. Maybe a
Nothing DirectAbstractDeclr
emptyarrdeclr
          Just AbstractDeclr
adeclr -> case AbstractDeclr
adeclr of
            C.AbstractDeclrDirect Maybe Ptr
mptr DirectAbstractDeclr
adeclr' -> Maybe Ptr -> DirectAbstractDeclr -> AbstractDeclr
C.AbstractDeclrDirect Maybe Ptr
mptr DirectAbstractDeclr
arrdeclr where
              arrdeclr :: DirectAbstractDeclr
arrdeclr = Maybe DirectAbstractDeclr
-> Maybe TypeQualList -> Maybe AssignExpr -> DirectAbstractDeclr
C.DirectAbstractDeclrArray1 (DirectAbstractDeclr -> Maybe DirectAbstractDeclr
forall a. a -> Maybe a
Just DirectAbstractDeclr
adeclr') Maybe TypeQualList
forall a. Maybe a
Nothing Maybe AssignExpr
lenexpr
            C.AbstractDeclr Ptr
ptr -> Maybe Ptr -> DirectAbstractDeclr -> AbstractDeclr
C.AbstractDeclrDirect (Ptr -> Maybe Ptr
forall a. a -> Maybe a
Just Ptr
ptr) DirectAbstractDeclr
emptyarrdeclr
    Maybe AbstractDeclr -> State (Maybe AbstractDeclr) ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (Maybe AbstractDeclr -> State (Maybe AbstractDeclr) ())
-> Maybe AbstractDeclr -> State (Maybe AbstractDeclr) ()
forall a b. (a -> b) -> a -> b
$ AbstractDeclr -> Maybe AbstractDeclr
forall a. a -> Maybe a
Just AbstractDeclr
declr
    Type -> State (Maybe AbstractDeclr) ()
getabstractdeclr Type
ty'

  Const    Type
ty' -> Type -> State (Maybe AbstractDeclr) ()
getabstractdeclr Type
ty'
  Restrict Type
ty' -> Type -> State (Maybe AbstractDeclr) ()
getabstractdeclr Type
ty'
  Volatile Type
ty' -> Type -> State (Maybe AbstractDeclr) ()
getabstractdeclr Type
ty'

transstmt :: Stmt -> C.Stmt
transstmt :: Stmt -> Stmt
transstmt Stmt
stmt = case Stmt
stmt of
  Expr    Expr
e                  -> Expr -> Stmt
exprstmt Expr
e
  If      Expr
cond [Stmt]
ss            -> Expr -> [Stmt] -> Stmt
ifstmt Expr
cond [Stmt]
ss
  IfElse  Expr
cond [Stmt]
ssthen [Stmt]
sselse -> Expr -> [Stmt] -> [Stmt] -> Stmt
ifelsestmt Expr
cond [Stmt]
ssthen [Stmt]
sselse
  Switch  Expr
cond [Case]
cases         -> Expr -> [Case] -> Stmt
switchstmt Expr
cond [Case]
cases
  While   Expr
cond [Stmt]
ss            -> Expr -> [Stmt] -> Stmt
whilestmt Expr
cond [Stmt]
ss
  For     Expr
start Expr
end Expr
step [Stmt]
ss  -> Maybe Expr -> Maybe Expr -> Maybe Expr -> [Stmt] -> Stmt
forstmt (Expr -> Maybe Expr
forall a. a -> Maybe a
Just Expr
start) (Expr -> Maybe Expr
forall a. a -> Maybe a
Just Expr
end) (Expr -> Maybe Expr
forall a. a -> Maybe a
Just Expr
step) [Stmt]
ss
  ForInf                 [Stmt]
ss  -> Maybe Expr -> Maybe Expr -> Maybe Expr -> [Stmt] -> Stmt
forstmt Maybe Expr
forall a. Maybe a
Nothing      Maybe Expr
forall a. Maybe a
Nothing    Maybe Expr
forall a. Maybe a
Nothing     [Stmt]
ss
  Stmt
Continue                   -> JumpStmt -> Stmt
C.StmtJump (JumpStmt -> Stmt) -> JumpStmt -> Stmt
forall a b. (a -> b) -> a -> b
$ JumpStmt
C.JumpContinue
  Stmt
Break                      -> JumpStmt -> Stmt
C.StmtJump (JumpStmt -> Stmt) -> JumpStmt -> Stmt
forall a b. (a -> b) -> a -> b
$ JumpStmt
C.JumpBreak
  Label   Ident
name   Stmt
s           -> Ident -> Stmt -> Stmt
labelstmt Ident
name Stmt
s
  Return  Maybe Expr
e                  -> Maybe Expr -> Stmt
returnstmt Maybe Expr
e

exprstmt :: Expr -> C.Stmt
exprstmt :: Expr -> Stmt
exprstmt Expr
e = ExprStmt -> Stmt
C.StmtExpr   (ExprStmt -> Stmt) -> ExprStmt -> Stmt
forall a b. (a -> b) -> a -> b
$ Maybe Expr -> ExprStmt
C.ExprStmt (Expr -> Maybe Expr
forall a. a -> Maybe a
Just (Expr -> Maybe Expr) -> Expr -> Maybe Expr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
forall a b. Wrap a b => a -> b
wrap (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
transexpr Expr
e)

ifstmt :: Expr -> [Stmt] -> C.Stmt
ifstmt :: Expr -> [Stmt] -> Stmt
ifstmt Expr
cond [Stmt]
ss = SelectStmt -> Stmt
C.StmtSelect (SelectStmt -> Stmt) -> SelectStmt -> Stmt
forall a b. (a -> b) -> a -> b
$ Expr -> Stmt -> SelectStmt
C.SelectIf Expr
cond' Stmt
body where
  cond' :: Expr
cond' = Expr -> Expr
forall a b. Wrap a b => a -> b
wrap (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
transexpr Expr
cond
  body :: Stmt
body  = [Decln] -> [Stmt] -> Stmt
compoundstmt [] [Stmt]
ss

ifelsestmt :: Expr -> [Stmt] -> [Stmt] -> C.Stmt
ifelsestmt :: Expr -> [Stmt] -> [Stmt] -> Stmt
ifelsestmt Expr
cond [Stmt]
ssthen [Stmt]
sselse =
  SelectStmt -> Stmt
C.StmtSelect (SelectStmt -> Stmt) -> SelectStmt -> Stmt
forall a b. (a -> b) -> a -> b
$ Expr -> Stmt -> Stmt -> SelectStmt
C.SelectIfElse Expr
cond' Stmt
ssthen' Stmt
sselse' where
    cond' :: Expr
cond'  = Expr -> Expr
forall a b. Wrap a b => a -> b
wrap (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
transexpr Expr
cond
    ssthen' :: Stmt
ssthen' = [Decln] -> [Stmt] -> Stmt
compoundstmt [] [Stmt]
ssthen
    sselse' :: Stmt
sselse' = [Decln] -> [Stmt] -> Stmt
compoundstmt [] [Stmt]
sselse

switchstmt :: Expr -> [Case] -> C.Stmt
switchstmt :: Expr -> [Case] -> Stmt
switchstmt Expr
cond [Case]
cs = SelectStmt -> Stmt
C.StmtSelect (SelectStmt -> Stmt) -> SelectStmt -> Stmt
forall a b. (a -> b) -> a -> b
$ Expr -> Stmt -> SelectStmt
C.SelectSwitch Expr
cond' Stmt
cs' where
  cond' :: Expr
cond' = Expr -> Expr
forall a b. Wrap a b => a -> b
wrap (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
transexpr Expr
cond
  cs' :: Stmt
cs'   = [Case] -> Stmt
casestmt [Case]
cs

whilestmt :: Expr -> [Stmt] -> C.Stmt
whilestmt :: Expr -> [Stmt] -> Stmt
whilestmt Expr
cond [Stmt]
ss = IterStmt -> Stmt
C.StmtIter (IterStmt -> Stmt) -> IterStmt -> Stmt
forall a b. (a -> b) -> a -> b
$ Expr -> Stmt -> IterStmt
C.IterWhile Expr
cond' Stmt
ss' where
  cond' :: Expr
cond' = Expr -> Expr
forall a b. Wrap a b => a -> b
wrap (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
transexpr Expr
cond
  ss' :: Stmt
ss'   = [Decln] -> [Stmt] -> Stmt
compoundstmt [] [Stmt]
ss

forstmt :: Maybe Expr -> Maybe Expr -> Maybe Expr -> [Stmt] -> C.Stmt
forstmt :: Maybe Expr -> Maybe Expr -> Maybe Expr -> [Stmt] -> Stmt
forstmt Maybe Expr
start Maybe Expr
end Maybe Expr
step [Stmt]
ss =
  IterStmt -> Stmt
C.StmtIter (IterStmt -> Stmt) -> IterStmt -> Stmt
forall a b. (a -> b) -> a -> b
$ Maybe Expr -> Maybe Expr -> Maybe Expr -> Stmt -> IterStmt
C.IterForUpdate Maybe Expr
start' Maybe Expr
end' Maybe Expr
step' Stmt
ss' where
    start' :: Maybe Expr
start' = (Expr -> Expr
forall a b. Wrap a b => a -> b
wrap(Expr -> Expr) -> (Expr -> Expr) -> Expr -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Expr -> Expr
transexpr) (Expr -> Expr) -> Maybe Expr -> Maybe Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Expr
start
    end' :: Maybe Expr
end'   = (Expr -> Expr
forall a b. Wrap a b => a -> b
wrap(Expr -> Expr) -> (Expr -> Expr) -> Expr -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Expr -> Expr
transexpr) (Expr -> Expr) -> Maybe Expr -> Maybe Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Expr
end
    step' :: Maybe Expr
step'  = (Expr -> Expr
forall a b. Wrap a b => a -> b
wrap(Expr -> Expr) -> (Expr -> Expr) -> Expr -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Expr -> Expr
transexpr) (Expr -> Expr) -> Maybe Expr -> Maybe Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Expr
step
    ss' :: Stmt
ss'    = [Decln] -> [Stmt] -> Stmt
compoundstmt [] [Stmt]
ss

labelstmt :: String -> Stmt -> C.Stmt
labelstmt :: Ident -> Stmt -> Stmt
labelstmt Ident
name Stmt
s = LabeledStmt -> Stmt
C.StmtLabeled (LabeledStmt -> Stmt) -> LabeledStmt -> Stmt
forall a b. (a -> b) -> a -> b
$ Ident -> Stmt -> LabeledStmt
C.LabeledIdent (Ident -> Ident
ident Ident
name) (Stmt -> Stmt
transstmt Stmt
s)

returnstmt :: Maybe Expr -> C.Stmt
returnstmt :: Maybe Expr -> Stmt
returnstmt Maybe Expr
e = JumpStmt -> Stmt
C.StmtJump (JumpStmt -> Stmt) -> JumpStmt -> Stmt
forall a b. (a -> b) -> a -> b
$ Maybe Expr -> JumpStmt
C.JumpReturn ((Expr -> Expr
forall a b. Wrap a b => a -> b
wrap(Expr -> Expr) -> (Expr -> Expr) -> Expr -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Expr -> Expr
transexpr) (Expr -> Expr) -> Maybe Expr -> Maybe Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Expr
e)

casestmt :: [Case] -> C.Stmt
casestmt :: [Case] -> Stmt
casestmt [Case]
cs =
  CompoundStmt -> Stmt
C.StmtCompound (CompoundStmt -> Stmt) -> CompoundStmt -> Stmt
forall a b. (a -> b) -> a -> b
$ Maybe BlockItemList -> CompoundStmt
C.Compound (BlockItemList -> Maybe BlockItemList
forall a. a -> Maybe a
Just (BlockItemList -> Maybe BlockItemList)
-> BlockItemList -> Maybe BlockItemList
forall a b. (a -> b) -> a -> b
$ [Item BlockItemList] -> BlockItemList
forall l. IsList l => [Item l] -> l
fromList ([Item BlockItemList] -> BlockItemList)
-> [Item BlockItemList] -> BlockItemList
forall a b. (a -> b) -> a -> b
$ (Case -> BlockItem) -> [Case] -> [BlockItem]
forall a b. (a -> b) -> [a] -> [b]
map Case -> BlockItem
casestmt' [Case]
cs) where
    casestmt' :: Case -> BlockItem
casestmt' Case
cs = Stmt -> BlockItem
C.BlockItemStmt (Stmt -> BlockItem) -> Stmt -> BlockItem
forall a b. (a -> b) -> a -> b
$ LabeledStmt -> Stmt
C.StmtLabeled (LabeledStmt -> Stmt) -> LabeledStmt -> Stmt
forall a b. (a -> b) -> a -> b
$ case Case
cs of
      Case  Expr
e Stmt
s -> ConstExpr -> Stmt -> LabeledStmt
C.LabeledCase (CondExpr -> ConstExpr
C.Const (CondExpr -> ConstExpr) -> CondExpr -> ConstExpr
forall a b. (a -> b) -> a -> b
$ Expr -> CondExpr
forall a b. Wrap a b => a -> b
wrap (Expr -> CondExpr) -> Expr -> CondExpr
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
transexpr Expr
e) (Stmt -> Stmt
transstmt Stmt
s)
      Default Stmt
s -> Stmt -> LabeledStmt
C.LabeledDefault (Stmt -> Stmt
transstmt Stmt
s)

compound :: [Decln] -> [Stmt] -> C.CompoundStmt
compound :: [Decln] -> [Stmt] -> CompoundStmt
compound [Decln]
ds [Stmt]
ss = Maybe BlockItemList -> CompoundStmt
C.Compound (BlockItemList -> Maybe BlockItemList
forall a. a -> Maybe a
Just (BlockItemList -> Maybe BlockItemList)
-> BlockItemList -> Maybe BlockItemList
forall a b. (a -> b) -> a -> b
$ [Item BlockItemList] -> BlockItemList
forall l. IsList l => [Item l] -> l
fromList [Item BlockItemList]
[BlockItem]
items) where
  items :: [BlockItem]
items = [BlockItem]
ds' [BlockItem] -> [BlockItem] -> [BlockItem]
forall a. [a] -> [a] -> [a]
++ [BlockItem]
ss'
  ss' :: [BlockItem]
ss' = (Stmt -> BlockItem) -> [Stmt] -> [BlockItem]
forall a b. (a -> b) -> [a] -> [b]
map (Stmt -> BlockItem
C.BlockItemStmt (Stmt -> BlockItem) -> (Stmt -> Stmt) -> Stmt -> BlockItem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Stmt -> Stmt
transstmt) [Stmt]
ss
  ds' :: [BlockItem]
ds' = (Decln -> BlockItem) -> [Decln] -> [BlockItem]
forall a b. (a -> b) -> [a] -> [b]
map (Decln -> BlockItem
C.BlockItemDecln (Decln -> BlockItem) -> (Decln -> Decln) -> Decln -> BlockItem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decln -> Decln
transdecln) [Decln]
ds

compoundstmt :: [Decln] -> [Stmt] -> C.Stmt
compoundstmt :: [Decln] -> [Stmt] -> Stmt
compoundstmt [Decln]
ds [Stmt]
ss = CompoundStmt -> Stmt
C.StmtCompound (CompoundStmt -> Stmt) -> CompoundStmt -> Stmt
forall a b. (a -> b) -> a -> b
$ [Decln] -> [Stmt] -> CompoundStmt
compound [Decln]
ds [Stmt]
ss

fundirectdeclr :: Ident -> [Param] -> C.DirectDeclr
fundirectdeclr :: Ident -> [Param] -> DirectDeclr
fundirectdeclr Ident
name [Param]
params = DirectDeclr -> ParamTypeList -> DirectDeclr
C.DirectDeclrFun1 DirectDeclr
namedeclr ParamTypeList
params' where
  namedeclr :: DirectDeclr
namedeclr = Ident -> DirectDeclr
C.DirectDeclrIdent (Ident -> DirectDeclr) -> Ident -> DirectDeclr
forall a b. (a -> b) -> a -> b
$ Ident -> Ident
ident Ident
name
  params' :: ParamTypeList
params'   = ParamList -> ParamTypeList
C.ParamTypeList (ParamList -> ParamTypeList) -> ParamList -> ParamTypeList
forall a b. (a -> b) -> a -> b
$ [ParamDecln] -> ParamList
voidparamlist ([ParamDecln] -> ParamList) -> [ParamDecln] -> ParamList
forall a b. (a -> b) -> a -> b
$ (Param -> ParamDecln) -> [Param] -> [ParamDecln]
forall a b. (a -> b) -> [a] -> [b]
map Param -> ParamDecln
transparamdecln [Param]
params