Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-kernel

Source of release 0.1.1

0.1.1 / src / lower / calls.lucb

# Calls: Base's `assert` and `trap`, checked conversions, the host API, `lib` and
# luce-std's `math` and `math32` (one column operation each), and the snippet's own
# helper functions, which are inlined.

extend Lowerer:
    func call(e: ast.Node*) -> Value!:
        let callee = e.left else return self.nothing()
        if callee.has(ast.flag_builtin):
            return try self.core_call(e, callee.text)
        if callee.has(ast.flag_type_ref) and e.resolved == none:
            if self.record(e.type_id) != none:
                return try self.construction(e)
            return try self.conversion(e)
        if let binding = self.call_binding(e):
            return try self.api_call(e, binding)
        let decl = e.resolved else return try self.not_available(e, "this call")
        let module = self.module_name_of(decl) else return try self.not_available(e, "this call")
        if module == "luce_kernel.lib":
            if has_operation(decl.text) and decl.kind == ast.Kind.func_ and self.receiver_node(e, decl) == none:
                return try self.lib_call(e, decl)
            return try self.inline(e, decl, true)
        if self.host.inlines(module):
            return try self.inline(e, decl, true)
        if module == "luce_std.math32" or module == "luce_std.math":
            return try self.math_call(e, decl)
        if module == self.c.modules.get(self.snippet).name and decl.kind == ast.Kind.func_:
            return try self.inline(e, decl, false)
        var room: u8[200]
        let what = strings.format(room, f"`{decl.text}`") else "this function"
        return try self.not_available(e, what)

    ## The arguments of a call, each converted to its parameter's type, defaults filled in.
    func arguments(e: ast.Node*, decl: ast.Node*, values: Value[]) -> usize!:
        var parameters = decl.right
        var given = e.body
        var count: usize = 0
        while let parameter = parameters:
            if count >= values.length:
                try self.fail(e, "too many arguments")
            var source: ast.Node*? = parameter.left
            if let argument = given:
                source = argument.left
                given = argument.next
            if source == none:
                try self.fail(e, "a missing argument")
            let node = source else return count
            # An API value (`p`) is passed as it is: the helper reads its members.
            if self.api_type(parameter.type_id) != none:
                values[count] = try self.expression(node)
            else:
                values[count] = try self.converted(try self.expression(node), parameter.type_id, node)
            count += 1
            parameters = parameter.next
        return count

    # mark: Core functions and conversions ====================================================

    func core_call(e: ast.Node*, name: str) -> Value!:
        let first = e.body
        # A fault of `assert` or `trap` points at the word, not the parenthesis.
        let at = e.left else return self.nothing()
        if name == "assert":
            let condition_node = (first else return self.nothing()).left else return self.nothing()
            let condition = try self.expression(condition_node)
            var message = "assert failed"
            if let second = (first else return self.nothing()).next:
                message = try self.text_literal(second.left)
            else:
                let src = self.c.modules.get(self.snippet).src
                var room: u8[400]
                let spelled = (str)src.bytes[condition_node.start..<condition_node.end]
                message = try self.texts.keep_text((strings.format(room, f"assert failed: {spelled}") else "assert failed").bytes)
            self.position(at)
            self.sync()
            self.b.check(condition.lanes[0], message)
            return self.nothing()
        if name == "trap":
            var message = "trap"
            if let argument = first:
                message = try self.text_literal(argument.left)
            self.position(at)
            self.sync()
            self.b.trap(message)
            return self.nothing()
        var room: u8[100]
        return try self.not_available(at, strings.format(room, f"`{name}`") else "this call")

    ## The text of a string literal (simple escapes decoded).
    func text_literal(node: ast.Node*?) -> str!:
        let literal = node else return ""
        if literal.kind != ast.Kind.literal or literal.text.length < 2 or literal.text.bytes[0] != '"':
            try self.fail(literal, "a message must be a literal")
        var decoded: u8[512]
        var used: usize = 0
        var at: usize = 1
        let bytes = literal.text.bytes
        while at + 1 < bytes.length and used < 511:
            var byte = bytes[at]
            if byte == '\\' and at + 2 < bytes.length:
                at += 1
                byte = match bytes[at]:
                    'n' => (u8)'\n'
                    't' => (u8)'\t'
                    'r' => (u8)'\r'
                    '0' => (u8)0
                    _ => bytes[at]
            decoded[used] = byte
            used += 1
            at += 1
        return try self.texts.keep_text(decoded[..<used])

    ## `T(field = x, ...)` of a record struct: the given fields, the others their
    ## defaults or zero (the checker names every argument's field).
    func construction(e: ast.Node*) -> Value!:
        let shape = self.record(e.type_id) else return try self.not_available(e, "this construction")
        let decl = self.c.table.get(e.type_id).decl else return try self.not_available(e, "this construction")
        var value = self.zero_record(shape, e.type_id)
        var uniform = true
        var member = decl.body
        while let field = member:
            member = field.next
            if field.kind != ast.Kind.field:
                continue
            var source: ast.Node*? = field.left
            var cursor = e.body
            while let argument = cursor:
                if argument.resolved == field or argument.text == field.text:
                    source = argument.left
                cursor = argument.next
            let node = source else continue
            let given = try self.converted(try self.expression(node), field.type_id, node)
            let place = self.field_of(e.type_id, field.text) else return try self.fail_value(e, "internal: a field without lanes")
            let (offset, kind, width, type_id) = place
            _ = kind
            _ = type_id
            for k in 0..<width: value.lanes[offset + k] = given.lanes[k if given.width > 1 else 0]
            uniform = uniform and given.uniform
        value.uniform = uniform
        return value

    ## The receiver of a method call (`m` in `m.inverted()`), or none for a function, a
    ## static method or an API call.
    func receiver_node(e: ast.Node*, decl: ast.Node*) -> ast.Node*?:
        if decl.has(ast.flag_static):
            return none
        let callee = e.left else return none
        if callee.kind != ast.Kind.member:
            return none
        let owner = callee.left else return none
        if owner.has(ast.flag_type_ref) or self.record(owner.type_id) == none:
            return none
        return owner

    ## `T(x)`: Base's checked conversion; `f32[4](x)`: every lane `x`.
    func conversion(e: ast.Node*) -> Value!:
        let argument = e.body else return try self.fail_value(e, "a conversion of nothing")
        let operand_node = argument.left else return self.nothing()
        let operand = try self.expression(operand_node)
        let (kind, width) = try self.shape_or_fail(e, e.type_id)
        self.position(e)
        if width > 1:
            if operand.width != 1:
                return try self.not_available(e, "this conversion")
            var lane = operand.lanes[0]
            if operand.kind != kind:
                self.sync()
                lane = self.b.convert(lane, kind)
            var result = self.scalar(kind, lane, operand.uniform, e.type_id)
            result.width = width
            for k in 1..<width: result.lanes[k] = lane
            return result
        if operand.width != 1:
            return try self.not_available(e, "this conversion")
        if operand.kind == kind:
            return self.scalar(kind, operand.lanes[0], operand.uniform, e.type_id)
        if operand.kind == .mask or kind == .mask:
            return try self.not_available(e, "this conversion")
        self.sync()
        return self.scalar(kind, self.b.convert(operand.lanes[0], kind), operand.uniform, e.type_id)

    # mark: The host API ======================================================================

    func api_call(e: ast.Node*, binding: Binding) -> Value!:
        match binding.role:
            .getter:
                let name = try self.literal_name(e, binding.column)
                let at = try self.column_index(e, name)
                let use = self.columns.at(at)
                var value = use.value
                value.borrowed = use.pinned
                return value
            .setter:
                let name = try self.literal_name(e, binding.column)
                let argument = (e.body else return self.nothing()).next else return try self.fail_value(e, "a setter without a value")
                let value_node = argument.left else return self.nothing()
                let at = try self.column_index(e, name)
                let value = try self.converted(try self.expression(value_node), self.columns.at(at).type_id, value_node)
                try self.write_column(e, name, value, every_lane)
                return self.nothing()
            .parameter:
                let name = try self.literal_name(e, "")
                var default: ast.Node*? = none
                if let first = e.body:
                    if let second = first.next:
                        default = second.left
                if default == none:
                    if let decl = e.resolved:
                        if let first_parameter = decl.right:
                            if let second_parameter = first_parameter.next:
                                default = second_parameter.left
                return try self.uniform_value(e, name, e.type_id, default, binding.components)
            .builtin:
                return try self.builtin_call(e, binding)
            .computed:
                let at = try self.column_index(e, binding.column)
                let use = self.columns.at(at)
                var value = use.value
                value.borrowed = use.pinned
                return value
            .reader:
                let name = try self.literal_name(e, binding.column)
                return try self.uniform_value(e, name, e.type_id, none)
            .handle:
                let argument = e.body else return try self.fail_value(e, "an API value needs its number")
                let number_node = argument.left else return self.nothing()
                let number = try self.expression(number_node)
                if number.width != 1 or not number.kind.is_integer():
                    return try self.fail_value(number_node, "an API value is named by an integer")
                # A literal number stays a constant, so the host can see which input a
                # call names before the run (`Program.may_pass`).
                var register = number.lanes[0]
                if number.kind != .i64:
                    var folded = false
                    if let known = self.b.constant_of(number.lanes[0]):
                        if known.bits < 0x80000000:
                            register = self.b.constant_i64((i64)known.bits)
                            folded = true
                    if not folded: register = self.b.cast(number.lanes[0], .i64)
                var value = self.scalar(.i64, register, number.uniform, e.type_id)
                value.handle = true
                return value
            _:
                return try self.fail_value(e, "this member is not a method")

    ## A host builtin: the arguments' lanes in order, the results as the call's value.
    func builtin_call(e: ast.Node*, binding: Binding) -> Value!:
        let builtin = binding.builtin else return self.nothing()
        var registers: u16[32]
        var count: usize = 0
        var uniform = true
        var texts: str[4] = ["", "", "", ""]
        var text_count: usize = 0
        # A method of an API value takes the value first (`k.input(1).point_count()`).
        if let callee = e.left:
            if let owner = callee.left:
                if not self.is_parameter(owner) and self.api_type(owner.type_id) != none:
                    let handle = try self.expression(owner)
                    if not handle.handle:
                        return try self.fail_value(owner, "internal: an API value without its number")
                    registers[0] = handle.lanes[0]
                    count = 1
                    uniform = handle.uniform
        # The given arguments, then the defaults of the parameters left out (the stub's
        # declaration says which).
        var cursor = e.body
        var parameter: ast.Node*? = none
        if let decl = e.resolved:
            if decl.kind == ast.Kind.func_: parameter = decl.right
        while cursor != none or parameter != none:
            var given: ast.Node*? = none
            if let argument = cursor:
                given = argument.left
                cursor = argument.next
            elif let left_out = parameter:
                given = left_out.left
                if given == none: return try self.fail_value(e, "a missing argument")
            if let declared = parameter: parameter = declared.next
            let node = given else return self.nothing()
            if node.type_id == types.str_id:
                if text_count >= 4:
                    return try self.fail_value(node, "at most four texts to one call")
                texts[text_count] = try self.text_literal(node)
                text_count += 1
                continue
            let value = try self.expression(node)
            uniform = uniform and value.uniform
            for k in 0..<value.width:
                if count >= builtin.argument_count:
                    return try self.fail_value(e, "more argument lanes than the builtin takes")
                if value.lane_kind(k) != builtin.arguments[count]:
                    return try self.fail_value(node, "an argument of another kind than the builtin takes")
                registers[count] = value.lanes[k]
                count += 1
        if count != builtin.argument_count:
            return try self.fail_value(e, "fewer argument lanes than the builtin takes")
        self.position(e)
        self.sync()
        let first = self.b.call_with_texts(builtin, registers[..<count], texts[..<text_count])
        if first == no_register:
            var room: u8[300]
            let text = strings.format(room, f"internal: the program was refused: {self.b.refusal()}") else "internal: the program was refused"
            return try self.fail_value(e, text)
        if e.type_id == types.unit_id:
            return self.nothing()
        # A builtin giving an API value (`g.pcopen(...)`): its one i64 result names it,
        # and its methods take that number first.
        if self.api_type(e.type_id) != none:
            if builtin.result_count != 1 or builtin.results[0] != .i64:
                return try self.fail_value(e, "a builtin giving an API value returns one i64")
            var named = self.scalar(.i64, first, false, e.type_id)
            named.handle = true
            return named
        if let shape = self.record(e.type_id):
            if shape.width != builtin.result_count:
                return try self.fail_value(e, "a builtin whose results differ from the method's type")
            var result = self.zero_record(shape, e.type_id)
            result.uniform = false
            for k in 0..<shape.width:
                if shape.kinds[k] != builtin.results[k]:
                    return try self.fail_value(e, "a builtin whose results differ from the method's type")
                result.lanes[k] = first +% (u16)k
            return result
        let (kind, width) = try self.shape_or_fail(e, e.type_id)
        if width != builtin.result_count or kind != builtin.results[0]:
            return try self.fail_value(e, "a builtin whose results differ from the method's type")
        var result = self.scalar(kind, first, false, e.type_id)
        result.width = width
        for k in 0..<width: result.lanes[k] = first +% (u16)k
        return result

    # mark: lib and math ======================================================================

    func lib_call(e: ast.Node*, decl: ast.Node*) -> Value!:
        var values: Value[5]
        let count = try self.arguments(e, decl, values)
        let name = decl.text
        self.position(e)
        if let code = field_code(name):
            return try self.field_call(e, name, code, values)
        let (kind, width) = try self.shape_or_fail(e, e.type_id)
        var uniform = true
        for k in 0..<count: uniform = uniform and values[k].uniform
        if name == "dot" or name == "dot2d" or name == "dot64":
            return self.scalar(kind, self.b.dot(self.consecutive(values[0]), self.consecutive(values[1]), values[0].width), uniform, e.type_id)
        if name == "length" or name == "length2d" or name == "length64":
            return self.scalar(kind, self.b.length(self.consecutive(values[0]), values[0].width), uniform, e.type_id)
        if name == "length2" or name == "length2_64":
            return self.scalar(kind, self.b.length2(self.consecutive(values[0]), values[0].width), uniform, e.type_id)
        if name == "distance" or name == "distance2d" or name == "distance64":
            return self.scalar(kind, self.b.distance(self.consecutive(values[0]), self.consecutive(values[1]), values[0].width), uniform, e.type_id)
        if name == "distance2" or name == "distance2_64":
            return self.scalar(kind, self.b.distance2(self.consecutive(values[0]), self.consecutive(values[1]), values[0].width), uniform, e.type_id)
        if name == "cross" or name == "cross64":
            let first = self.b.cross(self.consecutive(values[0]), self.consecutive(values[1]))
            var result = self.zero(kind, width, e.type_id)
            for k: u16 in 0..<3: result.lanes[(usize)k] = first + k
            result.uniform = uniform
            return result
        if name == "normalized" or name == "normalized2d" or name == "normalized64":
            let first = self.b.normalize(self.consecutive(values[0]), values[0].width)
            var result = self.scalar(kind, first, uniform, e.type_id)
            result.width = width
            for k in 0..<width: result.lanes[k] = first +% (u16)k
            return result
        if name == "lerp" or name == "lerp64" or name == "clamp" or name == "clamp64" or name == "smooth" or name == "smooth64" or name == "fit01" or name == "fit01_64":
            let op: Op = .lerp if name.bytes[0] == 'l' else (.clamp if name.bytes[0] == 'c' else (.smooth if name.bytes[0] == 's' else .fit01))
            return self.scalar(kind, self.b.ternary(op, values[0].lanes[0], values[1].lanes[0], values[2].lanes[0]), uniform, e.type_id)
        if name == "fit" or name == "fit64":
            return self.scalar(kind, self.b.fit(values[0].lanes[0], values[1].lanes[0], values[2].lanes[0], values[3].lanes[0], values[4].lanes[0]), uniform, e.type_id)
        if name == "degrees" or name == "degrees64" or name == "radians" or name == "radians64":
            return self.scalar(kind, self.b.unary(.degrees if name.bytes[0] == 'd' else .radians, values[0].lanes[0]), uniform, e.type_id)
        if name == "rand" or name == "rand64" or name == "rand3":
            if name == "rand3":
                var result = self.zero(kind, width, e.type_id)
                for k: u16 in 0..<3: result.lanes[(usize)k] = self.b.rand(values[0].lanes[0], .f32, k)
                result.uniform = uniform
                return result
            return self.scalar(kind, self.b.rand(values[0].lanes[0], kind, 0), uniform, e.type_id)
        if name == "rand_stream" or name == "rand_stream64":
            let argument = (e.body else return self.nothing()).next else return self.nothing()
            let stream_node = argument.left else return self.nothing()
            let stream = self.c.exact_integer(stream_node, 32, false) else return try self.fail_value(stream_node, "a random stream must be a constant")
            if stream < 0 or stream > 65535:
                return try self.fail_value(stream_node, "a random stream is 0 to 65535")
            return self.scalar(kind, self.b.rand(values[0].lanes[0], kind, (u16)stream), uniform, e.type_id)
        let noise = noise_shape(name) else return try self.not_available(e, "this lib function")
        let (signed, dimensions) = noise
        let point = self.consecutive(values[0])
        let value = self.b.snoise(point, dimensions) if signed else self.b.noise(point, dimensions)
        return self.scalar(kind, value, uniform, e.type_id)

    ## A lib field the engine runs natively (`curlnoise`, `wnoise`, ...): its results in
    ## the call's type, a vector or a record.
    func field_call(e: ast.Node*, name: str, code: u16, values: Value[]) -> Value!:
        # The inputs as consecutive f32 registers: the point's three lanes, then any
        # numbers after it (whole ones converted: periods and octaves are small).
        var point = values[0]
        point.kind = .f32
        point.width = 4
        var uniform = values[0].uniform
        let extra: usize = 1 if name == "flownoise" else (3 if code == field_pnoise or code == field_onoise or code == field_anoise else 0)
        for k in 0..<extra:
            let given = values[1 + k]
            var lane = given.lanes[0]
            if given.kind != .f32:
                self.sync()
                lane = self.b.convert(lane, .f32)
            point.lanes[3 + k] = lane
            uniform = uniform and given.uniform
        point.width = 3 + extra if extra > 0 else 4
        point.borrowed = extra > 0
        let first = self.b.field(code, self.consecutive(point))
        if name == "flownoise" or name == "alligator" or extra == 3:
            return self.scalar(.f32, first, uniform, e.type_id)
        if name == "curlnoise":
            var result = self.zero(.f32, 4, e.type_id)
            for k: u16 in 0..<3: result.lanes[(usize)k] = first + k
            result.uniform = uniform
            return result
        let shape = self.record(e.type_id) else return try self.fail_value(e, "internal: a field's record")
        var result = self.zero_record(shape, e.type_id)
        result.uniform = uniform
        if name == "wnoise":
            result.lanes[0] = first
            result.lanes[1] = first + 1
            self.sync()
            result.lanes[2] = self.b.convert(first + 2, .i32)
            return result
        # NoiseD: the value, then the gradient's three lanes (the fourth stays zero).
        for k: u16 in 0..<4: result.lanes[(usize)k] = first + k
        return result

    func math_call(e: ast.Node*, decl: ast.Node*) -> Value!:
        var values: Value[3]
        let count = try self.arguments(e, decl, values)
        let name = decl.text
        self.position(e)
        let (kind, width) = try self.shape_or_fail(e, e.type_id)
        _ = width
        var uniform = true
        for k in 0..<count: uniform = uniform and values[k].uniform
        if let op = math_unary(name):
            return self.scalar(kind, self.b.unary(op, values[0].lanes[0]), uniform, e.type_id)
        if let op = math_classify(name):
            return self.scalar(.mask, self.b.classify(op, values[0].lanes[0]), uniform, e.type_id)
        if let op = math_binary(name):
            if op == .abs or op == .min or op == .max:
                self.sync()
            if op == .abs:
                return self.scalar(kind, self.b.unary(.abs, values[0].lanes[0]), uniform, e.type_id)
            return self.scalar(kind, self.b.binary(op, values[0].lanes[0], values[1].lanes[0]), uniform, e.type_id)
        if name == "fma":
            return self.scalar(kind, self.b.ternary(.mul_add, values[0].lanes[0], values[1].lanes[0], values[2].lanes[0]), uniform, e.type_id)
        if name == "clamp" or name == "iclamp":
            # luce-std asserts ordered bounds, so a reversed pair fails the run as Base would.
            self.sync()
            self.b.check(self.b.compare(.le, values[1].lanes[0], values[2].lanes[0]), "assert failed: low <= high")
            return self.scalar(kind, self.b.ternary(.clamp, values[0].lanes[0], values[1].lanes[0], values[2].lanes[0]), uniform, e.type_id)
        var room: u8[120]
        return try self.not_available(e, strings.format(room, f"`{name}`") else "this function")

    # mark: Helpers ===========================================================================

    ## A helper function of the snippet, inlined: its parameters bound to the arguments,
    ## its body lowered in place, `return` writing its result.
    func inline(e: ast.Node*, decl: ast.Node*, from_lib: bool) -> Value!:
        if contains(self.inlining.view(), decl):
            return try self.fail_value(e, "recursion is not available in a kernel")
        var values: Value[16]
        let count = try self.arguments(e, decl, values)
        # A method's receiver is `self` while its body is lowered.
        var has_receiver = false
        if let owner = self.receiver_node(e, decl):
            try self.receivers.append(try self.expression(owner))
            has_receiver = true
        defer:
            if has_receiver: self.receivers.truncate(self.receivers.length() - 1)
        # A `lib` body reports positions and refusals at the snippet's call.
        if from_lib:
            if self.library_depth == 0: self.library_call = e
            self.library_depth += 1
        defer:
            if from_lib: self.library_depth -= 1
        try self.inlining.append(decl)
        let locals_before = self.locals.length()
        let varying_before = self.varying_decls.length()
        let pinned_before = self.pinned_decls.length()
        var parameters = decl.right
        var at: usize = 0
        while let parameter = parameters:
            if at < count:
                if not values[at].uniform: try self.varying_decls.append(parameter)
                try self.declare(parameter, values[at])
            at += 1
            parameters = parameter.next
        let body = decl.body else return self.nothing()
        # A body that is one `return value` is the value.
        if let only = body.body:
            if only.kind == ast.Kind.return_ and only.next == none and only.left != none:
                let result_node = only.left else return self.nothing()
                let returns = self.c.table.get(decl.type_id).elem
                let value = try self.converted(try self.expression(result_node), returns, result_node)
                self.locals.truncate(locals_before)
                self.varying_decls.truncate(varying_before)
                self.inlining.truncate(self.inlining.length() - 1)
                return value
        try self.scan_function(body.body)
        let returns = self.c.table.get(decl.type_id).elem
        var function = Function(decl = decl, live = no_register, result = self.nothing(), has_result = returns != types.unit_id)
        if function.has_result:
            function.result = self.copied(try self.zero_value(e, returns))
            function.result.uniform = false
        if has_early_return(body.body, 0):
            function.live = self.b.register(.mask)
            self.b.emit(.copy, .mask, function.live, self.b.constant_mask(true), 0, 0)
            try self.push_frame(function.live)
        try self.functions.append(function)
        try self.statements(body.body)
        self.functions.truncate(self.functions.length() - 1)
        if function.live != no_register:
            self.pop_frame()
        self.locals.truncate(locals_before)
        self.varying_decls.truncate(varying_before)
        self.pinned_decls.truncate(pinned_before)
        self.inlining.truncate(self.inlining.length() - 1)
        return function.result

