{-# LANGUAGE DeriveDataTypeable #-}
-----------------------------------------------------------------------------
-- |
-- Module      :  Language.C.Syntax.Ops
-- Copyright   :  (c) 2008 Benedikt Huber
-- License     :  BSD-style
-- Maintainer  : benedikt.huber@gmail.com
-- Stability   : experimental
-- Portability : ghc
--
-- Unary, binary and asssignment operators. Exported via AST.
-----------------------------------------------------------------------------
module Language.C.Syntax.Ops (
-- * Assignment operators
CAssignOp(..),
assignBinop,
-- * Binary operators
CBinaryOp(..),
isCmpOp,
isPtrOp,
isBitOp,
isLogicOp,
-- * Unary operators
CUnaryOp(..),
isEffectfulOp
)
where
import Data.Generics hiding (Generic)
import GHC.Generics (Generic)
import Control.DeepSeq (NFData)
-- | C assignment operators (K&R A7.17)
data CAssignOp = CAssignOp
               | CMulAssOp
               | CDivAssOp
               | CRmdAssOp              -- ^ remainder and assignment
               | CAddAssOp
               | CSubAssOp
               | CShlAssOp
               | CShrAssOp
               | CAndAssOp
               | CXorAssOp
               | COrAssOp
               deriving (CAssignOp -> CAssignOp -> Bool
(CAssignOp -> CAssignOp -> Bool)
-> (CAssignOp -> CAssignOp -> Bool) -> Eq CAssignOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CAssignOp -> CAssignOp -> Bool
$c/= :: CAssignOp -> CAssignOp -> Bool
== :: CAssignOp -> CAssignOp -> Bool
$c== :: CAssignOp -> CAssignOp -> Bool
Eq,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,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,Typeable CAssignOp
DataType
Constr
Typeable CAssignOp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CAssignOp -> c CAssignOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CAssignOp)
-> (CAssignOp -> Constr)
-> (CAssignOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CAssignOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CAssignOp))
-> ((forall b. Data b => b -> b) -> CAssignOp -> CAssignOp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CAssignOp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CAssignOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> CAssignOp -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CAssignOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp)
-> Data CAssignOp
CAssignOp -> DataType
CAssignOp -> Constr
(forall b. Data b => b -> b) -> CAssignOp -> CAssignOp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CAssignOp -> c CAssignOp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CAssignOp
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CAssignOp -> u
forall u. (forall d. Data d => d -> u) -> CAssignOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CAssignOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CAssignOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CAssignOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CAssignOp -> c CAssignOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CAssignOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CAssignOp)
$cCOrAssOp :: Constr
$cCXorAssOp :: Constr
$cCAndAssOp :: Constr
$cCShrAssOp :: Constr
$cCShlAssOp :: Constr
$cCSubAssOp :: Constr
$cCAddAssOp :: Constr
$cCRmdAssOp :: Constr
$cCDivAssOp :: Constr
$cCMulAssOp :: Constr
$cCAssignOp :: Constr
$tCAssignOp :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp
gmapMp :: (forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp
gmapM :: (forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp
gmapQi :: Int -> (forall d. Data d => d -> u) -> CAssignOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CAssignOp -> u
gmapQ :: (forall d. Data d => d -> u) -> CAssignOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CAssignOp -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CAssignOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CAssignOp -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CAssignOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CAssignOp -> r
gmapT :: (forall b. Data b => b -> b) -> CAssignOp -> CAssignOp
$cgmapT :: (forall b. Data b => b -> b) -> CAssignOp -> CAssignOp
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CAssignOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CAssignOp)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CAssignOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CAssignOp)
dataTypeOf :: CAssignOp -> DataType
$cdataTypeOf :: CAssignOp -> DataType
toConstr :: CAssignOp -> Constr
$ctoConstr :: CAssignOp -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CAssignOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CAssignOp
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CAssignOp -> c CAssignOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CAssignOp -> c CAssignOp
$cp1Data :: Typeable CAssignOp
Data,Typeable,(forall x. CAssignOp -> Rep CAssignOp x)
-> (forall x. Rep CAssignOp x -> CAssignOp) -> Generic CAssignOp
forall x. Rep CAssignOp x -> CAssignOp
forall x. CAssignOp -> Rep CAssignOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CAssignOp x -> CAssignOp
$cfrom :: forall x. CAssignOp -> Rep CAssignOp x
Generic)

