Files use .rex, the command is rex, and the crate, runtime prefixes, docs, editor files and examples all use the new name. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
84 lines
2.6 KiB
Rexx
84 lines
2.6 KiB
Rexx
// Evaluates a parsed calculation. Variables and functions live in `Scope`.
|
|
import ast
|
|
import math
|
|
|
|
pub struct Builtin {
|
|
pub name: string
|
|
pub arity: int
|
|
pub run: func([]float): float
|
|
}
|
|
|
|
pub struct Scope {
|
|
variables: map[string, float]
|
|
builtins: map[string, Builtin]
|
|
|
|
pub func set(name: string, v: float) {
|
|
variables[name] = v
|
|
}
|
|
|
|
pub func eval(n: ast.Node): (float, error) {
|
|
match n {
|
|
Num(v) => return v, nil
|
|
Var(name) => {
|
|
var v = variables.get(name)
|
|
if v == nil { return 0.0, error("unknown variable `{name}`") }
|
|
return v, nil
|
|
}
|
|
Neg(inner) => {
|
|
var x = eval(inner[0])?
|
|
return -x, nil
|
|
}
|
|
Assign(name, value) => {
|
|
var x = eval(value[0])?
|
|
set(name, x)
|
|
return x, nil
|
|
}
|
|
Bin(op, sides) => {
|
|
var a = eval(sides[0])?
|
|
var b = eval(sides[1])?
|
|
return apply(op, a, b)
|
|
}
|
|
Call(name, args) => {
|
|
if !builtins.has(name) { return 0.0, error("unknown function `{name}`") }
|
|
var b = builtins[name]
|
|
if args.len() != b.arity {
|
|
return 0.0, error("`{name}` takes {b.arity} argument(s), but {args.len()} given")
|
|
}
|
|
var vals: []float
|
|
for a in args { vals.push(eval(a)?) }
|
|
return b.run(vals), nil
|
|
}
|
|
}
|
|
}
|
|
|
|
func apply(op: string, a, b: float): (float, error) {
|
|
match op {
|
|
"+" => return a + b, nil
|
|
"-" => return a - b, nil
|
|
"*" => return a * b, nil
|
|
"/" => {
|
|
if b == 0.0 { return 0.0, error("division by zero") }
|
|
return a / b, nil
|
|
}
|
|
"%" => {
|
|
if b == 0.0 { return 0.0, error("division by zero") }
|
|
return a - b * math.floor(a / b), nil
|
|
}
|
|
"^" => return math.pow(a, b), nil
|
|
_ => return 0.0, error("unknown operator `{op}`")
|
|
}
|
|
}
|
|
}
|
|
|
|
pub func new_scope(): Scope {
|
|
var s = Scope{}
|
|
s.builtins["sqrt"] = Builtin{"sqrt", 1, a => math.sqrt(a[0])}
|
|
s.builtins["abs"] = Builtin{"abs", 1, a => math.abs(a[0])}
|
|
s.builtins["max"] = Builtin{"max", 2, a => math.max(a[0], a[1])}
|
|
s.builtins["min"] = Builtin{"min", 2, a => math.min(a[0], a[1])}
|
|
s.builtins["sum"] = Builtin{"sum", 3, a => a[0] + a[1] + a[2]}
|
|
s.set("pi", math.PI)
|
|
s.set("e", math.E)
|
|
return s
|
|
}
|