do
assert bits.length <= 8
- var int = 0
+ var int = 0u8
for b in bits.length.times do
- if bits[b] then int += 2**b
+ if bits[b] then int |= 1u8 << (7 - b)
end
write_byte int
# Read a single byte and return `true` if its value is different than 0
#
# Returns `false` when an error is pending (`last_error != null`).
- fun read_bool: Bool do return read_byte != 0
+ fun read_bool: Bool do return read_byte != 0u8
# Get an `Array` of 8 `Bool` by reading a single byte
#
do
var int = read_byte
if int == null then return new Array[Bool]
- return [for b in 8.times do int.bin_and(2**b) > 0]
+ var arr = new Array[Bool]
+ for i in [7 .. 0].step(-1) do
+ arr.push(((int >> i) & 1u8) != 0u8)
+ end
+ return arr
end
# Read a null terminated string
var buf = new FlatBuffer
loop
var byte = read_byte
- if byte == null or byte == 0x00 then return buf.to_s
+ if byte == null or byte == 0x00u8 then return buf.to_s
buf.bytes.add byte
end
end
end
# Utility for `read_float`
- private fun native_read_float(b0, b1, b2, b3: Int, big_endian: Bool): Float `{
+ private fun native_read_float(b0, b1, b2, b3: Byte, big_endian: Bool): Float `{
union {
unsigned char b[4];
float val;
end
# Utility for `read_double`
- private fun native_read_double(b0, b1, b2, b3, b4, b5, b6, b7: Int, big_endian: Bool): Float `{
+ private fun native_read_double(b0, b1, b2, b3, b4, b5, b6, b7: Byte, big_endian: Bool): Float `{
union {
unsigned char b[8];
double val;
end
# Utility for `read_int64`
- private fun native_read_int64(b0, b1, b2, b3, b4, b5, b6, b7: Int, big_endian: Bool): Int `{
+ private fun native_read_int64(b0, b1, b2, b3, b4, b5, b6, b7: Byte, big_endian: Bool): Int `{
union {
unsigned char b[8];
int64_t val;
redef class Int
# Utility for `BinaryWriter`
- private fun int64_byte_at(index: Int, big_endian: Bool): Int `{
+ private fun int64_byte_at(index: Int, big_endian: Bool): Byte `{
union {
unsigned char bytes[8];
int64_t val;
redef class Float
# Utility for `BinaryWriter`
- private fun float_byte_at(index: Int, big_endian: Bool): Int `{
+ private fun float_byte_at(index: Int, big_endian: Bool): Byte `{
union {
unsigned char bytes[4];
float val;
`}
# Utility for `BinaryWriter`
- private fun double_byte_at(index: Int, big_endian: Bool): Int `{
+ private fun double_byte_at(index: Int, big_endian: Bool): Byte `{
union {
unsigned char bytes[8];
double val;
# ---
# Special bytes, marking the kind of objects in the stream and the end on an object
-private fun kind_null: Int do return 0x01
-private fun kind_object_new: Int do return 0x02
-private fun kind_object_ref: Int do return 0x03
-private fun kind_int: Int do return 0x04
-private fun kind_bool: Int do return 0x05
-private fun kind_char: Int do return 0x06
-private fun kind_float: Int do return 0x07
-private fun kind_string: Int do return 0x08
-private fun kind_native_string: Int do return 0x09
-private fun kind_flat_array: Int do return 0x0A
-
-private fun new_object_end: Int do return 0x00
+private fun kind_null: Byte do return 0x01u8
+private fun kind_object_new: Byte do return 0x02u8
+private fun kind_object_ref: Byte do return 0x03u8
+private fun kind_int: Byte do return 0x04u8
+private fun kind_bool: Byte do return 0x05u8
+private fun kind_char: Byte do return 0x06u8
+private fun kind_float: Byte do return 0x07u8
+private fun kind_string: Byte do return 0x08u8
+private fun kind_native_string: Byte do return 0x09u8
+private fun kind_flat_array: Byte do return 0x0Au8
+
+private fun new_object_end: Byte do return 0x00u8
#---
# Engines
# A `peeked_char` can suffix the next attribute name.
#
# Returns `null` on error.
- private fun deserialize_next_attribute(peeked_char: nullable Char):
+ private fun deserialize_next_attribute(peeked_char: nullable Byte):
nullable Couple[String, nullable Object]
do
# Try the next attribute
private fun deserialize_next_object: nullable Object
do
var kind = stream.read_byte
- assert kind isa Int else
+ assert kind isa Byte else
# TODO break even on keep_going
return null
end
if kind == kind_int then return stream.read_int64
if kind == kind_bool then return stream.read_bool
if kind == kind_float then return stream.read_double
- if kind == kind_char then return (stream.read_byte or else 0).ascii
+ if kind == kind_char then
+ var b = stream.read_byte
+ if b == null then return 0
+ return b.to_i.ascii
+ end
if kind == kind_string then return stream.read_block
if kind == kind_native_string then return stream.read_block.to_cstring
if next_byte == new_object_end then break
# Fetch an additional attribute, even if it isn't expected
- deserialize_next_attribute((next_byte or else 0).ascii)
+ deserialize_next_attribute(next_byte)
end
# Close object
redef fun serialize_to_binary(v)
do
v.stream.write_byte kind_char
- v.stream.write_byte self.ascii
+ # Fix when UTF-8
+ v.stream.write_byte self.ascii.to_b
end
end
nitlanguage / nit.git / commitdiff