instance NFData CAssignOp

assignBinop :: CAssignOp -> CBinaryOp
assignBinop :: CAssignOp -> CBinaryOp
assignBinop CAssignOp = String -> CBinaryOp
forall a. HasCallStack => String -> a
error "direct assignment has no binary operator"
assignBinop CMulAssOp = CBinaryOp
CMulOp
assignBinop CDivAssOp = CBinaryOp
CDivOp
assignBinop CRmdAssOp = CBinaryOp
CRmdOp
assignBinop CAddAssOp = CBinaryOp
CAddOp
assignBinop CSubAssOp = CBinaryOp
CSubOp
assignBinop CShlAssOp = CBinaryOp
CShlOp
assignBinop CShrAssOp = CBinaryOp
CShrOp
assignBinop CAndAssOp = CBinaryOp
CAndOp
assignBinop CXorAssOp = CBinaryOp
CXorOp
assignBinop COrAssOp  = CBinaryOp
COrOp

-- | C binary operators (K&R A7.6-15)
--
data CBinaryOp = CMulOp
               | CDivOp
               | CRmdOp                 -- ^ remainder of division
               | CAddOp
               | CSubOp
               | CShlOp                 -- ^ shift left
               | CShrOp                 -- ^ shift right
               | CLeOp                  -- ^ less
               | CGrOp                  -- ^ greater
               | CLeqOp                 -- ^ less or equal
               | CGeqOp                 -- ^ greater or equal
               | CEqOp                  -- ^ equal
               | CNeqOp                 -- ^ not equal
               | CAndOp                 -- ^ bitwise and
               | CXorOp                 -- ^ exclusive bitwise or
               | COrOp                  -- ^ inclusive bitwise or
               | CLndOp                 -- ^ logical and
               | CLorOp                 -- ^ logical or
               deriving (CBinaryOp -> CBinaryOp -> Bool
(CBinaryOp -> CBinaryOp -> Bool)
-> (CBinaryOp -> CBinaryOp -> Bool) -> Eq CBinaryOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CBinaryOp -> CBinaryOp -> Bool
$c/= :: CBinaryOp -> CBinaryOp -> Bool
== :: CBinaryOp -> CBinaryOp -> Bool
$c== :: CBinaryOp -> CBinaryOp -> Bool
Eq,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,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,Typeable CBinaryOp
DataType
Constr
Typeable CBinaryOp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CBinaryOp -> c CBinaryOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CBinaryOp)
-> (CBinaryOp -> Constr)
-> (CBinaryOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CBinaryOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CBinaryOp))
-> ((forall b. Data b => b -> b) -> CBinaryOp -> CBinaryOp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CBinaryOp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CBinaryOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> CBinaryOp -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CBinaryOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp)
-> Data CBinaryOp
CBinaryOp -> DataType
CBinaryOp -> Constr
(forall b. Data b => b -> b) -> CBinaryOp -> CBinaryOp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CBinaryOp -> c CBinaryOp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CBinaryOp
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CBinaryOp -> u
forall u. (forall d. Data d => d -> u) -> CBinaryOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CBinaryOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CBinaryOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CBinaryOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CBinaryOp -> c CBinaryOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CBinaryOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CBinaryOp)
$cCLorOp :: Constr
$cCLndOp :: Constr
$cCOrOp :: Constr
$cCXorOp :: Constr
$cCAndOp :: Constr
$cCNeqOp :: Constr
$cCEqOp :: Constr
$cCGeqOp :: Constr
$cCLeqOp :: Constr
$cCGrOp :: Constr
$cCLeOp :: Constr
$cCShrOp :: Constr
$cCShlOp :: Constr
$cCSubOp :: Constr
$cCAddOp :: Constr
$cCRmdOp :: Constr
$cCDivOp :: Constr
$cCMulOp :: Constr
$tCBinaryOp :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp
gmapMp :: (forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp
gmapM :: (forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp
gmapQi :: Int -> (forall d. Data d => d -> u) -> CBinaryOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CBinaryOp -> u
gmapQ :: (forall d. Data d => d -> u) -> CBinaryOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CBinaryOp -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CBinaryOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CBinaryOp -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CBinaryOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CBinaryOp -> r
gmapT :: (forall b. Data b => b -> b) -> CBinaryOp -> CBinaryOp
$cgmapT :: (forall b. Data b => b -> b) -> CBinaryOp -> CBinaryOp
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CBinaryOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CBinaryOp)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CBinaryOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CBinaryOp)
dataTypeOf :: CBinaryOp -> DataType
$cdataTypeOf :: CBinaryOp -> DataType
toConstr :: CBinaryOp -> Constr
$ctoConstr :: CBinaryOp -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CBinaryOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CBinaryOp
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CBinaryOp -> c CBinaryOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CBinaryOp -> c CBinaryOp
$cp1Data :: Typeable CBinaryOp
Data,Typeable,(forall x. CBinaryOp -> Rep CBinaryOp x)
-> (forall x. Rep CBinaryOp x -> CBinaryOp) -> Generic CBinaryOp
forall x. Rep CBinaryOp x -> CBinaryOp
forall x. CBinaryOp -> Rep CBinaryOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CBinaryOp x -> CBinaryOp
$cfrom :: forall x. CBinaryOp -> Rep CBinaryOp x
Generic)

