Mercurial > repos > tabletprog
annotate interp.js @ 218:b799192e404b
Implemented match:where:yield and fixed a bug in zeroPlus
author | Michael Pavone <pavone@retrodev.com> |
---|---|
date | Sat, 21 Dec 2013 12:08:06 -0800 |
parents | adad61ea2f3a |
children | b70be565d54c |
rev | line source |
---|---|
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1 Number.prototype['tpmeth_+'] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
2 return this + other; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
3 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
4 Number.prototype['tpmeth_-'] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5 return this - other; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
6 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
7 Number.prototype['tpmeth_*'] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
8 return this * other; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
9 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
10 Number.prototype['tpmeth_/'] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
11 return this / other; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
12 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
13 Number.prototype['tpmeth_='] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
14 return this == other ? tptrue : tpfalse; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
15 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
16 Number.prototype['tpmeth_>'] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
17 return this > other ? tptrue : tpfalse; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
18 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
19 Number.prototype['tpmeth_<'] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
20 return this < other ? tptrue : tpfalse; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
21 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
22 Number.prototype['tpmeth_>='] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
23 return this >= other ? tptrue : tpfalse; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
24 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
25 Number.prototype['tpmeth_<='] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
26 return this <= other ? tptrue : tpfalse; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
27 }; |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
28 Number.prototype.tpmeth_asStringChar = function() { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
29 return String.fromCharCode(this); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
30 }; |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
31 Number.prototype['tpmeth_isString?'] = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
32 return false; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
33 }; |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
34 Number.prototype.tpmeth_string = function() { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
35 return '' + this; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
36 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
37 Number.prototype.tpmeth_print = function() { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
38 print(this); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
39 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
40 |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
41 String.prototype['tpmeth_.'] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
42 return this + other; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
43 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
44 String.prototype['tpmeth_='] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
45 return this == other ? tptrue : tpfalse; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
46 }; |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
47 String.prototype.tpmeth_length = function() { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
48 return this.length; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
49 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
50 String.prototype.tpmeth_byte_length = function() { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
51 return this.length; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
52 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
53 String.prototype.tpmeth_byte = function(index) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
54 return this.charCodeAt(index); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
55 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
56 String.prototype['tpmeth_from:withLength'] = function(pos, length) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
57 return this.substr(pos, length); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
58 }; |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
59 String.prototype['tpmeth_isString?'] = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
60 return true; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
61 }; |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
62 String.prototype.tpmeth_print = function() { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
63 print(this); |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
64 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
65 |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
66 Function.prototype['tpmeth_while:do'] = function(body) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
67 var ret = null; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
68 for (;;) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
69 var res = this.call(null); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
70 if (res != tptrue) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
71 break; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
72 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
73 ret = body.call(null); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
74 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
75 return ret; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
76 }; |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
77 |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
78 var tptrue = null; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
79 var tpfalse = null; |
210
d0848563f25d
Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents:
209
diff
changeset
|
80 var tplist = null; |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
81 |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
82 function topenv(moduledirs) |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
83 { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
84 this.names = {}; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
85 this.modules = {}; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
86 for (var dirnum in moduledirs) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
87 var results = os.system("ls", [moduledirs[dirnum]]).split('\n'); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
88 for (var i in results) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
89 var tpidx = results[i].indexOf('.tp') |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
90 if (tpidx > 0 && tpidx == results[i].length - 3) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
91 this.names[results[i].substr(0, tpidx)] = moduledirs[dirnum] + "/" + results[i]; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
92 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
93 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
94 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
95 if (!tptrue) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
96 tptrue = this.find('true'); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
97 tptrue.valueOf = function() { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
98 return true; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
99 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
100 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
101 if (!tpfalse) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
102 tpfalse = this.find('false'); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
103 tpfalse.valueOf = function() { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
104 return false; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
105 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
106 } |
210
d0848563f25d
Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents:
209
diff
changeset
|
107 if (!tplist) { |
d0848563f25d
Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents:
209
diff
changeset
|
108 tplist = this.find('list'); |
d0848563f25d
Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents:
209
diff
changeset
|
109 if (tplist instanceof Function) { |
d0848563f25d
Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents:
209
diff
changeset
|
110 tplist = tplist.call(null); |
d0848563f25d
Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents:
209
diff
changeset
|
111 } |
d0848563f25d
Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents:
209
diff
changeset
|
112 } |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
113 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
114 |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
115 topenv.prototype = { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
116 find: function(name) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
117 if (name in this.modules) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
118 return this.modules[name]; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
119 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
120 if (name in this.names) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
121 var parsed = parseFile(this.names[name]); |
217
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
122 var ret = parsed.macroexpand(this).eval(this); |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
123 if (typeof ret == 'function') { |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
124 ret = ret(); |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
125 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
126 this.modules[name] = ret; |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
127 return ret; |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
128 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
129 return null; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
130 }, |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
131 findNoTop: function(name) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
132 return null; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
133 }, |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
134 findSetPresent: function(name, val) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
135 return false; |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
136 }, |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
137 findMacro: function(name) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
138 return null; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
139 }, |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
140 findQuoteTrans: function(name) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
141 return null; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
142 } |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
143 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
144 |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
145 function environment(parent) |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
146 { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
147 this.parent = parent; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
148 this.syms = {}; |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
149 this.macros = {}; |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
150 this.quotetrans = {}; |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
151 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
152 |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
153 environment.prototype = { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
154 find: function(name) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
155 if (name in this.syms) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
156 return this.syms[name]; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
157 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
158 if (this.parent) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
159 return this.parent.find(name); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
160 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
161 return null; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
162 }, |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
163 findNoTop: function(name) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
164 if (name in this.syms) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
165 return this.syms[name]; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
166 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
167 if (this.parent) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
168 return this.parent.findNoTop(name); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
169 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
170 return null; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
171 }, |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
172 findSet: function(name, val) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
173 if (name in this.syms |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
174 || !this.parent |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
175 || !this.parent.findSetPresent(name, val)) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
176 this.syms[name] = val; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
177 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
178 }, |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
179 findSetPresent: function(name, val) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
180 if (name in this.syms) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
181 this.syms[name] = val; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
182 return true; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
183 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
184 if (this.parent) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
185 return this.parent.findSetPresent(name, val); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
186 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
187 return false; |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
188 }, |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
189 findMacro: function(name) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
190 if (name in this.syms) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
191 if (name in this.macros) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
192 return this.syms[name]; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
193 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
194 return null; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
195 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
196 if (this.parent) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
197 return this.parent.findMacro(name); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
198 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
199 return null; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
200 }, |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
201 findQuoteTrans: function(name) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
202 if (name in this.quotetrans) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
203 return this.quotetrans[name]; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
204 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
205 if (this.parent) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
206 return this.parent.findQuoteTrans(name); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
207 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
208 return null; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
209 }, |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
210 defMacro: function(name, def) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
211 this.syms[name] = def; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
212 this.macros[name] = true; |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
213 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
214 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
215 |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
216 function makeASTNode(val) |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
217 { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
218 if (typeof val == 'number') { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
219 return new intlit(val); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
220 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
221 if (typeof val == 'string') { |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
222 return new strlit(val); |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
223 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
224 if (val instanceof Array) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
225 return new arraylit(val); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
226 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
227 if (val == tptrue) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
228 return new symbol('true'); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
229 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
230 if (val == tpfalse) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
231 return new symbol('false'); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
232 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
233 return val; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
234 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
235 |
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
|
236 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
|
237 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
|
238 var name = this.op; |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
239 if (name == '&&' || name == '||') { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
240 var r = (new lambda([], [this.right])).eval(env); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
241 } else { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
242 var r = this.right.eval(env); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
243 } |
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
|
244 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
|
245 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
|
246 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
|
247 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
|
248 } else { |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
249 if (name == '&&') { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
250 name = 'if' |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
251 } else if (name == '||') { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
252 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
|
253 } 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
|
254 return r['tpmeth_|'](l); |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
255 } |
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
|
256 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
|
257 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
258 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
|
259 }; |
b4a9d4e405c5
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 |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
261 op.prototype.macroexpand = function(env) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
262 this.left = this.left.macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
263 this.right = this.right.macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
264 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
265 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
266 |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
267 op.prototype.quote = function(env) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
268 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
|
269 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
|
270 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
|
271 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
272 |
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
|
273 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
|
274 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
|
275 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
|
276 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
|
277 }; |
adad61ea2f3a
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 |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
279 op.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
280 return "op"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
281 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
282 |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
283 op.prototype.tpmeth_left = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
284 return this.left; |
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_right = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
288 return this.right; |
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_opName = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
292 return this.op; |
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 |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
295 var quote_prefix = 0; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
296 |
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
|
297 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
|
298 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
|
299 if (res === null) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
300 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
|
301 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
302 return res; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
303 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
304 |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
305 symbol.prototype.quote = function(env) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
306 var val = env.find(this.name); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
307 if (val) { |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
308 var newnode = makeASTNode(val); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
309 return newnode; |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
310 } 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
|
311 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
|
312 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
|
313 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
314 }; |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
315 |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
316 symbol.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
|
317 if (this.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
|
318 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
|
319 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
|
320 { |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
321 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
|
322 } 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
|
323 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
|
324 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
325 } 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
|
326 return this; |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
327 } |
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
|
328 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
329 |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
330 symbol.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
331 return "symbol"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
332 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
333 |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
334 symbol.prototype.tpmeth_name = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
335 return this.cleanName(); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
336 }; |
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
|
337 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
|
338 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
|
339 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
|
340 }; |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
341 |
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
|
342 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
|
343 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
|
344 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
|
345 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
|
346 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
|
347 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
348 |
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
|
349 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
|
350 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
|
351 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
|
352 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
|
353 } |
adad61ea2f3a
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 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
|
355 }; |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
356 |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
357 symbol.prototype.macroexpand = |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
358 intlit.prototype.macroexpand = |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
359 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
|
360 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
|
361 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
|
362 }; |
d0848563f25d
Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents:
209
diff
changeset
|
363 |
d0848563f25d
Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents:
209
diff
changeset
|
364 |
d0848563f25d
Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents:
209
diff
changeset
|
365 arraylit.prototype.macroexpand = |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
366 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
|
367 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
|
368 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
|
369 } |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
370 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
371 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
372 |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
373 intlit.prototype.quote = |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
374 floatlit.prototype.quote = |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
375 strlit.prototype.quote = |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
376 arraylit.prototype.quote = |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
377 listlit.prototype.quote = function(env) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
378 return this; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
379 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
380 |
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
|
381 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
|
382 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
|
383 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
|
384 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
|
385 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
|
386 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
|
387 }; |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
388 |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
389 intlit.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
390 return "intlit"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
391 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
392 |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
393 floatlit.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
394 return "floatlit"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
395 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
396 |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
397 strlit.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
398 return "strlit"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
399 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
400 |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
401 arraylit.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
402 return "arraylit"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
403 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
404 |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
405 listlit.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
406 return "strlit"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
407 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
408 |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
409 intlit.prototype.tpmeth_value = |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
410 floatlit.prototype.tpmeth_value = |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
411 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
|
412 arraylit.prototype.tpmeth_value = function() { |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
413 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
|
414 }; |
d0848563f25d
Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents:
209
diff
changeset
|
415 |
d0848563f25d
Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents:
209
diff
changeset
|
416 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
|
417 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
|
418 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
|
419 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
|
420 } |
d0848563f25d
Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents:
209
diff
changeset
|
421 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
|
422 }; |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
423 |
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
|
424 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
|
425 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
|
426 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
|
427 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
|
428 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
|
429 } |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
430 if (name == 'quote') { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
431 if (this.receiver) { |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
432 return this.receiver.quote(env); |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
433 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
434 if (this.args.length) { |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
435 var cur = env; |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
436 return this.args[0].quote(env); |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
437 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
438 throw new Error('quote takes an argument'); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
439 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
440 if (name == 'macro') { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
441 return null; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
442 } |
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
|
443 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
|
444 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
|
445 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
446 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
|
447 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
|
448 } |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
449 if (name == 'eval:else') { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
450 try { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
451 var res = args[0].eval(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
452 } catch(e) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
453 return args[2].call(null); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
454 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
455 return args[1].call(null, res); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
456 } |
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
|
457 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
|
458 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
|
459 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
|
460 } else { |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
461 //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
|
462 try { |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
463 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
|
464 } 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
|
465 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
|
466 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
|
467 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
|
468 } |
d0848563f25d
Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents:
209
diff
changeset
|
469 throw new Error(msg); |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
470 } |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
471 /*} else {JSON.stringify |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
472 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
|
473 }*/ |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
474 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
475 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
476 |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
477 funcall.prototype.macroexpand = function(env) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
478 var name = this.name; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
479 if (name[name.length-1] == ":") { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
480 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
|
481 } |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
482 var macro = env.findMacro(name); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
483 if (this.receiver) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
484 this.receiver = this.receiver.macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
485 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
486 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
|
487 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
|
488 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
489 if (!macro) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
490 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
491 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
492 var args = []; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
493 if (this.receiver) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
494 args.push(this.receiver); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
495 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
496 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
|
497 args.push(this.args[i]); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
498 } |
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
|
499 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
|
500 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
|
501 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
|
502 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
|
503 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
504 |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
505 funcall.prototype.quote = function(env) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
506 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
|
507 var args = []; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
508 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
|
509 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
|
510 } |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
511 var name = this.name; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
512 if (name[name.length-1] == ":") { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
513 name = name.substr(0, name.length-1); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
514 } |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
515 var fun = env.find(name); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
516 if (fun) { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
517 fun = makeASTNode(fun); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
518 if (fun instanceof symbol) { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
519 name = fun.cleanName(); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
520 } else if (fun instanceof lambda) { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
521 throw new Error('FIXME'); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
522 } |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
523 } 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
|
524 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
|
525 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
526 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
|
527 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
|
528 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
|
529 }; |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
530 |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
531 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
|
532 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
|
533 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
|
534 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
|
535 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
|
536 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
537 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
|
538 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
|
539 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
|
540 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
541 var 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
|
542 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
|
543 name = hygienic; |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
544 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
545 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
|
546 ret.receiver = receiver; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
547 return ret; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
548 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
549 |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
550 funcall.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
551 return "funcall"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
552 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
553 |
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
|
554 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
|
555 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
|
556 //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
|
557 }; |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
558 |
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
|
559 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
|
560 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
|
561 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
|
562 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
|
563 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
|
564 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
|
565 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
|
566 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
|
567 (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
|
568 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
|
569 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
|
570 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
|
571 }; |
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
|
572 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
|
573 })(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
|
574 } 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
|
575 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
|
576 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
|
577 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
|
578 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
|
579 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
580 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
|
581 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
|
582 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
|
583 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
|
584 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
585 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
586 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
|
587 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
588 } 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
|
589 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
|
590 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
591 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
592 return 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
|
593 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
594 |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
595 object.prototype.macroexpand = function(parentenv) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
596 var env = new environment(parentenv); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
597 var obj = {env: env}; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
598 var outmessages = []; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
599 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
|
600 var msg = this.messages[i].macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
601 if (msg instanceof assignment) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
602 if (msg.expression instanceof lambda) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
603 (function(name, expr) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
604 env.syms[name] = function() { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
605 if (!obj['tpmeth_' + name]) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
606 obj['tpmeth_' + name] = expr.eval(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
607 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
608 return obj['tpmeth_' + name].apply(obj, arguments); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
609 }; |
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
|
610 env.syms[name].numargs = expr.numArgs(); |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
611 })(msg.symbol.name, msg.expression); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
612 outmessages.push(msg); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
613 } 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
|
614 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
|
615 } else { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
616 outmessages.push(msg); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
617 /* |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
618 var makeProp = function(obj, name) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
619 obj['tprop_' + name] = msg.expression.eval(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
620 name = 'tpmeth_' + name; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
621 obj[name] = function() { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
622 return this[name]; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
623 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
624 var setname = name+'!'; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
625 obj[setname] = function(val) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
626 this[setname] = val; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
627 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
628 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
629 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
630 makeProp(obj, msg.symbol.name);*/ |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
631 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
632 } else { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
633 outmessages.push(msg); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
634 //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
|
635 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
636 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
637 this.messages = outmessages; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
638 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
639 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
640 |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
641 object.prototype.quote = function(parentenv) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
642 var env = new environment(parentenv); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
643 var outmessages = []; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
644 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
|
645 var msg = this.messages[i]; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
646 if (msg instanceof assignment) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
647 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
|
648 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
|
649 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
|
650 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
651 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
652 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
653 for (var i = 0; i < this.messages.length; i++) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
654 var msg = this.messages[i]; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
655 if (msg instanceof assignment) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
656 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
|
657 } else { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
658 outmessages.push(msg.quote(env)); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
659 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
660 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
661 return new object(outmessages); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
662 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
663 |
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
|
664 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
|
665 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
|
666 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
|
667 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
|
668 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
|
669 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
|
670 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
|
671 //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
|
672 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
|
673 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
|
674 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
|
675 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
|
676 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
677 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
678 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
679 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
|
680 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
|
681 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
|
682 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
|
683 } 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
|
684 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
|
685 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
686 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
687 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
|
688 }; |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
689 |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
690 object.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
691 return "object"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
692 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
693 |
217
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
694 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
|
695 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
|
696 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
|
697 }; |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
698 |
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
|
699 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
|
700 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
|
701 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
|
702 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
|
703 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
|
704 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
|
705 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
|
706 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
|
707 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
708 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
|
709 } |
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
|
710 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
|
711 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
|
712 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
713 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
|
714 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
|
715 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
|
716 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
717 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
|
718 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
719 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
720 |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
721 lambda.prototype.macroexpand = function(parentenv) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
722 var env = new environment(parentenv); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
723 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
|
724 env.syms[this.args[i].cleanName()] = {}; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
725 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
726 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
|
727 var expr = this.expressions[i]; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
728 if (expr instanceof assignment) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
729 if (expr.expression instanceof funcall && expr.expression.name == 'macro:') { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
730 env.defMacro(expr.symbol.name, exp.expression.args[0].eval(env)); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
731 } else { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
732 env.syms[expr.symbol.cleanName()] = {}; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
733 this.expressions[i] = expr.macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
734 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
735 } else { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
736 this.expressions[i] = expr.macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
737 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
738 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
739 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
740 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
741 |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
742 lambda.prototype.quote = function(parentenv) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
743 var args = []; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
744 var expressions = []; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
745 var env = new environment(parentenv); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
746 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
|
747 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
|
748 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
|
749 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
|
750 args.push(sym); |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
751 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
752 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
|
753 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
|
754 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
755 return new lambda(args, expressions); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
756 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
757 |
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
|
758 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
|
759 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
|
760 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
|
761 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
|
762 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
|
763 env.syms[this.args[i].cleanName()] = 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
|
764 if (this.args[i].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
|
765 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
|
766 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
|
767 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
|
768 } 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
|
769 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
|
770 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
771 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
772 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
|
773 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
|
774 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
775 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
|
776 }; |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
777 |
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
|
778 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
|
779 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
|
780 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
|
781 --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
|
782 } |
d0848563f25d
Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents:
209
diff
changeset
|
783 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
|
784 }; |
d0848563f25d
Fix some bugs and allow proper access to list literals in interpreter/macro expander
Mike Pavone <pavone@retrodev.com>
parents:
209
diff
changeset
|
785 |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
786 lambda.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
787 return "lambda"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
788 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
789 |
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
|
790 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
|
791 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
|
792 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
|
793 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
|
794 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
795 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
|
796 }; |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
797 |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
798 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
|
799 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
|
800 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
|
801 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
|
802 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
803 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
|
804 }; |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
805 |
adad61ea2f3a
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 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
|
807 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
|
808 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
|
809 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
|
810 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
|
811 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
812 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
|
813 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
|
814 }; |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
815 |
adad61ea2f3a
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.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
|
817 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
|
818 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
|
819 }; |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
820 |
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
|
821 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
|
822 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
|
823 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
|
824 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
|
825 }; |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
826 |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
827 assignment.prototype.macroexpand = function(env) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
828 this.expression = this.expression.macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
829 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
830 }; |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
831 |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
832 assignment.prototype.quote = function(env) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
833 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
|
834 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
|
835 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
|
836 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
|
837 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
|
838 if (!(node instanceof 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
|
839 throw new Error('Left hand side of assignment expression must be a 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
|
840 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
841 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
|
842 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
|
843 } |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
844 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
|
845 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
|
846 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
|
847 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
|
848 }; |
adad61ea2f3a
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 |
adad61ea2f3a
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 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
|
851 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
|
852 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
|
853 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
|
854 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
|
855 } |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
856 return 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
|
857 }; |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
858 |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
859 assignment.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
860 return "assignment"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
861 }; |
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
|
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 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
|
864 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
|
865 }; |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
866 |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
867 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
|
868 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
|
869 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
|
870 }; |
adad61ea2f3a
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 |
adad61ea2f3a
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 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
|
873 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
|
874 }; |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
875 |
adad61ea2f3a
Switched to a less hacky implementation of hygiene and exposed more AST properties to macros
Michael Pavone <pavone@retrodev.com>
parents:
213
diff
changeset
|
876 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
|
877 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
|
878 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
|
879 }; |