-- |
-- Module           : Lang.Crucible.LLVM.Errors.Standards
-- Description      : Standards documents
-- Copyright        : (c) Galois, Inc 2018
-- License          : BSD3
-- Maintainer       : Langston Barrett <lbarrett@galois.com>
-- Stability        : provisional
--
--------------------------------------------------------------------------

{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE Safe #-}

module Lang.Crucible.LLVM.Errors.Standards
  ( Standard(..)
  , CStdVer(..)
  , CXXStdVer(..)
  , LLVMRefVer(..)
  , ppStd
  , stdURL
  ) where

import           Prelude hiding (unwords, unlines)

import           Data.Data (Data)
import           Data.Typeable (Typeable)
import           GHC.Generics (Generic)

import           Data.Text (Text, pack)

-- | The various standards that prohibit certain behaviors
data Standard =
    CStd    CStdVer    -- ^ The C language standard
  | CXXStd  CXXStdVer  -- ^ The C++ language standard
  | LLVMRef LLVMRefVer -- ^ The LLVM language reference
  deriving (Typeable Standard
Typeable Standard =>
(forall (c :: Type -> Type).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Standard -> c Standard)
-> (forall (c :: Type -> Type).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Standard)
-> (Standard -> Constr)
-> (Standard -> DataType)
-> (forall (t :: Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Standard))
-> (forall (t :: Type -> Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Standard))
-> ((forall b. Data b => b -> b) -> Standard -> Standard)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Standard -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Standard -> r)
-> (forall u. (forall d. Data d => d -> u) -> Standard -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Standard -> u)
-> (forall (m :: Type -> Type).
    Monad m =>
    (forall d. Data d => d -> m d) -> Standard -> m Standard)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Standard -> m Standard)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Standard -> m Standard)
-> Data Standard
Standard -> Constr
Standard -> DataType
(forall b. Data b => b -> b) -> Standard -> Standard
forall a.
Typeable a =>
(forall (c :: Type -> Type).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: Type -> Type).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: Type -> Type -> Type) (c :: Type -> Type).
    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 :: Type -> Type).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Standard -> u
forall u. (forall d. Data d => d -> u) -> Standard -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Standard -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Standard -> r
forall (m :: Type -> Type).
Monad m =>
(forall d. Data d => d -> m d) -> Standard -> m Standard
forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Standard -> m Standard
forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Standard
forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Standard -> c Standard
forall (t :: Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Standard)
forall (t :: Type -> Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Standard)
$cgfoldl :: forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Standard -> c Standard
gfoldl :: forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Standard -> c Standard
$cgunfold :: forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Standard
gunfold :: forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Standard
$ctoConstr :: Standard -> Constr
toConstr :: Standard -> Constr
$cdataTypeOf :: Standard -> DataType
dataTypeOf :: Standard -> DataType
$cdataCast1 :: forall (t :: Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Standard)
dataCast1 :: forall (t :: Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Standard)
$cdataCast2 :: forall (t :: Type -> Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Standard)
dataCast2 :: forall (t :: Type -> Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Standard)
$cgmapT :: (forall b. Data b => b -> b) -> Standard -> Standard
gmapT :: (forall b. Data b => b -> b) -> Standard -> Standard
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Standard -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Standard -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Standard -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Standard -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Standard -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Standard -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Standard -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Standard -> u
$cgmapM :: forall (m :: Type -> Type).
Monad m =>
(forall d. Data d => d -> m d) -> Standard -> m Standard
gmapM :: forall (m :: Type -> Type).
Monad m =>
(forall d. Data d => d -> m d) -> Standard -> m Standard
$cgmapMp :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Standard -> m Standard
gmapMp :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Standard -> m Standard
$cgmapMo :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Standard -> m Standard
gmapMo :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Standard -> m Standard
Data, Standard -> Standard -> Bool
(Standard -> Standard -> Bool)
-> (Standard -> Standard -> Bool) -> Eq Standard
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Standard -> Standard -> Bool
== :: Standard -> Standard -> Bool
$c/= :: Standard -> Standard -> Bool
/= :: Standard -> Standard -> Bool
Eq, (forall x. Standard -> Rep Standard x)
-> (forall x. Rep Standard x -> Standard) -> Generic Standard
forall x. Rep Standard x -> Standard
forall x. Standard -> Rep Standard x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Standard -> Rep Standard x
from :: forall x. Standard -> Rep Standard x
$cto :: forall x. Rep Standard x -> Standard
to :: forall x. Rep Standard x -> Standard
Generic, Eq Standard
Eq Standard =>
(Standard -> Standard -> Ordering)
-> (Standard -> Standard -> Bool)
-> (Standard -> Standard -> Bool)
-> (Standard -> Standard -> Bool)
-> (Standard -> Standard -> Bool)
-> (Standard -> Standard -> Standard)
-> (Standard -> Standard -> Standard)
-> Ord Standard
Standard -> Standard -> Bool
Standard -> Standard -> Ordering
Standard -> Standard -> Standard
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
$ccompare :: Standard -> Standard -> Ordering
compare :: Standard -> Standard -> Ordering
$c< :: Standard -> Standard -> Bool
< :: Standard -> Standard -> Bool
$c<= :: Standard -> Standard -> Bool
<= :: Standard -> Standard -> Bool
$c> :: Standard -> Standard -> Bool
> :: Standard -> Standard -> Bool
$c>= :: Standard -> Standard -> Bool
>= :: Standard -> Standard -> Bool
$cmax :: Standard -> Standard -> Standard
max :: Standard -> Standard -> Standard
$cmin :: Standard -> Standard -> Standard
min :: Standard -> Standard -> Standard
Ord, ReadPrec [Standard]
ReadPrec Standard
Int -> ReadS Standard
ReadS [Standard]
(Int -> ReadS Standard)
-> ReadS [Standard]
-> ReadPrec Standard
-> ReadPrec [Standard]
-> Read Standard
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Standard
readsPrec :: Int -> ReadS Standard
$creadList :: ReadS [Standard]
readList :: ReadS [Standard]
$creadPrec :: ReadPrec Standard
readPrec :: ReadPrec Standard
$creadListPrec :: ReadPrec [Standard]
readListPrec :: ReadPrec [Standard]
Read, Int -> Standard -> ShowS
[Standard] -> ShowS
Standard -> String
(Int -> Standard -> ShowS)
-> (Standard -> String) -> ([Standard] -> ShowS) -> Show Standard
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Standard -> ShowS
showsPrec :: Int -> Standard -> ShowS
$cshow :: Standard -> String
show :: Standard -> String
$cshowList :: [Standard] -> ShowS
showList :: [Standard] -> ShowS
Show, Typeable)

