{-# LANGUAGE DeriveDataTypeable #-}
-----------------------------------------------------------------------------
-- |
-- Module      :  Language.C.Syntax.Constants
-- Copyright   :  (c) 2007..2008 Duncan Coutts, Benedikt Huber
-- License     :  BSD-style
-- Maintainer  : benedikt.huber@gmail.com
-- Stability   : experimental
-- Portability : ghc
--
-- This module provides support for representing, checking and exporting c
-- constants, i.e. integral, float, character and string constants.
-----------------------------------------------------------------------------
module Language.C.Syntax.Constants (
  -- * Utilities
  escapeChar, unescapeChar, unescapeString,
  Flags(..), noFlags, setFlag, clearFlag, testFlag,
  -- * C char constants (and multi-character character constants)
  cChar, cChar_w, cChars, CChar(..), getCChar, getCCharAsInt, isWideChar, showCharConst,
  -- * C integral constants
  CIntFlag(..), CIntRepr(..), cInteger, CInteger(..), getCInteger,readCInteger,
  -- * C floating point constants
  cFloat,  CFloat(..), readCFloat,
  -- * C string literals
  cString, cString_w, CString(..), getCString, showStringLit, concatCStrings,
  -- * Clang C version literals
  ClangCVersion(..), readClangCVersion,
)
where
import Data.Bits
import Data.Char
import Numeric (showOct, showHex, readHex, readOct, readDec)
import Data.Data (Data)
import Data.Typeable (Typeable)
import GHC.Generics (Generic, Generic1)
import Control.DeepSeq (NFData)

-- | C char constants (abstract)
data CChar = CChar
              !Char
              !Bool  -- wide flag
           | CChars
              [Char] -- multi-character character constant
              !Bool   -- wide flag
           deriving (CChar -> CChar -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CChar -> CChar -> Bool
$c/= :: CChar -> CChar -> Bool
== :: CChar -> CChar -> Bool
$c== :: CChar -> CChar -> Bool
Eq,Eq CChar
CChar -> CChar -> Bool
CChar -> CChar -> Ordering
CChar -> CChar -> CChar
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 :: CChar -> CChar -> CChar
$cmin :: CChar -> CChar -> CChar
max :: CChar -> CChar -> CChar
$cmax :: CChar -> CChar -> CChar
>= :: CChar -> CChar -> Bool
$c>= :: CChar -> CChar -> Bool
> :: CChar -> CChar -> Bool
$c> :: CChar -> CChar -> Bool
<= :: CChar -> CChar -> Bool
$c<= :: CChar -> CChar -> Bool
< :: CChar -> CChar -> Bool
$c< :: CChar -> CChar -> Bool
compare :: CChar -> CChar -> Ordering
$ccompare :: CChar -> CChar -> Ordering
Ord,Typeable CChar
CChar -> DataType
CChar -> Constr
(forall b. Data b => b -> b) -> CChar -> CChar
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) -> CChar -> u
forall u. (forall d. Data d => d -> u) -> CChar -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CChar -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CChar -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CChar -> m CChar
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CChar -> m CChar
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CChar
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CChar -> c CChar
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CChar)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CChar)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CChar -> m CChar
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CChar -> m CChar
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CChar -> m CChar
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CChar -> m CChar
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CChar -> m CChar
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CChar -> m CChar
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CChar -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CChar -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CChar -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CChar -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CChar -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CChar -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CChar -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CChar -> r
gmapT :: (forall b. Data b => b -> b) -> CChar -> CChar
$cgmapT :: (forall b. Data b => b -> b) -> CChar -> CChar
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CChar)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CChar)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CChar)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CChar)
dataTypeOf :: CChar -> DataType
$cdataTypeOf :: CChar -> DataType
toConstr :: CChar -> Constr
$ctoConstr :: CChar -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CChar
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CChar
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CChar -> c CChar
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CChar -> c CChar
Data,Typeable,forall x. Rep CChar x -> CChar
forall x. CChar -> Rep CChar x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CChar x -> CChar
$cfrom :: forall x. CChar -> Rep CChar x
Generic)

instance Show CChar where
    showsPrec :: Int -> CChar -> ShowS
showsPrec Int
_ (CChar Char
c Bool
wideflag)   = Bool -> ShowS
_showWideFlag Bool
wideflag forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showCharConst Char
c
    showsPrec Int
_ (CChars String
cs Bool
wideflag) = Bool -> ShowS
_showWideFlag Bool
wideflag forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
sQuote (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Char -> String
escapeCChar String
cs)

instance NFData CChar

-- | @showCharConst c@ prepends _a_ String representing the C char constant corresponding to @c@.
-- If necessary uses octal or hexadecimal escape sequences.
showCharConst :: Char -> ShowS
showCharConst :: Char -> ShowS
showCharConst Char
c = String -> ShowS
sQuote forall a b. (a -> b) -> a -> b
$ Char -> String
escapeCChar Char
c

_showWideFlag :: Bool -> ShowS
_showWideFlag :: Bool -> ShowS
_showWideFlag Bool
flag = if Bool
flag then String -> ShowS
showString String
"L" else forall a. a -> a
id

-- | get the haskell representation of a char constant
getCChar :: CChar -> String
getCChar :: CChar -> String
getCChar (CChar  Char
c Bool
_)   = [Char
c]
getCChar (CChars  String
cs Bool
_) = String
cs

-- | get integer value of a C char constant
-- undefined result for multi-char char constants
getCCharAsInt :: CChar -> Integer
getCCharAsInt :: CChar -> Integer
getCCharAsInt (CChar Char
c Bool
_) = forall a b. (Integral a, Num b) => a -> b
fromIntegral (forall a. Enum a => a -> Int
fromEnum Char
c)
getCCharAsInt (CChars String
_cs Bool
_) = forall a. HasCallStack => String -> a
error String
"integer value of multi-character character constants is implementation defined"

-- | return @true@ if the character constant is /wide/.
isWideChar :: CChar -> Bool
isWideChar :: CChar -> Bool
isWideChar (CChar Char
_ Bool
wideFlag) = Bool
wideFlag
isWideChar (CChars String
_ Bool
wideFlag) = Bool
wideFlag

