carp-lang/Carp
1
1
Fork 0
mirror of https://github.com/carp-lang/Carp.git synced 2024-09-11 13:37:57 +03:00
Code Issues Projects Releases Wiki Activity
6fc0562028
Carp/core/Binary.carp

289 lines
11 KiB
Plaintext
Raw Normal View History

Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
(system-include "carp_binary.h")
Use StdInt types in binary conversion functions
2020-02-18 00:04:09 +03:00
(load "StdInt.carp")
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
Add safe variants of byte conversion functions I've also adopted a new naming strategy for these functions--the seq in byte-seq was redundant, so we now just name these bytes->intN-seq.
2020-02-18 19:41:29 +03:00
;; Helper functions for making working with Maybe easier
;; TODO: Replace all of these with a single type-generic
;; zip-n macro.
(defmodule Maybe
(defn zip [f a b]
(match a
(Maybe.Nothing) (Maybe.Nothing)
(Just x)
(match b
(Maybe.Nothing) (Maybe.Nothing)
(Just y) (Just (~f x y)))))
(defn zip4 [f a b c d]
(match a
(Maybe.Nothing) (Maybe.Nothing)
(Just x)
(match b
(Maybe.Nothing) (Maybe.Nothing)
(Just y)
(match c
(Maybe.Nothing) (Maybe.Nothing)
(Just z)
(match d
(Maybe.Nothing) (Maybe.Nothing)
(Just x2) (Just (~f x y z x2)))))))
(defn zip8 [f a b c d e a1 b1 c1]
(match a
(Maybe.Nothing) (Maybe.Nothing)
(Just x)
(match b
(Maybe.Nothing) (Maybe.Nothing)
(Just y)
(match c
(Maybe.Nothing) (Maybe.Nothing)
(Just z)
(match d
(Maybe.Nothing) (Maybe.Nothing)
(Just x2)
(match e
(Maybe.Nothing) (Maybe.Nothing)
(Just y2)
(match a1
(Maybe.Nothing) (Maybe.Nothing)
(Just z2)
(match b1
(Maybe.Nothing) (Maybe.Nothing)
(Just x3)
(match c1
(Maybe.Nothing) (Maybe.Nothing)
(Just y3) (Just (~f x y z x2 y2 z2 x3 y3)))))))))))
)
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
(defmodule Binary
Use partitions in byte-seq->int16-seq-unsafe This change brings the implementation of `byte-seq->int16-seq-unsafe` into parity with the implementations of its 32 and 64 bit brethren. I've also cleaned up some of my previous sloppiness: - Correct function names in doc and sig annotations. - Remove extra spaces before newlines.
2020-02-18 03:03:52 +03:00
(doc Order
"The type of byte orders.
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
LittleEndian designates the little endian ordering, and indicates the least
significant byte appears first in a given byte sequence.
BigEndian designates the big endian ordering, and indicates the most
significant byte occurs first in a given byte sequence.")
(deftype Order LittleEndian BigEndian)
Use StdInt types in binary conversion functions
2020-02-18 00:04:09 +03:00
(register to-int16 (λ [Byte Byte] Uint16))
(register to-int32 (λ [Byte Byte Byte Byte] Uint32))
(register to-int64 (λ [Byte Byte Byte Byte Byte Byte Byte Byte] Uint64))
Add UintN->Byte conversions Note that we do not need an unsafe variant of these conversions since they are simple projections to and from the Uint types.
2020-02-18 21:35:35 +03:00
(register int16-to-byte (λ [(Ref Uint16)] Byte))
(register int32-to-byte (λ [(Ref Uint32)] Byte))
(register int64-to-byte (λ [(Ref Uint64)] Byte))
Add a function for retrieving the system endianness The technique here feels a bit hacky, but it's the common way to do it. We exploit the fact that ints are 16bits and chars are 8bits to grab the first byte in a systems int representation, which is indicative of its endianness.
2020-02-17 23:38:55 +03:00
(register system-endianness-internal (λ [] Int))
Use partitions in byte-seq->int16-seq-unsafe This change brings the implementation of `byte-seq->int16-seq-unsafe` into parity with the implementations of its 32 and 64 bit brethren. I've also cleaned up some of my previous sloppiness: - Correct function names in doc and sig annotations. - Remove extra spaces before newlines.
2020-02-18 03:03:52 +03:00
(doc system-endianness
Use StdInt types in binary conversion functions
2020-02-18 00:04:09 +03:00
"Returns the endianness of the host system.")
Add a function for retrieving the system endianness The technique here feels a bit hacky, but it's the common way to do it. We exploit the fact that ints are 16bits and chars are 8bits to grab the first byte in a systems int representation, which is indicative of its endianness.
2020-02-17 23:38:55 +03:00
(sig system-endianness (λ [] Order))
Use partitions in byte-seq->int16-seq-unsafe This change brings the implementation of `byte-seq->int16-seq-unsafe` into parity with the implementations of its 32 and 64 bit brethren. I've also cleaned up some of my previous sloppiness: - Correct function names in doc and sig annotations. - Remove extra spaces before newlines.
2020-02-18 03:03:52 +03:00
(defn system-endianness []
Add a function for retrieving the system endianness The technique here feels a bit hacky, but it's the common way to do it. We exploit the fact that ints are 16bits and chars are 8bits to grab the first byte in a systems int representation, which is indicative of its endianness.
2020-02-17 23:38:55 +03:00
(if (= (system-endianness-internal) 1)
(Order.LittleEndian)
(Order.BigEndian)))
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
(doc bytes->int16-unsafe
Binary: Make names consistent. Update docs. Specifically, we now reference the explicit unsigned int types we return in the docs for each function, and I've dropped the term byte-seq in favor of bytes in all cases.
2020-02-18 19:50:24 +03:00
"Interprets the first two bytes in a byte sequence as an Uint16 value.
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
**This operation is unsafe.**")
Use StdInt types in binary conversion functions
2020-02-18 00:04:09 +03:00
(sig bytes->int16-unsafe (Fn [Order (Ref (Array Byte) a)] Uint16))
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
(defn bytes->int16-unsafe [order bs]
Use partitions in byte-seq->int16-seq-unsafe This change brings the implementation of `byte-seq->int16-seq-unsafe` into parity with the implementations of its 32 and 64 bit brethren. I've also cleaned up some of my previous sloppiness: - Correct function names in doc and sig annotations. - Remove extra spaces before newlines.
2020-02-18 03:03:52 +03:00
(match order
Use StdInt types in binary conversion functions
2020-02-18 00:04:09 +03:00
(Order.LittleEndian)
(to-int16 @(Array.unsafe-nth bs 0) @(Array.unsafe-nth bs 1))
(Order.BigEndian)
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
(to-int16 @(Array.unsafe-nth bs 1) @(Array.unsafe-nth bs 0))))
Add safe variants of byte conversion functions I've also adopted a new naming strategy for these functions--the seq in byte-seq was redundant, so we now just name these bytes->intN-seq.
2020-02-18 19:41:29 +03:00
(doc bytes->int16
Binary: Make names consistent. Update docs. Specifically, we now reference the explicit unsigned int types we return in the docs for each function, and I've dropped the term byte-seq in favor of bytes in all cases.
2020-02-18 19:50:24 +03:00
"Interprets the first two bytes in a byte sequence as an Uint16 value.
Add safe variants of byte conversion functions I've also adopted a new naming strategy for these functions--the seq in byte-seq was redundant, so we now just name these bytes->intN-seq.
2020-02-18 19:41:29 +03:00
If the first two bytes are inaccessible, or the given array contains less
than two bytes, returns Maybe.Nothing.")
(sig bytes->int16 (Fn [Order (Ref (Array Byte) a)] (Maybe Uint16)))
(defn bytes->int16 [order bytes]
(match order
(Order.LittleEndian)
(Maybe.zip &to-int16 (Array.nth bytes 0) (Array.nth bytes 1))
(Order.BigEndian)
(Maybe.zip &to-int16 (Array.nth bytes 1) (Array.nth bytes 0))))
Add UintN->Byte conversions Note that we do not need an unsafe variant of these conversions since they are simple projections to and from the Uint types.
2020-02-18 21:35:35 +03:00
(doc int16->bytes
"Converts a Uint16 to a sequence of bytes representing the value using the provided `order`")
(sig int16->bytes (Fn [Order Uint16] (Array Byte)))
(defn int16->bytes [order i]
(match order
(Order.LittleEndian)
(Array.copy-map &int16-to-byte &[i (Uint16.bit-shift-right i (Uint16.from-long 8l))])
(Order.BigEndian)
(Array.copy-map &int16-to-byte &[(Uint16.bit-shift-right i (Uint16.from-long 8l)) i])))
Group functions by int type
2020-02-18 21:50:07 +03:00
(doc bytes->int16-seq-unsafe
"Interprets a sequence of bytes as a sequence of Uint16 values.
**This operation is unsafe.**")
(sig bytes->int16-seq-unsafe (Fn [Order (Ref (Array Byte) a)] (Array Uint16)))
(defn bytes->int16-seq-unsafe [order bs]
(let [partitions (Array.partition bs 2)
f (fn [b] (bytes->int16-unsafe order b))]
(Array.copy-map &f &partitions)))
(doc bytes->int16-seq
"Interprets a sequence of bytes as a sequence of Uint16 values.
If a segment of bytes cannot be interpreted as an Uint16, returns Maybe.Nothing.")
(sig bytes->int16-seq (Fn [Order (Ref (Array Byte) a)] (Array (Maybe Uint16))))
(defn bytes->int16-seq [order bs]
(let [partitions (Array.partition bs 2)
f (fn [b] (bytes->int16 order b))]
(Array.copy-map &f &partitions)))
(doc int16-seq->bytes
"Converts an array of Uint16 values into byte sequences.")
(sig int16-seq->bytes (Fn [Order (Ref (Array Uint16) a)] (Array (Array Byte))))
(defn int16-seq->bytes [order is]
(let [f (fn [i] (int16->bytes order @i))]
(Array.copy-map &f is)))
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
(doc bytes->int32-unsafe
Binary: Make names consistent. Update docs. Specifically, we now reference the explicit unsigned int types we return in the docs for each function, and I've dropped the term byte-seq in favor of bytes in all cases.
2020-02-18 19:50:24 +03:00
"Interprets the first four bytes in a byte sequence as an Uint32 value.
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
**This operation is unsafe.**")
Use StdInt types in binary conversion functions
2020-02-18 00:04:09 +03:00
(sig bytes->int32-unsafe (Fn [Order (Ref (Array Byte))] Uint32))
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
(defn bytes->int32-unsafe [order bs]
Use partitions in byte-seq->int16-seq-unsafe This change brings the implementation of `byte-seq->int16-seq-unsafe` into parity with the implementations of its 32 and 64 bit brethren. I've also cleaned up some of my previous sloppiness: - Correct function names in doc and sig annotations. - Remove extra spaces before newlines.
2020-02-18 03:03:52 +03:00
(match order
(Order.LittleEndian)
(to-int32 @(Array.unsafe-nth bs 0) @(Array.unsafe-nth bs 1)
@(Array.unsafe-nth bs 2) @(Array.unsafe-nth bs 3))
(Order.BigEndian)
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
(to-int32 @(Array.unsafe-nth bs 3) @(Array.unsafe-nth bs 2)
@(Array.unsafe-nth bs 1) @(Array.unsafe-nth bs 0))))
Add safe variants of byte conversion functions I've also adopted a new naming strategy for these functions--the seq in byte-seq was redundant, so we now just name these bytes->intN-seq.
2020-02-18 19:41:29 +03:00
(doc bytes->int32
Binary: Make names consistent. Update docs. Specifically, we now reference the explicit unsigned int types we return in the docs for each function, and I've dropped the term byte-seq in favor of bytes in all cases.
2020-02-18 19:50:24 +03:00
"Interprets the first four bytes in a byte sequence as an Uint32 value.
Add safe variants of byte conversion functions I've also adopted a new naming strategy for these functions--the seq in byte-seq was redundant, so we now just name these bytes->intN-seq.
2020-02-18 19:41:29 +03:00
If the first four bytes are inaccessible, or the given array contains less
than four bytes, returns Maybe.Nothing.")
(sig bytes->int32 (Fn [Order (Ref (Array Byte))] (Maybe Uint32)))
(defn bytes->int32 [order bs]
(match order
(Order.LittleEndian)
(Maybe.zip4 &to-int32 (Array.nth bs 0) (Array.nth bs 1)
(Array.nth bs 2) (Array.nth bs 3))
(Order.BigEndian)
(Maybe.zip4 &to-int32 (Array.nth bs 3) (Array.nth bs 2)
(Array.nth bs 1) (Array.nth bs 0))))
Add UintN->Byte conversions Note that we do not need an unsafe variant of these conversions since they are simple projections to and from the Uint types.
2020-02-18 21:35:35 +03:00
(doc int32->bytes
"Converts a Uint32 to a sequence of bytes representing the value using the provided `order`")
(sig int32->bytes (Fn [Order Uint32] (Array Byte)))
(defn int32->bytes [order i]
(let [shift (fn [lng] (Uint32.bit-shift-right i (Uint32.from-long lng)))]
(match order
(Order.LittleEndian)
(Array.copy-map &int32-to-byte
&[i (shift 8l) (shift 16l) (shift 24l)])
(Order.BigEndian)
(Array.copy-map &int32-to-byte
&[(shift 24l) (shift 16l) (shift 8l) i]))))
Group functions by int type
2020-02-18 21:50:07 +03:00
(doc bytes->int32-seq-unsafe
"Interprets a sequence of bytes as a sequence of Uint32 values.
**This operation is unsafe.**")
(sig bytes->int32-seq-unsafe (Fn [Order (Ref (Array Byte) a)] (Array Uint32)))
(defn bytes->int32-seq-unsafe [order bs]
(let [partitions (Array.partition bs 4)
f (fn [b] (bytes->int32-unsafe order b))]
(Array.copy-map &f &partitions)))
(doc bytes->int32-seq
"Interprets a sequence of bytes as a sequence of Uint32 values.
If a segment of bytes cannot be interpreted as an Uint32, returns Maybe.Nothing.")
(sig bytes->int32-seq (Fn [Order (Ref (Array Byte) a)] (Array (Maybe Uint32))))
(defn bytes->int32-seq [order bs]
(let [partitions (Array.partition bs 4)
f (fn [b] (bytes->int32 order b))]
(Array.copy-map &f &partitions)))
(doc int32-seq->bytes
"Converts an array of Uint32 values into byte sequences.")
(sig int32-seq->bytes (Fn [Order (Ref (Array Uint32) a)] (Array (Array Byte))))
(defn int32-seq->bytes [order is]
(let [f (fn [i] (int32->bytes order @i))]
(Array.copy-map &f is)))
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
(doc bytes->int64-unsafe
Binary: Make names consistent. Update docs. Specifically, we now reference the explicit unsigned int types we return in the docs for each function, and I've dropped the term byte-seq in favor of bytes in all cases.
2020-02-18 19:50:24 +03:00
"Interprets the first eight bytes in a byte sequence as an Uint64 value.
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
**This operation is unsafe.**")
Use StdInt types in binary conversion functions
2020-02-18 00:04:09 +03:00
(sig bytes->int64-unsafe (Fn [Order (Ref (Array Byte) a)] Uint64))
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
(defn bytes->int64-unsafe [order bs]
Use partitions in byte-seq->int16-seq-unsafe This change brings the implementation of `byte-seq->int16-seq-unsafe` into parity with the implementations of its 32 and 64 bit brethren. I've also cleaned up some of my previous sloppiness: - Correct function names in doc and sig annotations. - Remove extra spaces before newlines.
2020-02-18 03:03:52 +03:00
(match order
(Order.LittleEndian)
(to-int64 @(Array.unsafe-nth bs 0) @(Array.unsafe-nth bs 1)
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
@(Array.unsafe-nth bs 2) @(Array.unsafe-nth bs 3)
@(Array.unsafe-nth bs 4) @(Array.unsafe-nth bs 5)
@(Array.unsafe-nth bs 6) @(Array.unsafe-nth bs 7))
Use partitions in byte-seq->int16-seq-unsafe This change brings the implementation of `byte-seq->int16-seq-unsafe` into parity with the implementations of its 32 and 64 bit brethren. I've also cleaned up some of my previous sloppiness: - Correct function names in doc and sig annotations. - Remove extra spaces before newlines.
2020-02-18 03:03:52 +03:00
(Order.BigEndian)
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
(to-int64 @(Array.unsafe-nth bs 7) @(Array.unsafe-nth bs 6)
@(Array.unsafe-nth bs 5) @(Array.unsafe-nth bs 4)
@(Array.unsafe-nth bs 3) @(Array.unsafe-nth bs 2)
@(Array.unsafe-nth bs 1) @(Array.unsafe-nth bs 0))))
Use partitions in byte-seq->int16-seq-unsafe This change brings the implementation of `byte-seq->int16-seq-unsafe` into parity with the implementations of its 32 and 64 bit brethren. I've also cleaned up some of my previous sloppiness: - Correct function names in doc and sig annotations. - Remove extra spaces before newlines.
2020-02-18 03:03:52 +03:00
Add safe variants of byte conversion functions I've also adopted a new naming strategy for these functions--the seq in byte-seq was redundant, so we now just name these bytes->intN-seq.
2020-02-18 19:41:29 +03:00
(doc bytes->int64
Binary: Make names consistent. Update docs. Specifically, we now reference the explicit unsigned int types we return in the docs for each function, and I've dropped the term byte-seq in favor of bytes in all cases.
2020-02-18 19:50:24 +03:00
"Interprets the first eight bytes in a byte sequence as an Uint64 value.
Add safe variants of byte conversion functions I've also adopted a new naming strategy for these functions--the seq in byte-seq was redundant, so we now just name these bytes->intN-seq.
2020-02-18 19:41:29 +03:00
If the first eight bytes are inaccessible, or the given array contains less
than eight bytes, returns Maybe.Nothing.")
(sig bytes->int64 (Fn [Order (Ref (Array Byte) a)] (Maybe Uint64)))
(defn bytes->int64 [order bs]
(match order
(Order.LittleEndian)
(Maybe.zip8 &to-int64 (Array.nth bs 0) (Array.nth bs 1)
(Array.nth bs 2) (Array.nth bs 3)
(Array.nth bs 4) (Array.nth bs 5)
(Array.nth bs 6) (Array.nth bs 7))
(Order.BigEndian)
(Maybe.zip8 &to-int64 (Array.nth bs 7) (Array.nth bs 6)
(Array.nth bs 5) (Array.nth bs 4)
(Array.nth bs 3) (Array.nth bs 2)
(Array.nth bs 1) (Array.nth bs 0))))
Add UintN->Byte conversions Note that we do not need an unsafe variant of these conversions since they are simple projections to and from the Uint types.
2020-02-18 21:35:35 +03:00
(doc int64->bytes
"Converts a Uint64 to a sequence of bytes representing the value using the provided `order`")
(sig int64->bytes (Fn [Order Uint64] (Array Byte)))
(defn int64->bytes [order i]
(let [shift (fn [lng] (Uint64.bit-shift-right i (Uint64.from-long lng)))]
(match order
(Order.LittleEndian)
(Array.copy-map &int64-to-byte
&[i (shift 8l) (shift 16l)
(shift 24l) (shift 32l)
(shift 40l) (shift 48l) (shift 56l)])
(Order.BigEndian)
(Array.copy-map &int64-to-byte
&[(shift 56l) (shift 48l)
(shift 40l) (shift 32l)
(shift 24l) (shift 16l) (shift 8l) i]))))
Add safe variants of byte conversion functions I've also adopted a new naming strategy for these functions--the seq in byte-seq was redundant, so we now just name these bytes->intN-seq.
2020-02-18 19:41:29 +03:00
Binary: Make names consistent. Update docs. Specifically, we now reference the explicit unsigned int types we return in the docs for each function, and I've dropped the term byte-seq in favor of bytes in all cases.
2020-02-18 19:50:24 +03:00
(doc bytes->int64-seq-unsafe
"Interprets a sequence of bytes as a sequence of Uint64 values.
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
**This operation is unsafe.**")
Binary: Make names consistent. Update docs. Specifically, we now reference the explicit unsigned int types we return in the docs for each function, and I've dropped the term byte-seq in favor of bytes in all cases.
2020-02-18 19:50:24 +03:00
(sig bytes->int64-seq-unsafe (Fn [Order (Ref (Array Byte) a)] (Array Uint64)))
(defn bytes->int64-seq-unsafe [order bs]
Move partition function into the Array module Since the function is generic over arrays, it makes more sense to house it here. I've also fixed an issue with its definition whereby we produced extra empty arrays when n was greater than the original array length. We now return an array of a length that matches precisely the number of partitions with values we're able to create.
2020-02-16 23:57:38 +03:00
(let [partitions (Array.partition bs 8)
Use partitions in byte-seq->int16-seq-unsafe This change brings the implementation of `byte-seq->int16-seq-unsafe` into parity with the implementations of its 32 and 64 bit brethren. I've also cleaned up some of my previous sloppiness: - Correct function names in doc and sig annotations. - Remove extra spaces before newlines.
2020-02-18 03:03:52 +03:00
f (fn [b] (bytes->int64-unsafe order b))]
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
(Array.copy-map &f &partitions)))
Use partitions in byte-seq->int16-seq-unsafe This change brings the implementation of `byte-seq->int16-seq-unsafe` into parity with the implementations of its 32 and 64 bit brethren. I've also cleaned up some of my previous sloppiness: - Correct function names in doc and sig annotations. - Remove extra spaces before newlines.
2020-02-18 03:03:52 +03:00
Add safe variants of byte conversion functions I've also adopted a new naming strategy for these functions--the seq in byte-seq was redundant, so we now just name these bytes->intN-seq.
2020-02-18 19:41:29 +03:00
(doc bytes->int64-seq
"Interprets a sequence of bytes as a sequence of Uint64 values.
If a segment of bytes cannot be interpreted as an Uint64, returns Maybe.Nothing.")
(sig bytes->int64-seq (Fn [Order (Ref (Array Byte) a)] (Array (Maybe Uint64))))
(defn bytes->int64-seq [order bs]
(let [partitions (Array.partition bs 8)
f (fn [b] (bytes->int64 order b))]
(Array.copy-map &f &partitions)))
Add functions for converting intN seq(uence)s to byte seqs
2020-02-18 21:45:18 +03:00
(doc int64-seq->bytes
"Converts an array of Uint64 values into byte sequences.")
(sig int64-seq->bytes (Fn [Order (Ref (Array Uint64) a)] (Array (Array Byte))))
(defn int64-seq->bytes [order is]
(let [f (fn [i] (int64->bytes order @i))]
(Array.copy-map &f is)))
Add Binary module The binary module implements functions for interpreting byte sequences as int16, int32, or int64 values depending on a given endianess (the Byte module implements support for interpreting bytes as int8 values). It'd be nice if we could implement these functions in pure Carp, using the Bytes module--but unfortunately we need to rely on some type conversions in C, which are only possible by registering C functions for performing the necessary conversions. At the moment, all of these functions are unsafe (they access byte arrays using unsafe-nth).
2020-02-16 23:15:54 +03:00
)
Reference in New Issue Copy Permalink