Files
rexlang/examples/calc/eval.dino
T
Your NameandClaude Sonnet 5.5 eaf9567a36 Dino compiler: language, formatter, language server, docs, editor support
Compiler in Rust (lexer, parser, checker, C codegen), maps, chars,
dino fmt, dino lsp (diagnostics, formatting, outline, definition,
hover, completion, signature help), docs, examples, VS Code/Vim files.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 23:46:12 +01:00

84 lines
2.6 KiB
Plaintext

// 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
}