2015-05-19 05:54:18 +03:00
|
|
|
import reader
|
|
|
|
import printer
|
|
|
|
import types
|
|
|
|
import types.MalException
|
|
|
|
import types.MalSymbol
|
|
|
|
import types.MalFunc
|
|
|
|
import env.Env
|
|
|
|
import core
|
|
|
|
|
|
|
|
// READ
|
|
|
|
READ = { str ->
|
|
|
|
reader.read_str str
|
|
|
|
}
|
|
|
|
|
|
|
|
// EVAL
|
2022-01-10 02:15:40 +03:00
|
|
|
EVAL = { ast, env ->
|
|
|
|
while (true) {
|
|
|
|
def dbgevalenv = env.find("DEBUG-EVAL");
|
|
|
|
if (dbgevalenv != null) {
|
|
|
|
def dbgeval = env.get("DEBUG-EVAL");
|
|
|
|
if (dbgeval != null && dbgeval != false) {
|
|
|
|
println("EVAL: ${printer.pr_str(ast,true)}")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-19 05:54:18 +03:00
|
|
|
switch (ast) {
|
2022-01-10 02:15:40 +03:00
|
|
|
case MalSymbol: return env.get(ast.value);
|
|
|
|
case List: if (types.vector_Q(ast)) {
|
|
|
|
return types.vector(ast.collect { EVAL(it, env) })
|
|
|
|
}
|
|
|
|
break;
|
2015-05-19 05:54:18 +03:00
|
|
|
case Map: def new_hm = [:]
|
|
|
|
ast.each { k,v ->
|
2021-08-21 20:08:17 +03:00
|
|
|
new_hm[k] = EVAL(v, env)
|
2015-05-19 05:54:18 +03:00
|
|
|
}
|
|
|
|
return new_hm
|
|
|
|
default: return ast
|
|
|
|
}
|
|
|
|
|
2016-04-01 04:42:23 +03:00
|
|
|
if (ast.size() == 0) return ast
|
2015-05-19 05:54:18 +03:00
|
|
|
|
|
|
|
switch (ast[0]) {
|
|
|
|
case { it instanceof MalSymbol && it.value == "def!" }:
|
|
|
|
return env.set(ast[1], EVAL(ast[2], env))
|
|
|
|
case { it instanceof MalSymbol && it.value == "let*" }:
|
|
|
|
def let_env = new Env(env)
|
|
|
|
for (int i=0; i < ast[1].size(); i += 2) {
|
|
|
|
let_env.set(ast[1][i], EVAL(ast[1][i+1], let_env))
|
|
|
|
}
|
|
|
|
env = let_env
|
|
|
|
ast = ast[2]
|
|
|
|
break // TCO
|
|
|
|
case { it instanceof MalSymbol && it.value == "do" }:
|
2022-01-10 02:15:40 +03:00
|
|
|
ast.size() > 2 ? ast[1..-2].collect { EVAL(it, env) } : null
|
2015-05-19 05:54:18 +03:00
|
|
|
ast = ast[-1]
|
|
|
|
break // TCO
|
|
|
|
case { it instanceof MalSymbol && it.value == "if" }:
|
|
|
|
def cond = EVAL(ast[1], env)
|
|
|
|
if (cond == false || cond == null) {
|
|
|
|
if (ast.size > 3) {
|
|
|
|
ast = ast[3]
|
|
|
|
break // TCO
|
|
|
|
} else {
|
|
|
|
return null
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ast = ast[2]
|
|
|
|
break // TCO
|
|
|
|
}
|
|
|
|
case { it instanceof MalSymbol && it.value == "fn*" }:
|
|
|
|
return new MalFunc(EVAL, ast[2], env, ast[1])
|
|
|
|
default:
|
2022-01-10 02:15:40 +03:00
|
|
|
def el = ast.collect { EVAL(it, env) }
|
2015-05-19 05:54:18 +03:00
|
|
|
def (f, args) = [el[0], el.size() > 1 ? el[1..-1] : []]
|
|
|
|
if (f instanceof MalFunc) {
|
|
|
|
env = new Env(f.env, f.params, args)
|
|
|
|
ast = f.ast
|
|
|
|
break // TCO
|
|
|
|
} else {
|
|
|
|
return f(args)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// PRINT
|
|
|
|
PRINT = { exp ->
|
|
|
|
printer.pr_str exp, true
|
|
|
|
}
|
|
|
|
|
|
|
|
// REPL
|
|
|
|
repl_env = new Env();
|
|
|
|
REP = { str ->
|
|
|
|
PRINT(EVAL(READ(str), repl_env))
|
|
|
|
}
|
|
|
|
|
|
|
|
// core.EXT: defined using Groovy
|
|
|
|
core.ns.each { k,v ->
|
|
|
|
repl_env.set(new MalSymbol(k), v)
|
|
|
|
}
|
|
|
|
|
|
|
|
// core.mal: defined using mal itself
|
|
|
|
REP("(def! not (fn* (a) (if a false true)))")
|
|
|
|
|
|
|
|
|
|
|
|
while (true) {
|
|
|
|
line = System.console().readLine 'user> '
|
|
|
|
if (line == null) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
println REP(line)
|
|
|
|
} catch(MalException ex) {
|
Test uncaught throw, catchless try* . Fix 46 impls.
Fixes made to: ada, c, chuck, clojure, coffee, common-lisp, cpp,
crystal, d, dart, elm, erlang, es6, factor, fsharp, gnu-smalltalk,
groovy, guile, haxe, hy, js, livescript, matlab, miniMAL, nasm, nim,
objc, objpascal, ocaml, perl, perl6, php, plsql, ps, python, r,
rpython, ruby, scheme, swift3, tcl, ts, vb, vimscript, wasm, yorick.
Catchless try* test is an optional test. Not all implementations
support catchless try* but a number were fixed so they at least don't
crash on catchless try*.
2018-12-03 22:20:44 +03:00
|
|
|
println "Error: ${printer.pr_str(ex.obj, true)}"
|
2015-05-19 05:54:18 +03:00
|
|
|
} catch(StackOverflowError ex) {
|
|
|
|
println "Error: ${ex}"
|
|
|
|
} catch(ex) {
|
|
|
|
println "Error: $ex"
|
|
|
|
ex.printStackTrace()
|
|
|
|
}
|
|
|
|
}
|