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
|
|
|
|
macro_Q = { ast, env ->
|
|
|
|
if (types.list_Q(ast) &&
|
2016-04-01 04:42:23 +03:00
|
|
|
ast.size() > 0 &&
|
2015-05-19 05:54:18 +03:00
|
|
|
ast[0].class == MalSymbol &&
|
|
|
|
env.find(ast[0])) {
|
|
|
|
def obj = env.get(ast[0])
|
|
|
|
if (obj instanceof MalFunc && obj.ismacro) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
macroexpand = { ast, env ->
|
|
|
|
while (macro_Q(ast, env)) {
|
|
|
|
def mac = env.get(ast[0])
|
|
|
|
ast = mac(ast.drop(1))
|
|
|
|
}
|
|
|
|
return ast
|
|
|
|
}
|
|
|
|
|
2020-07-21 19:01:48 +03:00
|
|
|
starts_with = { lst, sym ->
|
|
|
|
lst.size() == 2 && lst[0].class == MalSymbol && lst[0].value == sym
|
|
|
|
}
|
|
|
|
qq_loop = { elt, acc ->
|
|
|
|
if (types.list_Q(elt) && starts_with(elt, "splice-unquote")) {
|
|
|
|
return [new MalSymbol("concat"), elt[1], acc]
|
2015-05-19 05:54:18 +03:00
|
|
|
} else {
|
2020-07-21 19:01:48 +03:00
|
|
|
return [new MalSymbol("cons"), quasiquote(elt), acc]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
qq_foldr = { xs ->
|
|
|
|
def acc = []
|
|
|
|
for (int i=xs.size()-1; 0<=i; i-=1) {
|
|
|
|
acc = qq_loop(xs[i], acc)
|
|
|
|
}
|
|
|
|
return acc
|
|
|
|
}
|
|
|
|
quasiquote = { ast ->
|
|
|
|
switch (ast) {
|
|
|
|
case List:
|
|
|
|
if (types.vector_Q(ast)) {
|
|
|
|
return [new MalSymbol("vec"), qq_foldr(ast)]
|
|
|
|
} else if (starts_with(ast, "unquote")) {
|
|
|
|
return ast[1]
|
|
|
|
} else {
|
|
|
|
return qq_foldr(ast)
|
|
|
|
}
|
|
|
|
case MalSymbol: return [new MalSymbol("quote"), ast]
|
|
|
|
case Map: return [new MalSymbol("quote"), ast]
|
|
|
|
default: return ast
|
2015-05-19 05:54:18 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
eval_ast = { ast, env ->
|
|
|
|
switch (ast) {
|
|
|
|
case MalSymbol: return env.get(ast);
|
|
|
|
case List: return types.vector_Q(ast) ?
|
|
|
|
types.vector(ast.collect { EVAL(it,env) }) :
|
|
|
|
ast.collect { EVAL(it,env) }
|
|
|
|
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
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
EVAL = { ast, env ->
|
|
|
|
while (true) {
|
|
|
|
//println("EVAL: ${printer.pr_str(ast,true)}")
|
|
|
|
if (! types.list_Q(ast)) return eval_ast(ast, env)
|
|
|
|
|
|
|
|
ast = macroexpand(ast, env)
|
2016-01-26 23:15:16 +03:00
|
|
|
if (! types.list_Q(ast)) return eval_ast(ast, env)
|
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 == "quote" }:
|
|
|
|
return ast[1]
|
2020-07-21 19:01:48 +03:00
|
|
|
case { it instanceof MalSymbol && it.value == "quasiquoteexpand" }:
|
|
|
|
return quasiquote(ast[1])
|
2015-05-19 05:54:18 +03:00
|
|
|
case { it instanceof MalSymbol && it.value == "quasiquote" }:
|
|
|
|
ast = quasiquote(ast[1])
|
|
|
|
break // TCO
|
|
|
|
case { it instanceof MalSymbol && it.value == "defmacro!" }:
|
|
|
|
def f = EVAL(ast[2], env)
|
2021-08-20 14:12:35 +03:00
|
|
|
f = f.clone()
|
2015-05-19 05:54:18 +03:00
|
|
|
f.ismacro = true
|
|
|
|
return env.set(ast[1], f)
|
|
|
|
case { it instanceof MalSymbol && it.value == "macroexpand" }:
|
|
|
|
return macroexpand(ast[1], env)
|
|
|
|
case { it instanceof MalSymbol && it.value == "try*" }:
|
|
|
|
try {
|
|
|
|
return EVAL(ast[1], env)
|
|
|
|
} catch(exc) {
|
|
|
|
if (ast.size() > 2 &&
|
|
|
|
ast[2][0] instanceof MalSymbol &&
|
|
|
|
ast[2][0].value == "catch*") {
|
|
|
|
def e = null
|
|
|
|
if (exc instanceof MalException) {
|
|
|
|
e = exc.obj
|
|
|
|
} else {
|
|
|
|
e = exc.message
|
|
|
|
}
|
|
|
|
return EVAL(ast[2][2], new Env(env, [ast[2][1]], [e]))
|
|
|
|
} else {
|
|
|
|
throw exc
|
|
|
|
}
|
|
|
|
}
|
|
|
|
case { it instanceof MalSymbol && it.value == "do" }:
|
|
|
|
ast.size() > 2 ? eval_ast(ast[1..-2], env) : null
|
|
|
|
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:
|
|
|
|
def el = eval_ast(ast, env)
|
|
|
|
def (f, args) = [el[0], el.drop(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)
|
|
|
|
}
|
|
|
|
repl_env.set(new MalSymbol("eval"), { a -> EVAL(a[0], repl_env)})
|
|
|
|
repl_env.set(new MalSymbol("*ARGV*"), this.args as List)
|
|
|
|
|
|
|
|
// core.mal: defined using mal itself
|
|
|
|
REP("(def! not (fn* (a) (if a false true)))")
|
2019-07-16 00:57:02 +03:00
|
|
|
REP("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \"\nnil)\")))))")
|
2015-05-19 05:54:18 +03:00
|
|
|
REP("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))");
|
|
|
|
|
|
|
|
|
|
|
|
if (this.args.size() > 0) {
|
|
|
|
repl_env.set(new MalSymbol("*ARGV*"), this.args.drop(1) as List)
|
|
|
|
REP("(load-file \"${this.args[0]}\")")
|
|
|
|
System.exit(0)
|
|
|
|
}
|
|
|
|
|
|
|
|
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()
|
|
|
|
}
|
|
|
|
}
|