instance NFData CBinaryOp

isCmpOp :: CBinaryOp -> Bool
isCmpOp :: CBinaryOp -> Bool
isCmpOp op :: CBinaryOp
op = CBinaryOp
op CBinaryOp -> [CBinaryOp] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [ CBinaryOp
CLeqOp, CBinaryOp
CGeqOp, CBinaryOp
CLeOp, CBinaryOp
CGrOp, CBinaryOp
CEqOp, CBinaryOp
CNeqOp ]

isPtrOp :: CBinaryOp -> Bool
isPtrOp :: CBinaryOp -> Bool
isPtrOp op :: CBinaryOp
op = CBinaryOp
op CBinaryOp -> [CBinaryOp] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [ CBinaryOp
CAddOp, CBinaryOp
CSubOp ]

isBitOp :: CBinaryOp -> Bool
isBitOp :: CBinaryOp -> Bool
isBitOp op :: CBinaryOp
op = CBinaryOp
op CBinaryOp -> [CBinaryOp] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [ CBinaryOp
CShlOp, CBinaryOp
CShrOp, CBinaryOp
CAndOp, CBinaryOp
COrOp, CBinaryOp
CXorOp ]

isLogicOp :: CBinaryOp -> Bool
isLogicOp :: CBinaryOp -> Bool
isLogicOp op :: CBinaryOp
op = CBinaryOp
op CBinaryOp -> [CBinaryOp] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [ CBinaryOp
CLndOp, CBinaryOp
CLorOp ]

