Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-base

Source of release 0.41.0

0.41.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")