-- | Versions of the C standard
data CStdVer =
    C99
  | C11
  | C18
  deriving (Typeable CStdVer
Typeable CStdVer =>
(forall (c :: Type -> Type).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CStdVer -> c CStdVer)
-> (forall (c :: Type -> Type).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CStdVer)
-> (CStdVer -> Constr)
-> (CStdVer -> DataType)
-> (forall (t :: Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CStdVer))
-> (forall (t :: Type -> Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CStdVer))
-> ((forall b. Data b => b -> b) -> CStdVer -> CStdVer)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CStdVer -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CStdVer -> r)
-> (forall u. (forall d. Data d => d -> u) -> CStdVer -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CStdVer -> u)
-> (forall (m :: Type -> Type).
    Monad m =>
    (forall d. Data d => d -> m d) -> CStdVer -> m CStdVer)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CStdVer -> m CStdVer)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CStdVer -> m CStdVer)
-> Data CStdVer
CStdVer -> Constr
CStdVer -> DataType
(forall b. Data b => b -> b) -> CStdVer -> CStdVer
forall a.
Typeable a =>
(forall (c :: Type -> Type).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: Type -> Type).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: Type -> Type -> Type) (c :: Type -> Type).
    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 :: Type -> Type).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CStdVer -> u
forall u. (forall d. Data d => d -> u) -> CStdVer -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CStdVer -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CStdVer -> r
forall (m :: Type -> Type).
Monad m =>
(forall d. Data d => d -> m d) -> CStdVer -> m CStdVer
forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CStdVer -> m CStdVer
forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CStdVer
forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CStdVer -> c CStdVer
forall (t :: Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CStdVer)
forall (t :: Type -> Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CStdVer)
$cgfoldl :: forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CStdVer -> c CStdVer
gfoldl :: forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CStdVer -> c CStdVer
$cgunfold :: forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CStdVer
gunfold :: forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CStdVer
$ctoConstr :: CStdVer -> Constr
toConstr :: CStdVer -> Constr
$cdataTypeOf :: CStdVer -> DataType
dataTypeOf :: CStdVer -> DataType
$cdataCast1 :: forall (t :: Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CStdVer)
dataCast1 :: forall (t :: Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CStdVer)
$cdataCast2 :: forall (t :: Type -> Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CStdVer)
dataCast2 :: forall (t :: Type -> Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CStdVer)
$cgmapT :: (forall b. Data b => b -> b) -> CStdVer -> CStdVer
gmapT :: (forall b. Data b => b -> b) -> CStdVer -> CStdVer
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CStdVer -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CStdVer -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CStdVer -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CStdVer -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CStdVer -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CStdVer -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CStdVer -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CStdVer -> u
$cgmapM :: forall (m :: Type -> Type).
Monad m =>
(forall d. Data d => d -> m d) -> CStdVer -> m CStdVer
gmapM :: forall (m :: Type -> Type).
Monad m =>
(forall d. Data d => d -> m d) -> CStdVer -> m CStdVer
$cgmapMp :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CStdVer -> m CStdVer
gmapMp :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CStdVer -> m CStdVer
$cgmapMo :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CStdVer -> m CStdVer
gmapMo :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CStdVer -> m CStdVer
Data, CStdVer -> CStdVer -> Bool
(CStdVer -> CStdVer -> Bool)
-> (CStdVer -> CStdVer -> Bool) -> Eq CStdVer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CStdVer -> CStdVer -> Bool
== :: CStdVer -> CStdVer -> Bool
$c/= :: CStdVer -> CStdVer -> Bool
/= :: CStdVer -> CStdVer -> Bool
Eq, Int -> CStdVer
CStdVer -> Int
CStdVer -> [CStdVer]
CStdVer -> CStdVer
CStdVer -> CStdVer -> [CStdVer]
CStdVer -> CStdVer -> CStdVer -> [CStdVer]
(CStdVer -> CStdVer)
-> (CStdVer -> CStdVer)
-> (Int -> CStdVer)
-> (CStdVer -> Int)
-> (CStdVer -> [CStdVer])
-> (CStdVer -> CStdVer -> [CStdVer])
-> (CStdVer -> CStdVer -> [CStdVer])
-> (CStdVer -> CStdVer -> CStdVer -> [CStdVer])
-> Enum CStdVer
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: CStdVer -> CStdVer
succ :: CStdVer -> CStdVer
$cpred :: CStdVer -> CStdVer
pred :: CStdVer -> CStdVer
$ctoEnum :: Int -> CStdVer
toEnum :: Int -> CStdVer
$cfromEnum :: CStdVer -> Int
fromEnum :: CStdVer -> Int
$cenumFrom :: CStdVer -> [CStdVer]
enumFrom :: CStdVer -> [CStdVer]
$cenumFromThen :: CStdVer -> CStdVer -> [CStdVer]
enumFromThen :: CStdVer -> CStdVer -> [CStdVer]
$cenumFromTo :: CStdVer -> CStdVer -> [CStdVer]
enumFromTo :: CStdVer -> CStdVer -> [CStdVer]
$cenumFromThenTo :: CStdVer -> CStdVer -> CStdVer -> [CStdVer]
enumFromThenTo :: CStdVer -> CStdVer -> CStdVer -> [CStdVer]
Enum, (forall x. CStdVer -> Rep CStdVer x)
-> (forall x. Rep CStdVer x -> CStdVer) -> Generic CStdVer
forall x. Rep CStdVer x -> CStdVer
forall x. CStdVer -> Rep CStdVer x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CStdVer -> Rep CStdVer x
from :: forall x. CStdVer -> Rep CStdVer x
$cto :: forall x. Rep CStdVer x -> CStdVer
to :: forall x. Rep CStdVer x -> CStdVer
Generic, Eq CStdVer
Eq CStdVer =>
(CStdVer -> CStdVer -> Ordering)
-> (CStdVer -> CStdVer -> Bool)
-> (CStdVer -> CStdVer -> Bool)
-> (CStdVer -> CStdVer -> Bool)
-> (CStdVer -> CStdVer -> Bool)
-> (CStdVer -> CStdVer -> CStdVer)
-> (CStdVer -> CStdVer -> CStdVer)
-> Ord CStdVer
CStdVer -> CStdVer -> Bool
CStdVer -> CStdVer -> Ordering
CStdVer -> CStdVer -> CStdVer
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
$ccompare :: CStdVer -> CStdVer -> Ordering
compare :: CStdVer -> CStdVer -> Ordering
$c< :: CStdVer -> CStdVer -> Bool
< :: CStdVer -> CStdVer -> Bool
$c<= :: CStdVer -> CStdVer -> Bool
<= :: CStdVer -> CStdVer -> Bool
$c> :: CStdVer -> CStdVer -> Bool
> :: CStdVer -> CStdVer -> Bool
$c>= :: CStdVer -> CStdVer -> Bool
>= :: CStdVer -> CStdVer -> Bool
$cmax :: CStdVer -> CStdVer -> CStdVer
max :: CStdVer -> CStdVer -> CStdVer
$cmin :: CStdVer -> CStdVer -> CStdVer
min :: CStdVer -> CStdVer -> CStdVer
Ord, ReadPrec [CStdVer]
ReadPrec CStdVer
Int -> ReadS CStdVer
ReadS [CStdVer]
(Int -> ReadS CStdVer)
-> ReadS [CStdVer]
-> ReadPrec CStdVer
-> ReadPrec [CStdVer]
-> Read CStdVer
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CStdVer
readsPrec :: Int -> ReadS CStdVer
$creadList :: ReadS [CStdVer]
readList :: ReadS [CStdVer]
$creadPrec :: ReadPrec CStdVer
readPrec :: ReadPrec CStdVer
$creadListPrec :: ReadPrec [CStdVer]
readListPrec :: ReadPrec [CStdVer]
Read, Int -> CStdVer -> ShowS
[CStdVer] -> ShowS
CStdVer -> String
(Int -> CStdVer -> ShowS)
-> (CStdVer -> String) -> ([CStdVer] -> ShowS) -> Show CStdVer
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CStdVer -> ShowS
showsPrec :: Int -> CStdVer -> ShowS
$cshow :: CStdVer -> String
show :: CStdVer -> String
$cshowList :: [CStdVer] -> ShowS
showList :: [CStdVer] -> ShowS
Show, Typeable)

