repos/tabletprog: interp.js annotate

annotate interp.js @ 209:4b3b57f39f10

Implement zeroPlus macro

author	Michael Pavone <pavone@retrodev.com>
date	Wed, 27 Nov 2013 23:36:24 -0800
parents	a1b4a2bc8d72
children	d0848563f25d

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;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	80
b4a9d4e405c5 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 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	82 {
b4a9d4e405c5 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 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	84 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	85 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	86 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	87 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	88 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	89 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	90 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	91 }
b4a9d4e405c5 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 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	95 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	96 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	97 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	98 };
b4a9d4e405c5 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 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	101 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	102 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	103 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	104 };
b4a9d4e405c5 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 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	107
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	108 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	109 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	110 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	111 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	112 }
b4a9d4e405c5 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 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	114 var parsed = parseFile(this.names[name]);
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	115 this.modules[name] = parsed.macroexpand(this).eval(this);
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	116 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	117 }
b4a9d4e405c5 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 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	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 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	121 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	122 },
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	123 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	124 return false;
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	125 },
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	126 findMacro: function(name) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	127 return null;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	128 },
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	129 findQuoteTrans: function(name) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	130 return null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	131 }
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	132 }
b4a9d4e405c5 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 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	135 {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	136 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	137 this.syms = {};
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	138 this.macros = {};
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	139 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	140 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	141
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	142 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	143 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	144 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	145 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	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 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	148 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	149 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	150 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	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 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	153 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	154 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	155 }
b4a9d4e405c5 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 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	157 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	158 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	159 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	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 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	162 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	163 \|\| !this.parent
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	164 \|\| !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	165 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	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 },
b4a9d4e405c5 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 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	169 if (name in this.syms) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	170 this.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	171 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	172 }
b4a9d4e405c5 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 (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	174 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	175 }
b4a9d4e405c5 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 return false;
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	177 },
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	178 findMacro: function(name) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	179 if (name in this.syms) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	180 if (name in this.macros) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	181 return this.syms[name];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	182 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	183 return null;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	184 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	185 if (this.parent) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	186 return this.parent.findMacro(name);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	187 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	188 return null;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	189 },
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	190 findQuoteTrans: function(name) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	191 if (name in this.quotetrans) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	192 return this.quotetrans[name];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	193 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	194 if (this.parent) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	195 return this.parent.findQuoteTrans(name);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	196 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	197 return null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	198 },
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	199 defMacro: function(name, def) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	200 this.syms[name] = def;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	201 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	202 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	203 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	204
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	205 function makeASTNode(val)
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	206 {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	207 if (typeof val == 'number') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	208 return new intlit(val);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	209 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	210 if (typeof val == 'string') {
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	211 return new strlit(val);
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	212 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	213 if (val instanceof Array) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	214 return new arraylit(val);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	215 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	216 if (val == tptrue) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	217 return new symbol('true');
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	218 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	219 if (val == tpfalse) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	220 return new symbol('false');
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	221 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	222 return val;
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
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	225 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	226 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	227 var name = this.op;
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	228 if (name == '&&' \|\| name == '\|\|') {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	229 var r = (new lambda([], [this.right])).eval(env);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	230 } else {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	231 var r = this.right.eval(env);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	232 }
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	233 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	234 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	235 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	236 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	237 } else {
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	238 if (name == '&&') {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	239 name = 'if'
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	240 } else if (name == '\|\|') {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	241 name = 'ifnot'
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	242 }
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	243 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	244 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	245 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	246 };
b4a9d4e405c5 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
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	248 op.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	249 this.left = this.left.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	250 this.right = this.right.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	251 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	252 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	253
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	254 op.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	255 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	256 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	257 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	258 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	259
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	260 op.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	261 return "op";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	262 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	263
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	264 op.prototype.tpmeth_left = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	265 return this.left;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	266 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	267
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	268 op.prototype.tpmeth_right = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	269 return this.right;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	270 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	271
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	272 op.prototype.tpmeth_opName = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	273 return this.op;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	274 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	275
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	276 var quote_prefix = 0;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	277
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	278 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	279 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	280 if (res === null) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	281 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	282 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	283 return res;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	284 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	285
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	286 symbol.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	287 var val = env.find(this.name);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	288 if (val) {
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	289 var newnode = makeASTNode(val);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	290 if (!(newnode instanceof symbol)) {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	291 newnode = newnode.quote(env);
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 return newnode;
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	294 } else {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	295 var hygenic = env.findQuoteTrans(this.name);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	296 return hygenic ? new symbol(hygenic, this.symbols) : this;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	297 }
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	298 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	299
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	300 symbol.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	301 return "symbol";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	302 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	303
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	304 symbol.prototype.tpmeth_name = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	305 return this.cleanName();
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	306 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	307
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	308 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	309 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	310 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	311 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	312 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	313 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	314
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	315 symbol.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	316 intlit.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	317 floatlit.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	318 strlit.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	319 arraylit.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	320 listlit.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	321 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	322 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	323
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	324 intlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	325 floatlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	326 strlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	327 arraylit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	328 listlit.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	329 return this;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	330 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	331
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	332 intlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	333 return "intlit";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	334 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	335
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	336 floatlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	337 return "floatlit";
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 strlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	341 return "strlit";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	342 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	343
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	344 arraylit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	345 return "arraylit";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	346 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	347
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	348 listlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	349 return "strlit";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	350 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	351
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	352 intlit.prototype.tpmeth_value =
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	353 floatlit.prototype.tpmeth_value =
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	354 strlit.prototype.tpmeth_value =
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	355 arraylit.prototype.tpmeth_value =
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	356 listlit.prototype.tpmeth_value = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	357 return this.val;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	358 }
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	359
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	360 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	361 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	362 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	363 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	364 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	365 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	366 if (name == 'quote') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	367 if (this.receiver) {
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	368 return this.receiver.quote(env);
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	369 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	370 if (this.args.length) {
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	371 var cur = env;
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	372 return this.args[0].quote(env);
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	373 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	374 throw new Error('quote takes an argument');
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	375 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	376 if (name == 'macro') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	377 return null;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	378 }
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	379 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	380 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	381 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	382 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	383 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	384 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	385 if (name == 'eval:else') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	386 try {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	387 var res = args[0].eval(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	388 } catch(e) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	389 return args[2].call(null);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	390 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	391 return args[1].call(null, res);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	392 }
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	393 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	394 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	395 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	396 } else {
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	397 //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	398 try {
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	399 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	400 } catch(e) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	401 throw new Error('Error, \n\t' + e.message.split('\n').join('\n\t') + '\ninvoking method ' + name + ' on object ' + args[0]);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	402 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	403 /*} else {JSON.stringify
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	404 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	405 }*/
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	406 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	407 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	408
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	409 funcall.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	410 var name = this.name;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	411 if (name[name.length-1] == ":") {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	412 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	413 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	414 var macro = env.findMacro(name);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	415 if (this.receiver) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	416 this.receiver = this.receiver.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	417 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	418 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	419 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	420 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	421 if (!macro) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	422 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	423 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	424 var args = [];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	425 if (this.receiver) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	426 args.push(this.receiver);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	427 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	428 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	429 args.push(this.args[i]);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	430 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	431 return makeASTNode(macro.apply(null, args));
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	432 };
b4a9d4e405c5 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
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	434 funcall.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	435 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	436 var args = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	437 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	438 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	439 }
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	440 var name = this.name;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	441 if (name[name.length-1] == ":") {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	442 name = name.substr(0, name.length-1);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	443 }
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	444 var fun = env.find(name);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	445 if (fun) {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	446 fun = makeASTNode(fun);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	447 if (fun instanceof symbol) {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	448 name = fun.cleanName();
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	449 } else if (fun instanceof lambda) {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	450 throw new Error('FIXME');
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	451 }
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	452 } else {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	453 var hygenic = env.findQuoteTrans(this.name);
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	454 if (hygenic) {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	455 name = hygenic;
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	456 }
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	457 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	458 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	459 ret.receiver = receiver;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	460 return ret;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	461 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	462
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	463 funcall.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	464 return "funcall";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	465 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	466
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	467 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	468 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	469 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	470 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	471 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	472 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	473 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	474 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	475 (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	476 env.syms[name] = 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	477 return obj['tpmeth_' + name].apply(obj, arguments);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	478 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	479 })(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	480 } 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	481 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	482 obj['tprop_' + 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	483 name = 'tpmeth_' + 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	484 obj[name] = 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	485 return 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	486 };
b4a9d4e405c5 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 var setname = 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	488 obj[setname] = function(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	489 this[setname] = 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	490 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	491 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	492 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	493 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	494 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	495 } 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	496 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	497 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	498 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	499 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	500 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	501
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	502 object.prototype.macroexpand = function(parentenv) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	503 var env = new environment(parentenv);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	504 var obj = {env: env};
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	505 var outmessages = [];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	506 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	507 var msg = this.messages[i].macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	508 if (msg instanceof assignment) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	509 if (msg.expression instanceof lambda) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	510 (function(name, expr) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	511 env.syms[name] = function() {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	512 if (!obj['tpmeth_' + name]) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	513 obj['tpmeth_' + name] = expr.eval(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	514 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	515 return obj['tpmeth_' + name].apply(obj, arguments);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	516 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	517 })(msg.symbol.name, msg.expression);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	518 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	519 } 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	520 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	521 } else {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	522 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	523 /*
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	524 var makeProp = function(obj, name) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	525 obj['tprop_' + name] = msg.expression.eval(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	526 name = 'tpmeth_' + name;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	527 obj[name] = function() {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	528 return this[name];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	529 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	530 var setname = name+'!';
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	531 obj[setname] = function(val) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	532 this[setname] = val;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	533 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	534 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	535 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	536 makeProp(obj, msg.symbol.name);*/
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	537 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	538 } else {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	539 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	540 //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	541 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	542 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	543 this.messages = outmessages;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	544 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	545 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	546
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	547 object.prototype.quote = function(parentenv) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	548 var env = new environment(parentenv);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	549 var outmessages = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	550 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	551 var msg = this.messages[i];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	552 if (msg instanceof assignment) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	553 //Make sure method names don't get renamed for hygene
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	554 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	555 env.quotetrans[msg.symbol.name] = msg.symbol.name;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	556 if (msg.expression instanceof lambda) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	557 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	558 env.quotetrans[msg.symbol.name + '!'] = msg.symbol.name + '!';
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	559 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	560 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	561 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	562 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	563 var msg = this.messages[i];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	564 if (msg instanceof assignment) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	565 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	566 } else {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	567 outmessages.push(msg.quote(env));
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	568 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	569 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	570 return new object(outmessages);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	571 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	572
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	573 object.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	574 return "object";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	575 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	576
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	577 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	578 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	579 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	580 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	581 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	582 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	583 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	584 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	585 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	586 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	587 }
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	588 if (this != null && !(args.length == 0 \|\| args[0].cleanName() != 'self')) {
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	589 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	590 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	591 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	592 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	593 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	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 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	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 };
b4a9d4e405c5 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
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	599 lambda.prototype.macroexpand = function(parentenv) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	600 var env = new environment(parentenv);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	601 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	602 env.syms[this.args[i].cleanName()] = {};
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	603 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	604 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	605 var expr = this.expressions[i];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	606 if (expr instanceof assignment) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	607 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	608 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	609 } else {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	610 env.syms[expr.symbol.cleanName()] = {};
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	611 this.expressions[i] = expr.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	612 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	613 } else {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	614 this.expressions[i] = expr.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	615 }
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 this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	618 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	619
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	620 lambda.prototype.quote = function(parentenv) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	621 var args = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	622 var expressions = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	623 var env = new environment(parentenv);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	624 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	625 env.syms[this.args[i].cleanName()] = null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	626 var hygenic = '' + quote_prefix + this.args[i].cleanName();
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	627 env.quotetrans[this.args[i].cleanName()] = hygenic;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	628 args.push(new symbol(hygenic, this.args[i].symbols));
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	629 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	630 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	631 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	632 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	633 return new lambda(args, expressions);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	634 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	635
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	636 lambda.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	637 return "lambda";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	638 };
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	639
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	640 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	641 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	642 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	643 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	644 };
207 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 assignment.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	647 this.expression = this.expression.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	648 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	649 };
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	650
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	651 assignment.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	652 var name = this.symbol.cleanName();
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	653 env.syms[name] = null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	654 var hygenic = '' + quote_prefix + name;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	655 env.quotetrans[name] = hygenic;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	656 return new assignment(new symbol(hygenic, this.symbol.symbols), this.expression.quote(env));
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	657 };
209 4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	658
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	659 assignment.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	660 return "assignment";
4b3b57f39f10 Implement zeroPlus macro Michael Pavone <pavone@retrodev.com> parents: 208 diff changeset	661 };