{-# LINE 1 "src/KB/Text/Shape/FFI/Flags.hsc" #-}
module KB.Text.Shape.FFI.Flags
  ( module KB.Text.Shape.FFI.Flags
  -- , module RE
  ) where

import Foreign

-- import KB.Text.Shape.FFI.Flags.Foo as RE



-- * Flags

-- ** BreakFlags

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

instance Semigroup BreakFlags where
  {-# INLINE (<>) #-}
  <> :: BreakFlags -> BreakFlags -> BreakFlags
(<>) = BreakFlags -> BreakFlags -> BreakFlags
forall a. Bits a => a -> a -> a
(.|.)

instance Monoid BreakFlags where
  {-# INLINE mempty #-}
  mempty :: BreakFlags
mempty = Word32 -> BreakFlags
BreakFlags Word32
0

instance Show BreakFlags where
  showsPrec :: Int -> BreakFlags -> ShowS
showsPrec = [(BreakFlags, String)]
-> String -> (BreakFlags -> Word32) -> Int -> BreakFlags -> ShowS
forall a x.
(Bits a, Num x, Eq x, Show x) =>
[(a, String)] -> String -> (a -> x) -> Int -> a -> ShowS
showsFlags [(BreakFlags, String)]
breakBits String
"BreakFlags" \(BreakFlags Word32
i) -> Word32
i

breakBits :: [(BreakFlags, String)]
breakBits :: [(BreakFlags, String)]
breakBits =
  [ (BreakFlags
BREAK_FLAG_DIRECTION, String
"BREAK_FLAG_DIRECTION")
  , (BreakFlags
BREAK_FLAG_SCRIPT, String
"BREAK_FLAG_SCRIPT")
  , (BreakFlags
BREAK_FLAG_GRAPHEME, String
"BREAK_FLAG_GRAPHEME")
  , (BreakFlags
BREAK_FLAG_WORD, String
"BREAK_FLAG_WORD")
  , (BreakFlags
BREAK_FLAG_LINE_SOFT, String
"BREAK_FLAG_LINE_SOFT")
  , (BreakFlags
BREAK_FLAG_LINE_HARD, String
"BREAK_FLAG_LINE_HARD")
  , (BreakFlags
BREAK_FLAG_MANUAL, String
"BREAK_FLAG_MANUAL")
  , (BreakFlags
BREAK_FLAG_PARAGRAPH_DIRECTION, String
"BREAK_FLAG_PARAGRAPH_DIRECTION")
  ]

pattern BREAK_FLAG_DIRECTION :: BreakFlags
pattern $mBREAK_FLAG_DIRECTION :: forall {r}. BreakFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bBREAK_FLAG_DIRECTION :: BreakFlags
BREAK_FLAG_DIRECTION = BreakFlags (1)
{-# LINE 45 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern BREAK_FLAG_SCRIPT :: BreakFlags
pattern $mBREAK_FLAG_SCRIPT :: forall {r}. BreakFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bBREAK_FLAG_SCRIPT :: BreakFlags
BREAK_FLAG_SCRIPT = BreakFlags (2)
{-# LINE 48 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern BREAK_FLAG_GRAPHEME :: BreakFlags
pattern $mBREAK_FLAG_GRAPHEME :: forall {r}. BreakFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bBREAK_FLAG_GRAPHEME :: BreakFlags
BREAK_FLAG_GRAPHEME = BreakFlags (4)
{-# LINE 51 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern BREAK_FLAG_WORD :: BreakFlags
pattern $mBREAK_FLAG_WORD :: forall {r}. BreakFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bBREAK_FLAG_WORD :: BreakFlags
BREAK_FLAG_WORD = BreakFlags (8)
{-# LINE 54 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern BREAK_FLAG_LINE_SOFT :: BreakFlags
pattern $mBREAK_FLAG_LINE_SOFT :: forall {r}. BreakFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bBREAK_FLAG_LINE_SOFT :: BreakFlags
BREAK_FLAG_LINE_SOFT = BreakFlags (16)
{-# LINE 57 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern BREAK_FLAG_LINE_HARD :: BreakFlags
pattern $mBREAK_FLAG_LINE_HARD :: forall {r}. BreakFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bBREAK_FLAG_LINE_HARD :: BreakFlags
BREAK_FLAG_LINE_HARD = BreakFlags (32)
{-# LINE 60 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern BREAK_FLAG_MANUAL :: BreakFlags
pattern $mBREAK_FLAG_MANUAL :: forall {r}. BreakFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bBREAK_FLAG_MANUAL :: BreakFlags
BREAK_FLAG_MANUAL = BreakFlags (64)
{-# LINE 63 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern BREAK_FLAG_PARAGRAPH_DIRECTION :: BreakFlags
pattern $mBREAK_FLAG_PARAGRAPH_DIRECTION :: forall {r}. BreakFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bBREAK_FLAG_PARAGRAPH_DIRECTION :: BreakFlags
BREAK_FLAG_PARAGRAPH_DIRECTION = BreakFlags (128)
{-# LINE 66 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

-- | `BREAK_FLAG_LINE_SOFT` | `BREAK_FLAG_LINE_HARD`
pattern BREAK_FLAG_LINE :: BreakFlags
pattern $mBREAK_FLAG_LINE :: forall {r}. BreakFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bBREAK_FLAG_LINE :: BreakFlags
BREAK_FLAG_LINE = BreakFlags (48)
{-# LINE 70 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

-- | `BREAK_FLAG_DIRECTION` | `BREAK_FLAG_SCRIPT` | `BREAK_FLAG_GRAPHEME` | `BREAK_FLAG_WORD` | `BREAK_FLAG_LINE_SOFT` | `BREAK_FLAG_LINE_HARD`.
pattern BREAK_FLAG_ANY :: BreakFlags
pattern $mBREAK_FLAG_ANY :: forall {r}. BreakFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bBREAK_FLAG_ANY :: BreakFlags
BREAK_FLAG_ANY = BreakFlags (63)
{-# LINE 74 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

-- ** BreakStateFlags

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

instance Semigroup BreakStateFlags where
  {-# INLINE (<>) #-}
  <> :: BreakStateFlags -> BreakStateFlags -> BreakStateFlags
(<>) = BreakStateFlags -> BreakStateFlags -> BreakStateFlags
forall a. Bits a => a -> a -> a
(.|.)

instance Monoid BreakStateFlags where
  {-# INLINE mempty #-}
  mempty :: BreakStateFlags
mempty = Word32 -> BreakStateFlags
BreakStateFlags Word32
0

instance Show BreakStateFlags where
  showsPrec :: Int -> BreakStateFlags -> ShowS
showsPrec = [(BreakStateFlags, String)]
-> String
-> (BreakStateFlags -> Word32)
-> Int
-> BreakStateFlags
-> ShowS
forall a x.
(Bits a, Num x, Eq x, Show x) =>
[(a, String)] -> String -> (a -> x) -> Int -> a -> ShowS
showsFlags [(BreakStateFlags, String)]
breakStateBits String
"BreakStateFlags" \(BreakStateFlags Word32
i) -> Word32
i

breakStateBits :: [(BreakStateFlags, String)]
breakStateBits :: [(BreakStateFlags, String)]
breakStateBits =
  [ (BreakStateFlags
BREAK_STATE_FLAG_STARTED, String
"BREAK_STATE_FLAG_STARTED")
  , (BreakStateFlags
BREAK_STATE_FLAG_END, String
"BREAK_STATE_FLAG_END")
  , (BreakStateFlags
BREAK_STATE_FLAG_SAW_R_AFTER_L, String
"BREAK_STATE_FLAG_SAW_R_AFTER_L")
  , (BreakStateFlags
BREAK_STATE_FLAG_SAW_AL_AFTER_LR, String
"BREAK_STATE_FLAG_SAW_AL_AFTER_LR")
  , (BreakStateFlags
BREAK_STATE_FLAG_LAST_WAS_BRACKET, String
"BREAK_STATE_FLAG_LAST_WAS_BRACKET")
  ]

pattern BREAK_STATE_FLAG_STARTED :: BreakStateFlags
pattern $mBREAK_STATE_FLAG_STARTED :: forall {r}. BreakStateFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bBREAK_STATE_FLAG_STARTED :: BreakStateFlags
BREAK_STATE_FLAG_STARTED = BreakStateFlags (1)
{-# LINE 103 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern BREAK_STATE_FLAG_END :: BreakStateFlags
pattern $mBREAK_STATE_FLAG_END :: forall {r}. BreakStateFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bBREAK_STATE_FLAG_END :: BreakStateFlags
BREAK_STATE_FLAG_END = BreakStateFlags (2)
{-# LINE 106 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

-- Bidirectional flags

pattern BREAK_STATE_FLAG_SAW_R_AFTER_L :: BreakStateFlags
pattern $mBREAK_STATE_FLAG_SAW_R_AFTER_L :: forall {r}. BreakStateFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bBREAK_STATE_FLAG_SAW_R_AFTER_L :: BreakStateFlags
BREAK_STATE_FLAG_SAW_R_AFTER_L = BreakStateFlags (8)
{-# LINE 111 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern BREAK_STATE_FLAG_SAW_AL_AFTER_LR :: BreakStateFlags
pattern $mBREAK_STATE_FLAG_SAW_AL_AFTER_LR :: forall {r}. BreakStateFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bBREAK_STATE_FLAG_SAW_AL_AFTER_LR :: BreakStateFlags
BREAK_STATE_FLAG_SAW_AL_AFTER_LR = BreakStateFlags (16)
{-# LINE 114 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern BREAK_STATE_FLAG_LAST_WAS_BRACKET :: BreakStateFlags
pattern $mBREAK_STATE_FLAG_LAST_WAS_BRACKET :: forall {r}. BreakStateFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bBREAK_STATE_FLAG_LAST_WAS_BRACKET :: BreakStateFlags
BREAK_STATE_FLAG_LAST_WAS_BRACKET = BreakStateFlags (32)
{-# LINE 117 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

-- ** BreakConfigFlags

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

instance Semigroup BreakConfigFlags where
  {-# INLINE (<>) #-}
  <> :: BreakConfigFlags -> BreakConfigFlags -> BreakConfigFlags
(<>) = BreakConfigFlags -> BreakConfigFlags -> BreakConfigFlags
forall a. Bits a => a -> a -> a
(.|.)

instance Monoid BreakConfigFlags where
  {-# INLINE mempty #-}
  mempty :: BreakConfigFlags
mempty = Word32 -> BreakConfigFlags
BreakConfigFlags Word32
0

instance Show BreakConfigFlags where
  showsPrec :: Int -> BreakConfigFlags -> ShowS
showsPrec = [(BreakConfigFlags, String)]
-> String
-> (BreakConfigFlags -> Word32)
-> Int
-> BreakConfigFlags
-> ShowS
forall a x.
(Bits a, Num x, Eq x, Show x) =>
[(a, String)] -> String -> (a -> x) -> Int -> a -> ShowS
showsFlags [(BreakConfigFlags, String)]
breakConfigBits String
"BreakConfigFlags" \(BreakConfigFlags Word32
i) -> Word32
i

breakConfigBits :: [(BreakConfigFlags, String)]
breakConfigBits :: [(BreakConfigFlags, String)]
breakConfigBits =
  [ (BreakConfigFlags
BREAK_CONFIG_FLAG_END_OF_TEXT_GENERATES_HARD_LINE_BREAK, String
"BREAK_CONFIG_FLAG_END_OF_TEXT_GENERATES_HARD_LINE_BREAK")
  ]

pattern BREAK_CONFIG_FLAG_END_OF_TEXT_GENERATES_HARD_LINE_BREAK :: BreakConfigFlags
pattern $mBREAK_CONFIG_FLAG_END_OF_TEXT_GENERATES_HARD_LINE_BREAK :: forall {r}. BreakConfigFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bBREAK_CONFIG_FLAG_END_OF_TEXT_GENERATES_HARD_LINE_BREAK :: BreakConfigFlags
BREAK_CONFIG_FLAG_END_OF_TEXT_GENERATES_HARD_LINE_BREAK = BreakConfigFlags (1)
{-# LINE 142 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

-- ** FontStyleFlags

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

instance Semigroup FontStyleFlags where
  {-# INLINE (<>) #-}
  <> :: FontStyleFlags -> FontStyleFlags -> FontStyleFlags
(<>) = FontStyleFlags -> FontStyleFlags -> FontStyleFlags
forall a. Bits a => a -> a -> a
(.|.)

instance Monoid FontStyleFlags where
  {-# INLINE mempty #-}
  mempty :: FontStyleFlags
mempty = Word32 -> FontStyleFlags
FontStyleFlags Word32
0

instance Show FontStyleFlags where
  showsPrec :: Int -> FontStyleFlags -> ShowS
showsPrec = [(FontStyleFlags, String)]
-> String
-> (FontStyleFlags -> Word32)
-> Int
-> FontStyleFlags
-> ShowS
forall a x.
(Bits a, Num x, Eq x, Show x) =>
[(a, String)] -> String -> (a -> x) -> Int -> a -> ShowS
showsFlags [(FontStyleFlags, String)]
fontStyleBits String
"FontStyleFlags" \(FontStyleFlags Word32
i) -> Word32
i

fontStyleBits :: [(FontStyleFlags, String)]
fontStyleBits :: [(FontStyleFlags, String)]
fontStyleBits =
  [ (FontStyleFlags
FONT_STYLE_FLAG_REGULAR, String
"FONT_STYLE_FLAG_REGULAR")
  , (FontStyleFlags
FONT_STYLE_FLAG_ITALIC, String
"FONT_STYLE_FLAG_ITALIC")
  , (FontStyleFlags
FONT_STYLE_FLAG_BOLD, String
"FONT_STYLE_FLAG_BOLD")
  ]

pattern FONT_STYLE_FLAG_REGULAR :: FontStyleFlags
pattern $mFONT_STYLE_FLAG_REGULAR :: forall {r}. FontStyleFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bFONT_STYLE_FLAG_REGULAR :: FontStyleFlags
FONT_STYLE_FLAG_REGULAR = FontStyleFlags (1)
{-# LINE 169 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern FONT_STYLE_FLAG_ITALIC :: FontStyleFlags
pattern $mFONT_STYLE_FLAG_ITALIC :: forall {r}. FontStyleFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bFONT_STYLE_FLAG_ITALIC :: FontStyleFlags
FONT_STYLE_FLAG_ITALIC = FontStyleFlags (2)
{-# LINE 172 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern FONT_STYLE_FLAG_BOLD :: FontStyleFlags
pattern $mFONT_STYLE_FLAG_BOLD :: forall {r}. FontStyleFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bFONT_STYLE_FLAG_BOLD :: FontStyleFlags
FONT_STYLE_FLAG_BOLD = FontStyleFlags (4)
{-# LINE 175 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

-- ** GlyphFlags

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

instance Semigroup GlyphFlags where
  {-# INLINE (<>) #-}
  <> :: GlyphFlags -> GlyphFlags -> GlyphFlags
(<>) = GlyphFlags -> GlyphFlags -> GlyphFlags
forall a. Bits a => a -> a -> a
(.|.)

instance Monoid GlyphFlags where
  {-# INLINE mempty #-}
  mempty :: GlyphFlags
mempty = Word32 -> GlyphFlags
GlyphFlags Word32
0

instance Show GlyphFlags where
  showsPrec :: Int -> GlyphFlags -> ShowS
showsPrec = [(GlyphFlags, String)]
-> String -> (GlyphFlags -> Word32) -> Int -> GlyphFlags -> ShowS
forall a x.
(Bits a, Num x, Eq x, Show x) =>
[(a, String)] -> String -> (a -> x) -> Int -> a -> ShowS
showsFlags [(GlyphFlags, String)]
glyphBits String
"GlyphFlags" \(GlyphFlags Word32
i) -> Word32
i

glyphBits :: [(GlyphFlags, String)]
glyphBits :: [(GlyphFlags, String)]
glyphBits =
  [ (GlyphFlags
GLYPH_FLAG_ISOL, String
"GLYPH_FLAG_ISOL")
  , (GlyphFlags
GLYPH_FLAG_FINA, String
"GLYPH_FLAG_FINA")
  , (GlyphFlags
GLYPH_FLAG_FIN2, String
"GLYPH_FLAG_FIN2")
  , (GlyphFlags
GLYPH_FLAG_FIN3, String
"GLYPH_FLAG_FIN3")
  , (GlyphFlags
GLYPH_FLAG_MEDI, String
"GLYPH_FLAG_MEDI")
  , (GlyphFlags
GLYPH_FLAG_MED2, String
"GLYPH_FLAG_MED2")
  , (GlyphFlags
GLYPH_FLAG_INIT, String
"GLYPH_FLAG_INIT")
  , (GlyphFlags
GLYPH_FLAG_LJMO, String
"GLYPH_FLAG_LJMO")
  , (GlyphFlags
GLYPH_FLAG_VJMO, String
"GLYPH_FLAG_VJMO")
  , (GlyphFlags
GLYPH_FLAG_TJMO, String
"GLYPH_FLAG_TJMO")
  , (GlyphFlags
GLYPH_FLAG_RPHF, String
"GLYPH_FLAG_RPHF")
  , (GlyphFlags
GLYPH_FLAG_BLWF, String
"GLYPH_FLAG_BLWF")
  , (GlyphFlags
GLYPH_FLAG_HALF, String
"GLYPH_FLAG_HALF")
  , (GlyphFlags
GLYPH_FLAG_PSTF, String
"GLYPH_FLAG_PSTF")
  , (GlyphFlags
GLYPH_FLAG_ABVF, String
"GLYPH_FLAG_ABVF")
  , (GlyphFlags
GLYPH_FLAG_PREF, String
"GLYPH_FLAG_PREF")
  , (GlyphFlags
GLYPH_FLAG_NUMR, String
"GLYPH_FLAG_NUMR")
  , (GlyphFlags
GLYPH_FLAG_FRAC, String
"GLYPH_FLAG_FRAC")
  , (GlyphFlags
GLYPH_FLAG_DNOM, String
"GLYPH_FLAG_DNOM")
  , (GlyphFlags
GLYPH_FLAG_CFAR, String
"GLYPH_FLAG_CFAR")
  , (GlyphFlags
GLYPH_FLAG_DO_NOT_DECOMPOSE, String
"GLYPH_FLAG_DO_NOT_DECOMPOSE")
  , (GlyphFlags
GLYPH_FLAG_FIRST_IN_MULTIPLE_SUBSTITUTION, String
"GLYPH_FLAG_FIRST_IN_MULTIPLE_SUBSTITUTION")
  , (GlyphFlags
GLYPH_FLAG_NO_BREAK, String
"GLYPH_FLAG_NO_BREAK")
  , (GlyphFlags
GLYPH_FLAG_CURSIVE, String
"GLYPH_FLAG_CURSIVE")
  , (GlyphFlags
GLYPH_FLAG_GENERATED_BY_GSUB, String
"GLYPH_FLAG_GENERATED_BY_GSUB")
  , (GlyphFlags
GLYPH_FLAG_USED_IN_GPOS, String
"GLYPH_FLAG_USED_IN_GPOS")
  , (GlyphFlags
GLYPH_FLAG_STCH_ENDPOINT, String
"GLYPH_FLAG_STCH_ENDPOINT")
  , (GlyphFlags
GLYPH_FLAG_STCH_EXTENSION, String
"GLYPH_FLAG_STCH_EXTENSION")
  , (GlyphFlags
GLYPH_FLAG_LIGATURE, String
"GLYPH_FLAG_LIGATURE")
  , (GlyphFlags
GLYPH_FLAG_MULTIPLE_SUBSTITUTION, String
"GLYPH_FLAG_MULTIPLE_SUBSTITUTION")
  ]

pattern GLYPH_FLAG_ISOL :: GlyphFlags
pattern $mGLYPH_FLAG_ISOL :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_ISOL :: GlyphFlags
GLYPH_FLAG_ISOL = GlyphFlags (1)
{-# LINE 229 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_FINA :: GlyphFlags
pattern $mGLYPH_FLAG_FINA :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_FINA :: GlyphFlags
GLYPH_FLAG_FINA = GlyphFlags (2)
{-# LINE 232 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_FIN2 :: GlyphFlags
pattern $mGLYPH_FLAG_FIN2 :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_FIN2 :: GlyphFlags
GLYPH_FLAG_FIN2 = GlyphFlags (4)
{-# LINE 235 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_FIN3 :: GlyphFlags
pattern $mGLYPH_FLAG_FIN3 :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_FIN3 :: GlyphFlags
GLYPH_FLAG_FIN3 = GlyphFlags (8)
{-# LINE 238 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_MEDI :: GlyphFlags
pattern $mGLYPH_FLAG_MEDI :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_MEDI :: GlyphFlags
GLYPH_FLAG_MEDI = GlyphFlags (16)
{-# LINE 241 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_MED2 :: GlyphFlags
pattern $mGLYPH_FLAG_MED2 :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_MED2 :: GlyphFlags
GLYPH_FLAG_MED2 = GlyphFlags (32)
{-# LINE 244 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_INIT :: GlyphFlags
pattern $mGLYPH_FLAG_INIT :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_INIT :: GlyphFlags
GLYPH_FLAG_INIT = GlyphFlags (64)
{-# LINE 247 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_LJMO :: GlyphFlags
pattern $mGLYPH_FLAG_LJMO :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_LJMO :: GlyphFlags
GLYPH_FLAG_LJMO = GlyphFlags (128)
{-# LINE 250 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_VJMO :: GlyphFlags
pattern $mGLYPH_FLAG_VJMO :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_VJMO :: GlyphFlags
GLYPH_FLAG_VJMO = GlyphFlags (256)
{-# LINE 253 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_TJMO :: GlyphFlags
pattern $mGLYPH_FLAG_TJMO :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_TJMO :: GlyphFlags
GLYPH_FLAG_TJMO = GlyphFlags (512)
{-# LINE 256 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_RPHF :: GlyphFlags
pattern $mGLYPH_FLAG_RPHF :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_RPHF :: GlyphFlags
GLYPH_FLAG_RPHF = GlyphFlags (1024)
{-# LINE 259 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_BLWF :: GlyphFlags
pattern $mGLYPH_FLAG_BLWF :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_BLWF :: GlyphFlags
GLYPH_FLAG_BLWF = GlyphFlags (2048)
{-# LINE 262 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_HALF :: GlyphFlags
pattern $mGLYPH_FLAG_HALF :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_HALF :: GlyphFlags
GLYPH_FLAG_HALF = GlyphFlags (4096)
{-# LINE 265 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_PSTF :: GlyphFlags
pattern $mGLYPH_FLAG_PSTF :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_PSTF :: GlyphFlags
GLYPH_FLAG_PSTF = GlyphFlags (8192)
{-# LINE 268 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_ABVF :: GlyphFlags
pattern $mGLYPH_FLAG_ABVF :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_ABVF :: GlyphFlags
GLYPH_FLAG_ABVF = GlyphFlags (16384)
{-# LINE 271 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_PREF :: GlyphFlags
pattern $mGLYPH_FLAG_PREF :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_PREF :: GlyphFlags
GLYPH_FLAG_PREF = GlyphFlags (32768)
{-# LINE 274 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_NUMR :: GlyphFlags
pattern $mGLYPH_FLAG_NUMR :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_NUMR :: GlyphFlags
GLYPH_FLAG_NUMR = GlyphFlags (65536)
{-# LINE 277 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_FRAC :: GlyphFlags
pattern $mGLYPH_FLAG_FRAC :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_FRAC :: GlyphFlags
GLYPH_FLAG_FRAC = GlyphFlags (131072)
{-# LINE 280 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_DNOM :: GlyphFlags
pattern $mGLYPH_FLAG_DNOM :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_DNOM :: GlyphFlags
GLYPH_FLAG_DNOM = GlyphFlags (262144)
{-# LINE 283 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_CFAR :: GlyphFlags
pattern $mGLYPH_FLAG_CFAR :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_CFAR :: GlyphFlags
GLYPH_FLAG_CFAR = GlyphFlags (524288)
{-# LINE 286 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_DO_NOT_DECOMPOSE :: GlyphFlags
pattern $mGLYPH_FLAG_DO_NOT_DECOMPOSE :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_DO_NOT_DECOMPOSE :: GlyphFlags
GLYPH_FLAG_DO_NOT_DECOMPOSE = GlyphFlags (2097152)
{-# LINE 289 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_FIRST_IN_MULTIPLE_SUBSTITUTION :: GlyphFlags
pattern $mGLYPH_FLAG_FIRST_IN_MULTIPLE_SUBSTITUTION :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_FIRST_IN_MULTIPLE_SUBSTITUTION :: GlyphFlags
GLYPH_FLAG_FIRST_IN_MULTIPLE_SUBSTITUTION = GlyphFlags (4194304)
{-# LINE 292 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_NO_BREAK :: GlyphFlags
pattern $mGLYPH_FLAG_NO_BREAK :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_NO_BREAK :: GlyphFlags
GLYPH_FLAG_NO_BREAK = GlyphFlags (8388608)
{-# LINE 295 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_CURSIVE :: GlyphFlags
pattern $mGLYPH_FLAG_CURSIVE :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_CURSIVE :: GlyphFlags
GLYPH_FLAG_CURSIVE = GlyphFlags (16777216)
{-# LINE 298 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_GENERATED_BY_GSUB :: GlyphFlags
pattern $mGLYPH_FLAG_GENERATED_BY_GSUB :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_GENERATED_BY_GSUB :: GlyphFlags
GLYPH_FLAG_GENERATED_BY_GSUB = GlyphFlags (33554432)
{-# LINE 301 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_USED_IN_GPOS :: GlyphFlags
pattern $mGLYPH_FLAG_USED_IN_GPOS :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_USED_IN_GPOS :: GlyphFlags
GLYPH_FLAG_USED_IN_GPOS = GlyphFlags (67108864)
{-# LINE 304 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_STCH_ENDPOINT :: GlyphFlags
pattern $mGLYPH_FLAG_STCH_ENDPOINT :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_STCH_ENDPOINT :: GlyphFlags
GLYPH_FLAG_STCH_ENDPOINT = GlyphFlags (134217728)
{-# LINE 307 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_STCH_EXTENSION :: GlyphFlags
pattern $mGLYPH_FLAG_STCH_EXTENSION :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_STCH_EXTENSION :: GlyphFlags
GLYPH_FLAG_STCH_EXTENSION = GlyphFlags (268435456)
{-# LINE 310 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_LIGATURE :: GlyphFlags
pattern $mGLYPH_FLAG_LIGATURE :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_LIGATURE :: GlyphFlags
GLYPH_FLAG_LIGATURE = GlyphFlags (536870912)
{-# LINE 313 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

pattern GLYPH_FLAG_MULTIPLE_SUBSTITUTION :: GlyphFlags
pattern $mGLYPH_FLAG_MULTIPLE_SUBSTITUTION :: forall {r}. GlyphFlags -> ((# #) -> r) -> ((# #) -> r) -> r
$bGLYPH_FLAG_MULTIPLE_SUBSTITUTION :: GlyphFlags
GLYPH_FLAG_MULTIPLE_SUBSTITUTION = GlyphFlags (1073741824)
{-# LINE 316 "src/KB/Text/Shape/FFI/Flags.hsc" #-}

-- * Flag utils

{-# INLINE showsFlags #-}
showsFlags :: (Bits a, Num x, Eq x, Show x) => [(a, String)] -> String -> (a -> x) -> Int -> a -> ShowS
showsFlags :: forall a x.
(Bits a, Num x, Eq x, Show x) =>
[(a, String)] -> String -> (a -> x) -> Int -> a -> ShowS
showsFlags [(a, String)]
knownBits String
typeName a -> x
unwrap Int
d a
combined =
  case (x
remains, [(a, String)]
found) of
    (x
_, []) -> Bool -> ShowS -> ShowS
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) ShowS
showsRemains
    (x
0, [(a
_single, String
name)]) -> String -> ShowS
showString String
name
    (x
0, (a
_, String
initial) : [(a, String)]
rest) -> Bool -> ShowS -> ShowS
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ String -> ShowS
showString String
initial ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a, String) -> ShowS -> ShowS) -> ShowS -> [(a, String)] -> ShowS
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\(a
_flag, String
name) ShowS
next -> String -> ShowS
showString String
" <> " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
name ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
next) ShowS
forall a. a -> a
id [(a, String)]
rest
    (x
_, [(a, String)]
some) -> Bool -> ShowS -> ShowS
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ ((a, String) -> ShowS -> ShowS) -> ShowS -> [(a, String)] -> ShowS
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\(a
_flag, String
name) ShowS
next -> String -> ShowS
showString String
name ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
" <> " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
next) ShowS
showsRemains [(a, String)]
some
  where
    remains :: x
remains = a -> x
unwrap a
remains'
    (a
remains', [(a, String)]
found) = [(a, String)] -> a -> (a, [(a, String)])
forall a b. Bits a => [(a, b)] -> a -> (a, [(a, b)])
splitFlags [(a, String)]
knownBits a
combined
    showsRemains :: ShowS
showsRemains = String -> ShowS
showString String
typeName ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString (Char
' ' Char -> ShowS
forall a. a -> [a] -> [a]
: x -> String
forall a. Show a => a -> String
show x
remains)

splitFlags
  :: Bits a
  => [(a, b)] -- static part
  -> a -> (a, [(a, b)]) -- unpacker function
splitFlags :: forall a b. Bits a => [(a, b)] -> a -> (a, [(a, b)])
splitFlags [(a, b)]
flagBits a
combined = ((a, b) -> (a, [(a, b)]) -> (a, [(a, b)]))
-> (a, [(a, b)]) -> [(a, b)] -> (a, [(a, b)])
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (a, b) -> (a, [(a, b)]) -> (a, [(a, b)])
forall {a} {b}. Bits a => (a, b) -> (a, [(a, b)]) -> (a, [(a, b)])
testFst (a
combined, []) [(a, b)]
flagBits
  where
    testFst :: (a, b) -> (a, [(a, b)]) -> (a, [(a, b)])
testFst pair :: (a, b)
pair@(a
flagBit, b
_) acc :: (a, [(a, b)])
acc@(a
remaining, [(a, b)]
found)
      | a
remaining a -> a -> a
forall a. Bits a => a -> a -> a
.&. a
flagBit a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
flagBit = (a
remaining a -> a -> a
forall a. Bits a => a -> a -> a
.^. a
flagBit, (a, b)
pair (a, b) -> [(a, b)] -> [(a, b)]
forall a. a -> [a] -> [a]
: [(a, b)]
found)
      | Bool
otherwise = (a, [(a, b)])
acc