-- | Versions of the C++ standard
data CXXStdVer =
    CXX03
  | CXX11
  | CXX14
  | CXX17
  deriving (Typeable CXXStdVer
Typeable CXXStdVer =>
(forall (c :: Type -> Type).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CXXStdVer -> c CXXStdVer)
-> (forall (c :: Type -> Type).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CXXStdVer)
-> (CXXStdVer -> Constr)
-> (CXXStdVer -> DataType)
-> (forall (t :: Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CXXStdVer))
-> (forall (t :: Type -> Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CXXStdVer))
-> ((forall b. Data b => b -> b) -> CXXStdVer -> CXXStdVer)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CXXStdVer -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CXXStdVer -> r)
-> (forall u. (forall d. Data d => d -> u) -> CXXStdVer -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CXXStdVer -> u)
-> (forall (m :: Type -> Type).
    Monad m =>
    (forall d. Data d => d -> m d) -> CXXStdVer -> m CXXStdVer)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CXXStdVer -> m CXXStdVer)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CXXStdVer -> m CXXStdVer)
-> Data CXXStdVer
CXXStdVer -> Constr
CXXStdVer -> DataType
(forall b. Data b => b -> b) -> CXXStdVer -> CXXStdVer
forall a.
Typeable a =>
(forall (c :: Type -> Type).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: Type -> Type).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: Type -> Type -> Type) (c :: Type -> Type).
    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 :: Type -> Type).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CXXStdVer -> u
