repos/tabletprog: interp.js annotate

annotate interp.js @ 251:2557ce4e671f

Fix a couple of compiler bugs. topenv was getting initialized in multiple places. This resulted in multiple copies of modules getting created which caused problems for macro expansion. Additionally, arguments were not being marked as declared during code generation so assigning to an argument that was not closed over generated invalid C code.

author	Michael Pavone <pavone@retrodev.com>
date	Fri, 11 Apr 2014 22:29:32 -0700
parents	dc5f487247ee
children	0ee70ac20a02

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]);
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	122 var ret = parsed.macroexpand(this).eval(this);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	123 if (typeof ret == 'function') {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	124 ret = ret();
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	125 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	126 this.modules[name] = ret;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	127 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	128 }
b4a9d4e405c5 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 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	130 },
b4a9d4e405c5 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 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	132 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	133 },
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	134 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	135 return false;
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	136 },
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	137 findMacro: function(name) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	138 return null;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	139 },
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	140 findQuoteTrans: function(name) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	141 return null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	142 }
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	143 }
b4a9d4e405c5 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
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	145 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	146 {
b4a9d4e405c5 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 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	148 this.syms = {};
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	149 this.macros = {};
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	150 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	151 }
b4a9d4e405c5 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
b4a9d4e405c5 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 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	154 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	155 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	156 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	157 }
b4a9d4e405c5 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 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	159 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	160 }
b4a9d4e405c5 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 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	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 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	164 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	165 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	166 }
b4a9d4e405c5 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 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	168 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	169 }
b4a9d4e405c5 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 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	171 },
b4a9d4e405c5 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 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	173 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	174 \|\| !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	175 \|\| !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	176 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	177 }
b4a9d4e405c5 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 },
b4a9d4e405c5 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 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	180 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	181 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	182 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	183 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	184 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	185 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	186 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	187 return false;
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	188 },
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	189 findMacro: function(name) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	190 if (name in this.syms) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	191 if (name in this.macros) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	192 return this.syms[name];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	193 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	194 return null;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	195 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	196 if (this.parent) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	197 return this.parent.findMacro(name);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	198 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	199 return null;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	200 },
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	201 findQuoteTrans: function(name) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	202 if (name in this.quotetrans) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	203 return this.quotetrans[name];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	204 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	205 if (this.parent) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	206 return this.parent.findQuoteTrans(name);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	207 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	208 return null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	209 },
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	210 defMacro: function(name, def) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	211 this.syms[name] = def;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	212 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	213 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	214 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	215
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	216 function makeASTNode(val)
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	217 {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	218 if (typeof val == 'number') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	219 return new intlit(val);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	220 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	221 if (typeof val == 'string') {
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	222 return new strlit(val);
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	223 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	224 if (val instanceof Array) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	225 return new arraylit(val);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	226 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	227 if (val == tptrue) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	228 return new symbol('true');
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	229 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	230 if (val == tpfalse) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	231 return new symbol('false');
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	232 }
221 218b11ec8fa2 Better handling for weird values being inserted into AST due to quoting Michael Pavone <pavone@retrodev.com> parents: 219 diff changeset	233 if ('makeHygienic' in val) {
218b11ec8fa2 Better handling for weird values being inserted into AST due to quoting Michael Pavone <pavone@retrodev.com> parents: 219 diff changeset	234 return val;
218b11ec8fa2 Better handling for weird values being inserted into AST due to quoting Michael Pavone <pavone@retrodev.com> parents: 219 diff changeset	235 }
218b11ec8fa2 Better handling for weird values being inserted into AST due to quoting Michael Pavone <pavone@retrodev.com> parents: 219 diff changeset	236 return null;
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	237 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	238
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	239 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	240 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	241 var name = this.op;
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	242 if (name == '&&' \|\| name == '\|\|') {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	243 var r = (new lambda([], [this.right])).eval(env);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	244 } else {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	245 var r = this.right.eval(env);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	246 }
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	247 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	248 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	249 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	250 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	251 } else {
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	252 if (name == '&&') {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	253 name = 'if'
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	254 } else if (name == '\|\|') {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	255 name = 'ifnot'
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	256 } else if (name == '\|') {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	257 return r['tpmeth_\|'](l);
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	258 }
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	259 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	260 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	261 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	262 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	263
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	264 op.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	265 this.left = this.left.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	266 this.right = this.right.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	267 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	268 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	269
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	270 op.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	271 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	272 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	273 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	274 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	275
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	276 op.prototype.makeHygienic = function(env) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	277 var left = this.left.makeHygienic(env);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	278 var right = this.right.makeHygienic(env);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	279 return new op(left, this.op, right);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	280 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	281
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	282 op.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	283 return "op";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	284 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	285
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	286 op.prototype.tpmeth_left = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	287 return this.left;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	288 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	289
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	290 op.prototype.tpmeth_right = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	291 return this.right;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	292 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	293
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	294 op.prototype.tpmeth_opName = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	295 return this.op;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	296 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	297
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	298 var quote_prefix = 0;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	299
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	300 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	301 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	302 if (res === null) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	303 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	304 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	305 return res;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	306 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	307
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	308 symbol.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	309 var val = env.find(this.name);
219 b70be565d54c Fix check of return value from env.find in symbol.quote so that falsey found values do not cause trouble. Michael Pavone <pavone@retrodev.com> parents: 217 diff changeset	310 if (val !== null) {
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	311 var newnode = makeASTNode(val);
221 218b11ec8fa2 Better handling for weird values being inserted into AST due to quoting Michael Pavone <pavone@retrodev.com> parents: 219 diff changeset	312 if (!newnode) {
218b11ec8fa2 Better handling for weird values being inserted into AST due to quoting Michael Pavone <pavone@retrodev.com> parents: 219 diff changeset	313 throw new Error(this.name + ' contains a value ' + val + ' that could not be converted to an AST node');
218b11ec8fa2 Better handling for weird values being inserted into AST due to quoting Michael Pavone <pavone@retrodev.com> parents: 219 diff changeset	314 }
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	315 return newnode;
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	316 } else {
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	317 this.dirty = true;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	318 return this;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	319 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	320 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	321
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	322 symbol.prototype.makeHygienic = function(env) {
240 dc5f487247ee Don't rename the symbol self in quote blocks Mike Pavone <pavone@retrodev.com> parents: 238 diff changeset	323 if (this.dirty && this.cleanName() != 'self') {
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	324 var hygenic = env.findQuoteTrans(this.cleanName());
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	325 if (hygenic)
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	326 {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	327 return new symbol(hygenic, this.symbols);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	328 } else {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	329 return this;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	330 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	331 } else {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	332 return this;
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	333 }
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	334 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	335
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	336 symbol.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	337 return "symbol";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	338 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	339
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	340 symbol.prototype.tpmeth_name = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	341 return this.cleanName();
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	342 };
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	343 symbol.prototype['tpmeth_name!'] = function(val) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	344 this.name = val;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	345 return this;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	346 };
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	347
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	348 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	349 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	350 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	351 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	352 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	353 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	354
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	355 listlit.prototype.eval = function(env) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	356 var cur = tplist.tpmeth_empty();
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	357 for (var idx = this.val.length - 1; idx >= 0; --idx) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	358 cur = tplist['tpmeth_node:withTail'](this.val[idx].eval(env), cur);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	359 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	360 return cur;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	361 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	362
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	363 symbol.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	364 intlit.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	365 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	366 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	367 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	368 };
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
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	370
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 arraylit.prototype.macroexpand =
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	372 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	373 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	374 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	375 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	376 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	377 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	378
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	379 intlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	380 floatlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	381 strlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	382 arraylit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	383 listlit.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	384 return this;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	385 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	386
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	387 intlit.prototype.makeHygienic =
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	388 floatlit.prototype.makeHygienic =
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	389 strlit.prototype.makeHygienic =
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	390 arraylit.prototype.makeHygienic =
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	391 listlit.prototype.makeHygienic = function(env) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	392 return this;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	393 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	394
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	395 intlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	396 return "intlit";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	397 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	398
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	399 floatlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	400 return "floatlit";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	401 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	402
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	403 strlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	404 return "strlit";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	405 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	406
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	407 arraylit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	408 return "arraylit";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	409 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	410
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	411 listlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	412 return "strlit";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	413 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	414
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	415 intlit.prototype.tpmeth_value =
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	416 floatlit.prototype.tpmeth_value =
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	417 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	418 arraylit.prototype.tpmeth_value = function() {
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	419 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	420 };
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	421
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 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	423 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	424 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	425 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	426 }
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	427 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	428 };
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	429
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	430 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	431 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	432 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	433 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	434 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	435 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	436 if (name == 'quote') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	437 if (this.receiver) {
224 97c3e33cd3f4 Support macro expansion inside quoted code Michael Pavone <pavone@retrodev.com> parents: 221 diff changeset	438 return this.receiver.quote(env).macroexpand(env);
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	439 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	440 if (this.args.length) {
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	441 var cur = env;
224 97c3e33cd3f4 Support macro expansion inside quoted code Michael Pavone <pavone@retrodev.com> parents: 221 diff changeset	442 return this.args[0].quote(env).macroexpand(env);
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	443 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	444 throw new Error('quote takes an argument');
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 (name == 'macro') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	447 return null;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	448 }
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	449 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	450 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	451 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	452 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	453 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	454 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	455 if (name == 'eval:else') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	456 try {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	457 var res = args[0].eval(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	458 } catch(e) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	459 return args[2].call(null);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	460 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	461 return args[1].call(null, res);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	462 }
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	463 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	464 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	465 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	466 } else {
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	467 //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	468 try {
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	469 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	470 } 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	471 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	472 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	473 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	474 }
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	475 throw new Error(msg);
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	476 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	477 /*} else {JSON.stringify
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	478 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	479 }*/
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	480 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	481 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	482
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	483 funcall.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	484 var name = this.name;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	485 if (name[name.length-1] == ":") {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	486 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	487 }
224 97c3e33cd3f4 Support macro expansion inside quoted code Michael Pavone <pavone@retrodev.com> parents: 221 diff changeset	488 if (name == 'quote') {
97c3e33cd3f4 Support macro expansion inside quoted code Michael Pavone <pavone@retrodev.com> parents: 221 diff changeset	489 return this;
97c3e33cd3f4 Support macro expansion inside quoted code Michael Pavone <pavone@retrodev.com> parents: 221 diff changeset	490 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	491 var macro = env.findMacro(name);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	492 if (this.receiver) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	493 this.receiver = this.receiver.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	494 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	495 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	496 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	497 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	498 if (!macro) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	499 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	500 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	501 var args = [];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	502 if (this.receiver) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	503 args.push(this.receiver);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	504 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	505 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	506 args.push(this.args[i]);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	507 }
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	508 var ret = makeASTNode(macro.apply(null, args));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	509 ret = ret.makeHygienic(env);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	510 quote_prefix++;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	511 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	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
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	514 funcall.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	515 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	516 var args = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	517 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	518 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	519 }
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	520 var name = this.name;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	521 if (name[name.length-1] == ":") {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	522 name = name.substr(0, name.length-1);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	523 }
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	524 var fun = env.find(name);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	525 if (fun) {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	526 fun = makeASTNode(fun);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	527 if (fun instanceof symbol) {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	528 name = fun.cleanName();
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	529 } else if (fun instanceof lambda) {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	530 throw new Error('FIXME');
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	531 }
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	532 } else {
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	533 this.dirty = true;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	534 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	535 var ret = new funcall(name, args);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	536 ret.receiver = receiver;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	537 return ret;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	538 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	539
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	540 funcall.prototype.makeHygienic = function(env) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	541 var receiver = this.receiver ? this.receiver.makeHygienic(env) : null;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	542 var args = [];
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	543 for (var i = 0; i < this.args.length; i++) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	544 args.push(this.args[i].makeHygienic(env));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	545 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	546 var name = this.name;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	547 if (name[name.length-1] == ":") {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	548 name = name.substr(0, name.length-1);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	549 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	550 var hygienic = env.findQuoteTrans(name);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	551 if (hygienic) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	552 name = hygienic;
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	553 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	554 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	555 ret.receiver = receiver;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	556 return ret;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	557 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	558
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	559 funcall.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	560 return "funcall";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	561 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	562
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	563 funcall.prototype['tpmeth_args!'] = function(arglist) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	564 this.args = [];
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	565 //TODO: Finish this
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	566 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	567
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	568 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	569 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	570 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	571 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	572 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	573 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	574 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	575 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	576 (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	577 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	578 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	579 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	580 };
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	581 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	582 })(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	583 } 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	584 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	585 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	586 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	587 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	588 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	589 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	590 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	591 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	592 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	593 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	594 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	595 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	596 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	597 } 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	598 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	599 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	600 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	601 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	602 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	603
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	604 object.prototype.macroexpand = function(parentenv) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	605 var env = new environment(parentenv);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	606 var obj = {env: env};
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	607 var outmessages = [];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	608 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	609 var msg = this.messages[i].macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	610 if (msg instanceof assignment) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	611 if (msg.expression instanceof lambda) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	612 (function(name, expr) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	613 env.syms[name] = function() {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	614 if (!obj['tpmeth_' + name]) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	615 obj['tpmeth_' + name] = expr.eval(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	616 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	617 return obj['tpmeth_' + name].apply(obj, arguments);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	618 };
210 d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	619 env.syms[name].numargs = expr.numArgs();
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	620 })(msg.symbol.name, msg.expression);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	621 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	622 } 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	623 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	624 } else {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	625 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	626 /*
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	627 var makeProp = function(obj, name) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	628 obj['tprop_' + name] = msg.expression.eval(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	629 name = 'tpmeth_' + name;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	630 obj[name] = function() {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	631 return this[name];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	632 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	633 var setname = name+'!';
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	634 obj[setname] = function(val) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	635 this[setname] = val;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	636 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	637 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	638 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	639 makeProp(obj, msg.symbol.name);*/
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	640 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	641 } else {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	642 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	643 //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	644 }
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 this.messages = outmessages;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	647 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	648 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	649
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	650 object.prototype.quote = function(parentenv) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	651 var env = new environment(parentenv);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	652 var outmessages = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	653 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	654 var msg = this.messages[i];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	655 if (msg instanceof assignment) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	656 env.syms[msg.symbol.name] = null;
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	657 if (!(msg.expression instanceof lambda)) {
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	658 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	659 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	660 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	661 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	662 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	663 var msg = this.messages[i];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	664 if (msg instanceof assignment) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	665 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	666 } else {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	667 outmessages.push(msg.quote(env));
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	668 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	669 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	670 return new object(outmessages);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	671 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	672
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	673 object.prototype.makeHygienic = function(parentenv) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	674 var env = new environment(parentenv);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	675 var outmessages = [];
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	676 for (var i = 0; i < this.messages.length; i++) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	677 var msg = this.messages[i];
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	678 if (msg instanceof assignment) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	679 env.syms[msg.symbol.name] = null;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	680 //make sure method names don't get translated for hygiene
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	681 env.quotetrans[msg.symbol.name] = null;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	682 if (!(msg.expression instanceof lambda)) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	683 env.syms[msg.symbol.name + '!'] = null;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	684 env.quotetrans[msg.symbol.name + '!'] = null;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	685 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	686 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	687 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	688 for (var i = 0; i < this.messages.length; i++) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	689 var msg = this.messages[i];
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	690 if (msg instanceof assignment) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	691 outmessages.push(new assignment(msg.symbol, msg.expression.makeHygienic(env)));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	692 } else {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	693 outmessages.push(msg.makeHygienic(env));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	694 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	695 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	696 return new object(outmessages);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	697 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	698
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	699 object.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	700 return "object";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	701 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	702
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	703 object.prototype.tpmeth_addMessage = function(message) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	704 this.messages.push(makeASTNode(message));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	705 return this;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	706 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	707
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	708 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	709 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	710 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	711 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	712 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	713 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	714 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	715 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	716 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	717 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	718 }
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	719 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	720 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	721 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	722 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	723 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	724 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	725 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	726 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	727 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	728 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	729
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	730 lambda.prototype.macroexpand = function(parentenv) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	731 var env = new environment(parentenv);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	732 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	733 env.syms[this.args[i].cleanName()] = {};
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	734 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	735 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	736 var expr = this.expressions[i];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	737 if (expr instanceof assignment) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	738 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	739 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	740 } else {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	741 env.syms[expr.symbol.cleanName()] = {};
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	742 this.expressions[i] = expr.macroexpand(env);
238 3bfc00e4f5e5 Eval lambda assignments at macro expandion time so they can be called by macros Mike Pavone <pavone@retrodev.com> parents: 224 diff changeset	743 if (this.expressions[i].expression instanceof lambda) {
3bfc00e4f5e5 Eval lambda assignments at macro expandion time so they can be called by macros Mike Pavone <pavone@retrodev.com> parents: 224 diff changeset	744 env.syms[expr.symbol.cleanName()] = this.expressions[i].expression.eval(env);
240 dc5f487247ee Don't rename the symbol self in quote blocks Mike Pavone <pavone@retrodev.com> parents: 238 diff changeset	745 } else {
dc5f487247ee Don't rename the symbol self in quote blocks Mike Pavone <pavone@retrodev.com> parents: 238 diff changeset	746 env.syms[expr.symbol.cleanName()] = null;
238 3bfc00e4f5e5 Eval lambda assignments at macro expandion time so they can be called by macros Mike Pavone <pavone@retrodev.com> parents: 224 diff changeset	747 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	748 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	749 } else {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	750 this.expressions[i] = expr.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	751 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	752 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	753 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	754 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	755
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	756 lambda.prototype.quote = function(parentenv) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	757 var args = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	758 var expressions = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	759 var env = new environment(parentenv);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	760 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	761 env.syms[this.args[i].cleanName()] = null;
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	762 var sym = new symbol(this.args[i].name, this.args[i].symbols);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	763 sym.dirty = true;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	764 args.push(sym);
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	765 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	766 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	767 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	768 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	769 return new lambda(args, expressions);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	770 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	771
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	772 lambda.prototype.makeHygienic = function(parentenv) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	773 var args = [];
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	774 var expressions = [];
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	775 var env = new environment(parentenv);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	776 for (var i = 0; i < this.args.length; i++) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	777 env.syms[this.args[i].cleanName()] = null;
240 dc5f487247ee Don't rename the symbol self in quote blocks Mike Pavone <pavone@retrodev.com> parents: 238 diff changeset	778 if (this.args[i].dirty && this.args[i].cleanName() != 'self') {
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	779 var hygienic = '' + quote_prefix + this.args[i].cleanName();
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	780 env.quotetrans[this.args[i].cleanName()] = hygienic;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	781 args.push(new symbol(hygienic, this.args[i].symbols));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	782 } else {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	783 args.push(this.args[i]);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	784 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	785 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	786 for (var i = 0; i < this.expressions.length; i++) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	787 expressions.push(this.expressions[i].makeHygienic(env));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	788 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	789 return new lambda(args, expressions);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	790 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	791
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	792 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	793 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	794 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	795 --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	796 }
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	797 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	798 };
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander Mike Pavone <pavone@retrodev.com> parents: 209 diff changeset	799
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	800 lambda.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	801 return "lambda";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	802 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	803
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	804 lambda.prototype.tpmeth_args = function() {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	805 var cur = tplist.tpmeth_empty();
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	806 for (var idx = this.args.length - 1; idx >= 0; --idx) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	807 cur = tplist['tpmeth_node:withTail'](this.args[idx], cur);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	808 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	809 return cur;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	810 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	811
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	812 lambda.prototype.tpmeth_expressions = function() {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	813 var cur = tplist.tpmeth_empty();
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	814 for (var idx = this.expressions.length - 1; idx >= 0; --idx) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	815 cur = tplist['tpmeth_node:withTail'](this.expressions[idx], cur);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	816 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	817 return cur;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	818 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	819
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	820 lambda.prototype['tpmeth_expressions!'] = function(exprs) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	821 var expressions = [];
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	822 while (!exprs['tpmeth_empty?']().valueOf()) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	823 expressions.push(makeASTNode(exprs.tpmeth_value()));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	824 exprs = exprs.tpmeth_tail();
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	825 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	826 this.expressions = expressions;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	827 return this;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	828 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	829
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	830 lambda.prototype.tpmeth_addExpression = function(expr) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	831 this.expressions.push(makeASTNode(expr));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	832 return this;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	833 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	834
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	835 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	836 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	837 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	838 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	839 };
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	840
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	841 assignment.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	842 this.expression = this.expression.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	843 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	844 };
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	845
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	846 assignment.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	847 var name = this.symbol.cleanName();
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	848 var val = env.find(name);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	849 var dirty = true;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	850 if (val) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	851 var node = makeASTNode(val);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	852 if (!(node instanceof symbol)) {
221 218b11ec8fa2 Better handling for weird values being inserted into AST due to quoting Michael Pavone <pavone@retrodev.com> parents: 219 diff changeset	853 throw new Error('Left hand side of assignment expression must be a symbol not a '+ node.constructor.name + ' '+(typeof node) + ', old name was ' + name);
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	854 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	855 name = node.cleanName();
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	856 dirty = node.dirty;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	857 }
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	858 env.syms[name] = null;
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	859 var sym = new symbol(name, this.symbol.symbols);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	860 sym.dirty = dirty;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	861 return new assignment(sym, this.expression.quote(env));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	862 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	863
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	864 assignment.prototype.makeHygienic = function(env) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	865 var name = this.symbol.cleanName();
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	866 env.syms[name] = null;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	867 if (this.symbol.dirty) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	868 name = env.quotetrans[name] = '' + quote_prefix + name;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	869 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	870 return new assignment(new symbol(name, this.symbol.symbols), this.expression.makeHygienic(env));
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	871 };
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	872
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	873 assignment.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	874 return "assignment";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	875 };
217 adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	876
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	877 assignment.prototype.tpmeth_symbol = function() {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	878 return this.symbol;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	879 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	880
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	881 assignment.prototype['tpmeth_symbol!'] = function(val) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	882 this.symbol = makeASTNode(val);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	883 return this;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	884 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	885
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	886 assignment.prototype.tpmeth_expression = function() {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	887 return this.expression;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	888 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	889
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	890 assignment.prototype['tpmeth_expression!'] = function(val) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	891 this.expression = makeASTNode(val);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	892 return this;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros Michael Pavone <pavone@retrodev.com> parents: 213 diff changeset	893 };