-- | construct a character constant from a haskell 'Char'
-- Use 'cchar_w' if you want a wide character constant.
cChar :: Char -> CChar
cChar :: Char -> CChar
cChar Char
c = Char -> Bool -> CChar
CChar Char
c Bool
False

-- | construct a wide chararacter constant
cChar_w :: Char -> CChar
cChar_w :: Char -> CChar
cChar_w Char
c = Char -> Bool -> CChar
CChar Char
c Bool
True

-- | create a multi-character character constant
cChars :: String -> Bool -> CChar
cChars :: String -> Bool -> CChar
cChars = String -> Bool -> CChar
CChars

-- | datatype for memorizing the representation of an integer
data CIntRepr = DecRepr | HexRepr | OctalRepr
  deriving (CIntRepr -> CIntRepr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CIntRepr -> CIntRepr -> Bool
$c/= :: CIntRepr -> CIntRepr -> Bool
== :: CIntRepr -> CIntRepr -> Bool
$c== :: CIntRepr -> CIntRepr -> Bool
Eq,Eq CIntRepr
CIntRepr -> CIntRepr -> Bool
CIntRepr -> CIntRepr -> Ordering
CIntRepr -> CIntRepr -> CIntRepr
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 :: CIntRepr -> CIntRepr -> CIntRepr
$cmin :: CIntRepr -> CIntRepr -> CIntRepr
max :: CIntRepr -> CIntRepr -> CIntRepr
$cmax :: CIntRepr -> CIntRepr -> CIntRepr
>= :: CIntRepr -> CIntRepr -> Bool
$c>= :: CIntRepr -> CIntRepr -> Bool
> :: CIntRepr -> CIntRepr -> Bool
$c> :: CIntRepr -> CIntRepr -> Bool
<= :: CIntRepr -> CIntRepr -> Bool
$c<= :: CIntRepr -> CIntRepr -> Bool
< :: CIntRepr -> CIntRepr -> Bool
$c< :: CIntRepr -> CIntRepr -> Bool
compare :: CIntRepr -> CIntRepr -> Ordering
$ccompare :: CIntRepr -> CIntRepr -> Ordering
Ord,Int -> CIntRepr
CIntRepr -> Int
CIntRepr -> [CIntRepr]
CIntRepr -> CIntRepr
CIntRepr -> CIntRepr -> [CIntRepr]
CIntRepr -> CIntRepr -> CIntRepr -> [CIntRepr]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: CIntRepr -> CIntRepr -> CIntRepr -> [CIntRepr]
$cenumFromThenTo :: CIntRepr -> CIntRepr -> CIntRepr -> [CIntRepr]
enumFromTo :: CIntRepr -> CIntRepr -> [CIntRepr]
$cenumFromTo :: CIntRepr -> CIntRepr -> [CIntRepr]
enumFromThen :: CIntRepr -> CIntRepr -> [CIntRepr]
$cenumFromThen :: CIntRepr -> CIntRepr -> [CIntRepr]
enumFrom :: CIntRepr -> [CIntRepr]
$cenumFrom :: CIntRepr -> [CIntRepr]
fromEnum :: CIntRepr -> Int
$cfromEnum :: CIntRepr -> Int
toEnum :: Int -> CIntRepr
$ctoEnum :: Int -> CIntRepr
pred :: CIntRepr -> CIntRepr
$cpred :: CIntRepr -> CIntRepr
succ :: CIntRepr -> CIntRepr
$csucc :: CIntRepr -> CIntRepr
Enum,CIntRepr
forall a. a -> a -> Bounded a
maxBound :: CIntRepr
$cmaxBound :: CIntRepr
minBound :: CIntRepr
$cminBound :: CIntRepr
Bounded,Typeable CIntRepr
CIntRepr -> DataType
CIntRepr -> Constr
(forall b. Data b => b -> b) -> CIntRepr -> CIntRepr
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) -> CIntRepr -> u
forall u. (forall d. Data d => d -> u) -> CIntRepr -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CIntRepr -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CIntRepr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CIntRepr -> m CIntRepr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CIntRepr -> m CIntRepr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CIntRepr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CIntRepr -> c CIntRepr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CIntRepr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CIntRepr)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CIntRepr -> m CIntRepr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CIntRepr -> m CIntRepr
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CIntRepr -> m CIntRepr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CIntRepr -> m CIntRepr
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CIntRepr -> m CIntRepr
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CIntRepr -> m CIntRepr
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CIntRepr -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CIntRepr -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CIntRepr -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CIntRepr -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CIntRepr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CIntRepr -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CIntRepr -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CIntRepr -> r
gmapT :: (forall b. Data b => b -> b) -> CIntRepr -> CIntRepr
$cgmapT :: (forall b. Data b => b -> b) -> CIntRepr -> CIntRepr
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CIntRepr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CIntRepr)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CIntRepr)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CIntRepr)
dataTypeOf :: CIntRepr -> DataType
$cdataTypeOf :: CIntRepr -> DataType
toConstr :: CIntRepr -> Constr
$ctoConstr :: CIntRepr -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CIntRepr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CIntRepr
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CIntRepr -> c CIntRepr
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CIntRepr -> c CIntRepr
Data,Typeable,forall x. Rep CIntRepr x -> CIntRepr
forall x. CIntRepr -> Rep CIntRepr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CIntRepr x -> CIntRepr
$cfrom :: forall x. CIntRepr -> Rep CIntRepr x
Generic)

instance NFData CIntRepr

