code/parse.js

   1 // Parser for lambda with let written in Simplified JavaScript
   2 //      by Jim Pryor 2010-09-22
   3 //      Stripped down from Top Down Operator Precedence : parse.js
   4 //      http://javascript.crockford.com/tdop/index.html
   5 //      Douglas Crockford 2010-06-26
   6
   7 //      See also http://effbot.org/zone/simple-top-down-parsing.htm
   8
   9
  10 /*jslint onevar: false
  11  */
  12
  13 /*   members create, error, message, name, prototype, stringify, toSource,
  14     toString, write
  15 */
  16
  17 /*global make_var, make_app, make_lam, Lambda_var */
  18
  19 var make_parse = function () {
  20     var symbol_table = {};
  21     var token;
  22     var tokens;
  23     var token_nr;
  24
  25     var advance = function (id) {
  26         var a, o, t, v;
  27         if (id && token.id !== id) {
  28             token.error("Expected '" + id + "'.");
  29         }
  30         if (token_nr >= tokens.length) {
  31             token = symbol_table["(end)"];
  32             return;
  33         }
  34         t = tokens[token_nr];
  35         token_nr += 1;
  36         v = t.value;
  37         a = t.type;
  38         if (a === "name") {
  39             o = symbol_table[v];
  40             if (!o || typeof o === 'function') {
  41                 o = symbol_table["(name)"];
  42             } else {
  43                 a = o.arity || "keyword";
  44             }
  45         } else if (a ===  "number") {
  46             o = symbol_table["(number)"];
  47                         a = "literal";
  48         } else if (a === "operator") {
  49             o = symbol_table[v];
  50             if (!o) {
  51                 t.error("Unknown operator.");
  52             }
  53             a = "keyword";
  54         } else {
  55             t.error("Unexpected token.");
  56         }
  57         token = Object.create(o);
  58         token.from  = t.from;
  59         token.to    = t.to;
  60         token.value = v;
  61         token.arity = a; // will be: name, keyword, literal
  62         return token;
  63     };
  64
  65     var original_symbol = {
  66         handler: function () {
  67             this.error("Undefined.");
  68         }
  69     };
  70
  71         /*
  72         try {
  73                 if (console && console.debug) {
  74                         function print() {
  75                                 console.debug.apply(this, arguments);
  76                         }
  77                 }
  78         } catch (e) {}
  79         */
  80
  81     var symbol = function (id) {
  82         var s = symbol_table[id];
  83         if (!s) {
  84             s = Object.create(original_symbol);
  85             s.id = s.value = id;
  86             symbol_table[id] = s;
  87         }
  88         return s;
  89     };
  90
  91     var var_table;
  92     var name_table;
  93
  94     var name_handler = function () {
  95         var n = name_table[this.value];
  96         if (!n) {
  97             n = make_var(this.value);
  98             var_table[this.value] = n;
  99             n = new Lambda_var(n);
 100             name_table[this.value] = n;
 101         }
 102         if (this.first) {
 103             return make_app(this.first.handler(), n);
 104         } else {
 105             return n;
 106         }
 107     };
 108
 109     var branch_handler = function () {
 110         var n = this.second.handler();
 111         if (this.first) {
 112             return make_app(this.first.handler(), n);
 113         } else {
 114             return n;
 115         }
 116     };
 117
 118     var lambda_handler = function () {
 119         var body = this.second.handler();
 120         var n, v;
 121         while (this.first.length) {
 122             n = this.first.pop().value;
 123             v = var_table[n];
 124             if (!v) {
 125                 v = make_var(n);
 126                 var_table[n] = v;
 127                 name_table[n] = new Lambda_var(v);
 128             }
 129             body = make_lam(v, body);
 130         }
 131         return body;
 132     };
 133
 134     symbol("(end)");
 135     symbol("(name)").handler = name_handler;
 136     symbol("let").handler = lambda_handler;
 137     symbol("=").handler = branch_handler;
 138     symbol("in");
 139     symbol(")").handler = branch_handler;
 140     symbol("(");
 141     symbol("\\").handler = lambda_handler;
 142     symbol("lambda").handler = lambda_handler;
 143     symbol("\u03bb").handler = lambda_handler;
 144     // symbol("\u2203").handler = exists_handler;
 145     // symbol("\u2200").handler = forall_handler;
 146     symbol(".");
 147
 148         function make_constants() {
 149
 150                 function make_lam2(a, b, aa) {
 151                         return make_lam(a, make_lam(b, aa));
 152                 }
 153                 function make_lam3(a, b, c, aa) {
 154                         return make_lam(a, make_lam(b, make_lam(c, aa)));
 155                 }
 156                 function make_app3(aa, bb, cc) {
 157                         return make_app(make_app(aa, bb), cc);
 158                 }
 159                 var u = make_var("u");
 160                 var v = make_var("v");
 161                 var x = make_var("x");
 162                 var s = make_var("s");
 163                 var z = make_var("z");
 164                 var uu = new Lambda_var(u);
 165                 var vv = new Lambda_var(v);
 166                 var xx = new Lambda_var(x);
 167                 var ss = new Lambda_var(s);
 168                 var zz = new Lambda_var(z);
 169                 var_table = { u: u, v: v, x: x, s: s, z: z};
 170                 name_table = {u: uu, v: vv, x: xx, s: ss, z: zz};
 171                 number_table = {};
 172
 173                 // constants have their own id and arity = literal
 174                 // numbers have id = "(number)" and arity = literal
 175                 symbol("(number)").handler = function () {
 176                         var n = this.value;
 177                         var res = number_table[n];
 178                         if (!res) {
 179                                 res = zz;
 180                                 while (n > 0) {
 181                                         n -= 1;
 182                                         res = make_app(ss, res);
 183                                 }
 184                                 res = make_lam2(s, z, res);
 185                                 number_table[this.value] = res;
 186                         }
 187                         if (this.first) {
 188                                 return make_app(this.first.handler(), res);
 189                         } else {
 190                                 return res;
 191                         }
 192                 }
 193
 194                 var constant = function (s, v) {
 195                         var x = symbol(s);
 196                         x.handler = function () {
 197                                 this.value = symbol_table[this.id].value;
 198                                 if (this.first) {
 199                                         return make_app(this.first.handler(), this.value);
 200                                 } else {
 201                                         return this.value;
 202                                 }
 203                         };
 204                         x.arity = "literal";
 205                         x.value = v;
 206                         return x;
 207                 };
 208
 209                 constant("S", make_lam3(u, v, x, make_app3(uu, xx, make_app(vv, xx))));
 210                 constant("K", make_lam2(u, v, uu));
 211                 constant("I", make_lam(x, xx));
 212                 constant("B", make_lam3(u, v, x, make_app(uu, make_app(vv, xx))));
 213                 constant("C", make_lam3(u, v, x, make_app3(uu, xx, vv)));
 214
 215                 // trush \uv.vu = CI
 216                 constant("T", make_lam2(u, v, make_app(vv, uu)));
 217                 // mockingbird \u.uu = SII
 218                 constant("M", make_lam(u, make_app(uu, uu)));
 219                 // warbler \uv.uvv = C(BM(BBT) = C(BS(C(BBI)I))I
 220                 constant("W", make_lam2(u, v, make_app3(uu, vv, vv)));
 221                 // lark \uv.u(vv) = CBM = BWB
 222                 constant("L", make_lam2(u, v, make_app(uu, make_app(vv, vv))));
 223                 // Y is SLL
 224
 225         }
 226         make_constants();
 227
 228     var expression = function (in_let) {
 229         var t, n;
 230         if (token.id === "\\" || token.id === "lambda") {
 231             token.value = "lambda";
 232             t = token;
 233             advance();
 234             n = token;
 235             if (n.arity !== "name") {
 236                 n.error("Expected a variable name.");
 237             }
 238             advance();
 239             if (token.id === "(") {
 240                 t.first = [n];
 241                 advance();
 242                 t.second = expression(false);
 243                 advance(")");
 244                 return t;
 245             } else {
 246                 t.first = [];
 247                 while (token.arity === "name" || token.id === "\\") {
 248                     if (token.id !== "\\") {
 249                       t.first.push(n);
 250                       n = token;
 251                     }
 252                     advance();
 253                 }
 254                                 if (token.arity === "literal" && t.first.length === 0) {
 255                                         t.first.push(n);
 256                                         t.second = token;
 257                                         advance();
 258                                 } else if (token.id === ".") {
 259                     t.first.push(n);
 260                     advance();
 261                     t.second = expression(in_let);
 262                 } else if (t.first.length === 1) {
 263                     t.second = n;
 264                 } else {
 265                     t.first.push(n);
 266                     t.error("Can't parse lambda abstract.");
 267                 }
 268                 return t;
 269             }
 270         } else {
 271             n = null;
 272             while (token.id === "(") {
 273                 advance();
 274                 t = expression(false);
 275                 token.first = n;
 276                 token.second = t;
 277                 n = token;
 278                 advance(")");
 279                 if (in_let && token.id === "let" || token.id === "(end)" || token.id === ")") {
 280                     return n;
 281                 }
 282             }
 283             while (true) {
 284                                 if (n && (in_let && token.id === "in" || token.id === "(end)" || token.id === ")")) {
 285                     return n;
 286                 } else if (token.id === "(") {
 287                     advance();
 288                     t = expression(false);
 289                     token.first = n;
 290                     token.second = t;
 291                     n = token;
 292                     advance(")");
 293                 } else {
 294                     if (token.arity !== "name" && token.arity !== "literal") {
 295                         token.error("Expected a variable name or literal.");
 296                     }
 297                     token.first = n;
 298                     n = token;
 299                     advance();
 300                 }
 301             }
 302         }
 303         };
 304
 305     return function (source) {
 306         tokens = source.tokens();
 307         token_nr = 0;
 308         advance();
 309
 310         // let n = c in b
 311         // (\n. b) c
 312
 313         var t = null, eq, c, base = {};
 314         var target = base;
 315
 316         while (token.id === "let") {
 317             t = token;
 318             advance();
 319             if (token.arity !== "name") {
 320                 token.error("Expected a variable name.");
 321             }
 322             t.first = [token];
 323             advance();
 324             eq = token; // token.id === "="
 325             advance("=");
 326             c = expression(true);
 327
 328                         eq.first = t;
 329                         eq.second = c;
 330                         target.second = eq;
 331
 332 //             c.first = eq;
 333 //             eq.second = t;
 334 //             target.second = c;
 335
 336             target = t;
 337             advance("in");
 338         }
 339
 340         target.second = expression(false);
 341
 342         advance("(end)");
 343         return base.second;
 344     };
 345
 346 };
 347