repos/tabletprog: interp.js annotate

annotate interp.js @ 210:d0848563f25d

Fix some bugs and allow proper access to list literals in interpreter/macro expander

author	Mike Pavone <pavone@retrodev.com>
date	Sat, 30 Nov 2013 15:03:47 -0800
parents	4b3b57f39f10
children	e00a8bc6361b

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)) {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	298 newnode = newnode.quote(env);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	299 }
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	300 return newnode;
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	301 } else {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	302 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	303 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	304 }
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	305 };
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	306
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	307 symbol.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	308 return "symbol";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	309 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	310
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	311 symbol.prototype.tpmeth_name = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	312 return this.cleanName();
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
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	315 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	316 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	317 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	318 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	319 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	320 };
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
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	322 symbol.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	323 intlit.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	324 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	325 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	326 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	327 };
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	328
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
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 arraylit.prototype.macroexpand =
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	331 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	332 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	333 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	334 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	335 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	336 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	337
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	338 intlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	339 floatlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	340 strlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	341 arraylit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	342 listlit.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	343 return this;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	344 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	345
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	346 intlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	347 return "intlit";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	348 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	349
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	350 floatlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	351 return "floatlit";
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 strlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	355 return "strlit";
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 arraylit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	359 return "arraylit";
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 listlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	363 return "strlit";
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 intlit.prototype.tpmeth_value =
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	367 floatlit.prototype.tpmeth_value =
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	368 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	369 arraylit.prototype.tpmeth_value = function() {
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	370 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	371 };
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	372
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 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	374 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	375 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	376 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	377 }
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 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	379 };
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	380
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	381 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	382 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	383 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	384 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	385 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	386 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	387 if (name == 'quote') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	388 if (this.receiver) {
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	389 return this.receiver.quote(env);
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	390 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	391 if (this.args.length) {
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	392 var cur = env;
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	393 return this.args[0].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 throw new Error('quote takes an argument');
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	396 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	397 if (name == 'macro') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	398 return null;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	399 }
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	400 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	401 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	402 }
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	403 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	404 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	405 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	406 if (name == 'eval:else') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	407 try {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	408 var res = args[0].eval(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	409 } catch(e) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	410 return args[2].call(null);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	411 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	412 return args[1].call(null, res);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	413 }
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	414 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	415 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	416 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	417 } else {
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	418 //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	419 try {
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	420 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	421 } 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	422 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	423 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	424 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	425 }
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 throw new Error(msg);
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	427 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	428 /*} else {JSON.stringify
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	429 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	430 }*/
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	431 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	432 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	433
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	434 funcall.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	435 var name = this.name;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	436 if (name[name.length-1] == ":") {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	437 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	438 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	439 var macro = env.findMacro(name);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	440 if (this.receiver) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	441 this.receiver = this.receiver.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	442 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	443 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	444 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	445 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	446 if (!macro) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	447 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	448 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	449 var args = [];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	450 if (this.receiver) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	451 args.push(this.receiver);
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 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	454 args.push(this.args[i]);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	455 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	456 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	457 };
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	458
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	459 funcall.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	460 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	461 var args = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	462 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	463 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	464 }
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	465 var name = this.name;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	466 if (name[name.length-1] == ":") {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	467 name = name.substr(0, name.length-1);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	468 }
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	469 var fun = env.find(name);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	470 if (fun) {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	471 fun = makeASTNode(fun);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	472 if (fun instanceof symbol) {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	473 name = fun.cleanName();
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	474 } else if (fun instanceof lambda) {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	475 throw new Error('FIXME');
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	476 }
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	477 } else {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	478 var hygenic = env.findQuoteTrans(this.name);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	479 if (hygenic) {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	480 name = hygenic;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	481 }
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	482 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	483 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	484 ret.receiver = receiver;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	485 return ret;
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
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	488 funcall.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	489 return "funcall";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	490 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	491
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	492 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	493 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	494 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	495 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	496 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	497 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	498 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	499 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	500 (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	501 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	502 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	503 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	504 };
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	505 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	506 })(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	507 } 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	508 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	509 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	510 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	511 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	512 };
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 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	514 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	515 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	516 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	517 };
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	518 };
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	519 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	520 }
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 } 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	522 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	523 }
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 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	526 };
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
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	528 object.prototype.macroexpand = function(parentenv) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	529 var env = new environment(parentenv);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	530 var obj = {env: env};
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	531 var outmessages = [];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	532 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	533 var msg = this.messages[i].macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	534 if (msg instanceof assignment) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	535 if (msg.expression instanceof lambda) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	536 (function(name, expr) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	537 env.syms[name] = function() {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	538 if (!obj['tpmeth_' + name]) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	539 obj['tpmeth_' + name] = expr.eval(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	540 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	541 return obj['tpmeth_' + name].apply(obj, arguments);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	542 };
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	543 env.syms[name].numargs = expr.numArgs();
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	544 })(msg.symbol.name, msg.expression);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	545 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	546 } 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	547 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	548 } else {
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 /*
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	551 var makeProp = function(obj, name) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	552 obj['tprop_' + name] = msg.expression.eval(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	553 name = 'tpmeth_' + name;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	554 obj[name] = function() {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	555 return this[name];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	556 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	557 var setname = name+'!';
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	558 obj[setname] = function(val) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	559 this[setname] = val;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	560 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	561 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	562 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	563 makeProp(obj, msg.symbol.name);*/
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	564 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	565 } else {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	566 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	567 //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	568 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	569 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	570 this.messages = outmessages;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	571 return this;
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
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	574 object.prototype.quote = function(parentenv) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	575 var env = new environment(parentenv);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	576 var outmessages = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	577 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	578 var msg = this.messages[i];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	579 if (msg instanceof assignment) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	580 //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	581 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	582 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	583 if (msg.expression instanceof lambda) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	584 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	585 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	586 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	587 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	588 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	589 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	590 var msg = this.messages[i];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	591 if (msg instanceof assignment) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	592 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	593 } else {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	594 outmessages.push(msg.quote(env));
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	595 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	596 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	597 return new object(outmessages);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	598 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	599
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	600 object.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	601 return "object";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	602 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	603
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	604 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	605 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	606 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	607 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	608 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	609 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	610 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	611 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	612 }
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 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	614 }
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	615 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	616 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	617 }
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 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	619 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	620 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	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 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	623 };
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 };
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
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	626 lambda.prototype.macroexpand = function(parentenv) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	627 var env = new environment(parentenv);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	628 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	629 env.syms[this.args[i].cleanName()] = {};
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	630 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	631 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	632 var expr = this.expressions[i];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	633 if (expr instanceof assignment) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	634 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	635 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	636 } else {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	637 env.syms[expr.symbol.cleanName()] = {};
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	638 this.expressions[i] = expr.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	639 }
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 this.expressions[i] = expr.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	642 }
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 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	645 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	646
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	647 lambda.prototype.quote = function(parentenv) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	648 var args = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	649 var expressions = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	650 var env = new environment(parentenv);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	651 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	652 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	653 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	654 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	655 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	656 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	657 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	658 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	659 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	660 return new lambda(args, expressions);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	661 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	662
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	663 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	664 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	665 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	666 --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	667 }
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 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	669 };
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
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	671 lambda.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	672 return "lambda";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	673 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	674
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	675 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	676 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	677 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	678 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	679 };
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	680
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	681 assignment.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	682 this.expression = this.expression.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	683 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	684 };
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	685
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	686 assignment.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	687 var name = this.symbol.cleanName();
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	688 env.syms[name] = null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	689 var hygenic = '' + quote_prefix + name;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	690 env.quotetrans[name] = hygenic;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	691 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	692 };
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	693
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	694 assignment.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	695 return "assignment";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	696 };