Mercurial > repos > tabletprog

annotate interp.js @ 317:6dfbf5691a7f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Move where additional parameters are inserted in gcc command line so that additional libs can be specified
author Michael Pavone <pavone@retrodev.com>
date Thu, 19 Mar 2015 22:39:42 -0700
parents d4df33596e7d
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1 Number.prototype['tpmeth_+'] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2 return this + other;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
4 Number.prototype['tpmeth_-'] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
5 return this - other;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
6 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
7 Number.prototype['tpmeth_*'] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
8 return this * other;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
9 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
10 Number.prototype['tpmeth_/'] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
11 return this / other;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
12 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
13 Number.prototype['tpmeth_='] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
14 return this == other ? tptrue : tpfalse;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
15 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
16 Number.prototype['tpmeth_>'] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
17 return this > other ? tptrue : tpfalse;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
18 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
19 Number.prototype['tpmeth_<'] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
20 return this < other ? tptrue : tpfalse;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
21 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
22 Number.prototype['tpmeth_>='] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
23 return this >= other ? tptrue : tpfalse;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
24 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
25 Number.prototype['tpmeth_<='] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
26 return this <= other ? tptrue : tpfalse;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
27 };
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
28 Number.prototype.tpmeth_asStringChar = function() {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
29 return String.fromCharCode(this);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
30 };
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
31 Number.prototype['tpmeth_isString?'] = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
32 return false;
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
33 };
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
34 Number.prototype.tpmeth_string = function() {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
35 return '' + this;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
36 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
37 Number.prototype.tpmeth_print = function() {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
38 print(this);
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
39 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
40
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
41 String.prototype['tpmeth_.'] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
42 return this + other;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
43 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
44 String.prototype['tpmeth_='] = function(other) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
45 return this == other ? tptrue : tpfalse;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
46 };
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
47 String.prototype.tpmeth_length = function() {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
48 return this.length;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
49 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
50 String.prototype.tpmeth_byte_length = function() {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
51 return this.length;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
52 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
53 String.prototype.tpmeth_byte = function(index) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
54 return this.charCodeAt(index);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
55 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
56 String.prototype['tpmeth_from:withLength'] = function(pos, length) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
57 return this.substr(pos, length);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
58 };
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
59 String.prototype['tpmeth_isString?'] = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
60 return true;
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
61 };
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
62 String.prototype.tpmeth_print = function() {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
63 print(this);
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
64 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
65
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
66 Function.prototype['tpmeth_while:do'] = function(body) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
67 var ret = null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
68 for (;;) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
69 var res = this.call(null);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
70 if (res != tptrue) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
71 break;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
72 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
73 ret = body.call(null);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
74 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
75 return ret;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
76 };
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
77
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
78 var tptrue = null;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
79 var tpfalse = null;
210
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
80 var tplist = null;
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
81
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
82 function topenv(moduledirs)
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
83 {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
84 this.names = {};
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
85 this.modules = {};
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
86 for (var dirnum in moduledirs) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
87 var results = os.system("ls", [moduledirs[dirnum]]).split('\n');
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
88 for (var i in results) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
89 var tpidx = results[i].indexOf('.tp')
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
90 if (tpidx > 0 && tpidx == results[i].length - 3) {
314
d4df33596e7d Make modules in earlier module directories take precedence over ones in later directories
Michael Pavone <pavone@retrodev.com>
parents: 312
diff changeset
91 var moduleName = results[i].substr(0, tpidx);
d4df33596e7d Make modules in earlier module directories take precedence over ones in later directories
Michael Pavone <pavone@retrodev.com>
parents: 312
diff changeset
92 if (!(moduleName in this.names)) {
d4df33596e7d Make modules in earlier module directories take precedence over ones in later directories
Michael Pavone <pavone@retrodev.com>
parents: 312
diff changeset
93 this.names[moduleName] = moduledirs[dirnum] + "/" + results[i];
d4df33596e7d Make modules in earlier module directories take precedence over ones in later directories
Michael Pavone <pavone@retrodev.com>
parents: 312
diff changeset
94 }
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
95 }
b4a9d4e405c5 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 }
b4a9d4e405c5 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 }
b4a9d4e405c5 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 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
99 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
100 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
101 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
102 };
b4a9d4e405c5 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 }
b4a9d4e405c5 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 (!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
105 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
106 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
107 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
108 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
109 }
210
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
110 if (!tplist) {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
111 tplist = this.find('list');
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
112 if (tplist instanceof Function) {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
113 tplist = tplist.call(null);
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
114 }
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
115 }
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
116 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
117
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
118 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
119 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
120 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
121 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
122 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
123 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
124 var parsed = parseFile(this.names[name]);
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
125 var ret = parsed.macroexpand(this).eval(this);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
126 if (typeof ret == 'function') {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
127 ret = ret();
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
128 }
312
8511aac1ce82 Fix module references in macros
Michael Pavone <pavone@retrodev.com>
parents: 281
diff changeset
129 ret.ismodule = true;
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
130 this.modules[name] = ret;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
131 return ret;
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
132 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
133 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
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 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
136 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
137 },
b4a9d4e405c5 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 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
139 return false;
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
140 },
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
141 findMacro: function(name) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
142 return null;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
143 },
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
144 findQuoteTrans: function(name) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
145 return null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
146 }
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
147 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
148
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
149 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
150 {
b4a9d4e405c5 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 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
152 this.syms = {};
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
153 this.macros = {};
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
154 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
155 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
156
b4a9d4e405c5 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 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
158 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
159 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
160 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
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 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
163 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
164 }
b4a9d4e405c5 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 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
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 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
168 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
169 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
170 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
171 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
172 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
173 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
174 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
175 },
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
176 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
177 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
178 || !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
179 || !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
180 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
181 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
182 },
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
183 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
184 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
185 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
186 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
187 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
188 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
189 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
190 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
191 return false;
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
192 },
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
193 findMacro: function(name) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
194 if (name in this.syms) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
195 if (name in this.macros) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
196 return this.syms[name];
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
197 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
198 return null;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
199 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
200 if (this.parent) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
201 return this.parent.findMacro(name);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
202 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
203 return null;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
204 },
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
205 findQuoteTrans: function(name) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
206 if (name in this.quotetrans) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
207 return this.quotetrans[name];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
208 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
209 if (this.parent) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
210 return this.parent.findQuoteTrans(name);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
211 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
212 return null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
213 },
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
214 defMacro: function(name, def) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
215 this.syms[name] = def;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
216 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
217 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
218 };
b4a9d4e405c5 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
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
220 function makeASTNode(val)
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
221 {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
222 if (typeof val == 'number') {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
223 return new intlit(val);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
224 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
225 if (typeof val == 'string') {
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
226 return new strlit(val);
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
227 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
228 if (val instanceof Array) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
229 return new arraylit(val);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
230 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
231 if (val == tptrue) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
232 return new symbol('true');
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
233 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
234 if (val == tpfalse) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
235 return new symbol('false');
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
236 }
221
218b11ec8fa2 Better handling for weird values being inserted into AST due to quoting
Michael Pavone <pavone@retrodev.com>
parents: 219
diff changeset
237 if ('makeHygienic' in val) {
218b11ec8fa2 Better handling for weird values being inserted into AST due to quoting
Michael Pavone <pavone@retrodev.com>
parents: 219
diff changeset
238 return val;
218b11ec8fa2 Better handling for weird values being inserted into AST due to quoting
Michael Pavone <pavone@retrodev.com>
parents: 219
diff changeset
239 }
218b11ec8fa2 Better handling for weird values being inserted into AST due to quoting
Michael Pavone <pavone@retrodev.com>
parents: 219
diff changeset
240 return null;
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
241 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
242
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
243 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
244 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
245 var name = this.op;
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
246 if (name == '&&' || name == '||') {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
247 var r = (new lambda([], [this.right])).eval(env);
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
248 } else {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
249 var r = this.right.eval(env);
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
250 }
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
251 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
252 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
253 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
254 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
255 } else {
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
256 if (name == '&&') {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
257 name = 'if'
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
258 } else if (name == '||') {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
259 name = 'ifnot'
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
260 } else if (name == '|') {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
261 return r['tpmeth_|'](l);
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
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 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
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 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
266 };
b4a9d4e405c5 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
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
268 op.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
269 this.left = this.left.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
270 this.right = this.right.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
271 return this;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
272 };
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
273
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
274 op.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
275 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
276 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
277 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
278 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
279
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
280 op.prototype.makeHygienic = function(env) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
281 var left = this.left.makeHygienic(env);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
282 var right = this.right.makeHygienic(env);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
283 return new op(left, this.op, right);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
284 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
285
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
286 op.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
287 return "op";
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
288 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
289
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
290 op.prototype.tpmeth_left = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
291 return this.left;
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
292 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
293
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
294 op.prototype.tpmeth_right = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
295 return this.right;
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
296 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
297
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
298 op.prototype.tpmeth_opName = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
299 return this.op;
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
300 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
301
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
302 var quote_prefix = 0;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
303
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
304 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
305 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
306 if (res === null) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
307 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
308 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
309 return res;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
310 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
311
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
312 symbol.prototype.quote = function(env) {
280
23b52d2d05a0 Don't try to replace self in a macro expansion since it's unlikely to be the desired behavior. A more explicit means of specifying what variables should be replaced in a quote expression is needed.
Michael Pavone <pavone@retrodev.com>
parents: 273
diff changeset
313 if (this.cleanName() != 'self') {
23b52d2d05a0 Don't try to replace self in a macro expansion since it's unlikely to be the desired behavior. A more explicit means of specifying what variables should be replaced in a quote expression is needed.
Michael Pavone <pavone@retrodev.com>
parents: 273
diff changeset
314 var val = env.find(this.name);
23b52d2d05a0 Don't try to replace self in a macro expansion since it's unlikely to be the desired behavior. A more explicit means of specifying what variables should be replaced in a quote expression is needed.
Michael Pavone <pavone@retrodev.com>
parents: 273
diff changeset
315 if (val !== null) {
312
8511aac1ce82 Fix module references in macros
Michael Pavone <pavone@retrodev.com>
parents: 281
diff changeset
316 if (val.ismodule) {
8511aac1ce82 Fix module references in macros
Michael Pavone <pavone@retrodev.com>
parents: 281
diff changeset
317 return this;
8511aac1ce82 Fix module references in macros
Michael Pavone <pavone@retrodev.com>
parents: 281
diff changeset
318 } else {
8511aac1ce82 Fix module references in macros
Michael Pavone <pavone@retrodev.com>
parents: 281
diff changeset
319 var newnode = makeASTNode(val);
8511aac1ce82 Fix module references in macros
Michael Pavone <pavone@retrodev.com>
parents: 281
diff changeset
320 if (!newnode) {
8511aac1ce82 Fix module references in macros
Michael Pavone <pavone@retrodev.com>
parents: 281
diff changeset
321 throw new Error(this.name + ' contains a value ' + val + ' that could not be converted to an AST node');
8511aac1ce82 Fix module references in macros
Michael Pavone <pavone@retrodev.com>
parents: 281
diff changeset
322 }
8511aac1ce82 Fix module references in macros
Michael Pavone <pavone@retrodev.com>
parents: 281
diff changeset
323 return newnode;
280
23b52d2d05a0 Don't try to replace self in a macro expansion since it's unlikely to be the desired behavior. A more explicit means of specifying what variables should be replaced in a quote expression is needed.
Michael Pavone <pavone@retrodev.com>
parents: 273
diff changeset
324 }
23b52d2d05a0 Don't try to replace self in a macro expansion since it's unlikely to be the desired behavior. A more explicit means of specifying what variables should be replaced in a quote expression is needed.
Michael Pavone <pavone@retrodev.com>
parents: 273
diff changeset
325 } else {
23b52d2d05a0 Don't try to replace self in a macro expansion since it's unlikely to be the desired behavior. A more explicit means of specifying what variables should be replaced in a quote expression is needed.
Michael Pavone <pavone@retrodev.com>
parents: 273
diff changeset
326 this.dirty = true;
23b52d2d05a0 Don't try to replace self in a macro expansion since it's unlikely to be the desired behavior. A more explicit means of specifying what variables should be replaced in a quote expression is needed.
Michael Pavone <pavone@retrodev.com>
parents: 273
diff changeset
327 return this;
221
218b11ec8fa2 Better handling for weird values being inserted into AST due to quoting
Michael Pavone <pavone@retrodev.com>
parents: 219
diff changeset
328 }
281
f6dfb85e80e5 Forgot to return this in previous self fix
Michael Pavone <pavone@retrodev.com>
parents: 280
diff changeset
329 } else {
f6dfb85e80e5 Forgot to return this in previous self fix
Michael Pavone <pavone@retrodev.com>
parents: 280
diff changeset
330 return this;
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
331 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
332 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
333
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
334 symbol.prototype.makeHygienic = function(env) {
240
dc5f487247ee Don't rename the symbol self in quote blocks
Mike Pavone <pavone@retrodev.com>
parents: 238
diff changeset
335 if (this.dirty && this.cleanName() != 'self') {
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
336 var hygenic = env.findQuoteTrans(this.cleanName());
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
337 if (hygenic)
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
338 {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
339 return new symbol(hygenic, this.symbols);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
340 } else {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
341 return this;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
342 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
343 } else {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
344 return this;
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
345 }
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
346 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
347
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
348 symbol.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
349 return "symbol";
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
350 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
351
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
352 symbol.prototype.tpmeth_name = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
353 return this.cleanName();
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
354 };
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
355 symbol.prototype['tpmeth_name!'] = function(val) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
356 this.name = val;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
357 return this;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
358 };
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
359
255
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
360 intlit.prototype.isconstant =
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
361 floatlit.prototype.isconstant =
280
23b52d2d05a0 Don't try to replace self in a macro expansion since it's unlikely to be the desired behavior. A more explicit means of specifying what variables should be replaced in a quote expression is needed.
Michael Pavone <pavone@retrodev.com>
parents: 273
diff changeset
362 strlit.prototype.isconstant =
255
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
363 lambda.prototype.isconstant = function() {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
364 return true;
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
365 };
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
366
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
367 object.prototype.isconstant =
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
368 symbol.prototype.isconstant =
280
23b52d2d05a0 Don't try to replace self in a macro expansion since it's unlikely to be the desired behavior. A more explicit means of specifying what variables should be replaced in a quote expression is needed.
Michael Pavone <pavone@retrodev.com>
parents: 273
diff changeset
369 funcall.prototype.isconstant =
23b52d2d05a0 Don't try to replace self in a macro expansion since it's unlikely to be the desired behavior. A more explicit means of specifying what variables should be replaced in a quote expression is needed.
Michael Pavone <pavone@retrodev.com>
parents: 273
diff changeset
370 op.prototype.isconstant =
255
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
371 assignment.prototype.isconstant = function() {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
372 return false;
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
373 }
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
374
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
375 arraylit.prototype.isconstant =
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
376 listlit.prototype.isconstant = function() {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
377 for (var idx = 0; idx < this.val.length; ++idx) {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
378 if (!this.val[idx].isconstant()) {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
379 return false;
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
380 }
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
381 }
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
382 return true;
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
383 };
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
384
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
385 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
386 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
387 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
388 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
389 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
390 };
b4a9d4e405c5 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
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
392 listlit.prototype.eval = function(env) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
393 var cur = tplist.tpmeth_empty();
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
394 for (var idx = this.val.length - 1; idx >= 0; --idx) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
395 cur = tplist['tpmeth_node:withTail'](this.val[idx].eval(env), cur);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
396 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
397 return cur;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
398 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
399
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
400 symbol.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
401 intlit.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
402 floatlit.prototype.macroexpand =
210
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
403 strlit.prototype.macroexpand = function(env) {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
404 return this;
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
405 };
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
406
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
407
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
408 arraylit.prototype.macroexpand =
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
409 listlit.prototype.macroexpand = function(env) {
210
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
410 for (var i = 0; i < this.val.length; i++) {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
411 this.val[i] = this.val[i].macroexpand(env);
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
412 }
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
413 return this;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
414 };
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
415
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
416 intlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
417 floatlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
418 strlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
419 arraylit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
420 listlit.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
421 return this;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
422 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
423
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
424 intlit.prototype.makeHygienic =
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
425 floatlit.prototype.makeHygienic =
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
426 strlit.prototype.makeHygienic =
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
427 arraylit.prototype.makeHygienic =
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
428 listlit.prototype.makeHygienic = function(env) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
429 return this;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
430 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
431
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
432 intlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
433 return "intlit";
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
434 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
435
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
436 floatlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
437 return "floatlit";
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
438 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
439
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
440 strlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
441 return "strlit";
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
442 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
443
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
444 arraylit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
445 return "arraylit";
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
446 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
447
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
448 listlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
449 return "strlit";
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
450 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
451
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
452 intlit.prototype.tpmeth_value =
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
453 floatlit.prototype.tpmeth_value =
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
454 strlit.prototype.tpmeth_value =
210
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
455 arraylit.prototype.tpmeth_value = function() {
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
456 return this.val;
210
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
457 };
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
458
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
459 listlit.prototype.tpmeth_value = function() {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
460 var cur = tplist.tpmeth_empty();
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
461 for (var idx = this.val.length - 1; idx >= 0; --idx) {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
462 cur = tplist['tpmeth_node:withTail'](this.val[idx], cur);
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
463 }
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
464 return cur;
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
465 };
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
466
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
467 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
468 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
469 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
470 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
471 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
472 }
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
473 if (name == 'quote') {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
474 if (this.receiver) {
224
97c3e33cd3f4 Support macro expansion inside quoted code
Michael Pavone <pavone@retrodev.com>
parents: 221
diff changeset
475 return this.receiver.quote(env).macroexpand(env);
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
476 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
477 if (this.args.length) {
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
478 var cur = env;
224
97c3e33cd3f4 Support macro expansion inside quoted code
Michael Pavone <pavone@retrodev.com>
parents: 221
diff changeset
479 return this.args[0].quote(env).macroexpand(env);
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
480 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
481 throw new Error('quote takes an argument');
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
482 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
483 if (name == 'macro') {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
484 return null;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
485 }
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
486 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
487 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
488 }
b4a9d4e405c5 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 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
490 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
491 }
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
492 if (name == 'eval:else') {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
493 try {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
494 var res = args[0].eval(env);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
495 } catch(e) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
496 return args[2].call(null);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
497 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
498 return args[1].call(null, res);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
499 }
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
500 var fun = env.findNoTop(name);
210
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
501 if (fun && (fun.numargs === undefined || fun.numargs == args.length)) {
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
502 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
503 } else {
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
504 //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
505 try {
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
506 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
507 } catch(e) {
210
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
508 var msg = 'Error, \n\t' + e.message.split('\n').join('\n\t') + '\ninvoking method ' + name + ' on object ' + args[0];
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
509 if (typeof args[0] == 'object') {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
510 msg += ' with keys ' + JSON.stringify(Object.keys(args[0]) + ' and constructor ' + args[0].constructor.name);
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
511 }
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
512 throw new Error(msg);
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
513 }
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
514 /*} else {JSON.stringify
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
515 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
516 }*/
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
517 }
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
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
520 funcall.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
521 var name = this.name;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
522 if (name[name.length-1] == ":") {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
523 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
524 }
224
97c3e33cd3f4 Support macro expansion inside quoted code
Michael Pavone <pavone@retrodev.com>
parents: 221
diff changeset
525 if (name == 'quote') {
97c3e33cd3f4 Support macro expansion inside quoted code
Michael Pavone <pavone@retrodev.com>
parents: 221
diff changeset
526 return this;
97c3e33cd3f4 Support macro expansion inside quoted code
Michael Pavone <pavone@retrodev.com>
parents: 221
diff changeset
527 }
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
528 var macro = env.findMacro(name);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
529 if (this.receiver) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
530 this.receiver = this.receiver.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
531 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
532 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
533 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
534 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
535 if (!macro) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
536 return this;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
537 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
538 var args = [];
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
539 if (this.receiver) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
540 args.push(this.receiver);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
541 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
542 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
543 args.push(this.args[i]);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
544 }
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
545 var ret = makeASTNode(macro.apply(null, args));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
546 ret = ret.makeHygienic(env);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
547 quote_prefix++;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
548 return ret;
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
549 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
550
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
551 funcall.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
552 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
553 var args = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
554 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
555 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
556 }
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
557 var name = this.name;
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
558 if (name[name.length-1] == ":") {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
559 name = name.substr(0, name.length-1);
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
560 }
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
561 var fun = env.find(name);
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
562 if (fun) {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
563 fun = makeASTNode(fun);
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
564 if (fun instanceof symbol) {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
565 name = fun.cleanName();
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
566 } else if (fun instanceof lambda) {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
567 throw new Error('FIXME');
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
568 }
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
569 } else {
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
570 this.dirty = true;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
571 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
572 var ret = new funcall(name, args);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
573 ret.receiver = receiver;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
574 return ret;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
575 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
576
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
577 funcall.prototype.makeHygienic = function(env) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
578 var receiver = this.receiver ? this.receiver.makeHygienic(env) : null;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
579 var args = [];
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
580 for (var i = 0; i < this.args.length; i++) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
581 args.push(this.args[i].makeHygienic(env));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
582 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
583 var name = this.name;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
584 if (name[name.length-1] == ":") {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
585 name = name.substr(0, name.length-1);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
586 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
587 var hygienic = env.findQuoteTrans(name);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
588 if (hygienic) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
589 name = hygienic;
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
590 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
591 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
592 ret.receiver = receiver;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
593 return ret;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
594 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
595
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
596 funcall.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
597 return "funcall";
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
598 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
599
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
600 funcall.prototype['tpmeth_args!'] = function(arglist) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
601 this.args = [];
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
602 //TODO: Finish this
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
603 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
604
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
605 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
606 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
607 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
608 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
609 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
610 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
611 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
612 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
613 (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
614 env.syms[name] = function() {
210
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
615 var ret = obj['tpmeth_' + name].apply(obj, arguments);
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
616 return ret;
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
617 };
210
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
618 env.syms[name].numargs = msg.expression.numArgs();
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
619 })(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
620 } 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
621 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
622 obj['tprop_' + name] = msg.expression.eval(env);
210
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
623 obj['tpmeth_' + name] = function() {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
624 return this['tprop_'+name];
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
625 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
626 var setname = name+'!';
210
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
627 obj['tpmeth_' + setname] = function(val) {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
628 this['tprop_'+name] = val;
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
629 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
630 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
631 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
632 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
633 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
634 } 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
635 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
636 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
637 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
638 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
639 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
640
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
641 object.prototype.macroexpand = function(parentenv) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
642 var env = new environment(parentenv);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
643 var obj = {env: env};
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
644 var outmessages = [];
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
645 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
646 var msg = this.messages[i].macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
647 if (msg instanceof assignment) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
648 if (msg.expression instanceof lambda) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
649 (function(name, expr) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
650 env.syms[name] = function() {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
651 if (!obj['tpmeth_' + name]) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
652 obj['tpmeth_' + name] = expr.eval(env);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
653 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
654 return obj['tpmeth_' + name].apply(obj, arguments);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
655 };
210
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
656 env.syms[name].numargs = expr.numArgs();
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
657 })(msg.symbol.name, msg.expression);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
658 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
659 } 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
660 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
661 } else {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
662 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
663 /*
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
664 var makeProp = function(obj, name) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
665 obj['tprop_' + name] = msg.expression.eval(env);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
666 name = 'tpmeth_' + name;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
667 obj[name] = function() {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
668 return this[name];
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
669 };
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
670 var setname = name+'!';
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
671 obj[setname] = function(val) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
672 this[setname] = val;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
673 return this;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
674 };
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
675 };
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
676 makeProp(obj, msg.symbol.name);*/
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
677 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
678 } else {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
679 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
680 //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
681 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
682 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
683 this.messages = outmessages;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
684 return this;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
685 };
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
686
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
687 object.prototype.quote = function(parentenv) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
688 var env = new environment(parentenv);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
689 var outmessages = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
690 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
691 var msg = this.messages[i];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
692 if (msg instanceof assignment) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
693 env.syms[msg.symbol.name] = null;
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
694 if (!(msg.expression instanceof lambda)) {
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
695 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
696 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
697 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
698 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
699 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
700 var msg = this.messages[i];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
701 if (msg instanceof assignment) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
702 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
703 } else {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
704 outmessages.push(msg.quote(env));
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
705 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
706 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
707 return new object(outmessages);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
708 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
709
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
710 object.prototype.makeHygienic = function(parentenv) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
711 var env = new environment(parentenv);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
712 var outmessages = [];
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
713 for (var i = 0; i < this.messages.length; i++) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
714 var msg = this.messages[i];
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
715 if (msg instanceof assignment) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
716 env.syms[msg.symbol.name] = null;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
717 //make sure method names don't get translated for hygiene
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
718 env.quotetrans[msg.symbol.name] = null;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
719 if (!(msg.expression instanceof lambda)) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
720 env.syms[msg.symbol.name + '!'] = null;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
721 env.quotetrans[msg.symbol.name + '!'] = null;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
722 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
723 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
724 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
725 for (var i = 0; i < this.messages.length; i++) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
726 var msg = this.messages[i];
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
727 if (msg instanceof assignment) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
728 outmessages.push(new assignment(msg.symbol, msg.expression.makeHygienic(env)));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
729 } else {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
730 outmessages.push(msg.makeHygienic(env));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
731 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
732 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
733 return new object(outmessages);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
734 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
735
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
736 object.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
737 return "object";
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
738 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
739
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
740 object.prototype.tpmeth_addMessage = function(message) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
741 this.messages.push(makeASTNode(message));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
742 return this;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
743 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
744
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
745 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
746 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
747 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
748 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
749 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
750 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
751 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
752 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
753 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
754 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
755 }
210
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
756 if (this != null) {
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
757 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
758 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
759 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
760 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
761 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
762 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
763 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
764 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
765 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
766
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
767 lambda.prototype.macroexpand = function(parentenv) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
768 var env = new environment(parentenv);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
769 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
770 env.syms[this.args[i].cleanName()] = {};
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
771 }
273
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object.
Michael Pavone <pavone@retrodev.com>
parents: 255
diff changeset
772 var outexprs = []
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
773 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
774 var expr = this.expressions[i];
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
775 if (expr instanceof assignment) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
776 if (expr.expression instanceof funcall && expr.expression.name == 'macro:') {
273
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object.
Michael Pavone <pavone@retrodev.com>
parents: 255
diff changeset
777 env.defMacro(expr.symbol.name, expr.expression.args[0].eval(env));
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
778 } else {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
779 env.syms[expr.symbol.cleanName()] = {};
273
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object.
Michael Pavone <pavone@retrodev.com>
parents: 255
diff changeset
780 outexprs.push(expr.macroexpand(env));
255
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
781 try {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
782 if (this.expressions[i].expression.isconstant()) {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
783 env.syms[expr.symbol.cleanName()] = this.expressions[i].expression.eval(env);
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
784 } else {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
785 env.syms[expr.symbol.cleanName()] = null;
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
786 }
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
787 } catch(e) {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
788 var msg = 'Error, \n\t' + e.message.split('\n').join('\n\t') + '\nevaling node ' + this.expressions[i].expression
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
789 if (typeof this.expressions[i].expression == 'object') {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
790 msg += ' with keys ' + JSON.stringify(Object.keys(this.expressions[i].expression) + ' and constructor ' + this.expressions[i].expression.constructor.name);
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
791 }
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
792 throw new Error(msg);
238
3bfc00e4f5e5 Eval lambda assignments at macro expandion time so they can be called by macros
Mike Pavone <pavone@retrodev.com>
parents: 224
diff changeset
793 }
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
794 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
795 } else {
273
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object.
Michael Pavone <pavone@retrodev.com>
parents: 255
diff changeset
796 outexprs.push(expr.macroexpand(env));
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
797 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
798 }
273
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object.
Michael Pavone <pavone@retrodev.com>
parents: 255
diff changeset
799 this.expressions = outexprs;
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
800 return this;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
801 };
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
802
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
803 lambda.prototype.quote = function(parentenv) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
804 var args = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
805 var expressions = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
806 var env = new environment(parentenv);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
807 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
808 env.syms[this.args[i].cleanName()] = null;
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
809 var sym = new symbol(this.args[i].name, this.args[i].symbols);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
810 sym.dirty = true;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
811 args.push(sym);
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
812 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
813 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
814 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
815 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
816 return new lambda(args, expressions);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
817 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
818
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
819 lambda.prototype.makeHygienic = function(parentenv) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
820 var args = [];
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
821 var expressions = [];
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
822 var env = new environment(parentenv);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
823 for (var i = 0; i < this.args.length; i++) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
824 env.syms[this.args[i].cleanName()] = null;
240
dc5f487247ee Don't rename the symbol self in quote blocks
Mike Pavone <pavone@retrodev.com>
parents: 238
diff changeset
825 if (this.args[i].dirty && this.args[i].cleanName() != 'self') {
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
826 var hygienic = '' + quote_prefix + this.args[i].cleanName();
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
827 env.quotetrans[this.args[i].cleanName()] = hygienic;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
828 args.push(new symbol(hygienic, this.args[i].symbols));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
829 } else {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
830 args.push(this.args[i]);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
831 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
832 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
833 for (var i = 0; i < this.expressions.length; i++) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
834 expressions.push(this.expressions[i].makeHygienic(env));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
835 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
836 return new lambda(args, expressions);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
837 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
838
210
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
839 lambda.prototype.numArgs = function() {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
840 var num = this.args.length;
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
841 if (num && (this.args[0].cleanName() == 'self')) {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
842 --num;
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
843 }
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
844 return num;
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
845 };
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
846
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
847 lambda.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
848 return "lambda";
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
849 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
850
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
851 lambda.prototype.tpmeth_args = function() {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
852 var cur = tplist.tpmeth_empty();
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
853 for (var idx = this.args.length - 1; idx >= 0; --idx) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
854 cur = tplist['tpmeth_node:withTail'](this.args[idx], cur);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
855 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
856 return cur;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
857 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
858
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
859 lambda.prototype.tpmeth_expressions = function() {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
860 var cur = tplist.tpmeth_empty();
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
861 for (var idx = this.expressions.length - 1; idx >= 0; --idx) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
862 cur = tplist['tpmeth_node:withTail'](this.expressions[idx], cur);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
863 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
864 return cur;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
865 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
866
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
867 lambda.prototype['tpmeth_expressions!'] = function(exprs) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
868 var expressions = [];
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
869 while (!exprs['tpmeth_empty?']().valueOf()) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
870 expressions.push(makeASTNode(exprs.tpmeth_value()));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
871 exprs = exprs.tpmeth_tail();
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
872 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
873 this.expressions = expressions;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
874 return this;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
875 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
876
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
877 lambda.prototype.tpmeth_addExpression = function(expr) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
878 this.expressions.push(makeASTNode(expr));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
879 return this;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
880 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
881
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
882 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
883 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
884 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
885 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
886 };
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
887
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
888 assignment.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
889 this.expression = this.expression.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
890 return this;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
891 };
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
892
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
893 assignment.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
894 var name = this.symbol.cleanName();
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
895 var val = env.find(name);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
896 var dirty = true;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
897 if (val) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
898 var node = makeASTNode(val);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
899 if (!(node instanceof symbol)) {
221
218b11ec8fa2 Better handling for weird values being inserted into AST due to quoting
Michael Pavone <pavone@retrodev.com>
parents: 219
diff changeset
900 throw new Error('Left hand side of assignment expression must be a symbol not a '+ node.constructor.name + ' '+(typeof node) + ', old name was ' + name);
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
901 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
902 name = node.cleanName();
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
903 dirty = node.dirty;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
904 }
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
905 env.syms[name] = null;
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
906 var sym = new symbol(name, this.symbol.symbols);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
907 sym.dirty = dirty;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
908 return new assignment(sym, this.expression.quote(env));
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
909 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
910
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
911 assignment.prototype.makeHygienic = function(env) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
912 var name = this.symbol.cleanName();
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
913 env.syms[name] = null;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
914 if (this.symbol.dirty) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
915 name = env.quotetrans[name] = '' + quote_prefix + name;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
916 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
917 return new assignment(new symbol(name, this.symbol.symbols), this.expression.makeHygienic(env));
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
918 };
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
919
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
920 assignment.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
921 return "assignment";
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
922 };
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
923
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
924 assignment.prototype.tpmeth_symbol = function() {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
925 return this.symbol;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
926 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
927
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
928 assignment.prototype['tpmeth_symbol!'] = function(val) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
929 this.symbol = makeASTNode(val);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
930 return this;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
931 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
932
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
933 assignment.prototype.tpmeth_expression = function() {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
934 return this.expression;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
935 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
936
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
937 assignment.prototype['tpmeth_expression!'] = function(val) {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
938 this.expression = makeASTNode(val);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
939 return this;
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
940 };