-- | datatype representing type flags for integers
data CIntFlag = FlagUnsigned | FlagLong | FlagLongLong | FlagImag
  deriving (CIntFlag -> CIntFlag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CIntFlag -> CIntFlag -> Bool
$c/= :: CIntFlag -> CIntFlag -> Bool
== :: CIntFlag -> CIntFlag -> Bool
$c== :: CIntFlag -> CIntFlag -> Bool
Eq,Eq CIntFlag
CIntFlag -> CIntFlag -> Bool
CIntFlag -> CIntFlag -> Ordering
CIntFlag -> CIntFlag -> CIntFlag
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 :: CIntFlag -> CIntFlag -> CIntFlag
$cmin :: CIntFlag -> CIntFlag -> CIntFlag
max :: CIntFlag -> CIntFlag -> CIntFlag
$cmax :: CIntFlag -> CIntFlag -> CIntFlag
>= :: CIntFlag -> CIntFlag -> Bool
$c>= :: CIntFlag -> CIntFlag -> Bool
> :: CIntFlag -> CIntFlag -> Bool
$c> :: CIntFlag -> CIntFlag -> Bool
<= :: CIntFlag -> CIntFlag -> Bool
$c<= :: CIntFlag -> CIntFlag -> Bool
< :: CIntFlag -> CIntFlag -> Bool
$c< :: CIntFlag -> CIntFlag -> Bool
compare :: CIntFlag -> CIntFlag -> Ordering
$ccompare :: CIntFlag -> CIntFlag -> Ordering
Ord,Int -> CIntFlag
CIntFlag -> Int
CIntFlag -> [CIntFlag]
CIntFlag -> CIntFlag
CIntFlag -> CIntFlag -> [CIntFlag]
CIntFlag -> CIntFlag -> CIntFlag -> [CIntFlag]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: CIntFlag -> CIntFlag -> CIntFlag -> [CIntFlag]
$cenumFromThenTo :: CIntFlag -> CIntFlag -> CIntFlag -> [CIntFlag]
enumFromTo :: CIntFlag -> CIntFlag -> [CIntFlag]
$cenumFromTo :: CIntFlag -> CIntFlag -> [CIntFlag]
enumFromThen :: CIntFlag -> CIntFlag -> [CIntFlag]
$cenumFromThen :: CIntFlag -> CIntFlag -> [CIntFlag]
enumFrom :: CIntFlag -> [CIntFlag]
$cenumFrom :: CIntFlag -> [CIntFlag]
fromEnum :: CIntFlag -> Int
$cfromEnum :: CIntFlag -> Int
toEnum :: Int -> CIntFlag
$ctoEnum :: Int -> CIntFlag
pred :: CIntFlag -> CIntFlag
$cpred :: CIntFlag -> CIntFlag
succ :: CIntFlag -> CIntFlag
$csucc :: CIntFlag -> CIntFlag
Enum,CIntFlag
forall a. a -> a -> Bounded a
maxBound :: CIntFlag
$cmaxBound :: CIntFlag
minBound :: CIntFlag
$cminBound :: CIntFlag
Bounded,Typeable CIntFlag
CIntFlag -> DataType
CIntFlag -> Constr
(forall b. Data b => b -> b) -> CIntFlag -> CIntFlag
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) -> CIntFlag -> u
forall u. (forall d. Data d => d -> u) -> CIntFlag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CIntFlag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CIntFlag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CIntFlag -> m CIntFlag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CIntFlag -> m CIntFlag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CIntFlag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CIntFlag -> c CIntFlag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CIntFlag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CIntFlag)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CIntFlag -> m CIntFlag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CIntFlag -> m CIntFlag
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CIntFlag -> m CIntFlag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CIntFlag -> m CIntFlag
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CIntFlag -> m CIntFlag
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CIntFlag -> m CIntFlag
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CIntFlag -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CIntFlag -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CIntFlag -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CIntFlag -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CIntFlag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CIntFlag -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CIntFlag -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CIntFlag -> r
gmapT :: (forall b. Data b => b -> b) -> CIntFlag -> CIntFlag
$cgmapT :: (forall b. Data b => b -> b) -> CIntFlag -> CIntFlag
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CIntFlag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CIntFlag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CIntFlag)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CIntFlag)
dataTypeOf :: CIntFlag -> DataType
$cdataTypeOf :: CIntFlag -> DataType
toConstr :: CIntFlag -> Constr
$ctoConstr :: CIntFlag -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CIntFlag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CIntFlag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CIntFlag -> c CIntFlag
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CIntFlag -> c CIntFlag
Data,Typeable,forall x. Rep CIntFlag x -> CIntFlag
forall x. CIntFlag -> Rep CIntFlag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CIntFlag x -> CIntFlag
$cfrom :: forall x. CIntFlag -> Rep CIntFlag x
Generic)
instance Show CIntFlag where
    show :: CIntFlag -> String
show CIntFlag
FlagUnsigned = String
"u"
    show CIntFlag
FlagLong = String
"L"
    show CIntFlag
FlagLongLong = String
"LL"
    show CIntFlag
FlagImag = String
"i"
instance NFData CIntFlag

{-# SPECIALIZE setFlag :: CIntFlag -> Flags CIntFlag -> Flags CIntFlag #-}
{-# SPECIALIZE clearFlag :: CIntFlag -> Flags CIntFlag -> Flags CIntFlag #-}
{-# SPECIALIZE testFlag :: CIntFlag -> Flags CIntFlag -> Bool #-}

data CInteger = CInteger
                 !Integer
                 !CIntRepr
                 !(Flags CIntFlag)  -- integer flags
                 deriving (CInteger -> CInteger -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CInteger -> CInteger -> Bool
$c/= :: CInteger -> CInteger -> Bool
== :: CInteger -> CInteger -> Bool
$c== :: CInteger -> CInteger -> Bool
Eq,Eq CInteger
CInteger -> CInteger -> Bool
CInteger -> CInteger -> Ordering
CInteger -> CInteger -> CInteger
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 :: CInteger -> CInteger -> CInteger
$cmin :: CInteger -> CInteger -> CInteger
max :: CInteger -> CInteger -> CInteger
$cmax :: CInteger -> CInteger -> CInteger
>= :: CInteger -> CInteger -> Bool
$c>= :: CInteger -> CInteger -> Bool
> :: CInteger -> CInteger -> Bool
$c> :: CInteger -> CInteger -> Bool
<= :: CInteger -> CInteger -> Bool
$c<= :: CInteger -> CInteger -> Bool
< :: CInteger -> CInteger -> Bool
$c< :: CInteger -> CInteger -> Bool
compare :: CInteger -> CInteger -> Ordering
$ccompare :: CInteger -> CInteger -> Ordering
Ord,Typeable CInteger
CInteger -> DataType
CInteger -> Constr
(forall b. Data b => b -> b) -> CInteger -> CInteger
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) -> CInteger -> u
forall u. (forall d. Data d => d -> u) -> CInteger -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CInteger -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CInteger -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CInteger -> m CInteger
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CInteger -> m CInteger
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CInteger
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CInteger -> c CInteger
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CInteger)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CInteger)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CInteger -> m CInteger
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CInteger -> m CInteger
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CInteger -> m CInteger
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CInteger -> m CInteger
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CInteger -> m CInteger
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CInteger -> m CInteger
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CInteger -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CInteger -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CInteger -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CInteger -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CInteger -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CInteger -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CInteger -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CInteger -> r
gmapT :: (forall b. Data b => b -> b) -> CInteger -> CInteger
$cgmapT :: (forall b. Data b => b -> b) -> CInteger -> CInteger
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CInteger)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CInteger)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CInteger)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CInteger)
dataTypeOf :: CInteger -> DataType
$cdataTypeOf :: CInteger -> DataType
toConstr :: CInteger -> Constr
$ctoConstr :: CInteger -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CInteger
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CInteger
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CInteger -> c CInteger
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CInteger -> c CInteger
Data,Typeable,forall x. Rep CInteger x -> CInteger
forall x. CInteger -> Rep CInteger x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CInteger x -> CInteger
$cfrom :: forall x. CInteger -> Rep CInteger x
Generic)
instance Show CInteger where
    showsPrec :: Int -> CInteger -> ShowS