forall u. (forall d. Data d => d -> u) -> CXXStdVer -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CXXStdVer -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CXXStdVer -> r
forall (m :: Type -> Type).
Monad m =>
(forall d. Data d => d -> m d) -> CXXStdVer -> m CXXStdVer
forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CXXStdVer -> m CXXStdVer
forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CXXStdVer
forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CXXStdVer -> c CXXStdVer
forall (t :: Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CXXStdVer)
forall (t :: Type -> Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CXXStdVer)
$cgfoldl :: forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CXXStdVer -> c CXXStdVer
gfoldl :: forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CXXStdVer -> c CXXStdVer
$cgunfold :: forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CXXStdVer
gunfold :: forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CXXStdVer
$ctoConstr :: CXXStdVer -> Constr
toConstr :: CXXStdVer -> Constr
$cdataTypeOf :: CXXStdVer -> DataType
dataTypeOf :: CXXStdVer -> DataType
$cdataCast1 :: forall (t :: Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CXXStdVer)
dataCast1 :: forall (t :: Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CXXStdVer)
$cdataCast2 :: forall (t :: Type -> Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CXXStdVer)
dataCast2 :: forall (t :: Type -> Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CXXStdVer)
$cgmapT :: (forall b. Data b => b -> b) -> CXXStdVer -> CXXStdVer
gmapT :: (forall b. Data b => b -> b) -> CXXStdVer -> CXXStdVer
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CXXStdVer -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CXXStdVer -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CXXStdVer -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CXXStdVer -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CXXStdVer -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CXXStdVer -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CXXStdVer -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CXXStdVer -> u
$cgmapM :: forall (m :: Type -> Type).
Monad m =>
(forall d. Data d => d -> m d) -> CXXStdVer -> m CXXStdVer
gmapM :: forall (m :: Type -> Type).
Monad m =>
(forall d. Data d => d -> m d) -> CXXStdVer -> m CXXStdVer
$cgmapMp :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CXXStdVer -> m CXXStdVer
gmapMp :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CXXStdVer -> m CXXStdVer
$cgmapMo :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CXXStdVer -> m CXXStdVer
gmapMo :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CXXStdVer -> m CXXStdVer
Data, CXXStdVer -> CXXStdVer -> Bool
(CXXStdVer -> CXXStdVer -> Bool)
-> (CXXStdVer -> CXXStdVer -> Bool) -> Eq CXXStdVer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CXXStdVer -> CXXStdVer -> Bool
== :: CXXStdVer -> CXXStdVer -> Bool
$c/= :: CXXStdVer -> CXXStdVer -> Bool
/= :: CXXStdVer -> CXXStdVer -> Bool
Eq, Int -> CXXStdVer
CXXStdVer -> Int
CXXStdVer -> [CXXStdVer]
CXXStdVer -> CXXStdVer
CXXStdVer -> CXXStdVer -> [CXXStdVer]
CXXStdVer -> CXXStdVer -> CXXStdVer -> [CXXStdVer]
(CXXStdVer -> CXXStdVer)
-> (CXXStdVer -> CXXStdVer)
-> (Int -> CXXStdVer)
-> (CXXStdVer -> Int)
-> (CXXStdVer -> [CXXStdVer])
-> (CXXStdVer -> CXXStdVer -> [CXXStdVer])
-> (CXXStdVer -> CXXStdVer -> [CXXStdVer])
-> (CXXStdVer -> CXXStdVer -> CXXStdVer -> [CXXStdVer])
-> Enum CXXStdVer
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: CXXStdVer -> CXXStdVer
succ :: CXXStdVer -> CXXStdVer
$cpred :: CXXStdVer -> CXXStdVer
pred :: CXXStdVer -> CXXStdVer
$ctoEnum :: Int -> CXXStdVer
toEnum :: Int -> CXXStdVer
$cfromEnum :: CXXStdVer -> Int
fromEnum :: CXXStdVer -> Int
$cenumFrom :: CXXStdVer -> [CXXStdVer]
enumFrom :: CXXStdVer -> [CXXStdVer]
$cenumFromThen :: CXXStdVer -> CXXStdVer -> [CXXStdVer]
enumFromThen :: CXXStdVer -> CXXStdVer -> [CXXStdVer]
$cenumFromTo :: CXXStdVer -> CXXStdVer -> [CXXStdVer]
enumFromTo :: CXXStdVer -> CXXStdVer -> [CXXStdVer]
$cenumFromThenTo :: CXXStdVer -> CXXStdVer -> CXXStdVer -> [CXXStdVer]
enumFromThenTo :: CXXStdVer -> CXXStdVer -> CXXStdVer -> [CXXStdVer]
Enum, (forall x. CXXStdVer -> Rep CXXStdVer x)
-> (forall x. Rep CXXStdVer x -> CXXStdVer) -> Generic CXXStdVer
forall x. Rep CXXStdVer x -> CXXStdVer
forall x. CXXStdVer -> Rep CXXStdVer x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CXXStdVer -> Rep CXXStdVer x
from :: forall x. CXXStdVer -> Rep CXXStdVer x
$cto :: forall x. Rep CXXStdVer x -> CXXStdVer
to :: forall x. Rep CXXStdVer x -> CXXStdVer
Generic, Eq CXXStdVer
Eq CXXStdVer =>
(CXXStdVer -> CXXStdVer -> Ordering)
-> (CXXStdVer -> CXXStdVer -> Bool)
-> (CXXStdVer -> CXXStdVer -> Bool)
-> (CXXStdVer -> CXXStdVer -> Bool)
-> (CXXStdVer -> CXXStdVer -> Bool)
-> (CXXStdVer -> CXXStdVer -> CXXStdVer)
-> (CXXStdVer -> CXXStdVer -> CXXStdVer)
-> Ord CXXStdVer
CXXStdVer -> CXXStdVer -> Bool
CXXStdVer -> CXXStdVer -> Ordering
CXXStdVer -> CXXStdVer -> CXXStdVer
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
$ccompare :: CXXStdVer -> CXXStdVer -> Ordering
compare :: CXXStdVer -> CXXStdVer -> Ordering
$c< :: CXXStdVer -> CXXStdVer -> Bool
< :: CXXStdVer -> CXXStdVer -> Bool
$c<= :: CXXStdVer -> CXXStdVer -> Bool
<= :: CXXStdVer -> CXXStdVer -> Bool
$c> :: CXXStdVer -> CXXStdVer -> Bool
> :: CXXStdVer -> CXXStdVer -> Bool
$c>= :: CXXStdVer -> CXXStdVer -> Bool
>= :: CXXStdVer -> CXXStdVer -> Bool
$cmax :: CXXStdVer -> CXXStdVer -> CXXStdVer
max :: CXXStdVer -> CXXStdVer -> CXXStdVer
$cmin :: CXXStdVer -> CXXStdVer -> CXXStdVer
min :: CXXStdVer -> CXXStdVer -> CXXStdVer
Ord, ReadPrec [CXXStdVer]
ReadPrec CXXStdVer
Int -> ReadS CXXStdVer
ReadS [CXXStdVer]
(Int -> ReadS CXXStdVer)
-> ReadS [CXXStdVer]
-> ReadPrec CXXStdVer
-> ReadPrec [CXXStdVer]
-> Read CXXStdVer
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CXXStdVer
readsPrec :: Int -> ReadS CXXStdVer
$creadList :: ReadS [CXXStdVer]
readList :: ReadS [CXXStdVer]
$creadPrec :: ReadPrec CXXStdVer
readPrec :: ReadPrec CXXStdVer
$creadListPrec :: ReadPrec [CXXStdVer]
readListPrec :: ReadPrec [CXXStdVer]
Read, Int -> CXXStdVer -> ShowS
[CXXStdVer] -> ShowS
CXXStdVer -> String
(Int -> CXXStdVer -> ShowS)
-> (CXXStdVer -> String)
-> ([CXXStdVer] -> ShowS)
-> Show CXXStdVer
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CXXStdVer -> ShowS
showsPrec :: Int -> CXXStdVer -> ShowS
$cshow :: CXXStdVer -> String
show :: CXXStdVer -> String
$cshowList :: [CXXStdVer] -> ShowS
showList :: [CXXStdVer] -> ShowS
Show, Typeable)

