dymokomi/luce-svg
Source of release 0.9.2
0.9.2 / src / svg / buffers.lucb
#==============================================================================================
#
# svg/buffers - Growable lists and a text arena
#
# DESCRIPTION:
# The document tree, the scene and the renderer keep their records in `List`s, heap
# arrays that double as they fill, addressed by index so nothing points into them.
# Text that is not a plain view of the source (decoded entities, normalised
# attribute values, copied CSS declarations) is stored in an `Arena`: blocks that
# never move, so a `str` into one stays valid until the arena is released.
#
#==============================================================================================
# mark: Lists =================================================================================
## A growable heap array of `T`; `used` of `items` are in use.
struct List[T]:
var items: T[]
var used: usize = 0
## Append `value`.
func push(value: T) -> !:
if self.used >= self.items.length:
self.items = try grown(self.items, self.used, 8)
self.items[self.used] = value
self.used += 1
## Insert `value` before item `at` (at most `used`).
func insert(at: usize, value: T) -> !:
try self.push(value)
var index = self.used - 1
while index > at:
self.items[index] = self.items[index - 1]
index -= 1
self.items[at] = value
## Remove item `at`, moving the ones after it down.
func remove(at: usize):
for index in at..<self.used - 1:
self.items[index] = self.items[index + 1]
self.used -= 1
## The items in use, as a span.
func view() -> T[]:
return self.items[..<self.used]
## Drop items past `length`.
func truncate(length: usize):
if length < self.used:
self.used = length
## Free the items; the list is empty afterwards.
func release():
if self.items.length > 0:
free(self.items) in memory.heap
var empty: T[]
self.items = empty
self.used = 0
# mark: The text arena ========================================================================
## Bytes for text that outlives the source view it was made from, in blocks that never move.
struct Arena:
var blocks: List[u8[]] = List[u8[]]()
var block_used: usize = 0
## A copy of `text` in the arena.
func store(text: const u8[]) -> str!:
let target = try self.reserve(text.length)
memory.copy(target, text, text.length)
return (str)target
## `length` bytes of fresh arena storage, for the caller to fill.
func reserve(length: usize) -> u8[]!:
if length == 0:
var empty: u8[]
return empty
var room: usize = 0
if self.blocks.used > 0:
room = self.blocks.items[self.blocks.used - 1].length - self.block_used
if room < length:
let size = length if length > 16384 else 16384
try self.blocks.push(try new u8[size] --- in memory.heap)
self.block_used = 0
let block = self.blocks.items[self.blocks.used - 1]
let start = self.block_used
self.block_used += length
return block[start..<start + length]
## Free every block; every `str` the arena gave out is invalid afterwards.
func release():
for block in self.blocks.view():
free(block) in memory.heap
self.blocks.release()
self.block_used = 0
## Text built a byte at a time in a scratch list, then kept in an arena.
struct TextBuilder:
var bytes: List[u8] = List[u8]()
func add(byte: u8) -> !:
try self.bytes.push(byte)
func add_all(text: const u8[]) -> !:
for byte in text:
try self.bytes.push(byte)
## The bytes so far, stored in `arena`; the builder is cleared.
func finish(arena: Arena*) -> str!:
let kept = try arena.store(self.bytes.view())
self.bytes.used = 0
return kept
func release():
self.bytes.release()