module Data.SpirV.Enum.MemoryAccess where

import Data.Bits (Bits)
import Data.String (IsString(..))
import Data.Word (Word32)
import Foreign (Storable(..))
import GHC.Read (Read(..))
import Text.ParserCombinators.ReadPrec (pfail)
import qualified GHC.Read as Read
import qualified Text.Read.Lex as Lex

newtype MemoryAccess = MemoryAccess Word32
  deriving (MemoryAccess -> MemoryAccess -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MemoryAccess -> MemoryAccess -> Bool
$c/= :: MemoryAccess -> MemoryAccess -> Bool
== :: MemoryAccess -> MemoryAccess -> Bool
$c== :: MemoryAccess -> MemoryAccess -> Bool
Eq, Eq MemoryAccess
MemoryAccess -> MemoryAccess -> Bool
MemoryAccess -> MemoryAccess -> Ordering
MemoryAccess -> MemoryAccess -> MemoryAccess
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 :: MemoryAccess -> MemoryAccess -> MemoryAccess
$cmin :: MemoryAccess -> MemoryAccess -> MemoryAccess
max :: MemoryAccess -> MemoryAccess -> MemoryAccess
$cmax :: MemoryAccess -> MemoryAccess -> MemoryAccess
>= :: MemoryAccess -> MemoryAccess -> Bool
$c>= :: MemoryAccess -> MemoryAccess -> Bool
> :: MemoryAccess -> MemoryAccess -> Bool
$c> :: MemoryAccess -> MemoryAccess -> Bool
<= :: MemoryAccess -> MemoryAccess -> Bool
$c<= :: MemoryAccess -> MemoryAccess -> Bool
< :: MemoryAccess -> MemoryAccess -> Bool
$c< :: MemoryAccess -> MemoryAccess -> Bool
compare :: MemoryAccess -> MemoryAccess -> Ordering
$ccompare :: MemoryAccess -> MemoryAccess -> Ordering
Ord, Ptr MemoryAccess -> IO MemoryAccess
Ptr MemoryAccess -> Int -> IO MemoryAccess
Ptr MemoryAccess -> Int -> MemoryAccess -> IO ()
Ptr MemoryAccess -> MemoryAccess -> IO ()
MemoryAccess -> Int
forall b. Ptr b -> Int -> IO MemoryAccess
forall b. Ptr b -> Int -> MemoryAccess -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr MemoryAccess -> MemoryAccess -> IO ()
$cpoke :: Ptr MemoryAccess -> MemoryAccess -> IO ()
peek :: Ptr MemoryAccess -> IO MemoryAccess
$cpeek :: Ptr MemoryAccess -> IO MemoryAccess
pokeByteOff :: forall b. Ptr b -> Int -> MemoryAccess -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> MemoryAccess -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO MemoryAccess
$cpeekByteOff :: forall b. Ptr b -> Int -> IO MemoryAccess
pokeElemOff :: Ptr MemoryAccess -> Int -> MemoryAccess -> IO ()
$cpokeElemOff :: Ptr MemoryAccess -> Int -> MemoryAccess -> IO ()
peekElemOff :: Ptr MemoryAccess -> Int -> IO MemoryAccess
$cpeekElemOff :: Ptr MemoryAccess -> Int -> IO MemoryAccess
alignment :: MemoryAccess -> Int
$calignment :: MemoryAccess -> Int
sizeOf :: MemoryAccess -> Int
$csizeOf :: MemoryAccess -> Int
Storable, Eq MemoryAccess
MemoryAccess
Int -> MemoryAccess
MemoryAccess -> Bool
MemoryAccess -> Int
MemoryAccess -> Maybe Int
MemoryAccess -> MemoryAccess
MemoryAccess -> Int -> Bool
MemoryAccess -> Int -> MemoryAccess
MemoryAccess -> MemoryAccess -> MemoryAccess
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: MemoryAccess -> Int
$cpopCount :: MemoryAccess -> Int
rotateR :: MemoryAccess -> Int -> MemoryAccess
$crotateR :: MemoryAccess -> Int -> MemoryAccess
rotateL :: MemoryAccess -> Int -> MemoryAccess
$crotateL :: MemoryAccess -> Int -> MemoryAccess
unsafeShiftR :: MemoryAccess -> Int -> MemoryAccess
$cunsafeShiftR :: MemoryAccess -> Int -> MemoryAccess
shiftR :: MemoryAccess -> Int -> MemoryAccess
$cshiftR :: MemoryAccess -> Int -> MemoryAccess
unsafeShiftL :: MemoryAccess -> Int -> MemoryAccess
$cunsafeShiftL :: MemoryAccess -> Int -> MemoryAccess
shiftL :: MemoryAccess -> Int -> MemoryAccess
$cshiftL :: MemoryAccess -> Int -> MemoryAccess
isSigned :: MemoryAccess -> Bool
$cisSigned :: MemoryAccess -> Bool
bitSize :: MemoryAccess -> Int
$cbitSize :: MemoryAccess -> Int
bitSizeMaybe :: MemoryAccess -> Maybe Int
$cbitSizeMaybe :: MemoryAccess -> Maybe Int
testBit :: MemoryAccess -> Int -> Bool
$ctestBit :: MemoryAccess -> Int -> Bool
complementBit :: MemoryAccess -> Int -> MemoryAccess
$ccomplementBit :: MemoryAccess -> Int -> MemoryAccess
clearBit :: MemoryAccess -> Int -> MemoryAccess
$cclearBit :: MemoryAccess -> Int -> MemoryAccess
setBit :: MemoryAccess -> Int -> MemoryAccess
$csetBit :: MemoryAccess -> Int -> MemoryAccess
bit :: Int -> MemoryAccess
$cbit :: Int -> MemoryAccess
zeroBits :: MemoryAccess
$czeroBits :: MemoryAccess
rotate :: MemoryAccess -> Int -> MemoryAccess
$crotate :: MemoryAccess -> Int -> MemoryAccess
shift :: MemoryAccess -> Int -> MemoryAccess
$cshift :: MemoryAccess -> Int -> MemoryAccess
complement :: MemoryAccess -> MemoryAccess
$ccomplement :: MemoryAccess -> MemoryAccess
xor :: MemoryAccess -> MemoryAccess -> MemoryAccess
$cxor :: MemoryAccess -> MemoryAccess -> MemoryAccess
.|. :: MemoryAccess -> MemoryAccess -> MemoryAccess
$c.|. :: MemoryAccess -> MemoryAccess -> MemoryAccess
.&. :: MemoryAccess -> MemoryAccess -> MemoryAccess
$c.&. :: MemoryAccess -> MemoryAccess -> MemoryAccess
Bits)

