FlatParse.Common.Assorted

Compatibility

shortInteger :: Int# -> Integer

Char predicates

isDigit :: Char -> Bool

isDigit c = '0' <= c && c <= '9'

isLatinLetter :: Char -> Bool

isLatinLetter c = ('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z')

isGreekLetter :: Char -> Bool

isGreekLetter c = ('Α' <= c && c <= 'Ω') || ('α' <= c && c <= 'ω')

Other

packBytes :: [Word] -> Word

splitBytes :: [Word] -> ([Word], [Word])

UTF-8 conversions

charToBytes :: Char -> [Word]

strToBytes :: String -> [Word]

strToUtf8 :: String -> ByteString

Convert an UTF8-encoded String to a ByteString.

utf8ToStr :: ByteString -> String

Convert a ByteString to an UTF8-encoded String.

Shortcuts

derefChar8# :: Addr# -> Char#

Shortcut for 'indexCharOffAddr# addr# 0#'.

Boxed integer coercions

These functions should be no-ops. They correspond to the similarly-named GHC 9.4 primops which work on unboxed integers.

word16ToInt16 :: Word16 -> Int16

Coerce a Word16 to Int16.

word32ToInt32 :: Word32 -> Int32

Coerce a Word32 to Int32.

word64ToInt64 :: Word64 -> Int64

Coerce a Word64 to Int64.

Helpers

withPosInt# :: Int# -> r -> r

Assert for the given Int# that n >= 0.

Throws a runtime error if given a negative integer.

withIntUnwrap# :: (Int# -> r) -> Int -> r

Unwrap the Int# from an Int and apply it to the given function.

Bit manipulation

zbytel :: (FiniteBits a, Num a) => a -> Int

Index of leftmost null byte, or (number of bytes in type) if not present.

Adapted from Hacker's Delight 6-1. Useful in big-endian environments.

zbytel'intermediate :: (FiniteBits a, Num a) => a -> a

bit mangling, returns 0 for inputs without a null byte

Separating allows us to skip some index calculation if there was no null byte.

zbytel'toIdx :: (FiniteBits a, Num a) => a -> Int

bit mangling, turns intermediate value into an index

Separating allows us to skip some index calculation if there was no null byte.

zbyter :: (FiniteBits a, Num a) => a -> Int

Index of rightmost null byte, or (number of bytes in type) if not present

Adapted from Hacker's Delight 6-1. Useful in little-endian environments.

zbyter'intermediate :: (FiniteBits a, Num a) => a -> a

bit mangling, returns 0 for inputs without a null byte

Separating allows us to skip some index calculation if there was no null byte.

zbyter'toIdx :: (FiniteBits a, Num a) => a -> Int

bit mangling, turns intermediate value into an index

Separating allows us to skip some index calculation if there was no null byte.