scala/step9_try.scala

   1 import types.{MalList, _list, _list_Q, MalVector, MalHashMap,
   2               Func, MalFunction}
   3 import env.Env
   4
   5 object step9_try {
   6   // read
   7   def READ(str: String): Any = {
   8     reader.read_str(str)
   9   }
  10
  11   // eval
  12   def is_pair(x: Any): Boolean = {
  13     types._sequential_Q(x) && x.asInstanceOf[MalList].value.length > 0
  14   }
  15
  16   def quasiquote(ast: Any): Any = {
  17     if (!is_pair(ast)) {
  18       return _list(Symbol("quote"), ast)
  19     } else {
  20       val a0 = ast.asInstanceOf[MalList](0)
  21       if (types._symbol_Q(a0) &&
  22           a0.asInstanceOf[Symbol].name == "unquote") {
  23         return ast.asInstanceOf[MalList](1)
  24       } else if (is_pair(a0)) {
  25         val a00 = a0.asInstanceOf[MalList](0)
  26         if (types._symbol_Q(a00) &&
  27             a00.asInstanceOf[Symbol].name == "splice-unquote") {
  28           return _list(Symbol("concat"),
  29                        a0.asInstanceOf[MalList](1),
  30                        quasiquote(ast.asInstanceOf[MalList].drop(1)))
  31         }
  32       }
  33       return _list(Symbol("cons"),
  34                    quasiquote(a0),
  35                    quasiquote(ast.asInstanceOf[MalList].drop(1)))
  36     }
  37   }
  38
  39   def is_macro_call(ast: Any, env: Env): Boolean = {
  40     ast match {
  41       case ml: MalList => {
  42         if (types._symbol_Q(ml(0)) &&
  43             env.find(ml(0).asInstanceOf[Symbol]) != null) {
  44           env.get(ml(0).asInstanceOf[Symbol]) match {
  45             case f: MalFunction => return f.ismacro
  46             case _ => return false
  47           }
  48         }
  49         return false
  50       }
  51       case _ => return false
  52     }
  53   }
  54
  55   def macroexpand(orig_ast: Any, env: Env): Any = {
  56     var ast = orig_ast;
  57     while (is_macro_call(ast, env)) {
  58       ast.asInstanceOf[MalList].value match {
  59         case f :: args => {
  60           val mac = env.get(f.asInstanceOf[Symbol])
  61           ast = mac.asInstanceOf[MalFunction](args)
  62         }
  63         case _ => throw new Exception("macroexpand: invalid call")
  64       }
  65     }
  66     ast
  67   }
  68
  69   def eval_ast(ast: Any, env: Env): Any = {
  70     ast match {
  71       case s : Symbol    => env.get(s)
  72       case v: MalVector  => v.map(EVAL(_, env))
  73       case l: MalList    => l.map(EVAL(_, env))
  74       case m: MalHashMap => {
  75         m.map{case (k,v) => (k, EVAL(v, env))}
  76       }
  77       case _             => ast
  78     }
  79   }
  80
  81   def EVAL(orig_ast: Any, orig_env: Env): Any = {
  82    var ast = orig_ast; var env = orig_env;
  83    while (true) {
  84
  85     //println("EVAL: " + printer._pr_str(ast,true))
  86     if (!_list_Q(ast))
  87       return eval_ast(ast, env)
  88
  89     // apply list
  90     ast = macroexpand(ast, env)
  91     if (!_list_Q(ast))
  92       return eval_ast(ast, env)
  93
  94     ast.asInstanceOf[MalList].value match {
  95       case Symbol("def!") :: a1 :: a2 :: Nil => {
  96         return env.set(a1.asInstanceOf[Symbol], EVAL(a2, env))
  97       }
  98       case Symbol("let*") :: a1 :: a2 :: Nil => {
  99         val let_env = new Env(env)
 100         for (g <- a1.asInstanceOf[MalList].value.grouped(2)) {
 101           let_env.set(g(0).asInstanceOf[Symbol],EVAL(g(1),let_env))
 102         }
 103         env = let_env
 104         ast = a2   // continue loop (TCO)
 105       }
 106       case Symbol("quote") :: a1 :: Nil => {
 107         return a1
 108       }
 109       case Symbol("quasiquote") :: a1 :: Nil => {
 110         ast = quasiquote(a1)  // continue loop (TCO)
 111       }
 112       case Symbol("defmacro!") :: a1 :: a2 :: Nil => {
 113         val f = EVAL(a2, env)
 114         f.asInstanceOf[MalFunction].ismacro = true
 115         return env.set(a1.asInstanceOf[Symbol], f)
 116       }
 117       case Symbol("macroexpand") :: a1 :: Nil => {
 118         return macroexpand(a1, env)
 119       }
 120       case Symbol("try*") :: a1 :: rest => {
 121         try {
 122           return EVAL(a1, env)
 123         } catch {
 124           case t: Throwable => {
 125             rest(0).asInstanceOf[MalList].value match {
 126               case List(Symbol("catch*"), a21, a22) => {
 127                 val exc: Any = t match {
 128                   case mex: types.MalException => mex.value
 129                   case _ => t.getMessage
 130                 }
 131                 return EVAL(a22, new Env(env,
 132                                          List(a21).iterator,
 133                                          List(exc).iterator))
 134               }
 135             }
 136             throw t
 137           }
 138         }
 139       }
 140       case Symbol("do") :: rest => {
 141         eval_ast(_list(rest.slice(0,rest.length-1):_*), env)
 142         ast = ast.asInstanceOf[MalList].value.last  // continue loop (TCO)
 143       }
 144       case Symbol("if") :: a1 :: a2 :: rest => {
 145         val cond = EVAL(a1, env)
 146         if (cond == null || cond == false) {
 147           if (rest.length == 0) return null
 148           ast = rest(0)  // continue loop (TCO)
 149         } else {
 150           ast = a2  // continue loop (TCO)
 151         }
 152       }
 153       case Symbol("fn*") :: a1 :: a2 :: Nil => {
 154         return new MalFunction(a2, env, a1.asInstanceOf[MalList],
 155           (args: List[Any]) => {
 156             EVAL(a2, new Env(env, types._toIter(a1), args.iterator))
 157           }
 158         )
 159       }
 160       case _ => {
 161         // function call
 162         eval_ast(ast, env).asInstanceOf[MalList].value match {
 163           case f :: el => {
 164             f match {
 165               case fn: MalFunction => {
 166                 env = fn.gen_env(el)
 167                 ast = fn.ast  // continue loop (TCO)
 168               }
 169               case fn: Func => {
 170                 return fn(el)
 171               }
 172               case _ => {
 173                 throw new Exception("attempt to call non-function: " + f)
 174               }
 175             }
 176           }
 177           case _ => throw new Exception("invalid apply")
 178         }
 179       }
 180     }
 181    }
 182   }
 183
 184   // print
 185   def PRINT(exp: Any): String = {
 186     printer._pr_str(exp, true)
 187   }
 188
 189   // repl
 190   def main(args: Array[String]) = {
 191     val repl_env: Env = new Env()
 192     val REP = (str: String) => PRINT(EVAL(READ(str), repl_env))
 193
 194     // core.scala: defined using scala
 195     core.ns.map{case (k: String,v: Any) => {
 196       repl_env.set(Symbol(k), new Func(v))
 197     }}
 198     repl_env.set(Symbol("eval"), new Func((a: List[Any]) => EVAL(a(0), repl_env)))
 199     repl_env.set(Symbol("*ARGV*"), _list(args.slice(1,args.length):_*))
 200
 201     // core.mal: defined using the language itself
 202     REP("(def! not (fn* (a) (if a false true)))")
 203     REP("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
 204     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)))))))")
 205     REP("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
 206
 207
 208     if (args.length > 0) {
 209       REP("(load-file \"" + args(0) + "\")")
 210       System.exit(0)
 211     }
 212
 213     // repl loop
 214     var line:String = null
 215     while ({line = readLine("user> "); line != null}) {
 216       try {
 217         println(REP(line))
 218       } catch {
 219         case e : Throwable => {
 220           println("Error: " + e.getMessage)
 221           println("    " + e.getStackTrace.mkString("\n    "))
 222         }
 223       }
 224     }
 225   }
 226 }
 227
 228 // vim: ts=2:sw=2