pattern Volatile :: MemoryAccess
pattern $bVolatile :: MemoryAccess
$mVolatile :: forall {r}. MemoryAccess -> ((# #) -> r) -> ((# #) -> r) -> r
Volatile = MemoryAccess 0x1

pattern Aligned :: MemoryAccess
pattern $bAligned :: MemoryAccess
$mAligned :: forall {r}. MemoryAccess -> ((# #) -> r) -> ((# #) -> r) -> r
Aligned = MemoryAccess 0x2

pattern Nontemporal :: MemoryAccess
pattern $bNontemporal :: MemoryAccess
$mNontemporal :: forall {r}. MemoryAccess -> ((# #) -> r) -> ((# #) -> r) -> r
Nontemporal = MemoryAccess 0x4

pattern MakePointerAvailable :: MemoryAccess
pattern $bMakePointerAvailable :: MemoryAccess
$mMakePointerAvailable :: forall {r}. MemoryAccess -> ((# #) -> r) -> ((# #) -> r) -> r
MakePointerAvailable = MemoryAccess 0x8

pattern MakePointerAvailableKHR :: MemoryAccess
pattern $bMakePointerAvailableKHR :: MemoryAccess
$mMakePointerAvailableKHR :: forall {r}. MemoryAccess -> ((# #) -> r) -> ((# #) -> r) -> r
MakePointerAvailableKHR = MemoryAccess 0x8

pattern MakePointerVisible :: MemoryAccess
pattern $bMakePointerVisible :: MemoryAccess
$mMakePointerVisible :: forall {r}. MemoryAccess -> ((# #) -> r) -> ((# #) -> r) -> r
MakePointerVisible = MemoryAccess 0x10

pattern MakePointerVisibleKHR :: MemoryAccess
pattern $bMakePointerVisibleKHR :: MemoryAccess
$mMakePointerVisibleKHR :: forall {r}. MemoryAccess -> ((# #) -> r) -> ((# #) -> r) -> r
MakePointerVisibleKHR = MemoryAccess 0x10

pattern NonPrivatePointer :: MemoryAccess
pattern $bNonPrivatePointer :: MemoryAccess
$mNonPrivatePointer :: forall {r}. MemoryAccess -> ((# #) -> r) -> ((# #) -> r) -> r
NonPrivatePointer = MemoryAccess 0x20

pattern NonPrivatePointerKHR :: MemoryAccess
pattern $bNonPrivatePointerKHR :: MemoryAccess
$mNonPrivatePointerKHR :: forall {r}. MemoryAccess -> ((# #) -> r) -> ((# #) -> r) -> r
NonPrivatePointerKHR = MemoryAccess 0x20

pattern AliasScopeINTELMask :: MemoryAccess
pattern $bAliasScopeINTELMask :: MemoryAccess
$mAliasScopeINTELMask :: forall {r}. MemoryAccess -> ((# #) -> r) -> ((# #) -> r) -> r
AliasScopeINTELMask = MemoryAccess 0x10000

pattern NoAliasINTELMask :: MemoryAccess
pattern $bNoAliasINTELMask :: MemoryAccess
$mNoAliasINTELMask :: forall {r}. MemoryAccess -> ((# #) -> r) -> ((# #) -> r) -> r
NoAliasINTELMask = MemoryAccess 0x20000

toName :: IsString a => MemoryAccess -> a
toName :: forall a. IsString a => MemoryAccess -> a
toName MemoryAccess
x = case MemoryAccess
x of
  MemoryAccess
Volatile -> a
"Volatile"
  MemoryAccess
Aligned -> a
"Aligned"
  MemoryAccess
Nontemporal -> a
"Nontemporal"
  MemoryAccess
MakePointerAvailable -> a
"MakePointerAvailable"
  MemoryAccess
MakePointerAvailableKHR -> a
"MakePointerAvailableKHR"
  MemoryAccess
MakePointerVisible -> a
"MakePointerVisible"
  MemoryAccess
MakePointerVisibleKHR -> a
"MakePointerVisibleKHR"
  MemoryAccess
NonPrivatePointer -> a
"NonPrivatePointer"
  MemoryAccess
NonPrivatePointerKHR -> a
"NonPrivatePointerKHR"
  MemoryAccess
AliasScopeINTELMask -> a
"AliasScopeINTELMask"
  MemoryAccess
NoAliasINTELMask -> a
"NoAliasINTELMask"
  MemoryAccess
unknown -> forall a. IsString a => [Char] -> a
fromString forall a b. (a -> b) -> a -> b
$ [Char]
"MemoryAccess " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show MemoryAccess
unknown

instance Show MemoryAccess where
  show :: MemoryAccess -> [Char]
show = forall a. IsString a => MemoryAccess -> a
toName

fromName :: (IsString a, Eq a) => a -> Maybe MemoryAccess
fromName :: forall a. (IsString a, Eq a) => a -> Maybe MemoryAccess
fromName a
x = case a
x of
  a
"Volatile" -> forall a. a -> Maybe a
Just MemoryAccess
Volatile
  a
"Aligned" -> forall a. a -> Maybe a
Just MemoryAccess
Aligned
  a
"Nontemporal" -> forall a. a -> Maybe a
Just MemoryAccess
Nontemporal
  a
"MakePointerAvailable" -> forall a. a -> Maybe a
Just MemoryAccess
MakePointerAvailable
  a
"MakePointerAvailableKHR" -> forall a. a -> Maybe a
Just MemoryAccess
MakePointerAvailableKHR
  a
"MakePointerVisible" -> forall a. a -> Maybe a
Just MemoryAccess
MakePointerVisible
  a
"MakePointerVisibleKHR" -> forall a. a -> Maybe a
Just MemoryAccess
MakePointerVisibleKHR
  a
"NonPrivatePointer" -> forall a. a -> Maybe a
Just MemoryAccess
NonPrivatePointer
  a
"NonPrivatePointerKHR" -> forall a. a -> Maybe a
Just MemoryAccess
NonPrivatePointerKHR
  a
"AliasScopeINTELMask" -> forall a. a -> Maybe a
Just MemoryAccess
AliasScopeINTELMask
  a
"NoAliasINTELMask" -> forall a. a -> Maybe a
Just MemoryAccess
NoAliasINTELMask
  a
_unknown -> forall a. Maybe a
Nothing

instance Read MemoryAccess where
  readPrec :: ReadPrec MemoryAccess
readPrec = forall a. ReadPrec a -> ReadPrec a
Read.parens do
    Lex.Ident [Char]
s <- ReadPrec Lexeme
Read.lexP
    forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall a. ReadPrec a
pfail forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. (IsString a, Eq a) => a -> Maybe MemoryAccess
fromName [Char]
s