Mercurial > repos > tabletprog

annotate interp.js @ 312:8511aac1ce82

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fix module references in macros
author Michael Pavone <pavone@retrodev.com>
date Fri, 05 Sep 2014 09:56:22 -0700
parents f6dfb85e80e5
children d4df33596e7d
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) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
91 this.names[results[i].substr(0, tpidx)] = moduledirs[dirnum] + "/" + results[i];
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
92 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
93 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
94 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
95 if (!tptrue) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
96 tptrue = this.find('true');
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
97 tptrue.valueOf = function() {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
98 return true;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
99 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
100 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
101 if (!tpfalse) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
102 tpfalse = this.find('false');
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
103 tpfalse.valueOf = function() {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
104 return false;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
105 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
106 }
210
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
107 if (!tplist) {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
108 tplist = this.find('list');
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
109 if (tplist instanceof Function) {
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
110 tplist = tplist.call(null);
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
111 }
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
112 }
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
113 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
114
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
115 topenv.prototype = {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
116 find: function(name) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
117 if (name in this.modules) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
118 return this.modules[name];
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
119 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
120 if (name in this.names) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
121 var parsed = parseFile(this.names[name]);
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
122 var ret = parsed.macroexpand(this).eval(this);
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
123 if (typeof ret == 'function') {
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
124 ret = ret();
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
125 }
312
8511aac1ce82 Fix module references in macros
Michael Pavone <pavone@retrodev.com>
parents: 281
diff changeset
126 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
127 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
128 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
129 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
130 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
131 },
b4a9d4e405c5 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 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
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 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
136 return false;
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
137 },
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
138 findMacro: function(name) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
139 return null;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
140 },
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
141 findQuoteTrans: function(name) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
142 return null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
143 }
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
144 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
145
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
146 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
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 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
149 this.syms = {};
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
150 this.macros = {};
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
151 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
152 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
153
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
154 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
155 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
156 if (name in this.syms) {
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
157 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
158 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
159 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
160 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
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 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
163 },
b4a9d4e405c5 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 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
165 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
166 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
167 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
168 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
169 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
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 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
172 },
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
173 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
174 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
175 || !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
176 || !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
177 this.syms[name] = val;
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
178 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
179 },
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
180 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
181 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
182 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
183 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
184 }
b4a9d4e405c5 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 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
186 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
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 return false;
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
189 },
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
190 findMacro: function(name) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
191 if (name in this.syms) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
192 if (name in this.macros) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
193 return this.syms[name];
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
194 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
195 return null;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
196 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
197 if (this.parent) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
198 return this.parent.findMacro(name);
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 return null;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
201 },
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
202 findQuoteTrans: function(name) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
203 if (name in this.quotetrans) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
204 return this.quotetrans[name];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
205 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
206 if (this.parent) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
207 return this.parent.findQuoteTrans(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 return null;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
210 },
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
211 defMacro: function(name, def) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
212 this.syms[name] = def;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
213 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
214 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
215 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
216
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
217 function makeASTNode(val)
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
218 {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
219 if (typeof val == 'number') {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
220 return new intlit(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 == 'string') {
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
223 return new strlit(val);
207
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 (val instanceof Array) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
226 return new arraylit(val);
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 == tptrue) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
229 return new symbol('true');
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 == tpfalse) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
232 return new symbol('false');
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
233 }
221
218b11ec8fa2 Better handling for weird values being inserted into AST due to quoting
Michael Pavone <pavone@retrodev.com>
parents: 219
diff changeset
234 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
235 return val;
218b11ec8fa2 Better handling for weird values being inserted into AST due to quoting
Michael Pavone <pavone@retrodev.com>
parents: 219
diff changeset
236 }
218b11ec8fa2 Better handling for weird values being inserted into AST due to quoting
Michael Pavone <pavone@retrodev.com>
parents: 219
diff changeset
237 return null;
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
238 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
239
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
240 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
241 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
242 var name = this.op;
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
243 if (name == '&&' || name == '||') {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
244 var r = (new lambda([], [this.right])).eval(env);
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
245 } else {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
246 var r = this.right.eval(env);
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
247 }
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
248 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
249 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
250 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
251 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
252 } else {
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
253 if (name == '&&') {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
254 name = 'if'
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
255 } else if (name == '||') {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
256 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
257 } 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
258 return r['tpmeth_|'](l);
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
259 }
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
260 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
261 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
262 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
263 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
264
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
265 op.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
266 this.left = this.left.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
267 this.right = this.right.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
268 return this;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
269 };
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
270
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
271 op.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
272 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
273 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
274 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
275 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
276
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
277 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
278 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
279 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
280 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
281 };
adad61ea2f3a 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
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
283 op.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
284 return "op";
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
285 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
286
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
287 op.prototype.tpmeth_left = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
288 return this.left;
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
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
291 op.prototype.tpmeth_right = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
292 return this.right;
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
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
295 op.prototype.tpmeth_opName = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
296 return this.op;
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
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
299 var quote_prefix = 0;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
300
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
301 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
302 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
303 if (res === null) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
304 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
305 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
306 return res;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
307 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
308
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
309 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
310 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
311 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
312 if (val !== null) {
312
8511aac1ce82 Fix module references in macros
Michael Pavone <pavone@retrodev.com>
parents: 281
diff changeset
313 if (val.ismodule) {
8511aac1ce82 Fix module references in macros
Michael Pavone <pavone@retrodev.com>
parents: 281
diff changeset
314 return this;
8511aac1ce82 Fix module references in macros
Michael Pavone <pavone@retrodev.com>
parents: 281
diff changeset
315 } else {
8511aac1ce82 Fix module references in macros
Michael Pavone <pavone@retrodev.com>
parents: 281
diff changeset
316 var newnode = makeASTNode(val);
8511aac1ce82 Fix module references in macros
Michael Pavone <pavone@retrodev.com>
parents: 281
diff changeset
317 if (!newnode) {
8511aac1ce82 Fix module references in macros
Michael Pavone <pavone@retrodev.com>
parents: 281
diff changeset
318 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
319 }
8511aac1ce82 Fix module references in macros
Michael Pavone <pavone@retrodev.com>
parents: 281
diff changeset
320 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
321 }
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
322 } 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
323 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
324 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
325 }
281
f6dfb85e80e5 Forgot to return this in previous self fix
Michael Pavone <pavone@retrodev.com>
parents: 280
diff changeset
326 } else {
f6dfb85e80e5 Forgot to return this in previous self fix
Michael Pavone <pavone@retrodev.com>
parents: 280
diff changeset
327 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
328 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
329 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
330
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
331 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
332 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
333 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
334 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
335 {
adad61ea2f3a 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 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
337 } 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
338 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
339 }
adad61ea2f3a 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;
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
342 }
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
343 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
344
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
345 symbol.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
346 return "symbol";
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
347 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
348
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
349 symbol.prototype.tpmeth_name = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
350 return this.cleanName();
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
351 };
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
352 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
353 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
354 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
355 };
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
356
255
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
357 intlit.prototype.isconstant =
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
358 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
359 strlit.prototype.isconstant =
255
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
360 lambda.prototype.isconstant = function() {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
361 return true;
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
362 };
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
363
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
364 object.prototype.isconstant =
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
365 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
366 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
367 op.prototype.isconstant =
255
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
368 assignment.prototype.isconstant = function() {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
369 return false;
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
370 }
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
371
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
372 arraylit.prototype.isconstant =
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
373 listlit.prototype.isconstant = function() {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
374 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
375 if (!this.val[idx].isconstant()) {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
376 return false;
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
377 }
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
378 }
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
379 return true;
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
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
382 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
383 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
384 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
385 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
386 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
387 };
b4a9d4e405c5 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
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
389 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
390 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
391 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
392 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
393 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
394 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
395 };
adad61ea2f3a 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
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
397 symbol.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
398 intlit.prototype.macroexpand =
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
399 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
400 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
401 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
402 };
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
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
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 arraylit.prototype.macroexpand =
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
406 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
407 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
408 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
409 }
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
410 return this;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
411 };
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
412
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
413 intlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
414 floatlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
415 strlit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
416 arraylit.prototype.quote =
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
417 listlit.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
418 return this;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
419 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
420
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
421 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
422 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
423 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
424 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
425 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
426 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
427 };
adad61ea2f3a 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
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
429 intlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
430 return "intlit";
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
431 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
432
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
433 floatlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
434 return "floatlit";
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
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
437 strlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
438 return "strlit";
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
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
441 arraylit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
442 return "arraylit";
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
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
445 listlit.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
446 return "strlit";
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
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
449 intlit.prototype.tpmeth_value =
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
450 floatlit.prototype.tpmeth_value =
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
451 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
452 arraylit.prototype.tpmeth_value = function() {
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
453 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
454 };
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
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
456 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
457 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
458 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
459 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
460 }
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 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
462 };
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
463
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
464 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
465 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
466 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
467 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
468 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
469 }
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
470 if (name == 'quote') {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
471 if (this.receiver) {
224
97c3e33cd3f4 Support macro expansion inside quoted code
Michael Pavone <pavone@retrodev.com>
parents: 221
diff changeset
472 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
473 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
474 if (this.args.length) {
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
475 var cur = env;
224
97c3e33cd3f4 Support macro expansion inside quoted code
Michael Pavone <pavone@retrodev.com>
parents: 221
diff changeset
476 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
477 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
478 throw new Error('quote takes an argument');
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
479 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
480 if (name == 'macro') {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
481 return null;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
482 }
206
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
483 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
484 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
485 }
b4a9d4e405c5 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 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
487 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
488 }
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
489 if (name == 'eval:else') {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
490 try {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
491 var res = args[0].eval(env);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
492 } catch(e) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
493 return args[2].call(null);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
494 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
495 return args[1].call(null, res);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
496 }
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
497 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
498 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
499 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
500 } else {
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
501 //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
502 try {
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
503 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
504 } 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
505 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
506 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
507 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
508 }
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 throw new Error(msg);
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
510 }
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
511 /*} else {JSON.stringify
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
512 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
513 }*/
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
514 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
515 };
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 funcall.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
518 var name = this.name;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
519 if (name[name.length-1] == ":") {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
520 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
521 }
224
97c3e33cd3f4 Support macro expansion inside quoted code
Michael Pavone <pavone@retrodev.com>
parents: 221
diff changeset
522 if (name == 'quote') {
97c3e33cd3f4 Support macro expansion inside quoted code
Michael Pavone <pavone@retrodev.com>
parents: 221
diff changeset
523 return this;
97c3e33cd3f4 Support macro expansion inside quoted code
Michael Pavone <pavone@retrodev.com>
parents: 221
diff changeset
524 }
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
525 var macro = env.findMacro(name);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
526 if (this.receiver) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
527 this.receiver = this.receiver.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
528 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
529 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
530 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
531 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
532 if (!macro) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
533 return this;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
534 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
535 var args = [];
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
536 if (this.receiver) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
537 args.push(this.receiver);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
538 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
539 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
540 args.push(this.args[i]);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
541 }
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
542 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
543 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
544 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
545 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
546 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
547
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
548 funcall.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
549 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
550 var args = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
551 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
552 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
553 }
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
554 var name = this.name;
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
555 if (name[name.length-1] == ":") {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
556 name = name.substr(0, name.length-1);
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
557 }
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
558 var fun = env.find(name);
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
559 if (fun) {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
560 fun = makeASTNode(fun);
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
561 if (fun instanceof symbol) {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
562 name = fun.cleanName();
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
563 } else if (fun instanceof lambda) {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
564 throw new Error('FIXME');
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
565 }
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
566 } 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
567 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
568 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
569 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
570 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
571 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
572 };
adad61ea2f3a 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
adad61ea2f3a 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 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
575 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
576 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
577 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
578 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
579 }
adad61ea2f3a 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 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
581 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
582 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
583 }
adad61ea2f3a 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 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
585 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
586 name = hygienic;
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
587 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
588 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
589 ret.receiver = receiver;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
590 return ret;
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
591 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
592
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
593 funcall.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
594 return "funcall";
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
595 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
596
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
597 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
598 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
599 //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
600 };
adad61ea2f3a 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
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
602 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
603 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
604 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
605 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
606 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
607 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
608 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
609 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
610 (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
611 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
612 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
613 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
614 };
210
d0848563f25d Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents: 209
diff changeset
615 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
616 })(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
617 } 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
618 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
619 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
620 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
621 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
622 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
623 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
624 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
625 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
626 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
627 };
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
628 };
b4a9d4e405c5 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 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
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 } 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
632 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
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 }
b4a9d4e405c5 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 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
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
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
638 object.prototype.macroexpand = function(parentenv) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
639 var env = new environment(parentenv);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
640 var obj = {env: env};
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
641 var outmessages = [];
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
642 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
643 var msg = this.messages[i].macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
644 if (msg instanceof assignment) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
645 if (msg.expression instanceof lambda) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
646 (function(name, expr) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
647 env.syms[name] = function() {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
648 if (!obj['tpmeth_' + name]) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
649 obj['tpmeth_' + name] = expr.eval(env);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
650 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
651 return obj['tpmeth_' + name].apply(obj, arguments);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
652 };
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
653 env.syms[name].numargs = expr.numArgs();
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
654 })(msg.symbol.name, msg.expression);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
655 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
656 } 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
657 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
658 } else {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
659 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
660 /*
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
661 var makeProp = function(obj, name) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
662 obj['tprop_' + name] = msg.expression.eval(env);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
663 name = 'tpmeth_' + name;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
664 obj[name] = function() {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
665 return this[name];
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
666 };
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
667 var setname = name+'!';
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
668 obj[setname] = function(val) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
669 this[setname] = val;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
670 return this;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
671 };
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
672 };
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
673 makeProp(obj, msg.symbol.name);*/
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 } else {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
676 outmessages.push(msg);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
677 //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
678 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
679 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
680 this.messages = outmessages;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
681 return this;
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
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
684 object.prototype.quote = function(parentenv) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
685 var env = new environment(parentenv);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
686 var outmessages = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
687 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
688 var msg = this.messages[i];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
689 if (msg instanceof assignment) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
690 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
691 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
692 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
693 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
694 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
695 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
696 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
697 var msg = this.messages[i];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
698 if (msg instanceof assignment) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
699 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
700 } else {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
701 outmessages.push(msg.quote(env));
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
702 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
703 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
704 return new object(outmessages);
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
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
707 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
708 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
709 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
710 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
711 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
712 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
713 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
714 //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
715 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
716 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
717 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
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 }
adad61ea2f3a 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 }
adad61ea2f3a 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 }
adad61ea2f3a 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 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
723 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
724 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
725 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
726 } 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
727 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
728 }
adad61ea2f3a 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 }
adad61ea2f3a 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 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
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
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
733 object.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
734 return "object";
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
735 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
736
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
737 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
738 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
739 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
740 };
adad61ea2f3a 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
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
742 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
743 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
744 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
745 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
746 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
747 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
748 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
749 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
750 }
b4a9d4e405c5 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 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
752 }
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
753 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
754 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
755 }
b4a9d4e405c5 Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
756 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
757 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
758 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
759 }
b4a9d4e405c5 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 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
761 };
b4a9d4e405c5 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
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
764 lambda.prototype.macroexpand = function(parentenv) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
765 var env = new environment(parentenv);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
766 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
767 env.syms[this.args[i].cleanName()] = {};
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
768 }
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
769 var outexprs = []
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
770 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
771 var expr = this.expressions[i];
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
772 if (expr instanceof assignment) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
773 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
774 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
775 } else {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
776 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
777 outexprs.push(expr.macroexpand(env));
255
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
778 try {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
779 if (this.expressions[i].expression.isconstant()) {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
780 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
781 } else {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
782 env.syms[expr.symbol.cleanName()] = null;
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
783 }
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
784 } catch(e) {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
785 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
786 if (typeof this.expressions[i].expression == 'object') {
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
787 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
788 }
08081b0a9382 Actual working implementation of isconstant check
Michael Pavone <pavone@retrodev.com>
parents: 254
diff changeset
789 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
790 }
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
791 }
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
792 } 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
793 outexprs.push(expr.macroexpand(env));
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 }
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 this.expressions = outexprs;
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
797 return this;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
798 };
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
799
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
800 lambda.prototype.quote = function(parentenv) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
801 var args = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
802 var expressions = [];
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
803 var env = new environment(parentenv);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
804 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
805 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
806 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
807 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
808 args.push(sym);
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
809 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
810 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
811 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
812 }
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
813 return new lambda(args, expressions);
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
814 };
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
815
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
816 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
817 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
818 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
819 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
820 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
821 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
822 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
823 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
824 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
825 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
826 } 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
827 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
828 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
829 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
830 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
831 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
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 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
834 };
adad61ea2f3a 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
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
836 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
837 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
838 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
839 --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
840 }
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 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
842 };
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
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
844 lambda.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
845 return "lambda";
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
846 };
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
847
217
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
848 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
849 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
850 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
851 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
852 }
adad61ea2f3a 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 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
854 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
855
adad61ea2f3a 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 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
857 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
858 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
859 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
860 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
861 return 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
862 };
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
863
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
864 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
865 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
866 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
867 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
868 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
869 }
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
870 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
871 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
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
adad61ea2f3a 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 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
875 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
876 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
877 };
adad61ea2f3a 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
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
879 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
880 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
881 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
882 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
883 };
207
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
884
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
885 assignment.prototype.macroexpand = function(env) {
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
886 this.expression = this.expression.macroexpand(env);
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
887 return this;
60eff5f81d9a Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents: 206
diff changeset
888 };
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
889
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
890 assignment.prototype.quote = function(env) {
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
891 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
892 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
893 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
894 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
895 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
896 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
897 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
898 }
adad61ea2f3a 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 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
900 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
901 }
208
a1b4a2bc8d72 Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents: 207
diff changeset
902 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
903 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
904 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
905 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
906 };
adad61ea2f3a 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
adad61ea2f3a 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 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
909 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
910 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
911 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
912 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
913 }
adad61ea2f3a 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 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
915 };
209
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
916
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
917 assignment.prototype.tpmeth_nodeType = function() {
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
918 return "assignment";
4b3b57f39f10 Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents: 208
diff changeset
919 };
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
920
adad61ea2f3a Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents: 213
diff changeset
921 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
922 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
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
adad61ea2f3a 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 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
926 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
927 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
928 };
adad61ea2f3a 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
adad61ea2f3a 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 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
931 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
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
adad61ea2f3a 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 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
935 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
936 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
937 };