## The `lib` functions the engine runs as column operations; every other `lib` function
## is lowered from its Base body, like the snippet's own helpers.
func has_operation(name: str) -> bool:
    let names: str[47] = ["dot", "dot2d", "dot64", "length", "length2d", "length64", "length2", "length2_64", "distance", "distance2d", "distance64", "distance2", "distance2_64", "cross", "cross64", "normalized", "normalized2d", "normalized64", "lerp", "lerp64", "clamp", "clamp64", "smooth", "smooth64", "fit01", "fit01_64", "fit", "fit64", "degrees", "degrees64", "radians", "radians64", "rand", "rand64", "rand3", "rand_stream", "rand_stream64", "snoise1", "snoise2", "snoise", "snoise4", "noise1", "noise2", "noise", "noise4", "snoise1_64", "noise1_64"]
    for known in names:
        if known == name: return true
    return noise_shape(name) != none or field_code(name) != none

## The engine field of lib function `name`, if it has one.
func field_code(name: str) -> u16?:
    if name == "curlnoise": return field_curl
    if name == "xnoised": return field_xnoised
    if name == "noised": return field_noised
    if name == "wnoise": return field_wnoise
    if name == "flownoise": return field_flow
    if name == "alligator": return field_alligator
    if name == "pnoise": return field_pnoise
    if name == "onoise": return field_onoise
    if name == "anoise": return field_anoise
    return none

