]>
Commit | Line | Data |
---|---|---|
b3378a02 | 1 | /* Cycript - Optimizing JavaScript Compiler/Runtime |
c1d3e52e | 2 | * Copyright (C) 2009-2015 Jay Freeman (saurik) |
4644480a JF |
3 | */ |
4 | ||
f95d2598 | 5 | /* GNU Affero General Public License, Version 3 {{{ */ |
4644480a | 6 | /* |
f95d2598 JF |
7 | * This program is free software: you can redistribute it and/or modify |
8 | * it under the terms of the GNU Affero General Public License as published by | |
9 | * the Free Software Foundation, either version 3 of the License, or | |
10 | * (at your option) any later version. | |
11 | ||
12 | * This program is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
c15969fd | 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
f95d2598 JF |
15 | * GNU Affero General Public License for more details. |
16 | ||
17 | * You should have received a copy of the GNU Affero General Public License | |
18 | * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
b3378a02 | 19 | **/ |
4644480a JF |
20 | /* }}} */ |
21 | ||
3b52fd1a | 22 | #include <iomanip> |
7085e1ab | 23 | #include <map> |
3b52fd1a | 24 | |
20052ff7 JF |
25 | #include "Replace.hpp" |
26 | #include "Syntax.hpp" | |
27 | ||
61fe0c53 JF |
28 | CYFunctionExpression *CYNonLocalize(CYContext &context, CYFunctionExpression *function) { |
29 | function->nonlocal_ = context.nextlocal_; | |
30 | return function; | |
31 | } | |
32 | ||
c5b15840 JF |
33 | CYFunctionExpression *CYSuperize(CYContext &context, CYFunctionExpression *function) { |
34 | function->super_ = context.super_; | |
35 | return function; | |
36 | } | |
37 | ||
a196a97a JF |
38 | CYStatement *CYDefineProperty(CYExpression *object, CYExpression *name, bool configurable, bool enumerable, CYProperty *descriptor) { |
39 | return $E($C3($M($V("Object"), $S("defineProperty")), object, name, $ CYObject(CYList<CYProperty>() | |
40 | ->* (configurable ? $ CYPropertyValue($S("configurable"), $ CYTrue()) : NULL) | |
41 | ->* (enumerable ? $ CYPropertyValue($S("enumerable"), $ CYTrue()) : NULL) | |
42 | ->* descriptor))); | |
43 | } | |
44 | ||
12e37ba3 JF |
45 | static void CYImplicitReturn(CYStatement *&code) { |
46 | if (CYStatement *&last = CYGetLast(code)) | |
47 | last = last->Return(); | |
48 | } | |
49 | ||
4644480a JF |
50 | CYExpression *CYAdd::Replace(CYContext &context) { |
51 | CYInfix::Replace(context); | |
52 | ||
fd5cdf97 JF |
53 | CYString *lhs(dynamic_cast<CYString *>(lhs_)); |
54 | CYString *rhs(dynamic_cast<CYString *>(rhs_)); | |
4644480a JF |
55 | |
56 | if (lhs != NULL || rhs != NULL) { | |
57 | if (lhs == NULL) { | |
fd5cdf97 | 58 | lhs = lhs_->String(context); |
4644480a | 59 | if (lhs == NULL) |
029bc65b | 60 | return this; |
4644480a | 61 | } else if (rhs == NULL) { |
fd5cdf97 | 62 | rhs = rhs_->String(context); |
4644480a | 63 | if (rhs == NULL) |
029bc65b | 64 | return this; |
4644480a JF |
65 | } |
66 | ||
67 | return lhs->Concat(context, rhs); | |
68 | } | |
69 | ||
fd5cdf97 JF |
70 | if (CYNumber *lhn = lhs_->Number(context)) |
71 | if (CYNumber *rhn = rhs_->Number(context)) | |
4644480a JF |
72 | return $D(lhn->Value() + rhn->Value()); |
73 | ||
029bc65b | 74 | return this; |
4644480a JF |
75 | } |
76 | ||
3b52fd1a | 77 | CYExpression *CYAddressOf::Replace(CYContext &context) { |
3b52fd1a JF |
78 | return $C0($M(rhs_, $S("$cya"))); |
79 | } | |
80 | ||
7085e1ab JF |
81 | CYTarget *CYApply::AddArgument(CYContext &context, CYExpression *value) { |
82 | CYArgument **argument(&arguments_); | |
83 | while (*argument != NULL) | |
84 | argument = &(*argument)->next_; | |
85 | *argument = $ CYArgument(value); | |
86 | return this; | |
87 | } | |
88 | ||
5192746c | 89 | CYArgument *CYArgument::Replace(CYContext &context) { $T(NULL) |
3b52fd1a | 90 | context.Replace(value_); |
5192746c JF |
91 | next_ = next_->Replace(context); |
92 | ||
93 | if (value_ == NULL) { | |
94 | if (next_ == NULL) | |
95 | return NULL; | |
96 | else | |
97 | value_ = $U; | |
98 | } | |
99 | ||
100 | return this; | |
3b52fd1a JF |
101 | } |
102 | ||
7085e1ab | 103 | CYTarget *CYArray::Replace(CYContext &context) { |
fc8fc33d JF |
104 | if (elements_ != NULL) |
105 | elements_->Replace(context); | |
029bc65b | 106 | return this; |
3b52fd1a JF |
107 | } |
108 | ||
7085e1ab | 109 | CYTarget *CYArrayComprehension::Replace(CYContext &context) { |
a0932196 | 110 | CYIdentifier *cyv(context.Unique()); |
3b52fd1a | 111 | |
09fc3efb | 112 | return $C0($F(NULL, $P1($B(cyv), comprehensions_->Parameters(context)), $$ |
a0932196 JF |
113 | ->* $E($ CYAssign($V(cyv), $ CYArray())) |
114 | ->* comprehensions_->Replace(context, $E($C1($M($V(cyv), $S("push")), expression_))) | |
115 | ->* $ CYReturn($V(cyv)) | |
3b52fd1a JF |
116 | )); |
117 | } | |
118 | ||
119 | CYExpression *CYAssignment::Replace(CYContext &context) { | |
120 | context.Replace(lhs_); | |
121 | context.Replace(rhs_); | |
029bc65b | 122 | return this; |
3b52fd1a JF |
123 | } |
124 | ||
12e37ba3 JF |
125 | CYStatement *CYBlock::Return() { |
126 | CYImplicitReturn(code_); | |
127 | return this; | |
128 | } | |
129 | ||
3b52fd1a | 130 | CYStatement *CYBlock::Replace(CYContext &context) { |
7085e1ab | 131 | CYScope scope(true, context); |
b0385401 | 132 | context.ReplaceAll(code_); |
7085e1ab JF |
133 | scope.Close(context); |
134 | ||
b0385401 | 135 | if (code_ == NULL) |
029bc65b JF |
136 | return $ CYEmpty(); |
137 | return this; | |
3b52fd1a JF |
138 | } |
139 | ||
140 | CYStatement *CYBreak::Replace(CYContext &context) { | |
029bc65b | 141 | return this; |
3b52fd1a JF |
142 | } |
143 | ||
7085e1ab | 144 | CYTarget *CYCall::Replace(CYContext &context) { |
3b52fd1a JF |
145 | context.Replace(function_); |
146 | arguments_->Replace(context); | |
029bc65b | 147 | return this; |
3b52fd1a JF |
148 | } |
149 | ||
37954781 JF |
150 | namespace cy { |
151 | namespace Syntax { | |
152 | ||
153 | void Catch::Replace(CYContext &context) { $T() | |
50a3d79f | 154 | CYScope scope(true, context); |
daf22a65 | 155 | |
7085e1ab | 156 | name_ = name_->Replace(context, CYIdentifierCatch); |
daf22a65 | 157 | |
b0385401 | 158 | context.ReplaceAll(code_); |
7085e1ab | 159 | scope.Close(context); |
3b52fd1a JF |
160 | } |
161 | ||
37954781 JF |
162 | } } |
163 | ||
7085e1ab | 164 | CYTarget *CYClassExpression::Replace(CYContext &context) { |
c5b15840 JF |
165 | CYBuilder builder; |
166 | ||
167 | CYIdentifier *super(context.Unique()); | |
168 | ||
169 | CYIdentifier *old(context.super_); | |
170 | context.super_ = super; | |
171 | ||
172 | CYIdentifier *constructor(context.Unique()); | |
173 | CYForEach (member, tail_->static_) | |
174 | member->Replace(context, builder, $V(constructor), true); | |
175 | ||
176 | CYIdentifier *prototype(context.Unique()); | |
177 | CYForEach (member, tail_->instance_) | |
178 | member->Replace(context, builder, $V(prototype), true); | |
179 | ||
180 | if (tail_->constructor_ == NULL) | |
181 | tail_->constructor_ = $ CYFunctionExpression(NULL, NULL, NULL); | |
182 | tail_->constructor_ = CYSuperize(context, tail_->constructor_); | |
183 | ||
184 | context.super_ = old; | |
185 | ||
09fc3efb JF |
186 | return $C1($ CYFunctionExpression(NULL, $P($B(super)), $$ |
187 | ->* $ CYVar($B1($B(constructor, tail_->constructor_))) | |
188 | ->* $ CYVar($B1($B(prototype, $ CYFunctionExpression(NULL, NULL, NULL)))) | |
c5b15840 JF |
189 | ->* $E($ CYAssign($M($V(prototype), $S("prototype")), $M($V(super), $S("prototype")))) |
190 | ->* $E($ CYAssign($V(prototype), $N($V(prototype)))) | |
a196a97a | 191 | ->* CYDefineProperty($V(prototype), $S("constructor"), false, false, $ CYPropertyValue($S("value"), $V(constructor))) |
09fc3efb | 192 | ->* $ CYVar(builder.bindings_) |
c5b15840 | 193 | ->* builder.statements_ |
a196a97a | 194 | ->* CYDefineProperty($V(constructor), $S("prototype"), false, false, $ CYPropertyValue($S("value"), $V(prototype))) |
c5b15840 JF |
195 | ->* $ CYReturn($V(constructor)) |
196 | ), tail_->extends_ ?: $V($I("Object"))); | |
197 | } | |
198 | ||
199 | CYStatement *CYClassStatement::Replace(CYContext &context) { | |
09fc3efb | 200 | return $ CYVar($B1($B(name_, $ CYClassExpression(name_, tail_)))); |
c5b15840 JF |
201 | } |
202 | ||
3b52fd1a | 203 | void CYClause::Replace(CYContext &context) { $T() |
09fc3efb | 204 | context.Replace(value_); |
b0385401 | 205 | context.ReplaceAll(code_); |
3b52fd1a JF |
206 | next_->Replace(context); |
207 | } | |
208 | ||
209 | CYExpression *CYCompound::Replace(CYContext &context) { | |
fd5cdf97 JF |
210 | context.Replace(expression_); |
211 | context.Replace(next_); | |
212 | ||
213 | if (CYCompound *compound = dynamic_cast<CYCompound *>(expression_)) { | |
214 | expression_ = compound->expression_; | |
215 | compound->expression_ = compound->next_; | |
216 | compound->next_ = next_; | |
217 | next_ = compound; | |
218 | } | |
219 | ||
9efd8b03 | 220 | return this; |
3b52fd1a JF |
221 | } |
222 | ||
b0385401 JF |
223 | CYFunctionParameter *CYCompound::Parameter() const { |
224 | CYFunctionParameter *next(next_->Parameter()); | |
225 | if (next == NULL) | |
e06e5ee1 | 226 | return NULL; |
0afc9ba3 JF |
227 | |
228 | CYFunctionParameter *parameter(expression_->Parameter()); | |
229 | if (parameter == NULL) | |
230 | return NULL; | |
231 | ||
232 | parameter->SetNext(next); | |
233 | return parameter; | |
234 | } | |
235 | ||
3b52fd1a JF |
236 | CYFunctionParameter *CYComprehension::Parameters(CYContext &context) const { $T(NULL) |
237 | CYFunctionParameter *next(next_->Parameters(context)); | |
238 | if (CYFunctionParameter *parameter = Parameter(context)) { | |
239 | parameter->SetNext(next); | |
240 | return parameter; | |
241 | } else | |
242 | return next; | |
243 | } | |
244 | ||
245 | CYStatement *CYComprehension::Replace(CYContext &context, CYStatement *statement) const { | |
246 | return next_ == NULL ? statement : next_->Replace(context, statement); | |
247 | } | |
248 | ||
c5b15840 JF |
249 | CYExpression *CYComputed::PropertyName(CYContext &context) { |
250 | return expression_; | |
251 | } | |
252 | ||
3b52fd1a JF |
253 | CYExpression *CYCondition::Replace(CYContext &context) { |
254 | context.Replace(test_); | |
255 | context.Replace(true_); | |
256 | context.Replace(false_); | |
029bc65b | 257 | return this; |
3b52fd1a JF |
258 | } |
259 | ||
ab2aa221 JF |
260 | void CYContext::NonLocal(CYStatement *&statements) { |
261 | CYContext &context(*this); | |
262 | ||
06293152 | 263 | if (nextlocal_ != NULL && nextlocal_->identifier_ != NULL) { |
7085e1ab JF |
264 | CYIdentifier *cye($I("$cye")->Replace(context, CYIdentifierGlobal)); |
265 | CYIdentifier *unique(nextlocal_->identifier_->Replace(context, CYIdentifierGlobal)); | |
daf22a65 JF |
266 | |
267 | CYStatement *declare( | |
09fc3efb | 268 | $ CYVar($B1($B(unique, $ CYObject())))); |
daf22a65 JF |
269 | |
270 | cy::Syntax::Catch *rescue( | |
8d970b62 JF |
271 | $ cy::Syntax::Catch(cye, $$ |
272 | ->* $ CYIf($ CYIdentical($M($V(cye), $S("$cyk")), $V(unique)), $$ | |
273 | ->* $ CYReturn($M($V(cye), $S("$cyv")))) | |
274 | ->* $ cy::Syntax::Throw($V(cye)))); | |
daf22a65 | 275 | |
577bfbfa | 276 | context.Replace(declare); |
daf22a65 | 277 | rescue->Replace(context); |
ab2aa221 | 278 | |
8d970b62 JF |
279 | statements = $$ |
280 | ->* declare | |
281 | ->* $ cy::Syntax::Try(statements, rescue, NULL); | |
ab2aa221 JF |
282 | } |
283 | } | |
284 | ||
285 | CYIdentifier *CYContext::Unique() { | |
0cbeddf8 | 286 | return $ CYIdentifier($pool.strcat("$cy", $pool.itoa(unique_++), NULL)); |
ab2aa221 JF |
287 | } |
288 | ||
3b52fd1a | 289 | CYStatement *CYContinue::Replace(CYContext &context) { |
029bc65b JF |
290 | return this; |
291 | } | |
292 | ||
c8a0500b JF |
293 | CYStatement *CYDebugger::Replace(CYContext &context) { |
294 | return this; | |
295 | } | |
296 | ||
09fc3efb | 297 | CYTarget *CYBinding::Target(CYContext &context) { |
7085e1ab JF |
298 | return $V(identifier_); |
299 | } | |
300 | ||
09fc3efb | 301 | CYAssignment *CYBinding::Replace(CYContext &context, CYIdentifierKind kind) { |
7085e1ab JF |
302 | identifier_ = identifier_->Replace(context, kind); |
303 | ||
09fc3efb | 304 | if (initializer_ == NULL) |
15b88a33 | 305 | return NULL; |
127c1a9c | 306 | |
09fc3efb JF |
307 | CYAssignment *value($ CYAssign(Target(context), initializer_)); |
308 | initializer_ = NULL; | |
127c1a9c | 309 | return value; |
15b88a33 JF |
310 | } |
311 | ||
09fc3efb JF |
312 | CYExpression *CYBindings::Replace(CYContext &context, CYIdentifierKind kind) { $T(NULL) |
313 | CYAssignment *assignment(binding_->Replace(context, kind)); | |
7085e1ab | 314 | CYExpression *compound(next_->Replace(context, kind)); |
3b52fd1a | 315 | |
7085e1ab JF |
316 | if (assignment != NULL) |
317 | if (compound == NULL) | |
318 | compound = assignment; | |
319 | else | |
320 | compound = $ CYCompound(assignment, compound); | |
321 | return compound; | |
3b52fd1a JF |
322 | } |
323 | ||
09fc3efb JF |
324 | CYFunctionParameter *CYBindings::Parameter(CYContext &context) { $T(NULL) |
325 | return $ CYFunctionParameter($ CYBinding(binding_->identifier_), next_->Parameter(context)); | |
15b88a33 JF |
326 | } |
327 | ||
09fc3efb JF |
328 | CYArgument *CYBindings::Argument(CYContext &context) { $T(NULL) |
329 | return $ CYArgument(binding_->initializer_, next_->Argument(context)); | |
15b88a33 JF |
330 | } |
331 | ||
7085e1ab | 332 | CYTarget *CYDirectMember::Replace(CYContext &context) { |
ca0f097f JF |
333 | context.Replace(object_); |
334 | context.Replace(property_); | |
029bc65b | 335 | return this; |
3b52fd1a JF |
336 | } |
337 | ||
338 | CYStatement *CYDoWhile::Replace(CYContext &context) { | |
339 | context.Replace(test_); | |
b0385401 | 340 | context.ReplaceAll(code_); |
029bc65b | 341 | return this; |
3b52fd1a JF |
342 | } |
343 | ||
fc8fc33d | 344 | void CYElementSpread::Replace(CYContext &context) { |
3b52fd1a | 345 | context.Replace(value_); |
fc8fc33d JF |
346 | } |
347 | ||
348 | void CYElementValue::Replace(CYContext &context) { | |
349 | context.Replace(value_); | |
350 | if (next_ != NULL) | |
351 | next_->Replace(context); | |
3b52fd1a JF |
352 | } |
353 | ||
bfd79fae | 354 | CYForInitializer *CYEmpty::Replace(CYContext &context) { |
9cd63688 | 355 | return NULL; |
029bc65b JF |
356 | } |
357 | ||
7085e1ab | 358 | CYTarget *CYEncodedType::Replace(CYContext &context) { |
9a39f705 JF |
359 | return typed_->Replace(context); |
360 | } | |
361 | ||
7085e1ab JF |
362 | CYTarget *CYEval::Replace(CYContext &context) { |
363 | context.scope_->Damage(); | |
364 | if (arguments_ != NULL) | |
365 | arguments_->value_ = $C1($M($V("Cycript"), $S("compile")), arguments_->value_); | |
366 | return $C($V("eval"), arguments_); | |
367 | } | |
368 | ||
12e37ba3 JF |
369 | CYStatement *CYExpress::Return() { |
370 | return $ CYReturn(expression_); | |
371 | } | |
372 | ||
bfd79fae | 373 | CYForInitializer *CYExpress::Replace(CYContext &context) { |
3b52fd1a | 374 | context.Replace(expression_); |
029bc65b | 375 | return this; |
3b52fd1a JF |
376 | } |
377 | ||
7085e1ab | 378 | CYTarget *CYExpression::AddArgument(CYContext &context, CYExpression *value) { |
6c093cce JF |
379 | return $C1(this, value); |
380 | } | |
381 | ||
0afc9ba3 JF |
382 | CYFunctionParameter *CYExpression::Parameter() const { |
383 | return NULL; | |
384 | } | |
385 | ||
c5587ed7 JF |
386 | CYStatement *CYExternal::Replace(CYContext &context) { |
387 | return $E($ CYAssign($V(typed_->identifier_), $C1(typed_->Replace(context), $C2($V("dlsym"), $V("RTLD_DEFAULT"), $S(typed_->identifier_->Word()))))); | |
388 | } | |
389 | ||
4644480a JF |
390 | CYNumber *CYFalse::Number(CYContext &context) { |
391 | return $D(0); | |
392 | } | |
393 | ||
394 | CYString *CYFalse::String(CYContext &context) { | |
395 | return $S("false"); | |
396 | } | |
397 | ||
a0be43fc JF |
398 | CYExpression *CYFatArrow::Replace(CYContext &context) { |
399 | CYFunctionExpression *function($ CYFunctionExpression(NULL, parameters_, code_)); | |
400 | function->this_.SetNext(context.this_); | |
401 | return function; | |
402 | } | |
403 | ||
3b52fd1a | 404 | void CYFinally::Replace(CYContext &context) { $T() |
7085e1ab | 405 | CYScope scope(true, context); |
b0385401 | 406 | context.ReplaceAll(code_); |
7085e1ab | 407 | scope.Close(context); |
3b52fd1a JF |
408 | } |
409 | ||
410 | CYStatement *CYFor::Replace(CYContext &context) { | |
7085e1ab | 411 | CYScope outer(true, context); |
09fc3efb | 412 | context.Replace(initializer_); |
7085e1ab | 413 | |
3b52fd1a | 414 | context.Replace(test_); |
7085e1ab JF |
415 | |
416 | { | |
417 | CYScope inner(true, context); | |
418 | context.ReplaceAll(code_); | |
419 | inner.Close(context); | |
420 | } | |
421 | ||
3b52fd1a | 422 | context.Replace(increment_); |
7085e1ab JF |
423 | |
424 | outer.Close(context); | |
029bc65b | 425 | return this; |
3b52fd1a JF |
426 | } |
427 | ||
7085e1ab JF |
428 | CYStatement *CYForLexical::Initialize(CYContext &context, CYExpression *value) { |
429 | if (value == NULL) { | |
09fc3efb | 430 | if (binding_->initializer_ == NULL) |
7085e1ab | 431 | return NULL; |
09fc3efb | 432 | value = binding_->initializer_; |
7085e1ab JF |
433 | } |
434 | ||
09fc3efb | 435 | return $ CYLexical(constant_, $B1($ CYBinding(binding_->identifier_, value))); |
7085e1ab JF |
436 | } |
437 | ||
438 | CYTarget *CYForLexical::Replace(CYContext &context) { | |
09fc3efb JF |
439 | _assert(binding_->Replace(context, CYIdentifierLexical) == NULL); |
440 | return binding_->Target(context); | |
7085e1ab | 441 | } |
ae65d594 | 442 | |
7085e1ab JF |
443 | CYStatement *CYForIn::Replace(CYContext &context) { |
444 | CYScope scope(true, context); | |
09fc3efb JF |
445 | context.Replace(initializer_); |
446 | context.Replace(iterable_); | |
b0385401 | 447 | context.ReplaceAll(code_); |
7085e1ab | 448 | scope.Close(context); |
15b88a33 | 449 | return this; |
3b52fd1a JF |
450 | } |
451 | ||
23111dca | 452 | CYStatement *CYForInitialized::Replace(CYContext &context) { |
09fc3efb | 453 | CYAssignment *assignment(binding_->Replace(context, CYIdentifierVariable)); |
23111dca JF |
454 | return $ CYBlock($$ |
455 | ->* (assignment == NULL ? NULL : $ CYExpress(assignment)) | |
09fc3efb | 456 | ->* $ CYForIn(binding_->Target(context), iterable_, code_)); |
23111dca JF |
457 | } |
458 | ||
3b52fd1a | 459 | CYFunctionParameter *CYForInComprehension::Parameter(CYContext &context) const { |
09fc3efb | 460 | return $ CYFunctionParameter(binding_); |
3b52fd1a JF |
461 | } |
462 | ||
463 | CYStatement *CYForInComprehension::Replace(CYContext &context, CYStatement *statement) const { | |
09fc3efb | 464 | return $ CYForIn(binding_->Target(context), iterable_, CYComprehension::Replace(context, statement)); |
3b52fd1a JF |
465 | } |
466 | ||
d5618df7 | 467 | CYStatement *CYForOf::Replace(CYContext &context) { |
7085e1ab | 468 | CYIdentifier *item(context.Unique()), *list(context.Unique()); |
3b52fd1a | 469 | |
ca6a1b2b | 470 | return $ CYBlock($$ |
09fc3efb JF |
471 | ->* initializer_->Initialize(context, NULL) |
472 | ->* $ CYLexical(false, $B2($B(list, iterable_), $B(item))) | |
7085e1ab | 473 | ->* $ CYForIn($V(item), $V(list), $ CYBlock($$ |
09fc3efb | 474 | ->* initializer_->Initialize(context, $M($V(list), $V(item))) |
ca6a1b2b JF |
475 | ->* code_ |
476 | ))); | |
3b52fd1a JF |
477 | } |
478 | ||
d5618df7 | 479 | CYFunctionParameter *CYForOfComprehension::Parameter(CYContext &context) const { |
09fc3efb | 480 | return $ CYFunctionParameter(binding_); |
3b52fd1a JF |
481 | } |
482 | ||
d5618df7 | 483 | CYStatement *CYForOfComprehension::Replace(CYContext &context, CYStatement *statement) const { |
a0932196 | 484 | CYIdentifier *cys(context.Unique()); |
3b52fd1a | 485 | |
a0932196 | 486 | return $ CYBlock($$ |
09fc3efb JF |
487 | ->* $ CYLexical(false, $B1($B(cys, iterable_))) |
488 | ->* $ CYForIn(binding_->Target(context), $V(cys), $ CYBlock($$ | |
489 | ->* $E($ CYAssign(binding_->Target(context), $M($V(cys), binding_->Target(context)))) | |
8d970b62 | 490 | ->* CYComprehension::Replace(context, statement) |
3b52fd1a JF |
491 | ))); |
492 | } | |
493 | ||
7085e1ab JF |
494 | CYStatement *CYForVariable::Initialize(CYContext &context, CYExpression *value) { |
495 | if (value == NULL) { | |
09fc3efb | 496 | if (binding_->initializer_ == NULL) |
7085e1ab | 497 | return NULL; |
09fc3efb | 498 | value = binding_->initializer_; |
7085e1ab JF |
499 | } |
500 | ||
09fc3efb | 501 | return $ CYVar($B1($ CYBinding(binding_->identifier_, value))); |
7085e1ab JF |
502 | } |
503 | ||
504 | CYTarget *CYForVariable::Replace(CYContext &context) { | |
09fc3efb JF |
505 | _assert(binding_->Replace(context, CYIdentifierVariable) == NULL); |
506 | return binding_->Target(context); | |
7085e1ab JF |
507 | } |
508 | ||
509 | // XXX: this is evil evil black magic. don't ask, don't tell... don't believe! | |
510 | #define MappingSet "0etnirsoalfucdphmgyvbxTwSNECAFjDLkMOIBPqzRH$_WXUVGYKQJZ" | |
511 | //#define MappingSet "0abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_" | |
512 | ||
c5b15840 | 513 | void CYFunction::Replace(CYContext &context) { |
a0be43fc | 514 | CYThisScope *_this(context.this_); |
12e37ba3 JF |
515 | context.this_ = &this_; |
516 | context.this_ = CYGetLast(context.this_); | |
a0be43fc | 517 | |
c5b15840 JF |
518 | CYIdentifier *super(context.super_); |
519 | context.super_ = super_; | |
520 | ||
06293152 JF |
521 | CYNonLocal *nonlocal(context.nonlocal_); |
522 | CYNonLocal *nextlocal(context.nextlocal_); | |
523 | ||
ab2aa221 | 524 | bool localize; |
06293152 | 525 | if (nonlocal_ != NULL) { |
ab2aa221 | 526 | localize = false; |
06293152 JF |
527 | context.nonlocal_ = nonlocal_; |
528 | } else { | |
ab2aa221 JF |
529 | localize = true; |
530 | nonlocal_ = $ CYNonLocal(); | |
06293152 | 531 | context.nextlocal_ = nonlocal_; |
ab2aa221 JF |
532 | } |
533 | ||
50a3d79f | 534 | CYScope scope(!localize, context); |
61fe0c53 | 535 | |
b026d136 JF |
536 | $I("arguments")->Replace(context, CYIdentifierMagic); |
537 | ||
c8a0500b | 538 | parameters_->Replace(context, code_); |
c5b15840 | 539 | |
b0385401 | 540 | context.ReplaceAll(code_); |
029bc65b | 541 | |
12e37ba3 JF |
542 | if (implicit_) |
543 | CYImplicitReturn(code_); | |
544 | ||
c5b15840 JF |
545 | if (CYIdentifier *identifier = this_.identifier_) { |
546 | context.scope_->Declare(context, identifier, CYIdentifierVariable); | |
547 | code_ = $$ | |
8d970b62 JF |
548 | ->* $E($ CYAssign($V(identifier), $ CYThis())) |
549 | ->* code_; | |
c5b15840 | 550 | } |
a0be43fc | 551 | |
ab2aa221 | 552 | if (localize) |
b0385401 | 553 | context.NonLocal(code_); |
06293152 JF |
554 | |
555 | context.nextlocal_ = nextlocal; | |
ab2aa221 JF |
556 | context.nonlocal_ = nonlocal; |
557 | ||
c5b15840 | 558 | context.super_ = super; |
a0be43fc JF |
559 | context.this_ = _this; |
560 | ||
b0385401 | 561 | scope.Close(context, code_); |
3b52fd1a JF |
562 | } |
563 | ||
7085e1ab | 564 | CYTarget *CYFunctionExpression::Replace(CYContext &context) { |
c5b15840 JF |
565 | CYScope scope(false, context); |
566 | if (name_ != NULL) | |
7085e1ab JF |
567 | name_ = name_->Replace(context, CYIdentifierOther); |
568 | ||
c5b15840 | 569 | CYFunction::Replace(context); |
7085e1ab | 570 | scope.Close(context); |
029bc65b JF |
571 | return this; |
572 | } | |
573 | ||
b0385401 | 574 | void CYFunctionParameter::Replace(CYContext &context, CYStatement *&statements) { $T() |
09fc3efb | 575 | CYAssignment *assignment(binding_->Replace(context, CYIdentifierArgument)); |
c8a0500b | 576 | |
b0385401 | 577 | next_->Replace(context, statements); |
c8a0500b JF |
578 | |
579 | if (assignment != NULL) | |
8d970b62 | 580 | statements = $$ |
09fc3efb | 581 | ->* $ CYIf($ CYIdentical($ CYTypeOf(binding_->Target(context)), $S("undefined")), $$ |
8d970b62 JF |
582 | ->* $E(assignment)) |
583 | ->* statements; | |
3b52fd1a JF |
584 | } |
585 | ||
586 | CYStatement *CYFunctionStatement::Replace(CYContext &context) { | |
7085e1ab | 587 | name_ = name_->Replace(context, CYIdentifierOther); |
c5b15840 | 588 | CYFunction::Replace(context); |
029bc65b JF |
589 | return this; |
590 | } | |
591 | ||
7085e1ab JF |
592 | CYIdentifier *CYIdentifier::Replace(CYContext &context, CYIdentifierKind kind) { |
593 | if (next_ == this) | |
594 | return this; | |
595 | if (next_ != NULL) | |
596 | return next_->Replace(context, kind); | |
597 | next_ = context.scope_->Declare(context, this, kind)->identifier_; | |
598 | return next_; | |
3b52fd1a JF |
599 | } |
600 | ||
12e37ba3 JF |
601 | CYStatement *CYIf::Return() { |
602 | CYImplicitReturn(true_); | |
603 | CYImplicitReturn(false_); | |
604 | return this; | |
605 | } | |
606 | ||
3b52fd1a JF |
607 | CYStatement *CYIf::Replace(CYContext &context) { |
608 | context.Replace(test_); | |
b0385401 JF |
609 | context.ReplaceAll(true_); |
610 | context.ReplaceAll(false_); | |
029bc65b | 611 | return this; |
3b52fd1a JF |
612 | } |
613 | ||
614 | CYFunctionParameter *CYIfComprehension::Parameter(CYContext &context) const { | |
615 | return NULL; | |
616 | } | |
617 | ||
618 | CYStatement *CYIfComprehension::Replace(CYContext &context, CYStatement *statement) const { | |
619 | return $ CYIf(test_, CYComprehension::Replace(context, statement)); | |
620 | } | |
621 | ||
7b750785 | 622 | CYStatement *CYImport::Replace(CYContext &context) { |
09fc3efb | 623 | return $ CYVar($B1($B($I(module_->part_->Word()), $C1($V("require"), module_->Replace(context, "/"))))); |
7b750785 JF |
624 | } |
625 | ||
7085e1ab | 626 | CYTarget *CYIndirect::Replace(CYContext &context) { |
3b52fd1a JF |
627 | return $M(rhs_, $S("$cyi")); |
628 | } | |
629 | ||
7085e1ab | 630 | CYTarget *CYIndirectMember::Replace(CYContext &context) { |
3b52fd1a JF |
631 | return $M($ CYIndirect(object_), property_); |
632 | } | |
633 | ||
634 | CYExpression *CYInfix::Replace(CYContext &context) { | |
635 | context.Replace(lhs_); | |
636 | context.Replace(rhs_); | |
029bc65b | 637 | return this; |
3b52fd1a JF |
638 | } |
639 | ||
640 | CYStatement *CYLabel::Replace(CYContext &context) { | |
641 | context.Replace(statement_); | |
029bc65b | 642 | return this; |
3b52fd1a JF |
643 | } |
644 | ||
7085e1ab | 645 | CYTarget *CYLambda::Replace(CYContext &context) { |
b0385401 | 646 | return $N2($V("Functor"), $ CYFunctionExpression(NULL, parameters_->Parameters(context), code_), parameters_->TypeSignature(context, typed_->Replace(context))); |
690cf1a8 JF |
647 | } |
648 | ||
09fc3efb JF |
649 | CYForInitializer *CYLexical::Replace(CYContext &context) { |
650 | if (CYExpression *expression = bindings_->Replace(context, CYIdentifierLexical)) | |
ca6a1b2b JF |
651 | return $E(expression); |
652 | return $ CYEmpty(); | |
550ee46a JF |
653 | } |
654 | ||
c5b15840 JF |
655 | CYFunctionExpression *CYMethod::Constructor() { |
656 | return NULL; | |
657 | } | |
658 | ||
659 | void CYMethod::Replace(CYContext &context) { | |
660 | CYFunction::Replace(context); | |
661 | } | |
662 | ||
7b750785 JF |
663 | CYString *CYModule::Replace(CYContext &context, const char *separator) const { |
664 | if (next_ == NULL) | |
665 | return $ CYString(part_); | |
666 | return $ CYString($pool.strcat(next_->Replace(context, separator)->Value(), separator, part_->Word(), NULL)); | |
667 | } | |
668 | ||
62f398e4 JF |
669 | CYExpression *CYMultiply::Replace(CYContext &context) { |
670 | CYInfix::Replace(context); | |
671 | ||
fd5cdf97 JF |
672 | if (CYNumber *lhn = lhs_->Number(context)) |
673 | if (CYNumber *rhn = rhs_->Number(context)) | |
62f398e4 JF |
674 | return $D(lhn->Value() * rhn->Value()); |
675 | ||
676 | return this; | |
677 | } | |
678 | ||
2eb8215d JF |
679 | namespace cy { |
680 | namespace Syntax { | |
681 | ||
7085e1ab | 682 | CYTarget *New::AddArgument(CYContext &context, CYExpression *value) { |
bf45251b | 683 | CYSetLast(arguments_) = $ CYArgument(value); |
6c093cce JF |
684 | return this; |
685 | } | |
686 | ||
7085e1ab | 687 | CYTarget *New::Replace(CYContext &context) { |
3b52fd1a JF |
688 | context.Replace(constructor_); |
689 | arguments_->Replace(context); | |
029bc65b | 690 | return this; |
3b52fd1a JF |
691 | } |
692 | ||
2eb8215d JF |
693 | } } |
694 | ||
4644480a JF |
695 | CYNumber *CYNull::Number(CYContext &context) { |
696 | return $D(0); | |
697 | } | |
698 | ||
699 | CYString *CYNull::String(CYContext &context) { | |
700 | return $S("null"); | |
701 | } | |
702 | ||
703 | CYNumber *CYNumber::Number(CYContext &context) { | |
704 | return this; | |
705 | } | |
706 | ||
707 | CYString *CYNumber::String(CYContext &context) { | |
708 | // XXX: there is a precise algorithm for this | |
0cbeddf8 | 709 | return $S($pool.sprintf(24, "%.17g", Value())); |
4644480a JF |
710 | } |
711 | ||
c5b15840 JF |
712 | CYExpression *CYNumber::PropertyName(CYContext &context) { |
713 | return String(context); | |
714 | } | |
715 | ||
7085e1ab | 716 | CYTarget *CYObject::Replace(CYContext &context) { |
c5b15840 JF |
717 | CYBuilder builder; |
718 | if (properties_ != NULL) | |
719 | properties_ = properties_->ReplaceAll(context, builder, $ CYThis(), false); | |
720 | ||
721 | if (builder) { | |
09fc3efb | 722 | return $C1($M($ CYFunctionExpression(NULL, builder.bindings_->Parameter(context), |
8d970b62 JF |
723 | builder.statements_ |
724 | ->* $ CYReturn($ CYThis()) | |
09fc3efb | 725 | ), $S("call")), this, builder.bindings_->Argument(context)); |
c5b15840 JF |
726 | } |
727 | ||
728 | CYForEach (property, properties_) | |
729 | property->Replace(context); | |
029bc65b | 730 | return this; |
3b52fd1a JF |
731 | } |
732 | ||
7085e1ab JF |
733 | CYTarget *CYParenthetical::Replace(CYContext &context) { |
734 | // XXX: return expression_; | |
735 | context.Replace(expression_); | |
736 | return this; | |
b0385401 JF |
737 | } |
738 | ||
3b52fd1a JF |
739 | CYExpression *CYPostfix::Replace(CYContext &context) { |
740 | context.Replace(lhs_); | |
029bc65b | 741 | return this; |
3b52fd1a JF |
742 | } |
743 | ||
744 | CYExpression *CYPrefix::Replace(CYContext &context) { | |
745 | context.Replace(rhs_); | |
029bc65b | 746 | return this; |
3b52fd1a JF |
747 | } |
748 | ||
c5b15840 | 749 | CYProperty *CYProperty::ReplaceAll(CYContext &context, CYBuilder &builder, CYExpression *self, bool update) { |
7b87d205 | 750 | update |= Update(); |
c5b15840 | 751 | if (update) |
a196a97a | 752 | Replace(context, builder, self, false); |
c5b15840 JF |
753 | if (next_ != NULL) |
754 | next_ = next_->ReplaceAll(context, builder, self, update); | |
755 | return update ? next_ : this; | |
756 | } | |
757 | ||
a196a97a | 758 | void CYProperty::Replace(CYContext &context, CYBuilder &builder, CYExpression *self, bool protect) { |
c5b15840 | 759 | CYExpression *name(name_->PropertyName(context)); |
a196a97a | 760 | if (name_->Computed()) { |
c5b15840 | 761 | CYIdentifier *unique(context.Unique()); |
09fc3efb JF |
762 | builder.bindings_ |
763 | ->* $B1($B(unique, name)); | |
c5b15840 JF |
764 | name = $V(unique); |
765 | } | |
766 | ||
a196a97a | 767 | Replace(context, builder, self, name, protect); |
c5b15840 JF |
768 | } |
769 | ||
7b87d205 JF |
770 | bool CYProperty::Update() const { |
771 | return name_->Computed(); | |
772 | } | |
773 | ||
a196a97a | 774 | void CYPropertyGetter::Replace(CYContext &context, CYBuilder &builder, CYExpression *self, CYExpression *name, bool protect) { |
c5b15840 | 775 | CYIdentifier *unique(context.Unique()); |
09fc3efb JF |
776 | builder.bindings_ |
777 | ->* $B1($B(unique, CYSuperize(context, $ CYFunctionExpression(NULL, parameters_, code_)))); | |
c5b15840 | 778 | builder.statements_ |
a196a97a | 779 | ->* CYDefineProperty(self, name, true, !protect, $ CYPropertyValue($S("get"), $V(unique))); |
c5b15840 JF |
780 | } |
781 | ||
782 | CYFunctionExpression *CYPropertyMethod::Constructor() { | |
783 | return name_->Constructor() ? $ CYFunctionExpression(NULL, parameters_, code_) : NULL; | |
784 | } | |
785 | ||
a196a97a | 786 | void CYPropertyMethod::Replace(CYContext &context, CYBuilder &builder, CYExpression *self, CYExpression *name, bool protect) { |
c5b15840 | 787 | CYIdentifier *unique(context.Unique()); |
09fc3efb JF |
788 | builder.bindings_ |
789 | ->* $B1($B(unique, CYSuperize(context, $ CYFunctionExpression(NULL, parameters_, code_)))); | |
c5b15840 | 790 | builder.statements_ |
a196a97a JF |
791 | ->* (!protect ? $E($ CYAssign($M(self, name), $V(unique))) : |
792 | CYDefineProperty(self, name, true, !protect, $ CYPropertyValue($S("value"), $V(unique), $ CYPropertyValue($S("writable"), $ CYTrue())))); | |
c5b15840 JF |
793 | } |
794 | ||
7b87d205 JF |
795 | bool CYPropertyMethod::Update() const { |
796 | return true; | |
797 | } | |
798 | ||
a196a97a | 799 | void CYPropertySetter::Replace(CYContext &context, CYBuilder &builder, CYExpression *self, CYExpression *name, bool protect) { |
c5b15840 | 800 | CYIdentifier *unique(context.Unique()); |
09fc3efb JF |
801 | builder.bindings_ |
802 | ->* $B1($B(unique, CYSuperize(context, $ CYFunctionExpression(NULL, parameters_, code_)))); | |
c5b15840 | 803 | builder.statements_ |
a196a97a | 804 | ->* CYDefineProperty(self, name, true, !protect, $ CYPropertyValue($S("set"), $V(unique))); |
c5b15840 JF |
805 | } |
806 | ||
a196a97a JF |
807 | void CYPropertyValue::Replace(CYContext &context, CYBuilder &builder, CYExpression *self, CYExpression *name, bool protect) { |
808 | _assert(!protect); | |
c5b15840 | 809 | CYIdentifier *unique(context.Unique()); |
09fc3efb JF |
810 | builder.bindings_ |
811 | ->* $B1($B(unique, value_)); | |
c5b15840 JF |
812 | builder.statements_ |
813 | ->* $E($ CYAssign($M(self, name), $V(unique))); | |
814 | } | |
815 | ||
816 | void CYPropertyValue::Replace(CYContext &context) { | |
817 | context.Replace(value_); | |
818 | } | |
819 | ||
a7d8b413 | 820 | void CYScript::Replace(CYContext &context) { |
7085e1ab JF |
821 | CYScope scope(false, context); |
822 | context.scope_->Damage(); | |
ab2aa221 | 823 | |
06293152 | 824 | context.nextlocal_ = $ CYNonLocal(); |
b0385401 JF |
825 | context.ReplaceAll(code_); |
826 | context.NonLocal(code_); | |
ab2aa221 | 827 | |
b0385401 | 828 | scope.Close(context, code_); |
14ec9e00 | 829 | |
7085e1ab | 830 | unsigned offset(0); |
de9fc71b | 831 | |
7085e1ab | 832 | for (std::vector<CYIdentifier *>::const_iterator i(context.replace_.begin()); i != context.replace_.end(); ++i) { |
14ec9e00 | 833 | const char *name; |
14ec9e00 | 834 | if (context.options_.verbose_) |
7085e1ab | 835 | name = $pool.strcat("$", $pool.itoa(offset++), NULL); |
14ec9e00 JF |
836 | else { |
837 | char id[8]; | |
838 | id[7] = '\0'; | |
839 | ||
840 | id: | |
7085e1ab | 841 | unsigned position(7), local(offset++ + 1); |
14ec9e00 JF |
842 | |
843 | do { | |
45d0c928 JF |
844 | unsigned index(local % (sizeof(MappingSet) - 1)); |
845 | local /= sizeof(MappingSet) - 1; | |
846 | id[--position] = MappingSet[index]; | |
14ec9e00 JF |
847 | } while (local != 0); |
848 | ||
7085e1ab | 849 | if (scope.Lookup(context, id + position) != NULL) |
14ec9e00 | 850 | goto id; |
7085e1ab | 851 | // XXX: at some point, this could become a keyword |
14ec9e00 | 852 | |
b799113b | 853 | name = $pool.strmemdup(id + position, 7 - position); |
14ec9e00 JF |
854 | } |
855 | ||
7085e1ab JF |
856 | CYIdentifier *identifier(*i); |
857 | _assert(identifier->next_ == identifier); | |
858 | identifier->next_ = $I(name); | |
14ec9e00 | 859 | } |
3b52fd1a JF |
860 | } |
861 | ||
3b52fd1a | 862 | CYStatement *CYReturn::Replace(CYContext &context) { |
ab2aa221 | 863 | if (context.nonlocal_ != NULL) { |
c5b15840 | 864 | CYProperty *value(value_ == NULL ? NULL : $ CYPropertyValue($S("$cyv"), value_)); |
ab2aa221 | 865 | return $ cy::Syntax::Throw($ CYObject( |
c5b15840 | 866 | $ CYPropertyValue($S("$cyk"), $V(context.nonlocal_->Target(context)), value) |
ab2aa221 JF |
867 | )); |
868 | } | |
869 | ||
3b52fd1a | 870 | context.Replace(value_); |
029bc65b JF |
871 | return this; |
872 | } | |
873 | ||
7085e1ab | 874 | CYTarget *CYRubyBlock::Replace(CYContext &context) { |
6c093cce JF |
875 | return call_->AddArgument(context, proc_->Replace(context)); |
876 | } | |
877 | ||
7085e1ab | 878 | CYTarget *CYRubyBlock::AddArgument(CYContext &context, CYExpression *value) { |
1abe53bf JF |
879 | return Replace(context)->AddArgument(context, value); |
880 | } | |
881 | ||
7085e1ab | 882 | CYTarget *CYRubyProc::Replace(CYContext &context) { |
12e37ba3 JF |
883 | CYFunctionExpression *function($ CYFunctionExpression(NULL, parameters_, code_)); |
884 | function = CYNonLocalize(context, function); | |
885 | function->implicit_ = true; | |
886 | return function; | |
6c093cce JF |
887 | } |
888 | ||
50a3d79f | 889 | CYScope::CYScope(bool transparent, CYContext &context) : |
61fe0c53 | 890 | transparent_(transparent), |
7085e1ab JF |
891 | parent_(context.scope_), |
892 | damaged_(false), | |
893 | shadow_(NULL), | |
894 | internal_(NULL) | |
daf22a65 | 895 | { |
7085e1ab | 896 | _assert(!transparent_ || parent_ != NULL); |
50a3d79f | 897 | context.scope_ = this; |
daf22a65 JF |
898 | } |
899 | ||
7085e1ab JF |
900 | void CYScope::Damage() { |
901 | damaged_ = true; | |
902 | if (parent_ != NULL) | |
903 | parent_->Damage(); | |
a86e34d0 JF |
904 | } |
905 | ||
7085e1ab JF |
906 | CYIdentifierFlags *CYScope::Lookup(CYContext &context, const char *word) { |
907 | CYForEach (i, internal_) | |
908 | if (strcmp(i->identifier_->Word(), word) == 0) | |
909 | return i; | |
910 | return NULL; | |
a86e34d0 JF |
911 | } |
912 | ||
7085e1ab JF |
913 | CYIdentifierFlags *CYScope::Lookup(CYContext &context, CYIdentifier *identifier) { |
914 | return Lookup(context, identifier->Word()); | |
029bc65b JF |
915 | } |
916 | ||
7085e1ab JF |
917 | CYIdentifierFlags *CYScope::Declare(CYContext &context, CYIdentifier *identifier, CYIdentifierKind kind) { |
918 | _assert(identifier->next_ == NULL || identifier->next_ == identifier); | |
10711823 | 919 | |
7085e1ab JF |
920 | CYIdentifierFlags *existing(Lookup(context, identifier)); |
921 | if (existing == NULL) | |
922 | internal_ = $ CYIdentifierFlags(identifier, kind, internal_); | |
923 | ++internal_->count_; | |
924 | if (existing == NULL) | |
925 | return internal_; | |
10711823 | 926 | |
f5753712 JF |
927 | if (kind == CYIdentifierGlobal); |
928 | else if (existing->kind_ == CYIdentifierGlobal || existing->kind_ == CYIdentifierMagic) | |
7085e1ab | 929 | existing->kind_ = kind; |
7085e1ab JF |
930 | else if (existing->kind_ == CYIdentifierLexical || kind == CYIdentifierLexical) |
931 | _assert(false); // XXX: throw new SyntaxError() | |
10711823 | 932 | |
7085e1ab JF |
933 | return existing; |
934 | } | |
935 | ||
936 | void CYScope::Merge(CYContext &context, const CYIdentifierFlags *flags) { | |
937 | _assert(flags->identifier_->next_ == flags->identifier_); | |
938 | CYIdentifierFlags *existing(Declare(context, flags->identifier_, flags->kind_)); | |
939 | flags->identifier_->next_ = existing->identifier_; | |
940 | ||
941 | existing->count_ += flags->count_; | |
942 | if (existing->offset_ < flags->offset_) | |
943 | existing->offset_ = flags->offset_; | |
10711823 JF |
944 | } |
945 | ||
50a3d79f | 946 | void CYScope::Close(CYContext &context, CYStatement *&statements) { |
7085e1ab JF |
947 | Close(context); |
948 | ||
09fc3efb | 949 | CYList<CYBindings> bindings; |
7085e1ab JF |
950 | |
951 | CYForEach (i, internal_) | |
952 | if (i->kind_ == CYIdentifierVariable) | |
09fc3efb JF |
953 | bindings |
954 | ->* $ CYBindings($ CYBinding(i->identifier_)); | |
7085e1ab | 955 | |
09fc3efb JF |
956 | if (bindings) { |
957 | CYVar *var($ CYVar(bindings)); | |
7085e1ab JF |
958 | var->SetNext(statements); |
959 | statements = var; | |
960 | } | |
961 | } | |
962 | ||
963 | void CYScope::Close(CYContext &context) { | |
50a3d79f JF |
964 | context.scope_ = parent_; |
965 | ||
7085e1ab JF |
966 | CYForEach (i, internal_) { |
967 | _assert(i->identifier_->next_ == i->identifier_); | |
968 | switch (i->kind_) { | |
969 | case CYIdentifierArgument: { | |
970 | _assert(!transparent_); | |
971 | } break; | |
972 | ||
973 | case CYIdentifierLexical: { | |
974 | if (!damaged_) { | |
975 | CYIdentifier *replace(context.Unique()); | |
976 | replace->next_ = replace; | |
977 | i->identifier_->next_ = replace; | |
978 | i->identifier_ = replace; | |
979 | } | |
980 | ||
981 | if (!transparent_) | |
982 | i->kind_ = CYIdentifierVariable; | |
983 | else | |
984 | parent_->Declare(context, i->identifier_, CYIdentifierVariable); | |
985 | } break; | |
2c81c6df | 986 | |
7085e1ab JF |
987 | case CYIdentifierVariable: { |
988 | if (transparent_) { | |
989 | parent_->Declare(context, i->identifier_, i->kind_); | |
990 | i->kind_ = CYIdentifierGlobal; | |
991 | } | |
992 | } break; | |
993 | default:; } } | |
14ec9e00 | 994 | |
7085e1ab JF |
995 | if (damaged_) |
996 | return; | |
6a981250 | 997 | |
7085e1ab JF |
998 | typedef std::multimap<unsigned, CYIdentifier *> CYIdentifierOffsetMap; |
999 | CYIdentifierOffsetMap offsets; | |
10711823 | 1000 | |
7085e1ab JF |
1001 | CYForEach (i, internal_) { |
1002 | _assert(i->identifier_->next_ == i->identifier_); | |
1003 | switch (i->kind_) { | |
1004 | case CYIdentifierArgument: | |
1005 | case CYIdentifierVariable: | |
1006 | offsets.insert(CYIdentifierOffsetMap::value_type(i->offset_, i->identifier_)); | |
1007 | break; | |
1008 | default:; } } | |
10711823 | 1009 | |
7085e1ab | 1010 | unsigned offset(0); |
029bc65b | 1011 | |
7085e1ab JF |
1012 | for (CYIdentifierOffsetMap::const_iterator i(offsets.begin()); i != offsets.end(); ++i) { |
1013 | if (offset < i->first) | |
1014 | offset = i->first; | |
1015 | CYIdentifier *identifier(i->second); | |
10711823 | 1016 | |
7085e1ab JF |
1017 | if (offset >= context.replace_.size()) |
1018 | context.replace_.resize(offset + 1, NULL); | |
1019 | CYIdentifier *&replace(context.replace_[offset++]); | |
6a981250 | 1020 | |
7085e1ab JF |
1021 | if (replace == NULL) |
1022 | replace = identifier; | |
1023 | else { | |
1024 | _assert(replace->next_ == replace); | |
1025 | identifier->next_ = replace; | |
1026 | } | |
029bc65b JF |
1027 | } |
1028 | ||
7085e1ab JF |
1029 | if (parent_ == NULL) |
1030 | return; | |
1031 | ||
1032 | CYForEach (i, internal_) { | |
1033 | switch (i->kind_) { | |
1034 | case CYIdentifierGlobal: { | |
1035 | if (i->offset_ < offset) | |
1036 | i->offset_ = offset; | |
1037 | parent_->Merge(context, i); | |
1038 | } break; | |
1039 | default:; } } | |
029bc65b JF |
1040 | } |
1041 | ||
fc8fc33d JF |
1042 | CYElementValue *CYSpan::Replace(CYContext &context) { $T(NULL) |
1043 | return $ CYElementValue(expression_, $ CYElementValue(string_, next_->Replace(context))); | |
b900e1a4 JF |
1044 | } |
1045 | ||
12e37ba3 JF |
1046 | CYStatement *CYStatement::Return() { |
1047 | return this; | |
1048 | } | |
1049 | ||
4644480a JF |
1050 | CYString *CYString::Concat(CYContext &context, CYString *rhs) const { |
1051 | size_t size(size_ + rhs->size_); | |
2eb8215d | 1052 | char *value($ char[size + 1]); |
4644480a JF |
1053 | memcpy(value, value_, size_); |
1054 | memcpy(value + size_, rhs->value_, rhs->size_); | |
1055 | value[size] = '\0'; | |
a14eb702 | 1056 | return $S(value, size); |
4644480a JF |
1057 | } |
1058 | ||
1059 | CYNumber *CYString::Number(CYContext &context) { | |
1060 | // XXX: there is a precise algorithm for this | |
1061 | return NULL; | |
1062 | } | |
1063 | ||
c5b15840 JF |
1064 | CYExpression *CYString::PropertyName(CYContext &context) { |
1065 | return this; | |
1066 | } | |
1067 | ||
4644480a JF |
1068 | CYString *CYString::String(CYContext &context) { |
1069 | return this; | |
1070 | } | |
1071 | ||
7085e1ab | 1072 | CYTarget *CYSuperAccess::Replace(CYContext &context) { |
c5b15840 JF |
1073 | return $C1($M($M($M($V(context.super_), $S("prototype")), property_), $S("bind")), $ CYThis()); |
1074 | } | |
1075 | ||
7085e1ab | 1076 | CYTarget *CYSuperCall::Replace(CYContext &context) { |
c5b15840 JF |
1077 | return $C($C1($M($V(context.super_), $S("bind")), $ CYThis()), arguments_); |
1078 | } | |
1079 | ||
3b52fd1a JF |
1080 | CYStatement *CYSwitch::Replace(CYContext &context) { |
1081 | context.Replace(value_); | |
1082 | clauses_->Replace(context); | |
029bc65b | 1083 | return this; |
3b52fd1a JF |
1084 | } |
1085 | ||
7085e1ab JF |
1086 | CYStatement *CYTarget::Initialize(CYContext &context, CYExpression *value) { |
1087 | if (value == NULL) | |
1088 | return NULL; | |
1089 | return $E($ CYAssign(this, value)); | |
1090 | } | |
1091 | ||
1092 | CYTarget *CYTemplate::Replace(CYContext &context) { | |
fc8fc33d | 1093 | return $C2($M($M($M($V("String"), $S("prototype")), $S("concat")), $S("apply")), $S(""), $ CYArray($ CYElementValue(string_, spans_->Replace(context)))); |
b900e1a4 JF |
1094 | } |
1095 | ||
7085e1ab | 1096 | CYTarget *CYThis::Replace(CYContext &context) { |
a0be43fc JF |
1097 | if (context.this_ != NULL) |
1098 | return $V(context.this_->Identifier(context)); | |
029bc65b | 1099 | return this; |
3b52fd1a JF |
1100 | } |
1101 | ||
37954781 JF |
1102 | namespace cy { |
1103 | namespace Syntax { | |
1104 | ||
1105 | CYStatement *Throw::Replace(CYContext &context) { | |
3b52fd1a | 1106 | context.Replace(value_); |
029bc65b | 1107 | return this; |
3b52fd1a JF |
1108 | } |
1109 | ||
37954781 JF |
1110 | } } |
1111 | ||
7085e1ab | 1112 | CYTarget *CYTrivial::Replace(CYContext &context) { |
029bc65b | 1113 | return this; |
3b52fd1a JF |
1114 | } |
1115 | ||
4644480a JF |
1116 | CYNumber *CYTrue::Number(CYContext &context) { |
1117 | return $D(1); | |
1118 | } | |
1119 | ||
1120 | CYString *CYTrue::String(CYContext &context) { | |
1121 | return $S("true"); | |
1122 | } | |
1123 | ||
37954781 JF |
1124 | namespace cy { |
1125 | namespace Syntax { | |
1126 | ||
1127 | CYStatement *Try::Replace(CYContext &context) { | |
7085e1ab | 1128 | CYScope scope(true, context); |
b0385401 | 1129 | context.ReplaceAll(code_); |
7085e1ab JF |
1130 | scope.Close(context); |
1131 | ||
3b52fd1a JF |
1132 | catch_->Replace(context); |
1133 | finally_->Replace(context); | |
029bc65b | 1134 | return this; |
3b52fd1a JF |
1135 | } |
1136 | ||
37954781 JF |
1137 | } } |
1138 | ||
7085e1ab | 1139 | CYTarget *CYTypeArrayOf::Replace_(CYContext &context, CYTarget *type) { |
9a39f705 | 1140 | return next_->Replace(context, $ CYCall($ CYDirectMember(type, $ CYString("arrayOf")), $ CYArgument(size_))); |
690cf1a8 JF |
1141 | } |
1142 | ||
7085e1ab | 1143 | CYTarget *CYTypeBlockWith::Replace_(CYContext &context, CYTarget *type) { |
3fe16be7 JF |
1144 | return next_->Replace(context, $ CYCall($ CYDirectMember(type, $ CYString("blockWith")), parameters_->Argument(context))); |
1145 | } | |
1146 | ||
7085e1ab | 1147 | CYTarget *CYTypeConstant::Replace_(CYContext &context, CYTarget *type) { |
9a39f705 | 1148 | return next_->Replace(context, $ CYCall($ CYDirectMember(type, $ CYString("constant")))); |
690cf1a8 JF |
1149 | } |
1150 | ||
60097023 | 1151 | CYStatement *CYTypeDefinition::Replace(CYContext &context) { |
64a505ff JF |
1152 | CYIdentifier *identifier(typed_->identifier_); |
1153 | typed_->identifier_ = NULL; | |
1154 | return $ CYLexical(false, $B1($B(identifier, $ CYTypeExpression(typed_)))); | |
60097023 JF |
1155 | } |
1156 | ||
7085e1ab | 1157 | CYTarget *CYTypeError::Replace(CYContext &context) { |
03db6a67 JF |
1158 | _assert(false); |
1159 | return NULL; | |
1160 | } | |
1161 | ||
64a505ff JF |
1162 | CYTarget *CYTypeExpression::Replace(CYContext &context) { |
1163 | return typed_->Replace(context); | |
1164 | } | |
1165 | ||
7085e1ab | 1166 | CYTarget *CYTypeModifier::Replace(CYContext &context, CYTarget *type) { $T(type) |
9a39f705 JF |
1167 | return Replace_(context, type); |
1168 | } | |
1169 | ||
7085e1ab | 1170 | CYTarget *CYTypeFunctionWith::Replace_(CYContext &context, CYTarget *type) { |
9a39f705 JF |
1171 | return next_->Replace(context, $ CYCall($ CYDirectMember(type, $ CYString("functionWith")), parameters_->Argument(context))); |
1172 | } | |
1173 | ||
7085e1ab | 1174 | CYTarget *CYTypeLong::Replace(CYContext &context) { |
3fe283c5 JF |
1175 | return $ CYCall($ CYDirectMember(specifier_->Replace(context), $ CYString("long"))); |
1176 | } | |
1177 | ||
7085e1ab | 1178 | CYTarget *CYTypePointerTo::Replace_(CYContext &context, CYTarget *type) { |
9a39f705 | 1179 | return next_->Replace(context, $ CYCall($ CYDirectMember(type, $ CYString("pointerTo")))); |
663c538f JF |
1180 | } |
1181 | ||
7085e1ab | 1182 | CYTarget *CYTypeShort::Replace(CYContext &context) { |
3fe283c5 JF |
1183 | return $ CYCall($ CYDirectMember(specifier_->Replace(context), $ CYString("short"))); |
1184 | } | |
1185 | ||
7085e1ab | 1186 | CYTarget *CYTypeSigned::Replace(CYContext &context) { |
3fe283c5 JF |
1187 | return $ CYCall($ CYDirectMember(specifier_->Replace(context), $ CYString("signed"))); |
1188 | } | |
1189 | ||
b3c38c5f JF |
1190 | CYTarget *CYTypeStruct::Replace(CYContext &context) { |
1191 | CYList<CYElementValue> types; | |
1192 | CYList<CYElementValue> names; | |
1193 | ||
1194 | CYForEach (field, fields_) { | |
1195 | CYTypedIdentifier *typed(field->typed_); | |
1196 | types->*$ CYElementValue(typed->Replace(context)); | |
1197 | ||
1198 | CYExpression *name; | |
1199 | if (typed->identifier_ == NULL) | |
1200 | name = NULL; | |
1201 | else | |
1202 | name = $S(typed->identifier_->Word()); | |
1203 | names->*$ CYElementValue(name); | |
1204 | } | |
1205 | ||
1206 | CYTarget *target($N2($V("Type"), $ CYArray(types), $ CYArray(names))); | |
1207 | if (name_ != NULL) | |
1208 | target = $C1($M(target, $S("withName")), $S(name_->Word())); | |
1209 | return target; | |
1210 | } | |
1211 | ||
7085e1ab | 1212 | CYTarget *CYTypeUnsigned::Replace(CYContext &context) { |
3fe283c5 JF |
1213 | return $ CYCall($ CYDirectMember(specifier_->Replace(context), $ CYString("unsigned"))); |
1214 | } | |
1215 | ||
7085e1ab | 1216 | CYTarget *CYTypeVariable::Replace(CYContext &context) { |
3fe283c5 JF |
1217 | return $V(name_); |
1218 | } | |
1219 | ||
7085e1ab | 1220 | CYTarget *CYTypeVoid::Replace(CYContext &context) { |
3fe283c5 JF |
1221 | return $N1($V("Type"), $ CYString("v")); |
1222 | } | |
1223 | ||
7085e1ab | 1224 | CYTarget *CYTypeVolatile::Replace_(CYContext &context, CYTarget *type) { |
9a39f705 | 1225 | return next_->Replace(context, $ CYCall($ CYDirectMember(type, $ CYString("volatile")))); |
690cf1a8 JF |
1226 | } |
1227 | ||
7085e1ab | 1228 | CYTarget *CYTypedIdentifier::Replace(CYContext &context) { |
3fe283c5 | 1229 | return modifier_->Replace(context, specifier_->Replace(context)); |
690cf1a8 JF |
1230 | } |
1231 | ||
00b4cb83 JF |
1232 | CYTypeFunctionWith *CYTypedIdentifier::Function() { |
1233 | CYTypeModifier **modifier(&modifier_); | |
1234 | if (*modifier == NULL) | |
1235 | return NULL; | |
1236 | while ((*modifier)->next_ != NULL) | |
1237 | modifier = &(*modifier)->next_; | |
1238 | CYTypeFunctionWith *function((*modifier)->Function()); | |
1239 | if (function == NULL) | |
1240 | return NULL; | |
1241 | *modifier = NULL; | |
1242 | return function; | |
1243 | } | |
1244 | ||
663c538f | 1245 | CYArgument *CYTypedParameter::Argument(CYContext &context) { $T(NULL) |
9a39f705 | 1246 | return $ CYArgument(typed_->Replace(context), next_->Argument(context)); |
663c538f JF |
1247 | } |
1248 | ||
690cf1a8 | 1249 | CYFunctionParameter *CYTypedParameter::Parameters(CYContext &context) { $T(NULL) |
09fc3efb | 1250 | return $ CYFunctionParameter($ CYBinding(typed_->identifier_ ?: context.Unique()), next_->Parameters(context)); |
690cf1a8 JF |
1251 | } |
1252 | ||
1253 | CYExpression *CYTypedParameter::TypeSignature(CYContext &context, CYExpression *prefix) { $T(prefix) | |
a2f3ecab | 1254 | return next_->TypeSignature(context, $ CYAdd(prefix, typed_->Replace(context))); |
690cf1a8 JF |
1255 | } |
1256 | ||
bfd79fae | 1257 | CYForInitializer *CYVar::Replace(CYContext &context) { |
09fc3efb | 1258 | if (CYExpression *expression = bindings_->Replace(context, CYIdentifierVariable)) |
b0385401 | 1259 | return $E(expression); |
fd5cdf97 | 1260 | return $ CYEmpty(); |
3b52fd1a JF |
1261 | } |
1262 | ||
7085e1ab JF |
1263 | CYTarget *CYVariable::Replace(CYContext &context) { |
1264 | name_ = name_->Replace(context, CYIdentifierGlobal); | |
029bc65b | 1265 | return this; |
3b52fd1a JF |
1266 | } |
1267 | ||
0afc9ba3 | 1268 | CYFunctionParameter *CYVariable::Parameter() const { |
09fc3efb | 1269 | return $ CYFunctionParameter($ CYBinding(name_)); |
0afc9ba3 JF |
1270 | } |
1271 | ||
3b52fd1a JF |
1272 | CYStatement *CYWhile::Replace(CYContext &context) { |
1273 | context.Replace(test_); | |
b0385401 | 1274 | context.ReplaceAll(code_); |
029bc65b | 1275 | return this; |
3b52fd1a JF |
1276 | } |
1277 | ||
1278 | CYStatement *CYWith::Replace(CYContext &context) { | |
1279 | context.Replace(scope_); | |
28ef79aa JF |
1280 | CYScope scope(true, context); |
1281 | scope.Damage(); | |
b0385401 | 1282 | context.ReplaceAll(code_); |
28ef79aa | 1283 | scope.Close(context); |
029bc65b | 1284 | return this; |
3b52fd1a JF |
1285 | } |
1286 | ||
c5b15840 JF |
1287 | CYExpression *CYWord::PropertyName(CYContext &context) { |
1288 | return $S(this); | |
3b52fd1a | 1289 | } |