showsPrec Int
_ (CInteger Integer
ig CIntRepr
repr Flags CIntFlag
flags) = forall {a}. (Show a, Integral a) => a -> ShowS
showInt Integer
ig forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap CIntFlag -> String
showIFlag [CIntFlag
FlagUnsigned .. ]) where
        showIFlag :: CIntFlag -> String
showIFlag CIntFlag
f = if forall f. Enum f => f -> Flags f -> Bool
testFlag CIntFlag
f Flags CIntFlag
flags then forall a. Show a => a -> String
show CIntFlag
f else []
        showInt :: a -> ShowS
showInt a
num = case CIntRepr
repr of CIntRepr
DecRepr -> forall a. Show a => a -> ShowS
shows a
num
                                   CIntRepr
OctalRepr -> String -> ShowS
showString String
"0" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (Integral a, Show a) => a -> ShowS
showOct a
num
                                   CIntRepr
HexRepr -> String -> ShowS
showString String
"0x" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (Integral a, Show a) => a -> ShowS
showHex a
num
instance NFData CInteger

-- To be used in the lexer
-- Note that the flag lexer won't scale
readCInteger :: CIntRepr -> String -> Either String CInteger
readCInteger :: CIntRepr -> String -> Either String CInteger
readCInteger CIntRepr
repr String
str =
  case ReadS Integer
readNum String
str of
    [(Integer
n,String
suffix)] -> Integer -> String -> Either String CInteger
mkCInt Integer
n String
suffix
    [(Integer, String)]
parseFailed  -> forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$ String
"Bad Integer literal: "forall a. [a] -> [a] -> [a]
++forall a. Show a => a -> String
show [(Integer, String)]
parseFailed
  where
    readNum :: ReadS Integer
readNum = case CIntRepr
repr of CIntRepr
DecRepr -> forall a. (Eq a, Num a) => ReadS a
readDec; CIntRepr
HexRepr -> forall a. (Eq a, Num a) => ReadS a
readHex; CIntRepr
OctalRepr -> forall a. (Eq a, Num a) => ReadS a
readOct
    mkCInt :: Integer -> String -> Either String CInteger
mkCInt Integer
n String
suffix = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a b. a -> Either a b
Left (forall a b. b -> Either a b
Right forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> CIntRepr -> Flags CIntFlag -> CInteger
CInteger Integer
n CIntRepr
repr)  forall a b. (a -> b) -> a -> b
$ String -> Either String (Flags CIntFlag)
readSuffix String
suffix
    readSuffix :: String -> Either String (Flags CIntFlag)
readSuffix = Flags CIntFlag -> String -> Either String (Flags CIntFlag)
parseFlags forall f. Flags f
noFlags
    parseFlags :: Flags CIntFlag -> String -> Either String (Flags CIntFlag)
parseFlags Flags CIntFlag
flags [] = forall a b. b -> Either a b
Right Flags CIntFlag
flags
    parseFlags Flags CIntFlag
flags (Char
'l':Char
'l':String
fs) = Flags CIntFlag -> String -> Either String (Flags CIntFlag)
parseFlags (forall f. Enum f => f -> Flags f -> Flags f
setFlag CIntFlag
FlagLongLong Flags CIntFlag
flags) String
fs
    parseFlags Flags CIntFlag
flags (Char
'L':Char
'L':String
fs) = Flags CIntFlag -> String -> Either String (Flags CIntFlag)
parseFlags (forall f. Enum f => f -> Flags f -> Flags f
setFlag CIntFlag
FlagLongLong Flags CIntFlag
flags) String
fs
    parseFlags Flags CIntFlag
flags (Char
f:String
fs) =
      let go1 :: CIntFlag -> Either String (Flags CIntFlag)
go1 CIntFlag
flag = Flags CIntFlag -> String -> Either String (Flags CIntFlag)
parseFlags (forall f. Enum f => f -> Flags f -> Flags f
setFlag CIntFlag
flag Flags CIntFlag
flags) String
fs in
      case Char
f of
        Char
'l' -> CIntFlag -> Either String (Flags CIntFlag)
go1 CIntFlag
FlagLong ; Char
'L' -> CIntFlag -> Either String (Flags CIntFlag)
go1 CIntFlag
FlagLong
        Char
'u' -> CIntFlag -> Either String (Flags CIntFlag)
go1 CIntFlag
FlagUnsigned ; Char
'U' -> CIntFlag -> Either String (Flags CIntFlag)
go1 CIntFlag
FlagUnsigned
        Char
