dymokomi/luce-base
Source of release 0.42.0
0.42.0 / src / support / buffer.lucb
#==============================================================================================
#
# buffer - Growable compiler output
#
# DESCRIPTION:
# Storage belongs to the allocator captured at creation; views borrow that storage until
# the next append or destruction.
#
#==============================================================================================
import io
import memory
## A growable byte buffer over a captured allocator, for emitted text; as a `Writer`, it
## keeps what is written to it.
pub struct Buffer: io.Writer:
var data: u8[]
## The number of bytes written; `bytes()[..<used]` are them.
pub var used: usize
var allocator: memory.Allocator
## An empty buffer with room for `capacity` bytes (at least 256).
pub static func create(capacity: usize) -> Buffer!:
let room = capacity if capacity > 0 else 256
return Buffer(data = try new u8[room] ---, used = 0, allocator = memory.allocator)
func reserve(extra: usize) -> !:
let required = self.used +? extra else error(memory.exhausted, "the output buffer size overflows")
if required <= self.data.length:
return
var room = self.data.length if self.data.length > 0 else 1
while room < required:
room = room *? 2 else required
let grown = try new u8[room] --- in self.allocator
memory.copy(grown, self.data, self.used)
free(self.data) in self.allocator
self.data = grown
## Append `text`.
pub func put(text: str) -> !:
try self.reserve(text.length)
memory.copy(self.data[self.used..], text.bytes, text.length)
self.used += text.length
## Append `bytes`, as a `Writer`: all of them, or none when memory is exhausted.
pub func write(bytes: const u8[]) -> usize!:
try self.put_bytes(bytes)
return bytes.length
## Append raw `bytes`.
pub func put_bytes(bytes: const u8[]) -> !:
try self.reserve(bytes.length)
memory.copy(self.data[self.used..], bytes, bytes.length)
self.used += bytes.length
## Append one byte.
pub func put_byte(byte: u8) -> !:
try self.reserve(1)
self.data[self.used] = byte
self.used += 1
## Append `value` in decimal.
pub func put_u64(value: u64) -> !:
var digits: u8[24]
var n: usize = 0
var v = value
if v == 0:
digits[0] = '0'
n = 1
while v > 0:
digits[n] = (u8)(v % 10) + '0'
v = v // 10
n += 1
try self.reserve(n)
while n > 0:
n -= 1
self.data[self.used] = digits[n]
self.used += 1
## Append `value` in decimal, with a leading minus when negative.
pub func put_i64(value: i64) -> !:
if value < 0:
try self.put_byte('-')
try self.put_u64((u64)(0 -% value))
return
try self.put_u64((u64)value)
## The text so far; invalid after the next append.
pub func view() -> str:
return (str)self.data[..<self.used]
## The bytes written so far; invalid after the next append.
pub func bytes() -> const u8[]:
return self.data[..<self.used]
## Discard the contents, keeping the storage.
pub func clear():
self.used = 0
## Release the storage.
pub func destroy():
free(self.data) in self.allocator
test "a buffer appends text and numbers and grows":
var backing: u8[65536]
var arena = memory.FixedBuffer.over(backing)
with arena:
var b = try Buffer.create(4)
try b.put("abc")
try b.put_u64(12345)
try b.put_byte('-')
try b.put_i64(-7)
assert(b.view() == "abc12345--7")
assert(b.used == 11)
test "failed buffer growth preserves content and reports exhaustion":
var output = try Buffer.create(4)
defer output.destroy()
try output.put("abc")
for amount in [(usize)18446744073709551615, (usize)4611686018427387904]:
var failed = false
output.reserve(amount) catch failure:
assert(failure.code == memory.exhausted)
failed = true
assert(failed and output.view() == "abc" and output.used == 3)
try output.put("de")
assert(output.view() == "abcde")