ppCXXStdVer :: CXXStdVer -> Text
ppCXXStdVer :: CXXStdVer -> Text
ppCXXStdVer CXXStdVer
CXX03 = Text
"C++03"
ppCXXStdVer CXXStdVer
CXX11 = Text
"C++11"
ppCXXStdVer CXXStdVer
CXX14 = Text
"C++14"
ppCXXStdVer CXXStdVer
CXX17 = Text
"C++17"

-- | Versions of the LLVM Language Reference
data LLVMRefVer =
    LLVM38
  | LLVM4
  | LLVM5
  | LLVM6
  | LLVM7
  | LLVM8
  | LLVM12
  deriving (Typeable LLVMRefVer
Typeable LLVMRefVer =>
(forall (c :: Type -> Type).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> LLVMRefVer -> c LLVMRefVer)
-> (forall (c :: Type -> Type).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LLVMRefVer)
-> (LLVMRefVer -> Constr)
-> (LLVMRefVer -> DataType)
-> (forall (t :: Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LLVMRefVer))
-> (forall (t :: Type -> Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c LLVMRefVer))
-> ((forall b. Data b => b -> b) -> LLVMRefVer -> LLVMRefVer)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LLVMRefVer -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LLVMRefVer -> r)
-> (forall u. (forall d. Data d => d -> u) -> LLVMRefVer -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> LLVMRefVer -> u)
-> (forall (m :: Type -> Type).
    Monad m =>
    (forall d. Data d => d -> m d) -> LLVMRefVer -> m LLVMRefVer)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LLVMRefVer -> m LLVMRefVer)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LLVMRefVer -> m LLVMRefVer)