'i' -> CIntFlag -> Either String (Flags CIntFlag)
go1 CIntFlag
FlagImag ; Char
'I' -> CIntFlag -> Either String (Flags CIntFlag)
go1 CIntFlag
FlagImag; Char
'j' -> CIntFlag -> Either String (Flags CIntFlag)
go1 CIntFlag
FlagImag; Char
'J' -> CIntFlag -> Either String (Flags CIntFlag)
go1 CIntFlag
FlagImag
        Char
_ -> forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$ String
"Unexpected flag " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Char
f

getCInteger :: CInteger -> Integer
getCInteger :: CInteger -> Integer
getCInteger (CInteger Integer
i CIntRepr
_ Flags CIntFlag
_) = Integer
i

-- | construct a integer constant (without type flags) from a haskell integer
cInteger :: Integer -> CInteger
cInteger :: Integer -> CInteger
cInteger Integer
i = Integer -> CIntRepr -> Flags CIntFlag -> CInteger
CInteger Integer
i CIntRepr
DecRepr forall f. Flags f
noFlags


-- | Floats (represented as strings)
data CFloat = CFloat
               !String
               deriving (CFloat -> CFloat -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CFloat -> CFloat -> Bool
$c/= :: CFloat -> CFloat -> Bool
== :: CFloat -> CFloat -> Bool
$c== :: CFloat -> CFloat -> Bool
Eq,Eq CFloat
CFloat -> CFloat -> Bool
CFloat -> CFloat -> Ordering
CFloat -> CFloat -> CFloat
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 :: CFloat -> CFloat -> CFloat
$cmin :: CFloat -> CFloat -> CFloat
max :: CFloat -> CFloat -> CFloat
$cmax :: CFloat -> CFloat -> CFloat
>= :: CFloat -> CFloat -> Bool
$c>= :: CFloat -> CFloat -> Bool
> :: CFloat -> CFloat -> Bool
$c> :: CFloat -> CFloat -> Bool
<= :: CFloat -> CFloat -> Bool
$c<= :: CFloat -> CFloat -> Bool
< :: CFloat -> CFloat -> Bool
$c< :: CFloat -> CFloat -> Bool
compare :: CFloat -> CFloat -> Ordering
$ccompare :: CFloat -> CFloat -> Ordering
Ord,Typeable CFloat
CFloat -> DataType
CFloat -> Constr
(forall b. Data b => b -> b) -> CFloat -> CFloat
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) -> CFloat -> u
forall u. (forall d. Data d => d -> u) -> CFloat -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CFloat -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CFloat -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CFloat -> m CFloat
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CFloat -> m CFloat
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CFloat
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CFloat -> c CFloat
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CFloat)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CFloat)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CFloat -> m CFloat
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CFloat -> m CFloat
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CFloat -> m CFloat
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CFloat -> m CFloat
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CFloat -> m CFloat
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CFloat -> m CFloat
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CFloat -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CFloat -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CFloat -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CFloat -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CFloat -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CFloat -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CFloat -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CFloat -> r
gmapT :: (forall b. Data b => b -> b) -> CFloat -> CFloat
$cgmapT :: (forall b. Data b => b -> b) -> CFloat -> CFloat
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CFloat)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CFloat)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CFloat)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CFloat)
dataTypeOf :: CFloat -> DataType
$cdataTypeOf :: CFloat -> DataType
toConstr :: CFloat -> Constr
$ctoConstr :: CFloat -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CFloat
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CFloat
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CFloat -> c CFloat
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CFloat -> c CFloat
Data,Typeable,forall x. Rep CFloat x -> CFloat
forall x. CFloat -> Rep CFloat x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CFloat x -> CFloat
$cfrom :: forall x. CFloat -> Rep CFloat x
Generic)
instance Show CFloat where
  showsPrec :: Int -> CFloat -> ShowS
showsPrec Int
_ (CFloat String
internal) = String -> ShowS
showString String
internal
instance NFData CFloat

cFloat :: Float -> CFloat
cFloat :: Float -> CFloat
cFloat = String -> CFloat
CFloat forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show

-- dummy implementation
readCFloat :: String -> CFloat
readCFloat :: String -> CFloat
readCFloat = String -> CFloat
CFloat

-- | Clang dotted version literal
-- <https://clang.llvm.org/docs/AttributeReference.html#availability>
data ClangCVersion = ClangCVersion
                     !String
                     deriving (ClangCVersion -> ClangCVersion -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ClangCVersion -> ClangCVersion -> Bool
$c/= :: ClangCVersion -> ClangCVersion -> Bool
== :: ClangCVersion -> ClangCVersion -> Bool
$c== :: ClangCVersion -> ClangCVersion -> Bool
Eq,Eq ClangCVersion
ClangCVersion -> ClangCVersion -> Bool
ClangCVersion -> ClangCVersion -> Ordering
ClangCVersion -> ClangCVersion -> ClangCVersion
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 :: ClangCVersion -> ClangCVersion -> ClangCVersion
$cmin :: ClangCVersion -> ClangCVersion -> ClangCVersion
max :: ClangCVersion -> ClangCVersion -> ClangCVersion
$cmax :: ClangCVersion -> ClangCVersion -> ClangCVersion
>= :: ClangCVersion -> ClangCVersion -> Bool
$c>= :: ClangCVersion -> ClangCVersion -> Bool
> :: ClangCVersion -> ClangCVersion -> Bool
$c> :: ClangCVersion -> ClangCVersion -> Bool
<= :: ClangCVersion -> ClangCVersion -> Bool
$c<= :: ClangCVersion -> ClangCVersion -> Bool
< :: ClangCVersion -> ClangCVersion -> Bool
$c< :: ClangCVersion -> ClangCVersion -> Bool
compare :: ClangCVersion -> ClangCVersion -> Ordering
$ccompare :: ClangCVersion -> ClangCVersion -> Ordering
Ord,Typeable ClangCVersion
ClangCVersion -> DataType
ClangCVersion -> Constr
(forall b. Data b => b -> b) -> ClangCVersion -> ClangCVersion
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) -> ClangCVersion -> u
forall u. (forall d. Data d => d -> u) -> ClangCVersion -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClangCVersion -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClangCVersion -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClangCVersion -> m ClangCVersion
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClangCVersion -> m ClangCVersion
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClangCVersion
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClangCVersion -> c ClangCVersion
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClangCVersion)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ClangCVersion)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClangCVersion -> m ClangCVersion
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClangCVersion -> m ClangCVersion
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClangCVersion -> m ClangCVersion
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClangCVersion -> m ClangCVersion
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClangCVersion -> m ClangCVersion
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClangCVersion -> m ClangCVersion
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ClangCVersion -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ClangCVersion -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ClangCVersion -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ClangCVersion -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClangCVersion -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClangCVersion -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClangCVersion -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClangCVersion -> r
gmapT :: (forall b. Data b => b -> b) -> ClangCVersion -> ClangCVersion
$cgmapT :: (forall b. Data b => b -> b) -> ClangCVersion -> ClangCVersion
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ClangCVersion)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ClangCVersion)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClangCVersion)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClangCVersion)
dataTypeOf :: ClangCVersion -> DataType
$cdataTypeOf :: ClangCVersion -> DataType
toConstr :: ClangCVersion -> Constr
$ctoConstr :: ClangCVersion -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClangCVersion
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClangCVersion
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClangCVersion -> c ClangCVersion
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClangCVersion -> c ClangCVersion
Data,Typeable)
instance Show ClangCVersion where
  showsPrec :: Int -> ClangCVersion -> ShowS
