Mercurial > repos > tabletprog
annotate interp.js @ 209:4b3b57f39f10
Implement zeroPlus macro
author | Michael Pavone <pavone@retrodev.com> |
---|---|
date | Wed, 27 Nov 2013 23:36:24 -0800 |
parents | a1b4a2bc8d72 |
children | d0848563f25d |
rev | line source |
---|---|
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1 Number.prototype['tpmeth_+'] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
2 return this + other; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
3 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
4 Number.prototype['tpmeth_-'] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5 return this - other; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
6 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
7 Number.prototype['tpmeth_*'] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
8 return this * other; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
9 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
10 Number.prototype['tpmeth_/'] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
11 return this / other; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
12 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
13 Number.prototype['tpmeth_='] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
14 return this == other ? tptrue : tpfalse; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
15 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
16 Number.prototype['tpmeth_>'] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
17 return this > other ? tptrue : tpfalse; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
18 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
19 Number.prototype['tpmeth_<'] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
20 return this < other ? tptrue : tpfalse; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
21 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
22 Number.prototype['tpmeth_>='] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
23 return this >= other ? tptrue : tpfalse; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
24 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
25 Number.prototype['tpmeth_<='] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
26 return this <= other ? tptrue : tpfalse; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
27 }; |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
28 Number.prototype.tpmeth_asStringChar = function() { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
29 return String.fromCharCode(this); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
30 }; |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
31 Number.prototype['tpmeth_isString?'] = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
32 return false; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
33 }; |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
34 Number.prototype.tpmeth_string = function() { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
35 return '' + this; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
36 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
37 Number.prototype.tpmeth_print = function() { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
38 print(this); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
39 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
40 |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
41 String.prototype['tpmeth_.'] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
42 return this + other; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
43 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
44 String.prototype['tpmeth_='] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
45 return this == other ? tptrue : tpfalse; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
46 }; |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
47 String.prototype.tpmeth_length = function() { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
48 return this.length; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
49 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
50 String.prototype.tpmeth_byte_length = function() { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
51 return this.length; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
52 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
53 String.prototype.tpmeth_byte = function(index) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
54 return this.charCodeAt(index); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
55 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
56 String.prototype['tpmeth_from:withLength'] = function(pos, length) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
57 return this.substr(pos, length); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
58 }; |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
59 String.prototype['tpmeth_isString?'] = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
60 return true; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
61 }; |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
62 String.prototype.tpmeth_print = function() { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
63 print(this); |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
64 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
65 |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
66 Function.prototype['tpmeth_while:do'] = function(body) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
67 var ret = null; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
68 for (;;) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
69 var res = this.call(null); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
70 if (res != tptrue) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
71 break; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
72 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
73 ret = body.call(null); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
74 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
75 return ret; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
76 }; |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
77 |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
78 var tptrue = null; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
79 var tpfalse = null; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
80 |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
81 function topenv(moduledirs) |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
82 { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
83 this.names = {}; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
84 this.modules = {}; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
85 for (var dirnum in moduledirs) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
86 var results = os.system("ls", [moduledirs[dirnum]]).split('\n'); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
87 for (var i in results) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
88 var tpidx = results[i].indexOf('.tp') |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
89 if (tpidx > 0 && tpidx == results[i].length - 3) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
90 this.names[results[i].substr(0, tpidx)] = moduledirs[dirnum] + "/" + results[i]; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
91 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
92 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
93 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
94 if (!tptrue) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
95 tptrue = this.find('true'); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
96 tptrue.valueOf = function() { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
97 return true; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
98 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
99 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
100 if (!tpfalse) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
101 tpfalse = this.find('false'); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
102 tpfalse.valueOf = function() { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
103 return false; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
104 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
105 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
106 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
107 |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
108 topenv.prototype = { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
109 find: function(name) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
110 if (name in this.modules) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
111 return this.modules[name]; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
112 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
113 if (name in this.names) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
114 var parsed = parseFile(this.names[name]); |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
115 this.modules[name] = parsed.macroexpand(this).eval(this); |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
116 return this.modules[name]; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
117 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
118 return null; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
119 }, |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
120 findNoTop: function(name) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
121 return null; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
122 }, |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
123 findSetPresent: function(name, val) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
124 return false; |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
125 }, |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
126 findMacro: function(name) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
127 return null; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
128 }, |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
129 findQuoteTrans: function(name) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
130 return null; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
131 } |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
132 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
133 |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
134 function environment(parent) |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
135 { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
136 this.parent = parent; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
137 this.syms = {}; |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
138 this.macros = {}; |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
139 this.quotetrans = {}; |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
140 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
141 |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
142 environment.prototype = { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
143 find: function(name) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
144 if (name in this.syms) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
145 return this.syms[name]; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
146 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
147 if (this.parent) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
148 return this.parent.find(name); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
149 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
150 return null; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
151 }, |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
152 findNoTop: function(name) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
153 if (name in this.syms) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
154 return this.syms[name]; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
155 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
156 if (this.parent) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
157 return this.parent.findNoTop(name); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
158 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
159 return null; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
160 }, |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
161 findSet: function(name, val) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
162 if (name in this.syms |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
163 || !this.parent |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
164 || !this.parent.findSetPresent(name, val)) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
165 this.syms[name] = val; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
166 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
167 }, |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
168 findSetPresent: function(name, val) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
169 if (name in this.syms) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
170 this.syms[name] = val; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
171 return true; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
172 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
173 if (this.parent) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
174 return this.parent.findSetPresent(name, val); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
175 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
176 return false; |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
177 }, |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
178 findMacro: function(name) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
179 if (name in this.syms) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
180 if (name in this.macros) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
181 return this.syms[name]; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
182 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
183 return null; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
184 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
185 if (this.parent) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
186 return this.parent.findMacro(name); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
187 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
188 return null; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
189 }, |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
190 findQuoteTrans: function(name) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
191 if (name in this.quotetrans) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
192 return this.quotetrans[name]; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
193 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
194 if (this.parent) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
195 return this.parent.findQuoteTrans(name); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
196 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
197 return null; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
198 }, |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
199 defMacro: function(name, def) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
200 this.syms[name] = def; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
201 this.macros[name] = true; |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
202 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
203 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
204 |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
205 function makeASTNode(val) |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
206 { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
207 if (typeof val == 'number') { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
208 return new intlit(val); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
209 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
210 if (typeof val == 'string') { |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
211 return new strlit(val); |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
212 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
213 if (val instanceof Array) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
214 return new arraylit(val); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
215 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
216 if (val == tptrue) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
217 return new symbol('true'); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
218 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
219 if (val == tpfalse) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
220 return new symbol('false'); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
221 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
222 return val; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
223 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
224 |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
225 op.prototype.eval = function(env) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
226 var l = this.left.eval(env); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
227 var name = this.op; |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
228 if (name == '&&' || name == '||') { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
229 var r = (new lambda([], [this.right])).eval(env); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
230 } else { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
231 var r = this.right.eval(env); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
232 } |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
233 var fun = env.findNoTop(name); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
234 var ret; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
235 if (fun) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
236 ret = fun(l,r) |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
237 } else { |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
238 if (name == '&&') { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
239 name = 'if' |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
240 } else if (name == '||') { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
241 name = 'ifnot' |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
242 } |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
243 ret = l['tpmeth_'+name](r); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
244 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
245 return ret; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
246 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
247 |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
248 op.prototype.macroexpand = function(env) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
249 this.left = this.left.macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
250 this.right = this.right.macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
251 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
252 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
253 |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
254 op.prototype.quote = function(env) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
255 var left = this.left.quote(env); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
256 var right = this.right.quote(env); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
257 return new op(left, this.op, right); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
258 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
259 |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
260 op.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
261 return "op"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
262 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
263 |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
264 op.prototype.tpmeth_left = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
265 return this.left; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
266 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
267 |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
268 op.prototype.tpmeth_right = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
269 return this.right; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
270 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
271 |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
272 op.prototype.tpmeth_opName = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
273 return this.op; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
274 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
275 |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
276 var quote_prefix = 0; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
277 |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
278 symbol.prototype.eval = function(env) { |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
279 var res = env.find(this.name); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
280 if (res === null) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
281 throw new Error('Symbol ' + this.name + ' is not bound'); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
282 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
283 return res; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
284 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
285 |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
286 symbol.prototype.quote = function(env) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
287 var val = env.find(this.name); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
288 if (val) { |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
289 var newnode = makeASTNode(val); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
290 if (!(newnode instanceof symbol)) { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
291 newnode = newnode.quote(env); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
292 } |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
293 return newnode; |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
294 } else { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
295 var hygenic = env.findQuoteTrans(this.name); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
296 return hygenic ? new symbol(hygenic, this.symbols) : this; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
297 } |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
298 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
299 |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
300 symbol.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
301 return "symbol"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
302 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
303 |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
304 symbol.prototype.tpmeth_name = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
305 return this.cleanName(); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
306 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
307 |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
308 intlit.prototype.eval = |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
309 floatlit.prototype.eval = |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
310 strlit.prototype.eval = |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
311 arraylit.prototype.eval = function(env) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
312 return this.val; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
313 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
314 |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
315 symbol.prototype.macroexpand = |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
316 intlit.prototype.macroexpand = |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
317 floatlit.prototype.macroexpand = |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
318 strlit.prototype.macroexpand = |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
319 arraylit.prototype.macroexpand = |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
320 listlit.prototype.macroexpand = function(env) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
321 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
322 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
323 |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
324 intlit.prototype.quote = |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
325 floatlit.prototype.quote = |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
326 strlit.prototype.quote = |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
327 arraylit.prototype.quote = |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
328 listlit.prototype.quote = function(env) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
329 return this; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
330 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
331 |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
332 intlit.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
333 return "intlit"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
334 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
335 |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
336 floatlit.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
337 return "floatlit"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
338 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
339 |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
340 strlit.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
341 return "strlit"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
342 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
343 |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
344 arraylit.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
345 return "arraylit"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
346 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
347 |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
348 listlit.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
349 return "strlit"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
350 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
351 |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
352 intlit.prototype.tpmeth_value = |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
353 floatlit.prototype.tpmeth_value = |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
354 strlit.prototype.tpmeth_value = |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
355 arraylit.prototype.tpmeth_value = |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
356 listlit.prototype.tpmeth_value = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
357 return this.val; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
358 } |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
359 |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
360 funcall.prototype.eval = function(env) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
361 var args = []; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
362 var name = this.name; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
363 if (name[name.length-1] == ":") { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
364 name = name.substr(0, name.length-1); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
365 } |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
366 if (name == 'quote') { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
367 if (this.receiver) { |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
368 return this.receiver.quote(env); |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
369 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
370 if (this.args.length) { |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
371 var cur = env; |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
372 return this.args[0].quote(env); |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
373 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
374 throw new Error('quote takes an argument'); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
375 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
376 if (name == 'macro') { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
377 return null; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
378 } |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
379 if (this.receiver) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
380 args.push(this.receiver.eval(env)); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
381 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
382 for (var i = 0; i < this.args.length; i++) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
383 args.push(this.args[i].eval(env)); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
384 } |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
385 if (name == 'eval:else') { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
386 try { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
387 var res = args[0].eval(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
388 } catch(e) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
389 return args[2].call(null); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
390 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
391 return args[1].call(null, res); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
392 } |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
393 var fun = env.findNoTop(name); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
394 if (fun) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
395 return fun.apply(null, args); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
396 } else { |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
397 //if (typeof args[0]'tpmeth_'+name in args[0]) { |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
398 try { |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
399 return args[0]['tpmeth_'+name].apply(args[0], args.slice(1)); |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
400 } catch(e) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
401 throw new Error('Error, \n\t' + e.message.split('\n').join('\n\t') + '\ninvoking method ' + name + ' on object ' + args[0]); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
402 } |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
403 /*} else {JSON.stringify |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
404 throw new Error('No method named ' + name + ' on object ' + JSON.stringify(args[0])); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
405 }*/ |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
406 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
407 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
408 |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
409 funcall.prototype.macroexpand = function(env) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
410 var name = this.name; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
411 if (name[name.length-1] == ":") { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
412 name = name.substr(0, name.length-1); |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
413 } |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
414 var macro = env.findMacro(name); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
415 if (this.receiver) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
416 this.receiver = this.receiver.macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
417 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
418 for (var i = 0; i < this.args.length; i++) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
419 this.args[i] = this.args[i].macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
420 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
421 if (!macro) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
422 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
423 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
424 var args = []; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
425 if (this.receiver) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
426 args.push(this.receiver); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
427 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
428 for (var i = 0; i < this.args.length; i++) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
429 args.push(this.args[i]); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
430 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
431 return makeASTNode(macro.apply(null, args)); |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
432 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
433 |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
434 funcall.prototype.quote = function(env) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
435 var receiver = this.receiver ? this.receiver.quote(env) : null; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
436 var args = []; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
437 for (var i = 0; i < this.args.length; i++) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
438 args.push(this.args[i].quote(env)); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
439 } |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
440 var name = this.name; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
441 if (name[name.length-1] == ":") { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
442 name = name.substr(0, name.length-1); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
443 } |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
444 var fun = env.find(name); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
445 if (fun) { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
446 fun = makeASTNode(fun); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
447 if (fun instanceof symbol) { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
448 name = fun.cleanName(); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
449 } else if (fun instanceof lambda) { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
450 throw new Error('FIXME'); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
451 } |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
452 } else { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
453 var hygenic = env.findQuoteTrans(this.name); |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
454 if (hygenic) { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
455 name = hygenic; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
456 } |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
457 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
458 var ret = new funcall(name, args); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
459 ret.receiver = receiver; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
460 return ret; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
461 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
462 |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
463 funcall.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
464 return "funcall"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
465 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
466 |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
467 object.prototype.eval = function(parentenv) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
468 var env = new environment(parentenv); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
469 var obj = {env: env}; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
470 for (var i = 0; i < this.messages.length; i++) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
471 var msg = this.messages[i]; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
472 if (msg instanceof assignment) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
473 if (msg.expression instanceof lambda) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
474 obj['tpmeth_' + msg.symbol.name] = msg.expression.eval(env); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
475 (function(name) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
476 env.syms[name] = function() { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
477 return obj['tpmeth_' + name].apply(obj, arguments); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
478 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
479 })(msg.symbol.name); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
480 } else { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
481 var makeProp = function(obj, name) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
482 obj['tprop_' + name] = msg.expression.eval(env); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
483 name = 'tpmeth_' + name; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
484 obj[name] = function() { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
485 return this[name]; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
486 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
487 var setname = name+'!'; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
488 obj[setname] = function(val) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
489 this[setname] = val; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
490 return this; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
491 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
492 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
493 makeProp(obj, msg.symbol.name); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
494 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
495 } else { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
496 throw new Error('pseudo function calls in object definitions not implemented yet'); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
497 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
498 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
499 return obj; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
500 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
501 |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
502 object.prototype.macroexpand = function(parentenv) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
503 var env = new environment(parentenv); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
504 var obj = {env: env}; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
505 var outmessages = []; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
506 for (var i = 0; i < this.messages.length; i++) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
507 var msg = this.messages[i].macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
508 if (msg instanceof assignment) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
509 if (msg.expression instanceof lambda) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
510 (function(name, expr) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
511 env.syms[name] = function() { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
512 if (!obj['tpmeth_' + name]) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
513 obj['tpmeth_' + name] = expr.eval(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
514 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
515 return obj['tpmeth_' + name].apply(obj, arguments); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
516 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
517 })(msg.symbol.name, msg.expression); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
518 outmessages.push(msg); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
519 } else if (msg.expression instanceof funcall && msg.expression.name == 'macro:') { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
520 env.defMacro(msg.symbol.name, msg.expression.args[0].eval(env)); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
521 } else { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
522 outmessages.push(msg); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
523 /* |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
524 var makeProp = function(obj, name) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
525 obj['tprop_' + name] = msg.expression.eval(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
526 name = 'tpmeth_' + name; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
527 obj[name] = function() { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
528 return this[name]; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
529 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
530 var setname = name+'!'; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
531 obj[setname] = function(val) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
532 this[setname] = val; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
533 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
534 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
535 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
536 makeProp(obj, msg.symbol.name);*/ |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
537 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
538 } else { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
539 outmessages.push(msg); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
540 //throw new Error('pseudo function calls in object definitions not implemented yet'); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
541 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
542 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
543 this.messages = outmessages; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
544 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
545 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
546 |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
547 object.prototype.quote = function(parentenv) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
548 var env = new environment(parentenv); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
549 var outmessages = []; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
550 for (var i = 0; i < this.messages.length; i++) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
551 var msg = this.messages[i]; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
552 if (msg instanceof assignment) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
553 //Make sure method names don't get renamed for hygene |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
554 env.syms[msg.symbol.name] = null; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
555 env.quotetrans[msg.symbol.name] = msg.symbol.name; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
556 if (msg.expression instanceof lambda) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
557 env.syms[msg.symbol.name + '!'] = null; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
558 env.quotetrans[msg.symbol.name + '!'] = msg.symbol.name + '!'; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
559 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
560 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
561 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
562 for (var i = 0; i < this.messages.length; i++) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
563 var msg = this.messages[i]; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
564 if (msg instanceof assignment) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
565 outmessages.push(new assignment(msg.symbol, msg.expression.quote(env))); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
566 } else { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
567 outmessages.push(msg.quote(env)); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
568 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
569 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
570 return new object(outmessages); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
571 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
572 |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
573 object.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
574 return "object"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
575 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
576 |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
577 lambda.prototype.eval = function(parentenv) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
578 var args = this.args; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
579 var exprs = this.expressions; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
580 return function() { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
581 var env = new environment(parentenv); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
582 for (var i = 0, j = 0; i < arguments.length && j < args.length; i++, j++) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
583 while (j < args.length && args[j].cleanName() == 'self') { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
584 j++; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
585 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
586 env.syms[args[j].cleanName()] = arguments[i]; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
587 } |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
588 if (this != null && !(args.length == 0 || args[0].cleanName() != 'self')) { |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
589 env.syms['self'] = this; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
590 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
591 var res = null; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
592 for (var i = 0; i < exprs.length; i++) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
593 res = exprs[i].eval(env); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
594 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
595 return res; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
596 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
597 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
598 |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
599 lambda.prototype.macroexpand = function(parentenv) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
600 var env = new environment(parentenv); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
601 for (var i = 0; i < this.args.length; i++) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
602 env.syms[this.args[i].cleanName()] = {}; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
603 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
604 for (var i = 0; i < this.expressions.length; i++) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
605 var expr = this.expressions[i]; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
606 if (expr instanceof assignment) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
607 if (expr.expression instanceof funcall && expr.expression.name == 'macro:') { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
608 env.defMacro(expr.symbol.name, exp.expression.args[0].eval(env)); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
609 } else { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
610 env.syms[expr.symbol.cleanName()] = {}; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
611 this.expressions[i] = expr.macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
612 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
613 } else { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
614 this.expressions[i] = expr.macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
615 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
616 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
617 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
618 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
619 |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
620 lambda.prototype.quote = function(parentenv) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
621 var args = []; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
622 var expressions = []; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
623 var env = new environment(parentenv); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
624 for (var i = 0; i < this.args.length; i++) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
625 env.syms[this.args[i].cleanName()] = null; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
626 var hygenic = '' + quote_prefix + this.args[i].cleanName(); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
627 env.quotetrans[this.args[i].cleanName()] = hygenic; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
628 args.push(new symbol(hygenic, this.args[i].symbols)); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
629 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
630 for (var i = 0; i < this.expressions.length; i++) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
631 expressions.push(this.expressions[i].quote(env)); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
632 } |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
633 return new lambda(args, expressions); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
634 }; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
635 |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
636 lambda.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
637 return "lambda"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
638 }; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
639 |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
640 assignment.prototype.eval = function(env) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
641 var val = this.expression.eval(env); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
642 env.findSet(this.symbol.name, val); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
643 return val; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
644 }; |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
645 |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
646 assignment.prototype.macroexpand = function(env) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
647 this.expression = this.expression.macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
648 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
649 }; |
208
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
650 |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
651 assignment.prototype.quote = function(env) { |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
652 var name = this.symbol.cleanName(); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
653 env.syms[name] = null; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
654 var hygenic = '' + quote_prefix + name; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
655 env.quotetrans[name] = hygenic; |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
656 return new assignment(new symbol(hygenic, this.symbol.symbols), this.expression.quote(env)); |
a1b4a2bc8d72
Initial work on pattern match macrosfor the new parser
Mike Pavone <pavone@retrodev.com>
parents:
207
diff
changeset
|
657 }; |
209
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
658 |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
659 assignment.prototype.tpmeth_nodeType = function() { |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
660 return "assignment"; |
4b3b57f39f10
Implement zeroPlus macro
Michael Pavone <pavone@retrodev.com>
parents:
208
diff
changeset
|
661 }; |