repos/tabletprog: interp.js annotate

annotate interp.js @ 216:2dac67e9d18b

Add -m flag to compiler driver to select macro expansion only

author	Michael Pavone <pavone@retrodev.com>
date	Sat, 21 Dec 2013 12:07:00 -0800
parents	e00a8bc6361b
children	adad61ea2f3a

rev	line source
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	1 Number.prototype['tpmeth_+'] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	2 return this + other;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	3 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	4 Number.prototype['tpmeth_-'] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	5 return this - other;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	6 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	7 Number.prototype['tpmeth_*'] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	8 return this * other;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	9 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	10 Number.prototype['tpmeth_/'] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	11 return this / other;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	12 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	13 Number.prototype['tpmeth_='] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	14 return this == other ? tptrue : tpfalse;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	15 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	16 Number.prototype['tpmeth_>'] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	17 return this > other ? tptrue : tpfalse;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	18 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	19 Number.prototype['tpmeth_<'] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	20 return this < other ? tptrue : tpfalse;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	21 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	22 Number.prototype['tpmeth_>='] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	23 return this >= other ? tptrue : tpfalse;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	24 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	25 Number.prototype['tpmeth_<='] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	26 return this <= other ? tptrue : tpfalse;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	27 };
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	28 Number.prototype.tpmeth_asStringChar = function() {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	29 return String.fromCharCode(this);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	30 };
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	31 Number.prototype['tpmeth_isString?'] = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	32 return false;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	33 };
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	34 Number.prototype.tpmeth_string = function() {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	35 return '' + this;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	36 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	37 Number.prototype.tpmeth_print = function() {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	38 print(this);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	39 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	40
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	41 String.prototype['tpmeth_.'] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	42 return this + other;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	43 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	44 String.prototype['tpmeth_='] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	45 return this == other ? tptrue : tpfalse;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	46 };
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	47 String.prototype.tpmeth_length = function() {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	48 return this.length;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	49 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	50 String.prototype.tpmeth_byte_length = function() {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	51 return this.length;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	52 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	53 String.prototype.tpmeth_byte = function(index) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	54 return this.charCodeAt(index);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	55 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	56 String.prototype['tpmeth_from:withLength'] = function(pos, length) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	57 return this.substr(pos, length);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	58 };
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	59 String.prototype['tpmeth_isString?'] = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	60 return true;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	61 };
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	62 String.prototype.tpmeth_print = function() {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	63 print(this);
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	64 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	65
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	66 Function.prototype['tpmeth_while:do'] = function(body) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	67 var ret = null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	68 for (;;) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	69 var res = this.call(null);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	70 if (res != tptrue) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	71 break;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	72 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	73 ret = body.call(null);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	74 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	75 return ret;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	76 };
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	77
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	78 var tptrue = null;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	79 var tpfalse = null;
210 d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	80 var tplist = null;
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	81
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	82 function topenv(moduledirs)
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	83 {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	84 this.names = {};
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	85 this.modules = {};
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	86 for (var dirnum in moduledirs) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	87 var results = os.system("ls", [moduledirs[dirnum]]).split('\n');
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	88 for (var i in results) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	89 var tpidx = results[i].indexOf('.tp')
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	90 if (tpidx > 0 && tpidx == results[i].length - 3) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	91 this.names[results[i].substr(0, tpidx)] = moduledirs[dirnum] + "/" + results[i];
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	92 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	93 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	94 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	95 if (!tptrue) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	96 tptrue = this.find('true');
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	97 tptrue.valueOf = function() {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	98 return true;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	99 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	100 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	101 if (!tpfalse) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	102 tpfalse = this.find('false');
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	103 tpfalse.valueOf = function() {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	104 return false;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	105 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	106 }
210 d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	107 if (!tplist) {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	108 tplist = this.find('list');
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	109 if (tplist instanceof Function) {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	110 tplist = tplist.call(null);
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	111 }
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	112 }
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	113 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	114
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	115 topenv.prototype = {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	116 find: function(name) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	117 if (name in this.modules) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	118 return this.modules[name];
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	119 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	120 if (name in this.names) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	121 var parsed = parseFile(this.names[name]);
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	122 this.modules[name] = parsed.macroexpand(this).eval(this);
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	123 return this.modules[name];
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	124 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	125 return null;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	126 },
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	127 findNoTop: function(name) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	128 return null;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	129 },
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	130 findSetPresent: function(name, val) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	131 return false;
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	132 },
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	133 findMacro: function(name) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	134 return null;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	135 },
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	136 findQuoteTrans: function(name) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	137 return null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	138 }
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	139 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	140
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	141 function environment(parent)
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	142 {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	143 this.parent = parent;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	144 this.syms = {};
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	145 this.macros = {};
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	146 this.quotetrans = {};
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	147 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	148
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	149 environment.prototype = {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	150 find: function(name) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	151 if (name in this.syms) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	152 return this.syms[name];
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	153 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	154 if (this.parent) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	155 return this.parent.find(name);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	156 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	157 return null;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	158 },
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	159 findNoTop: function(name) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	160 if (name in this.syms) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	161 return this.syms[name];
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	162 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	163 if (this.parent) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	164 return this.parent.findNoTop(name);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	165 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	166 return null;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	167 },
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	168 findSet: function(name, val) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	169 if (name in this.syms
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	170 \|\| !this.parent
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	171 \|\| !this.parent.findSetPresent(name, val)) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	172 this.syms[name] = val;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	173 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	174 },
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	175 findSetPresent: function(name, val) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	176 if (name in this.syms) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	177 this.syms[name] = val;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	178 return true;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	179 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	180 if (this.parent) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	181 return this.parent.findSetPresent(name, val);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	182 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	183 return false;
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	184 },
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	185 findMacro: function(name) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	186 if (name in this.syms) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	187 if (name in this.macros) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	188 return this.syms[name];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	189 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	190 return null;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	191 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	192 if (this.parent) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	193 return this.parent.findMacro(name);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	194 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	195 return null;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	196 },
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	197 findQuoteTrans: function(name) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	198 if (name in this.quotetrans) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	199 return this.quotetrans[name];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	200 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	201 if (this.parent) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	202 return this.parent.findQuoteTrans(name);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	203 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	204 return null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	205 },
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	206 defMacro: function(name, def) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	207 this.syms[name] = def;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	208 this.macros[name] = true;
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	209 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	210 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	211
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	212 function makeASTNode(val)
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	213 {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	214 if (typeof val == 'number') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	215 return new intlit(val);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	216 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	217 if (typeof val == 'string') {
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	218 return new strlit(val);
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	219 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	220 if (val instanceof Array) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	221 return new arraylit(val);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	222 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	223 if (val == tptrue) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	224 return new symbol('true');
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	225 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	226 if (val == tpfalse) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	227 return new symbol('false');
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	228 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	229 return val;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	230 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	231
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	232 op.prototype.eval = function(env) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	233 var l = this.left.eval(env);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	234 var name = this.op;
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	235 if (name == '&&' \|\| name == '\|\|') {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	236 var r = (new lambda([], [this.right])).eval(env);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	237 } else {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	238 var r = this.right.eval(env);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	239 }
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	240 var fun = env.findNoTop(name);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	241 var ret;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	242 if (fun) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	243 ret = fun(l,r)
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	244 } else {
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	245 if (name == '&&') {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	246 name = 'if'
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	247 } else if (name == '\|\|') {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	248 name = 'ifnot'
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	249 }
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	250 ret = l['tpmeth_'+name](r);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	251 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	252 return ret;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	253 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	254
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	255 op.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	256 this.left = this.left.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	257 this.right = this.right.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	258 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	259 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	260
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	261 op.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	262 var left = this.left.quote(env);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	263 var right = this.right.quote(env);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	264 return new op(left, this.op, right);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	265 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	266
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	267 op.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	268 return "op";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	269 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	270
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	271 op.prototype.tpmeth_left = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	272 return this.left;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	273 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	274
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	275 op.prototype.tpmeth_right = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	276 return this.right;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	277 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	278
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	279 op.prototype.tpmeth_opName = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	280 return this.op;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	281 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	282
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	283 var quote_prefix = 0;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	284
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	285 symbol.prototype.eval = function(env) {
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	286 var res = env.find(this.name);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	287 if (res === null) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	288 throw new Error('Symbol ' + this.name + ' is not bound');
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	289 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	290 return res;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	291 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	292
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	293 symbol.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	294 var val = env.find(this.name);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	295 if (val) {
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	296 var newnode = makeASTNode(val);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	297 if (!(newnode instanceof symbol)) {
213 e00a8bc6361b Implement match:yield macro Mike Pavone <pavone@retrodev.com> parents: 210 diff changeset	298 if ('quote' in newnode) {
e00a8bc6361b Implement match:yield macro Mike Pavone <pavone@retrodev.com> parents: 210 diff changeset	299 newnode = newnode.quote(env);
e00a8bc6361b Implement match:yield macro Mike Pavone <pavone@retrodev.com> parents: 210 diff changeset	300 } else {
e00a8bc6361b Implement match:yield macro Mike Pavone <pavone@retrodev.com> parents: 210 diff changeset	301 throw new Error('Symbol ' + this.name + ' is not bound to a valid AST value, instead it is bound to an object with keys ' + JSON.stringify(Object.keys(newnode)));
e00a8bc6361b Implement match:yield macro Mike Pavone <pavone@retrodev.com> parents: 210 diff changeset	302 }
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	303 }
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	304 return newnode;
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	305 } else {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	306 var hygenic = env.findQuoteTrans(this.name);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	307 return hygenic ? new symbol(hygenic, this.symbols) : this;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	308 }
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	309 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	310
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	311 symbol.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	312 return "symbol";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	313 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	314
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	315 symbol.prototype.tpmeth_name = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	316 return this.cleanName();
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	317 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	318
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	319 intlit.prototype.eval =
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	320 floatlit.prototype.eval =
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	321 strlit.prototype.eval =
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	322 arraylit.prototype.eval = function(env) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	323 return this.val;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	324 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	325
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	326 symbol.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	327 intlit.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	328 floatlit.prototype.macroexpand =
210 d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	329 strlit.prototype.macroexpand = function(env) {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	330 return this;
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	331 };
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	332
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	333
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	334 arraylit.prototype.macroexpand =
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	335 listlit.prototype.macroexpand = function(env) {
210 d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	336 for (var i = 0; i < this.val.length; i++) {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	337 this.val[i] = this.val[i].macroexpand(env);
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	338 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	339 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	340 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	341
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	342 intlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	343 floatlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	344 strlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	345 arraylit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	346 listlit.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	347 return this;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	348 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	349
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	350 intlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	351 return "intlit";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	352 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	353
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	354 floatlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	355 return "floatlit";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	356 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	357
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	358 strlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	359 return "strlit";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	360 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	361
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	362 arraylit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	363 return "arraylit";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	364 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	365
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	366 listlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	367 return "strlit";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	368 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	369
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	370 intlit.prototype.tpmeth_value =
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	371 floatlit.prototype.tpmeth_value =
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	372 strlit.prototype.tpmeth_value =
210 d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	373 arraylit.prototype.tpmeth_value = function() {
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	374 return this.val;
210 d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	375 };
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	376
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	377 listlit.prototype.tpmeth_value = function() {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	378 var cur = tplist.tpmeth_empty();
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	379 for (var idx = this.val.length - 1; idx >= 0; --idx) {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	380 cur = tplist['tpmeth_node:withTail'](this.val[idx], cur);
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	381 }
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	382 return cur;
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	383 };
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	384
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	385 funcall.prototype.eval = function(env) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	386 var args = [];
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	387 var name = this.name;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	388 if (name[name.length-1] == ":") {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	389 name = name.substr(0, name.length-1);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	390 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	391 if (name == 'quote') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	392 if (this.receiver) {
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	393 return this.receiver.quote(env);
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	394 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	395 if (this.args.length) {
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	396 var cur = env;
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	397 return this.args[0].quote(env);
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	398 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	399 throw new Error('quote takes an argument');
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	400 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	401 if (name == 'macro') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	402 return null;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	403 }
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	404 if (this.receiver) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	405 args.push(this.receiver.eval(env));
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	406 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	407 for (var i = 0; i < this.args.length; i++) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	408 args.push(this.args[i].eval(env));
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	409 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	410 if (name == 'eval:else') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	411 try {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	412 var res = args[0].eval(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	413 } catch(e) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	414 return args[2].call(null);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	415 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	416 return args[1].call(null, res);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	417 }
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	418 var fun = env.findNoTop(name);
210 d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	419 if (fun && (fun.numargs === undefined \|\| fun.numargs == args.length)) {
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	420 return fun.apply(null, args);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	421 } else {
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	422 //if (typeof args[0]'tpmeth_'+name in args[0]) {
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	423 try {
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	424 return args[0]['tpmeth_'+name].apply(args[0], args.slice(1));
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	425 } catch(e) {
210 d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	426 var msg = 'Error, \n\t' + e.message.split('\n').join('\n\t') + '\ninvoking method ' + name + ' on object ' + args[0];
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	427 if (typeof args[0] == 'object') {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	428 msg += ' with keys ' + JSON.stringify(Object.keys(args[0]) + ' and constructor ' + args[0].constructor.name);
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	429 }
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	430 throw new Error(msg);
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	431 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	432 /*} else {JSON.stringify
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	433 throw new Error('No method named ' + name + ' on object ' + JSON.stringify(args[0]));
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	434 }*/
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	435 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	436 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	437
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	438 funcall.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	439 var name = this.name;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	440 if (name[name.length-1] == ":") {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	441 name = name.substr(0, name.length-1);
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	442 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	443 var macro = env.findMacro(name);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	444 if (this.receiver) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	445 this.receiver = this.receiver.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	446 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	447 for (var i = 0; i < this.args.length; i++) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	448 this.args[i] = this.args[i].macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	449 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	450 if (!macro) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	451 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	452 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	453 var args = [];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	454 if (this.receiver) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	455 args.push(this.receiver);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	456 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	457 for (var i = 0; i < this.args.length; i++) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	458 args.push(this.args[i]);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	459 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	460 return makeASTNode(macro.apply(null, args));
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	461 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	462
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	463 funcall.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	464 var receiver = this.receiver ? this.receiver.quote(env) : null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	465 var args = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	466 for (var i = 0; i < this.args.length; i++) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	467 args.push(this.args[i].quote(env));
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	468 }
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	469 var name = this.name;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	470 if (name[name.length-1] == ":") {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	471 name = name.substr(0, name.length-1);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	472 }
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	473 var fun = env.find(name);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	474 if (fun) {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	475 fun = makeASTNode(fun);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	476 if (fun instanceof symbol) {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	477 name = fun.cleanName();
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	478 } else if (fun instanceof lambda) {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	479 throw new Error('FIXME');
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	480 }
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	481 } else {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	482 var hygenic = env.findQuoteTrans(this.name);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	483 if (hygenic) {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	484 name = hygenic;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	485 }
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	486 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	487 var ret = new funcall(name, args);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	488 ret.receiver = receiver;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	489 return ret;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	490 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	491
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	492 funcall.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	493 return "funcall";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	494 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	495
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	496 object.prototype.eval = function(parentenv) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	497 var env = new environment(parentenv);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	498 var obj = {env: env};
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	499 for (var i = 0; i < this.messages.length; i++) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	500 var msg = this.messages[i];
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	501 if (msg instanceof assignment) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	502 if (msg.expression instanceof lambda) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	503 obj['tpmeth_' + msg.symbol.name] = msg.expression.eval(env);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	504 (function(name) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	505 env.syms[name] = function() {
210 d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	506 var ret = obj['tpmeth_' + name].apply(obj, arguments);
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	507 return ret;
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	508 };
210 d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	509 env.syms[name].numargs = msg.expression.numArgs();
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	510 })(msg.symbol.name);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	511 } else {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	512 var makeProp = function(obj, name) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	513 obj['tprop_' + name] = msg.expression.eval(env);
210 d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	514 obj['tpmeth_' + name] = function() {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	515 return this['tprop_'+name];
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	516 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	517 var setname = name+'!';
210 d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	518 obj['tpmeth_' + setname] = function(val) {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	519 this['tprop_'+name] = val;
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	520 return this;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	521 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	522 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	523 makeProp(obj, msg.symbol.name);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	524 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	525 } else {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	526 throw new Error('pseudo function calls in object definitions not implemented yet');
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	527 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	528 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	529 return obj;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	530 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	531
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	532 object.prototype.macroexpand = function(parentenv) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	533 var env = new environment(parentenv);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	534 var obj = {env: env};
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	535 var outmessages = [];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	536 for (var i = 0; i < this.messages.length; i++) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	537 var msg = this.messages[i].macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	538 if (msg instanceof assignment) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	539 if (msg.expression instanceof lambda) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	540 (function(name, expr) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	541 env.syms[name] = function() {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	542 if (!obj['tpmeth_' + name]) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	543 obj['tpmeth_' + name] = expr.eval(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	544 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	545 return obj['tpmeth_' + name].apply(obj, arguments);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	546 };
210 d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	547 env.syms[name].numargs = expr.numArgs();
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	548 })(msg.symbol.name, msg.expression);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	549 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	550 } else if (msg.expression instanceof funcall && msg.expression.name == 'macro:') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	551 env.defMacro(msg.symbol.name, msg.expression.args[0].eval(env));
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	552 } else {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	553 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	554 /*
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	555 var makeProp = function(obj, name) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	556 obj['tprop_' + name] = msg.expression.eval(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	557 name = 'tpmeth_' + name;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	558 obj[name] = function() {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	559 return this[name];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	560 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	561 var setname = name+'!';
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	562 obj[setname] = function(val) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	563 this[setname] = val;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	564 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	565 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	566 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	567 makeProp(obj, msg.symbol.name);*/
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	568 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	569 } else {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	570 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	571 //throw new Error('pseudo function calls in object definitions not implemented yet');
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	572 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	573 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	574 this.messages = outmessages;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	575 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	576 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	577
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	578 object.prototype.quote = function(parentenv) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	579 var env = new environment(parentenv);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	580 var outmessages = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	581 for (var i = 0; i < this.messages.length; i++) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	582 var msg = this.messages[i];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	583 if (msg instanceof assignment) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	584 //Make sure method names don't get renamed for hygene
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	585 env.syms[msg.symbol.name] = null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	586 env.quotetrans[msg.symbol.name] = msg.symbol.name;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	587 if (msg.expression instanceof lambda) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	588 env.syms[msg.symbol.name + '!'] = null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	589 env.quotetrans[msg.symbol.name + '!'] = msg.symbol.name + '!';
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	590 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	591 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	592 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	593 for (var i = 0; i < this.messages.length; i++) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	594 var msg = this.messages[i];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	595 if (msg instanceof assignment) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	596 outmessages.push(new assignment(msg.symbol, msg.expression.quote(env)));
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	597 } else {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	598 outmessages.push(msg.quote(env));
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	599 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	600 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	601 return new object(outmessages);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	602 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	603
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	604 object.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	605 return "object";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	606 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	607
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	608 lambda.prototype.eval = function(parentenv) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	609 var args = this.args;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	610 var exprs = this.expressions;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	611 return function() {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	612 var env = new environment(parentenv);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	613 for (var i = 0, j = 0; i < arguments.length && j < args.length; i++, j++) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	614 while (j < args.length && args[j].cleanName() == 'self') {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	615 j++;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	616 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	617 env.syms[args[j].cleanName()] = arguments[i];
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	618 }
210 d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	619 if (this != null) {
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	620 env.syms['self'] = this;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	621 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	622 var res = null;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	623 for (var i = 0; i < exprs.length; i++) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	624 res = exprs[i].eval(env);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	625 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	626 return res;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	627 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	628 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	629
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	630 lambda.prototype.macroexpand = function(parentenv) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	631 var env = new environment(parentenv);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	632 for (var i = 0; i < this.args.length; i++) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	633 env.syms[this.args[i].cleanName()] = {};
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	634 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	635 for (var i = 0; i < this.expressions.length; i++) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	636 var expr = this.expressions[i];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	637 if (expr instanceof assignment) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	638 if (expr.expression instanceof funcall && expr.expression.name == 'macro:') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	639 env.defMacro(expr.symbol.name, exp.expression.args[0].eval(env));
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	640 } else {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	641 env.syms[expr.symbol.cleanName()] = {};
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	642 this.expressions[i] = expr.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	643 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	644 } else {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	645 this.expressions[i] = expr.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	646 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	647 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	648 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	649 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	650
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	651 lambda.prototype.quote = function(parentenv) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	652 var args = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	653 var expressions = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	654 var env = new environment(parentenv);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	655 for (var i = 0; i < this.args.length; i++) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	656 env.syms[this.args[i].cleanName()] = null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	657 var hygenic = '' + quote_prefix + this.args[i].cleanName();
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	658 env.quotetrans[this.args[i].cleanName()] = hygenic;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	659 args.push(new symbol(hygenic, this.args[i].symbols));
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	660 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	661 for (var i = 0; i < this.expressions.length; i++) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	662 expressions.push(this.expressions[i].quote(env));
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	663 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	664 return new lambda(args, expressions);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	665 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	666
210 d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	667 lambda.prototype.numArgs = function() {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	668 var num = this.args.length;
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	669 if (num && (this.args[0].cleanName() == 'self')) {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	670 --num;
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	671 }
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	672 return num;
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	673 };
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	674
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	675 lambda.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	676 return "lambda";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	677 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	678
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	679 assignment.prototype.eval = function(env) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	680 var val = this.expression.eval(env);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	681 env.findSet(this.symbol.name, val);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	682 return val;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	683 };
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	684
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	685 assignment.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	686 this.expression = this.expression.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	687 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	688 };
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	689
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	690 assignment.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	691 var name = this.symbol.cleanName();
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	692 env.syms[name] = null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	693 var hygenic = '' + quote_prefix + name;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	694 env.quotetrans[name] = hygenic;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	695 return new assignment(new symbol(hygenic, this.symbol.symbols), this.expression.quote(env));
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	696 };
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	697
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	698 assignment.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	699 return "assignment";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	700 };