showsPrec Int
_ (ClangCVersion String
internal) = String -> ShowS
showString String
internal

readClangCVersion :: String -> ClangCVersion
readClangCVersion :: String -> ClangCVersion
readClangCVersion = String -> ClangCVersion
ClangCVersion

-- | C String literals
data CString = CString
                String    -- characters
                Bool      -- wide flag
                deriving (CString -> CString -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CString -> CString -> Bool
$c/= :: CString -> CString -> Bool
== :: CString -> CString -> Bool
$c== :: CString -> CString -> Bool
Eq,Eq CString
CString -> CString -> Bool
CString -> CString -> Ordering
CString -> CString -> CString
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 :: CString -> CString -> CString
$cmin :: CString -> CString -> CString
max :: CString -> CString -> CString
$cmax :: CString -> CString -> CString
>= :: CString -> CString -> Bool
$c>= :: CString -> CString -> Bool
> :: CString -> CString -> Bool
$c> :: CString -> CString -> Bool
<= :: CString -> CString -> Bool
$c<= :: CString -> CString -> Bool
< :: CString -> CString -> Bool
$c< :: CString -> CString -> Bool
compare :: CString -> CString -> Ordering
$ccompare :: CString -> CString -> Ordering
Ord,Typeable CString
CString -> DataType
CString -> Constr
(forall b. Data b => b -> b) -> CString -> CString
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) -> CString -> u
forall u. (forall d. Data d => d -> u) -> CString -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CString -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CString -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CString -> m CString
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CString -> m CString
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CString
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CString -> c CString
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CString)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CString)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CString -> m CString
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CString -> m CString
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CString -> m CString
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CString -> m CString
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CString -> m CString
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CString -> m CString
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CString -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CString -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CString -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CString -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CString -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CString -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CString -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CString -> r
gmapT :: (forall b. Data b => b -> b) -> CString -> CString
$cgmapT :: (forall b. Data b => b -> b) -> CString -> CString
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CString)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CString)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CString)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CString)
dataTypeOf :: CString -> DataType
$cdataTypeOf :: CString -> DataType
toConstr :: CString -> Constr
$ctoConstr :: CString -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CString
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CString
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CString -> c CString
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CString -> c CString
Data,Typeable, forall x. Rep CString x -> CString
forall x. CString -> Rep CString x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CString x -> CString
$cfrom :: forall x. CString -> Rep CString x
Generic)
instance Show CString where
    showsPrec :: Int -> CString -> ShowS
showsPrec Int
_ (CString String
str Bool
wideflag) = Bool -> ShowS
_showWideFlag Bool
wideflag forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showStringLit String
str
instance NFData CString

-- construction
cString :: String -> CString
cString :: String -> CString
cString String
str = String -> Bool -> CString
CString String
str Bool
False
cString_w :: String -> CString
cString_w :: String -> CString
cString_w String
str = String -> Bool -> CString
CString String
str Bool
True

-- selectors
getCString :: CString -> String
getCString :: CString -> String
getCString (CString String
str Bool
_) = String
str
isWideString :: CString -> Bool
isWideString :: CString -> Bool
isWideString (CString String
_ Bool
wideflag) = Bool
wideflag

-- | concatenate a list of C string literals
concatCStrings :: [CString] -> CString
concatCStrings :: [CString] -> CString
concatCStrings [CString]
cs = String -> Bool -> CString
CString (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap CString -> String
getCString [CString]
cs) (forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any CString -> Bool
isWideString [CString]
cs)

-- | @showStringLiteral s@ prepends a String representing the C string literal corresponding to @s@.
-- If necessary it uses octal or hexadecimal escape sequences.
showStringLit :: String -> ShowS
showStringLit :: String -> ShowS
showStringLit = String -> ShowS
dQuote forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Char -> String
showStringChar
  where
  showStringChar :: Char -> String
showStringChar Char
c | Char -> Bool
isSChar Char
c = forall (m :: * -> *) a. Monad m => a -> m a
return Char
c
                     | Char
c forall a. Eq a => a -> a -> Bool
== Char
'"'  = String
"\\\""
                     | Bool
otherwise = Char -> String
escapeChar Char
c



-- | @isAsciiSourceChar b@ returns @True@ if the given character is a character which
--   may appear in a ASCII C source file and is printable.
isAsciiSourceChar :: Char -> Bool
isAsciiSourceChar :: Char -> Bool
isAsciiSourceChar Char
c = Char -> Bool
isAscii Char
c Bool -> Bool -> Bool
&& Char -> Bool
isPrint Char
c

