Mercurial > repos > tabletprog
annotate interp.js @ 207:60eff5f81d9a
Basic implementation of macros is now working
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Tue, 19 Nov 2013 22:02:11 -0800 |
parents | b4a9d4e405c5 |
children | a1b4a2bc8d72 |
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 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
28 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
|
29 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
|
30 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
31 Number.prototype.tpmeth_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
|
32 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
|
33 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
34 |
b4a9d4e405c5
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 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
|
36 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
|
37 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
38 String.prototype['tpmeth_='] = function(other) { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
39 return this == other ? 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
|
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_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
|
42 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
|
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 |
b4a9d4e405c5
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 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
|
46 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
|
47 |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
48 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
|
49 { |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
50 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
|
51 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
|
52 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
|
53 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
|
54 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
|
55 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
|
56 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
|
57 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
|
58 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
59 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
60 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
61 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
|
62 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
|
63 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
|
64 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
|
65 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
66 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
67 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
|
68 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
|
69 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
|
70 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
|
71 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
72 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
73 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
74 |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
75 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
|
76 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
|
77 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
|
78 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
|
79 } |
b4a9d4e405c5
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 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
|
81 var parsed = parseFile(this.names[name]); |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
82 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
|
83 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
|
84 } |
b4a9d4e405c5
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 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
|
86 }, |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
87 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
|
88 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
|
89 }, |
b4a9d4e405c5
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 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
|
91 return false; |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
92 }, |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
93 findMacro: function(name) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
94 return null; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
95 }, |
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
|
96 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
97 |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
98 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
|
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 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
|
101 this.syms = {}; |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
102 this.macros = {}; |
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
|
103 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
104 |
b4a9d4e405c5
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 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
|
106 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
|
107 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
|
108 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
|
109 } |
b4a9d4e405c5
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 (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
|
111 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
|
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 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
|
114 }, |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
115 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
|
116 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
|
117 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
|
118 } |
b4a9d4e405c5
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 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
|
120 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
|
121 } |
b4a9d4e405c5
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 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
|
123 }, |
b4a9d4e405c5
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 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
|
125 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
|
126 || !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
|
127 || !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
|
128 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
|
129 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
130 }, |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
131 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
|
132 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
|
133 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
|
134 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
|
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 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
|
137 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
|
138 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
139 return false; |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
140 }, |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
141 findMacro: function(name) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
142 if (name in this.syms) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
143 if (name in this.macros) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
144 return this.syms[name]; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
145 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
146 return null; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
147 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
148 if (this.parent) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
149 return this.parent.findMacro(name); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
150 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
151 return null; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
152 }, |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
153 defMacro: function(name, def) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
154 this.syms[name] = def; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
155 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
|
156 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
157 }; |
b4a9d4e405c5
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 |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
159 function makeASTNode(val) |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
160 { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
161 if (typeof val == 'number') { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
162 return new intlit(val); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
163 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
164 if (typeof val == 'string') { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
165 return new stringlit(val); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
166 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
167 if (val instanceof Array) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
168 return new arraylit(val); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
169 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
170 if (val == tptrue) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
171 return new symbol('true'); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
172 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
173 if (val == tpfalse) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
174 return new symbol('false'); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
175 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
176 return val; |
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 |
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
|
179 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
|
180 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
|
181 var r = this.right.eval(env); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
182 var name = this.op; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
183 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
|
184 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
|
185 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
|
186 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
|
187 } 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
|
188 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
|
189 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
190 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
|
191 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
192 |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
193 op.prototype.macroexpand = function(env) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
194 this.left = this.left.macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
195 this.right = this.right.macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
196 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
197 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
198 |
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
|
199 symbol.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
|
200 return env.find(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
|
201 }; |
b4a9d4e405c5
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 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
|
204 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
|
205 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
|
206 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
|
207 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
|
208 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
209 |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
210 symbol.prototype.macroexpand = |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
211 intlit.prototype.macroexpand = |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
212 floatlit.prototype.macroexpand = |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
213 strlit.prototype.macroexpand = |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
214 arraylit.prototype.macroexpand = |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
215 listlit.prototype.macroexpand = function(env) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
216 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
217 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
218 |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
219 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
|
220 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
|
221 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
|
222 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
|
223 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
|
224 } |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
225 if (name == 'quote') { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
226 if (this.receiver) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
227 return this.receiver; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
228 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
229 if (this.args.length) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
230 return this.args[0]; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
231 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
232 throw new Error('quote takes an argument'); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
233 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
234 if (name == 'macro') { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
235 return null; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
236 } |
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
|
237 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
|
238 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
|
239 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
240 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
|
241 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
|
242 } |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
243 if (name == 'eval:else') { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
244 try { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
245 var res = args[0].eval(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
246 } catch(e) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
247 return args[2].call(null); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
248 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
249 return args[1].call(null, res); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
250 } |
206
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
251 var fun = env.findNoTop(name); |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
252 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
|
253 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
|
254 } else { |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
255 //if (typeof args[0]'tpmeth_'+name in args[0]) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
256 //try { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
257 return args[0]['tpmeth_'+name].apply(args[0], args.slice(1)); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
258 /*} catch(e) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
259 throw new Error('Error, \n\t' + e.message.split('\n').join('\n\t') + '\ninvoking method ' + name + ' on object ' + args[0] + ' ' + JSON.stringify(Object.keys(args[0]))); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
260 }*/ |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
261 /*} else {JSON.stringify |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
262 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
|
263 }*/ |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
264 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
265 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
266 |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
267 funcall.prototype.macroexpand = function(env) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
268 var name = this.name; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
269 if (name[name.length-1] == ":") { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
270 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
|
271 } |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
272 var macro = env.findMacro(name); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
273 if (this.receiver) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
274 this.receiver = this.receiver.macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
275 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
276 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
|
277 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
|
278 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
279 if (!macro) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
280 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
281 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
282 var args = []; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
283 if (this.receiver) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
284 args.push(this.receiver); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
285 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
286 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
|
287 args.push(this.args[i]); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
288 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
289 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
|
290 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
291 |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
292 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
|
293 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
|
294 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
|
295 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
|
296 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
|
297 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
|
298 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
|
299 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
|
300 (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
|
301 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
|
302 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
|
303 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
304 })(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
|
305 } 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
|
306 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
|
307 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
|
308 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
|
309 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
|
310 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
|
311 }; |
b4a9d4e405c5
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 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
|
313 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
|
314 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
|
315 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
|
316 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
317 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
318 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
|
319 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
320 } 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
|
321 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
|
322 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
323 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
324 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
|
325 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
326 |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
327 object.prototype.macroexpand = function(parentenv) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
328 var env = new environment(parentenv); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
329 var obj = {env: env}; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
330 var outmessages = []; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
331 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
|
332 var msg = this.messages[i].macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
333 if (msg instanceof assignment) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
334 if (msg.expression instanceof lambda) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
335 (function(name, expr) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
336 env.syms[name] = function() { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
337 if (!obj['tpmeth_' + name]) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
338 obj['tpmeth_' + name] = expr.eval(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
339 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
340 return obj['tpmeth_' + name].apply(obj, arguments); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
341 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
342 })(msg.symbol.name, msg.expression); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
343 outmessages.push(msg); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
344 } 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
|
345 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
|
346 } else { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
347 outmessages.push(msg); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
348 /* |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
349 var makeProp = function(obj, name) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
350 obj['tprop_' + name] = msg.expression.eval(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
351 name = 'tpmeth_' + name; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
352 obj[name] = function() { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
353 return this[name]; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
354 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
355 var setname = name+'!'; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
356 obj[setname] = function(val) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
357 this[setname] = val; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
358 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
359 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
360 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
361 makeProp(obj, msg.symbol.name);*/ |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
362 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
363 } else { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
364 outmessages.push(msg); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
365 //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
|
366 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
367 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
368 this.messages = outmessages; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
369 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
370 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
371 |
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
|
372 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
|
373 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
|
374 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
|
375 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
|
376 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
|
377 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
|
378 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
|
379 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
|
380 } |
b4a9d4e405c5
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 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
|
382 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
383 if (this != null && (args.length == 0 || args[0].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
|
384 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
|
385 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
386 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
|
387 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
|
388 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
|
389 } |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
390 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
|
391 }; |
b4a9d4e405c5
Implemented a simple interpreter to be used for macro expansion and a driver for testing it
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
392 }; |
b4a9d4e405c5
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 |
207
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
394 lambda.prototype.macroexpand = function(parentenv) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
395 var env = new environment(parentenv); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
396 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
|
397 env.syms[this.args[i].cleanName()] = {}; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
398 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
399 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
|
400 var expr = this.expressions[i]; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
401 if (expr instanceof assignment) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
402 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
|
403 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
|
404 } else { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
405 env.syms[expr.symbol.cleanName()] = {}; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
406 this.expressions[i] = expr.macroexpand(env); |
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 } else { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
409 this.expressions[i] = expr.macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
410 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
411 } |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
412 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
413 }; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
414 |
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
|
415 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
|
416 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
|
417 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
|
418 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
|
419 }; |
207
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 assignment.prototype.macroexpand = function(env) { |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
422 this.expression = this.expression.macroexpand(env); |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
423 return this; |
60eff5f81d9a
Basic implementation of macros is now working
Mike Pavone <pavone@retrodev.com>
parents:
206
diff
changeset
|
424 }; |