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>
This commit is contained in:
1 parent
3e2779f447
commit
eaf9567a36
117 files changed
+19970
No files matched your search
@@ -0,0 +1,15 @@
|
||||
// The shape of a parsed calculation.
|
||||
|
||||
pub enum Node {
|
||||
Num(value: float)
|
||||
Var(name: string)
|
||||
Neg(inner: []Node)
|
||||
Bin(op: string, sides: []Node)
|
||||
Call(name: string, args: []Node)
|
||||
Assign(name: string, value: []Node)
|
||||
}
|
||||
|
||||
// Enums can't hold themselves directly, so children live in a list of one or two.
|
||||
pub func neg(n: Node): Node { return Node.Neg([n]) }
|
||||
pub func bin(op: string, l, r: Node): Node { return Node.Bin(op, [l, r]) }
|
||||
pub func assign(name: string, v: Node): Node { return Node.Assign(name, [v]) }
|
||||
@@ -0,0 +1,83 @@
|
||||
// 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
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
import parser
|
||||
import eval
|
||||
import os
|
||||
|
||||
// Evaluates one line and prints the answer or the problem.
|
||||
func run_line(scope: shared eval.Scope, line: string) {
|
||||
var text = line.trim()
|
||||
if text == "" { return }
|
||||
var tree, err = parser.parse(text)
|
||||
if err != nil {
|
||||
print(" error:", err)
|
||||
return
|
||||
}
|
||||
var value, err2 = scope.eval(tree)
|
||||
if err2 != nil {
|
||||
print(" error:", err2)
|
||||
return
|
||||
}
|
||||
print(" =", value)
|
||||
}
|
||||
|
||||
// Reads lines from the file named on the command line, or from the keyboard.
|
||||
func main() {
|
||||
var scope = shared eval.new_scope()
|
||||
var args = os.args
|
||||
if args.len() > 1 {
|
||||
var text, err = os.read_file(args[1])
|
||||
if err != nil {
|
||||
print("cannot read", args[1], err)
|
||||
os.exit(1)
|
||||
}
|
||||
for line in text.lines() {
|
||||
print(line)
|
||||
run_line(scope, line)
|
||||
}
|
||||
return
|
||||
}
|
||||
for {
|
||||
var line = os.read_line()
|
||||
if line == nil { break }
|
||||
run_line(scope, line)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,130 @@
|
||||
// Recursive descent: assignment < + - < * / % < unary minus < ^ < calls and atoms.
|
||||
import token
|
||||
import ast
|
||||
|
||||
pub struct Parser {
|
||||
tokens: []token.Token
|
||||
at: int
|
||||
|
||||
func peek(): token.Token { return tokens[at] }
|
||||
|
||||
func next(): token.Token {
|
||||
var t = tokens[at]
|
||||
if at < tokens.len() - 1 { at += 1 }
|
||||
return t
|
||||
}
|
||||
|
||||
func is_op(text: string): bool {
|
||||
var t = peek()
|
||||
return t.kind == token.Kind.Op && t.text == text
|
||||
}
|
||||
|
||||
func expect(kind: token.Kind, what: string): error {
|
||||
if peek().kind != kind {
|
||||
return error("expected {what} at column {peek().pos + 1}")
|
||||
}
|
||||
next()
|
||||
return nil
|
||||
}
|
||||
|
||||
pub func statement(): (ast.Node, error) {
|
||||
// `name = expression`
|
||||
if peek().kind == token.Kind.Name && at + 1 < tokens.len() {
|
||||
var after = tokens[at + 1]
|
||||
if after.kind == token.Kind.Op && after.text == "=" {
|
||||
var name = next().text
|
||||
next()
|
||||
var value = sum()?
|
||||
return ast.assign(name, value), finish()
|
||||
}
|
||||
}
|
||||
var e = sum()?
|
||||
return e, finish()
|
||||
}
|
||||
|
||||
func finish(): error {
|
||||
if peek().kind != token.Kind.End {
|
||||
return error("unexpected `{peek().text}` at column {peek().pos + 1}")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func sum(): (ast.Node, error) {
|
||||
var left = product()?
|
||||
for is_op("+") || is_op("-") {
|
||||
var op = next().text
|
||||
var right = product()?
|
||||
left = ast.bin(op, left, right)
|
||||
}
|
||||
return left, nil
|
||||
}
|
||||
|
||||
func product(): (ast.Node, error) {
|
||||
var left = unary()?
|
||||
for is_op("*") || is_op("/") || is_op("%") {
|
||||
var op = next().text
|
||||
var right = unary()?
|
||||
left = ast.bin(op, left, right)
|
||||
}
|
||||
return left, nil
|
||||
}
|
||||
|
||||
func unary(): (ast.Node, error) {
|
||||
if is_op("-") {
|
||||
next()
|
||||
var inner = unary()?
|
||||
return ast.neg(inner), nil
|
||||
}
|
||||
return power()
|
||||
}
|
||||
|
||||
func power(): (ast.Node, error) {
|
||||
var base = atom()?
|
||||
if is_op("^") {
|
||||
next()
|
||||
var exp = unary()?
|
||||
return ast.bin("^", base, exp), nil
|
||||
}
|
||||
return base, nil
|
||||
}
|
||||
|
||||
func atom(): (ast.Node, error) {
|
||||
var t = next()
|
||||
match t.kind {
|
||||
Num => {
|
||||
var v, err = t.text.to_float()
|
||||
if err != nil { return ast.Node.Num(0.0), error("bad number `{t.text}` at column {t.pos + 1}") }
|
||||
return ast.Node.Num(v), nil
|
||||
}
|
||||
Name => {
|
||||
if peek().kind == token.Kind.Open {
|
||||
next()
|
||||
var args: []ast.Node
|
||||
if peek().kind != token.Kind.Close {
|
||||
args.push(sum()?)
|
||||
for is_op(",") {
|
||||
next()
|
||||
args.push(sum()?)
|
||||
}
|
||||
}
|
||||
expect(token.Kind.Close, "`)`")?
|
||||
return ast.Node.Call(t.text, args), nil
|
||||
}
|
||||
return ast.Node.Var(t.text), nil
|
||||
}
|
||||
Open => {
|
||||
var inner = sum()?
|
||||
expect(token.Kind.Close, "`)`")?
|
||||
return inner, nil
|
||||
}
|
||||
End => return ast.Node.Num(0.0), error("the calculation ends too early (column {t.pos + 1})")
|
||||
_ => return ast.Node.Num(0.0), error("unexpected `{t.text}` at column {t.pos + 1}")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub func parse(src: string): (ast.Node, error) {
|
||||
var tokens = token.tokenize(src)?
|
||||
var p = Parser{tokens, 0}
|
||||
return p.statement()
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
1 + 2 * 3
|
||||
= 7.0
|
||||
(1 + 2) * 3
|
||||
= 9.0
|
||||
-2 ^ 2
|
||||
= -4.0
|
||||
2 ^ 3 ^ 2
|
||||
= 512.0
|
||||
x = 10 / 4
|
||||
= 2.5
|
||||
x * 2 + pi
|
||||
= 8.14159265358979
|
||||
sqrt(16) + abs(-3)
|
||||
= 7.0
|
||||
max(2, 7) % 4
|
||||
= 3.0
|
||||
y
|
||||
error: unknown variable `y`
|
||||
1 / 0
|
||||
error: division by zero
|
||||
foo(1)
|
||||
error: unknown function `foo`
|
||||
sqrt(1, 2)
|
||||
error: `sqrt` takes 1 argument(s), but 2 given
|
||||
3 +
|
||||
error: the calculation ends too early (column 4)
|
||||
4 $ 4
|
||||
error: unexpected `$` at column 3
|
||||
sum(1, 2, 3) * x
|
||||
= 15.0
|
||||
@@ -0,0 +1,15 @@
|
||||
1 + 2 * 3
|
||||
(1 + 2) * 3
|
||||
-2 ^ 2
|
||||
2 ^ 3 ^ 2
|
||||
x = 10 / 4
|
||||
x * 2 + pi
|
||||
sqrt(16) + abs(-3)
|
||||
max(2, 7) % 4
|
||||
y
|
||||
1 / 0
|
||||
foo(1)
|
||||
sqrt(1, 2)
|
||||
3 +
|
||||
4 $ 4
|
||||
sum(1, 2, 3) * x
|
||||
@@ -0,0 +1,49 @@
|
||||
// Turns the text of a calculation into a list of tokens.
|
||||
|
||||
pub enum Kind {
|
||||
Num
|
||||
Name
|
||||
Op
|
||||
Open
|
||||
Close
|
||||
End
|
||||
}
|
||||
|
||||
pub struct Token {
|
||||
pub kind: Kind
|
||||
pub text: string
|
||||
pub pos: int
|
||||
}
|
||||
|
||||
pub func tokenize(src: string): ([]Token, error) {
|
||||
var tokens: []Token
|
||||
var i = 0
|
||||
for i < src.len() {
|
||||
var c = src[i]
|
||||
if c == ' ' {
|
||||
i += 1
|
||||
continue
|
||||
}
|
||||
var start = i
|
||||
if c.is_digit() || c == '.' {
|
||||
for i < src.len() && (src[i].is_digit() || src[i] == '.') { i += 1 }
|
||||
tokens.push(Token{Kind.Num, src[start..i], start})
|
||||
} else if c.is_letter() || c == '_' {
|
||||
for i < src.len() && (src[i].is_alnum() || src[i] == '_') { i += 1 }
|
||||
tokens.push(Token{Kind.Name, src[start..i], start})
|
||||
} else if "+-*/^%=,".contains(string(c)) {
|
||||
tokens.push(Token{Kind.Op, string(c), start})
|
||||
i += 1
|
||||
} else if c == '(' {
|
||||
tokens.push(Token{Kind.Open, "(", start})
|
||||
i += 1
|
||||
} else if c == ')' {
|
||||
tokens.push(Token{Kind.Close, ")", start})
|
||||
i += 1
|
||||
} else {
|
||||
return tokens, error("unexpected `{c}` at column {i + 1}")
|
||||
}
|
||||
}
|
||||
tokens.push(Token{Kind.End, "", src.len()})
|
||||
return tokens, nil
|
||||
}
|
||||
Reference in new issue
Block a user