repos/tabletprog: interp.js annotate

annotate interp.js @ 208:a1b4a2bc8d72

Initial work on pattern match macrosfor the new parser

author	Mike Pavone <pavone@retrodev.com>
date	Fri, 22 Nov 2013 19:37:25 -0800
parents	60eff5f81d9a
children	4b3b57f39f10

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 };
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	31 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	32 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	33 };
b4a9d4e405c5 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_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	35 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	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
b4a9d4e405c5 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 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	39 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	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 ? 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	43 };
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	44 String.prototype.tpmeth_length = function() {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	45 return this.length;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	46 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	47 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	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 = function(index) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	51 return this.charCodeAt(index);
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_from:withLength'] = function(pos, length) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	54 return this.substr(pos, length);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	55 };
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	56 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	57 print(this);
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	58 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	59
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	60 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	61 var ret = null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	62 for (;;) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	63 var res = this.call(null);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	64 if (res != tptrue) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	65 break;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	66 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	67 ret = body.call(null);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	68 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	69 return ret;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	70 };
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	71
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	72 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	73 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	74
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	75 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	76 {
b4a9d4e405c5 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 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	78 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	79 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	80 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	81 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	82 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	83 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	84 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	85 }
b4a9d4e405c5 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 }
b4a9d4e405c5 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 }
b4a9d4e405c5 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 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	89 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	90 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	91 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	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 (!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	95 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	96 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	97 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	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 }
b4a9d4e405c5 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
b4a9d4e405c5 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 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	103 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	104 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	105 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	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 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	108 var parsed = parseFile(this.names[name]);
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	109 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	110 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	111 }
b4a9d4e405c5 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 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	113 },
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	114 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	115 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	116 },
b4a9d4e405c5 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 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	118 return false;
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	119 },
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	120 findMacro: function(name) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	121 return null;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	122 },
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	123 findQuoteTrans: function(name) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	124 return null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	125 }
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	126 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	127
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	128 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	129 {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	130 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	131 this.syms = {};
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	132 this.macros = {};
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	133 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	134 }
b4a9d4e405c5 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 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	137 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	138 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	139 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	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 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	142 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	143 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	144 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	145 },
b4a9d4e405c5 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 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	147 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	148 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	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 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	151 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	152 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	153 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	154 },
b4a9d4e405c5 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 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	156 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	157 \|\| !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	158 \|\| !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	159 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	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 },
b4a9d4e405c5 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 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	163 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	164 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	165 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	166 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	167 if (this.parent) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	168 return this.parent.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	169 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	170 return false;
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	171 },
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	172 findMacro: function(name) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	173 if (name in this.syms) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	174 if (name in this.macros) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	175 return this.syms[name];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	176 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	177 return null;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	178 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	179 if (this.parent) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	180 return this.parent.findMacro(name);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	181 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	182 return null;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	183 },
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	184 findQuoteTrans: function(name) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	185 if (name in this.quotetrans) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	186 return this.quotetrans[name];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	187 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	188 if (this.parent) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	189 return this.parent.findQuoteTrans(name);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	190 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	191 return null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	192 },
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	193 defMacro: function(name, def) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	194 this.syms[name] = def;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	195 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	196 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	197 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	198
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	199 function makeASTNode(val)
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	200 {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	201 if (typeof val == 'number') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	202 return new intlit(val);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	203 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	204 if (typeof val == 'string') {
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	205 return new strlit(val);
207 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 (val instanceof Array) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	208 return new arraylit(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 (val == tptrue) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	211 return new symbol('true');
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 == tpfalse) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	214 return new symbol('false');
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 return val;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	217 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	218
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	219 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	220 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	221 var r = this.right.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	222 var name = this.op;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	223 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	224 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	225 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	226 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	227 } 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	228 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	229 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	230 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	231 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	232
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	233 op.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	234 this.left = this.left.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	235 this.right = this.right.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	236 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	237 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	238
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	239 op.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	240 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	241 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	242 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	243 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	244
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	245 var quote_prefix = 0;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	246
206 b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	247 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	248 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	249 if (res === null) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	250 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	251 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	252 return res;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	253 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	254
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	255 symbol.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	256 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	257 if (val) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	258 return makeASTNode(val);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	259 } else {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	260 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	261 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	262 }
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	263 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	264
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	265 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	266 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	267 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	268 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	269 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	270 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	271
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	272 symbol.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	273 intlit.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	274 floatlit.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	275 strlit.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	276 arraylit.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	277 listlit.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	278 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	279 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	280
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	281 intlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	282 floatlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	283 strlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	284 arraylit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	285 listlit.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	286 return this;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	287 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	288
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	289 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	290 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	291 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	292 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	293 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	294 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	295 if (name == 'quote') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	296 if (this.receiver) {
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	297 return this.receiver.quote(env);
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	298 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	299 if (this.args.length) {
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	300 return this.args[0].quote(env);
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	301 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	302 throw new Error('quote takes an argument');
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	303 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	304 if (name == 'macro') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	305 return null;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	306 }
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	307 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	308 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	309 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	310 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	311 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	312 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	313 if (name == 'eval:else') {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	314 try {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	315 var res = args[0].eval(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	316 } catch(e) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	317 return args[2].call(null);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	318 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	319 return args[1].call(null, res);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	320 }
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	321 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	322 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	323 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	324 } else {
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	325 //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	326 try {
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	327 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	328 } catch(e) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	329 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	330 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	331 /*} else {JSON.stringify
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	332 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	333 }*/
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	334 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	335 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	336
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	337 funcall.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	338 var name = this.name;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	339 if (name[name.length-1] == ":") {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	340 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	341 }
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	342 var macro = env.findMacro(name);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	343 if (this.receiver) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	344 this.receiver = this.receiver.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	345 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	346 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	347 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	348 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	349 if (!macro) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	350 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	351 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	352 var args = [];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	353 if (this.receiver) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	354 args.push(this.receiver);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	355 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	356 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	357 args.push(this.args[i]);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	358 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	359 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	360 };
b4a9d4e405c5 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
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	362 funcall.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	363 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	364 var args = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	365 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	366 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	367 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	368 var name = env.findQuoteTrans(this.name);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	369 if (!name) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	370 name = this.name;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	371 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	372 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	373 ret.receiver = receiver;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	374 return ret;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	375 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	376
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	377 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	378 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	379 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	380 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	381 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	382 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	383 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	384 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	385 (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	386 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	387 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	388 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	389 })(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	390 } 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	391 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	392 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	393 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	394 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	395 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	396 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	397 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	398 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	399 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	400 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	401 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	402 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	403 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	404 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	405 } 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	406 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	407 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	408 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	409 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	410 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	411
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	412 object.prototype.macroexpand = function(parentenv) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	413 var env = new environment(parentenv);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	414 var obj = {env: env};
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	415 var outmessages = [];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	416 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	417 var msg = this.messages[i].macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	418 if (msg instanceof assignment) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	419 if (msg.expression instanceof lambda) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	420 (function(name, expr) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	421 env.syms[name] = function() {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	422 if (!obj['tpmeth_' + name]) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	423 obj['tpmeth_' + name] = expr.eval(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	424 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	425 return obj['tpmeth_' + name].apply(obj, arguments);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	426 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	427 })(msg.symbol.name, msg.expression);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	428 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	429 } 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	430 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	431 } else {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	432 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	433 /*
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	434 var makeProp = function(obj, name) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	435 obj['tprop_' + name] = msg.expression.eval(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	436 name = 'tpmeth_' + name;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	437 obj[name] = function() {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	438 return this[name];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	439 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	440 var setname = name+'!';
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	441 obj[setname] = function(val) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	442 this[setname] = val;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	443 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	444 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	445 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	446 makeProp(obj, msg.symbol.name);*/
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	447 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	448 } else {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	449 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	450 //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	451 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	452 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	453 this.messages = outmessages;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	454 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	455 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	456
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	457 object.prototype.quote = function(parentenv) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	458 var env = new environment(parentenv);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	459 var outmessages = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	460 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	461 var msg = this.messages[i];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	462 if (msg instanceof assignment) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	463 //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	464 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	465 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	466 if (msg.expression instanceof lambda) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	467 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	468 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	469 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	470 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	471 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	472 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	473 var msg = this.messages[i];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	474 if (msg instanceof assignment) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	475 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	476 } else {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	477 outmessages.push(msg.quote(env));
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	478 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	479 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	480 return new object(outmessages);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	481 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	482
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	483 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	484 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	485 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	486 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	487 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	488 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	489 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	490 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	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 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	493 }
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	494 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	495 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	496 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	497 var 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	498 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	499 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	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 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	502 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	503 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it Mike Pavone <pavone@retrodev.com> parents: diff changeset	504
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	505 lambda.prototype.macroexpand = function(parentenv) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	506 var env = new environment(parentenv);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	507 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	508 env.syms[this.args[i].cleanName()] = {};
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	509 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	510 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	511 var expr = this.expressions[i];
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	512 if (expr instanceof assignment) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	513 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	514 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	515 } else {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	516 env.syms[expr.symbol.cleanName()] = {};
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	517 this.expressions[i] = expr.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	518 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	519 } else {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	520 this.expressions[i] = expr.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	521 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	522 }
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	523 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	524 };
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	525
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	526 lambda.prototype.quote = function(parentenv) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	527 var args = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	528 var expressions = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	529 var env = new environment(parentenv);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	530 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	531 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	532 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	533 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	534 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	535 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	536 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	537 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	538 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	539 return new lambda(args, expressions);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	540 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	541
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	542 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	543 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	544 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	545 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	546 };
207 60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	547
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	548 assignment.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	549 this.expression = this.expression.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	550 return this;
60eff5f81d9a Basic implementation of macros is now working Mike Pavone <pavone@retrodev.com> parents: 206 diff changeset	551 };
208 a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	552
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	553 assignment.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	554 var name = this.symbol.cleanName();
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	555 env.syms[name] = null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	556 var hygenic = '' + quote_prefix + name;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	557 env.quotetrans[name] = hygenic;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser Mike Pavone <pavone@retrodev.com> parents: 207 diff changeset	558 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	559 };