## lib's noise functions: signed or not, and dimensions.
func noise_shape(name: str) -> (bool, usize)?:
    let signed = name.bytes[0] == 's'
    let rest = (str)name.bytes[(1 if signed else 0)..]
    if rest == "noise1" or rest == "noise1_64": return (signed, 1)
    if rest == "noise2" or rest == "noise2_64": return (signed, 2)
    if rest == "noise" or rest == "noise64": return (signed, 3)
    if rest == "noise4" or rest == "noise4_64": return (signed, 4)
    return none

## math and math32 functions that are one unary column operation.
func math_unary(name: str) -> Op?:
    let names: str[22] = ["floor", "ceil", "round", "trunc", "sqrt", "cbrt", "exp", "exp2", "log", "log2", "log10", "sin", "cos", "tan", "asin", "acos", "atan", "sinh", "cosh", "tanh", "sign", "abs"]
    let ops: Op[22] = [.floor, .ceil, .round, .trunc, .sqrt, .cbrt, .exp, .exp2, .log, .log2, .log10, .sin, .cos, .tan, .asin, .acos, .atan, .sinh, .cosh, .tanh, .sign, .abs]
    for (at, known) in names.indexed():
        if known == name:
            return ops[at]
    return none

func math_classify(name: str) -> Op?:
    if name == "is_nan": return Op.isnan
    if name == "is_infinite": return Op.isinf
    if name == "is_finite": return Op.isfinite
    return none

## Binary math functions, and math's integer helpers.
func math_binary(name: str) -> Op?:
    if name == "pow": return Op.pow
    if name == "atan2": return Op.atan2
    if name == "hypot": return Op.hypot
    if name == "mod": return Op.fmod
    if name == "min" or name == "imin": return Op.min
    if name == "max" or name == "imax": return Op.max
    if name == "iabs": return Op.abs
    return none