-> Data LLVMRefVer
LLVMRefVer -> Constr
LLVMRefVer -> DataType
(forall b. Data b => b -> b) -> LLVMRefVer -> LLVMRefVer
forall a.
Typeable a =>
(forall (c :: Type -> Type).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: Type -> Type).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: Type -> Type -> Type) (c :: Type -> Type).
    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 :: Type -> Type).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> LLVMRefVer -> u
forall u. (forall d. Data d => d -> u) -> LLVMRefVer -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LLVMRefVer -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LLVMRefVer -> r
forall (m :: Type -> Type).
Monad m =>
(forall d. Data d => d -> m d) -> LLVMRefVer -> m LLVMRefVer
forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LLVMRefVer -> m LLVMRefVer
forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LLVMRefVer
forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LLVMRefVer -> c LLVMRefVer
forall (t :: Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LLVMRefVer)
forall (t :: Type -> Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LLVMRefVer)
$cgfoldl :: forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LLVMRefVer -> c LLVMRefVer
gfoldl :: forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LLVMRefVer -> c LLVMRefVer
$cgunfold :: forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LLVMRefVer
gunfold :: forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LLVMRefVer
$ctoConstr :: LLVMRefVer -> Constr
toConstr :: LLVMRefVer -> Constr
$cdataTypeOf :: LLVMRefVer -> DataType
dataTypeOf :: LLVMRefVer -> DataType
$cdataCast1 :: forall (t :: Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LLVMRefVer)
dataCast1 :: forall (t :: Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LLVMRefVer)
$cdataCast2 :: forall (t :: Type -> Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LLVMRefVer)
dataCast2 :: forall (t :: Type -> Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LLVMRefVer)
$cgmapT :: (forall b. Data b => b -> b) -> LLVMRefVer -> LLVMRefVer
gmapT :: (forall b. Data b => b -> b) -> LLVMRefVer -> LLVMRefVer
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LLVMRefVer -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LLVMRefVer -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LLVMRefVer -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LLVMRefVer -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> LLVMRefVer -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> LLVMRefVer -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LLVMRefVer -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LLVMRefVer -> u
$cgmapM :: forall (m :: Type -> Type).
Monad m =>
(forall d. Data d => d -> m d) -> LLVMRefVer -> m LLVMRefVer
gmapM :: forall (m :: Type -> Type).
Monad m =>
(forall d. Data d => d -> m d) -> LLVMRefVer -> m LLVMRefVer
$cgmapMp :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LLVMRefVer -> m LLVMRefVer
gmapMp :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LLVMRefVer -> m LLVMRefVer
$cgmapMo :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LLVMRefVer -> m LLVMRefVer
gmapMo :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LLVMRefVer -> m LLVMRefVer
Data, LLVMRefVer -> LLVMRefVer -> Bool
(LLVMRefVer -> LLVMRefVer -> Bool)
-> (LLVMRefVer -> LLVMRefVer -> Bool) -> Eq LLVMRefVer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LLVMRefVer -> LLVMRefVer -> Bool
== :: LLVMRefVer -> LLVMRefVer -> Bool
$c/= :: LLVMRefVer -> LLVMRefVer -> Bool
/= :: LLVMRefVer -> LLVMRefVer -> Bool
Eq, Int -> LLVMRefVer
LLVMRefVer -> Int
LLVMRefVer -> [LLVMRefVer]
LLVMRefVer -> LLVMRefVer
LLVMRefVer -> LLVMRefVer -> [LLVMRefVer]
LLVMRefVer -> LLVMRefVer -> LLVMRefVer -> [LLVMRefVer]
(LLVMRefVer -> LLVMRefVer)
-> (LLVMRefVer -> LLVMRefVer)
-> (Int -> LLVMRefVer)
-> (LLVMRefVer -> Int)
-> (LLVMRefVer -> [LLVMRefVer])
-> (LLVMRefVer -> LLVMRefVer -> [LLVMRefVer])
-> (LLVMRefVer -> LLVMRefVer -> [LLVMRefVer])
-> (LLVMRefVer -> LLVMRefVer -> LLVMRefVer -> [LLVMRefVer])
-> Enum LLVMRefVer
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: LLVMRefVer -> LLVMRefVer
succ :: LLVMRefVer -> LLVMRefVer
$cpred :: LLVMRefVer -> LLVMRefVer
pred :: LLVMRefVer -> LLVMRefVer
$ctoEnum :: Int -> LLVMRefVer
toEnum :: Int -> LLVMRefVer
$cfromEnum :: LLVMRefVer -> Int
fromEnum :: LLVMRefVer -> Int
$cenumFrom :: LLVMRefVer -> [LLVMRefVer]
enumFrom :: LLVMRefVer -> [LLVMRefVer]
$cenumFromThen :: LLVMRefVer -> LLVMRefVer -> [LLVMRefVer]
enumFromThen :: LLVMRefVer -> LLVMRefVer -> [LLVMRefVer]
$cenumFromTo :: LLVMRefVer -> LLVMRefVer -> [LLVMRefVer]
enumFromTo :: LLVMRefVer -> LLVMRefVer -> [LLVMRefVer]
$cenumFromThenTo :: LLVMRefVer -> LLVMRefVer -> LLVMRefVer -> [LLVMRefVer]
enumFromThenTo :: LLVMRefVer -> LLVMRefVer -> LLVMRefVer -> [LLVMRefVer]
Enum, (forall x. LLVMRefVer -> Rep LLVMRefVer x)
-> (forall x. Rep LLVMRefVer x -> LLVMRefVer) -> Generic LLVMRefVer
forall x. Rep LLVMRefVer x -> LLVMRefVer
forall x. LLVMRefVer -> Rep LLVMRefVer x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LLVMRefVer -> Rep LLVMRefVer x
from :: forall x. LLVMRefVer -> Rep LLVMRefVer x
$cto :: forall x. Rep LLVMRefVer x -> LLVMRefVer
to :: forall x. Rep LLVMRefVer x -> LLVMRefVer
Generic, Eq LLVMRefVer
Eq LLVMRefVer =>
(LLVMRefVer -> LLVMRefVer -> Ordering)
-> (LLVMRefVer -> LLVMRefVer -> Bool)
-> (LLVMRefVer -> LLVMRefVer -> Bool)
-> (LLVMRefVer -> LLVMRefVer -> Bool)
-> (LLVMRefVer -> LLVMRefVer -> Bool)
-> (LLVMRefVer -> LLVMRefVer -> LLVMRefVer)
-> (LLVMRefVer -> LLVMRefVer -> LLVMRefVer)
-> Ord LLVMRefVer
LLVMRefVer -> LLVMRefVer -> Bool
LLVMRefVer -> LLVMRefVer -> Ordering
LLVMRefVer -> LLVMRefVer -> LLVMRefVer
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
$ccompare :: LLVMRefVer -> LLVMRefVer -> Ordering
compare :: LLVMRefVer -> LLVMRefVer -> Ordering
$c< :: LLVMRefVer -> LLVMRefVer -> Bool
< :: LLVMRefVer -> LLVMRefVer -> Bool
$c<= :: LLVMRefVer -> LLVMRefVer -> Bool
<= :: LLVMRefVer -> LLVMRefVer -> Bool
$c> :: LLVMRefVer -> LLVMRefVer -> Bool
> :: LLVMRefVer -> LLVMRefVer -> Bool
$c>= :: LLVMRefVer -> LLVMRefVer -> Bool
>= :: LLVMRefVer -> LLVMRefVer -> Bool
$cmax :: LLVMRefVer -> LLVMRefVer -> LLVMRefVer
max :: LLVMRefVer -> LLVMRefVer -> LLVMRefVer
$cmin :: LLVMRefVer -> LLVMRefVer -> LLVMRefVer
min :: LLVMRefVer -> LLVMRefVer -> LLVMRefVer
Ord, ReadPrec [LLVMRefVer]
ReadPrec LLVMRefVer
Int -> ReadS LLVMRefVer
ReadS [LLVMRefVer]
(Int -> ReadS LLVMRefVer)
-> ReadS [LLVMRefVer]
-> ReadPrec LLVMRefVer
-> ReadPrec [LLVMRefVer]
-> Read LLVMRefVer
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS LLVMRefVer
readsPrec :: Int -> ReadS LLVMRefVer
$creadList :: ReadS [LLVMRefVer]
readList :: ReadS [LLVMRefVer]
$creadPrec :: ReadPrec LLVMRefVer
readPrec :: ReadPrec LLVMRefVer
$creadListPrec :: ReadPrec [LLVMRefVer]
readListPrec :: ReadPrec [LLVMRefVer]
Read, Int -> LLVMRefVer -> ShowS
[LLVMRefVer] -> ShowS
LLVMRefVer -> String
(Int -> LLVMRefVer -> ShowS)
-> (LLVMRefVer -> String)
-> ([LLVMRefVer] -> ShowS)
-> Show LLVMRefVer
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LLVMRefVer -> ShowS
showsPrec :: Int -> LLVMRefVer -> ShowS
$cshow :: LLVMRefVer -> String
show :: LLVMRefVer -> String
$cshowList :: [LLVMRefVer] -> ShowS
showList :: [LLVMRefVer] -> ShowS
Show, Typeable)

