| Safe Haskell | Ignore |
|---|---|
| Language | GHC2021 |
GHC.Utils.Binary
Synopsis
- data Bin (a :: k)
- data RelBin (a :: k) = RelBin {
- relBin_anchor :: !(Bin a)
- relBin_offset :: !(RelBinPtr a)
- getRelBin :: forall {k} (a :: k). ReadBinHandle -> IO (RelBin a)
- class Binary a where
- put_ :: WriteBinHandle -> a -> IO ()
- put :: WriteBinHandle -> a -> IO (Bin a)
- get :: ReadBinHandle -> IO a
- data ReadBinHandle
- data WriteBinHandle
- type SymbolTable a = Array Int a
- type Dictionary = SymbolTable FastString
- data BinData = BinData Int BinArray
- dataHandle :: BinData -> IO ReadBinHandle
- handleData :: WriteBinHandle -> IO BinData
- unsafeUnpackBinBuffer :: ByteString -> IO ReadBinHandle
- openBinMem :: Int -> IO WriteBinHandle
- seekBinWriter :: forall {k} (a :: k). WriteBinHandle -> Bin a -> IO ()
- seekBinReader :: forall {k} (a :: k). ReadBinHandle -> Bin a -> IO ()
- seekBinReaderRel :: forall {k} (a :: k). ReadBinHandle -> RelBin a -> IO ()
- tellBinReader :: forall {k} (a :: k). ReadBinHandle -> IO (Bin a)
- tellBinWriter :: forall {k} (a :: k). WriteBinHandle -> IO (Bin a)
- castBin :: forall {k1} {k2} (a :: k1) (b :: k2). Bin a -> Bin b
- withBinBuffer :: WriteBinHandle -> (ByteString -> IO a) -> IO a
- freezeWriteHandle :: WriteBinHandle -> IO ReadBinHandle
- shrinkBinBuffer :: WriteBinHandle -> IO ReadBinHandle
- thawReadHandle :: ReadBinHandle -> IO WriteBinHandle
- foldGet :: Binary a => Word -> ReadBinHandle -> b -> (Word -> a -> b -> IO b) -> IO b
- foldGet' :: Binary a => Word -> ReadBinHandle -> b -> (Word -> a -> b -> IO b) -> IO b
- writeBinMem :: WriteBinHandle -> FilePath -> IO ()
- readBinMem :: FilePath -> IO ReadBinHandle
- readBinMemN :: Int -> FilePath -> IO (Maybe ReadBinHandle)
- putAt :: Binary a => WriteBinHandle -> Bin a -> a -> IO ()
- getAt :: Binary a => ReadBinHandle -> Bin a -> IO a
- putAtRel :: forall {k} (a :: k). WriteBinHandle -> Bin (RelBinPtr a) -> Bin a -> IO ()
- forwardPut :: WriteBinHandle -> (b -> IO a) -> IO b -> IO (a, b)
- forwardPut_ :: WriteBinHandle -> (b -> IO a) -> IO b -> IO ()
- forwardGet :: ReadBinHandle -> IO a -> IO a
- forwardPutRel :: WriteBinHandle -> (b -> IO a) -> IO b -> IO (a, b)
- forwardPutRel_ :: WriteBinHandle -> (b -> IO a) -> IO b -> IO ()
- forwardGetRel :: ReadBinHandle -> IO a -> IO a
- putByte :: WriteBinHandle -> Word8 -> IO ()
- getByte :: ReadBinHandle -> IO Word8
- putByteString :: WriteBinHandle -> ByteString -> IO ()
- getByteString :: ReadBinHandle -> Int -> IO ByteString
- putULEB128 :: (Integral a, FiniteBits a) => WriteBinHandle -> a -> IO ()
- getULEB128 :: (Integral a, FiniteBits a) => ReadBinHandle -> IO a
- putSLEB128 :: (Integral a, Bits a) => WriteBinHandle -> a -> IO ()
- getSLEB128 :: (Show a, Integral a, FiniteBits a) => ReadBinHandle -> IO a
- newtype FixedLengthEncoding a = FixedLengthEncoding {
- unFixedLength :: a
- lazyGet :: Binary a => ReadBinHandle -> IO a
- lazyPut :: Binary a => WriteBinHandle -> a -> IO ()
- lazyGet' :: (ReadBinHandle -> IO a) -> ReadBinHandle -> IO a
- lazyPut' :: (WriteBinHandle -> a -> IO ()) -> WriteBinHandle -> a -> IO ()
- lazyGetMaybe :: Binary a => ReadBinHandle -> IO (Maybe a)
- lazyPutMaybe :: Binary a => WriteBinHandle -> Maybe a -> IO ()
- newtype EnumBinary a = EnumBinary {
- unEnumBinary :: a
- data ReaderUserData
- getReaderUserData :: ReadBinHandle -> ReaderUserData
- setReaderUserData :: ReadBinHandle -> ReaderUserData -> ReadBinHandle
- noReaderUserData :: ReaderUserData
- data WriterUserData
- getWriterUserData :: WriteBinHandle -> WriterUserData
- setWriterUserData :: WriteBinHandle -> WriterUserData -> WriteBinHandle
- noWriterUserData :: WriterUserData
- mkWriterUserData :: [SomeBinaryWriter] -> WriterUserData
- mkReaderUserData :: [SomeBinaryReader] -> ReaderUserData
- newReadState :: (ReadBinHandle -> IO Name) -> (ReadBinHandle -> IO FastString) -> ReaderUserData
- newWriteState :: (WriteBinHandle -> Name -> IO ()) -> (WriteBinHandle -> Name -> IO ()) -> (WriteBinHandle -> FastString -> IO ()) -> WriterUserData
- addReaderToUserData :: Typeable a => BinaryReader a -> ReadBinHandle -> ReadBinHandle
- addWriterToUserData :: Typeable a => BinaryWriter a -> WriteBinHandle -> WriteBinHandle
- findUserDataReader :: Typeable a => Proxy a -> ReadBinHandle -> BinaryReader a
- findUserDataWriter :: Typeable a => Proxy a -> WriteBinHandle -> BinaryWriter a
- newtype BinaryReader s = BinaryReader {
- getEntry :: ReadBinHandle -> IO s
- newtype BinaryWriter s = BinaryWriter {
- putEntry :: WriteBinHandle -> s -> IO ()
- mkWriter :: (WriteBinHandle -> s -> IO ()) -> BinaryWriter s
- mkReader :: (ReadBinHandle -> IO s) -> BinaryReader s
- data SomeBinaryReader
- data SomeBinaryWriter
- mkSomeBinaryReader :: Typeable a => BinaryReader a -> SomeBinaryReader
- mkSomeBinaryWriter :: Typeable a => BinaryWriter a -> SomeBinaryWriter
- data ReaderTable a = ReaderTable {
- getTable :: ReadBinHandle -> IO (SymbolTable a)
- mkReaderFromTable :: SymbolTable a -> BinaryReader a
- newtype WriterTable = WriterTable {
- putTable :: WriteBinHandle -> IO Int
- initFastStringReaderTable :: IO (ReaderTable FastString)
- initFastStringWriterTable :: IO (WriterTable, BinaryWriter FastString)
- putDictionary :: WriteBinHandle -> Int -> UniqFM FastString (Int, FastString) -> IO ()
- getDictionary :: ReadBinHandle -> IO Dictionary
- putFS :: WriteBinHandle -> FastString -> IO ()
- data FSTable = FSTable {
- fs_tab_next :: !FastMutInt
- fs_tab_map :: !(IORef (UniqFM FastString (Int, FastString)))
- getDictFastString :: Dictionary -> ReadBinHandle -> IO FastString
- putDictFastString :: FSTable -> WriteBinHandle -> FastString -> IO ()
- data GenericSymbolTable (m :: Type -> Type) = GenericSymbolTable {
- gen_symtab_next :: !FastMutInt
- gen_symtab_map :: !(IORef (m Int))
- gen_symtab_to_write :: !(IORef [Key m])
- initGenericSymbolTable :: forall (m :: Type -> Type). TrieMap m => IO (GenericSymbolTable m)
- getGenericSymtab :: Binary a => SymbolTable a -> ReadBinHandle -> IO a
- putGenericSymTab :: forall (m :: Type -> Type). TrieMap m => GenericSymbolTable m -> WriteBinHandle -> Key m -> IO ()
- getGenericSymbolTable :: (ReadBinHandle -> IO a) -> ReadBinHandle -> IO (SymbolTable a)
- putGenericSymbolTable :: forall (m :: Type -> Type). TrieMap m => GenericSymbolTable m -> (WriteBinHandle -> Key m -> IO ()) -> WriteBinHandle -> IO Int
- newtype BinSpan = BinSpan {}
- newtype BinSrcSpan = BinSrcSpan {}
- newtype BinLocated a = BinLocated {
- unBinLocated :: Located a
- newtype BindingName = BindingName {}
- simpleBindingNameWriter :: BinaryWriter Name -> BinaryWriter BindingName
- simpleBindingNameReader :: BinaryReader Name -> BinaryReader BindingName
- data FullBinData = FullBinData {
- fbd_readerUserData :: ReaderUserData
- fbd_off_s :: !Int
- fbd_off_e :: !Int
- fbd_size :: !Int
- fbd_buffer :: !BinArray
- freezeBinHandle :: forall {k} (a :: k). ReadBinHandle -> Bin a -> IO FullBinData
- thawBinHandle :: FullBinData -> IO ReadBinHandle
- putFullBinData :: WriteBinHandle -> FullBinData -> IO ()
- type BinArray = ForeignPtr Word8
- data FingerprintWithValue a = FingerprintWithValue !Fingerprint (Maybe a)
Documentation
Like a Bin but is used to store relative offset pointers.
Relative offset pointers store a relative location, but also contain an
anchor that allow to obtain the absolute offset.
Constructors
| RelBin | |
Fields
| |
getRelBin :: forall {k} (a :: k). ReadBinHandle -> IO (RelBin a) #
Do not rely on instance sizes for general types, we use variable length encoding for many of them.
Minimal complete definition
Methods
put_ :: WriteBinHandle -> a -> IO () #
put :: WriteBinHandle -> a -> IO (Bin a) #
get :: ReadBinHandle -> IO a #
Instances
data ReadBinHandle #
A read-only handle that can be used to deserialise binary data from a buffer.
The buffer is an unboxed binary array.
data WriteBinHandle #
A write-only handle that can be used to serialise binary data into a buffer.
The buffer is an unboxed binary array.
type SymbolTable a = Array Int a #
Symbols that are read from disk.
The SymbolTable index starts on '0'.
type Dictionary = SymbolTable FastString #
A SymbolTable of FastStrings.
dataHandle :: BinData -> IO ReadBinHandle #
handleData :: WriteBinHandle -> IO BinData #
openBinMem :: Int -> IO WriteBinHandle #
seekBinWriter :: forall {k} (a :: k). WriteBinHandle -> Bin a -> IO () #
seekBinReader :: forall {k} (a :: k). ReadBinHandle -> Bin a -> IO () #
SeekBin but without calling expandBin
seekBinReaderRel :: forall {k} (a :: k). ReadBinHandle -> RelBin a -> IO () #
tellBinReader :: forall {k} (a :: k). ReadBinHandle -> IO (Bin a) #
tellBinWriter :: forall {k} (a :: k). WriteBinHandle -> IO (Bin a) #
withBinBuffer :: WriteBinHandle -> (ByteString -> IO a) -> IO a #
Get access to the underlying buffer.
freezeWriteHandle :: WriteBinHandle -> IO ReadBinHandle #
Freeze the given WriteBinHandle and turn it into an equivalent ReadBinHandle.
The current offset of the WriteBinHandle is maintained in the new ReadBinHandle.
shrinkBinBuffer :: WriteBinHandle -> IO ReadBinHandle #
Copy the BinBuffer to a new BinBuffer which is exactly the right size. This performs a copy of the underlying buffer. The buffer may be truncated if the offset is not at the end of the written output.
UserData is also discarded during the copy You should just use this when translating a Put handle into a Get handle.
writeBinMem :: WriteBinHandle -> FilePath -> IO () #
readBinMem :: FilePath -> IO ReadBinHandle #
readBinMemN :: Int -> FilePath -> IO (Maybe ReadBinHandle) #
forwardPut :: WriteBinHandle -> (b -> IO a) -> IO b -> IO (a, b) #
forwardPut put_A put_B
forwardPut_ :: WriteBinHandle -> (b -> IO a) -> IO b -> IO () #
forwardGet :: ReadBinHandle -> IO a -> IO a #
Read a value stored using a forward reference
The forward reference is expected to be an absolute offset.
forwardPutRel :: WriteBinHandle -> (b -> IO a) -> IO b -> IO (a, b) #
forwardPutRel put_A put_B
This forward reference is a relative offset that allows us to skip over the
result of put_A.
forwardPutRel_ :: WriteBinHandle -> (b -> IO a) -> IO b -> IO () #
Like forwardGetRel, but discard the result.
forwardGetRel :: ReadBinHandle -> IO a -> IO a #
Read a value stored using a forward reference.
The forward reference is expected to be a relative offset.
For writing instances
putByte :: WriteBinHandle -> Word8 -> IO () #
getByte :: ReadBinHandle -> IO Word8 #
putByteString :: WriteBinHandle -> ByteString -> IO () #
Put a ByteString without its length (can't be read back without knowing the length!)
getByteString :: ReadBinHandle -> Int -> IO ByteString #
Get a ByteString whose length is known
Variable length encodings
putULEB128 :: (Integral a, FiniteBits a) => WriteBinHandle -> a -> IO () #
getULEB128 :: (Integral a, FiniteBits a) => ReadBinHandle -> IO a #
putSLEB128 :: (Integral a, Bits a) => WriteBinHandle -> a -> IO () #
getSLEB128 :: (Show a, Integral a, FiniteBits a) => ReadBinHandle -> IO a #
Fixed length encoding
newtype FixedLengthEncoding a #
Encode the argument in its full length. This is different from many default binary instances which make no guarantee about the actual encoding and might do things using variable length encoding.
Constructors
| FixedLengthEncoding | |
Fields
| |
Instances
Lazy Binary I/O
lazyGet :: Binary a => ReadBinHandle -> IO a #
lazyPut :: Binary a => WriteBinHandle -> a -> IO () #
lazyGet' :: (ReadBinHandle -> IO a) -> ReadBinHandle -> IO a #
lazyPut' :: (WriteBinHandle -> a -> IO ()) -> WriteBinHandle -> a -> IO () #
lazyGetMaybe :: Binary a => ReadBinHandle -> IO (Maybe a) #
Deserialize a value serialized by lazyPutMaybe.
lazyPutMaybe :: Binary a => WriteBinHandle -> Maybe a -> IO () #
Serialize the constructor strictly but lazily serialize a value inside a
Just.
This way we can check for the presence of a value without deserializing the value itself.
EnumBinary
newtype EnumBinary a #
Constructors
| EnumBinary | |
Fields
| |
Instances
| Enum a => Binary (EnumBinary a) # | |
Defined in GHC.Utils.Binary Methods put_ :: WriteBinHandle -> EnumBinary a -> IO () # put :: WriteBinHandle -> EnumBinary a -> IO (Bin (EnumBinary a)) # get :: ReadBinHandle -> IO (EnumBinary a) # | |
User data
data ReaderUserData #
UserData required to deserialise symbols for interface files.
See Note [Binary UserData]
data WriterUserData #
UserData required to serialise symbols for interface files.
See Note [Binary UserData]
Arguments
| :: (ReadBinHandle -> IO Name) | how to deserialize |
| -> (ReadBinHandle -> IO FastString) | |
| -> ReaderUserData |
Arguments
| :: (WriteBinHandle -> Name -> IO ()) | how to serialize non-binding |
| -> (WriteBinHandle -> Name -> IO ()) | how to serialize binding |
| -> (WriteBinHandle -> FastString -> IO ()) | |
| -> WriterUserData |
addReaderToUserData :: Typeable a => BinaryReader a -> ReadBinHandle -> ReadBinHandle #
Add SomeBinaryReader as a known binary decoder.
If a BinaryReader for the associated type already exists in ReaderUserData,
it is overwritten.
addWriterToUserData :: Typeable a => BinaryWriter a -> WriteBinHandle -> WriteBinHandle #
Add SomeBinaryWriter as a known binary encoder.
If a BinaryWriter for the associated type already exists in WriterUserData,
it is overwritten.
findUserDataReader :: Typeable a => Proxy a -> ReadBinHandle -> BinaryReader a #
Find the BinaryReader for the Binary instance for the type identified by 'Proxy a'.
If no BinaryReader has been configured before, this function will panic.
findUserDataWriter :: Typeable a => Proxy a -> WriteBinHandle -> BinaryWriter a #
Find the BinaryWriter for the Binary instance for the type identified by 'Proxy a'.
If no BinaryWriter has been configured before, this function will panic.
Binary Readers & Writers
newtype BinaryReader s #
Constructors
| BinaryReader | |
Fields
| |
Instances
| Functor BinaryReader # | |
Defined in GHC.Utils.Binary Methods fmap :: (a -> b) -> BinaryReader a -> BinaryReader b # (<$) :: a -> BinaryReader b -> BinaryReader a # | |
newtype BinaryWriter s #
Constructors
| BinaryWriter | |
Fields
| |
mkWriter :: (WriteBinHandle -> s -> IO ()) -> BinaryWriter s #
mkReader :: (ReadBinHandle -> IO s) -> BinaryReader s #
data SomeBinaryReader #
Existential for BinaryReader with a type witness.
data SomeBinaryWriter #
Existential for BinaryWriter with a type witness.
mkSomeBinaryReader :: Typeable a => BinaryReader a -> SomeBinaryReader #
mkSomeBinaryWriter :: Typeable a => BinaryWriter a -> SomeBinaryWriter #
Tables
data ReaderTable a #
A ReaderTable describes how to deserialise a table from disk,
and how to create a BinaryReader that looks up values in the deduplication table.
Constructors
| ReaderTable | |
Fields
| |
newtype WriterTable #
A WriterTable is an interface any deduplication table can implement to
describe how the table can be written to disk.
Constructors
| WriterTable | |
Fields
| |
String table ("dictionary")
putDictionary :: WriteBinHandle -> Int -> UniqFM FastString (Int, FastString) -> IO () #
getDictionary :: ReadBinHandle -> IO Dictionary #
putFS :: WriteBinHandle -> FastString -> IO () #
Constructors
| FSTable | |
Fields
| |
getDictFastString :: Dictionary -> ReadBinHandle -> IO FastString #
putDictFastString :: FSTable -> WriteBinHandle -> FastString -> IO () #
Generic deduplication table
data GenericSymbolTable (m :: Type -> Type) #
The GenericSymbolTable stores a mapping from already seen elements to an index.
If an element wasn't seen before, it is added to the mapping together with a fresh
index.
GenericSymbolTable is a variant of a BinSymbolTable that is polymorphic in the table implementation.
As such it can be used with any container that implements the TrieMap type class.
While GenericSymbolTable is similar to the BinSymbolTable, it supports storing tree-like
structures such as Type and IfaceType more efficiently.
Constructors
| GenericSymbolTable | |
Fields
| |
initGenericSymbolTable :: forall (m :: Type -> Type). TrieMap m => IO (GenericSymbolTable m) #
Initialise a GenericSymbolTable, initialising the index to '0'.
getGenericSymtab :: Binary a => SymbolTable a -> ReadBinHandle -> IO a #
Read a value from a SymbolTable.
putGenericSymTab :: forall (m :: Type -> Type). TrieMap m => GenericSymbolTable m -> WriteBinHandle -> Key m -> IO () #
Write an element 'Key m' to the given WriteBinHandle.
If the element was seen before, we simply write the index of that element to the
WriteBinHandle. If we haven't seen it before, we add the element to
the GenericSymbolTable, increment the index, and return this new index.
getGenericSymbolTable :: (ReadBinHandle -> IO a) -> ReadBinHandle -> IO (SymbolTable a) #
Read the elements of a GenericSymbolTable from disk into a SymbolTable.
putGenericSymbolTable :: forall (m :: Type -> Type). TrieMap m => GenericSymbolTable m -> (WriteBinHandle -> Key m -> IO ()) -> WriteBinHandle -> IO Int #
Serialise the GenericSymbolTable to disk.
Since GenericSymbolTable stores tree-like structures, such as IfaceType,
serialising an element can add new elements to the mapping.
Thus, putGenericSymbolTable first serialises all values, and then checks whether any
new elements have been discovered. If so, repeat the loop.
Newtype wrappers
Constructors
| BinSpan | |
Fields | |
newtype BinSrcSpan #
Constructors
| BinSrcSpan | |
Fields | |
Instances
| Binary BinSrcSpan # | |
Defined in GHC.Utils.Binary Methods put_ :: WriteBinHandle -> BinSrcSpan -> IO () # put :: WriteBinHandle -> BinSrcSpan -> IO (Bin BinSrcSpan) # get :: ReadBinHandle -> IO BinSrcSpan # | |
newtype BinLocated a #
Constructors
| BinLocated | |
Fields
| |
Instances
| Binary a => Binary (BinLocated a) # | |
Defined in GHC.Utils.Binary Methods put_ :: WriteBinHandle -> BinLocated a -> IO () # put :: WriteBinHandle -> BinLocated a -> IO (Bin (BinLocated a)) # get :: ReadBinHandle -> IO (BinLocated a) # | |
Newtypes for types that have canonically more than one valid encoding
newtype BindingName #
Newtype to serialise binding names differently to non-binding Name.
See Note [Binary UserData]
Constructors
| BindingName | |
Fields | |
Instances
| Eq BindingName # | |
Defined in GHC.Utils.Binary | |
data FullBinData #
FullBinData stores a slice to a BinArray.
It requires less memory than ReadBinHandle, and can be constructed from
a ReadBinHandle via freezeBinHandle and turned back into a
ReadBinHandle using thawBinHandle.
Additionally, the byte array slice can be put into a WriteBinHandle without extra
conversions via putFullBinData.
Constructors
| FullBinData | |
Fields
| |
Instances
| Eq FullBinData # | |
Defined in GHC.Utils.Binary | |
| Ord FullBinData # | |
Defined in GHC.Utils.Binary Methods compare :: FullBinData -> FullBinData -> Ordering # (<) :: FullBinData -> FullBinData -> Bool # (<=) :: FullBinData -> FullBinData -> Bool # (>) :: FullBinData -> FullBinData -> Bool # (>=) :: FullBinData -> FullBinData -> Bool # max :: FullBinData -> FullBinData -> FullBinData # min :: FullBinData -> FullBinData -> FullBinData # | |
freezeBinHandle :: forall {k} (a :: k). ReadBinHandle -> Bin a -> IO FullBinData #
Freeze a ReadBinHandle and a start index into a FullBinData.
FullBinData stores a slice starting from the 'Bin a' location to the current
offset of the ReadBinHandle.
thawBinHandle :: FullBinData -> IO ReadBinHandle #
Turn the FullBinData into a ReadBinHandle, setting the ReadBinHandle
offset to the start of the FullBinData and restore the ReaderUserData that was
obtained from freezeBinHandle.
putFullBinData :: WriteBinHandle -> FullBinData -> IO () #
Write the FullBinData slice into the WriteBinHandle.
type BinArray = ForeignPtr Word8 #
FingerprintWithValue
data FingerprintWithValue a #
A wrapper which allows us to store a fingerprint and optionally the value which was used to create the fingerprint.
Constructors
| FingerprintWithValue !Fingerprint (Maybe a) |
Instances
| Functor FingerprintWithValue # | |
Defined in GHC.Utils.Binary Methods fmap :: (a -> b) -> FingerprintWithValue a -> FingerprintWithValue b # (<$) :: a -> FingerprintWithValue b -> FingerprintWithValue a # | |
| NFData a => NFData (FingerprintWithValue a) # | |
Defined in GHC.Utils.Binary Methods rnf :: FingerprintWithValue a -> () # | |
| Binary a => Binary (FingerprintWithValue a) # | |
Defined in GHC.Utils.Binary Methods put_ :: WriteBinHandle -> FingerprintWithValue a -> IO () # put :: WriteBinHandle -> FingerprintWithValue a -> IO (Bin (FingerprintWithValue a)) # get :: ReadBinHandle -> IO (FingerprintWithValue a) # | |