-- | @isCChar c@ returns true, if c is a source character which does not have to be escaped in
--   C char constants (C99: 6.4.4.4)
isCChar :: Char -> Bool
isCChar :: Char -> Bool
isCChar Char
'\\' = Bool
False
isCChar Char
'\'' = Bool
False
isCChar Char
'\n' = Bool
False
isCChar Char
c = Char -> Bool
isAsciiSourceChar Char
c

-- | @escapeCChar c@ escapes c for use in a char constant
escapeCChar :: Char -> String
escapeCChar :: Char -> String
escapeCChar Char
'\'' = String
"\\'"
escapeCChar Char
c | Char -> Bool
isCChar Char
c = [Char
c]
              | Bool
otherwise = Char -> String
escapeChar Char
c

-- | @isSChar c@ returns true if c is a source character which does not have to be escaped in C string
--  literals (C99: 6.4.5)
isSChar :: Char -> Bool
isSChar :: Char -> Bool
isSChar Char
'\\' = Bool
False
isSChar Char
'\"' = Bool
False
isSChar Char
'\n' = Bool
False
isSChar Char
c = Char -> Bool
isAsciiSourceChar Char
c

showOct' :: Int -> String
showOct' :: Int -> String
showOct' Int
i = forall a. Int -> a -> [a]
replicate (Int
3 forall a. Num a => a -> a -> a
- forall (t :: * -> *) a. Foldable t => t a -> Int
length String
s) Char
'0' forall a. [a] -> [a] -> [a]
++ String
s
  where s :: String
s = forall a. (Integral a, Show a) => a -> ShowS
showOct Int
i String
""

escapeChar :: Char -> String
escapeChar :: Char -> String
escapeChar Char
'\\' = String
"\\\\"
escapeChar Char
'\a' = String
"\\a"
escapeChar Char
'\b' = String
"\\b"
escapeChar Char
'\f' = String
"\\f"
escapeChar Char
'\n' = String
"\\n"
escapeChar Char
'\r' = String
"\\r"
escapeChar Char
'\t' = String
"\\t"
escapeChar Char
'\v' = String
"\\v"
escapeChar Char
c  | (Char -> Int
ord Char
c) forall a. Ord a => a -> a -> Bool
< Int
512   = Char
'\\' forall a. a -> [a] -> [a]
: Int -> String
showOct' (Char -> Int
ord Char
c)
              | Bool
otherwise       = Char
'\\' forall a. a -> [a] -> [a]
: Char
'x'  forall a. a -> [a] -> [a]
: forall a. (Integral a, Show a) => a -> ShowS
showHex (Char -> Int
ord Char
c) String
""

unescapeChar :: String -> (Char, String)
unescapeChar :: String -> (Char, String)
unescapeChar (Char
'\\':Char
c:String
cs)  = case Char
c of
       Char
'n'  -> (Char
'\n', String
cs)
       Char
't'  -> (Char
'\t', String
cs)
       Char
'v'  -> (Char
'\v', String
cs)
       Char
'b'  -> (Char
'\b', String
cs)
       Char
'r'  -> (Char
'\r', String
cs)
       Char
'f'  -> (Char
'\f', String
cs)
       Char
'a'  -> (Char
'\a', String
cs)
       Char
'e'  -> (Char
'\ESC', String
cs)  -- GNU extension
       Char
'E'  -> (Char
'\ESC', String
cs)  -- GNU extension
       Char
'\\' -> (Char
'\\', String
cs)
       Char
'?'  -> (Char
'?', String
cs)
       Char
'\'' -> (Char
'\'', String
cs)
       Char
'"'  -> (Char
'"', String
cs)
       Char
