Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.1

0.6.1 / src / surface / math.lucb

## Arithmetic surface expressions lower to canonical operation elements and wires.
import strings
import memory
from model import DocumentData
from value import scalar_bits
from types import DType, invalid, limit_exceeded, max_items, max_depth
from storage import Buffer, List, text_copy
from path import joined
from authoring.names import unique_path
from codecs.common import whitespace, put

struct Node:
    var kind: u8
    var left: usize
    var right: usize
    var number: f64
    var reference: str = ""

struct Parser:
    var source: str = ""
    var offset: usize
    var nodes: List[Node]

    func peek() -> u8:
        while self.offset < self.source.length and whitespace(self.source.bytes[self.offset]):
            self.offset += 1
        return self.source.bytes[self.offset] if self.offset < self.source.length else 0

    func append(node: Node) -> usize!:
        if self.nodes.count >= max_items:
            error(limit_exceeded, "Prism math expression is too large")
        let index = self.nodes.count
        try self.nodes.push(node)
        return index

    func factor(depth: usize) -> usize!:
        if depth > max_depth:
            error(limit_exceeded, "Prism math expression is too deep")
        let byte = self.peek()
        if byte == '-':
            self.offset += 1
            return try self.append(Node(kind = 'n', left = try self.factor(depth + 1)))
        if byte == '(':
            self.offset += 1
            let node = try self.expression(depth + 1)
            if self.peek() != ')':
                error(invalid, "expected a closing parenthesis in Prism math")
            self.offset += 1
            return node
        let start = self.offset
        if (byte >= '0' and byte <= '9') or byte == '.':
            while self.offset < self.source.length:
                let current = self.source.bytes[self.offset]
                if (current < '0' or current > '9') and current != '.':
                    break
                self.offset += 1
            let number = try strings.parse_f64((str)self.source.bytes[start..<self.offset])
            return try self.append(Node(kind = 'l', number = number))
        while self.offset < self.source.length:
            let current = self.source.bytes[self.offset]
            if not ((current >= 'a' and current <= 'z') or (current >= 'A' and current <= 'Z') or (current >= '0' and current <= '9') or current == '_' or current == '.'):
                break
            self.offset += 1
        if self.offset == start:
            error(invalid, "expected an operand in Prism math")
        return try self.append(Node(kind = 'r', reference = (str)self.source.bytes[start..<self.offset]))

    func term(depth: usize) -> usize!:
        var node = try self.factor(depth)
        while self.peek() == '*' or self.peek() == '/':
            let op = self.peek()
            self.offset += 1
            let right = try self.factor(depth)
            node = try self.append(Node(kind = op, left = node, right = right))
        return node

    func expression(depth: usize) -> usize!:
        var node = try self.term(depth)
        while self.peek() == '+' or self.peek() == '-':
            let op = self.peek()
            self.offset += 1
            let right = try self.term(depth)
            node = try self.append(Node(kind = op, left = node, right = right))
        return node

struct Operand:
    var reference: Buffer
    var number: f64

pub func set_number(doc: DocumentData*, path: str, name: str, number: f64) -> !:
    var native = number
    var value = try scalar_bits(DType.float64, memory.read[u64](&native))
    defer value.close()
    try put(doc, path, name, &value)

func input(doc: DocumentData*, path: str, name: str, operand: const Operand*) -> !:
    if operand.reference.used == 0:
        try set_number(doc, path, name, operand.number)
        return
    var target = try text_copy(path)
    defer target.close()
    try target.text(".")
    try target.text(name)
    try doc.connect(operand.reference.view(), target.view())

func emit(doc: DocumentData*, nodes: const Node[], index: usize, root: str, counter: usize*, is_root: bool, depth: usize) -> Operand!:
    if depth > max_depth:
        error(limit_exceeded, "Prism math expression is too deep")
    let node = &nodes[index]
    if node.kind == 'l':
        return Operand(number = node.number)
    if node.kind == 'r':
        return Operand(reference = try joined("/", node.reference))
    var path: Buffer
    defer path.close()
    if is_root:
        path = try text_copy(root)
    else:
        var scratch: u8[32]
        path = try joined(root, try strings.format(scratch, f"[{counter[0]}]"))
        counter[0] += 1
    let kind = "neg" if node.kind == 'n' else ("add" if node.kind == '+' else ("sub" if node.kind == '-' else ("mul" if node.kind == '*' else "div")))
    try doc.insert(path.view(), kind)
    var a = try emit(doc, nodes, node.left, root, counter, false, depth + 1)
    defer a.reference.close()
    try input(doc, path.view(), "a", &a)
    if node.kind != 'n':
        var b = try emit(doc, nodes, node.right, root, counter, false, depth + 1)
        defer b.reference.close()
        try input(doc, path.view(), "b", &b)
    try path.text(".out")
    return Operand(reference = try path.copy())

pub func compile(doc: DocumentData*, name: str, expression: str) -> !:
    var parser = Parser(source = expression)
    defer parser.nodes.close()
    let root_node = try parser.expression(0)
    if parser.peek() != 0:
        error(invalid, "unexpected text after Prism math expression")
    var requested = try joined("/", name)
    defer requested.close()
    var path = try unique_path(doc, requested.view())
    defer path.close()
    var counter: usize = 0
    let kind = parser.nodes.items[root_node].kind
    if kind == 'l' or kind == 'r':
        try doc.insert(path.view(), "add")
        var a = try emit(doc, parser.nodes.span(), root_node, path.view(), &counter, false, 0)
        defer a.reference.close()
        try input(doc, path.view(), "a", &a)
        try set_number(doc, path.view(), "b", 0.0)
    else:
        var output = try emit(doc, parser.nodes.span(), root_node, path.view(), &counter, true, 0)
        output.reference.close()