-- | C unary operator (K&R A7.3-4)
--
data CUnaryOp = CPreIncOp               -- ^ prefix increment operator
              | CPreDecOp               -- ^ prefix decrement operator
              | CPostIncOp              -- ^ postfix increment operator
              | CPostDecOp              -- ^ postfix decrement operator
              | CAdrOp                  -- ^ address operator
              | CIndOp                  -- ^ indirection operator
              | CPlusOp                 -- ^ prefix plus
              | CMinOp                  -- ^ prefix minus
              | CCompOp                 -- ^ one's complement
              | CNegOp                  -- ^ logical negation
              deriving (CUnaryOp -> CUnaryOp -> Bool
(CUnaryOp -> CUnaryOp -> Bool)
-> (CUnaryOp -> CUnaryOp -> Bool) -> Eq CUnaryOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CUnaryOp -> CUnaryOp -> Bool
$c/= :: CUnaryOp -> CUnaryOp -> Bool
== :: CUnaryOp -> CUnaryOp -> Bool
$c== :: CUnaryOp -> CUnaryOp -> Bool
Eq,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,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,Typeable CUnaryOp
DataType
Constr
Typeable CUnaryOp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CUnaryOp -> c CUnaryOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CUnaryOp)
-> (CUnaryOp -> Constr)
-> (CUnaryOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CUnaryOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CUnaryOp))
-> ((forall b. Data b => b -> b) -> CUnaryOp -> CUnaryOp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CUnaryOp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CUnaryOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> CUnaryOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CUnaryOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp)
-> Data CUnaryOp
CUnaryOp -> DataType
CUnaryOp -> Constr
(forall b. Data b => b -> b) -> CUnaryOp -> CUnaryOp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CUnaryOp -> c CUnaryOp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CUnaryOp
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CUnaryOp -> u
forall u. (forall d. Data d => d -> u) -> CUnaryOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CUnaryOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CUnaryOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CUnaryOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CUnaryOp -> c CUnaryOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CUnaryOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CUnaryOp)
$cCNegOp :: Constr
$cCCompOp :: Constr
$cCMinOp :: Constr
$cCPlusOp :: Constr
$cCIndOp :: Constr
$cCAdrOp :: Constr
$cCPostDecOp :: Constr
$cCPostIncOp :: Constr
$cCPreDecOp :: Constr
$cCPreIncOp :: Constr
$tCUnaryOp :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp
gmapMp :: (forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp
gmapM :: (forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp
gmapQi :: Int -> (forall d. Data d => d -> u) -> CUnaryOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CUnaryOp -> u
gmapQ :: (forall d. Data d => d -> u) -> CUnaryOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CUnaryOp -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CUnaryOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CUnaryOp -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CUnaryOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CUnaryOp -> r
gmapT :: (forall b. Data b => b -> b) -> CUnaryOp -> CUnaryOp
$cgmapT :: (forall b. Data b => b -> b) -> CUnaryOp -> CUnaryOp
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CUnaryOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CUnaryOp)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CUnaryOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CUnaryOp)
dataTypeOf :: CUnaryOp -> DataType
$cdataTypeOf :: CUnaryOp -> DataType
toConstr :: CUnaryOp -> Constr
$ctoConstr :: CUnaryOp -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CUnaryOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CUnaryOp
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CUnaryOp -> c CUnaryOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CUnaryOp -> c CUnaryOp
$cp1Data :: Typeable CUnaryOp
Data,Typeable,(forall x. CUnaryOp -> Rep CUnaryOp x)
-> (forall x. Rep CUnaryOp x -> CUnaryOp) -> Generic CUnaryOp
forall x. Rep CUnaryOp x -> CUnaryOp
forall x. CUnaryOp -> Rep CUnaryOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CUnaryOp x -> CUnaryOp
$cfrom :: forall x. CUnaryOp -> Rep CUnaryOp x
Generic)

instance NFData CUnaryOp

isEffectfulOp :: CUnaryOp -> Bool
isEffectfulOp :: CUnaryOp -> Bool
isEffectfulOp op :: CUnaryOp
op = CUnaryOp
op CUnaryOp -> [CUnaryOp] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [ CUnaryOp
CPreIncOp, CUnaryOp
CPreDecOp, CUnaryOp
CPostIncOp, CUnaryOp
CPostDecOp ]