'x'  -> case forall a. String -> [a] -> a
head' String
"bad escape sequence" (forall a. (Eq a, Num a) => ReadS a
readHex String
cs) of
                 (Int
i, String
cs') -> (forall a. Enum a => Int -> a
toEnum Int
i, String
cs')
       Char
_    -> case forall a. String -> [a] -> a
head' String
"bad escape sequence" (ReadS Int
readOct' (Char
cforall a. a -> [a] -> [a]
:String
cs)) of
                 (Int
i, String
cs') -> (forall a. Enum a => Int -> a
toEnum Int
i, String
cs')
unescapeChar (Char
c   :String
cs)    = (Char
c, String
cs)
unescapeChar []  = forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ String
"unescape char: empty string"

readOct' :: ReadS Int
readOct' :: ReadS Int
readOct' String
s = forall a b. (a -> b) -> [a] -> [b]
map (\(Int
i, String
cs) -> (Int
i, String
cs forall a. [a] -> [a] -> [a]
++ String
rest)) (forall a. (Eq a, Num a) => ReadS a
readOct String
octStr)
  where octStr :: String
octStr = forall a. (a -> Bool) -> [a] -> [a]
takeWhile Char -> Bool
isOctDigit forall a b. (a -> b) -> a -> b
$ forall a. Int -> [a] -> [a]
take Int
3 String
s
        rest :: String
rest = forall a. Int -> [a] -> [a]
drop (forall (t :: * -> *) a. Foldable t => t a -> Int
length String
octStr) String
s

unescapeString :: String -> String
unescapeString :: ShowS
unescapeString [] = []
unescapeString String
cs = case String -> (Char, String)
unescapeChar String
cs of
                        (Char
c, String
cs') -> Char
c forall a. a -> [a] -> [a]
: ShowS
unescapeString String
cs'

-- helpers
sQuote :: String -> ShowS
sQuote :: String -> ShowS
sQuote String
s String
t = String
"'" forall a. [a] -> [a] -> [a]
++ String
s forall a. [a] -> [a] -> [a]
++ String
"'" forall a. [a] -> [a] -> [a]
++ String
t
dQuote :: String -> ShowS
dQuote :: String -> ShowS
dQuote String
s String
t = (Char
'"' forall a. a -> [a] -> [a]
: String
s) forall a. [a] -> [a] -> [a]
++ String
"\"" forall a. [a] -> [a] -> [a]
++ String
t
head' :: String -> [a] -> a
head' :: forall a. String -> [a] -> a
head' String
err []  = forall a. HasCallStack => String -> a
error String
err
head' String
_ (a
x:[a]
_) = a
x

-- TODO: Move to separate file ?
newtype Flags f = Flags Integer deriving (Flags f -> Flags f -> Bool
forall f. Flags f -> Flags f -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Flags f -> Flags f -> Bool
$c/= :: forall f. Flags f -> Flags f -> Bool
== :: Flags f -> Flags f -> Bool
$c== :: forall f. Flags f -> Flags f -> Bool
Eq,Flags f -> Flags f -> Bool
Flags f -> Flags f -> Ordering
Flags f -> Flags f -> Flags f
forall f. Eq (Flags f)
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
forall f. Flags f -> Flags f -> Bool
forall f. Flags f -> Flags f -> Ordering
forall f. Flags f -> Flags f -> Flags f
min :: Flags f -> Flags f -> Flags f
$cmin :: forall f. Flags f -> Flags f -> Flags f
max :: Flags f -> Flags f -> Flags f
$cmax :: forall f. Flags f -> Flags f -> Flags f
>= :: Flags f -> Flags f -> Bool
$c>= :: forall f. Flags f -> Flags f -> Bool
> :: Flags f -> Flags f -> Bool
$c> :: forall f. Flags f -> Flags f -> Bool
<= :: Flags f -> Flags f -> Bool
$c<= :: forall f. Flags f -> Flags f -> Bool
< :: Flags f -> Flags f -> Bool
$c< :: forall f. Flags f -> Flags f -> Bool
compare :: Flags f -> Flags f -> Ordering
$ccompare :: forall f. Flags f -> Flags f -> Ordering
Ord,Flags f -> DataType
Flags f -> Constr
forall {f}. Data f => Typeable (Flags f)
forall f. Data f => Flags f -> DataType
forall f. Data f => Flags f -> Constr
forall f.
Data f =>
(forall b. Data b => b -> b) -> Flags f -> Flags f
forall f u.
Data f =>
Int -> (forall d. Data d => d -> u) -> Flags f -> u
forall f u.
Data f =>
(forall d. Data d => d -> u) -> Flags f -> [u]
forall f r r'.
Data f =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Flags f -> r
forall f r r'.
Data f =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Flags f -> r
forall f (m :: * -> *).
(Data f, Monad m) =>
(forall d. Data d => d -> m d) -> Flags f -> m (Flags f)
forall f (m :: * -> *).
(Data f, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Flags f -> m (Flags f)
forall f (c :: * -> *).
Data f =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Flags f)
forall f (c :: * -> *).
Data f =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flags f -> c (Flags f)
forall f (t :: * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Flags f))
forall f (t :: * -> * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Flags f))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Flags f)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flags f -> c (Flags f)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Flags f))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Flags f -> m (Flags f)
$cgmapMo :: forall f (m :: * -> *).
(Data f, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Flags f -> m (Flags f)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Flags f -> m (Flags f)
$cgmapMp :: forall f (m :: * -> *).
(Data f, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Flags f -> m (Flags f)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Flags f -> m (Flags f)
$cgmapM :: forall f (m :: * -> *).
(Data f, Monad m) =>
(forall d. Data d => d -> m d) -> Flags f -> m (Flags f)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Flags f -> u
$cgmapQi :: forall f u.
Data f =>
Int -> (forall d. Data d => d -> u) -> Flags f -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Flags f -> [u]
$cgmapQ :: forall f u.
Data f =>
(forall d. Data d => d -> u) -> Flags f -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Flags f -> r
$cgmapQr :: forall f r r'.
Data f =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Flags f -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Flags f -> r
$cgmapQl :: forall f r r'.
Data f =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Flags f -> r
gmapT :: (forall b. Data b => b -> b) -> Flags f -> Flags f
$cgmapT :: forall f.
Data f =>
(forall b. Data b => b -> b) -> Flags f -> Flags f
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Flags f))
$cdataCast2 :: forall f (t :: * -> * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Flags f))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Flags f))
$cdataCast1 :: forall f (t :: * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Flags f))
dataTypeOf :: Flags f -> DataType
$cdataTypeOf :: forall f. Data f => Flags f -> DataType
toConstr :: Flags f -> Constr
$ctoConstr :: forall f. Data f => Flags f -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Flags f)
$cgunfold :: forall f (c :: * -> *).
Data f =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Flags f)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flags f -> c (Flags f)
$cgfoldl :: forall f (c :: * -> *).
Data f =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flags f -> c (Flags f)
Data,Typeable,forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall f x. Rep (Flags f) x -> Flags f
forall f x. Flags f -> Rep (Flags f) x
$cto :: forall f x. Rep (Flags f) x -> Flags f
$cfrom :: forall f x. Flags f -> Rep (Flags f) x
Generic,forall a. Rep1 Flags a -> Flags a
forall a. Flags a -> Rep1 Flags a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cto1 :: forall a. Rep1 Flags a -> Flags a
$cfrom1 :: forall a. Flags a -> Rep1 Flags a
Generic1)
instance NFData (Flags f)
noFlags :: Flags f
noFlags :: forall f. Flags f
noFlags = forall f. Integer -> Flags f
Flags Integer
0
setFlag :: (Enum f) => f -> Flags f -> Flags f
setFlag :: forall f. Enum f => f -> Flags f -> Flags f
setFlag f
flag (Flags Integer
k)   = forall f. Integer -> Flags f
Flagsforall a b. (a -> b) -> a -> b
$ Integer
k  forall a. Bits a => a -> Int -> a
`setBit` forall a. Enum a => a -> Int
fromEnum f
flag
clearFlag :: (Enum f) => f -> Flags f -> Flags f
clearFlag :: forall f. Enum f => f -> Flags f -> Flags f
clearFlag f
flag (Flags Integer
k) = forall f. Integer -> Flags f
Flagsforall a b. (a -> b) -> a -> b
$ Integer
k forall a. Bits a => a -> Int -> a
`clearBit` forall a. Enum a => a -> Int
fromEnum f
flag
testFlag :: (Enum f) => f -> Flags f -> Bool
testFlag :: forall f. Enum f => f -> Flags f -> Bool
testFlag f
flag (Flags Integer
k)  = Integer
k forall a. Bits a => a -> Int -> Bool
`testBit` forall a. Enum a => a -> Int
fromEnum f
flag