js/stepA_more.js

   1 if (typeof module !== 'undefined') {
   2     var types = require('./types');
   3     var readline = require('./node_readline');
   4     var reader = require('./reader');
   5     var printer = require('./printer');
   6     var Env = require('./env').Env;
   7     var core = require('./core');
   8 }
   9
  10 // read
  11 function READ(str) {
  12     return reader.read_str(str);
  13 }
  14
  15 // eval
  16 function is_pair(x) {
  17     return types._sequential_Q(x) && x.length > 0;
  18 }
  19
  20 function quasiquote(ast) {
  21     if (!is_pair(ast)) {
  22         return [types._symbol("quote"), ast];
  23     } else if (ast[0].value === 'unquote') {
  24         return ast[1];
  25     } else if (is_pair(ast[0]) && ast[0][0].value === 'splice-unquote') {
  26         return [types._symbol("concat"),
  27                 ast[0][1],
  28                 quasiquote(ast.slice(1))];
  29     } else {
  30         return [types._symbol("cons"),
  31                 quasiquote(ast[0]),
  32                 quasiquote(ast.slice(1))];
  33     }
  34 }
  35
  36 function is_macro_call(ast, env) {
  37     return types._list_Q(ast) &&
  38            types._symbol_Q(ast[0]) &&
  39            env.find(ast[0].value) &&
  40            env.get(ast[0].value)._ismacro_;
  41 }
  42
  43 function macroexpand(ast, env) {
  44     while (is_macro_call(ast, env)) {
  45         var mac = env.get(ast[0]);
  46         ast = mac.apply(mac, ast.slice(1));
  47     }
  48     return ast;
  49 }
  50
  51 function eval_ast(ast, env) {
  52     if (types._symbol_Q(ast)) {
  53         return env.get(ast);
  54     } else if (types._list_Q(ast)) {
  55         return ast.map(function(a) { return EVAL(a, env); });
  56     } else if (types._vector_Q(ast)) {
  57         var v = ast.map(function(a) { return EVAL(a, env); });
  58         v.__isvector__ = true;
  59         return v;
  60     } else if (types._hash_map_Q(ast)) {
  61         var new_hm = {};
  62         for (k in ast) {
  63             new_hm[EVAL(k, env)] = EVAL(ast[k], env);
  64         }
  65         return new_hm;
  66     } else {
  67         return ast;
  68     }
  69 }
  70
  71 function _EVAL(ast, env) {
  72     while (true) {
  73
  74     //printer.println("EVAL:", types._pr_str(ast, true));
  75     if (!types._list_Q(ast)) {
  76         return eval_ast(ast, env);
  77     }
  78
  79     // apply list
  80     ast = macroexpand(ast, env);
  81     if (!types._list_Q(ast)) { return ast; }
  82
  83     var a0 = ast[0], a1 = ast[1], a2 = ast[2], a3 = ast[3];
  84     switch (a0.value) {
  85     case "def!":
  86         var res = EVAL(a2, env);
  87         return env.set(a1, res);
  88     case "let*":
  89         var let_env = new Env(env);
  90         for (var i=0; i < a1.length; i+=2) {
  91             let_env.set(a1[i].value, EVAL(a1[i+1], let_env));
  92         }
  93         return EVAL(a2, let_env);
  94     case "quote":
  95         return a1;
  96     case "quasiquote":
  97         return EVAL(quasiquote(a1), env);
  98     case 'defmacro!':
  99         var func = EVAL(a2, env);
 100         func._ismacro_ = true;
 101         return env.set(a1, func);
 102     case 'macroexpand':
 103         return macroexpand(a1, env);
 104     case "js*":
 105         return eval(a1.toString());
 106     case ".":
 107         var el = eval_ast(ast.slice(2), env),
 108             f = eval(a1.toString());
 109         return f.apply(f, el);
 110     case "try*":
 111         try {
 112             return EVAL(a1, env);
 113         } catch (exc) {
 114             if (a2 && a2[0].value === "catch*") {
 115                 if (exc instanceof Error) { exc = exc.message; }
 116                 return EVAL(a2[2], new Env(env, [a2[1]], [exc]));
 117             } else {
 118                 throw exc;
 119             }
 120         }
 121     case "do":
 122         eval_ast(ast.slice(1, -1), env);
 123         ast = ast[ast.length-1];
 124         break;
 125     case "if":
 126         var cond = EVAL(a1, env);
 127         if (cond === null || cond === false) {
 128             ast = (typeof a3 !== "undefined") ? a3 : null;
 129         } else {
 130             ast = a2;
 131         }
 132         break;
 133     case "fn*":
 134         return types._function(EVAL, Env, a2, env, a1);
 135     default:
 136         var el = eval_ast(ast, env), f = el[0];
 137         if (f.__ast__) {
 138             ast = f.__ast__;
 139             env = f.__gen_env__(el.slice(1));
 140         } else {
 141             return f.apply(f, el.slice(1));
 142         }
 143     }
 144
 145     }
 146 }
 147
 148 function EVAL(ast, env) {
 149     var result = _EVAL(ast, env);
 150     return (typeof result !== "undefined") ? result : null;
 151 }
 152
 153 // print
 154 function PRINT(exp) {
 155     return printer._pr_str(exp, true);
 156 }
 157
 158 // repl
 159 var repl_env = new Env();
 160 var rep = function(str) { return PRINT(EVAL(READ(str), repl_env)); };
 161 _ref = function (k,v) { repl_env.set(k, v); }
 162
 163 // Import core functions
 164 for (var n in core.ns) { repl_env.set(n, core.ns[n]); }
 165
 166 _ref('readline', readline.readline)
 167 _ref('read-string', reader.read_str);
 168 _ref('eval', function(ast) { return EVAL(ast, repl_env); });
 169 _ref('slurp', function(f) {
 170     return require('fs').readFileSync(f, 'utf-8');
 171 });
 172
 173 // Defined using the language itself
 174 rep("(def! not (fn* (a) (if a false true)))");
 175 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)))))))");
 176 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))))))))");
 177 rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))");
 178
 179 if (typeof process !== 'undefined' && process.argv.length > 2) {
 180     for (var i=2; i < process.argv.length; i++) {
 181         rep('(load-file "' + process.argv[i] + '")');
 182     }
 183 } else if (typeof require === 'undefined') {
 184     // Asynchronous browser mode
 185     readline.rlwrap(function(line) { return rep(line); },
 186                     function(exc) {
 187                         if (exc instanceof reader.BlankException) { return; }
 188                         if (exc.stack) { printer.println(exc.stack); }
 189                         else           { printer.println(exc); }
 190                     });
 191 } else if (require.main === module) {
 192     // Synchronous node.js commandline mode
 193     while (true) {
 194         var line = readline.readline("user> ");
 195         if (line === null) { break; }
 196         try {
 197             if (line) { printer.println(rep(line)); }
 198         } catch (exc) {
 199             if (exc instanceof reader.BlankException) { continue; }
 200             if (exc.stack) { printer.println(exc.stack); }
 201             else           { printer.println(exc); }
 202         }
 203     }
 204 } else {
 205     exports.rep = rep;
 206 }