ppLLVMRefVer :: LLVMRefVer -> Text
ppLLVMRefVer :: LLVMRefVer -> Text
ppLLVMRefVer LLVMRefVer
LLVM38 = Text
"3.8"
ppLLVMRefVer LLVMRefVer
LLVM4  = Text
"4"
ppLLVMRefVer LLVMRefVer
LLVM5  = Text
"5"
ppLLVMRefVer LLVMRefVer
LLVM6  = Text
"6"
ppLLVMRefVer LLVMRefVer
LLVM7  = Text
"7"
ppLLVMRefVer LLVMRefVer
LLVM8  = Text
"8"
ppLLVMRefVer LLVMRefVer
LLVM12 = Text
"12"

stdURL :: Standard -> Maybe Text
stdURL :: Standard -> Maybe Text
stdURL (CStd   CStdVer
C11)     = Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"http://www.iso-9899.info/n1570.html"
stdURL (CXXStd CXXStdVer
CXX17)   = Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"http://www.open-std.org/jtc1/sc22/wg14/www/abq/c17_updated_proposed_fdis.pdf"
stdURL (LLVMRef LLVMRefVer
LLVM38) = Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"https://releases.llvm.org/3.8.0/docs/LangRef.html"
stdURL (LLVMRef LLVMRefVer
LLVM4)  = Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"https://releases.llvm.org/4.0.1/docs/LangRef.html"
stdURL (LLVMRef LLVMRefVer
LLVM5)  = Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"https://releases.llvm.org/5.0.0/docs/LangRef.html"
stdURL (LLVMRef LLVMRefVer
LLVM6)  = Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"https://releases.llvm.org/6.0.0/docs/LangRef.html"
stdURL (LLVMRef LLVMRefVer
LLVM7)  = Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"https://releases.llvm.org/7.0.0/docs/LangRef.html"
stdURL (LLVMRef LLVMRefVer
LLVM8)  = Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"https://releases.llvm.org/8.0.0/docs/LangRef.html"
stdURL (LLVMRef LLVMRefVer
LLVM12) = Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"https://releases.llvm.org/12.0.0/docs/LangRef.html"
stdURL Standard
_                = Maybe Text
forall a. Maybe a
Nothing

ppStd :: Standard -> Text
ppStd :: Standard -> Text
ppStd =
  \case
    CStd    CStdVer
ver -> Text
"The C language standard, version "     Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> String -> Text
pack (CStdVer -> String
forall a. Show a => a -> String
show CStdVer
ver)
    CXXStd  CXXStdVer
ver -> Text
"The C++ language standard, version "   Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> CXXStdVer -> Text
ppCXXStdVer CXXStdVer
ver
    LLVMRef LLVMRefVer
ver -> Text
"The LLVM language reference, version " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> LLVMRefVer -> Text
ppLLVMRefVer LLVMRefVer
ver